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/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();
 
   //------------------------------------------------------------------
   /// 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/include/lldb/Core/DataExtractorEx.h

+//===-- DataExtractorEx.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_DATAEXTRACTOREX_H
+#define LLDB_CORE_DATAEXTRACTOREX_H
+
+// Project includes
+#include "lldb/Core/DataExtractor.h"
+
+namespace lldb_private {
+  class ExecutionContextScope;
+  class Stream;
+
+  class DataExtractorEx : public DataExtractor {
+  public:
+    DataExtractorEx();
+
+    DataExtractorEx(const void *data, lldb::offset_t data_length,
+      lldb::ByteOrder byte_order, uint32_t addr_size,
+      uint32_t target_byte_size = 1);
+
+    DataExtractorEx(const lldb::DataBufferSP &data_sp, lldb::ByteOrder byte_order,
+      uint32_t addr_size, uint32_t target_byte_size = 1);
+
+    DataExtractorEx(const DataExtractor &data, lldb::offset_t offset,
+      lldb::offset_t length, uint32_t target_byte_size = 1);
+
+    DataExtractorEx(const DataExtractorEx &rhs);
+    const DataExtractorEx &operator=(const DataExtractorEx &rhs);
+    ~DataExtractorEx();
+
+    //------------------------------------------------------------------
+    /// 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);
+
+    //------------------------------------------------------------------
+    /// 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;
+
+    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
+  };
+}
+
+#endif

lldb/include/lldb/Symbol/ClangASTContext.h

 #include "lldb/lldb-enumerations.h"
 
 class DWARFASTParserClang;
 class PDBASTParser;
 
 namespace lldb_private {
 
 class Declaration;
+class DataExtractorEx;
 
 class ClangASTContext : public TypeSystem {
 public:
   typedef void (*CompleteTagDeclCallback)(void *baton, clang::TagDecl *);
   typedef void (*CompleteObjCInterfaceDeclCallback)(void *baton,
                                                     clang::ObjCInterfaceDecl *);
 
   //------------------------------------------------------------------
#define LLDB_INVALID_DECL_LEVEL UINT32_MAX
   size_t ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
                                    const char *s, uint8_t *dst,
                                    size_t dst_size) override;
 
   //----------------------------------------------------------------------
   // Dumping types
   //----------------------------------------------------------------------
   void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
-                 Stream *s, lldb::Format format, const DataExtractor &data,
+                 Stream *s, lldb::Format format, const DataExtractorEx &data,
                  lldb::offset_t data_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) override;
 
   bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
-                     lldb::Format format, const DataExtractor &data,
+                     lldb::Format format, const DataExtractorEx &data,
                      lldb::offset_t data_offset, size_t data_byte_size,
                      uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
                      ExecutionContextScope *exe_scope) override;
 
   void DumpSummary(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
                    Stream *s, const DataExtractor &data,
                    lldb::offset_t data_offset, size_t data_byte_size) override;
 

lldb/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;
+  class DataExtractorEx;
+
 //----------------------------------------------------------------------
 // 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
public:
   // point bytes in the "dst" buffer.
   size_t ConvertStringToFloatValue(const char *s, uint8_t *dst,
                                    size_t dst_size) const;
 
   //----------------------------------------------------------------------
   // Dumping types
   //----------------------------------------------------------------------
   void DumpValue(ExecutionContext *exe_ctx, Stream *s, lldb::Format format,
-                 const DataExtractor &data, lldb::offset_t data_offset,
+                 const DataExtractorEx &data, lldb::offset_t data_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);
 
-  bool DumpTypeValue(Stream *s, lldb::Format format, const DataExtractor &data,
+  bool DumpTypeValue(Stream *s, lldb::Format format, const DataExtractorEx &data,
                      lldb::offset_t data_offset, size_t data_byte_size,
                      uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
                      ExecutionContextScope *exe_scope);
 
   void DumpSummary(ExecutionContext *exe_ctx, Stream *s,
-                   const DataExtractor &data, lldb::offset_t data_offset,
+                   const DataExtractorEx &data, lldb::offset_t data_offset,
                    size_t data_byte_size);
 
   void DumpTypeDescription() const; // Dump to stdout
 
   void DumpTypeDescription(Stream *s) const;
 
   bool GetValueAsScalar(const DataExtractor &data, lldb::offset_t data_offset,
                         size_t data_byte_size, Scalar &value) const;

lldb/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/Core/DataExtractorEx.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"
bool HandleCommonDwarfOpcode(uint8_t primary_opcode, uint8_t extended_opcode,
                                UnwindPlan::Row &row);
 
   ObjectFile &m_objfile;
   lldb::SectionSP m_section_sp;
   lldb::RegisterKind m_reg_kind;
   Flags m_flags;
   cie_map_t m_cie_map;
 
-  DataExtractor m_cfi_data;
+  DataExtractorEx m_cfi_data;
   bool m_cfi_data_initialized; // only copy the section into the DE once
 
   FDEEntryMap m_fde_index;
   bool m_fde_index_initialized; // only scan the section for FDEs once
   std::mutex m_fde_index_mutex; // and isolate the thread that does it
 
   bool m_is_eh_frame;
 
   CIESP
   ParseCIE(const uint32_t cie_offset);
 };
 
 } // namespace lldb_private
 
 #endif // liblldb_DWARFCallFrameInfo_h_

lldb/include/lldb/Symbol/GoASTContext.h

CompilerType GetTemplateArgument(lldb::opaque_compiler_type_t type,
                                    lldb::TemplateArgumentKind &kind) override {
     return CompilerType();
   }
 
   //----------------------------------------------------------------------
   // Dumping types
   //----------------------------------------------------------------------
   void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
-                 Stream *s, lldb::Format format, const DataExtractor &data,
+                 Stream *s, lldb::Format format, const DataExtractorEx &data,
                  lldb::offset_t data_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) override;
 
   bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
-                     lldb::Format format, const DataExtractor &data,
+                     lldb::Format format, const DataExtractorEx &data,
                      lldb::offset_t data_offset, size_t data_byte_size,
                      uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
                      ExecutionContextScope *exe_scope) override;
 
   void DumpTypeDescription(
       lldb::opaque_compiler_type_t type) override; // Dump to stdout
 
   void DumpTypeDescription(lldb::opaque_compiler_type_t type,

lldb/include/lldb/Symbol/JavaASTContext.h

 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Symbol/TypeSystem.h"
 #include "lldb/Utility/ConstString.h"
 
 namespace lldb_private {
 
+  class DataExtractorEx;
+
 class JavaASTContext : public TypeSystem {
 public:
   class JavaType;
   typedef std::map<ConstString, std::unique_ptr<JavaType>> JavaTypeMap;
 
   JavaASTContext(const ArchSpec &arch);
   ~JavaASTContext() override;
 
CompilerType GetVirtualBaseClassAtIndex(lldb::opaque_compiler_type_t type,
                                           size_t idx,
                                           uint32_t *bit_offset_ptr) override;
 
   size_t ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
                                    const char *s, uint8_t *dst,
                                    size_t dst_size) override;
 
   void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
-                 Stream *s, lldb::Format format, const DataExtractor &data,
+                 Stream *s, lldb::Format format, const DataExtractorEx &data,
                  lldb::offset_t data_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) override;
 
   bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
-                     lldb::Format format, const DataExtractor &data,
+                     lldb::Format format, const DataExtractorEx &data,
                      lldb::offset_t data_offset, size_t data_byte_size,
                      uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
                      ExecutionContextScope *exe_scope) override;
 
   void DumpTypeDescription(lldb::opaque_compiler_type_t type) override;
 
   void DumpTypeDescription(lldb::opaque_compiler_type_t type,
                            Stream *s) override;

lldb/include/lldb/Symbol/OCamlASTContext.h

public:
 
   CompilerType GetTemplateArgument(lldb::opaque_compiler_type_t type,
                                    size_t idx,
                                    lldb::TemplateArgumentKind &kind) override {
     return CompilerType();
   }
 
   void DumpValue(lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx,
-                 Stream *s, lldb::Format format, const DataExtractor &data,
+                 Stream *s, lldb::Format format, const DataExtractorEx &data,
                  lldb::offset_t data_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) override;
 
   bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
-                     lldb::Format format, const DataExtractor &data,
+                     lldb::Format format, const DataExtractorEx &data,
                      lldb::offset_t data_offset, size_t data_byte_size,
                      uint32_t bitfield_bit_size, uint32_t bitfield_bit_offset,
                      ExecutionContextScope *exe_scope) override;
 
   void DumpTypeDescription(lldb::opaque_compiler_type_t type) override;
 
   void DumpTypeDescription(lldb::opaque_compiler_type_t type,
                            Stream *s) override;

lldb/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 {
+  class DataExtractorEx;
 
 //----------------------------------------------------------------------
 // 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) {}
public:
 
   lldb::TypeSP GetTypedefType();
 
   const ConstString &GetName() const { return m_name; }
 
   ConstString GetQualifiedName();
 
   void DumpValue(ExecutionContext *exe_ctx, Stream *s,
-                 const DataExtractor &data, uint32_t data_offset,
+                 const DataExtractorEx &data, uint32_t data_offset,
                  bool show_type, bool show_summary, bool verbose,
                  lldb::Format format = lldb::eFormatDefault);
 
   bool DumpValueInMemory(ExecutionContext *exe_ctx, Stream *s,
                          lldb::addr_t address, AddressType address_type,
                          bool show_types, bool show_summary, bool verbose);
 
   bool ReadFromMemory(ExecutionContext *exe_ctx, lldb::addr_t address,

lldb/include/lldb/Symbol/TypeSystem.h

 #include "lldb/Symbol/CompilerDeclContext.h"
 #include "lldb/lldb-private.h"
 
 class DWARFDIE;
 class DWARFASTParser;
 
 namespace lldb_private {
 
+  class DataExtractorEx;
+
 //----------------------------------------------------------------------
 // Interface for representing the Type Systems in different languages.
 //----------------------------------------------------------------------
 class TypeSystem : public PluginInterface {
 public:
   //----------------------------------------------------------------------
   // Intrusive type system that allows us to use llvm casting.
   //
GetTemplateArgument(lldb::opaque_compiler_type_t type, size_t idx,
                       lldb::TemplateArgumentKind &kind) = 0;
 
   //----------------------------------------------------------------------
   // Dumping types
   //----------------------------------------------------------------------
 
   virtual void DumpValue(lldb::opaque_compiler_type_t type,
                          ExecutionContext *exe_ctx, Stream *s,
-                         lldb::Format format, const DataExtractor &data,
+                         lldb::Format format, const DataExtractorEx &data,
                          lldb::offset_t data_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) = 0;
 
   virtual bool DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
-                             lldb::Format format, const DataExtractor &data,
+                             lldb::Format format, const DataExtractorEx &data,
                              lldb::offset_t data_offset, size_t data_byte_size,
                              uint32_t bitfield_bit_size,
                              uint32_t bitfield_bit_offset,
                              ExecutionContextScope *exe_scope) = 0;
 
   virtual void
   DumpTypeDescription(lldb::opaque_compiler_type_t type) = 0; // Dump to stdout
 

lldb/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/DataExtractorEx.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,
+    auto Ex = std::static_pointer_cast<DataExtractorEx>(m_opaque_sp);
+    Ex->Dump(&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,
log->Printf("SBData::ReadRawData (error=%p,offset=%" PRIu64
                 static_cast<void *>(ok));
   return ok ? size : 0;
 }
 
 void SBData::SetData(lldb::SBError &error, const void *buf, size_t size,
                      lldb::ByteOrder endian, uint8_t addr_size) {
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_API));
   if (!m_opaque_sp.get())
-    m_opaque_sp.reset(new DataExtractor(buf, size, endian, addr_size));
+    m_opaque_sp.reset(new DataExtractorEx(buf, size, endian, addr_size));
   else
   {
     m_opaque_sp->SetData(buf, size, endian);
     m_opaque_sp->SetAddressByteSize(addr_size);
   }
 
   if (log)
     log->Printf("SBData::SetData (error=%p,buf=%p,size=%" PRIu64
bool SBData::SetDataFromCString(const char *data) {
   }
 
   size_t data_len = strlen(data);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(data, data_len));
 
   if (!m_opaque_sp.get())
     m_opaque_sp.reset(
-        new DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()));
+        new DataExtractorEx(buffer_sp, GetByteOrder(), GetAddressByteSize()));
   else
     m_opaque_sp->SetData(buffer_sp);
 
   if (log)
     log->Printf("SBData::SetDataFromCString (data=%p) => true",
                 static_cast<const void *>(data));
 
   return true;
bool SBData::SetDataFromUInt64Array(uint64_t *array, size_t array_len) {
   }
 
   size_t data_len = array_len * sizeof(uint64_t);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 
   if (!m_opaque_sp.get())
     m_opaque_sp.reset(
-        new DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()));
+        new DataExtractorEx(buffer_sp, GetByteOrder(), GetAddressByteSize()));
   else
     m_opaque_sp->SetData(buffer_sp);
 
   if (log)
     log->Printf("SBData::SetDataFromUInt64Array (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
bool SBData::SetDataFromUInt32Array(uint32_t *array, size_t array_len) {
   }
 
   size_t data_len = array_len * sizeof(uint32_t);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 
   if (!m_opaque_sp.get())
     m_opaque_sp.reset(
-        new DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()));
+        new DataExtractorEx(buffer_sp, GetByteOrder(), GetAddressByteSize()));
   else
     m_opaque_sp->SetData(buffer_sp);
 
   if (log)
     log->Printf("SBData::SetDataFromUInt32Array (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
bool SBData::SetDataFromSInt64Array(int64_t *array, size_t array_len) {
   }
 
   size_t data_len = array_len * sizeof(int64_t);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 
   if (!m_opaque_sp.get())
     m_opaque_sp.reset(
-        new DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()));
+        new DataExtractorEx(buffer_sp, GetByteOrder(), GetAddressByteSize()));
   else
     m_opaque_sp->SetData(buffer_sp);
 
   if (log)
     log->Printf("SBData::SetDataFromSInt64Array (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
bool SBData::SetDataFromSInt32Array(int32_t *array, size_t array_len) {
   }
 
   size_t data_len = array_len * sizeof(int32_t);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 
   if (!m_opaque_sp.get())
     m_opaque_sp.reset(
-        new DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()));
+        new DataExtractorEx(buffer_sp, GetByteOrder(), GetAddressByteSize()));
   else
     m_opaque_sp->SetData(buffer_sp);
 
   if (log)
     log->Printf("SBData::SetDataFromSInt32Array (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
bool SBData::SetDataFromDoubleArray(double *array, size_t array_len) {
   }
 
   size_t data_len = array_len * sizeof(double);
 
   lldb::DataBufferSP buffer_sp(new DataBufferHeap(array, data_len));
 
   if (!m_opaque_sp.get())
     m_opaque_sp.reset(
-        new DataExtractor(buffer_sp, GetByteOrder(), GetAddressByteSize()));
+        new DataExtractorEx(buffer_sp, GetByteOrder(), GetAddressByteSize()));
   else
     m_opaque_sp->SetData(buffer_sp);
 
   if (log)
     log->Printf("SBData::SetDataFromDoubleArray (array=%p, array_len = %" PRIu64
                 ") => "
                 "true",
                 static_cast<void *>(array), static_cast<uint64_t>(array_len));
 
   return true;
 }

lldb/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/DataExtractorEx.h"
 #include "lldb/Core/Debugger.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"
if (clang_ast_type.GetOpaqueQualType()) {
           result.SetStatus(eReturnStatusFailed);
           return false;
         }
       }
       return true;
     }
 
     result.SetStatus(eReturnStatusSuccessFinishResult);
-    DataExtractor data(data_sp, target->GetArchitecture().GetByteOrder(),
+    DataExtractorEx data(data_sp, target->GetArchitecture().GetByteOrder(),
                        target->GetArchitecture().GetAddressByteSize(),
                        target->GetArchitecture().GetDataByteSize());
 
     Format format = m_format_options.GetFormat();
     if (((format == eFormatChar) || (format == eFormatCharPrintable)) &&
         (item_byte_size != 1)) {
       // if a count was not passed, or it is 1
       if (!m_format_options.GetCountValue().OptionWasSet() || item_count == 1) {
while (count) {
       result.AppendMessageWithFormat("data found at location: 0x%" PRIx64 "\n",
                                      found_location);
 
       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(),
+        DataExtractorEx 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);
         result.GetOutputStream().EOL();
       }

lldb/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/DataExtractorEx.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,
   if (exe_scope == nullptr || byte_size == 0)
     return 0;
   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);
+      DataExtractorEx data(&buf.front(), buf.size(), byte_order, addr_size);
 
       data.Dump(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
static size_t ReadCStringFromMemory(ExecutionContextScope *exe_scope,
                                     const Address &address, Stream *strm) {
   if (exe_scope == nullptr)
     return 0;
   const size_t k_buf_len = 256;
   char buf[k_buf_len + 1];
   buf[k_buf_len] = '\0'; // NULL terminate
 
   // Byte order and address size don't matter for C string dumping..
-  DataExtractor data(buf, sizeof(buf), endian::InlHostByteOrder(), 4);
+  DataExtractorEx data(buf, sizeof(buf), endian::InlHostByteOrder(), 4);
   size_t total_len = 0;
   size_t bytes_read;
   Address curr_address(address);
   strm->PutChar('"');
   while ((bytes_read = ReadBytes(exe_scope, curr_address, buf, k_buf_len)) >
          0) {
     size_t len = strlen(buf);
     if (len == 0)

lldb/source/Core/CMakeLists.txt

 add_lldb_library(lldbCore
   Address.cpp
   AddressRange.cpp
   AddressResolver.cpp
   AddressResolverFileLine.cpp
   AddressResolverName.cpp
   ArchSpec.cpp
   Baton.cpp
   Broadcaster.cpp
   Communication.cpp
   Connection.cpp
   DataBufferHeap.cpp
   DataBufferLLVM.cpp
   DataEncoder.cpp
   DataExtractor.cpp
+  DataExtractorEx.cpp
   Debugger.cpp
   Disassembler.cpp
   DynamicLoader.cpp
   EmulateInstruction.cpp
   Event.cpp
   FastDemangle.cpp
   FileLineResolver.cpp
   FileSpecList.cpp

lldb/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/source/Core/DataExtractorEx.cpp

+//===-- DataExtractorEx.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/DataExtractorEx.h"
+#include "lldb/Core/Disassembler.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/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 DataExtractorEx &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 DataExtractorEx &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;
+}
+
+DataExtractorEx::DataExtractorEx() {
+
+}
+
+DataExtractorEx::DataExtractorEx(const void *Data, offset_t Length,
+  ByteOrder BO, uint32_t AddrSize, uint32_t TargetByteSize) : DataExtractor(Data, Length, BO, AddrSize, TargetByteSize) {
+
+}
+
+DataExtractorEx::DataExtractorEx(const lldb::DataBufferSP &Data, ByteOrder BO,
+  uint32_t AddrSize, uint32_t TargetByteSize) : DataExtractor(Data, BO, AddrSize, TargetByteSize) {
+
+}
+
+DataExtractorEx::DataExtractorEx(const DataExtractor &Extractor, offset_t Offset,
+  offset_t Length, uint32_t TargetByteSize) : DataExtractor(Extractor, Offset, Length, TargetByteSize) {
+
+}
+
+DataExtractorEx::DataExtractorEx(const DataExtractorEx &rhs) : DataExtractor(rhs) {
+
+}
+
+DataExtractorEx::~DataExtractorEx() {
+
+}
+
+//----------------------------------------------------------------------
+// GetDwarfEHPtr
+//
+// Used for calls when the value type is specified by a DWARF EH Frame
+// pointer encoding.
+//----------------------------------------------------------------------
+uint64_t DataExtractorEx::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;
+}
+
+lldb::offset_t DataExtractorEx::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
+}
+
+void DataExtractorEx::DumpHexBytes(Stream *s, const void *src, size_t src_len,
+  uint32_t bytes_per_line, addr_t base_addr) {
+  DataExtractorEx 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
+}

lldb/source/Core/Event.cpp

 //===-- Event.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 <algorithm>
 
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/Broadcaster.h"
-#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/DataExtractorEx.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;
+    DataExtractorEx 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);
   }
 }
 
 const void *EventDataBytes::GetBytes() const {
   return (m_bytes.empty() ? nullptr : m_bytes.data());

lldb/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/DataExtractorEx.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;
 using namespace lldb_private;
 
 bool RegisterValue::Dump(Stream *s, const RegisterInfo *reg_info,
                          bool prefix_with_name, bool prefix_with_alt_name,
                          Format format,
                          uint32_t reg_name_right_align_at) const {
-  DataExtractor data;
+  DataExtractorEx data;
   if (GetData(data)) {
     bool name_printed = false;
     // For simplicity, alignment of the register name printing applies only
     // in the most common case where:
     //
     //     prefix_with_name^prefix_with_alt_name is true
     //
     StreamString format_string;

lldb/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/DataExtractorEx.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"
 

 bool TypeFormatImpl_Format::FormatObject(ValueObject *valobj,
                                          std::string &dest) const {
   if (!valobj)
     return false;
   if (valobj->CanProvideValue()) {
     Value &value(valobj->GetValue());
     const Value::ContextType context_type = value.GetContextType();
     ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
-    DataExtractor data;
+    DataExtractorEx data;
 
     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;
for (lldb::TypeSP type_sp : types.Types()) {
         m_types.emplace(valobj_key, valobj_enum_type);
         break;
       }
     }
   } else
     valobj_enum_type = iter->second;
   if (valobj_enum_type.IsValid() == false)
     return false;
-  DataExtractor data;
+  DataExtractorEx data;
   Error error;
   valobj->GetData(data, error);
   if (error.Fail())
     return false;
   ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
   StreamString sstr;
   valobj_enum_type.DumpTypeValue(&sstr, lldb::eFormatEnum, data, 0,
                                  data.GetByteSize(), 0, 0,

lldb/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/DataExtractorEx.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"
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(),
+        DataExtractorEx extractor(data.GetBytes(), data.GetByteSize(),
                                 map.GetByteOrder(), map.GetAddressByteSize());
 
         extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
                                data.GetByteSize(), 16, load_addr);
 
         dump_stream.PutChar('\n');
       }
     }
dump_stream.Printf("0x%" PRIx64 ": EntityPersistentVariable (%s)\n",
         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(),
+          DataExtractorEx extractor(data.GetBytes(), data.GetByteSize(),
                                   map.GetByteOrder(), map.GetAddressByteSize());
 
           extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
                                  data.GetByteSize(), 16, target_address);
 
           dump_stream.PutChar('\n');
         }
       }
lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
 
       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(),
+        DataExtractorEx extractor(data.GetBytes(), data.GetByteSize(),
                                 map.GetByteOrder(), map.GetAddressByteSize());
 
         extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
                                data.GetByteSize(), 16, load_addr);
 
         lldb::offset_t offset;
 
         ptr = extractor.GetPointer(&offset);
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(),
+        DataExtractorEx extractor(data.GetBytes(), data.GetByteSize(),
                                 map.GetByteOrder(), map.GetAddressByteSize());
 
         extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
                                data.GetByteSize(), 16, load_addr);
 
         dump_stream.PutChar('\n');
       }
     }
lldb::addr_t ptr = LLDB_INVALID_ADDRESS;
 
       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(),
+        DataExtractorEx extractor(data.GetBytes(), data.GetByteSize(),
                                 map.GetByteOrder(), map.GetAddressByteSize());
 
         extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
                                data.GetByteSize(), 16, load_addr);
 
         lldb::offset_t offset;
 
         ptr = extractor.GetPointer(&offset);
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(),
+        DataExtractorEx extractor(data.GetBytes(), data.GetByteSize(),
                                 map.GetByteOrder(), map.GetAddressByteSize());
 
         extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
                                data.GetByteSize(), 16, load_addr);
 
         dump_stream.PutChar('\n');
       }
     }
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(),
+        DataExtractorEx extractor(data.GetBytes(), data.GetByteSize(),
                                 map.GetByteOrder(), map.GetAddressByteSize());
 
         extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
                                data.GetByteSize(), 16, load_addr);
 
         dump_stream.PutChar('\n');
       }
     }
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(),
+        DataExtractorEx extractor(data.GetBytes(), data.GetByteSize(),
                                 map.GetByteOrder(), map.GetAddressByteSize());
 
         extractor.DumpHexBytes(&dump_stream, data.GetBytes(),
                                data.GetByteSize(), 16, load_addr);
 
         dump_stream.PutChar('\n');
       }
     }

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

 // Other libraries and framework includes
 #include "llvm/ADT/StringSwitch.h"
 
 // Project includes
 #include "RenderScriptRuntime.h"
 #include "RenderScriptScriptGroup.h"
 
 #include "lldb/Breakpoint/StoppointCallbackContext.h"
+#include "lldb/Core/DataExtractorEx.h"
 #include "lldb/Core/Debugger.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"
bool RenderScriptRuntime::DumpAllocation(Stream &strm, StackFrame *frame_ptr,
   dim_y = dim_y == 0 ? 1 : dim_y;
 
   uint32_t dim_z = alloc->dimension.get()->dim_3;
   dim_z = dim_z == 0 ? 1 : dim_z;
 
   // Use data extractor to format output
   const uint32_t target_ptr_size =
       GetProcess()->GetTarget().GetArchitecture().GetAddressByteSize();
-  DataExtractor alloc_data(buffer.get(), size, GetProcess()->GetByteOrder(),
+  DataExtractorEx alloc_data(buffer.get(), size, GetProcess()->GetByteOrder(),
                            target_ptr_size);
 
   uint32_t offset = 0;   // Offset in buffer to next element to be printed
   uint32_t prev_row = 0; // Offset to the start of the previous row
 
   // Iterate over allocation dimensions, printing results to user
   strm.Printf("Data (X, Y, Z):");
   for (uint32_t z = 0; z < dim_z; ++z) {

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

 //===-- DWARFDataExtractor.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_DWARFDataExtractor_h_
 #define liblldb_DWARFDataExtractor_h_
 
 // Other libraries and framework includes.
-#include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/DataExtractorEx.h"
 #include "lldb/Core/dwarf.h"
 
 namespace lldb_private {
 
-class DWARFDataExtractor : public lldb_private::DataExtractor {
+class DWARFDataExtractor : public lldb_private::DataExtractorEx {
 public:
-  DWARFDataExtractor() : DataExtractor(), m_is_dwarf64(false) {}
+  DWARFDataExtractor() : DataExtractorEx(), m_is_dwarf64(false) {}
 
   DWARFDataExtractor(const DWARFDataExtractor &data, lldb::offset_t offset,
                      lldb::offset_t length)
-      : DataExtractor(data, offset, length), m_is_dwarf64(false) {}
+      : DataExtractorEx(data, offset, length), m_is_dwarf64(false) {}
 
   uint64_t GetDWARFInitialLength(lldb::offset_t *offset_ptr) const;
 
   dw_offset_t GetDWARFOffset(lldb::offset_t *offset_ptr) const;
 
   size_t GetDWARFSizeofInitialLength() const { return m_is_dwarf64 ? 12 : 4; }
 
   bool IsDWARF64() const { return m_is_dwarf64; }
 
 protected:
   mutable bool m_is_dwarf64;
 };
 }
 
 #endif // liblldb_DWARFDataExtractor_h_

lldb/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/DataExtractorEx.h"
 #include "lldb/Core/Disassembler.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"
if (baton && dst && dst_len)
     return ((UnwindAssemblyInstEmulation *)baton)
         ->WriteMemory(instruction, context, addr, dst, dst_len);
   return 0;
 }
 
 size_t UnwindAssemblyInstEmulation::WriteMemory(
     EmulateInstruction *instruction, const EmulateInstruction::Context &context,
     lldb::addr_t addr, const void *dst, size_t dst_len) {
-  DataExtractor data(dst, dst_len,
+  DataExtractorEx data(dst, dst_len,
                      instruction->GetArchitecture().GetByteOrder(),
                      instruction->GetArchitecture().GetAddressByteSize());
 
   Log *log(GetLogIfAllCategoriesSet(LIBLLDB_LOG_UNWIND));
 
   if (log && log->GetVerbose()) {
     StreamString strm;
 

lldb/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/DataExtractorEx.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 lldb_private::DataExtractorEx &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()) {
default:
     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,
+    const lldb_private::DataExtractorEx &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));
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(),
+        lldb_private::DataExtractorEx cstr_data(&buf.front(), buf.size(),
                                               process->GetByteOrder(), 4);
         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());

lldb/source/Symbol/CompilerType.cpp

 //===-- CompilerType.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/CompilerType.h"
 
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/DataExtractorEx.h"
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Core/StreamFile.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/ClangExternalASTSourceCommon.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Process.h"

 
 //----------------------------------------------------------------------
 // Dumping types
 //----------------------------------------------------------------------
 #define DEPTH_INCREMENT 2
 
 void CompilerType::DumpValue(ExecutionContext *exe_ctx, Stream *s,
                              lldb::Format format,
-                             const lldb_private::DataExtractor &data,
+                             const lldb_private::DataExtractorEx &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 lldb_private::DataExtractorEx &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 lldb_private::DataExtractorEx &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/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/DataExtractorEx.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"

 }
 //----------------------------------------------------------------------
 // Dumping types
 //----------------------------------------------------------------------
 #define DEPTH_INCREMENT 2
 
 void GoASTContext::DumpValue(lldb::opaque_compiler_type_t type,
                              ExecutionContext *exe_ctx, Stream *s,
-                             lldb::Format format, const DataExtractor &data,
+                             lldb::Format format, const DataExtractorEx &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 (IsTypedefType(type))
     type = GetTypedefedType(type).GetOpaqueQualType();
   if (!type)
     return;
if (element_idx > 0)
       s->Printf("\n%*s}", depth, "");
   }
 
   if (show_summary)
     DumpSummary(type, exe_ctx, s, data, data_byte_offset, data_byte_size);
 }
 
 bool GoASTContext::DumpTypeValue(lldb::opaque_compiler_type_t type, Stream *s,
-                                 lldb::Format format, const DataExtractor &data,
+                                 lldb::Format format, const DataExtractorEx &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;

lldb/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/DataExtractorEx.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"
if (JavaObjectType *obj =
     GetCompleteType(type);
     return obj->GetInterfaceAtIndex(idx);
   }
   return CompilerType();
 }
 
 void JavaASTContext::DumpValue(
     lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s,
-    lldb::Format format, const DataExtractor &data, lldb::offset_t data_offset,
+    lldb::Format format, const DataExtractorEx &data, lldb::offset_t data_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) {
   assert(false && "Not implemented");
 }
 
 bool JavaASTContext::DumpTypeValue(
     lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format,
-    const DataExtractor &data, lldb::offset_t data_offset,
+    const DataExtractorEx &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,
                      1, // count
                      UINT32_MAX, LLDB_INVALID_ADDRESS, bitfield_bit_size,
                      bitfield_bit_offset, exe_scope);
   }

lldb/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/DataExtractorEx.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"
OCamlASTContext::ConvertStringToFloatValue(lldb::opaque_compiler_type_t type,
   return 0;
 }
 //----------------------------------------------------------------------
 // Dumping types
 //----------------------------------------------------------------------
 
 void OCamlASTContext::DumpValue(
     lldb::opaque_compiler_type_t type, ExecutionContext *exe_ctx, Stream *s,
-    lldb::Format format, const DataExtractor &data,
+    lldb::Format format, const DataExtractorEx &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) {
     s->Printf("no type\n");
     return;
   }
 
   s->Printf("no value\n");
 
   if (show_summary)
     DumpSummary(type, exe_ctx, s, data, data_byte_offset, data_byte_size);
 }
 
 bool OCamlASTContext::DumpTypeValue(
     lldb::opaque_compiler_type_t type, Stream *s, lldb::Format format,
-    const DataExtractor &data, lldb::offset_t byte_offset, size_t byte_size,
+    const DataExtractorEx &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) {
     s->Printf("no type value\n");
     return false;
   }
 
   if (IsScalarType(type)) {

lldb/source/Symbol/Type.cpp

 // C Includes
 #include <stdio.h>
 
 // C++ Includes
 // Other libraries and framework includes
 // Project includes
 #include "lldb/Core/DataBufferHeap.h"
 #include "lldb/Core/DataExtractor.h"
+#include "lldb/Core/DataExtractorEx.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Utility/StreamString.h"
 
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/ObjectFile.h"
 #include "lldb/Symbol/SymbolContextScope.h"
 #include "lldb/Symbol/SymbolFile.h"
const ConstString &Type::GetName() {
   if (!m_name)
     m_name = GetForwardCompilerType().GetConstTypeName();
   return m_name;
 }
 
 void Type::DumpTypeName(Stream *s) { GetName().Dump(s, "<invalid-type-name>"); }
 
 void Type::DumpValue(ExecutionContext *exe_ctx, Stream *s,
-                     const DataExtractor &data, uint32_t data_byte_offset,
+                     const DataExtractorEx &data, uint32_t data_byte_offset,
                      bool show_types, bool show_summary, bool verbose,
                      lldb::Format format) {
   if (ResolveClangType(eResolveStateForward)) {
     if (show_types) {
       s->PutChar('(');
       if (verbose)
         s->Printf("Type{0x%8.8" PRIx64 "} ", GetID());
       DumpTypeName(s);
lldb::Encoding Type::GetEncoding(uint64_t &count) {
   // Make sure we resolve our type if it already hasn't been.
   return GetForwardCompilerType().GetEncoding(count);
 }
 
 bool Type::DumpValueInMemory(ExecutionContext *exe_ctx, Stream *s,
                              lldb::addr_t address, AddressType address_type,
                              bool show_types, bool show_summary, bool verbose) {
   if (address != LLDB_INVALID_ADDRESS) {
-    DataExtractor data;
+    DataExtractorEx data;
     Target *target = nullptr;
     if (exe_ctx)
       target = exe_ctx->GetTargetPtr();
     if (target)
       data.SetByteOrder(target->GetArchitecture().GetByteOrder());
     if (ReadFromMemory(exe_ctx, address, address_type, data)) {
       DumpValue(exe_ctx, s, data, 0, show_types, show_summary, verbose);
       return true;