ArgumentEncoder.cpp [plain text]
#include "config.h"
#include "ArgumentEncoder.h"
#include "DataReference.h"
#include <algorithm>
#include <stdio.h>
#if OS(DARWIN)
#include <sys/mman.h>
#endif
namespace IPC {
template <typename T>
static inline bool allocBuffer(T*& buffer, size_t size)
{
#if OS(DARWIN)
buffer = static_cast<T*>(mmap(0, size, PROT_READ | PROT_WRITE, MAP_ANON | MAP_PRIVATE, -1, 0));
return buffer != MAP_FAILED;
#else
buffer = static_cast<T*>(fastMalloc(size));
return !!buffer;
#endif
}
static inline void freeBuffer(void* addr, size_t size)
{
#if OS(DARWIN)
munmap(addr, size);
#else
UNUSED_PARAM(size);
fastFree(addr);
#endif
}
ArgumentEncoder::ArgumentEncoder()
: m_buffer(m_inlineBuffer)
, m_bufferPointer(m_inlineBuffer)
, m_bufferSize(0)
, m_bufferCapacity(sizeof(m_inlineBuffer))
{
}
ArgumentEncoder::~ArgumentEncoder()
{
if (m_buffer != m_inlineBuffer)
freeBuffer(m_buffer, m_bufferCapacity);
}
static inline size_t roundUpToAlignment(size_t value, unsigned alignment)
{
return ((value + alignment - 1) / alignment) * alignment;
}
void ArgumentEncoder::reserve(size_t size)
{
if (size <= m_bufferCapacity)
return;
size_t newCapacity = roundUpToAlignment(m_bufferCapacity * 2, 4096);
while (newCapacity < size)
newCapacity *= 2;
uint8_t* newBuffer;
if (!allocBuffer(newBuffer, newCapacity))
CRASH();
memcpy(newBuffer, m_buffer, m_bufferSize);
if (m_buffer != m_inlineBuffer)
freeBuffer(m_buffer, m_bufferCapacity);
m_buffer = newBuffer;
m_bufferCapacity = newCapacity;
}
uint8_t* ArgumentEncoder::grow(unsigned alignment, size_t size)
{
size_t alignedSize = roundUpToAlignment(m_bufferSize, alignment);
reserve(alignedSize + size);
m_bufferSize = alignedSize + size;
m_bufferPointer = m_buffer + alignedSize + size;
return m_buffer + alignedSize;
}
void ArgumentEncoder::encodeFixedLengthData(const uint8_t* data, size_t size, unsigned alignment)
{
ASSERT(!(reinterpret_cast<uintptr_t>(data) % alignment));
uint8_t* buffer = grow(alignment, size);
memcpy(buffer, data, size);
}
void ArgumentEncoder::encodeVariableLengthByteArray(const DataReference& dataReference)
{
encode(static_cast<uint64_t>(dataReference.size()));
encodeFixedLengthData(dataReference.data(), dataReference.size(), 1);
}
template<typename Type>
static void copyValueToBuffer(Type value, uint8_t* bufferPosition)
{
memcpy(bufferPosition, &value, sizeof(Type));
}
void ArgumentEncoder::encode(bool n)
{
uint8_t* buffer = grow(sizeof(n), sizeof(n));
copyValueToBuffer(n, buffer);
}
void ArgumentEncoder::encode(uint8_t n)
{
uint8_t* buffer = grow(sizeof(n), sizeof(n));
copyValueToBuffer(n, buffer);
}
void ArgumentEncoder::encode(uint16_t n)
{
uint8_t* buffer = grow(sizeof(n), sizeof(n));
copyValueToBuffer(n, buffer);
}
void ArgumentEncoder::encode(uint32_t n)
{
uint8_t* buffer = grow(sizeof(n), sizeof(n));
copyValueToBuffer(n, buffer);
}
void ArgumentEncoder::encode(uint64_t n)
{
uint8_t* buffer = grow(sizeof(n), sizeof(n));
copyValueToBuffer(n, buffer);
}
void ArgumentEncoder::encode(int32_t n)
{
uint8_t* buffer = grow(sizeof(n), sizeof(n));
copyValueToBuffer(n, buffer);
}
void ArgumentEncoder::encode(int64_t n)
{
uint8_t* buffer = grow(sizeof(n), sizeof(n));
copyValueToBuffer(n, buffer);
}
void ArgumentEncoder::encode(float n)
{
uint8_t* buffer = grow(sizeof(n), sizeof(n));
copyValueToBuffer(n, buffer);
}
void ArgumentEncoder::encode(double n)
{
uint8_t* buffer = grow(sizeof(n), sizeof(n));
copyValueToBuffer(n, buffer);
}
void ArgumentEncoder::addAttachment(Attachment&& attachment)
{
m_attachments.append(WTF::move(attachment));
}
Vector<Attachment> ArgumentEncoder::releaseAttachments()
{
return WTF::move(m_attachments);
}
}