lldb/source/Core/DataEncoder.cpp

//===-- 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(const unsigned char* ptr, unsigned offset, uint16_t value) 
{
    *(uint16_t *)(ptr + offset) = value;
}
static inline void
WriteInt32 (const unsigned char* ptr, unsigned offset, uint32_t value) 
{
    *(uint32_t *)(ptr + offset) = value;
}

static inline void
WriteInt64(const unsigned char* ptr, unsigned offset, uint64_t value) 
{
    *(uint64_t *)(ptr + offset) = value;
}

static inline void
WriteSwappedInt16(const unsigned char* ptr, unsigned offset, uint16_t value) 
{
    *(uint16_t *)(ptr + offset) = llvm::ByteSwap_16(value);
}

static inline void
WriteSwappedInt32 (const unsigned char* ptr, unsigned offset, uint32_t value) 
{
    *(uint32_t *)(ptr + offset) = llvm::ByteSwap_32(value);
}

static inline void 
WriteSwappedInt64(const 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;
}

//------------------------------------------------------------------
// Returns true if there are LENGTH bytes availabe starting OFFSET
// into the data that is in this object.
//------------------------------------------------------------------
bool
DataEncoder::ValidOffsetForDataOfSize (uint32_t offset, uint32_t length) const
{
    size_t size = GetByteSize();
    if (offset >= size)
        return false;   // offset isn't valid

    if (length == 0)
        return true;    // No bytes requested at this offset, return true

    // If we flip the bits in offset we can figure out how
    // many bytes we have left before "offset + length"
    // could overflow when doing unsigned arithmetic.
    if (length > ~offset)
        return false;   // unsigned overflow

    // Make sure "offset + length" is a valid offset as well.
    // length must be greater than zero for this to be a
    // valid expression, and we have already checked for this.
    return ((offset + length) <= size);
}

//----------------------------------------------------------------------
// 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 (const 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;
}