blob: a844493a6d67db88305dfd46e43a0ce7ce63af19 [file] [log] [blame]
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
// for details. All rights reserved. Use of this source code is governed by a
// BSD-style license that can be found in the LICENSE file.
#ifndef RUNTIME_VM_DATASTREAM_H_
#define RUNTIME_VM_DATASTREAM_H_
#include "include/dart_api.h"
#include "platform/assert.h"
#include "platform/utils.h"
#include "vm/allocation.h"
#include "vm/exceptions.h"
#include "vm/globals.h"
#include "vm/os.h"
namespace dart {
static const int8_t kDataBitsPerByte = 7;
static const int8_t kByteMask = (1 << kDataBitsPerByte) - 1;
static const int8_t kMaxUnsignedDataPerByte = kByteMask;
static const int8_t kMinDataPerByte = -(1 << (kDataBitsPerByte - 1));
static const int8_t kMaxDataPerByte = (~kMinDataPerByte & kByteMask); // NOLINT
static const uint8_t kEndByteMarker = (255 - kMaxDataPerByte);
static const uint8_t kEndUnsignedByteMarker = (255 - kMaxUnsignedDataPerByte);
typedef uint8_t* (*ReAlloc)(uint8_t* ptr, intptr_t old_size, intptr_t new_size);
typedef void (*DeAlloc)(uint8_t* ptr);
// Stream for reading various types from a buffer.
class ReadStream : public ValueObject {
public:
ReadStream(const uint8_t* buffer, intptr_t size)
: buffer_(buffer), current_(buffer), end_(buffer + size) {}
void SetStream(const uint8_t* buffer, intptr_t size) {
buffer_ = buffer;
current_ = buffer;
end_ = buffer + size;
}
template <int N, typename T>
class Raw {};
template <typename T>
class Raw<1, T> {
public:
static T Read(ReadStream* st) { return bit_cast<T>(st->ReadByte()); }
};
template <typename T>
class Raw<2, T> {
public:
static T Read(ReadStream* st) { return bit_cast<T>(st->Read16()); }
};
template <typename T>
class Raw<4, T> {
public:
static T Read(ReadStream* st) { return bit_cast<T>(st->Read32()); }
};
template <typename T>
class Raw<8, T> {
public:
static T Read(ReadStream* st) { return bit_cast<T>(st->Read64()); }
};
// Reads 'len' bytes from the stream.
void ReadBytes(uint8_t* addr, intptr_t len) {
ASSERT((end_ - current_) >= len);
if (len != 0) {
memmove(addr, current_, len);
}
current_ += len;
}
template <typename T = intptr_t>
T ReadUnsigned() {
return Read<T>(kEndUnsignedByteMarker);
}
intptr_t Position() const { return current_ - buffer_; }
void SetPosition(intptr_t value) {
ASSERT((end_ - buffer_) > value);
current_ = buffer_ + value;
}
void Align(intptr_t alignment) {
intptr_t position_before = Position();
intptr_t position_after = Utils::RoundUp(position_before, alignment);
Advance(position_after - position_before);
}
const uint8_t* AddressOfCurrentPosition() const { return current_; }
void Advance(intptr_t value) {
ASSERT((end_ - current_) >= value);
current_ = current_ + value;
}
intptr_t PendingBytes() const {
ASSERT(end_ >= current_);
return (end_ - current_);
}
template <typename T>
T Read() {
return Read<T>(kEndByteMarker);
}
uword ReadWordWith32BitReads() {
constexpr intptr_t kNumBytesPerRead32 = sizeof(uint32_t);
constexpr intptr_t kNumRead32PerWord = sizeof(uword) / kNumBytesPerRead32;
constexpr intptr_t kNumBitsPerRead32 = kNumBytesPerRead32 * kBitsPerByte;
uword value = 0;
for (intptr_t j = 0; j < kNumRead32PerWord; j++) {
const auto partial_value = Raw<kNumBytesPerRead32, uint32_t>::Read(this);
value |= (static_cast<uword>(partial_value) << (j * kNumBitsPerRead32));
}
return value;
}
private:
uint16_t Read16() { return Read16(kEndByteMarker); }
uint32_t Read32() { return Read32(kEndByteMarker); }
uint64_t Read64() { return Read64(kEndByteMarker); }
template <typename T>
T Read(uint8_t end_byte_marker) {
using Unsigned = typename std::make_unsigned<T>::type;
const uint8_t* c = current_;
ASSERT(c < end_);
Unsigned b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return b - end_byte_marker;
}
T r = 0;
uint8_t s = 0;
do {
r |= static_cast<Unsigned>(b) << s;
s += kDataBitsPerByte;
ASSERT(c < end_);
b = *c++;
} while (b <= kMaxUnsignedDataPerByte);
current_ = c;
return r | (static_cast<Unsigned>(b - end_byte_marker) << s);
}
uint16_t Read16(uint8_t end_byte_marker) {
const uint8_t* c = current_;
ASSERT(c < end_);
uint16_t b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return b - end_byte_marker;
}
uint16_t r = b;
ASSERT(c < end_);
b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return r | (static_cast<uint16_t>(b - end_byte_marker) << 7);
}
r |= b << 7;
ASSERT(c < end_);
b = *c++;
ASSERT(b > kMaxUnsignedDataPerByte);
current_ = c;
return r | (static_cast<uint16_t>(b - end_byte_marker) << 14);
}
uint32_t Read32(uint8_t end_byte_marker) {
const uint8_t* c = current_;
ASSERT(c < end_);
uint32_t b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return b - end_byte_marker;
}
uint32_t r = b;
ASSERT(c < end_);
b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return r | (static_cast<uint32_t>(b - end_byte_marker) << 7);
}
r |= b << 7;
ASSERT(c < end_);
b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return r | (static_cast<uint32_t>(b - end_byte_marker) << 14);
}
r |= b << 14;
ASSERT(c < end_);
b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return r | (static_cast<uint32_t>(b - end_byte_marker) << 21);
}
r |= b << 21;
ASSERT(c < end_);
b = *c++;
ASSERT(b > kMaxUnsignedDataPerByte);
current_ = c;
return r | (static_cast<uint32_t>(b - end_byte_marker) << 28);
}
uint64_t Read64(uint8_t end_byte_marker) {
const uint8_t* c = current_;
ASSERT(c < end_);
uint64_t b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return b - end_byte_marker;
}
uint64_t r = b;
ASSERT(c < end_);
b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return r | (static_cast<uint64_t>(b - end_byte_marker) << 7);
}
r |= b << 7;
ASSERT(c < end_);
b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return r | (static_cast<uint64_t>(b - end_byte_marker) << 14);
}
r |= b << 14;
ASSERT(c < end_);
b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return r | (static_cast<uint64_t>(b - end_byte_marker) << 21);
}
r |= b << 21;
ASSERT(c < end_);
b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return r | (static_cast<uint64_t>(b - end_byte_marker) << 28);
}
r |= b << 28;
ASSERT(c < end_);
b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return r | (static_cast<uint64_t>(b - end_byte_marker) << 35);
}
r |= b << 35;
ASSERT(c < end_);
b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return r | (static_cast<uint64_t>(b - end_byte_marker) << 42);
}
r |= b << 42;
ASSERT(c < end_);
b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return r | (static_cast<uint64_t>(b - end_byte_marker) << 49);
}
r |= b << 49;
ASSERT(c < end_);
b = *c++;
if (b > kMaxUnsignedDataPerByte) {
current_ = c;
return r | (static_cast<uint64_t>(b - end_byte_marker) << 56);
}
r |= b << 56;
ASSERT(c < end_);
b = *c++;
ASSERT(b > kMaxUnsignedDataPerByte);
current_ = c;
return r | (static_cast<uint64_t>(b - end_byte_marker) << 63);
}
uint8_t ReadByte() {
ASSERT(current_ < end_);
return *current_++;
}
private:
const uint8_t* buffer_;
const uint8_t* current_;
const uint8_t* end_;
DISALLOW_COPY_AND_ASSIGN(ReadStream);
};
// Stream for writing various types into a buffer.
class WriteStream : public ValueObject {
public:
WriteStream(uint8_t** buffer, ReAlloc alloc, intptr_t initial_size)
: buffer_(buffer),
end_(NULL),
current_(NULL),
current_size_(0),
alloc_(alloc),
initial_size_(initial_size) {
ASSERT(buffer != NULL);
ASSERT(alloc != NULL);
*buffer_ = reinterpret_cast<uint8_t*>(alloc_(NULL, 0, initial_size_));
if (*buffer_ == NULL) {
Exceptions::ThrowOOM();
}
current_ = *buffer_;
current_size_ = initial_size_;
end_ = *buffer_ + initial_size_;
}
uint8_t* buffer() const { return *buffer_; }
void set_buffer(uint8_t* value) { *buffer_ = value; }
intptr_t bytes_written() const { return current_ - *buffer_; }
intptr_t Position() const { return current_ - *buffer_; }
void SetPosition(intptr_t value) { current_ = *buffer_ + value; }
void Align(intptr_t alignment) {
intptr_t position_before = Position();
intptr_t position_after = Utils::RoundUp(position_before, alignment);
memset(current_, 0, position_after - position_before);
SetPosition(position_after);
}
template <int N, typename T>
class Raw {};
template <typename T>
class Raw<1, T> {
public:
static void Write(WriteStream* st, T value) {
st->WriteByte(bit_cast<int8_t>(value));
}
};
template <typename T>
class Raw<2, T> {
public:
static void Write(WriteStream* st, T value) {
st->Write<int16_t>(bit_cast<int16_t>(value));
}
};
template <typename T>
class Raw<4, T> {
public:
static void Write(WriteStream* st, T value) {
st->Write<int32_t>(bit_cast<int32_t>(value));
}
};
template <typename T>
class Raw<8, T> {
public:
static void Write(WriteStream* st, T value) {
st->Write<int64_t>(bit_cast<int64_t>(value));
}
};
void WriteWordWith32BitWrites(uword value) {
constexpr intptr_t kNumBytesPerWrite32 = sizeof(uint32_t);
constexpr intptr_t kNumWrite32PerWord = sizeof(uword) / kNumBytesPerWrite32;
constexpr intptr_t kNumBitsPerWrite32 = kNumBytesPerWrite32 * kBitsPerByte;
const uint32_t mask = Utils::NBitMask(kNumBitsPerWrite32);
for (intptr_t j = 0; j < kNumWrite32PerWord; j++) {
const uint32_t shifted_value = (value >> (j * kNumBitsPerWrite32));
Raw<kNumBytesPerWrite32, uint32_t>::Write(this, shifted_value & mask);
}
}
template <typename T>
void WriteUnsigned(T value) {
ASSERT(value >= 0);
while (value > kMaxUnsignedDataPerByte) {
WriteByte(static_cast<uint8_t>(value & kByteMask));
value = value >> kDataBitsPerByte;
}
WriteByte(static_cast<uint8_t>(value + kEndUnsignedByteMarker));
}
void WriteBytes(const void* addr, intptr_t len) {
if ((end_ - current_) < len) {
Resize(len);
}
ASSERT((end_ - current_) >= len);
if (len != 0) {
memmove(current_, addr, len);
}
current_ += len;
}
void WriteWord(uword value) {
const intptr_t len = sizeof(uword);
if ((end_ - current_) < len) {
Resize(len);
}
ASSERT((end_ - current_) >= len);
*reinterpret_cast<uword*>(current_) = value;
current_ += len;
}
void WriteTargetWord(uword value) {
#if defined(IS_SIMARM_X64)
RELEASE_ASSERT(Utils::IsInt(32, static_cast<word>(value)));
const intptr_t len = sizeof(uint32_t);
if ((end_ - current_) < len) {
Resize(len);
}
ASSERT((end_ - current_) >= len);
*reinterpret_cast<uint32_t*>(current_) = static_cast<uint32_t>(value);
current_ += len;
#else // defined(IS_SIMARM_X64)
WriteWord(value);
#endif // defined(IS_SIMARM_X64)
}
void Print(const char* format, ...) {
va_list args;
va_start(args, format);
VPrint(format, args);
va_end(args);
}
void VPrint(const char* format, va_list args) {
// Measure.
va_list measure_args;
va_copy(measure_args, args);
intptr_t len = Utils::VSNPrint(NULL, 0, format, measure_args);
va_end(measure_args);
// Alloc.
if ((end_ - current_) < (len + 1)) {
Resize(len + 1);
}
ASSERT((end_ - current_) >= (len + 1));
// Print.
va_list print_args;
va_copy(print_args, args);
Utils::VSNPrint(reinterpret_cast<char*>(current_), len + 1, format,
print_args);
va_end(print_args);
current_ += len; // Not len + 1 to swallow the terminating NUL.
}
template <typename T>
void Write(T value) {
T v = value;
while (v < kMinDataPerByte || v > kMaxDataPerByte) {
WriteByte(static_cast<uint8_t>(v & kByteMask));
v = v >> kDataBitsPerByte;
}
WriteByte(static_cast<uint8_t>(v + kEndByteMarker));
}
template <typename T>
void WriteFixed(T value) {
const intptr_t len = sizeof(T);
if ((end_ - current_) < len) {
Resize(len);
}
ASSERT((end_ - current_) >= len);
*reinterpret_cast<T*>(current_) = static_cast<T>(value);
current_ += len;
}
private:
DART_FORCE_INLINE void WriteByte(uint8_t value) {
if (current_ >= end_) {
Resize(1);
}
ASSERT(current_ < end_);
*current_++ = value;
}
void Resize(intptr_t size_needed) {
intptr_t position = current_ - *buffer_;
intptr_t increment_size = current_size_;
if (size_needed > increment_size) {
increment_size = Utils::RoundUp(size_needed, initial_size_);
}
intptr_t new_size = current_size_ + increment_size;
ASSERT(new_size > current_size_);
*buffer_ =
reinterpret_cast<uint8_t*>(alloc_(*buffer_, current_size_, new_size));
if (*buffer_ == NULL) {
Exceptions::ThrowOOM();
}
current_ = *buffer_ + position;
current_size_ = new_size;
end_ = *buffer_ + new_size;
ASSERT(end_ > *buffer_);
}
private:
uint8_t** const buffer_;
uint8_t* end_;
uint8_t* current_;
intptr_t current_size_;
ReAlloc alloc_;
intptr_t initial_size_;
DISALLOW_COPY_AND_ASSIGN(WriteStream);
};
class StreamingWriteStream : public ValueObject {
public:
explicit StreamingWriteStream(intptr_t initial_capacity,
Dart_StreamingWriteCallback callback,
void* callback_data);
~StreamingWriteStream();
intptr_t position() const { return flushed_size_ + (cursor_ - buffer_); }
void Align(intptr_t alignment) {
intptr_t padding = Utils::RoundUp(position(), alignment) - position();
EnsureAvailable(padding);
memset(cursor_, 0, padding);
cursor_ += padding;
}
void Print(const char* format, ...) {
va_list args;
va_start(args, format);
VPrint(format, args);
va_end(args);
}
void VPrint(const char* format, va_list args);
void WriteBytes(const uint8_t* buffer, intptr_t size) {
EnsureAvailable(size);
if (size != 0) {
memmove(cursor_, buffer, size);
}
cursor_ += size;
}
private:
void EnsureAvailable(intptr_t needed) {
intptr_t available = limit_ - cursor_;
if (available >= needed) return;
EnsureAvailableSlowPath(needed);
}
void EnsureAvailableSlowPath(intptr_t needed);
void Flush();
uint8_t* buffer_;
uint8_t* cursor_;
uint8_t* limit_;
intptr_t flushed_size_;
Dart_StreamingWriteCallback callback_;
void* callback_data_;
DISALLOW_COPY_AND_ASSIGN(StreamingWriteStream);
};
} // namespace dart
#endif // RUNTIME_VM_DATASTREAM_H_