Split DataExtractor into two classes.

[zturner]

Summary

The goal is to move DataBuffer, DataBufferLLVM, DataBufferHeap, DataExtractor, and DataEncoder from Core to Utility. All of this is a straightforward move except for DataExtractor, which has 3 methods which depend on the target and various debug info things.

The most sensible way I can come up with to do the split is to move those 3 functions into a subclass of DataExtractor, and update those callsites that use those 3 functions to use the new subclass.

After this change it should be a straightforward move to get the various DataBuffer and family classes into Utility.

[jingham]

Is it horrible of me to ask that we choose a name that is more descriptive than DataExtractorEx? That "Ex" extension to a class name is just such a punt, and I'd really rather not encourage it.

The subclass you made adds the ability to:

(a) Dump itself
(b) Extract some Dwarf EH Frame specific bits.

And (b) is only used in DwarfCallFrameInfo.cpp,

So it would be clearer to make a class that just does (a) and call it DataExtractorDumpable.

Then you could have a class override (like DataExtractorEH) local to DwarfCallFrameInfo.cpp that adds the GetGNUEHPointer. That latter seems awfully specific, and probably doesn't need to be sitting out in the general world. It certainly doesn't need to be riding along all the dumpable data extractors.

[jingham]

The EH stuff should definitely go in a specific subclass.

It also seems a shame to lose the capability to Dump DataExtractors in general. The only thing the exe_scope is used for in Dump (which is what is causing you problems) is to print instructions, and to do a more accurate job of printing non-native floats. It would be best to leave the Dump without these bits in the base data extractor, and return an error for the unsupported format kinds, and then add a Dump method that takes an exe_scope in the subclass (now DataExtractorTargetAware???)

[zturner]

I basically turned the two dump methods into free functions and moved the DWARF specific function into DWARFCallFrameInfo.cpp. I think this is much better than before, as we don't muck with the inheritance hierarchy at all (removes a lot of code churn), and the header is very appropriately named.

[labath]

I like the free-standing function approach a lot.

[jingham]

Yes, that is a good solution. It's still a little awkward that DataExtractors live in Utility and their dumper lives in Core. Especially as almost all the functionality of the dumper could live in Utility. If you were serious about using Utility separate from Core you would want to put the non-target parts of DumpDataExtractor into Core and assert if those are passed the unsupported flavors, and then have DumpDataExtractorTarget, with the instruction and fancy float bits. But maybe that's work for another day.

We name functions starting with a Capitol first letter, so these should be "Dump..." not "dump...". But other than that, this seems good.

lldb/trunk/include/lldb/Core/DataExtractor.h

 ///
 /// @see DataBuffer
 //----------------------------------------------------------------------
 class DataExtractor {
 public:
   //------------------------------------------------------------------
   /// @typedef DataExtractor::Type
   /// @brief Type enumerations used in the dump routines.
-  /// @see DataExtractor::Dump()
-  /// @see DataExtractor::DumpRawHexBytes()
   //------------------------------------------------------------------
   typedef enum {
     TypeUInt8,   ///< Format output as unsigned 8 bit integers
     TypeChar,    ///< Format output as characters
     TypeUInt16,  ///< Format output as unsigned 16 bit integers
     TypeUInt32,  ///< Format output as unsigned 32 bit integers
     TypeUInt64,  ///< Format output as unsigned 64 bit integers
     TypePointer, ///< Format output as pointers
     TypeULEB128, ///< Format output as ULEB128 numbers
     TypeSLEB128  ///< Format output as SLEB128 numbers
   } Type;
 
-  static void DumpHexBytes(Stream *s, const void *src, size_t src_len,
-                           uint32_t bytes_per_line,
-                           lldb::addr_t base_addr); // Pass LLDB_INVALID_ADDRESS
-                                                    // to not show address at
-                                                    // start of line
-
   //------------------------------------------------------------------
   /// Default constructor.
   ///
   /// Initialize all members to a default empty state.
   //------------------------------------------------------------------
   DataExtractor();
 
   //------------------------------------------------------------------
public:
 
   //------------------------------------------------------------------
   /// Destructor
   ///
   /// If this object contains a valid shared data reference, the
   /// reference count on the data will be decremented, and if zero,
   /// the data will be freed.
   //------------------------------------------------------------------
-  ~DataExtractor();
+  virtual ~DataExtractor();
+
+  uint32_t getTargetByteSize() const { return m_target_byte_size; }
 
   //------------------------------------------------------------------
   /// Clears the object state.
   ///
   /// Clears the object contents back to a default invalid state, and
   /// release any references to shared data that this object may
   /// contain.
   //------------------------------------------------------------------
public:
   ///     The offset at which dumping ended.
   //------------------------------------------------------------------
   lldb::offset_t PutToLog(Log *log, lldb::offset_t offset,
                           lldb::offset_t length, uint64_t base_addr,
                           uint32_t num_per_line, Type type,
                           const char *type_format = nullptr) const;
 
   //------------------------------------------------------------------
-  /// Dumps \a item_count objects into the stream \a s.
-  ///
-  /// Dumps \a item_count objects using \a item_format, each of which
-  /// are \a item_byte_size bytes long starting at offset \a offset
-  /// bytes into the contained data, into the stream \a s. \a
-  /// num_per_line objects will be dumped on each line before a new
-  /// line will be output. If \a base_addr is a valid address, then
-  /// each new line of output will be preceded by the address value
-  /// plus appropriate offset, and a colon and space. Bitfield values
-  /// can be dumped by calling this function multiple times with the
-  /// same start offset, format and size, yet differing \a
-  /// item_bit_size and \a item_bit_offset values.
-  ///
-  /// @param[in] s
-  ///     The stream to dump the output to. This value can not be nullptr.
-  ///
-  /// @param[in] offset
-  ///     The offset into the data at which to start dumping.
-  ///
-  /// @param[in] item_format
-  ///     The format to use when dumping each item.
-  ///
-  /// @param[in] item_byte_size
-  ///     The byte size of each item.
-  ///
-  /// @param[in] item_count
-  ///     The number of items to dump.
-  ///
-  /// @param[in] num_per_line
-  ///     The number of items to display on each line.
-  ///
-  /// @param[in] base_addr
-  ///     The base address that gets added to the offset displayed on
-  ///     each line if the value is valid. Is \a base_addr is
-  ///     LLDB_INVALID_ADDRESS then no address values will be prepended
-  ///     to any lines.
-  ///
-  /// @param[in] item_bit_size
-  ///     If the value to display is a bitfield, this value should
-  ///     be the number of bits that the bitfield item has within the
-  ///     item's byte size value. This function will need to be called
-  ///     multiple times with identical \a offset and \a item_byte_size
-  ///     values in order to display multiple bitfield values that
-  ///     exist within the same integer value. If the items being
-  ///     displayed are not bitfields, this value should be zero.
-  ///
-  /// @param[in] item_bit_offset
-  ///     If the value to display is a bitfield, this value should
-  ///     be the offset in bits, or shift right amount, that the
-  ///     bitfield item occupies within the item's byte size value.
-  ///     This function will need to be called multiple times with
-  ///     identical \a offset and \a item_byte_size values in order
-  ///     to display multiple bitfield values that exist within the
-  ///     same integer value. If the items being displayed are not
-  ///     bitfields, this value should be zero.
-  ///
-  /// @return
-  ///     The offset at which dumping ended.
-  //------------------------------------------------------------------
-  lldb::offset_t Dump(Stream *s, lldb::offset_t offset,
-                      lldb::Format item_format, size_t item_byte_size,
-                      size_t item_count, size_t num_per_line,
-                      uint64_t base_addr, uint32_t item_bit_size,
-                      uint32_t item_bit_offset,
-                      ExecutionContextScope *exe_scope = nullptr) const;
-
-  //------------------------------------------------------------------
   /// Dump a UUID value at \a offset.
   ///
   /// Dump a UUID starting at \a offset bytes into this object's data.
   /// If the stream \a s is nullptr, the output will be sent to Log().
   ///
   /// @param[in] s
   ///     The stream to dump the output to. If nullptr the output will
   ///     be dumped to Log().
public:
   //------------------------------------------------------------------
   float GetFloat(lldb::offset_t *offset_ptr) const;
 
   double GetDouble(lldb::offset_t *offset_ptr) const;
 
   long double GetLongDouble(lldb::offset_t *offset_ptr) const;
 
   //------------------------------------------------------------------
-  /// Extract a GNU encoded pointer value from \a *offset_ptr.
-  ///
-  /// @param[in,out] offset_ptr
-  ///     A pointer to an offset within the data that will be advanced
-  ///     by the appropriate number of bytes if the value is extracted
-  ///     correctly. If the offset is out of bounds or there are not
-  ///     enough bytes to extract this value, the offset will be left
-  ///     unmodified.
-  ///
-  /// @param[in] eh_ptr_enc
-  ///     The GNU pointer encoding type.
-  ///
-  /// @param[in] pc_rel_addr
-  ///     The PC relative address to use when the encoding is
-  ///     \c DW_GNU_EH_PE_pcrel.
-  ///
-  /// @param[in] text_addr
-  ///     The text (code) relative address to use when the encoding is
-  ///     \c DW_GNU_EH_PE_textrel.
-  ///
-  /// @param[in] data_addr
-  ///     The data relative address to use when the encoding is
-  ///     \c DW_GNU_EH_PE_datarel.
-  ///
-  /// @return
-  ///     The extracted GNU encoded pointer value.
-  //------------------------------------------------------------------
-  uint64_t GetGNUEHPointer(lldb::offset_t *offset_ptr, uint32_t eh_ptr_enc,
-                           lldb::addr_t pc_rel_addr, lldb::addr_t text_addr,
-                           lldb::addr_t data_addr);
-
-  //------------------------------------------------------------------
   /// Extract an integer of size \a byte_size from \a *offset_ptr.
   ///
   /// Extract a single integer value and update the offset pointed to
   /// by \a offset_ptr. The size of the extracted integer is specified
   /// by the \a byte_size argument. \a byte_size should have a value
   /// >= 1 and <= 4 since the return value is only 32 bits wide. Any
   /// \a byte_size values less than 1 or greater than 4 will result in
   /// nothing being extracted, and zero being returned.

lldb/trunk/include/lldb/Core/DumpDataExtractor.h

+//===-- DumpDataExtractor.h -------------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLDB_CORE_DUMPDATAEXTRACTOR_H
+#define LLDB_CORE_DUMPDATAEXTRACTOR_H
+
+#include "lldb/lldb-types.h"
+
+namespace lldb_private {
+class DataExtractor;
+class ExecutionContextScope;
+class Stream;
+
+//------------------------------------------------------------------
+/// Dumps \a item_count objects into the stream \a s.
+///
+/// Dumps \a item_count objects using \a item_format, each of which
+/// are \a item_byte_size bytes long starting at offset \a offset
+/// bytes into the contained data, into the stream \a s. \a
+/// num_per_line objects will be dumped on each line before a new
+/// line will be output. If \a base_addr is a valid address, then
+/// each new line of output will be preceded by the address value
+/// plus appropriate offset, and a colon and space. Bitfield values
+/// can be dumped by calling this function multiple times with the
+/// same start offset, format and size, yet differing \a
+/// item_bit_size and \a item_bit_offset values.
+///
+/// @param[in] s
+///     The stream to dump the output to. This value can not be nullptr.
+///
+/// @param[in] offset
+///     The offset into the data at which to start dumping.
+///
+/// @param[in] item_format
+///     The format to use when dumping each item.
+///
+/// @param[in] item_byte_size
+///     The byte size of each item.
+///
+/// @param[in] item_count
+///     The number of items to dump.
+///
+/// @param[in] num_per_line
+///     The number of items to display on each line.
+///
+/// @param[in] base_addr
+///     The base address that gets added to the offset displayed on
+///     each line if the value is valid. Is \a base_addr is
+///     LLDB_INVALID_ADDRESS then no address values will be prepended
+///     to any lines.
+///
+/// @param[in] item_bit_size
+///     If the value to display is a bitfield, this value should
+///     be the number of bits that the bitfield item has within the
+///     item's byte size value. This function will need to be called
+///     multiple times with identical \a offset and \a item_byte_size
+///     values in order to display multiple bitfield values that
+///     exist within the same integer value. If the items being
+///     displayed are not bitfields, this value should be zero.
+///
+/// @param[in] item_bit_offset
+///     If the value to display is a bitfield, this value should
+///     be the offset in bits, or shift right amount, that the
+///     bitfield item occupies within the item's byte size value.
+///     This function will need to be called multiple times with
+///     identical \a offset and \a item_byte_size values in order
+///     to display multiple bitfield values that exist within the
+///     same integer value. If the items being displayed are not
+///     bitfields, this value should be zero.
+///
+/// @return
+///     The offset at which dumping ended.
+//------------------------------------------------------------------
+lldb::offset_t
+DumpDataExtractor(const DataExtractor &DE, Stream *s, lldb::offset_t offset,
+                  lldb::Format item_format, size_t item_byte_size,
+                  size_t item_count, size_t num_per_line, uint64_t base_addr,
+                  uint32_t item_bit_size, uint32_t item_bit_offset,
+                  ExecutionContextScope *exe_scope = nullptr);
+}
+
+#endif

lldb/trunk/include/lldb/Symbol/CompilerType.h

 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/ClangForward.h"
 #include "lldb/lldb-private.h"
 
 namespace lldb_private {
 
+class DataExtractor;
+
 //----------------------------------------------------------------------
 // A class that can carry around a clang ASTContext and a opaque clang
 // QualType. A clang::QualType can be easily reconstructed from an
 // opaque clang type and often the ASTContext is needed when doing
 // various type related tasks, so this class allows both items to travel
 // in a single very lightweight class that can be used. There are many
 // static equivalents of the member functions that allow the ASTContext
 // and the opaque clang QualType to be specified for ease of use and

lldb/trunk/include/lldb/Symbol/DWARFCallFrameInfo.h

 //===-- DWARFCallFrameInfo.h ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef liblldb_DWARFCallFrameInfo_h_
 #define liblldb_DWARFCallFrameInfo_h_
 
 #include <map>
 #include <mutex>
 
 #include "lldb/Core/AddressRange.h"
-#include "lldb/Core/DataExtractor.h"
 #include "lldb/Utility/Flags.h"
 
 #include "lldb/Core/RangeMap.h"
 #include "lldb/Core/VMRange.h"
 #include "lldb/Core/dwarf.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/lldb-private.h"

lldb/trunk/include/lldb/Symbol/Type.h

 #include "lldb/Utility/ConstString.h"
 #include "lldb/lldb-private.h"
 
 #include "llvm/ADT/APSInt.h"
 
 #include <set>
 
 namespace lldb_private {
-
 //----------------------------------------------------------------------
 // CompilerContext allows an array of these items to be passed to
 // perform detailed lookups in SymbolVendor and SymbolFile functions.
 //----------------------------------------------------------------------
 struct CompilerContext {
   CompilerContext(CompilerContextKind t, const ConstString &n)
       : type(t), name(n) {}
 

lldb/trunk/source/API/SBData.cpp

 #include <inttypes.h> // PRIu64
 
 #include "lldb/API/SBData.h"
 #include "lldb/API/SBError.h"
 #include "lldb/API/SBStream.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
 SBData::SBData() : m_opaque_sp(new DataExtractor()) {}
 
const char *SBData::GetString(lldb::SBError &error, lldb::offset_t offset) {
   return value;
 }
 
 bool SBData::GetDescription(lldb::SBStream &description,
                             lldb::addr_t base_addr) {
   Stream &strm = description.ref();
 
   if (m_opaque_sp) {
-    m_opaque_sp->Dump(&strm, 0, lldb::eFormatBytesWithASCII, 1,
+    DumpDataExtractor(*m_opaque_sp, &strm, 0, lldb::eFormatBytesWithASCII, 1,
                       m_opaque_sp->GetByteSize(), 16, base_addr, 0, 0);
   } else
     strm.PutCString("No value");
 
   return true;
 }
 
 size_t SBData::ReadRawData(lldb::SBError &error, lldb::offset_t offset,

lldb/trunk/source/Commands/CommandObjectMemory.cpp

 // C++ Includes
 // Other libraries and framework includes
 #include "clang/AST/Decl.h"
 
 // Project includes
 #include "CommandObjectMemory.h"
 #include "Plugins/ExpressionParser/Clang/ClangPersistentVariables.h"
 #include "lldb/Core/DataBufferHeap.h"
-#include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Debugger.h"
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
if (((format == eFormatChar) || (format == eFormatCharPrintable)) &&
             "reading memory as characters of size %" PRIu64 " is not supported",
             (uint64_t)item_byte_size);
         result.SetStatus(eReturnStatusFailed);
         return false;
       }
     }
 
     assert(output_stream);
-    size_t bytes_dumped =
-        data.Dump(output_stream, 0, format, item_byte_size, item_count,
-                  num_per_line / target->GetArchitecture().GetDataByteSize(),
-                  addr, 0, 0, exe_scope);
+    size_t bytes_dumped = DumpDataExtractor(
+        data, output_stream, 0, format, item_byte_size, item_count,
+        num_per_line / target->GetArchitecture().GetDataByteSize(), addr, 0, 0,
+        exe_scope);
     m_next_addr = addr + bytes_dumped;
     output_stream->EOL();
     return true;
   }
 
   OptionGroupOptions m_option_group;
   OptionGroupFormat m_format_options;
   OptionGroupReadMemory m_memory_options;
while (count) {
       DataBufferHeap dumpbuffer(32, 0);
       process->ReadMemory(
           found_location + m_memory_options.m_offset.GetCurrentValue(),
           dumpbuffer.GetBytes(), dumpbuffer.GetByteSize(), error);
       if (!error.Fail()) {
         DataExtractor data(dumpbuffer.GetBytes(), dumpbuffer.GetByteSize(),
                            process->GetByteOrder(),
                            process->GetAddressByteSize());
-        data.Dump(&result.GetOutputStream(), 0, lldb::eFormatBytesWithASCII, 1,
-                  dumpbuffer.GetByteSize(), 16,
-                  found_location + m_memory_options.m_offset.GetCurrentValue(),
-                  0, 0);
+        DumpDataExtractor(
+            data, &result.GetOutputStream(), 0, lldb::eFormatBytesWithASCII, 1,
+            found_location + m_memory_options.m_offset.GetCurrentValue(), 0, 0);
         result.GetOutputStream().EOL();
       }
 
       --count;
       found_location++;
       ever_found = true;
     }
 

lldb/trunk/source/Core/Address.cpp

 #include "lldb/Core/Address.h"
 
 // C Includes
 // C++ Includes
 #include "llvm/ADT/Triple.h"
 
 // Other libraries and framework includes
 // Project includes
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
 #include "lldb/Symbol/Block.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolVendor.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Symbol/VariableList.h"
 #include "lldb/Target/ExecutionContext.h"
static bool DumpUInt(ExecutionContextScope *exe_scope, const Address &address,
   std::vector<uint8_t> buf(byte_size, 0);
 
   if (ReadBytes(exe_scope, address, &buf[0], buf.size()) == buf.size()) {
     ByteOrder byte_order = eByteOrderInvalid;
     uint32_t addr_size = 0;
     if (GetByteOrderAndAddressSize(exe_scope, address, byte_order, addr_size)) {
       DataExtractor data(&buf.front(), buf.size(), byte_order, addr_size);
 
-      data.Dump(strm,
+      DumpDataExtractor(data, strm,
                         0,                    // Start offset in "data"
                         eFormatHex,           // Print as characters
                         buf.size(),           // Size of item
                         1,                    // Items count
                         UINT32_MAX,           // num per line
                         LLDB_INVALID_ADDRESS, // base address
                         0,                    // bitfield bit size
                         0);                   // bitfield bit offset
 
       return true;
     }
   }
   return false;
 }
 
 static size_t ReadCStringFromMemory(ExecutionContextScope *exe_scope,
static size_t ReadCStringFromMemory(ExecutionContextScope *exe_scope,
   while ((bytes_read = ReadBytes(exe_scope, curr_address, buf, k_buf_len)) >
          0) {
     size_t len = strlen(buf);
     if (len == 0)
       break;
     if (len > bytes_read)
       len = bytes_read;
 
-    data.Dump(strm,
+    DumpDataExtractor(data, strm,
                       0,                    // Start offset in "data"
                       eFormatChar,          // Print as characters
                       1,                    // Size of item (1 byte for a char!)
                       len,                  // How many bytes to print?
                       UINT32_MAX,           // num per line
                       LLDB_INVALID_ADDRESS, // base address
                       0,                    // bitfield bit size
 
                       0); // bitfield bit offset
 
     total_len += bytes_read;
 
     if (len < k_buf_len)
       break;
     curr_address.SetOffset(curr_address.GetOffset() + bytes_read);
   }
   strm->PutChar('"');

lldb/trunk/source/Core/CMakeLists.txt

add_lldb_library(lldbCore
   Communication.cpp
   Connection.cpp
   DataBufferHeap.cpp
   DataBufferLLVM.cpp
   DataEncoder.cpp
   DataExtractor.cpp
   Debugger.cpp
   Disassembler.cpp
+  DumpDataExtractor.cpp
   DynamicLoader.cpp
   EmulateInstruction.cpp
   Event.cpp
   FastDemangle.cpp
   FileLineResolver.cpp
   FileSpecList.cpp
   FormatEntity.cpp
   History.cpp

lldb/trunk/source/Core/DataExtractor.cpp

 //===-- DataExtractor.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
-#include <bitset>
 #include <cassert>
 #include <cmath>
 #include <cstddef>
-#include <sstream>
 #include <string>
 
 // Other libraries and framework includes
-#include "llvm/ADT/APFloat.h"
-#include "llvm/ADT/APInt.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/MD5.h"
 #include "llvm/Support/MathExtras.h"
 
-#include "clang/AST/ASTContext.h"
-
 // Project includes
 #include "lldb/Core/DataBuffer.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
-#include "lldb/Core/Disassembler.h"
 #include "lldb/Core/UUID.h"
-#include "lldb/Core/dwarf.h"
-#include "lldb/Symbol/ClangASTContext.h"
-#include "lldb/Target/ExecutionContext.h"
-#include "lldb/Target/ExecutionContextScope.h"
-#include "lldb/Target/SectionLoadList.h"
-#include "lldb/Target/Target.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
 using namespace lldb_private;
 

 }
 
 static inline uint64_t ReadSwapInt64(const void *ptr) {
   uint64_t value;
   memcpy(&value, ptr, 8);
   return llvm::ByteSwap_64(value);
 }
 
-#define NON_PRINTABLE_CHAR '.'
-
 DataExtractor::DataExtractor()
     : m_start(nullptr), m_end(nullptr),
       m_byte_order(endian::InlHostByteOrder()), m_addr_size(sizeof(void *)),
       m_data_sp(), m_target_byte_size(1) {}
 
 //----------------------------------------------------------------------
 // This constructor allows us to use data that is owned by someone else.
 // The data must stay around as long as this object is valid.

 //------------------------------------------------------------------
 uint64_t DataExtractor::GetPointer(offset_t *offset_ptr) const {
 #ifdef LLDB_CONFIGURATION_DEBUG
   assert(m_addr_size == 4 || m_addr_size == 8);
 #endif
   return GetMaxU64(offset_ptr, m_addr_size);
 }
 
-//----------------------------------------------------------------------
-// GetDwarfEHPtr
-//
-// Used for calls when the value type is specified by a DWARF EH Frame
-// pointer encoding.
-//----------------------------------------------------------------------
-
-uint64_t DataExtractor::GetGNUEHPointer(
-    offset_t *offset_ptr, uint32_t eh_ptr_enc, lldb::addr_t pc_rel_addr,
-    lldb::addr_t text_addr,
-    lldb::addr_t data_addr) //, BSDRelocs *data_relocs) const
-{
-  if (eh_ptr_enc == DW_EH_PE_omit)
-    return ULLONG_MAX; // Value isn't in the buffer...
-
-  uint64_t baseAddress = 0;
-  uint64_t addressValue = 0;
-  const uint32_t addr_size = GetAddressByteSize();
-#ifdef LLDB_CONFIGURATION_DEBUG
-  assert(addr_size == 4 || addr_size == 8);
-#endif
-
-  bool signExtendValue = false;
-  // Decode the base part or adjust our offset
-  switch (eh_ptr_enc & 0x70) {
-  case DW_EH_PE_pcrel:
-    signExtendValue = true;
-    baseAddress = *offset_ptr;
-    if (pc_rel_addr != LLDB_INVALID_ADDRESS)
-      baseAddress += pc_rel_addr;
-    //      else
-    //          Log::GlobalWarning ("PC relative pointer encoding found with
-    //          invalid pc relative address.");
-    break;
-
-  case DW_EH_PE_textrel:
-    signExtendValue = true;
-    if (text_addr != LLDB_INVALID_ADDRESS)
-      baseAddress = text_addr;
-    //      else
-    //          Log::GlobalWarning ("text relative pointer encoding being
-    //          decoded with invalid text section address, setting base address
-    //          to zero.");
-    break;
-
-  case DW_EH_PE_datarel:
-    signExtendValue = true;
-    if (data_addr != LLDB_INVALID_ADDRESS)
-      baseAddress = data_addr;
-    //      else
-    //          Log::GlobalWarning ("data relative pointer encoding being
-    //          decoded with invalid data section address, setting base address
-    //          to zero.");
-    break;
-
-  case DW_EH_PE_funcrel:
-    signExtendValue = true;
-    break;
-
-  case DW_EH_PE_aligned: {
-    // SetPointerSize should be called prior to extracting these so the
-    // pointer size is cached
-    assert(addr_size != 0);
-    if (addr_size) {
-      // Align to a address size boundary first
-      uint32_t alignOffset = *offset_ptr % addr_size;
-      if (alignOffset)
-        offset_ptr += addr_size - alignOffset;
-    }
-  } break;
-
-  default:
-    break;
-  }
-
-  // Decode the value part
-  switch (eh_ptr_enc & DW_EH_PE_MASK_ENCODING) {
-  case DW_EH_PE_absptr: {
-    addressValue = GetAddress(offset_ptr);
-    //          if (data_relocs)
-    //              addressValue = data_relocs->Relocate(*offset_ptr -
-    //              addr_size, *this, addressValue);
-  } break;
-  case DW_EH_PE_uleb128:
-    addressValue = GetULEB128(offset_ptr);
-    break;
-  case DW_EH_PE_udata2:
-    addressValue = GetU16(offset_ptr);
-    break;
-  case DW_EH_PE_udata4:
-    addressValue = GetU32(offset_ptr);
-    break;
-  case DW_EH_PE_udata8:
-    addressValue = GetU64(offset_ptr);
-    break;
-  case DW_EH_PE_sleb128:
-    addressValue = GetSLEB128(offset_ptr);
-    break;
-  case DW_EH_PE_sdata2:
-    addressValue = (int16_t)GetU16(offset_ptr);
-    break;
-  case DW_EH_PE_sdata4:
-    addressValue = (int32_t)GetU32(offset_ptr);
-    break;
-  case DW_EH_PE_sdata8:
-    addressValue = (int64_t)GetU64(offset_ptr);
-    break;
-  default:
-    // Unhandled encoding type
-    assert(eh_ptr_enc);
-    break;
-  }
-
-  // Since we promote everything to 64 bit, we may need to sign extend
-  if (signExtendValue && addr_size < sizeof(baseAddress)) {
-    uint64_t sign_bit = 1ull << ((addr_size * 8ull) - 1ull);
-    if (sign_bit & addressValue) {
-      uint64_t mask = ~sign_bit + 1;
-      addressValue |= mask;
-    }
-  }
-  return baseAddress + addressValue;
-}
 
 size_t DataExtractor::ExtractBytes(offset_t offset, offset_t length,
                                    ByteOrder dst_byte_order, void *dst) const {
   const uint8_t *src = PeekData(offset, length);
   if (src) {
     if (dst_byte_order != GetByteOrder()) {
       // Validate that only a word- or register-sized dst is byte swapped
       assert(length == 1 || length == 2 || length == 4 || length == 8 ||
if (src < end) {
     const uint8_t *src_pos = src;
     while ((src_pos < end) && (*src_pos++ & 0x80))
       ++bytes_consumed;
     *offset_ptr += src_pos - src;
   }
   return bytes_consumed;
 }
 
-static bool GetAPInt(const DataExtractor &data, lldb::offset_t *offset_ptr,
-                     lldb::offset_t byte_size, llvm::APInt &result) {
-  llvm::SmallVector<uint64_t, 2> uint64_array;
-  lldb::offset_t bytes_left = byte_size;
-  uint64_t u64;
-  const lldb::ByteOrder byte_order = data.GetByteOrder();
-  if (byte_order == lldb::eByteOrderLittle) {
-    while (bytes_left > 0) {
-      if (bytes_left >= 8) {
-        u64 = data.GetU64(offset_ptr);
-        bytes_left -= 8;
-      } else {
-        u64 = data.GetMaxU64(offset_ptr, (uint32_t)bytes_left);
-        bytes_left = 0;
-      }
-      uint64_array.push_back(u64);
-    }
-    result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array));
-    return true;
-  } else if (byte_order == lldb::eByteOrderBig) {
-    lldb::offset_t be_offset = *offset_ptr + byte_size;
-    lldb::offset_t temp_offset;
-    while (bytes_left > 0) {
-      if (bytes_left >= 8) {
-        be_offset -= 8;
-        temp_offset = be_offset;
-        u64 = data.GetU64(&temp_offset);
-        bytes_left -= 8;
-      } else {
-        be_offset -= bytes_left;
-        temp_offset = be_offset;
-        u64 = data.GetMaxU64(&temp_offset, (uint32_t)bytes_left);
-        bytes_left = 0;
-      }
-      uint64_array.push_back(u64);
-    }
-    *offset_ptr += byte_size;
-    result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array));
-    return true;
-  }
-  return false;
-}
-
-static lldb::offset_t DumpAPInt(Stream *s, const DataExtractor &data,
-                                lldb::offset_t offset, lldb::offset_t byte_size,
-                                bool is_signed, unsigned radix) {
-  llvm::APInt apint;
-  if (GetAPInt(data, &offset, byte_size, apint)) {
-    std::string apint_str(apint.toString(radix, is_signed));
-    switch (radix) {
-    case 2:
-      s->Write("0b", 2);
-      break;
-    case 8:
-      s->Write("0", 1);
-      break;
-    case 10:
-      break;
-    }
-    s->Write(apint_str.c_str(), apint_str.size());
-  }
-  return offset;
-}
-
-static float half2float(uint16_t half) {
-  union {
-    float f;
-    uint32_t u;
-  } u;
-  int32_t v = (int16_t)half;
-
-  if (0 == (v & 0x7c00)) {
-    u.u = v & 0x80007FFFU;
-    return u.f * ldexpf(1, 125);
-  }
-
-  v <<= 13;
-  u.u = v | 0x70000000U;
-  return u.f * ldexpf(1, -112);
-}
-
-lldb::offset_t DataExtractor::Dump(
-    Stream *s, offset_t start_offset, lldb::Format item_format,
-    size_t item_byte_size, size_t item_count, size_t num_per_line,
-    uint64_t base_addr,
-    uint32_t item_bit_size,   // If zero, this is not a bitfield value, if
-                              // non-zero, the value is a bitfield
-    uint32_t item_bit_offset, // If "item_bit_size" is non-zero, this is the
-                              // shift amount to apply to a bitfield
-    ExecutionContextScope *exe_scope) const {
-  if (s == nullptr)
-    return start_offset;
-
-  if (item_format == eFormatPointer) {
-    if (item_byte_size != 4 && item_byte_size != 8)
-      item_byte_size = s->GetAddressByteSize();
-  }
-
-  offset_t offset = start_offset;
-
-  if (item_format == eFormatInstruction) {
-    TargetSP target_sp;
-    if (exe_scope)
-      target_sp = exe_scope->CalculateTarget();
-    if (target_sp) {
-      DisassemblerSP disassembler_sp(Disassembler::FindPlugin(
-          target_sp->GetArchitecture(), nullptr, nullptr));
-      if (disassembler_sp) {
-        lldb::addr_t addr = base_addr + start_offset;
-        lldb_private::Address so_addr;
-        bool data_from_file = true;
-        if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr, so_addr)) {
-          data_from_file = false;
-        } else {
-          if (target_sp->GetSectionLoadList().IsEmpty() ||
-              !target_sp->GetImages().ResolveFileAddress(addr, so_addr))
-            so_addr.SetRawAddress(addr);
-        }
-
-        size_t bytes_consumed = disassembler_sp->DecodeInstructions(
-            so_addr, *this, start_offset, item_count, false, data_from_file);
-
-        if (bytes_consumed) {
-          offset += bytes_consumed;
-          const bool show_address = base_addr != LLDB_INVALID_ADDRESS;
-          const bool show_bytes = true;
-          ExecutionContext exe_ctx;
-          exe_scope->CalculateExecutionContext(exe_ctx);
-          disassembler_sp->GetInstructionList().Dump(s, show_address,
-                                                     show_bytes, &exe_ctx);
-        }
-      }
-    } else
-      s->Printf("invalid target");
-
-    return offset;
-  }
-
-  if ((item_format == eFormatOSType || item_format == eFormatAddressInfo) &&
-      item_byte_size > 8)
-    item_format = eFormatHex;
-
-  lldb::offset_t line_start_offset = start_offset;
-  for (uint32_t count = 0; ValidOffset(offset) && count < item_count; ++count) {
-    if ((count % num_per_line) == 0) {
-      if (count > 0) {
-        if (item_format == eFormatBytesWithASCII &&
-            offset > line_start_offset) {
-          s->Printf("%*s",
-                    static_cast<int>(
-                        (num_per_line - (offset - line_start_offset)) * 3 + 2),
-                    "");
-          Dump(s, line_start_offset, eFormatCharPrintable, 1,
-               offset - line_start_offset, SIZE_MAX, LLDB_INVALID_ADDRESS, 0,
-               0);
-        }
-        s->EOL();
-      }
-      if (base_addr != LLDB_INVALID_ADDRESS)
-        s->Printf("0x%8.8" PRIx64 ": ",
-                  (uint64_t)(base_addr +
-                             (offset - start_offset) / m_target_byte_size));
-
-      line_start_offset = offset;
-    } else if (item_format != eFormatChar &&
-               item_format != eFormatCharPrintable &&
-               item_format != eFormatCharArray && count > 0) {
-      s->PutChar(' ');
-    }
-
-    switch (item_format) {
-    case eFormatBoolean:
-      if (item_byte_size <= 8)
-        s->Printf("%s", GetMaxU64Bitfield(&offset, item_byte_size,
-                                          item_bit_size, item_bit_offset)
-                            ? "true"
-                            : "false");
-      else {
-        s->Printf("error: unsupported byte size (%" PRIu64
-                  ") for boolean format",
-                  (uint64_t)item_byte_size);
-        return offset;
-      }
-      break;
-
-    case eFormatBinary:
-      if (item_byte_size <= 8) {
-        uint64_t uval64 = GetMaxU64Bitfield(&offset, item_byte_size,
-                                            item_bit_size, item_bit_offset);
-        // Avoid std::bitset<64>::to_string() since it is missing in
-        // earlier C++ libraries
-        std::string binary_value(64, '0');
-        std::bitset<64> bits(uval64);
-        for (uint32_t i = 0; i < 64; ++i)
-          if (bits[i])
-            binary_value[64 - 1 - i] = '1';
-        if (item_bit_size > 0)
-          s->Printf("0b%s", binary_value.c_str() + 64 - item_bit_size);
-        else if (item_byte_size > 0 && item_byte_size <= 8)
-          s->Printf("0b%s", binary_value.c_str() + 64 - item_byte_size * 8);
-      } else {
-        const bool is_signed = false;
-        const unsigned radix = 2;
-        offset = DumpAPInt(s, *this, offset, item_byte_size, is_signed, radix);
-      }
-      break;
-
-    case eFormatBytes:
-    case eFormatBytesWithASCII:
-      for (uint32_t i = 0; i < item_byte_size; ++i) {
-        s->Printf("%2.2x", GetU8(&offset));
-      }
-
-      // Put an extra space between the groups of bytes if more than one
-      // is being dumped in a group (item_byte_size is more than 1).
-      if (item_byte_size > 1)
-        s->PutChar(' ');
-      break;
-
-    case eFormatChar:
-    case eFormatCharPrintable:
-    case eFormatCharArray: {
-      // If we are only printing one character surround it with single
-      // quotes
-      if (item_count == 1 && item_format == eFormatChar)
-        s->PutChar('\'');
-
-      const uint64_t ch = GetMaxU64Bitfield(&offset, item_byte_size,
-                                            item_bit_size, item_bit_offset);
-      if (isprint(ch))
-        s->Printf("%c", (char)ch);
-      else if (item_format != eFormatCharPrintable) {
-        switch (ch) {
-        case '\033':
-          s->Printf("\\e");
-          break;
-        case '\a':
-          s->Printf("\\a");
-          break;
-        case '\b':
-          s->Printf("\\b");
-          break;
-        case '\f':
-          s->Printf("\\f");
-          break;
-        case '\n':
-          s->Printf("\\n");
-          break;
-        case '\r':
-          s->Printf("\\r");
-          break;
-        case '\t':
-          s->Printf("\\t");
-          break;
-        case '\v':
-          s->Printf("\\v");
-          break;
-        case '\0':
-          s->Printf("\\0");
-          break;
-        default:
-          if (item_byte_size == 1)
-            s->Printf("\\x%2.2x", (uint8_t)ch);
-          else
-            s->Printf("%" PRIu64, ch);
-          break;
-        }
-      } else {
-        s->PutChar(NON_PRINTABLE_CHAR);
-      }
-
-      // If we are only printing one character surround it with single quotes
-      if (item_count == 1 && item_format == eFormatChar)
-        s->PutChar('\'');
-    } break;
-
-    case eFormatEnum: // Print enum value as a signed integer when we don't get
-                      // the enum type
-    case eFormatDecimal:
-      if (item_byte_size <= 8)
-        s->Printf("%" PRId64,
-                  GetMaxS64Bitfield(&offset, item_byte_size, item_bit_size,
-                                    item_bit_offset));
-      else {
-        const bool is_signed = true;
-        const unsigned radix = 10;
-        offset = DumpAPInt(s, *this, offset, item_byte_size, is_signed, radix);
-      }
-      break;
-
-    case eFormatUnsigned:
-      if (item_byte_size <= 8)
-        s->Printf("%" PRIu64,
-                  GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
-                                    item_bit_offset));
-      else {
-        const bool is_signed = false;
-        const unsigned radix = 10;
-        offset = DumpAPInt(s, *this, offset, item_byte_size, is_signed, radix);
-      }
-      break;
-
-    case eFormatOctal:
-      if (item_byte_size <= 8)
-        s->Printf("0%" PRIo64,
-                  GetMaxS64Bitfield(&offset, item_byte_size, item_bit_size,
-                                    item_bit_offset));
-      else {
-        const bool is_signed = false;
-        const unsigned radix = 8;
-        offset = DumpAPInt(s, *this, offset, item_byte_size, is_signed, radix);
-      }
-      break;
-
-    case eFormatOSType: {
-      uint64_t uval64 = GetMaxU64Bitfield(&offset, item_byte_size,
-                                          item_bit_size, item_bit_offset);
-      s->PutChar('\'');
-      for (uint32_t i = 0; i < item_byte_size; ++i) {
-        uint8_t ch = (uint8_t)(uval64 >> ((item_byte_size - i - 1) * 8));
-        if (isprint(ch))
-          s->Printf("%c", ch);
-        else {
-          switch (ch) {
-          case '\033':
-            s->Printf("\\e");
-            break;
-          case '\a':
-            s->Printf("\\a");
-            break;
-          case '\b':
-            s->Printf("\\b");
-            break;
-          case '\f':
-            s->Printf("\\f");
-            break;
-          case '\n':
-            s->Printf("\\n");
-            break;
-          case '\r':
-            s->Printf("\\r");
-            break;
-          case '\t':
-            s->Printf("\\t");
-            break;
-          case '\v':
-            s->Printf("\\v");
-            break;
-          case '\0':
-            s->Printf("\\0");
-            break;
-          default:
-            s->Printf("\\x%2.2x", ch);
-            break;
-          }
-        }
-      }
-      s->PutChar('\'');
-    } break;
-
-    case eFormatCString: {
-      const char *cstr = GetCStr(&offset);
-
-      if (!cstr) {
-        s->Printf("NULL");
-        offset = LLDB_INVALID_OFFSET;
-      } else {
-        s->PutChar('\"');
-
-        while (const char c = *cstr) {
-          if (isprint(c)) {
-            s->PutChar(c);
-          } else {
-            switch (c) {
-            case '\033':
-              s->Printf("\\e");
-              break;
-            case '\a':
-              s->Printf("\\a");
-              break;
-            case '\b':
-              s->Printf("\\b");
-              break;
-            case '\f':
-              s->Printf("\\f");
-              break;
-            case '\n':
-              s->Printf("\\n");
-              break;
-            case '\r':
-              s->Printf("\\r");
-              break;
-            case '\t':
-              s->Printf("\\t");
-              break;
-            case '\v':
-              s->Printf("\\v");
-              break;
-            default:
-              s->Printf("\\x%2.2x", c);
-              break;
-            }
-          }
-
-          ++cstr;
-        }
-
-        s->PutChar('\"');
-      }
-    } break;
-
-    case eFormatPointer:
-      s->Address(GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
-                                   item_bit_offset),
-                 sizeof(addr_t));
-      break;
-
-    case eFormatComplexInteger: {
-      size_t complex_int_byte_size = item_byte_size / 2;
-
-      if (complex_int_byte_size > 0 && complex_int_byte_size <= 8) {
-        s->Printf("%" PRIu64,
-                  GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0));
-        s->Printf(" + %" PRIu64 "i",
-                  GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0));
-      } else {
-        s->Printf("error: unsupported byte size (%" PRIu64
-                  ") for complex integer format",
-                  (uint64_t)item_byte_size);
-        return offset;
-      }
-    } break;
-
-    case eFormatComplex:
-      if (sizeof(float) * 2 == item_byte_size) {
-        float f32_1 = GetFloat(&offset);
-        float f32_2 = GetFloat(&offset);
-
-        s->Printf("%g + %gi", f32_1, f32_2);
-        break;
-      } else if (sizeof(double) * 2 == item_byte_size) {
-        double d64_1 = GetDouble(&offset);
-        double d64_2 = GetDouble(&offset);
-
-        s->Printf("%lg + %lgi", d64_1, d64_2);
-        break;
-      } else if (sizeof(long double) * 2 == item_byte_size) {
-        long double ld64_1 = GetLongDouble(&offset);
-        long double ld64_2 = GetLongDouble(&offset);
-        s->Printf("%Lg + %Lgi", ld64_1, ld64_2);
-        break;
-      } else {
-        s->Printf("error: unsupported byte size (%" PRIu64
-                  ") for complex float format",
-                  (uint64_t)item_byte_size);
-        return offset;
-      }
-      break;
-
-    default:
-    case eFormatDefault:
-    case eFormatHex:
-    case eFormatHexUppercase: {
-      bool wantsuppercase = (item_format == eFormatHexUppercase);
-      switch (item_byte_size) {
-      case 1:
-      case 2:
-      case 4:
-      case 8:
-        s->Printf(wantsuppercase ? "0x%*.*" PRIX64 : "0x%*.*" PRIx64,
-                  (int)(2 * item_byte_size), (int)(2 * item_byte_size),
-                  GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
-                                    item_bit_offset));
-        break;
-      default: {
-        assert(item_bit_size == 0 && item_bit_offset == 0);
-        const uint8_t *bytes =
-            (const uint8_t *)GetData(&offset, item_byte_size);
-        if (bytes) {
-          s->PutCString("0x");
-          uint32_t idx;
-          if (m_byte_order == eByteOrderBig) {
-            for (idx = 0; idx < item_byte_size; ++idx)
-              s->Printf(wantsuppercase ? "%2.2X" : "%2.2x", bytes[idx]);
-          } else {
-            for (idx = 0; idx < item_byte_size; ++idx)
-              s->Printf(wantsuppercase ? "%2.2X" : "%2.2x",
-                        bytes[item_byte_size - 1 - idx]);
-          }
-        }
-      } break;
-      }
-    } break;
-
-    case eFormatFloat: {
-      TargetSP target_sp;
-      bool used_apfloat = false;
-      if (exe_scope)
-        target_sp = exe_scope->CalculateTarget();
-      if (target_sp) {
-        ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
-        if (clang_ast) {
-          clang::ASTContext *ast = clang_ast->getASTContext();
-          if (ast) {
-            llvm::SmallVector<char, 256> sv;
-            // Show full precision when printing float values
-            const unsigned format_precision = 0;
-            const unsigned format_max_padding = 100;
-            size_t item_bit_size = item_byte_size * 8;
-
-            if (item_bit_size == ast->getTypeSize(ast->FloatTy)) {
-              llvm::APInt apint(item_bit_size,
-                                this->GetMaxU64(&offset, item_byte_size));
-              llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->FloatTy),
-                                    apint);
-              apfloat.toString(sv, format_precision, format_max_padding);
-            } else if (item_bit_size == ast->getTypeSize(ast->DoubleTy)) {
-              llvm::APInt apint;
-              if (GetAPInt(*this, &offset, item_byte_size, apint)) {
-                llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->DoubleTy),
-                                      apint);
-                apfloat.toString(sv, format_precision, format_max_padding);
-              }
-            } else if (item_bit_size == ast->getTypeSize(ast->LongDoubleTy)) {
-              const auto &semantics =
-                  ast->getFloatTypeSemantics(ast->LongDoubleTy);
-              const auto byte_size =
-                  (llvm::APFloat::getSizeInBits(semantics) + 7) / 8;
-
-              llvm::APInt apint;
-              if (GetAPInt(*this, &offset, byte_size, apint)) {
-                llvm::APFloat apfloat(semantics, apint);
-                apfloat.toString(sv, format_precision, format_max_padding);
-              }
-            } else if (item_bit_size == ast->getTypeSize(ast->HalfTy)) {
-              llvm::APInt apint(item_bit_size, this->GetU16(&offset));
-              llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->HalfTy),
-                                    apint);
-              apfloat.toString(sv, format_precision, format_max_padding);
-            }
-
-            if (!sv.empty()) {
-              s->Printf("%*.*s", (int)sv.size(), (int)sv.size(), sv.data());
-              used_apfloat = true;
-            }
-          }
-        }
-      }
-
-      if (!used_apfloat) {
-        std::ostringstream ss;
-        if (item_byte_size == sizeof(float) || item_byte_size == 2) {
-          float f;
-          if (item_byte_size == 2) {
-            uint16_t half = this->GetU16(&offset);
-            f = half2float(half);
-          } else {
-            f = GetFloat(&offset);
-          }
-          ss.precision(std::numeric_limits<float>::digits10);
-          ss << f;
-        } else if (item_byte_size == sizeof(double)) {
-          ss.precision(std::numeric_limits<double>::digits10);
-          ss << GetDouble(&offset);
-        } else if (item_byte_size == sizeof(long double) ||
-                   item_byte_size == 10) {
-          ss.precision(std::numeric_limits<long double>::digits10);
-          ss << GetLongDouble(&offset);
-        } else {
-          s->Printf("error: unsupported byte size (%" PRIu64
-                    ") for float format",
-                    (uint64_t)item_byte_size);
-          return offset;
-        }
-        ss.flush();
-        s->Printf("%s", ss.str().c_str());
-      }
-    } break;
-
-    case eFormatUnicode16:
-      s->Printf("U+%4.4x", GetU16(&offset));
-      break;
-
-    case eFormatUnicode32:
-      s->Printf("U+0x%8.8x", GetU32(&offset));
-      break;
-
-    case eFormatAddressInfo: {
-      addr_t addr = GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
-                                      item_bit_offset);
-      s->Printf("0x%*.*" PRIx64, (int)(2 * item_byte_size),
-                (int)(2 * item_byte_size), addr);
-      if (exe_scope) {
-        TargetSP target_sp(exe_scope->CalculateTarget());
-        lldb_private::Address so_addr;
-        if (target_sp) {
-          if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr,
-                                                                 so_addr)) {
-            s->PutChar(' ');
-            so_addr.Dump(s, exe_scope, Address::DumpStyleResolvedDescription,
-                         Address::DumpStyleModuleWithFileAddress);
-          } else {
-            so_addr.SetOffset(addr);
-            so_addr.Dump(s, exe_scope,
-                         Address::DumpStyleResolvedPointerDescription);
-          }
-        }
-      }
-    } break;
-
-    case eFormatHexFloat:
-      if (sizeof(float) == item_byte_size) {
-        char float_cstr[256];
-        llvm::APFloat ap_float(GetFloat(&offset));
-        ap_float.convertToHexString(float_cstr, 0, false,
-                                    llvm::APFloat::rmNearestTiesToEven);
-        s->Printf("%s", float_cstr);
-        break;
-      } else if (sizeof(double) == item_byte_size) {
-        char float_cstr[256];
-        llvm::APFloat ap_float(GetDouble(&offset));
-        ap_float.convertToHexString(float_cstr, 0, false,
-                                    llvm::APFloat::rmNearestTiesToEven);
-        s->Printf("%s", float_cstr);
-        break;
-      } else {
-        s->Printf("error: unsupported byte size (%" PRIu64
-                  ") for hex float format",
-                  (uint64_t)item_byte_size);
-        return offset;
-      }
-      break;
-
-    // please keep the single-item formats below in sync with
-    // FormatManager::GetSingleItemFormat
-    // if you fail to do so, users will start getting different outputs
-    // depending on internal
-    // implementation details they should not care about ||
-    case eFormatVectorOfChar: //   ||
-      s->PutChar('{');        //   \/
-      offset = Dump(s, offset, eFormatCharArray, 1, item_byte_size,
-                    item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-
-    case eFormatVectorOfSInt8:
-      s->PutChar('{');
-      offset = Dump(s, offset, eFormatDecimal, 1, item_byte_size,
-                    item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-
-    case eFormatVectorOfUInt8:
-      s->PutChar('{');
-      offset = Dump(s, offset, eFormatHex, 1, item_byte_size, item_byte_size,
-                    LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-
-    case eFormatVectorOfSInt16:
-      s->PutChar('{');
-      offset =
-          Dump(s, offset, eFormatDecimal, sizeof(uint16_t),
-               item_byte_size / sizeof(uint16_t),
-               item_byte_size / sizeof(uint16_t), LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-
-    case eFormatVectorOfUInt16:
-      s->PutChar('{');
-      offset =
-          Dump(s, offset, eFormatHex, sizeof(uint16_t),
-               item_byte_size / sizeof(uint16_t),
-               item_byte_size / sizeof(uint16_t), LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-
-    case eFormatVectorOfSInt32:
-      s->PutChar('{');
-      offset =
-          Dump(s, offset, eFormatDecimal, sizeof(uint32_t),
-               item_byte_size / sizeof(uint32_t),
-               item_byte_size / sizeof(uint32_t), LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-
-    case eFormatVectorOfUInt32:
-      s->PutChar('{');
-      offset =
-          Dump(s, offset, eFormatHex, sizeof(uint32_t),
-               item_byte_size / sizeof(uint32_t),
-               item_byte_size / sizeof(uint32_t), LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-
-    case eFormatVectorOfSInt64:
-      s->PutChar('{');
-      offset =
-          Dump(s, offset, eFormatDecimal, sizeof(uint64_t),
-               item_byte_size / sizeof(uint64_t),
-               item_byte_size / sizeof(uint64_t), LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-
-    case eFormatVectorOfUInt64:
-      s->PutChar('{');
-      offset =
-          Dump(s, offset, eFormatHex, sizeof(uint64_t),
-               item_byte_size / sizeof(uint64_t),
-               item_byte_size / sizeof(uint64_t), LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-
-    case eFormatVectorOfFloat16:
-      s->PutChar('{');
-      offset = Dump(s, offset, eFormatFloat, 2, item_byte_size / 2,
-                    item_byte_size / 2, LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-
-    case eFormatVectorOfFloat32:
-      s->PutChar('{');
-      offset = Dump(s, offset, eFormatFloat, 4, item_byte_size / 4,
-                    item_byte_size / 4, LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-
-    case eFormatVectorOfFloat64:
-      s->PutChar('{');
-      offset = Dump(s, offset, eFormatFloat, 8, item_byte_size / 8,
-                    item_byte_size / 8, LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-
-    case eFormatVectorOfUInt128:
-      s->PutChar('{');
-      offset = Dump(s, offset, eFormatHex, 16, item_byte_size / 16,
-                    item_byte_size / 16, LLDB_INVALID_ADDRESS, 0, 0);
-      s->PutChar('}');
-      break;
-    }
-  }
-
-  if (item_format == eFormatBytesWithASCII && offset > line_start_offset) {
-    s->Printf("%*s", static_cast<int>(
-                         (num_per_line - (offset - line_start_offset)) * 3 + 2),
-              "");
-    Dump(s, line_start_offset, eFormatCharPrintable, 1,
-         offset - line_start_offset, SIZE_MAX, LLDB_INVALID_ADDRESS, 0, 0);
-  }
-  return offset; // Return the offset at which we ended up
-}
-
 //----------------------------------------------------------------------
 // Dumps bytes from this object's data to the stream "s" starting
 // "start_offset" bytes into this data, and ending with the byte
 // before "end_offset". "base_addr" will be added to the offset
 // into the dumped data when showing the offset into the data in the
 // output information. "num_per_line" objects of type "type" will
 // be dumped with the option to override the format for each object
 // with "type_format". "type_format" is a printf style formatting
if (uuid_data) {
       uuid.Dump(s);
     } else {
       s->Printf("<not enough data for UUID at offset 0x%8.8" PRIx64 ">",
                 offset);
     }
   }
 }
 
-void DataExtractor::DumpHexBytes(Stream *s, const void *src, size_t src_len,
-                                 uint32_t bytes_per_line, addr_t base_addr) {
-  DataExtractor data(src, src_len, eByteOrderLittle, 4);
-  data.Dump(s,
-            0,              // Offset into "src"
-            eFormatBytes,   // Dump as hex bytes
-            1,              // Size of each item is 1 for single bytes
-            src_len,        // Number of bytes
-            bytes_per_line, // Num bytes per line
-            base_addr,      // Base address
-            0, 0);          // Bitfield info
-}
-
 size_t DataExtractor::Copy(DataExtractor &dest_data) const {
   if (m_data_sp) {
     // we can pass along the SP to the data
     dest_data.SetData(m_data_sp);
   } else {
     const uint8_t *base_ptr = m_start;
     size_t data_size = GetByteSize();
     dest_data.SetData(DataBufferSP(new DataBufferHeap(base_ptr, data_size)));

lldb/trunk/source/Core/DumpDataExtractor.cpp

+//===-- DumpDataExtractor.cpp -----------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#include "lldb/Core/DumpDataExtractor.h"
+
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/Disassembler.h"
+#include "lldb/Symbol/ClangASTContext.h"
+#include "lldb/Target/ExecutionContext.h"
+#include "lldb/Target/ExecutionContextScope.h"
+#include "lldb/Target/SectionLoadList.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Utility/Stream.h"
+
+#include <bitset>
+#include <sstream>
+
+using namespace lldb_private;
+using namespace lldb;
+
+#define NON_PRINTABLE_CHAR '.'
+
+static float half2float(uint16_t half) {
+  union {
+    float f;
+    uint32_t u;
+  } u;
+  int32_t v = (int16_t)half;
+
+  if (0 == (v & 0x7c00)) {
+    u.u = v & 0x80007FFFU;
+    return u.f * ldexpf(1, 125);
+  }
+
+  v <<= 13;
+  u.u = v | 0x70000000U;
+  return u.f * ldexpf(1, -112);
+}
+
+static bool GetAPInt(const DataExtractor &data, lldb::offset_t *offset_ptr,
+                     lldb::offset_t byte_size, llvm::APInt &result) {
+  llvm::SmallVector<uint64_t, 2> uint64_array;
+  lldb::offset_t bytes_left = byte_size;
+  uint64_t u64;
+  const lldb::ByteOrder byte_order = data.GetByteOrder();
+  if (byte_order == lldb::eByteOrderLittle) {
+    while (bytes_left > 0) {
+      if (bytes_left >= 8) {
+        u64 = data.GetU64(offset_ptr);
+        bytes_left -= 8;
+      } else {
+        u64 = data.GetMaxU64(offset_ptr, (uint32_t)bytes_left);
+        bytes_left = 0;
+      }
+      uint64_array.push_back(u64);
+    }
+    result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array));
+    return true;
+  } else if (byte_order == lldb::eByteOrderBig) {
+    lldb::offset_t be_offset = *offset_ptr + byte_size;
+    lldb::offset_t temp_offset;
+    while (bytes_left > 0) {
+      if (bytes_left >= 8) {
+        be_offset -= 8;
+        temp_offset = be_offset;
+        u64 = data.GetU64(&temp_offset);
+        bytes_left -= 8;
+      } else {
+        be_offset -= bytes_left;
+        temp_offset = be_offset;
+        u64 = data.GetMaxU64(&temp_offset, (uint32_t)bytes_left);
+        bytes_left = 0;
+      }
+      uint64_array.push_back(u64);
+    }
+    *offset_ptr += byte_size;
+    result = llvm::APInt(byte_size * 8, llvm::ArrayRef<uint64_t>(uint64_array));
+    return true;
+  }
+  return false;
+}
+
+static lldb::offset_t DumpAPInt(Stream *s, const DataExtractor &data,
+                                lldb::offset_t offset, lldb::offset_t byte_size,
+                                bool is_signed, unsigned radix) {
+  llvm::APInt apint;
+  if (GetAPInt(data, &offset, byte_size, apint)) {
+    std::string apint_str(apint.toString(radix, is_signed));
+    switch (radix) {
+    case 2:
+      s->Write("0b", 2);
+      break;
+    case 8:
+      s->Write("0", 1);
+      break;
+    case 10:
+      break;
+    }
+    s->Write(apint_str.c_str(), apint_str.size());
+  }
+  return offset;
+}
+
+lldb::offset_t lldb_private::DumpDataExtractor(
+    const DataExtractor &DE, Stream *s, offset_t start_offset,
+    lldb::Format item_format, size_t item_byte_size, size_t item_count,
+    size_t num_per_line, uint64_t base_addr,
+    uint32_t item_bit_size,   // If zero, this is not a bitfield value, if
+                              // non-zero, the value is a bitfield
+    uint32_t item_bit_offset, // If "item_bit_size" is non-zero, this is the
+                              // shift amount to apply to a bitfield
+    ExecutionContextScope *exe_scope) {
+  if (s == nullptr)
+    return start_offset;
+
+  if (item_format == eFormatPointer) {
+    if (item_byte_size != 4 && item_byte_size != 8)
+      item_byte_size = s->GetAddressByteSize();
+  }
+
+  offset_t offset = start_offset;
+
+  if (item_format == eFormatInstruction) {
+    TargetSP target_sp;
+    if (exe_scope)
+      target_sp = exe_scope->CalculateTarget();
+    if (target_sp) {
+      DisassemblerSP disassembler_sp(Disassembler::FindPlugin(
+          target_sp->GetArchitecture(), nullptr, nullptr));
+      if (disassembler_sp) {
+        lldb::addr_t addr = base_addr + start_offset;
+        lldb_private::Address so_addr;
+        bool data_from_file = true;
+        if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr, so_addr)) {
+          data_from_file = false;
+        } else {
+          if (target_sp->GetSectionLoadList().IsEmpty() ||
+              !target_sp->GetImages().ResolveFileAddress(addr, so_addr))
+            so_addr.SetRawAddress(addr);
+        }
+
+        size_t bytes_consumed = disassembler_sp->DecodeInstructions(
+            so_addr, DE, start_offset, item_count, false, data_from_file);
+
+        if (bytes_consumed) {
+          offset += bytes_consumed;
+          const bool show_address = base_addr != LLDB_INVALID_ADDRESS;
+          const bool show_bytes = true;
+          ExecutionContext exe_ctx;
+          exe_scope->CalculateExecutionContext(exe_ctx);
+          disassembler_sp->GetInstructionList().Dump(s, show_address,
+                                                     show_bytes, &exe_ctx);
+        }
+      }
+    } else
+      s->Printf("invalid target");
+
+    return offset;
+  }
+
+  if ((item_format == eFormatOSType || item_format == eFormatAddressInfo) &&
+      item_byte_size > 8)
+    item_format = eFormatHex;
+
+  lldb::offset_t line_start_offset = start_offset;
+  for (uint32_t count = 0; DE.ValidOffset(offset) && count < item_count;
+       ++count) {
+    if ((count % num_per_line) == 0) {
+      if (count > 0) {
+        if (item_format == eFormatBytesWithASCII &&
+            offset > line_start_offset) {
+          s->Printf("%*s",
+                    static_cast<int>(
+                        (num_per_line - (offset - line_start_offset)) * 3 + 2),
+                    "");
+          DumpDataExtractor(DE, s, line_start_offset, eFormatCharPrintable, 1,
+                            offset - line_start_offset, SIZE_MAX,
+                            LLDB_INVALID_ADDRESS, 0, 0);
+        }
+        s->EOL();
+      }
+      if (base_addr != LLDB_INVALID_ADDRESS)
+        s->Printf("0x%8.8" PRIx64 ": ",
+                  (uint64_t)(base_addr +
+                             (offset - start_offset) / DE.getTargetByteSize()));
+
+      line_start_offset = offset;
+    } else if (item_format != eFormatChar &&
+               item_format != eFormatCharPrintable &&
+               item_format != eFormatCharArray && count > 0) {
+      s->PutChar(' ');
+    }
+
+    switch (item_format) {
+    case eFormatBoolean:
+      if (item_byte_size <= 8)
+        s->Printf("%s", DE.GetMaxU64Bitfield(&offset, item_byte_size,
+                                             item_bit_size, item_bit_offset)
+                            ? "true"
+                            : "false");
+      else {
+        s->Printf("error: unsupported byte size (%" PRIu64
+                  ") for boolean format",
+                  (uint64_t)item_byte_size);
+        return offset;
+      }
+      break;
+
+    case eFormatBinary:
+      if (item_byte_size <= 8) {
+        uint64_t uval64 = DE.GetMaxU64Bitfield(&offset, item_byte_size,
+                                               item_bit_size, item_bit_offset);
+        // Avoid std::bitset<64>::to_string() since it is missing in
+        // earlier C++ libraries
+        std::string binary_value(64, '0');
+        std::bitset<64> bits(uval64);
+        for (uint32_t i = 0; i < 64; ++i)
+          if (bits[i])
+            binary_value[64 - 1 - i] = '1';
+        if (item_bit_size > 0)
+          s->Printf("0b%s", binary_value.c_str() + 64 - item_bit_size);
+        else if (item_byte_size > 0 && item_byte_size <= 8)
+          s->Printf("0b%s", binary_value.c_str() + 64 - item_byte_size * 8);
+      } else {
+        const bool is_signed = false;
+        const unsigned radix = 2;
+        offset = DumpAPInt(s, DE, offset, item_byte_size, is_signed, radix);
+      }
+      break;
+
+    case eFormatBytes:
+    case eFormatBytesWithASCII:
+      for (uint32_t i = 0; i < item_byte_size; ++i) {
+        s->Printf("%2.2x", DE.GetU8(&offset));
+      }
+
+      // Put an extra space between the groups of bytes if more than one
+      // is being dumped in a group (item_byte_size is more than 1).
+      if (item_byte_size > 1)
+        s->PutChar(' ');
+      break;
+
+    case eFormatChar:
+    case eFormatCharPrintable:
+    case eFormatCharArray: {
+      // If we are only printing one character surround it with single
+      // quotes
+      if (item_count == 1 && item_format == eFormatChar)
+        s->PutChar('\'');
+
+      const uint64_t ch = DE.GetMaxU64Bitfield(&offset, item_byte_size,
+                                               item_bit_size, item_bit_offset);
+      if (isprint(ch))
+        s->Printf("%c", (char)ch);
+      else if (item_format != eFormatCharPrintable) {
+        switch (ch) {
+        case '\033':
+          s->Printf("\\e");
+          break;
+        case '\a':
+          s->Printf("\\a");
+          break;
+        case '\b':
+          s->Printf("\\b");
+          break;
+        case '\f':
+          s->Printf("\\f");
+          break;
+        case '\n':
+          s->Printf("\\n");
+          break;
+        case '\r':
+          s->Printf("\\r");
+          break;
+        case '\t':
+          s->Printf("\\t");
+          break;
+        case '\v':
+          s->Printf("\\v");
+          break;
+        case '\0':
+          s->Printf("\\0");
+          break;
+        default:
+          if (item_byte_size == 1)
+            s->Printf("\\x%2.2x", (uint8_t)ch);
+          else
+            s->Printf("%" PRIu64, ch);
+          break;
+        }
+      } else {
+        s->PutChar(NON_PRINTABLE_CHAR);
+      }
+
+      // If we are only printing one character surround it with single quotes
+      if (item_count == 1 && item_format == eFormatChar)
+        s->PutChar('\'');
+    } break;
+
+    case eFormatEnum: // Print enum value as a signed integer when we don't get
+                      // the enum type
+    case eFormatDecimal:
+      if (item_byte_size <= 8)
+        s->Printf("%" PRId64,
+                  DE.GetMaxS64Bitfield(&offset, item_byte_size, item_bit_size,
+                                       item_bit_offset));
+      else {
+        const bool is_signed = true;
+        const unsigned radix = 10;
+        offset = DumpAPInt(s, DE, offset, item_byte_size, is_signed, radix);
+      }
+      break;
+
+    case eFormatUnsigned:
+      if (item_byte_size <= 8)
+        s->Printf("%" PRIu64,
+                  DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
+                                       item_bit_offset));
+      else {
+        const bool is_signed = false;
+        const unsigned radix = 10;
+        offset = DumpAPInt(s, DE, offset, item_byte_size, is_signed, radix);
+      }
+      break;
+
+    case eFormatOctal:
+      if (item_byte_size <= 8)
+        s->Printf("0%" PRIo64,
+                  DE.GetMaxS64Bitfield(&offset, item_byte_size, item_bit_size,
+                                       item_bit_offset));
+      else {
+        const bool is_signed = false;
+        const unsigned radix = 8;
+        offset = DumpAPInt(s, DE, offset, item_byte_size, is_signed, radix);
+      }
+      break;
+
+    case eFormatOSType: {
+      uint64_t uval64 = DE.GetMaxU64Bitfield(&offset, item_byte_size,
+                                             item_bit_size, item_bit_offset);
+      s->PutChar('\'');
+      for (uint32_t i = 0; i < item_byte_size; ++i) {
+        uint8_t ch = (uint8_t)(uval64 >> ((item_byte_size - i - 1) * 8));
+        if (isprint(ch))
+          s->Printf("%c", ch);
+        else {
+          switch (ch) {
+          case '\033':
+            s->Printf("\\e");
+            break;
+          case '\a':
+            s->Printf("\\a");
+            break;
+          case '\b':
+            s->Printf("\\b");
+            break;
+          case '\f':
+            s->Printf("\\f");
+            break;
+          case '\n':
+            s->Printf("\\n");
+            break;
+          case '\r':
+            s->Printf("\\r");
+            break;
+          case '\t':
+            s->Printf("\\t");
+            break;
+          case '\v':
+            s->Printf("\\v");
+            break;
+          case '\0':
+            s->Printf("\\0");
+            break;
+          default:
+            s->Printf("\\x%2.2x", ch);
+            break;
+          }
+        }
+      }
+      s->PutChar('\'');
+    } break;
+
+    case eFormatCString: {
+      const char *cstr = DE.GetCStr(&offset);
+
+      if (!cstr) {
+        s->Printf("NULL");
+        offset = LLDB_INVALID_OFFSET;
+      } else {
+        s->PutChar('\"');
+
+        while (const char c = *cstr) {
+          if (isprint(c)) {
+            s->PutChar(c);
+          } else {
+            switch (c) {
+            case '\033':
+              s->Printf("\\e");
+              break;
+            case '\a':
+              s->Printf("\\a");
+              break;
+            case '\b':
+              s->Printf("\\b");
+              break;
+            case '\f':
+              s->Printf("\\f");
+              break;
+            case '\n':
+              s->Printf("\\n");
+              break;
+            case '\r':
+              s->Printf("\\r");
+              break;
+            case '\t':
+              s->Printf("\\t");
+              break;
+            case '\v':
+              s->Printf("\\v");
+              break;
+            default:
+              s->Printf("\\x%2.2x", c);
+              break;
+            }
+          }
+
+          ++cstr;
+        }
+
+        s->PutChar('\"');
+      }
+    } break;
+
+    case eFormatPointer:
+      s->Address(DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
+                                      item_bit_offset),
+                 sizeof(addr_t));
+      break;
+
+    case eFormatComplexInteger: {
+      size_t complex_int_byte_size = item_byte_size / 2;
+
+      if (complex_int_byte_size > 0 && complex_int_byte_size <= 8) {
+        s->Printf("%" PRIu64,
+                  DE.GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0));
+        s->Printf(" + %" PRIu64 "i",
+                  DE.GetMaxU64Bitfield(&offset, complex_int_byte_size, 0, 0));
+      } else {
+        s->Printf("error: unsupported byte size (%" PRIu64
+                  ") for complex integer format",
+                  (uint64_t)item_byte_size);
+        return offset;
+      }
+    } break;
+
+    case eFormatComplex:
+      if (sizeof(float) * 2 == item_byte_size) {
+        float f32_1 = DE.GetFloat(&offset);
+        float f32_2 = DE.GetFloat(&offset);
+
+        s->Printf("%g + %gi", f32_1, f32_2);
+        break;
+      } else if (sizeof(double) * 2 == item_byte_size) {
+        double d64_1 = DE.GetDouble(&offset);
+        double d64_2 = DE.GetDouble(&offset);
+
+        s->Printf("%lg + %lgi", d64_1, d64_2);
+        break;
+      } else if (sizeof(long double) * 2 == item_byte_size) {
+        long double ld64_1 = DE.GetLongDouble(&offset);
+        long double ld64_2 = DE.GetLongDouble(&offset);
+        s->Printf("%Lg + %Lgi", ld64_1, ld64_2);
+        break;
+      } else {
+        s->Printf("error: unsupported byte size (%" PRIu64
+                  ") for complex float format",
+                  (uint64_t)item_byte_size);
+        return offset;
+      }
+      break;
+
+    default:
+    case eFormatDefault:
+    case eFormatHex:
+    case eFormatHexUppercase: {
+      bool wantsuppercase = (item_format == eFormatHexUppercase);
+      switch (item_byte_size) {
+      case 1:
+      case 2:
+      case 4:
+      case 8:
+        s->Printf(wantsuppercase ? "0x%*.*" PRIX64 : "0x%*.*" PRIx64,
+                  (int)(2 * item_byte_size), (int)(2 * item_byte_size),
+                  DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
+                                       item_bit_offset));
+        break;
+      default: {
+        assert(item_bit_size == 0 && item_bit_offset == 0);
+        const uint8_t *bytes =
+            (const uint8_t *)DE.GetData(&offset, item_byte_size);
+        if (bytes) {
+          s->PutCString("0x");
+          uint32_t idx;
+          if (DE.GetByteOrder() == eByteOrderBig) {
+            for (idx = 0; idx < item_byte_size; ++idx)
+              s->Printf(wantsuppercase ? "%2.2X" : "%2.2x", bytes[idx]);
+          } else {
+            for (idx = 0; idx < item_byte_size; ++idx)
+              s->Printf(wantsuppercase ? "%2.2X" : "%2.2x",
+                        bytes[item_byte_size - 1 - idx]);
+          }
+        }
+      } break;
+      }
+    } break;
+
+    case eFormatFloat: {
+      TargetSP target_sp;
+      bool used_apfloat = false;
+      if (exe_scope)
+        target_sp = exe_scope->CalculateTarget();
+      if (target_sp) {
+        ClangASTContext *clang_ast = target_sp->GetScratchClangASTContext();
+        if (clang_ast) {
+          clang::ASTContext *ast = clang_ast->getASTContext();
+          if (ast) {
+            llvm::SmallVector<char, 256> sv;
+            // Show full precision when printing float values
+            const unsigned format_precision = 0;
+            const unsigned format_max_padding = 100;
+            size_t item_bit_size = item_byte_size * 8;
+
+            if (item_bit_size == ast->getTypeSize(ast->FloatTy)) {
+              llvm::APInt apint(item_bit_size,
+                                DE.GetMaxU64(&offset, item_byte_size));
+              llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->FloatTy),
+                                    apint);
+              apfloat.toString(sv, format_precision, format_max_padding);
+            } else if (item_bit_size == ast->getTypeSize(ast->DoubleTy)) {
+              llvm::APInt apint;
+              if (GetAPInt(DE, &offset, item_byte_size, apint)) {
+                llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->DoubleTy),
+                                      apint);
+                apfloat.toString(sv, format_precision, format_max_padding);
+              }
+            } else if (item_bit_size == ast->getTypeSize(ast->LongDoubleTy)) {
+              const auto &semantics =
+                  ast->getFloatTypeSemantics(ast->LongDoubleTy);
+              const auto byte_size =
+                  (llvm::APFloat::getSizeInBits(semantics) + 7) / 8;
+
+              llvm::APInt apint;
+              if (GetAPInt(DE, &offset, byte_size, apint)) {
+                llvm::APFloat apfloat(semantics, apint);
+                apfloat.toString(sv, format_precision, format_max_padding);
+              }
+            } else if (item_bit_size == ast->getTypeSize(ast->HalfTy)) {
+              llvm::APInt apint(item_bit_size, DE.GetU16(&offset));
+              llvm::APFloat apfloat(ast->getFloatTypeSemantics(ast->HalfTy),
+                                    apint);
+              apfloat.toString(sv, format_precision, format_max_padding);
+            }
+
+            if (!sv.empty()) {
+              s->Printf("%*.*s", (int)sv.size(), (int)sv.size(), sv.data());
+              used_apfloat = true;
+            }
+          }
+        }
+      }
+
+      if (!used_apfloat) {
+        std::ostringstream ss;
+        if (item_byte_size == sizeof(float) || item_byte_size == 2) {
+          float f;
+          if (item_byte_size == 2) {
+            uint16_t half = DE.GetU16(&offset);
+            f = half2float(half);
+          } else {
+            f = DE.GetFloat(&offset);
+          }
+          ss.precision(std::numeric_limits<float>::digits10);
+          ss << f;
+        } else if (item_byte_size == sizeof(double)) {
+          ss.precision(std::numeric_limits<double>::digits10);
+          ss << DE.GetDouble(&offset);
+        } else if (item_byte_size == sizeof(long double) ||
+                   item_byte_size == 10) {
+          ss.precision(std::numeric_limits<long double>::digits10);
+          ss << DE.GetLongDouble(&offset);
+        } else {
+          s->Printf("error: unsupported byte size (%" PRIu64
+                    ") for float format",
+                    (uint64_t)item_byte_size);
+          return offset;
+        }
+        ss.flush();
+        s->Printf("%s", ss.str().c_str());
+      }
+    } break;
+
+    case eFormatUnicode16:
+      s->Printf("U+%4.4x", DE.GetU16(&offset));
+      break;
+
+    case eFormatUnicode32:
+      s->Printf("U+0x%8.8x", DE.GetU32(&offset));
+      break;
+
+    case eFormatAddressInfo: {
+      addr_t addr = DE.GetMaxU64Bitfield(&offset, item_byte_size, item_bit_size,
+                                         item_bit_offset);
+      s->Printf("0x%*.*" PRIx64, (int)(2 * item_byte_size),
+                (int)(2 * item_byte_size), addr);
+      if (exe_scope) {
+        TargetSP target_sp(exe_scope->CalculateTarget());
+        lldb_private::Address so_addr;
+        if (target_sp) {
+          if (target_sp->GetSectionLoadList().ResolveLoadAddress(addr,
+                                                                 so_addr)) {
+            s->PutChar(' ');
+            so_addr.Dump(s, exe_scope, Address::DumpStyleResolvedDescription,
+                         Address::DumpStyleModuleWithFileAddress);
+          } else {
+            so_addr.SetOffset(addr);
+            so_addr.Dump(s, exe_scope,
+                         Address::DumpStyleResolvedPointerDescription);
+          }
+        }
+      }
+    } break;
+
+    case eFormatHexFloat:
+      if (sizeof(float) == item_byte_size) {
+        char float_cstr[256];
+        llvm::APFloat ap_float(DE.GetFloat(&offset));
+        ap_float.convertToHexString(float_cstr, 0, false,
+                                    llvm::APFloat::rmNearestTiesToEven);
+        s->Printf("%s", float_cstr);
+        break;
+      } else if (sizeof(double) == item_byte_size) {
+        char float_cstr[256];
+        llvm::APFloat ap_float(DE.GetDouble(&offset));
+        ap_float.convertToHexString(float_cstr, 0, false,
+                                    llvm::APFloat::rmNearestTiesToEven);
+        s->Printf("%s", float_cstr);
+        break;
+      } else {
+        s->Printf("error: unsupported byte size (%" PRIu64
+                  ") for hex float format",
+                  (uint64_t)item_byte_size);
+        return offset;
+      }
+      break;
+
+    // please keep the single-item formats below in sync with
+    // FormatManager::GetSingleItemFormat
+    // if you fail to do so, users will start getting different outputs
+    // depending on internal
+    // implementation details they should not care about ||
+    case eFormatVectorOfChar: //   ||
+      s->PutChar('{');        //   \/
+      offset =
+          DumpDataExtractor(DE, s, offset, eFormatCharArray, 1, item_byte_size,
+                            item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+
+    case eFormatVectorOfSInt8:
+      s->PutChar('{');
+      offset =
+          DumpDataExtractor(DE, s, offset, eFormatDecimal, 1, item_byte_size,
+                            item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+
+    case eFormatVectorOfUInt8:
+      s->PutChar('{');
+      offset = DumpDataExtractor(DE, s, offset, eFormatHex, 1, item_byte_size,
+                                 item_byte_size, LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+
+    case eFormatVectorOfSInt16:
+      s->PutChar('{');
+      offset = DumpDataExtractor(
+          DE, s, offset, eFormatDecimal, sizeof(uint16_t),
+          item_byte_size / sizeof(uint16_t), item_byte_size / sizeof(uint16_t),
+          LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+
+    case eFormatVectorOfUInt16:
+      s->PutChar('{');
+      offset = DumpDataExtractor(DE, s, offset, eFormatHex, sizeof(uint16_t),
+                                 item_byte_size / sizeof(uint16_t),
+                                 item_byte_size / sizeof(uint16_t),
+                                 LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+
+    case eFormatVectorOfSInt32:
+      s->PutChar('{');
+      offset = DumpDataExtractor(
+          DE, s, offset, eFormatDecimal, sizeof(uint32_t),
+          item_byte_size / sizeof(uint32_t), item_byte_size / sizeof(uint32_t),
+          LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+
+    case eFormatVectorOfUInt32:
+      s->PutChar('{');
+      offset = DumpDataExtractor(DE, s, offset, eFormatHex, sizeof(uint32_t),
+                                 item_byte_size / sizeof(uint32_t),
+                                 item_byte_size / sizeof(uint32_t),
+                                 LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+
+    case eFormatVectorOfSInt64:
+      s->PutChar('{');
+      offset = DumpDataExtractor(
+          DE, s, offset, eFormatDecimal, sizeof(uint64_t),
+          item_byte_size / sizeof(uint64_t), item_byte_size / sizeof(uint64_t),
+          LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+
+    case eFormatVectorOfUInt64:
+      s->PutChar('{');
+      offset = DumpDataExtractor(DE, s, offset, eFormatHex, sizeof(uint64_t),
+                                 item_byte_size / sizeof(uint64_t),
+                                 item_byte_size / sizeof(uint64_t),
+                                 LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+
+    case eFormatVectorOfFloat16:
+      s->PutChar('{');
+      offset =
+          DumpDataExtractor(DE, s, offset, eFormatFloat, 2, item_byte_size / 2,
+                            item_byte_size / 2, LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+
+    case eFormatVectorOfFloat32:
+      s->PutChar('{');
+      offset =
+          DumpDataExtractor(DE, s, offset, eFormatFloat, 4, item_byte_size / 4,
+                            item_byte_size / 4, LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+
+    case eFormatVectorOfFloat64:
+      s->PutChar('{');
+      offset =
+          DumpDataExtractor(DE, s, offset, eFormatFloat, 8, item_byte_size / 8,
+                            item_byte_size / 8, LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+
+    case eFormatVectorOfUInt128:
+      s->PutChar('{');
+      offset =
+          DumpDataExtractor(DE, s, offset, eFormatHex, 16, item_byte_size / 16,
+                            item_byte_size / 16, LLDB_INVALID_ADDRESS, 0, 0);
+      s->PutChar('}');
+      break;
+    }
+  }
+
+  if (item_format == eFormatBytesWithASCII && offset > line_start_offset) {
+    s->Printf("%*s", static_cast<int>(
+                         (num_per_line - (offset - line_start_offset)) * 3 + 2),
+              "");
+    DumpDataExtractor(DE, s, line_start_offset, eFormatCharPrintable, 1,
+                      offset - line_start_offset, SIZE_MAX,
+                      LLDB_INVALID_ADDRESS, 0, 0);
+  }
+  return offset; // Return the offset at which we ended up
+}

lldb/trunk/source/Core/Event.cpp

 // C Includes
 // C++ Includes
 #include <algorithm>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Broadcaster.h"
 #include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Event.h"
 #include "lldb/Core/State.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Utility/Endian.h"
 #include "lldb/Utility/Log.h"
 #include "lldb/Utility/Stream.h"
 
 using namespace lldb;

 void EventDataBytes::Dump(Stream *s) const {
   size_t num_printable_chars =
       std::count_if(m_bytes.begin(), m_bytes.end(), isprint);
   if (num_printable_chars == m_bytes.size()) {
     s->Printf("\"%s\"", m_bytes.c_str());
   } else if (!m_bytes.empty()) {
     DataExtractor data;
     data.SetData(m_bytes.data(), m_bytes.size(), endian::InlHostByteOrder());
-    data.Dump(s, 0, eFormatBytes, 1, m_bytes.size(), 32, LLDB_INVALID_ADDRESS,
-              0, 0);
+    DumpDataExtractor(data, s, 0, eFormatBytes, 1, m_bytes.size(), 32,
+                      LLDB_INVALID_ADDRESS, 0, 0);
   }
 }
 
 const void *EventDataBytes::GetBytes() const {
   return (m_bytes.empty() ? nullptr : m_bytes.data());
 }
 
 size_t EventDataBytes::GetByteSize() const { return m_bytes.size(); }

lldb/trunk/source/Core/RegisterValue.cpp

 #include <vector>
 
 // Other libraries and framework includes
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 
 // Project includes
 #include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Utility/Error.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb;
if (prefix_with_alt_name) {
       }
     }
     if (name_printed)
       s->PutCString(" = ");
 
     if (format == eFormatDefault)
       format = reg_info->format;
 
-    data.Dump(s,
+    DumpDataExtractor(data, s,
                       0,                    // Offset in "data"
                       format,               // Format to use when dumping
                       reg_info->byte_size,  // item_byte_size
                       1,                    // item_count
                       UINT32_MAX,           // num_per_line
                       LLDB_INVALID_ADDRESS, // base_addr
                       0,                    // item_bit_size
                       0);                   // item_bit_offset
     return true;
   }
   return false;
 }
 
 bool RegisterValue::GetData(DataExtractor &data) const {
   return data.SetData(GetBytes(), GetByteSize(), GetByteOrder()) > 0;
 }

lldb/trunk/source/DataFormatters/TypeFormat.cpp

 // C++ Includes
 
 // Other libraries and framework includes
 
 // Project includes
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-public.h"
 
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/SymbolContext.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/TypeList.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/StreamString.h"
 
if (context_type == Value::eContextTypeRegisterInfo) {
       const RegisterInfo *reg_info = value.GetRegisterInfo();
       if (reg_info) {
         Error error;
         valobj->GetData(data, error);
         if (error.Fail())
           return false;
 
         StreamString reg_sstr;
-        data.Dump(&reg_sstr, 0, GetFormat(), reg_info->byte_size, 1, UINT32_MAX,
-                  LLDB_INVALID_ADDRESS, 0, 0,
+        DumpDataExtractor(data, &reg_sstr, 0, GetFormat(), reg_info->byte_size,
+                          1, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0,
                           exe_ctx.GetBestExecutionContextScope());
         dest = reg_sstr.GetString();
       }
     } else {
       CompilerType compiler_type = value.GetCompilerType();
       if (compiler_type) {
         // put custom bytes to display in the DataExtractor to override the
         // default value logic
         if (GetFormat() == eFormatCString) {

lldb/trunk/source/Expression/Materializer.cpp

 //===-- Materializer.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Expression/Materializer.h"
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/RegisterValue.h"
 #include "lldb/Core/ValueObjectConstResult.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/Symbol.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Symbol/Variable.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Log.h"
 
 using namespace lldb_private;
 
+static void DumpHexBytes(Stream *s, const void *src, size_t src_len,
+                         uint32_t bytes_per_line, lldb::addr_t base_addr) {
+  DataExtractor data(src, src_len, lldb::eByteOrderLittle, 4);
+  DumpDataExtractor(data, s,
+                    0,                  // Offset into "src"
+                    lldb::eFormatBytes, // Dump as hex bytes
+                    1,              // Size of each item is 1 for single bytes
+                    src_len,        // Number of bytes
+                    bytes_per_line, // Num bytes per line
+                    base_addr,      // Base address
+                    0, 0);          // Bitfield info
+}
+
 uint32_t Materializer::AddStructMember(Entity &entity) {
   uint32_t size = entity.GetSize();
   uint32_t alignment = entity.GetAlignment();
 
   uint32_t ret;
 
   if (m_current_offset == 0)
     m_struct_alignment = alignment;
dump_stream.Printf("0x%" PRIx64 ": EntityPersistentVariable (%s)\n",
 
       DataBufferHeap data(m_size, 0);
 
       map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
 
       if (!err.Success()) {
         dump_stream.Printf("  <could not be read>\n");
       } else {
-        DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
-                                map.GetByteOrder(), map.GetAddressByteSize());
-
-        extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
-                               data.GetByteSize(), 16, load_addr);
+        DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16,
+                     load_addr);
 
         dump_stream.PutChar('\n');
       }
     }
 
     {
       dump_stream.Printf("Target:\n");
 
       lldb::addr_t target_address;
 
       map.ReadPointerFromMemory(&target_address, load_addr, err);
 
       if (!err.Success()) {
         dump_stream.Printf("  <could not be read>\n");
       } else {
         DataBufferHeap data(m_persistent_variable_sp->GetByteSize(), 0);
 
         map.ReadMemory(data.GetBytes(), target_address,
                        m_persistent_variable_sp->GetByteSize(), err);
 
         if (!err.Success()) {
           dump_stream.Printf("  <could not be read>\n");
         } else {
-          DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
-                                  map.GetByteOrder(), map.GetAddressByteSize());
-
-          extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
-                                 data.GetByteSize(), 16, target_address);
+          DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16,
+                       target_address);
 
           dump_stream.PutChar('\n');
         }
       }
     }
 
     log->PutString(dump_stream.GetString());
   }
lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
       map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
 
       if (!err.Success()) {
         dump_stream.Printf("  <could not be read>\n");
       } else {
         DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
                                 map.GetByteOrder(), map.GetAddressByteSize());
 
-        extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
-                               data.GetByteSize(), 16, load_addr);
+        DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16,
+                     load_addr);
 
         lldb::offset_t offset;
 
         ptr = extractor.GetPointer(&offset);
 
         dump_stream.PutChar('\n');
       }
     }
if (ptr == LLDB_INVALID_ADDRESS) {
       DataBufferHeap data(m_temporary_allocation_size, 0);
 
       map.ReadMemory(data.GetBytes(), m_temporary_allocation,
                      m_temporary_allocation_size, err);
 
       if (!err.Success()) {
         dump_stream.Printf("  <could not be read>\n");
       } else {
-        DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
-                                map.GetByteOrder(), map.GetAddressByteSize());
-
-        extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
-                               data.GetByteSize(), 16, load_addr);
+        DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16,
+                     load_addr);
 
         dump_stream.PutChar('\n');
       }
     }
 
     log->PutString(dump_stream.GetString());
   }
 
lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
       map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
 
       if (!err.Success()) {
         dump_stream.Printf("  <could not be read>\n");
       } else {
         DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
                                 map.GetByteOrder(), map.GetAddressByteSize());
 
-        extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
-                               data.GetByteSize(), 16, load_addr);
+        DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16,
+                     load_addr);
 
         lldb::offset_t offset;
 
         ptr = extractor.GetPointer(&offset);
 
         dump_stream.PutChar('\n');
       }
     }
if (ptr == LLDB_INVALID_ADDRESS) {
       DataBufferHeap data(m_temporary_allocation_size, 0);
 
       map.ReadMemory(data.GetBytes(), m_temporary_allocation,
                      m_temporary_allocation_size, err);
 
       if (!err.Success()) {
         dump_stream.Printf("  <could not be read>\n");
       } else {
-        DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
-                                map.GetByteOrder(), map.GetAddressByteSize());
-
-        extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
-                               data.GetByteSize(), 16, load_addr);
+        DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16,
+                     load_addr);
 
         dump_stream.PutChar('\n');
       }
     }
 
     log->PutString(dump_stream.GetString());
   }
 
dump_stream.Printf("0x%" PRIx64 ": EntitySymbol (%s)\n", load_addr,
 
       DataBufferHeap data(m_size, 0);
 
       map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
 
       if (!err.Success()) {
         dump_stream.Printf("  <could not be read>\n");
       } else {
-        DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
-                                map.GetByteOrder(), map.GetAddressByteSize());
-
-        extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
-                               data.GetByteSize(), 16, load_addr);
+        DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16,
+                     load_addr);
 
         dump_stream.PutChar('\n');
       }
     }
 
     log->PutString(dump_stream.GetString());
   }
 
dump_stream.Printf("0x%" PRIx64 ": EntityRegister (%s)\n", load_addr,
 
       DataBufferHeap data(m_size, 0);
 
       map.ReadMemory(data.GetBytes(), load_addr, m_size, err);
 
       if (!err.Success()) {
         dump_stream.Printf("  <could not be read>\n");
       } else {
-        DataExtractor extractor(data.GetBytes(), data.GetByteSize(),
-                                map.GetByteOrder(), map.GetAddressByteSize());
-
-        extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
-                               data.GetByteSize(), 16, load_addr);
+        DumpHexBytes(&dump_stream, data.GetBytes(), data.GetByteSize(), 16,
+                     load_addr);
 
         dump_stream.PutChar('\n');
       }
     }
 
     log->PutString(dump_stream.GetString());
   }
 

lldb/trunk/source/Plugins/LanguageRuntime/RenderScript/RenderScriptRuntime/RenderScriptRuntime.cpp

 #include "llvm/ADT/StringSwitch.h"
 
 // Project includes
 #include "RenderScriptRuntime.h"
 #include "RenderScriptScriptGroup.h"
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
 #include "lldb/Core/Debugger.h"
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObjectVariable.h"
 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
 #include "lldb/Expression/UserExpression.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Interpreter/Args.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObjectMultiword.h"
for (uint32_t y = 0; y < dim_y; ++y) {
           // Evaluate expression
           ValueObjectSP expr_result;
           GetProcess()->GetTarget().EvaluateExpression(expr_char_buffer,
                                                        frame_ptr, expr_result);
 
           // Print the results to our stream.
           expr_result->Dump(strm, expr_options);
         } else {
-          alloc_data.Dump(&strm, offset, format, data_size - padding, 1, 1,
-                          LLDB_INVALID_ADDRESS, 0, 0);
+          DumpDataExtractor(alloc_data, &strm, offset, format,
+                            data_size - padding, 1, 1, LLDB_INVALID_ADDRESS, 0,
+                            0);
         }
         offset += data_size;
       }
     }
   }
   strm.EOL();
 
   return true;

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFCompileUnit.cpp

 //===-- DWARFCompileUnit.cpp ------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "DWARFCompileUnit.h"
 
 #include "Plugins/Language/ObjC/ObjCLanguage.h"
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Mangled.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Timer.h"
 #include "lldb/Host/StringConvert.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/LineTable.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Utility/Stream.h"
bool DWARFCompileUnit::Verify(Stream *s) const {
   bool abbr_offset_OK =
       m_dwarf2Data->get_debug_abbrev_data().ValidOffset(GetAbbrevOffset());
   bool addr_size_OK = ((m_addr_size == 4) || (m_addr_size == 8));
   if (valid_offset && length_OK && version_OK && addr_size_OK &&
       abbr_offset_OK) {
     return true;
   } else {
     s->Printf("    0x%8.8x: ", m_offset);
-
-    m_dwarf2Data->get_debug_info_data().Dump(s, m_offset, lldb::eFormatHex, 1,
-                                             Size(), 32, LLDB_INVALID_ADDRESS,
-                                             0, 0);
+    DumpDataExtractor(m_dwarf2Data->get_debug_info_data(), s, m_offset,
+                      lldb::eFormatHex, 1, Size(), 32, LLDB_INVALID_ADDRESS, 0,
+                      0);
     s->EOL();
     if (valid_offset) {
       if (!length_OK)
         s->Printf("        The length (0x%8.8x) for this compile unit is too "
                   "large for the .debug_info provided.\n",
                   m_length);
       if (!version_OK)
         s->Printf("        The 16 bit compile unit header version is not "

lldb/trunk/source/Plugins/SymbolFile/DWARF/DWARFDataExtractor.h

 #define liblldb_DWARFDataExtractor_h_
 
 // Other libraries and framework includes.
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/dwarf.h"
 
 namespace lldb_private {
 
-class DWARFDataExtractor : public lldb_private::DataExtractor {
+class DWARFDataExtractor : public DataExtractor {
 public:
   DWARFDataExtractor() : DataExtractor(), m_is_dwarf64(false) {}
 
   DWARFDataExtractor(const DWARFDataExtractor &data, lldb::offset_t offset,
                      lldb::offset_t length)
       : DataExtractor(data, offset, length), m_is_dwarf64(false) {}
 
   uint64_t GetDWARFInitialLength(lldb::offset_t *offset_ptr) const;

lldb/trunk/source/Plugins/UnwindAssembly/InstEmulation/UnwindAssemblyInstEmulation.cpp

 //===-- UnwindAssemblyInstEmulation.cpp --------------------------*- C++-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "UnwindAssemblyInstEmulation.h"
 
 #include "lldb/Core/Address.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Disassembler.h"
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/FormatEntity.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Error.h"
 #include "lldb/Utility/Log.h"
DataExtractor data(dst, dst_len,
                      instruction->GetArchitecture().GetAddressByteSize());
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
 
   if (log && log->GetVerbose()) {
     StreamString strm;
 
     strm.PutCString("UnwindAssemblyInstEmulation::WriteMemory   (");
-    data.Dump(&strm, 0, eFormatBytes, 1, dst_len, UINT32_MAX, addr, 0, 0);
+    DumpDataExtractor(data, &strm, 0, eFormatBytes, 1, dst_len, UINT32_MAX,
+                      addr, 0, 0);
     strm.PutCString(", context = ");
     context.Dump(strm, instruction);
     log->PutString(strm.GetString());
   }
 
   const bool cant_replace = false;
 
   switch (context.type) {

lldb/trunk/source/Symbol/ClangASTContext.cpp

 #include "llvm/Support/Threading.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangFunctionCaller.h"
 #include "Plugins/ExpressionParser/Clang/ClangUserExpression.h"
 #include "Plugins/ExpressionParser/Clang/ClangUtilityFunction.h"
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Utility/Flags.h"
 
+#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ThreadSafeDenseMap.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangASTImporter.h"

 
 //----------------------------------------------------------------------
 // Dumping types
 //----------------------------------------------------------------------
 #define DEPTH_INCREMENT 2
 
 void ClangASTContext::DumpValue(
     lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s,
-    lldb::Format format, const lldb_private::DataExtractor &data,
+    lldb::Format format, const DataExtractor &data,
     lldb::offset_t data_byte_offset, size_t data_byte_size,
     uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset, bool show_types,
     bool show_summary, bool verbose, uint32_t depth) {
   if (!type)
     return;
 
   clang::QualType qual_type(GetQualType(type));
   switch (qual_type->getTypeClass()) {
case clang::Type::ConstantArray: {
 
     uint32_t element_idx = 0;
     uint32_t element_offset = 0;
     uint64_t element_byte_size = field_type_info.Width / 8;
     uint32_t element_stride = element_byte_size;
 
     if (is_array_of_characters) {
       s->PutChar('"');
-      data.Dump(s, data_byte_offset, lldb::eFormatChar, element_byte_size,
-                element_count, UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0);
+      DumpDataExtractor(data, s, data_byte_offset, lldb::eFormatChar,
+                        element_byte_size, element_count, UINT32_MAX,
+                        LLDB_INVALID_ADDRESS, 0, 0);
       s->PutChar('"');
       return;
     } else {
       CompilerType element_clang_type(getASTContext(), element_qual_type);
       lldb::Format element_format = element_clang_type.GetFormat();
 
       for (element_idx = 0; element_idx < element_count; ++element_idx) {
         // Print the starting squiggly bracket (if this is the
return desugar_clang_type.DumpValue(
         show_summary, // Boolean indicating if we should show a summary for the
                       // current type
         verbose,      // Verbose output?
         depth);       // Scope depth for any types that have children
   } break;
 
   default:
     // We are down to a scalar type that we just need to display.
-    data.Dump(s, data_byte_offset, format, data_byte_size, 1, UINT32_MAX,
-              LLDB_INVALID_ADDRESS, bitfield_bit_size, bitfield_bit_offset);
+    DumpDataExtractor(data, s, data_byte_offset, format, data_byte_size, 1,
+                      UINT32_MAX, LLDB_INVALID_ADDRESS, bitfield_bit_size,
+                      bitfield_bit_offset);
 
     if (show_summary)
       DumpSummary(type, exe_ctx, s, data, data_byte_offset, data_byte_size);
     break;
   }
 }
 
 bool ClangASTContext::DumpTypeValue(
     lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format,
-    const lldb_private::DataExtractor &data, lldb::offset_t byte_offset,
-    size_t byte_size, uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
+    const DataExtractor &data, lldb::offset_t byte_offset, size_t byte_size,
+    uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
     ExecutionContextScope *exe_scope) {
   if (!type)
     return false;
   if (IsAggregateType(type)) {
     return false;
   } else {
     clang::QualType qual_type(GetQualType(type));
 
default:
           byte_size = 2;
           break;
 
         case eFormatUnicode32:
           item_count = byte_size / 4;
           byte_size = 4;
           break;
         }
-        return data.Dump(s, byte_offset, format, byte_size, item_count,
-                         UINT32_MAX, LLDB_INVALID_ADDRESS, bitfield_bit_size,
-                         bitfield_bit_offset, exe_scope);
+        return DumpDataExtractor(data, s, byte_offset, format, byte_size,
+                                 item_count, UINT32_MAX, LLDB_INVALID_ADDRESS,
+                                 bitfield_bit_size, bitfield_bit_offset,
+                                 exe_scope);
       }
       break;
     }
   }
   return 0;
 }
 
 void ClangASTContext::DumpSummary(lldb::opaque_compiler_type_t type,
if (exe_ctx) {
         lldb::offset_t offset = data_byte_offset;
         lldb::addr_t pointer_address = data.GetMaxU64(&offset, data_byte_size);
         std::vector<uint8_t> buf;
         if (length > 0)
           buf.resize(length);
         else
           buf.resize(256);
 
-        lldb_private::DataExtractor cstr_data(&buf.front(), buf.size(),
-                                              process->GetByteOrder(), 4);
+        DataExtractor cstr_data(&buf.front(), buf.size(),
         buf.back() = '\0';
         size_t bytes_read;
         size_t total_cstr_len = 0;
         Error error;
         while ((bytes_read = process->ReadMemory(pointer_address, &buf.front(),
                                                  buf.size(), error)) > 0) {
           const size_t len = strlen((const char *)&buf.front());
           if (len == 0)
             break;
           if (total_cstr_len == 0)
             s->PutCString(" \"");
-          cstr_data.Dump(s, 0, lldb::eFormatChar, 1, len, UINT32_MAX,
-                         LLDB_INVALID_ADDRESS, 0, 0);
+          DumpDataExtractor(cstr_data, s, 0, lldb::eFormatChar, 1, len,
+                            UINT32_MAX, LLDB_INVALID_ADDRESS, 0, 0);
           total_cstr_len += len;
           if (len < buf.size())
             break;
           pointer_address += total_cstr_len;
         }
         if (total_cstr_len > 0)
           s->PutChar('"');
       }

lldb/trunk/source/Symbol/CompilerType.cpp

 }
 
 //----------------------------------------------------------------------
 // Dumping types
 //----------------------------------------------------------------------
 #define DEPTH_INCREMENT 2
 
 void CompilerType::DumpValue(ExecutionContext *exe_ctx, Stream *s,
-                             lldb::Format format,
-                             const lldb_private::DataExtractor &data,
+                             lldb::Format format, const DataExtractor &data,
                              lldb::offset_t data_byte_offset,
                              size_t data_byte_size, uint32_t bitfield_bit_size,
                              uint32_t bitfield_bit_offset, bool show_types,
                              bool show_summary, bool verbose, uint32_t depth) {
   if (!IsValid())
     return;
   m_type_system->DumpValue(m_type, exe_ctx, s, format, data, data_byte_offset,
                            data_byte_size, bitfield_bit_size,
                            bitfield_bit_offset, show_types, show_summary,
                            verbose, depth);
 }
 
 bool CompilerType::DumpTypeValue(Stream *s, lldb::Format format,
-                                 const lldb_private::DataExtractor &data,
+                                 const DataExtractor &data,
                                  lldb::offset_t byte_offset, size_t byte_size,
                                  uint32_t bitfield_bit_size,
                                  uint32_t bitfield_bit_offset,
                                  ExecutionContextScope *exe_scope) {
   if (!IsValid())
     return false;
   return m_type_system->DumpTypeValue(m_type, s, format, data, byte_offset,
                                       byte_size, bitfield_bit_size,
                                       bitfield_bit_offset, exe_scope);
 }
 
 void CompilerType::DumpSummary(ExecutionContext *exe_ctx, Stream *s,
-                               const lldb_private::DataExtractor &data,
+                               const DataExtractor &data,
                                lldb::offset_t data_byte_offset,
                                size_t data_byte_size) {
   if (IsValid())
     m_type_system->DumpSummary(m_type, exe_ctx, s, data, data_byte_offset,
                                data_byte_size);
 }
 
 void CompilerType::DumpTypeDescription() const {

lldb/trunk/source/Symbol/DWARFCallFrameInfo.cpp

 //===-- DWARFCallFrameInfo.cpp ----------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 // C Includes
 // C++ Includes
 #include <list>
 
 #include "lldb/Core/ArchSpec.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Section.h"
-#include "lldb/Core/Section.h"
 #include "lldb/Core/Timer.h"
+#include "lldb/Core/dwarf.h"
 #include "lldb/Host/Host.h"
 #include "lldb/Symbol/DWARFCallFrameInfo.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/UnwindPlan.h"
 #include "lldb/Target/RegisterContext.h"
 #include "lldb/Target/Thread.h"
 #include "lldb/Utility/Log.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+//----------------------------------------------------------------------
+// GetDwarfEHPtr
+//
+// Used for calls when the value type is specified by a DWARF EH Frame
+// pointer encoding.
+//----------------------------------------------------------------------
+static uint64_t
+GetGNUEHPointer(const DataExtractor &DE, offset_t *offset_ptr,
+                uint32_t eh_ptr_enc, addr_t pc_rel_addr, addr_t text_addr,
+                addr_t data_addr) //, BSDRelocs *data_relocs) const
+{
+  if (eh_ptr_enc == DW_EH_PE_omit)
+    return ULLONG_MAX; // Value isn't in the buffer...
+
+  uint64_t baseAddress = 0;
+  uint64_t addressValue = 0;
+  const uint32_t addr_size = DE.GetAddressByteSize();
+#ifdef LLDB_CONFIGURATION_DEBUG
+  assert(addr_size == 4 || addr_size == 8);
+#endif
+
+  bool signExtendValue = false;
+  // Decode the base part or adjust our offset
+  switch (eh_ptr_enc & 0x70) {
+  case DW_EH_PE_pcrel:
+    signExtendValue = true;
+    baseAddress = *offset_ptr;
+    if (pc_rel_addr != LLDB_INVALID_ADDRESS)
+      baseAddress += pc_rel_addr;
+    //      else
+    //          Log::GlobalWarning ("PC relative pointer encoding found with
+    //          invalid pc relative address.");
+    break;
+
+  case DW_EH_PE_textrel:
+    signExtendValue = true;
+    if (text_addr != LLDB_INVALID_ADDRESS)
+      baseAddress = text_addr;
+    //      else
+    //          Log::GlobalWarning ("text relative pointer encoding being
+    //          decoded with invalid text section address, setting base address
+    //          to zero.");
+    break;
+
+  case DW_EH_PE_datarel:
+    signExtendValue = true;
+    if (data_addr != LLDB_INVALID_ADDRESS)
+      baseAddress = data_addr;
+    //      else
+    //          Log::GlobalWarning ("data relative pointer encoding being
+    //          decoded with invalid data section address, setting base address
+    //          to zero.");
+    break;
+
+  case DW_EH_PE_funcrel:
+    signExtendValue = true;
+    break;
+
+  case DW_EH_PE_aligned: {
+    // SetPointerSize should be called prior to extracting these so the
+    // pointer size is cached
+    assert(addr_size != 0);
+    if (addr_size) {
+      // Align to a address size boundary first
+      uint32_t alignOffset = *offset_ptr % addr_size;
+      if (alignOffset)
+        offset_ptr += addr_size - alignOffset;
+    }
+  } break;
+
+  default:
+    break;
+  }
+
+  // Decode the value part
+  switch (eh_ptr_enc & DW_EH_PE_MASK_ENCODING) {
+  case DW_EH_PE_absptr: {
+    addressValue = DE.GetAddress(offset_ptr);
+    //          if (data_relocs)
+    //              addressValue = data_relocs->Relocate(*offset_ptr -
+    //              addr_size, *this, addressValue);
+  } break;
+  case DW_EH_PE_uleb128:
+    addressValue = DE.GetULEB128(offset_ptr);
+    break;
+  case DW_EH_PE_udata2:
+    addressValue = DE.GetU16(offset_ptr);
+    break;
+  case DW_EH_PE_udata4:
+    addressValue = DE.GetU32(offset_ptr);
+    break;
+  case DW_EH_PE_udata8:
+    addressValue = DE.GetU64(offset_ptr);
+    break;
+  case DW_EH_PE_sleb128:
+    addressValue = DE.GetSLEB128(offset_ptr);
+    break;
+  case DW_EH_PE_sdata2:
+    addressValue = (int16_t)DE.GetU16(offset_ptr);
+    break;
+  case DW_EH_PE_sdata4:
+    addressValue = (int32_t)DE.GetU32(offset_ptr);
+    break;
+  case DW_EH_PE_sdata8:
+    addressValue = (int64_t)DE.GetU64(offset_ptr);
+    break;
+  default:
+    // Unhandled encoding type
+    assert(eh_ptr_enc);
+    break;
+  }
+
+  // Since we promote everything to 64 bit, we may need to sign extend
+  if (signExtendValue && addr_size < sizeof(baseAddress)) {
+    uint64_t sign_bit = 1ull << ((addr_size * 8ull) - 1ull);
+    if (sign_bit & addressValue) {
+      uint64_t mask = ~sign_bit + 1;
+      addressValue |= mask;
+    }
+  }
+  return baseAddress + addressValue;
+}
+
 DWARFCallFrameInfo::DWARFCallFrameInfo(ObjectFile &objfile,
                                        SectionSP &section_sp,
                                        lldb::RegisterKind reg_kind,
                                        bool is_eh_frame)
     : m_objfile(objfile), m_section_sp(section_sp),
       m_reg_kind(reg_kind), // The flavor of registers that the CFI data uses
                             // (enum RegisterKind)
       m_flags(), m_cie_map(), m_cfi_data(), m_cfi_data_initialized(false),
if (cie_sp->augmentation[0]) {
             // The address of the personality function will
             // be stored at this location.  Pre-execution, it
             // will be all zero's so don't read it until we're
             // trying to do an unwind & the reloc has been
             // resolved.
             {
               uint8_t arg_ptr_encoding = m_cfi_data.GetU8(&offset);
               const lldb::addr_t pc_rel_addr = m_section_sp->GetFileAddress();
-              cie_sp->personality_loc = m_cfi_data.GetGNUEHPointer(
-                  &offset, arg_ptr_encoding, pc_rel_addr, LLDB_INVALID_ADDRESS,
-                  LLDB_INVALID_ADDRESS);
+              cie_sp->personality_loc = GetGNUEHPointer(
+                  m_cfi_data, &offset, arg_ptr_encoding, pc_rel_addr,
+                  LLDB_INVALID_ADDRESS, LLDB_INVALID_ADDRESS);
             }
             break;
 
           case 'R':
             // A 'R' may be present at any position after the
             // first character of the string. The Augmentation
             // Data shall include a 1 byte argument that
             // represents the pointer encoding for the address
while (m_cfi_data.ValidOffsetForDataOfSize(offset, 8)) {
     }
 
     const CIE *cie = GetCIE(cie_offset);
     if (cie) {
       const lldb::addr_t pc_rel_addr = m_section_sp->GetFileAddress();
       const lldb::addr_t text_addr = LLDB_INVALID_ADDRESS;
       const lldb::addr_t data_addr = LLDB_INVALID_ADDRESS;
 
-      lldb::addr_t addr = m_cfi_data.GetGNUEHPointer(
-          &offset, cie->ptr_encoding, pc_rel_addr, text_addr, data_addr);
+      lldb::addr_t addr =
+          GetGNUEHPointer(m_cfi_data, &offset, cie->ptr_encoding, pc_rel_addr,
+                          text_addr, data_addr);
       if (clear_address_zeroth_bit)
         addr &= ~1ull;
 
-      lldb::addr_t length = m_cfi_data.GetGNUEHPointer(
-          &offset, cie->ptr_encoding & DW_EH_PE_MASK_ENCODING, pc_rel_addr,
-          text_addr, data_addr);
+      lldb::addr_t length = GetGNUEHPointer(
+          m_cfi_data, &offset, cie->ptr_encoding & DW_EH_PE_MASK_ENCODING,
+          pc_rel_addr, text_addr, data_addr);
       FDEEntryMap::Entry fde(addr, length, current_entry);
       m_fde_index.Append(fde);
     } else {
       Host::SystemLog(Host::eSystemLogError, "error: unable to find CIE at "
                                              "0x%8.8x for cie_id = 0x%8.8x for "
                                              "entry at 0x%8.8x.\n",
                       cie_offset, cie_id, current_entry);
     }
bool DWARFCallFrameInfo::FDEToUnwindPlan(dw_offset_t dwarf_offset,
   const CIE *cie = GetCIE(cie_offset);
   assert(cie != nullptr);
 
   const dw_offset_t end_offset = current_entry + length + (is_64bit ? 12 : 4);
 
   const lldb::addr_t pc_rel_addr = m_section_sp->GetFileAddress();
   const lldb::addr_t text_addr = LLDB_INVALID_ADDRESS;
   const lldb::addr_t data_addr = LLDB_INVALID_ADDRESS;
-  lldb::addr_t range_base = m_cfi_data.GetGNUEHPointer(
-      &offset, cie->ptr_encoding, pc_rel_addr, text_addr, data_addr);
-  lldb::addr_t range_len = m_cfi_data.GetGNUEHPointer(
-      &offset, cie->ptr_encoding & DW_EH_PE_MASK_ENCODING, pc_rel_addr,
+  lldb::addr_t range_base =
+      GetGNUEHPointer(m_cfi_data, &offset, cie->ptr_encoding, pc_rel_addr,
                       text_addr, data_addr);
+  lldb::addr_t range_len = GetGNUEHPointer(
+      m_cfi_data, &offset, cie->ptr_encoding & DW_EH_PE_MASK_ENCODING,
+      pc_rel_addr, text_addr, data_addr);
   AddressRange range(range_base, m_objfile.GetAddressByteSize(),
                      m_objfile.GetSectionList());
   range.SetByteSize(range_len);
 
   addr_t lsda_data_file_address = LLDB_INVALID_ADDRESS;
 
   if (cie->augmentation[0] == 'z') {
     uint32_t aug_data_len = (uint32_t)m_cfi_data.GetULEB128(&offset);
     if (aug_data_len != 0 && cie->lsda_addr_encoding != DW_EH_PE_omit) {
       offset_t saved_offset = offset;
-      lsda_data_file_address = m_cfi_data.GetGNUEHPointer(
-          &offset, cie->lsda_addr_encoding, pc_rel_addr, text_addr, data_addr);
+      lsda_data_file_address =
+          GetGNUEHPointer(m_cfi_data, &offset, cie->lsda_addr_encoding,
+                          pc_rel_addr, text_addr, data_addr);
       if (offset - saved_offset != aug_data_len) {
         // There is more in the augmentation region than we know how to process;
         // don't read anything.
         lsda_data_file_address = LLDB_INVALID_ADDRESS;
       }
       offset = saved_offset;
     }
     offset += aug_data_len;

lldb/trunk/source/Symbol/GoASTContext.cpp

 //===-- GoASTContext.cpp ----------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <mutex>
 #include <utility>
 #include <vector>
 
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/UniqueCStringMap.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/GoASTContext.h"
case eFormatUnicode16:
       byte_size = 2;
       break;
 
     case eFormatUnicode32:
       item_count = byte_size / 4;
       byte_size = 4;
       break;
     }
-    return data.Dump(s, byte_offset, format, byte_size, item_count, UINT32_MAX,
-                     LLDB_INVALID_ADDRESS, bitfield_bit_size,
-                     bitfield_bit_offset, exe_scope);
+    return DumpDataExtractor(data, s, byte_offset, format, byte_size,
+                             item_count, UINT32_MAX, LLDB_INVALID_ADDRESS,
+                             bitfield_bit_size, bitfield_bit_offset, exe_scope);
   }
   return 0;
 }
 
 void GoASTContext::DumpSummary(lldb::opaque_compiler_type_t type,
                                ExecutionContext *exe_ctx, Stream *s,
                                const DataExtractor &data,
                                lldb::offset_t data_offset,

lldb/trunk/source/Symbol/JavaASTContext.cpp

 //===-- JavaASTContext.cpp --------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include <sstream>
 
 #include "lldb/Core/ArchSpec.h"
-#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Expression/DWARFExpression.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/JavaASTContext.h"
 #include "lldb/Symbol/SymbolFile.h"

 }
 
 bool JavaASTContext::DumpTypeValue(
     lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format,
     const DataExtractor &data, lldb::offset_t data_offset,
     size_t data_byte_size, uint32_t bitfield_bit_size,
     uint32_t bitfield_bit_offset, ExecutionContextScope *exe_scope) {
   if (IsScalarType(type)) {
-    return data.Dump(s, data_offset, format, data_byte_size,
+    return DumpDataExtractor(data, s, data_offset, format, data_byte_size,
                              1, // count
-                     UINT32_MAX, LLDB_INVALID_ADDRESS, bitfield_bit_size,
-                     bitfield_bit_offset, exe_scope);
+                             UINT32_MAX, LLDB_INVALID_ADDRESS,
+                             bitfield_bit_size, bitfield_bit_offset, exe_scope);
   }
   return false;
 }
 
 void JavaASTContext::DumpTypeDescription(lldb::opaque_compiler_type_t type) {
   StreamFile s(stdout, false);
   DumpTypeDescription(type, &s);
 }

lldb/trunk/source/Symbol/OCamlASTContext.cpp

 //===-- OCamlASTContext.cpp ----------------------------------------*- C++
 //-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Symbol/OCamlASTContext.h"
+#include "lldb/Core/DumpDataExtractor.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolFile.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
bool OCamlASTContext::DumpTypeValue(
     uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
     ExecutionContextScope *exe_scope) {
   if (!type) {
     s->Printf("no type value\n");
     return false;
   }
 
   if (IsScalarType(type)) {
-    return data.Dump(s, byte_offset, format, byte_size, 1, SIZE_MAX,
-                     LLDB_INVALID_ADDRESS, bitfield_bit_size,
+    return DumpDataExtractor(data, s, byte_offset, format, byte_size, 1,
+                             SIZE_MAX, LLDB_INVALID_ADDRESS, bitfield_bit_size,
                              bitfield_bit_offset, exe_scope);
   }
 
   return false;
 }
 
 void OCamlASTContext::DumpSummary(lldb::opaque_compiler_type_t type,
                                   ExecutionContext *exe_ctx, Stream *s,
                                   const DataExtractor &data,