tor-browser

CompactBuffer.h (6615B)

---

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
* vim: set ts=8 sts=2 et sw=2 tw=80:
* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this
* file, You can obtain one at http://mozilla.org/MPL/2.0/. */

#ifndef jit_Compactbuffer_h
#define jit_Compactbuffer_h

#include "mozilla/Assertions.h"

#include <stddef.h>
#include <stdint.h>

#include "js/AllocPolicy.h"
#include "js/Vector.h"

namespace js {
namespace jit {

class CompactBufferWriter;

// CompactBuffers are byte streams designed for compressable integers. It has
// helper functions for writing bytes, fixed-size integers, and variable-sized
// integers. Variable sized integers are encoded in 1-5 bytes, each byte
// containing 7 bits of the integer and a bit which specifies whether the next
// byte is also part of the integer.
//
// Fixed-width integers are also available, in case the actual value will not
// be known until later.

class CompactBufferReader {
 const uint8_t* buffer_;
 const uint8_t* end_;

 uint32_t readVariableLength() {
   uint32_t val = 0;
   uint32_t shift = 0;
   uint8_t byte;
   while (true) {
     MOZ_ASSERT(shift < 32);
     byte = readByte();
     val |= (uint32_t(byte) >> 1) << shift;
     shift += 7;
     if (!(byte & 1)) {
       return val;
     }
   }
 }

 uint64_t readVariableLength64() {
   uint64_t val = 0;
   uint32_t shift = 0;
   uint8_t byte;
   while (true) {
     MOZ_ASSERT(shift < 64);
     byte = readByte();
     val |= (uint64_t(byte) >> 1) << shift;
     shift += 7;
     if (!(byte & 1)) {
       return val;
     }
   }
 }

public:
 CompactBufferReader(const uint8_t* start, const uint8_t* end)
     : buffer_(start), end_(end) {}
 inline explicit CompactBufferReader(const CompactBufferWriter& writer);
 uint8_t readByte() {
   MOZ_ASSERT(buffer_ < end_);
   return *buffer_++;
 }
 uint32_t readFixedUint32_t() {
   uint32_t b0 = readByte();
   uint32_t b1 = readByte();
   uint32_t b2 = readByte();
   uint32_t b3 = readByte();
   return b0 | (b1 << 8) | (b2 << 16) | (b3 << 24);
 }
 uint16_t readFixedUint16_t() {
   uint32_t b0 = readByte();
   uint32_t b1 = readByte();
   return b0 | (b1 << 8);
 }
 uint16_t peekFixedUint16_t() {
   uint32_t b0 = buffer_[0];
   uint32_t b1 = buffer_[1];
   return b0 | (b1 << 8);
 }
 uint32_t readNativeEndianUint32_t() {
   // Must be at 4-byte boundary
   MOZ_ASSERT(uintptr_t(buffer_) % sizeof(uint32_t) == 0);
   return *reinterpret_cast<const uint32_t*>(buffer_);
 }
 uint32_t readUnsigned() { return readVariableLength(); }
 uint64_t readUnsigned64() { return readVariableLength64(); }
 int32_t readSigned() {
   uint8_t b = readByte();
   bool isNegative = !!(b & (1 << 0));
   bool more = !!(b & (1 << 1));
   int32_t result = b >> 2;
   if (more) {
     result |= readUnsigned() << 6;
   }
   if (isNegative) {
     return -result;
   }
   return result;
 }
 void* readRawPointer() {
   uintptr_t ptrWord = 0;
   for (unsigned i = 0; i < sizeof(uintptr_t); i++) {
     ptrWord |= static_cast<uintptr_t>(readByte()) << (i * 8);
   }
   return reinterpret_cast<void*>(ptrWord);
 }

 bool more() const {
   MOZ_ASSERT(buffer_ <= end_);
   return buffer_ < end_;
 }

 void seek(const uint8_t* start, uint32_t offset) {
   buffer_ = start + offset;
   MOZ_ASSERT(start < end_);
   MOZ_ASSERT(buffer_ <= end_);
 }

 const uint8_t* currentPosition() const { return buffer_; }
};

class CompactBufferWriter {
 js::Vector<uint8_t, 32, SystemAllocPolicy> buffer_;
 bool enoughMemory_;

public:
 CompactBufferWriter() : enoughMemory_(true) {}

 void setOOM() { enoughMemory_ = false; }

 // Note: writeByte() takes uint32 to catch implicit casts with a runtime
 // assert.
 void writeByte(uint32_t byte) {
   MOZ_ASSERT(byte <= 0xFF);
   if (!buffer_.append(byte)) {
     enoughMemory_ = false;
   }
 }
 void writeByteAt(uint32_t pos, uint32_t byte) {
   MOZ_ASSERT(byte <= 0xFF);
   if (!oom()) {
     buffer_[pos] = byte;
   }
 }
 void writeUnsigned(uint32_t value) {
   do {
     uint8_t byte = ((value & 0x7F) << 1) | (value > 0x7F);
     writeByte(byte);
     value >>= 7;
   } while (value);
 }
 void writeUnsignedAt(uint32_t pos, uint32_t value, uint32_t original) {
   MOZ_ASSERT(value <= original);
   do {
     uint8_t byte = ((value & 0x7F) << 1) | (original > 0x7F);
     writeByteAt(pos++, byte);
     value >>= 7;
     original >>= 7;
   } while (original);
 }
 void writeUnsigned64(uint64_t value) {
   do {
     uint8_t byte = ((value & 0x7F) << 1) | (value > 0x7F);
     writeByte(byte);
     value >>= 7;
   } while (value);
 }
 void writeSigned(int32_t v) {
   bool isNegative = v < 0;
   uint32_t value = isNegative ? -v : v;
   uint8_t byte =
       ((value & 0x3F) << 2) | ((value > 0x3F) << 1) | uint32_t(isNegative);
   writeByte(byte);

   // Write out the rest of the bytes, if needed.
   value >>= 6;
   if (value == 0) {
     return;
   }
   writeUnsigned(value);
 }
 void writeFixedUint32_t(uint32_t value) {
   writeByte(value & 0xFF);
   writeByte((value >> 8) & 0xFF);
   writeByte((value >> 16) & 0xFF);
   writeByte((value >> 24) & 0xFF);
 }
 void writeFixedUint16_t(uint16_t value) {
   writeByte(value & 0xFF);
   writeByte(value >> 8);
 }
 void writeNativeEndianUint32_t(uint32_t value) {
   // Must be at 4-byte boundary
   MOZ_ASSERT_IF(!oom(), length() % sizeof(uint32_t) == 0);
   writeFixedUint32_t(0);
   if (oom()) {
     return;
   }
   uint8_t* endPtr = buffer() + length();
   reinterpret_cast<uint32_t*>(endPtr)[-1] = value;
 }
 void writeRawPointer(const void* ptr) {
   uintptr_t ptrWord = reinterpret_cast<uintptr_t>(ptr);
   for (unsigned i = 0; i < sizeof(uintptr_t); i++) {
     writeByte((ptrWord >> (i * 8)) & 0xFF);
   }
 }
 void writeBytes(const uint8_t* data, size_t len) {
   if (!buffer_.append(data, len)) {
     enoughMemory_ = false;
   }
 }
 size_t length() const { return buffer_.length(); }
 uint8_t* buffer() {
   MOZ_ASSERT(!oom());
   return &buffer_[0];
 }
 const uint8_t* buffer() const {
   MOZ_ASSERT(!oom());
   return &buffer_[0];
 }
 bool oom() const { return !enoughMemory_; }
 void propagateOOM(bool success) { enoughMemory_ &= success; }
};

CompactBufferReader::CompactBufferReader(const CompactBufferWriter& writer)
   : buffer_(writer.buffer()), end_(writer.buffer() + writer.length()) {}

}  // namespace jit
}  // namespace js

#endif /* jit_Compactbuffer_h */