dart::BaseWriteStream Class Reference

#include <datastream.h>

Inheritance diagram for dart::BaseWriteStream:

Classes
class	Raw
class	Raw< 1, T >
class	Raw< 2, T >
class	Raw< 4, T >
class	Raw< 8, T >

Public Member Functions
	BaseWriteStream (intptr_t initial_size)
virtual	~BaseWriteStream ()
DART_FORCE_INLINE intptr_t	bytes_written () const
virtual intptr_t	Position () const
intptr_t	Align (intptr_t alignment, intptr_t offset=0)
void	WriteWordWith32BitWrites (uword value)
template<typename T >
void	WriteUnsigned (T value)
void	WriteRefId (intptr_t value)
void	WriteBytes (const void *addr, intptr_t len)
void	WriteWord (uword value)
void	WriteTargetWord (word value)
void	Printf (const char *format,...) PRINTF_ATTRIBUTE(2
void	va_start (args, format)
	VPrintf (format, args)
	va_end (args)
void	VPrintf (const char *format, va_list args)
template<typename T >
void	Write (T value)
template<typename T >
void	WriteFixed (T value)
DART_FORCE_INLINE void	WriteByte (uint8_t value)
void	WriteString (const char *cstr)
template<typename T >
C::only_if_unsigned< T, void >	WriteLEB128 (T value)
template<typename T >
C::only_if_signed< T, void >	WriteLEB128 (T value)
template<typename T >
C::only_if_signed< T, void >	WriteSLEB128 (T value)
template<typename T >
C::only_if_unsigned< T, void >	WriteSLEB128 (T value)
Public Member Functions inherited from dart::ValueObject
	ValueObject ()
	~ValueObject ()

Protected Member Functions
void	EnsureSpace (intptr_t size_needed)
virtual void	SetPosition (intptr_t value)
DART_FORCE_INLINE intptr_t	Remaining () const
virtual void	Realloc (intptr_t new_capacity)=0
	DISALLOW_COPY_AND_ASSIGN (BaseWriteStream)

Protected Attributes
const intptr_t	initial_size_
uint8_t *	buffer_ = nullptr
uint8_t *	current_ = nullptr
intptr_t	capacity_ = 0

Detailed Description

Definition at line 332 of file datastream.h.

Constructor & Destructor Documentation

BaseWriteStream()

dart::BaseWriteStream::BaseWriteStream ( intptr_t  initial_size )

inlineexplicit

Definition at line 334 of file datastream.h.

      : initial_size_(Utils::RoundUpToPowerOfTwo(initial_size)) {}

~BaseWriteStream()

virtual dart::BaseWriteStream::~BaseWriteStream ( )

inlinevirtual

Definition at line 336 of file datastream.h.

{}

Member Function Documentation

Align()

intptr_t dart::BaseWriteStream::Align ( intptr_t  alignment, intptr_t  offset = 0  )

inline

Definition at line 341 of file datastream.h.

                                                          {
    const intptr_t position_before = Position();
    const intptr_t position_after =
        Utils::RoundUp(position_before, alignment, offset);
    const intptr_t length = position_after - position_before;
    if (length != 0) {
      EnsureSpace(length);
      memset(current_, 0, length);
      SetPosition(position_after);
    }
    return length;
  }

bytes_written()

DART_FORCE_INLINE intptr_t dart::BaseWriteStream::bytes_written ( ) const

inline

Definition at line 338 of file datastream.h.

{ return Position(); }

DISALLOW_COPY_AND_ASSIGN()

dart::BaseWriteStream::DISALLOW_COPY_AND_ASSIGN ( BaseWriteStream  )

protected

EnsureSpace()

void dart::BaseWriteStream::EnsureSpace ( intptr_t  size_needed )

inlineprotected

Definition at line 564 of file datastream.h.

                                         {
    if (Remaining() >= size_needed) return;
    intptr_t increment_size = capacity_;
    if (size_needed > increment_size) {
      increment_size = Utils::RoundUp(size_needed, initial_size_);
    }
    intptr_t new_size = capacity_ + increment_size;
    ASSERT(new_size > capacity_);
    Realloc(new_size);
    if (buffer_ == nullptr) {
      Exceptions::ThrowOOM();
    }
    ASSERT(Remaining() >= size_needed);
  }

Position()

virtual intptr_t dart::BaseWriteStream::Position ( ) const

inlinevirtual

Reimplemented in dart::StreamingWriteStream.

Definition at line 339 of file datastream.h.

{ return current_ - buffer_; }

Printf()

void dart::BaseWriteStream::Printf	(	const char *	format,
			...
	)

Realloc()

virtual void dart::BaseWriteStream::Realloc ( intptr_t  new_capacity )

protectedpure virtual

Implemented in dart::MallocWriteStream, dart::ZoneWriteStream, and dart::StreamingWriteStream.

Remaining()

DART_FORCE_INLINE intptr_t dart::BaseWriteStream::Remaining ( ) const

inlineprotected

Definition at line 584 of file datastream.h.

                                               {
    return capacity_ - BaseWriteStream::Position();
  }

SetPosition()

virtual void dart::BaseWriteStream::SetPosition ( intptr_t  value )

inlineprotectedvirtual

Reimplemented in dart::NonStreamingWriteStream, and dart::StreamingWriteStream.

Definition at line 579 of file datastream.h.

                                           {
    EnsureSpace(value - BaseWriteStream::Position());
    current_ = buffer_ + value;
  }

va_end()

dart::BaseWriteStream::va_end

(

args

)

va_start()

void dart::BaseWriteStream::va_start	(	args	,
		format
	)

VPrintf() [1/2]

void dart::BaseWriteStream::VPrintf ( const char *  format, va_list  args  )

inline

Definition at line 443 of file datastream.h.

                                                 {
    // Measure.
    va_list measure_args;
    va_copy(measure_args, args);
    intptr_t len = Utils::VSNPrint(nullptr, 0, format, measure_args);
    va_end(measure_args);
 
    // Alloc.
    EnsureSpace(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.
  }

VPrintf() [2/2]

dart::BaseWriteStream::VPrintf	(	format	,
		args
	)

Write()

template<typename T >

void dart::BaseWriteStream::Write ( T  value )

inline

Definition at line 463 of file datastream.h.

                      {
    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));
  }

WriteByte()

DART_FORCE_INLINE void dart::BaseWriteStream::WriteByte ( uint8_t  value )

inline

Definition at line 477 of file datastream.h.

                                                  {
    EnsureSpace(1);
    *current_++ = value;
  }

WriteBytes()

void dart::BaseWriteStream::WriteBytes ( const void *  addr, intptr_t  len  )

inline

Definition at line 424 of file datastream.h.

                                                  {
    if (len != 0) {
      EnsureSpace(len);
      memmove(current_, addr, len);
      current_ += len;
    }
  }

WriteFixed()

template<typename T >

void dart::BaseWriteStream::WriteFixed ( T  value )

inline

Definition at line 473 of file datastream.h.

                           {
    WriteBytes(&value, sizeof(value));
  }

WriteLEB128() [1/2]

template<typename T >

C::only_if_unsigned< T, void > dart::BaseWriteStream::WriteLEB128 ( T  value )

inline

Definition at line 489 of file datastream.h.

                                                  {
    T remainder = value;
    bool is_last_part;
    do {
      uint8_t part = static_cast<uint8_t>(remainder & C::kDataByteMask);
      remainder >>= C::kDataBitsPerByte;
      // For unsigned types, we're done when the remainder has no bits set.
      is_last_part = remainder == static_cast<T>(0);
      if (!is_last_part) {
        // Mark this part as a non-final part for this value.
        part |= C::kMoreDataMask;
      }
      WriteByte(part);
    } while (!is_last_part);
  }

WriteLEB128() [2/2]

template<typename T >

C::only_if_signed< T, void > dart::BaseWriteStream::WriteLEB128 ( T  value )

inline

Definition at line 506 of file datastream.h.

                                                {
    // If we're trying to LEB128 encode a negative value, chances are we should
    // be using SLEB128 instead.
    ASSERT(value >= 0);
    return WriteLEB128(bit_cast<typename std::make_unsigned<T>::type>(value));
  }

WriteRefId()

void dart::BaseWriteStream::WriteRefId ( intptr_t  value )

inline

Definition at line 409 of file datastream.h.

                                  {
    ASSERT(Utils::IsUint(28, value));  // 256MB is enough for anyone...
    EnsureSpace(4);
    if ((value >> 21) != 0) {
      *current_++ = (value >> 21) & 127;
    }
    if ((value >> 14) != 0) {
      *current_++ = (value >> 14) & 127;
    }
    if ((value >> 7) != 0) {
      *current_++ = (value >> 7) & 127;
    }
    *current_++ = ((value >> 0) & 127) | 128;
  }

WriteSLEB128() [1/2]

template<typename T >

C::only_if_signed< T, void > dart::BaseWriteStream::WriteSLEB128 ( T  value )

inline

Definition at line 514 of file datastream.h.

                                                 {
    constexpr intptr_t kBitsPerT = kBitsPerByte * sizeof(T);
    using Unsigned = typename std::make_unsigned<T>::type;
    // Record whether the original value was negative.
    const bool is_negative = value < 0;
    T remainder = value;
    bool is_last_part;
    do {
      uint8_t part = static_cast<uint8_t>(remainder & C::kDataByteMask);
      remainder >>= C::kDataBitsPerByte;
      // For signed types, we're done when either:
      // - the remainder has all bits set and the part's sign bit is set
      //   for negative values, or
      // - the remainder has no bits set and the part's sign bit is unset for
      //   non-negative values.
      // If the remainder matches but the sign bit does not, we need one more
      // part to set the sign bit correctly when decoding.
      if (is_negative) {
        // Right shifts of negative values in C are not guaranteed to be
        // arithmetic. For negative values, set the [kDataBitsPerByte] most
        // significant bits after shifting to ensure the value stays negative.
        constexpr intptr_t preserved_bits = kBitsPerT - C::kDataBitsPerByte;
        // The sign extension mask is the inverse of the preserved bits mask.
        constexpr T sign_extend =
            ~static_cast<T>((static_cast<Unsigned>(1) << preserved_bits) - 1);
        // Sign extend for negative values just in case a non-arithmetic right
        // shift is used by the compiler.
        remainder |= sign_extend;
        ASSERT(remainder < 0);  // Remainder should still be negative.
        is_last_part =
            remainder == ~static_cast<T>(0) && (part & C::kSignMask) != 0;
      } else {
        ASSERT(remainder >= 0);  // Remainder should still be non-negative.
        is_last_part =
            (remainder == static_cast<T>(0) && (part & C::kSignMask) == 0);
      }
      if (!is_last_part) {
        // Mark this part as a non-final part for this value.
        part |= C::kMoreDataMask;
      }
      WriteByte(part);
    } while (!is_last_part);
  }

WriteSLEB128() [2/2]

template<typename T >

C::only_if_unsigned< T, void > dart::BaseWriteStream::WriteSLEB128 ( T  value )

inline

Definition at line 559 of file datastream.h.

                                                   {
    return WriteSLEB128(bit_cast<typename std::make_signed<T>::type>(value));
  }

WriteString()

void dart::BaseWriteStream::WriteString ( const char *  cstr )

inline

Definition at line 482 of file datastream.h.

{ WriteBytes(cstr, strlen(cstr)); }

WriteTargetWord()

void dart::BaseWriteStream::WriteTargetWord

(

word

value

)

Definition at line 12 of file datastream.cc.

                                                {
  ASSERT(Utils::BitLength(value) <= compiler::target::kBitsPerWord);
  WriteFixed(static_cast<compiler::target::word>(value));
}

WriteUnsigned()

template<typename T >

void dart::BaseWriteStream::WriteUnsigned ( T  value )

inline

Definition at line 400 of file datastream.h.

                              {
    ASSERT(value >= 0);
    while (value > kMaxUnsignedDataPerByte) {
      WriteByte(static_cast<uint8_t>(value & kByteMask));
      value = value >> kDataBitsPerByte;
    }
    WriteByte(static_cast<uint8_t>(value + kEndUnsignedByteMarker));
  }

WriteWord()

void dart::BaseWriteStream::WriteWord ( uword  value )

inline

Definition at line 432 of file datastream.h.

{ WriteFixed(value); }

WriteWordWith32BitWrites()

void dart::BaseWriteStream::WriteWordWith32BitWrites ( uword  value )

inline

Definition at line 389 of file datastream.h.

                                             {
    constexpr intptr_t kNumWrite32PerWord = kBitsPerWord / kBitsPerInt32;
 
    const uint32_t mask = Utils::NBitMask(kBitsPerInt32);
    for (intptr_t j = 0; j < kNumWrite32PerWord; j++) {
      const uint32_t shifted_value = (value >> (j * kBitsPerInt32));
      Raw<kInt32Size, uint32_t>::Write(this, shifted_value & mask);
    }
  }

Member Data Documentation

buffer_

uint8_t* dart::BaseWriteStream::buffer_ = nullptr

protected

Definition at line 598 of file datastream.h.

capacity_

intptr_t dart::BaseWriteStream::capacity_ = 0

protected

Definition at line 600 of file datastream.h.

current_

uint8_t* dart::BaseWriteStream::current_ = nullptr

protected

Definition at line 599 of file datastream.h.

initial_size_

const intptr_t dart::BaseWriteStream::initial_size_

protected

Definition at line 597 of file datastream.h.

---

The documentation for this class was generated from the following files:

• third_party/dart-lang/sdk/runtime/vm/datastream.h
• third_party/dart-lang/sdk/runtime/vm/datastream.cc