Merge clang, llvm, lld, lldb, compiler-rt and libc++ 5.0.0 release.

MFC r309126 (by emaste):

  Correct lld llvm-tblgen dependency file name

MFC r309169:

  Get rid of separate Subversion mergeinfo properties for llvm-dwarfdump
  and llvm-lto.  The mergeinfo confuses Subversion enormously, and these
  directories will just use the mergeinfo for llvm itself.

MFC r312765:

  Pull in r276136 from upstream llvm trunk (by Wei Mi):

    Use ValueOffsetPair to enhance value reuse during SCEV expansion.

    In D12090, the ExprValueMap was added to reuse existing value during
    SCEV expansion. However, const folding and sext/zext distribution can
    make the reuse still difficult.

    A simplified case is: suppose we know S1 expands to V1 in
    ExprValueMap, and
      S1 = S2 + C_a
      S3 = S2 + C_b
    where C_a and C_b are different SCEVConstants. Then we'd like to
    expand S3 as V1 - C_a + C_b instead of expanding S2 literally. It is
    helpful when S2 is a complex SCEV expr and S2 has no entry in
    ExprValueMap, which is usually caused by the fact that S3 is
    generated from S1 after const folding.

    In order to do that, we represent ExprValueMap as a mapping from SCEV
    to ValueOffsetPair. We will save both S1->{V1, 0} and S2->{V1, C_a}
    into the ExprValueMap when we create SCEV for V1. When S3 is
    expanded, it will first expand S2 to V1 - C_a because of S2->{V1,
    C_a} in the map, then expand S3 to V1 - C_a + C_b.

    Differential Revision: https://reviews.llvm.org/D21313

  This should fix assertion failures when building OpenCV >= 3.1.

  PR:		215649

MFC r312831:

  Revert r312765 for now, since it causes assertions when building
  lang/spidermonkey24.

  Reported by:	antoine
  PR:		215649

MFC r316511 (by jhb):

  Add an implementation of __ffssi2() derived from __ffsdi2().

  Newer versions of GCC include an __ffssi2() symbol in libgcc and the
  compiler can emit calls to it in generated code.  This is true for at
  least GCC 6.2 when compiling world for mips and mips64.

  Reviewed by:	jmallett, dim
  Sponsored by:	DARPA / AFRL
  Differential Revision:	https://reviews.freebsd.org/D10086

MFC r318601 (by adrian):

  [libcompiler-rt] add bswapdi2/bswapsi2

  This is required for mips gcc 6.3 userland to build/run.

  Reviewed by:	emaste, dim
  Approved by:	emaste
  Differential Revision:	https://reviews.freebsd.org/D10838

MFC r318884 (by emaste):

  lldb: map TRAP_CAP to a trace trap

  In the absense of a more specific handler for TRAP_CAP (generated by
  ENOTCAPABLE or ECAPMODE while in capability mode) treat it as a trace
  trap.

  Example usage (testing the bug in PR219173):

  % proccontrol -m trapcap lldb usr.bin/hexdump/obj/hexdump -- -Cv -s 1 /bin/ls
  ...
  (lldb) run
  Process 12980 launching
  Process 12980 launched: '.../usr.bin/hexdump/obj/hexdump' (x86_64)
  Process 12980 stopped
  * thread #1, stop reason = trace
      frame #0: 0x0000004b80c65f1a libc.so.7`__sys_lseek + 10
  ...

  In the future we should have LLDB control the trapcap procctl itself
  (as it does with ASLR), as well as report a specific stop reason.
  This change eliminates an assertion failure from LLDB for now.

MFC r319796:

  Remove a few unneeded files from libllvm, libclang and liblldb.

MFC r319885 (by emaste):

  lld: ELF: Fix ICF crash on absolute symbol relocations.

  If two sections contained relocations to absolute symbols with the same
  value we would crash when trying to access their sections. Add a check that
  both symbols point to sections before accessing their sections, and treat
  absolute symbols as equal if their values are equal.

  Obtained from:	LLD commit r292578

MFC r319918:

  Revert r319796 for now, it can cause undefined references when linking
  in some circumstances.

  Reported by:	Shawn Webb <shawn.webb@hardenedbsd.org>

MFC r319957 (by emaste):

  lld: Add armelf emulation mode

  Obtained from:	LLD r305375

MFC r321369:

  Upgrade our copies of clang, llvm, lld, lldb, compiler-rt and libc++ to
  5.0.0 (trunk r308421).  Upstream has branched for the 5.0.0 release,
  which should be in about a month.  Please report bugs and regressions,
  so we can get them into the release.

  Please note that from 3.5.0 onwards, clang, llvm and lldb require C++11
  support to build; see UPDATING for more information.

MFC r321420:

  Add a few more object files to liblldb, which should solve errors when
  linking the lldb executable in some cases.  In particular, when the
  -ffunction-sections -fdata-sections options are turned off, or
  ineffective.

  Reported by:	Shawn Webb, Mark Millard

MFC r321433:

  Cleanup stale Options.inc files from the previous libllvm build for
  clang 4.0.0.  Otherwise, these can get included before the two newly
  generated ones (which are different) for clang 5.0.0.

  Reported by:	Mark Millard

MFC r321439 (by bdrewery):

  Move llvm Options.inc hack from r321433 for NO_CLEAN to lib/clang/libllvm.

  The files are only ever generated to .OBJDIR, not to WORLDTMP (as a
  sysroot) and are only ever included from a compilation.  So using
  a beforebuild target here removes the file before the compilation
  tries to include it.

MFC r321664:

  Pull in r308891 from upstream llvm trunk (by Benjamin Kramer):

    [CodeGenPrepare] Cut off FindAllMemoryUses if there are too many uses.

    This avoids excessive compile time. The case I'm looking at is
    Function.cpp from an old version of LLVM that still had the giant
    memcmp string matcher in it. Before r308322 this compiled in about 2
    minutes, after it, clang takes infinite* time to compile it. With
    this patch we're at 5 min, which is still bad but this is a
    pathological case.

    The cut off at 20 uses was chosen by looking at other cut-offs in LLVM
    for user scanning. It's probably too high, but does the job and is
    very unlikely to regress anything.

    Fixes PR33900.

    * I'm impatient and aborted after 15 minutes, on the bug report it was
      killed after 2h.

  Pull in r308986 from upstream llvm trunk (by Simon Pilgrim):

    [X86][CGP] Reduce memcmp() expansion to 2 load pairs (PR33914)

    D35067/rL308322 attempted to support up to 4 load pairs for memcmp
    inlining which resulted in regressions for some optimized libc memcmp
    implementations (PR33914).

    Until we can match these more optimal cases, this patch reduces the
    memcmp expansion to a maximum of 2 load pairs (which matches what we
    do for -Os).

    This patch should be considered for the 5.0.0 release branch as well

    Differential Revision: https://reviews.llvm.org/D35830

  These fix a hang (or extremely long compile time) when building older
  LLVM ports.

  Reported by:    antoine
  PR:             219139

MFC r321719:

  Pull in r309503 from upstream clang trunk (by Richard Smith):

    PR33902: Invalidate line number cache when adding more text to
    existing buffer.

    This led to crashes as the line number cache would report a bogus
    line number for a line of code, and we'd try to find a nonexistent
    column within the line when printing diagnostics.

  This fixes an assertion when building the graphics/champlain port.

  Reported by:	antoine, kwm
  PR:		219139

MFC r321723:

  Upgrade our copies of clang, llvm, lld and lldb to r309439 from the
  upstream release_50 branch.  This is just after upstream's 5.0.0-rc1.

MFC r322320:

  Upgrade our copies of clang, llvm and libc++ to r310316 from the
  upstream release_50 branch.

MFC r322326 (by emaste):

  lldb: Make i386-*-freebsd expression work on JIT path

  * Enable i386 ABI creation for freebsd
  * Added an extra argument in ABISysV_i386::PrepareTrivialCall for mmap
    syscall
  * Unlike linux, the last argument of mmap is actually 64-bit(off_t).
    This requires us to push an additional word for the higher order bits.
  * Prior to this change, ktrace dump will show mmap failures due to
    invalid argument coming from the 6th mmap argument.

  Submitted by:	Karnajit Wangkhem
  Differential Revision:	https://reviews.llvm.org/D34776

MFC r322360 (by emaste):

  lldb: Report inferior signals as signals, not exceptions, on FreeBSD

  This is the FreeBSD equivalent of LLVM r238549.

  This serves 2 purposes:

  * LLDB should handle inferior process signals SIGSEGV/SIGILL/SIGBUS/
    SIGFPE the way it is suppose to be handled. Prior to this fix these
    signals will neither create a coredump, nor exit from the debugger
    or work for signal handling scenario.
  * eInvalidCrashReason need not report "unknown crash reason" if we have
    a valid si_signo

  llvm.org/pr23699

  Patch by Karnajit Wangkhem

  Differential Revision:  https://reviews.llvm.org/D35223

  Submitted by:	Karnajit Wangkhem
  Obtained from:	LLVM r310591

MFC r322474 (by emaste):

  lld: Add `-z muldefs` option.

  Obtained from:	LLVM r310757

MFC r322740:

  Upgrade our copies of clang, llvm, lld and libc++ to r311219 from the
  upstream release_50 branch.

MFC r322855:

  Upgrade our copies of clang, llvm, lldb and compiler-rt to r311606 from
  the upstream release_50 branch.

  As of this version, lib/msun's trig test should also work correctly
  again (see bug 220989 for more information).

  PR:		220989

MFC r323112:

  Upgrade our copies of clang, llvm, lldb and compiler-rt to r312293 from
  the upstream release_50 branch.  This corresponds to 5.0.0 rc4.

  As of this version, the cad/stepcode port should now compile in a more
  reasonable time on i386 (see bug 221836 for more information).

  PR:		221836

MFC r323245:

  Upgrade our copies of clang, llvm, lld, lldb, compiler-rt and libc++ to
  5.0.0 release (upstream r312559).

  Release notes for llvm, clang and lld will be available here soon:
  <http://releases.llvm.org/5.0.0/docs/ReleaseNotes.html>
  <http://releases.llvm.org/5.0.0/tools/clang/docs/ReleaseNotes.html>
  <http://releases.llvm.org/5.0.0/tools/lld/docs/ReleaseNotes.html>

  Relnotes:	yes

(cherry picked from commit 12cd91cf4c6b96a24427c0de5374916f2808d263)

1 files changed, 1245 insertions, 0 deletions

diff --git a/contrib/llvm/tools/lldb/source/Utility/DataExtractor.cpp b/contrib/llvm/tools/lldb/source/Utility/DataExtractor.cpp
new file mode 100644
index 0000000..008aff2
--- /dev/null
+++ b/contrib/llvm/tools/lldb/source/Utility/DataExtractor.cpp
@@ -0,0 +1,1245 @@
+//===-- DataExtractor.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/Utility/DataExtractor.h"
+
+#include "lldb/lldb-defines.h"      // for LLDB_INVALID_ADDRESS
+#include "lldb/lldb-enumerations.h" // for ByteOrder::eByteOrderBig
+#include "lldb/lldb-forward.h"      // for DataBufferSP
+#include "lldb/lldb-types.h"        // for offset_t
+
+#include "lldb/Utility/DataBuffer.h"
+#include "lldb/Utility/DataBufferHeap.h"
+#include "lldb/Utility/Endian.h"
+#include "lldb/Utility/Log.h"
+#include "lldb/Utility/Stream.h"
+#include "lldb/Utility/StreamString.h"
+#include "lldb/Utility/UUID.h"
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/ADT/SmallVector.h"
+#include "llvm/Support/MD5.h"
+#include "llvm/Support/MathExtras.h"
+
+#include <algorithm> // for min
+#include <array>     // for array
+#include <cassert>
+#include <cstdint> // for uint8_t, uint32_t, uint64_t
+#include <string>
+
+#include <ctype.h>    // for isprint
+#include <inttypes.h> // for PRIx64, PRId64
+#include <string.h>   // for memcpy, memset, memchr
+
+using namespace lldb;
+using namespace lldb_private;
+
+static inline uint16_t ReadInt16(const unsigned char *ptr, offset_t offset) {
+  uint16_t value;
+  memcpy(&value, ptr + offset, 2);
+  return value;
+}
+
+static inline uint32_t ReadInt32(const unsigned char *ptr,
+                                 offset_t offset = 0) {
+  uint32_t value;
+  memcpy(&value, ptr + offset, 4);
+  return value;
+}
+
+static inline uint64_t ReadInt64(const unsigned char *ptr,
+                                 offset_t offset = 0) {
+  uint64_t value;
+  memcpy(&value, ptr + offset, 8);
+  return value;
+}
+
+static inline uint16_t ReadInt16(const void *ptr) {
+  uint16_t value;
+  memcpy(&value, ptr, 2);
+  return value;
+}
+
+static inline uint16_t ReadSwapInt16(const unsigned char *ptr,
+                                     offset_t offset) {
+  uint16_t value;
+  memcpy(&value, ptr + offset, 2);
+  return llvm::ByteSwap_16(value);
+}
+
+static inline uint32_t ReadSwapInt32(const unsigned char *ptr,
+                                     offset_t offset) {
+  uint32_t value;
+  memcpy(&value, ptr + offset, 4);
+  return llvm::ByteSwap_32(value);
+}
+
+static inline uint64_t ReadSwapInt64(const unsigned char *ptr,
+                                     offset_t offset) {
+  uint64_t value;
+  memcpy(&value, ptr + offset, 8);
+  return llvm::ByteSwap_64(value);
+}
+
+static inline uint16_t ReadSwapInt16(const void *ptr) {
+  uint16_t value;
+  memcpy(&value, ptr, 2);
+  return llvm::ByteSwap_16(value);
+}
+
+static inline uint32_t ReadSwapInt32(const void *ptr) {
+  uint32_t value;
+  memcpy(&value, ptr, 4);
+  return llvm::ByteSwap_32(value);
+}
+
+static inline uint64_t ReadSwapInt64(const void *ptr) {
+  uint64_t value;
+  memcpy(&value, ptr, 8);
+  return llvm::ByteSwap_64(value);
+}
+
+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.
+//----------------------------------------------------------------------
+DataExtractor::DataExtractor(const void *data, offset_t length,
+                             ByteOrder endian, uint32_t addr_size,
+                             uint32_t target_byte_size /*=1*/)
+    : m_start(const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(data))),
+      m_end(const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(data)) +
+            length),
+      m_byte_order(endian), m_addr_size(addr_size), m_data_sp(),
+      m_target_byte_size(target_byte_size) {
+#ifdef LLDB_CONFIGURATION_DEBUG
+  assert(addr_size == 4 || addr_size == 8);
+#endif
+}
+
+//----------------------------------------------------------------------
+// Make a shared pointer reference to the shared data in "data_sp" and
+// set the endian swapping setting to "swap", and the address size to
+// "addr_size". The shared data reference will ensure the data lives
+// as long as any DataExtractor objects exist that have a reference to
+// this data.
+//----------------------------------------------------------------------
+DataExtractor::DataExtractor(const DataBufferSP &data_sp, ByteOrder endian,
+                             uint32_t addr_size,
+                             uint32_t target_byte_size /*=1*/)
+    : m_start(nullptr), m_end(nullptr), m_byte_order(endian),
+      m_addr_size(addr_size), m_data_sp(),
+      m_target_byte_size(target_byte_size) {
+#ifdef LLDB_CONFIGURATION_DEBUG
+  assert(addr_size == 4 || addr_size == 8);
+#endif
+  SetData(data_sp);
+}
+
+//----------------------------------------------------------------------
+// Initialize this object with a subset of the data bytes in "data".
+// If "data" contains shared data, then a reference to this shared
+// data will added and the shared data will stay around as long
+// as any object contains a reference to that data. The endian
+// swap and address size settings are copied from "data".
+//----------------------------------------------------------------------
+DataExtractor::DataExtractor(const DataExtractor &data, offset_t offset,
+                             offset_t length, uint32_t target_byte_size /*=1*/)
+    : m_start(nullptr), m_end(nullptr), m_byte_order(data.m_byte_order),
+      m_addr_size(data.m_addr_size), m_data_sp(),
+      m_target_byte_size(target_byte_size) {
+#ifdef LLDB_CONFIGURATION_DEBUG
+  assert(m_addr_size == 4 || m_addr_size == 8);
+#endif
+  if (data.ValidOffset(offset)) {
+    offset_t bytes_available = data.GetByteSize() - offset;
+    if (length > bytes_available)
+      length = bytes_available;
+    SetData(data, offset, length);
+  }
+}
+
+DataExtractor::DataExtractor(const DataExtractor &rhs)
+    : m_start(rhs.m_start), m_end(rhs.m_end), m_byte_order(rhs.m_byte_order),
+      m_addr_size(rhs.m_addr_size), m_data_sp(rhs.m_data_sp),
+      m_target_byte_size(rhs.m_target_byte_size) {
+#ifdef LLDB_CONFIGURATION_DEBUG
+  assert(m_addr_size == 4 || m_addr_size == 8);
+#endif
+}
+
+//----------------------------------------------------------------------
+// Assignment operator
+//----------------------------------------------------------------------
+const DataExtractor &DataExtractor::operator=(const DataExtractor &rhs) {
+  if (this != &rhs) {
+    m_start = rhs.m_start;
+    m_end = rhs.m_end;
+    m_byte_order = rhs.m_byte_order;
+    m_addr_size = rhs.m_addr_size;
+    m_data_sp = rhs.m_data_sp;
+  }
+  return *this;
+}
+
+DataExtractor::~DataExtractor() = default;
+
+//------------------------------------------------------------------
+// Clears the object contents back to a default invalid state, and
+// release any references to shared data that this object may
+// contain.
+//------------------------------------------------------------------
+void DataExtractor::Clear() {
+  m_start = nullptr;
+  m_end = nullptr;
+  m_byte_order = endian::InlHostByteOrder();
+  m_addr_size = sizeof(void *);
+  m_data_sp.reset();
+}
+
+//------------------------------------------------------------------
+// If this object contains shared data, this function returns the
+// offset into that shared data. Else zero is returned.
+//------------------------------------------------------------------
+size_t DataExtractor::GetSharedDataOffset() const {
+  if (m_start != nullptr) {
+    const DataBuffer *data = m_data_sp.get();
+    if (data != nullptr) {
+      const uint8_t *data_bytes = data->GetBytes();
+      if (data_bytes != nullptr) {
+        assert(m_start >= data_bytes);
+        return m_start - data_bytes;
+      }
+    }
+  }
+  return 0;
+}
+
+//----------------------------------------------------------------------
+// Set the data with which this object will extract from to data
+// starting at BYTES and set the length of the data to LENGTH bytes
+// long. The data is externally owned must be around at least as
+// long as this object points to the data. No copy of the data is
+// made, this object just refers to this data and can extract from
+// it. If this object refers to any shared data upon entry, the
+// reference to that data will be released. Is SWAP is set to true,
+// any data extracted will be endian swapped.
+//----------------------------------------------------------------------
+lldb::offset_t DataExtractor::SetData(const void *bytes, offset_t length,
+                                      ByteOrder endian) {
+  m_byte_order = endian;
+  m_data_sp.reset();
+  if (bytes == nullptr || length == 0) {
+    m_start = nullptr;
+    m_end = nullptr;
+  } else {
+    m_start = const_cast<uint8_t *>(reinterpret_cast<const uint8_t *>(bytes));
+    m_end = m_start + length;
+  }
+  return GetByteSize();
+}
+
+//----------------------------------------------------------------------
+// Assign the data for this object to be a subrange in "data"
+// starting "data_offset" bytes into "data" and ending "data_length"
+// bytes later. If "data_offset" is not a valid offset into "data",
+// then this object will contain no bytes. If "data_offset" is
+// within "data" yet "data_length" is too large, the length will be
+// capped at the number of bytes remaining in "data". If "data"
+// contains a shared pointer to other data, then a ref counted
+// pointer to that data will be made in this object. If "data"
+// doesn't contain a shared pointer to data, then the bytes referred
+// to in "data" will need to exist at least as long as this object
+// refers to those bytes. The address size and endian swap settings
+// are copied from the current values in "data".
+//----------------------------------------------------------------------
+lldb::offset_t DataExtractor::SetData(const DataExtractor &data,
+                                      offset_t data_offset,
+                                      offset_t data_length) {
+  m_addr_size = data.m_addr_size;
+#ifdef LLDB_CONFIGURATION_DEBUG
+  assert(m_addr_size == 4 || m_addr_size == 8);
+#endif
+  // If "data" contains shared pointer to data, then we can use that
+  if (data.m_data_sp) {
+    m_byte_order = data.m_byte_order;
+    return SetData(data.m_data_sp, data.GetSharedDataOffset() + data_offset,
+                   data_length);
+  }
+
+  // We have a DataExtractor object that just has a pointer to bytes
+  if (data.ValidOffset(data_offset)) {
+    if (data_length > data.GetByteSize() - data_offset)
+      data_length = data.GetByteSize() - data_offset;
+    return SetData(data.GetDataStart() + data_offset, data_length,
+                   data.GetByteOrder());
+  }
+  return 0;
+}
+
+//----------------------------------------------------------------------
+// Assign the data for this object to be a subrange of the shared
+// data in "data_sp" starting "data_offset" bytes into "data_sp"
+// and ending "data_length" bytes later. If "data_offset" is not
+// a valid offset into "data_sp", then this object will contain no
+// bytes. If "data_offset" is within "data_sp" yet "data_length" is
+// too large, the length will be capped at the number of bytes
+// remaining in "data_sp". A ref counted pointer to the data in
+// "data_sp" will be made in this object IF the number of bytes this
+// object refers to in greater than zero (if at least one byte was
+// available starting at "data_offset") to ensure the data stays
+// around as long as it is needed. The address size and endian swap
+// settings will remain unchanged from their current settings.
+//----------------------------------------------------------------------
+lldb::offset_t DataExtractor::SetData(const DataBufferSP &data_sp,
+                                      offset_t data_offset,
+                                      offset_t data_length) {
+  m_start = m_end = nullptr;
+
+  if (data_length > 0) {
+    m_data_sp = data_sp;
+    if (data_sp) {
+      const size_t data_size = data_sp->GetByteSize();
+      if (data_offset < data_size) {
+        m_start = data_sp->GetBytes() + data_offset;
+        const size_t bytes_left = data_size - data_offset;
+        // Cap the length of we asked for too many
+        if (data_length <= bytes_left)
+          m_end = m_start + data_length; // We got all the bytes we wanted
+        else
+          m_end = m_start + bytes_left; // Not all the bytes requested were
+                                        // available in the shared data
+      }
+    }
+  }
+
+  size_t new_size = GetByteSize();
+
+  // Don't hold a shared pointer to the data buffer if we don't share
+  // any valid bytes in the shared buffer.
+  if (new_size == 0)
+    m_data_sp.reset();
+
+  return new_size;
+}
+
+//----------------------------------------------------------------------
+// Extract a single unsigned char from the binary data and update
+// the offset pointed to by "offset_ptr".
+//
+// RETURNS the byte that was extracted, or zero on failure.
+//----------------------------------------------------------------------
+uint8_t DataExtractor::GetU8(offset_t *offset_ptr) const {
+  const uint8_t *data = (const uint8_t *)GetData(offset_ptr, 1);
+  if (data)
+    return *data;
+  return 0;
+}
+
+//----------------------------------------------------------------------
+// Extract "count" unsigned chars from the binary data and update the
+// offset pointed to by "offset_ptr". The extracted data is copied into
+// "dst".
+//
+// RETURNS the non-nullptr buffer pointer upon successful extraction of
+// all the requested bytes, or nullptr when the data is not available in
+// the buffer due to being out of bounds, or insufficient data.
+//----------------------------------------------------------------------
+void *DataExtractor::GetU8(offset_t *offset_ptr, void *dst,
+                           uint32_t count) const {
+  const uint8_t *data = (const uint8_t *)GetData(offset_ptr, count);
+  if (data) {
+    // Copy the data into the buffer
+    memcpy(dst, data, count);
+    // Return a non-nullptr pointer to the converted data as an indicator of
+    // success
+    return dst;
+  }
+  return nullptr;
+}
+
+//----------------------------------------------------------------------
+// Extract a single uint16_t from the data and update the offset
+// pointed to by "offset_ptr".
+//
+// RETURNS the uint16_t that was extracted, or zero on failure.
+//----------------------------------------------------------------------
+uint16_t DataExtractor::GetU16(offset_t *offset_ptr) const {
+  uint16_t val = 0;
+  const uint8_t *data = (const uint8_t *)GetData(offset_ptr, sizeof(val));
+  if (data) {
+    if (m_byte_order != endian::InlHostByteOrder())
+      val = ReadSwapInt16(data);
+    else
+      val = ReadInt16(data);
+  }
+  return val;
+}
+
+uint16_t DataExtractor::GetU16_unchecked(offset_t *offset_ptr) const {
+  uint16_t val;
+  if (m_byte_order == endian::InlHostByteOrder())
+    val = ReadInt16(m_start, *offset_ptr);
+  else
+    val = ReadSwapInt16(m_start, *offset_ptr);
+  *offset_ptr += sizeof(val);
+  return val;
+}
+
+uint32_t DataExtractor::GetU32_unchecked(offset_t *offset_ptr) const {
+  uint32_t val;
+  if (m_byte_order == endian::InlHostByteOrder())
+    val = ReadInt32(m_start, *offset_ptr);
+  else
+    val = ReadSwapInt32(m_start, *offset_ptr);
+  *offset_ptr += sizeof(val);
+  return val;
+}
+
+uint64_t DataExtractor::GetU64_unchecked(offset_t *offset_ptr) const {
+  uint64_t val;
+  if (m_byte_order == endian::InlHostByteOrder())
+    val = ReadInt64(m_start, *offset_ptr);
+  else
+    val = ReadSwapInt64(m_start, *offset_ptr);
+  *offset_ptr += sizeof(val);
+  return val;
+}
+
+//----------------------------------------------------------------------
+// Extract "count" uint16_t values from the binary data and update
+// the offset pointed to by "offset_ptr". The extracted data is
+// copied into "dst".
+//
+// RETURNS the non-nullptr buffer pointer upon successful extraction of
+// all the requested bytes, or nullptr when the data is not available
+// in the buffer due to being out of bounds, or insufficient data.
+//----------------------------------------------------------------------
+void *DataExtractor::GetU16(offset_t *offset_ptr, void *void_dst,
+                            uint32_t count) const {
+  const size_t src_size = sizeof(uint16_t) * count;
+  const uint16_t *src = (const uint16_t *)GetData(offset_ptr, src_size);
+  if (src) {
+    if (m_byte_order != endian::InlHostByteOrder()) {
+      uint16_t *dst_pos = (uint16_t *)void_dst;
+      uint16_t *dst_end = dst_pos + count;
+      const uint16_t *src_pos = src;
+      while (dst_pos < dst_end) {
+        *dst_pos = ReadSwapInt16(src_pos);
+        ++dst_pos;
+        ++src_pos;
+      }
+    } else {
+      memcpy(void_dst, src, src_size);
+    }
+    // Return a non-nullptr pointer to the converted data as an indicator of
+    // success
+    return void_dst;
+  }
+  return nullptr;
+}
+
+//----------------------------------------------------------------------
+// Extract a single uint32_t from the data and update the offset
+// pointed to by "offset_ptr".
+//
+// RETURNS the uint32_t that was extracted, or zero on failure.
+//----------------------------------------------------------------------
+uint32_t DataExtractor::GetU32(offset_t *offset_ptr) const {
+  uint32_t val = 0;
+  const uint8_t *data = (const uint8_t *)GetData(offset_ptr, sizeof(val));
+  if (data) {
+    if (m_byte_order != endian::InlHostByteOrder()) {
+      val = ReadSwapInt32(data);
+    } else {
+      memcpy(&val, data, 4);
+    }
+  }
+  return val;
+}
+
+//----------------------------------------------------------------------
+// Extract "count" uint32_t values from the binary data and update
+// the offset pointed to by "offset_ptr". The extracted data is
+// copied into "dst".
+//
+// RETURNS the non-nullptr buffer pointer upon successful extraction of
+// all the requested bytes, or nullptr when the data is not available
+// in the buffer due to being out of bounds, or insufficient data.
+//----------------------------------------------------------------------
+void *DataExtractor::GetU32(offset_t *offset_ptr, void *void_dst,
+                            uint32_t count) const {
+  const size_t src_size = sizeof(uint32_t) * count;
+  const uint32_t *src = (const uint32_t *)GetData(offset_ptr, src_size);
+  if (src) {
+    if (m_byte_order != endian::InlHostByteOrder()) {
+      uint32_t *dst_pos = (uint32_t *)void_dst;
+      uint32_t *dst_end = dst_pos + count;
+      const uint32_t *src_pos = src;
+      while (dst_pos < dst_end) {
+        *dst_pos = ReadSwapInt32(src_pos);
+        ++dst_pos;
+        ++src_pos;
+      }
+    } else {
+      memcpy(void_dst, src, src_size);
+    }
+    // Return a non-nullptr pointer to the converted data as an indicator of
+    // success
+    return void_dst;
+  }
+  return nullptr;
+}
+
+//----------------------------------------------------------------------
+// Extract a single uint64_t from the data and update the offset
+// pointed to by "offset_ptr".
+//
+// RETURNS the uint64_t that was extracted, or zero on failure.
+//----------------------------------------------------------------------
+uint64_t DataExtractor::GetU64(offset_t *offset_ptr) const {
+  uint64_t val = 0;
+  const uint8_t *data = (const uint8_t *)GetData(offset_ptr, sizeof(val));
+  if (data) {
+    if (m_byte_order != endian::InlHostByteOrder()) {
+      val = ReadSwapInt64(data);
+    } else {
+      memcpy(&val, data, 8);
+    }
+  }
+  return val;
+}
+
+//----------------------------------------------------------------------
+// GetU64
+//
+// Get multiple consecutive 64 bit values. Return true if the entire
+// read succeeds and increment the offset pointed to by offset_ptr, else
+// return false and leave the offset pointed to by offset_ptr unchanged.
+//----------------------------------------------------------------------
+void *DataExtractor::GetU64(offset_t *offset_ptr, void *void_dst,
+                            uint32_t count) const {
+  const size_t src_size = sizeof(uint64_t) * count;
+  const uint64_t *src = (const uint64_t *)GetData(offset_ptr, src_size);
+  if (src) {
+    if (m_byte_order != endian::InlHostByteOrder()) {
+      uint64_t *dst_pos = (uint64_t *)void_dst;
+      uint64_t *dst_end = dst_pos + count;
+      const uint64_t *src_pos = src;
+      while (dst_pos < dst_end) {
+        *dst_pos = ReadSwapInt64(src_pos);
+        ++dst_pos;
+        ++src_pos;
+      }
+    } else {
+      memcpy(void_dst, src, src_size);
+    }
+    // Return a non-nullptr pointer to the converted data as an indicator of
+    // success
+    return void_dst;
+  }
+  return nullptr;
+}
+
+//----------------------------------------------------------------------
+// Extract a single integer value from the data and update the offset
+// pointed to by "offset_ptr". The size of the extracted integer
+// is specified by the "byte_size" argument. "byte_size" should have
+// a value between 1 and 4 since the return value is only 32 bits
+// wide. Any "byte_size" values less than 1 or greater than 4 will
+// result in nothing being extracted, and zero being returned.
+//
+// RETURNS the integer value that was extracted, or zero on failure.
+//----------------------------------------------------------------------
+uint32_t DataExtractor::GetMaxU32(offset_t *offset_ptr,
+                                  size_t byte_size) const {
+  switch (byte_size) {
+  case 1:
+    return GetU8(offset_ptr);
+    break;
+  case 2:
+    return GetU16(offset_ptr);
+    break;
+  case 4:
+    return GetU32(offset_ptr);
+    break;
+  default:
+    assert(false && "GetMaxU32 unhandled case!");
+    break;
+  }
+  return 0;
+}
+
+//----------------------------------------------------------------------
+// Extract a single integer value from the data and update the offset
+// pointed to by "offset_ptr". The size of the extracted integer
+// is specified by the "byte_size" argument. "byte_size" should have
+// a value >= 1 and <= 8 since the return value is only 64 bits
+// wide. Any "byte_size" values less than 1 or greater than 8 will
+// result in nothing being extracted, and zero being returned.
+//
+// RETURNS the integer value that was extracted, or zero on failure.
+//----------------------------------------------------------------------
+uint64_t DataExtractor::GetMaxU64(offset_t *offset_ptr, size_t size) const {
+  switch (size) {
+  case 1:
+    return GetU8(offset_ptr);
+    break;
+  case 2:
+    return GetU16(offset_ptr);
+    break;
+  case 4:
+    return GetU32(offset_ptr);
+    break;
+  case 8:
+    return GetU64(offset_ptr);
+    break;
+  default:
+    assert(false && "GetMax64 unhandled case!");
+    break;
+  }
+  return 0;
+}
+
+uint64_t DataExtractor::GetMaxU64_unchecked(offset_t *offset_ptr,
+                                            size_t size) const {
+  switch (size) {
+  case 1:
+    return GetU8_unchecked(offset_ptr);
+    break;
+  case 2:
+    return GetU16_unchecked(offset_ptr);
+    break;
+  case 4:
+    return GetU32_unchecked(offset_ptr);
+    break;
+  case 8:
+    return GetU64_unchecked(offset_ptr);
+    break;
+  default:
+    assert(false && "GetMax64 unhandled case!");
+    break;
+  }
+  return 0;
+}
+
+int64_t DataExtractor::GetMaxS64(offset_t *offset_ptr, size_t size) const {
+  switch (size) {
+  case 1:
+    return (int8_t)GetU8(offset_ptr);
+    break;
+  case 2:
+    return (int16_t)GetU16(offset_ptr);
+    break;
+  case 4:
+    return (int32_t)GetU32(offset_ptr);
+    break;
+  case 8:
+    return (int64_t)GetU64(offset_ptr);
+    break;
+  default:
+    assert(false && "GetMax64 unhandled case!");
+    break;
+  }
+  return 0;
+}
+
+uint64_t DataExtractor::GetMaxU64Bitfield(offset_t *offset_ptr, size_t size,
+                                          uint32_t bitfield_bit_size,
+                                          uint32_t bitfield_bit_offset) const {
+  uint64_t uval64 = GetMaxU64(offset_ptr, size);
+  if (bitfield_bit_size > 0) {
+    int32_t lsbcount = bitfield_bit_offset;
+    if (m_byte_order == eByteOrderBig)
+      lsbcount = size * 8 - bitfield_bit_offset - bitfield_bit_size;
+    if (lsbcount > 0)
+      uval64 >>= lsbcount;
+    uint64_t bitfield_mask = ((1ul << bitfield_bit_size) - 1);
+    if (!bitfield_mask && bitfield_bit_offset == 0 && bitfield_bit_size == 64)
+      return uval64;
+    uval64 &= bitfield_mask;
+  }
+  return uval64;
+}
+
+int64_t DataExtractor::GetMaxS64Bitfield(offset_t *offset_ptr, size_t size,
+                                         uint32_t bitfield_bit_size,
+                                         uint32_t bitfield_bit_offset) const {
+  int64_t sval64 = GetMaxS64(offset_ptr, size);
+  if (bitfield_bit_size > 0) {
+    int32_t lsbcount = bitfield_bit_offset;
+    if (m_byte_order == eByteOrderBig)
+      lsbcount = size * 8 - bitfield_bit_offset - bitfield_bit_size;
+    if (lsbcount > 0)
+      sval64 >>= lsbcount;
+    uint64_t bitfield_mask = (((uint64_t)1) << bitfield_bit_size) - 1;
+    sval64 &= bitfield_mask;
+    // sign extend if needed
+    if (sval64 & (((uint64_t)1) << (bitfield_bit_size - 1)))
+      sval64 |= ~bitfield_mask;
+  }
+  return sval64;
+}
+
+float DataExtractor::GetFloat(offset_t *offset_ptr) const {
+  typedef float float_type;
+  float_type val = 0.0;
+  const size_t src_size = sizeof(float_type);
+  const float_type *src = (const float_type *)GetData(offset_ptr, src_size);
+  if (src) {
+    if (m_byte_order != endian::InlHostByteOrder()) {
+      const uint8_t *src_data = (const uint8_t *)src;
+      uint8_t *dst_data = (uint8_t *)&val;
+      for (size_t i = 0; i < sizeof(float_type); ++i)
+        dst_data[sizeof(float_type) - 1 - i] = src_data[i];
+    } else {
+      val = *src;
+    }
+  }
+  return val;
+}
+
+double DataExtractor::GetDouble(offset_t *offset_ptr) const {
+  typedef double float_type;
+  float_type val = 0.0;
+  const size_t src_size = sizeof(float_type);
+  const float_type *src = (const float_type *)GetData(offset_ptr, src_size);
+  if (src) {
+    if (m_byte_order != endian::InlHostByteOrder()) {
+      const uint8_t *src_data = (const uint8_t *)src;
+      uint8_t *dst_data = (uint8_t *)&val;
+      for (size_t i = 0; i < sizeof(float_type); ++i)
+        dst_data[sizeof(float_type) - 1 - i] = src_data[i];
+    } else {
+      val = *src;
+    }
+  }
+  return val;
+}
+
+long double DataExtractor::GetLongDouble(offset_t *offset_ptr) const {
+  long double val = 0.0;
+#if defined(__i386__) || defined(__amd64__) || defined(__x86_64__) ||          \
+    defined(_M_IX86) || defined(_M_IA64) || defined(_M_X64)
+  *offset_ptr += CopyByteOrderedData(*offset_ptr, 10, &val, sizeof(val),
+                                     endian::InlHostByteOrder());
+#else
+  *offset_ptr += CopyByteOrderedData(*offset_ptr, sizeof(val), &val,
+                                     sizeof(val), endian::InlHostByteOrder());
+#endif
+  return val;
+}
+
+//------------------------------------------------------------------
+// Extract a single address from the data and update the offset
+// pointed to by "offset_ptr". The size of the extracted address
+// comes from the "this->m_addr_size" member variable and should be
+// set correctly prior to extracting any address values.
+//
+// RETURNS the address that was extracted, or zero on failure.
+//------------------------------------------------------------------
+uint64_t DataExtractor::GetAddress(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);
+}
+
+uint64_t DataExtractor::GetAddress_unchecked(offset_t *offset_ptr) const {
+#ifdef LLDB_CONFIGURATION_DEBUG
+  assert(m_addr_size == 4 || m_addr_size == 8);
+#endif
+  return GetMaxU64_unchecked(offset_ptr, m_addr_size);
+}
+
+//------------------------------------------------------------------
+// Extract a single pointer from the data and update the offset
+// pointed to by "offset_ptr". The size of the extracted pointer
+// comes from the "this->m_addr_size" member variable and should be
+// set correctly prior to extracting any pointer values.
+//
+// RETURNS the pointer that was extracted, or zero on failure.
+//------------------------------------------------------------------
+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);
+}
+
+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 ||
+             length == 10 || length == 16 || length == 32);
+
+      for (uint32_t i = 0; i < length; ++i)
+        ((uint8_t *)dst)[i] = src[length - i - 1];
+    } else
+      ::memcpy(dst, src, length);
+    return length;
+  }
+  return 0;
+}
+
+// Extract data as it exists in target memory
+lldb::offset_t DataExtractor::CopyData(offset_t offset, offset_t length,
+                                       void *dst) const {
+  const uint8_t *src = PeekData(offset, length);
+  if (src) {
+    ::memcpy(dst, src, length);
+    return length;
+  }
+  return 0;
+}
+
+// Extract data and swap if needed when doing the copy
+lldb::offset_t
+DataExtractor::CopyByteOrderedData(offset_t src_offset, offset_t src_len,
+                                   void *dst_void_ptr, offset_t dst_len,
+                                   ByteOrder dst_byte_order) const {
+  // Validate the source info
+  if (!ValidOffsetForDataOfSize(src_offset, src_len))
+    assert(ValidOffsetForDataOfSize(src_offset, src_len));
+  assert(src_len > 0);
+  assert(m_byte_order == eByteOrderBig || m_byte_order == eByteOrderLittle);
+
+  // Validate the destination info
+  assert(dst_void_ptr != nullptr);
+  assert(dst_len > 0);
+  assert(dst_byte_order == eByteOrderBig || dst_byte_order == eByteOrderLittle);
+
+  // Validate that only a word- or register-sized dst is byte swapped
+  assert(dst_byte_order == m_byte_order || dst_len == 1 || dst_len == 2 ||
+         dst_len == 4 || dst_len == 8 || dst_len == 10 || dst_len == 16 ||
+         dst_len == 32);
+
+  // Must have valid byte orders set in this object and for destination
+  if (!(dst_byte_order == eByteOrderBig ||
+        dst_byte_order == eByteOrderLittle) ||
+      !(m_byte_order == eByteOrderBig || m_byte_order == eByteOrderLittle))
+    return 0;
+
+  uint8_t *dst = (uint8_t *)dst_void_ptr;
+  const uint8_t *src = (const uint8_t *)PeekData(src_offset, src_len);
+  if (src) {
+    if (dst_len >= src_len) {
+      // We are copying the entire value from src into dst.
+      // Calculate how many, if any, zeroes we need for the most
+      // significant bytes if "dst_len" is greater than "src_len"...
+      const size_t num_zeroes = dst_len - src_len;
+      if (dst_byte_order == eByteOrderBig) {
+        // Big endian, so we lead with zeroes...
+        if (num_zeroes > 0)
+          ::memset(dst, 0, num_zeroes);
+        // Then either copy or swap the rest
+        if (m_byte_order == eByteOrderBig) {
+          ::memcpy(dst + num_zeroes, src, src_len);
+        } else {
+          for (uint32_t i = 0; i < src_len; ++i)
+            dst[i + num_zeroes] = src[src_len - 1 - i];
+        }
+      } else {
+        // Little endian destination, so we lead the value bytes
+        if (m_byte_order == eByteOrderBig) {
+          for (uint32_t i = 0; i < src_len; ++i)
+            dst[i] = src[src_len - 1 - i];
+        } else {
+          ::memcpy(dst, src, src_len);
+        }
+        // And zero the rest...
+        if (num_zeroes > 0)
+          ::memset(dst + src_len, 0, num_zeroes);
+      }
+      return src_len;
+    } else {
+      // We are only copying some of the value from src into dst..
+
+      if (dst_byte_order == eByteOrderBig) {
+        // Big endian dst
+        if (m_byte_order == eByteOrderBig) {
+          // Big endian dst, with big endian src
+          ::memcpy(dst, src + (src_len - dst_len), dst_len);
+        } else {
+          // Big endian dst, with little endian src
+          for (uint32_t i = 0; i < dst_len; ++i)
+            dst[i] = src[dst_len - 1 - i];
+        }
+      } else {
+        // Little endian dst
+        if (m_byte_order == eByteOrderBig) {
+          // Little endian dst, with big endian src
+          for (uint32_t i = 0; i < dst_len; ++i)
+            dst[i] = src[src_len - 1 - i];
+        } else {
+          // Little endian dst, with big endian src
+          ::memcpy(dst, src, dst_len);
+        }
+      }
+      return dst_len;
+    }
+  }
+  return 0;
+}
+
+//----------------------------------------------------------------------
+// Extracts a variable length NULL terminated C string from
+// the data at the offset pointed to by "offset_ptr".  The
+// "offset_ptr" will be updated with the offset of the byte that
+// follows the NULL terminator byte.
+//
+// If the offset pointed to by "offset_ptr" is out of bounds, or if
+// "length" is non-zero and there aren't enough available
+// bytes, nullptr will be returned and "offset_ptr" will not be
+// updated.
+//----------------------------------------------------------------------
+const char *DataExtractor::GetCStr(offset_t *offset_ptr) const {
+  const char *cstr = (const char *)PeekData(*offset_ptr, 1);
+  if (cstr) {
+    const char *cstr_end = cstr;
+    const char *end = (const char *)m_end;
+    while (cstr_end < end && *cstr_end)
+      ++cstr_end;
+
+    // Now we are either at the end of the data or we point to the
+    // NULL C string terminator with cstr_end...
+    if (*cstr_end == '\0') {
+      // Advance the offset with one extra byte for the NULL terminator
+      *offset_ptr += (cstr_end - cstr + 1);
+      return cstr;
+    }
+
+    // We reached the end of the data without finding a NULL C string
+    // terminator. Fall through and return nullptr otherwise anyone that
+    // would have used the result as a C string can wander into
+    // unknown memory...
+  }
+  return nullptr;
+}
+
+//----------------------------------------------------------------------
+// Extracts a NULL terminated C string from the fixed length field of
+// length "len" at the offset pointed to by "offset_ptr".
+// The "offset_ptr" will be updated with the offset of the byte that
+// follows the fixed length field.
+//
+// If the offset pointed to by "offset_ptr" is out of bounds, or if
+// the offset plus the length of the field is out of bounds, or if the
+// field does not contain a NULL terminator byte, nullptr will be returned
+// and "offset_ptr" will not be updated.
+//----------------------------------------------------------------------
+const char *DataExtractor::GetCStr(offset_t *offset_ptr, offset_t len) const {
+  const char *cstr = (const char *)PeekData(*offset_ptr, len);
+  if (cstr != nullptr) {
+    if (memchr(cstr, '\0', len) == nullptr) {
+      return nullptr;
+    }
+    *offset_ptr += len;
+    return cstr;
+  }
+  return nullptr;
+}
+
+//------------------------------------------------------------------
+// Peeks at a string in the contained data. No verification is done
+// to make sure the entire string lies within the bounds of this
+// object's data, only "offset" is verified to be a valid offset.
+//
+// Returns a valid C string pointer if "offset" is a valid offset in
+// this object's data, else nullptr is returned.
+//------------------------------------------------------------------
+const char *DataExtractor::PeekCStr(offset_t offset) const {
+  return (const char *)PeekData(offset, 1);
+}
+
+//----------------------------------------------------------------------
+// Extracts an unsigned LEB128 number from this object's data
+// starting at the offset pointed to by "offset_ptr". The offset
+// pointed to by "offset_ptr" will be updated with the offset of the
+// byte following the last extracted byte.
+//
+// Returned the extracted integer value.
+//----------------------------------------------------------------------
+uint64_t DataExtractor::GetULEB128(offset_t *offset_ptr) const {
+  const uint8_t *src = (const uint8_t *)PeekData(*offset_ptr, 1);
+  if (src == nullptr)
+    return 0;
+
+  const uint8_t *end = m_end;
+
+  if (src < end) {
+    uint64_t result = *src++;
+    if (result >= 0x80) {
+      result &= 0x7f;
+      int shift = 7;
+      while (src < end) {
+        uint8_t byte = *src++;
+        result |= (uint64_t)(byte & 0x7f) << shift;
+        if ((byte & 0x80) == 0)
+          break;
+        shift += 7;
+      }
+    }
+    *offset_ptr = src - m_start;
+    return result;
+  }
+
+  return 0;
+}
+
+//----------------------------------------------------------------------
+// Extracts an signed LEB128 number from this object's data
+// starting at the offset pointed to by "offset_ptr". The offset
+// pointed to by "offset_ptr" will be updated with the offset of the
+// byte following the last extracted byte.
+//
+// Returned the extracted integer value.
+//----------------------------------------------------------------------
+int64_t DataExtractor::GetSLEB128(offset_t *offset_ptr) const {
+  const uint8_t *src = (const uint8_t *)PeekData(*offset_ptr, 1);
+  if (src == nullptr)
+    return 0;
+
+  const uint8_t *end = m_end;
+
+  if (src < end) {
+    int64_t result = 0;
+    int shift = 0;
+    int size = sizeof(int64_t) * 8;
+
+    uint8_t byte = 0;
+    int bytecount = 0;
+
+    while (src < end) {
+      bytecount++;
+      byte = *src++;
+      result |= (int64_t)(byte & 0x7f) << shift;
+      shift += 7;
+      if ((byte & 0x80) == 0)
+        break;
+    }
+
+    // Sign bit of byte is 2nd high order bit (0x40)
+    if (shift < size && (byte & 0x40))
+      result |= -(1 << shift);
+
+    *offset_ptr += bytecount;
+    return result;
+  }
+  return 0;
+}
+
+//----------------------------------------------------------------------
+// Skips a ULEB128 number (signed or unsigned) from this object's
+// data starting at the offset pointed to by "offset_ptr". The
+// offset pointed to by "offset_ptr" will be updated with the offset
+// of the byte following the last extracted byte.
+//
+// Returns the number of bytes consumed during the extraction.
+//----------------------------------------------------------------------
+uint32_t DataExtractor::Skip_LEB128(offset_t *offset_ptr) const {
+  uint32_t bytes_consumed = 0;
+  const uint8_t *src = (const uint8_t *)PeekData(*offset_ptr, 1);
+  if (src == nullptr)
+    return 0;
+
+  const uint8_t *end = m_end;
+
+  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;
+}
+
+//----------------------------------------------------------------------
+// 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
+// string. If "type_format" is nullptr, then an appropriate format
+// string will be used for the supplied "type". If the stream "s"
+// is nullptr, then the output will be send to Log().
+//----------------------------------------------------------------------
+lldb::offset_t DataExtractor::PutToLog(Log *log, offset_t start_offset,
+                                       offset_t length, uint64_t base_addr,
+                                       uint32_t num_per_line,
+                                       DataExtractor::Type type,
+                                       const char *format) const {
+  if (log == nullptr)
+    return start_offset;
+
+  offset_t offset;
+  offset_t end_offset;
+  uint32_t count;
+  StreamString sstr;
+  for (offset = start_offset, end_offset = offset + length, count = 0;
+       ValidOffset(offset) && offset < end_offset; ++count) {
+    if ((count % num_per_line) == 0) {
+      // Print out any previous string
+      if (sstr.GetSize() > 0) {
+        log->PutString(sstr.GetString());
+        sstr.Clear();
+      }
+      // Reset string offset and fill the current line string with address:
+      if (base_addr != LLDB_INVALID_ADDRESS)
+        sstr.Printf("0x%8.8" PRIx64 ":",
+                    (uint64_t)(base_addr + (offset - start_offset)));
+    }
+
+    switch (type) {
+    case TypeUInt8:
+      sstr.Printf(format ? format : " %2.2x", GetU8(&offset));
+      break;
+    case TypeChar: {
+      char ch = GetU8(&offset);
+      sstr.Printf(format ? format : " %c", isprint(ch) ? ch : ' ');
+    } break;
+    case TypeUInt16:
+      sstr.Printf(format ? format : " %4.4x", GetU16(&offset));
+      break;
+    case TypeUInt32:
+      sstr.Printf(format ? format : " %8.8x", GetU32(&offset));
+      break;
+    case TypeUInt64:
+      sstr.Printf(format ? format : " %16.16" PRIx64, GetU64(&offset));
+      break;
+    case TypePointer:
+      sstr.Printf(format ? format : " 0x%" PRIx64, GetAddress(&offset));
+      break;
+    case TypeULEB128:
+      sstr.Printf(format ? format : " 0x%" PRIx64, GetULEB128(&offset));
+      break;
+    case TypeSLEB128:
+      sstr.Printf(format ? format : " %" PRId64, GetSLEB128(&offset));
+      break;
+    }
+  }
+
+  if (!sstr.Empty())
+    log->PutString(sstr.GetString());
+
+  return offset; // Return the offset at which we ended up
+}
+
+//----------------------------------------------------------------------
+// DumpUUID
+//
+// Dump out a UUID starting at 'offset' bytes into the buffer
+//----------------------------------------------------------------------
+void DataExtractor::DumpUUID(Stream *s, offset_t offset) const {
+  if (s) {
+    const uint8_t *uuid_data = PeekData(offset, 16);
+    if (uuid_data) {
+      lldb_private::UUID uuid(uuid_data, 16);
+      uuid.Dump(s);
+    } else {
+      s->Printf("<not enough data for UUID at offset 0x%8.8" PRIx64 ">",
+                offset);
+    }
+  }
+}
+
+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)));
+  }
+  return GetByteSize();
+}
+
+bool DataExtractor::Append(DataExtractor &rhs) {
+  if (rhs.GetByteOrder() != GetByteOrder())
+    return false;
+
+  if (rhs.GetByteSize() == 0)
+    return true;
+
+  if (GetByteSize() == 0)
+    return (rhs.Copy(*this) > 0);
+
+  size_t bytes = GetByteSize() + rhs.GetByteSize();
+
+  DataBufferHeap *buffer_heap_ptr = nullptr;
+  DataBufferSP buffer_sp(buffer_heap_ptr = new DataBufferHeap(bytes, 0));
+
+  if (!buffer_sp || buffer_heap_ptr == nullptr)
+    return false;
+
+  uint8_t *bytes_ptr = buffer_heap_ptr->GetBytes();
+
+  memcpy(bytes_ptr, GetDataStart(), GetByteSize());
+  memcpy(bytes_ptr + GetByteSize(), rhs.GetDataStart(), rhs.GetByteSize());
+
+  SetData(buffer_sp);
+
+  return true;
+}
+
+bool DataExtractor::Append(void *buf, offset_t length) {
+  if (buf == nullptr)
+    return false;
+
+  if (length == 0)
+    return true;
+
+  size_t bytes = GetByteSize() + length;
+
+  DataBufferHeap *buffer_heap_ptr = nullptr;
+  DataBufferSP buffer_sp(buffer_heap_ptr = new DataBufferHeap(bytes, 0));
+
+  if (!buffer_sp || buffer_heap_ptr == nullptr)
+    return false;
+
+  uint8_t *bytes_ptr = buffer_heap_ptr->GetBytes();
+
+  if (GetByteSize() > 0)
+    memcpy(bytes_ptr, GetDataStart(), GetByteSize());
+
+  memcpy(bytes_ptr + GetByteSize(), buf, length);
+
+  SetData(buffer_sp);
+
+  return true;
+}
+
+void DataExtractor::Checksum(llvm::SmallVectorImpl<uint8_t> &dest,
+                             uint64_t max_data) {
+  if (max_data == 0)
+    max_data = GetByteSize();
+  else
+    max_data = std::min(max_data, GetByteSize());
+
+  llvm::MD5 md5;
+
+  const llvm::ArrayRef<uint8_t> data(GetDataStart(), max_data);
+  md5.update(data);
+
+  llvm::MD5::MD5Result result;
+  md5.final(result);
+
+  dest.clear();
+  dest.append(result.Bytes.begin(), result.Bytes.end());
+}