text: //===-- DataEncoder.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/DataEncoder.h"
  
  #include <assert.h>
  #include <stddef.h>
  
  #include "llvm/Support/MathExtras.h"
  
  #include "lldb/Core/DataBuffer.h"
  #include "lldb/Host/Endian.h"
  
  using namespace lldb;
  using namespace lldb_private;
  
  static inline void
  WriteInt16(unsigned char* ptr, unsigned offset, uint16_t value)
  {
      *(uint16_t *)(ptr + offset) = value;
  }
  static inline void
  WriteInt32 (unsigned char* ptr, unsigned offset, uint32_t value)
  {
      *(uint32_t *)(ptr + offset) = value;
  }
  
  static inline void
  WriteInt64(unsigned char* ptr, unsigned offset, uint64_t value)
  {
      *(uint64_t *)(ptr + offset) = value;
  }
  
  static inline void
  WriteSwappedInt16(unsigned char* ptr, unsigned offset, uint16_t value)
  {
      *(uint16_t *)(ptr + offset) = llvm::ByteSwap_16(value);
  }
  
  static inline void
  WriteSwappedInt32 (unsigned char* ptr, unsigned offset, uint32_t value)
  {
      *(uint32_t *)(ptr + offset) = llvm::ByteSwap_32(value);
  }
  
  static inline void 
  WriteSwappedInt64(unsigned char* ptr, unsigned offset, uint64_t value)
  {
      *(uint64_t *)(ptr + offset) = llvm::ByteSwap_64(value);
  }
  
  //----------------------------------------------------------------------
  // Default constructor.
  //----------------------------------------------------------------------
  DataEncoder::DataEncoder () :
      m_start     (NULL),
      m_end       (NULL),
      m_byte_order(lldb::endian::InlHostByteOrder()),
      m_addr_size (sizeof(void*)),
      m_data_sp   ()
  {
  }
  
  //----------------------------------------------------------------------
  // 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.
  //----------------------------------------------------------------------
  DataEncoder::DataEncoder (void* data, uint32_t length, ByteOrder endian, uint8_t addr_size) :
      m_start     ((uint8_t*)data),
      m_end       ((uint8_t*)data + length),
      m_byte_order(endian),
      m_addr_size (addr_size),
      m_data_sp   ()
  {
  }
  
  //----------------------------------------------------------------------
  // 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 DataEncoder objects exist that have a reference to
  // this data.
  //----------------------------------------------------------------------
  DataEncoder::DataEncoder (const DataBufferSP& data_sp, ByteOrder endian, uint8_t addr_size) :
      m_start     (NULL),
      m_end       (NULL),
      m_byte_order(endian),
      m_addr_size (addr_size),
      m_data_sp   ()
  {
      SetData (data_sp);
  }
  
  //----------------------------------------------------------------------
  // Destructor
  //----------------------------------------------------------------------
  DataEncoder::~DataEncoder ()
  {
  }
  
  //------------------------------------------------------------------
  // Clears the object contents back to a default invalid state, and
  // release any references to shared data that this object may
  // contain.
  //------------------------------------------------------------------
  void
  DataEncoder::Clear ()
  {
      m_start = NULL;
      m_end = NULL;
      m_byte_order = lldb::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
  DataEncoder::GetSharedDataOffset () const
  {
      if (m_start != NULL)
      {
          const DataBuffer * data = m_data_sp.get();
          if (data != NULL)
          {
              const uint8_t * data_bytes = data->GetBytes();
              if (data_bytes != NULL)
              {
                  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.
  //----------------------------------------------------------------------
  uint32_t
  DataEncoder::SetData (void *bytes, uint32_t length, ByteOrder endian)
  {
      m_byte_order = endian;
      m_data_sp.reset();
      if (bytes == NULL || length == 0)
      {
          m_start = NULL;
          m_end = NULL;
      }
      else
      {
          m_start = (uint8_t *)bytes;
          m_end = m_start + length;
      }
      return GetByteSize();
  }
  
  //----------------------------------------------------------------------
  // 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.
  //----------------------------------------------------------------------
  uint32_t
  DataEncoder::SetData (const DataBufferSP& data_sp, uint32_t data_offset, uint32_t data_length)
  {
      m_start = m_end = NULL;
  
      if (data_length > 0)
      {
          m_data_sp = data_sp;
          if (data_sp.get())
          {
              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
              }
          }
      }
  
      uint32_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.
  //----------------------------------------------------------------------
  uint32_t
  DataEncoder::PutU8 (uint32_t offset, uint8_t value)
  {
      if (ValidOffset(offset))
      {
          m_start[offset] = value;
          return offset + 1;
      }
      return UINT32_MAX;
  }
  
  uint32_t
  DataEncoder::PutU16 (uint32_t offset, uint16_t value)
  {
      if (ValidOffsetForDataOfSize(offset, sizeof(value)))
      {
          if (m_byte_order != lldb::endian::InlHostByteOrder())
              WriteSwappedInt16 (m_start, offset, value);
          else
              WriteInt16 (m_start, offset, value);
  
          return offset + sizeof (value);
      }
      return UINT32_MAX;
  }
  
  uint32_t
  DataEncoder::PutU32 (uint32_t offset, uint32_t value)
  {
      if (ValidOffsetForDataOfSize(offset, sizeof(value)))
      {
          if (m_byte_order != lldb::endian::InlHostByteOrder())
              WriteSwappedInt32 (m_start, offset, value);
          else
              WriteInt32 (m_start, offset, value);
          
          return offset + sizeof (value);
      }
      return UINT32_MAX;
  }
  
  uint32_t
  DataEncoder::PutU64 (uint32_t offset, uint64_t value)
  {
      if (ValidOffsetForDataOfSize(offset, sizeof(value)))
      {
          if (m_byte_order != lldb::endian::InlHostByteOrder())
              WriteSwappedInt64 (m_start, offset, value);
          else
              WriteInt64 (m_start, offset, value);
          
          return offset + sizeof (value);
      }
      return UINT32_MAX;
  }
  
  //----------------------------------------------------------------------
  // 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.
  //----------------------------------------------------------------------
  uint32_t
  DataEncoder::PutMaxU64 (uint32_t offset, uint32_t byte_size, uint64_t value)
  {
      switch (byte_size)
      {
      case 1: return PutU8 (offset, value);
      case 2: return PutU16(offset, value);
      case 4: return PutU32(offset, value);
      case 8: return PutU64(offset, value);
      default:
          assert(!"GetMax64 unhandled case!");
          break;
      }
      return UINT32_MAX;
  }
  
  uint32_t
  DataEncoder::PutData (uint32_t offset, const void *src, uint32_t src_len)
  {
      if (src == NULL || src_len == 0)
          return offset;
  
      if (ValidOffsetForDataOfSize(offset, src_len))
      {
          memcpy (m_start + offset, src, src_len);
          return offset + src_len;
      }
      return UINT32_MAX;
  }
  
  uint32_t
  DataEncoder::PutAddress (uint32_t offset, lldb::addr_t addr)
  {
      return PutMaxU64 (offset, GetAddressByteSize(), addr);
  }
  
  uint32_t
  DataEncoder::PutCString (uint32_t offset, const char *cstr)
  {
      if (cstr)
          return PutData (offset, cstr, strlen(cstr) + 1);
      return UINT32_MAX;
  }
  