mirror of
https://github.com/classilla/tenfourfox.git
synced 2024-06-25 20:29:33 +00:00
268 lines
7.1 KiB
C++
268 lines
7.1 KiB
C++
/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 4 -*-
|
|
* vim: set ts=8 sts=4 et sw=4 tw=99:
|
|
* 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 vm_Xdr_h
|
|
#define vm_Xdr_h
|
|
|
|
#include "mozilla/Endian.h"
|
|
#include "mozilla/TypeTraits.h"
|
|
|
|
#include "jsatom.h"
|
|
#include "jsfriendapi.h"
|
|
|
|
namespace js {
|
|
|
|
/*
|
|
* Bytecode version number. Increment the subtrahend whenever JS bytecode
|
|
* changes incompatibly.
|
|
*
|
|
* This version number is XDR'd near the front of xdr bytecode and aborts
|
|
* deserialization if there is a mismatch between the current and saved
|
|
* versions. If deserialization fails, the data should be invalidated if
|
|
* possible.
|
|
*
|
|
* When you change this, run make_opcode_doc.py and copy the new output into
|
|
* this wiki page:
|
|
*
|
|
* https://developer.mozilla.org/en-US/docs/SpiderMonkey/Internals/Bytecode
|
|
*/
|
|
static const uint32_t XDR_BYTECODE_VERSION_SUBTRAHEND = 339;
|
|
static const uint32_t XDR_BYTECODE_VERSION =
|
|
uint32_t(0xb973c0de - XDR_BYTECODE_VERSION_SUBTRAHEND);
|
|
|
|
static_assert(JSErr_Limit == 444,
|
|
"GREETINGS, POTENTIAL SUBTRAHEND INCREMENTER! If you added or "
|
|
"removed MSG_DEFs from js.msg, you should increment "
|
|
"XDR_BYTECODE_VERSION_SUBTRAHEND and update this assertion's "
|
|
"expected JSErr_Limit value.");
|
|
|
|
class XDRBuffer {
|
|
public:
|
|
explicit XDRBuffer(JSContext* cx)
|
|
: context(cx), base(nullptr), cursor(nullptr), limit(nullptr) { }
|
|
|
|
JSContext* cx() const {
|
|
return context;
|
|
}
|
|
|
|
void* getData(uint32_t* lengthp) const {
|
|
MOZ_ASSERT(size_t(cursor - base) <= size_t(UINT32_MAX));
|
|
*lengthp = uint32_t(cursor - base);
|
|
return base;
|
|
}
|
|
|
|
void setData(const void* data, uint32_t length) {
|
|
base = static_cast<uint8_t*>(const_cast<void*>(data));
|
|
cursor = base;
|
|
limit = base + length;
|
|
}
|
|
|
|
const uint8_t* read(size_t n) {
|
|
MOZ_ASSERT(n <= size_t(limit - cursor));
|
|
uint8_t* ptr = cursor;
|
|
cursor += n;
|
|
return ptr;
|
|
}
|
|
|
|
const char* readCString() {
|
|
char* ptr = reinterpret_cast<char*>(cursor);
|
|
cursor = reinterpret_cast<uint8_t*>(strchr(ptr, '\0')) + 1;
|
|
MOZ_ASSERT(base < cursor);
|
|
MOZ_ASSERT(cursor <= limit);
|
|
return ptr;
|
|
}
|
|
|
|
uint8_t* write(size_t n) {
|
|
if (n > size_t(limit - cursor)) {
|
|
if (!grow(n))
|
|
return nullptr;
|
|
}
|
|
uint8_t* ptr = cursor;
|
|
cursor += n;
|
|
return ptr;
|
|
}
|
|
|
|
void freeBuffer();
|
|
|
|
private:
|
|
bool grow(size_t n);
|
|
|
|
JSContext* const context;
|
|
uint8_t* base;
|
|
uint8_t* cursor;
|
|
uint8_t* limit;
|
|
};
|
|
|
|
/*
|
|
* XDR serialization state. All data is encoded in little endian.
|
|
*/
|
|
template <XDRMode mode>
|
|
class XDRState {
|
|
public:
|
|
XDRBuffer buf;
|
|
|
|
protected:
|
|
explicit XDRState(JSContext* cx)
|
|
: buf(cx) { }
|
|
|
|
public:
|
|
JSContext* cx() const {
|
|
return buf.cx();
|
|
}
|
|
|
|
bool codeUint8(uint8_t* n) {
|
|
if (mode == XDR_ENCODE) {
|
|
uint8_t* ptr = buf.write(sizeof *n);
|
|
if (!ptr)
|
|
return false;
|
|
*ptr = *n;
|
|
} else {
|
|
*n = *buf.read(sizeof *n);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool codeUint16(uint16_t* n) {
|
|
if (mode == XDR_ENCODE) {
|
|
uint8_t* ptr = buf.write(sizeof *n);
|
|
if (!ptr)
|
|
return false;
|
|
mozilla::LittleEndian::writeUint16(ptr, *n);
|
|
} else {
|
|
const uint8_t* ptr = buf.read(sizeof *n);
|
|
*n = mozilla::LittleEndian::readUint16(ptr);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool codeUint32(uint32_t* n) {
|
|
if (mode == XDR_ENCODE) {
|
|
uint8_t* ptr = buf.write(sizeof *n);
|
|
if (!ptr)
|
|
return false;
|
|
mozilla::LittleEndian::writeUint32(ptr, *n);
|
|
} else {
|
|
const uint8_t* ptr = buf.read(sizeof *n);
|
|
*n = mozilla::LittleEndian::readUint32(ptr);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool codeUint64(uint64_t* n) {
|
|
if (mode == XDR_ENCODE) {
|
|
uint8_t* ptr = buf.write(sizeof(*n));
|
|
if (!ptr)
|
|
return false;
|
|
mozilla::LittleEndian::writeUint64(ptr, *n);
|
|
} else {
|
|
const uint8_t* ptr = buf.read(sizeof(*n));
|
|
*n = mozilla::LittleEndian::readUint64(ptr);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* Use SFINAE to refuse any specialization which is not an enum. Uses of
|
|
* this function do not have to specialize the type of the enumerated field
|
|
* as C++ will extract the parameterized from the argument list.
|
|
*/
|
|
template <typename T>
|
|
bool codeEnum32(T* val, typename mozilla::EnableIf<mozilla::IsEnum<T>::value, T>::Type * = NULL)
|
|
{
|
|
uint32_t tmp;
|
|
if (mode == XDR_ENCODE)
|
|
tmp = uint32_t(*val);
|
|
if (!codeUint32(&tmp))
|
|
return false;
|
|
if (mode == XDR_DECODE)
|
|
*val = T(tmp);
|
|
return true;
|
|
}
|
|
|
|
bool codeDouble(double* dp) {
|
|
union DoublePun {
|
|
double d;
|
|
uint64_t u;
|
|
} pun;
|
|
if (mode == XDR_ENCODE)
|
|
pun.d = *dp;
|
|
if (!codeUint64(&pun.u))
|
|
return false;
|
|
if (mode == XDR_DECODE)
|
|
*dp = pun.d;
|
|
return true;
|
|
}
|
|
|
|
bool codeBytes(void* bytes, size_t len) {
|
|
if (mode == XDR_ENCODE) {
|
|
uint8_t* ptr = buf.write(len);
|
|
if (!ptr)
|
|
return false;
|
|
memcpy(ptr, bytes, len);
|
|
} else {
|
|
memcpy(bytes, buf.read(len), len);
|
|
}
|
|
return true;
|
|
}
|
|
|
|
/*
|
|
* During encoding the string is written into the buffer together with its
|
|
* terminating '\0'. During decoding the method returns a pointer into the
|
|
* decoding buffer and the caller must copy the string if it will outlive
|
|
* the decoding buffer.
|
|
*/
|
|
bool codeCString(const char** sp) {
|
|
if (mode == XDR_ENCODE) {
|
|
size_t n = strlen(*sp) + 1;
|
|
uint8_t* ptr = buf.write(n);
|
|
if (!ptr)
|
|
return false;
|
|
memcpy(ptr, *sp, n);
|
|
} else {
|
|
*sp = buf.readCString();
|
|
}
|
|
return true;
|
|
}
|
|
|
|
bool codeChars(const JS::Latin1Char* chars, size_t nchars);
|
|
bool codeChars(char16_t* chars, size_t nchars);
|
|
|
|
bool codeFunction(JS::MutableHandleFunction objp);
|
|
bool codeScript(MutableHandleScript scriptp);
|
|
bool codeConstValue(MutableHandleValue vp);
|
|
};
|
|
|
|
class XDREncoder : public XDRState<XDR_ENCODE> {
|
|
public:
|
|
explicit XDREncoder(JSContext* cx)
|
|
: XDRState<XDR_ENCODE>(cx) {
|
|
}
|
|
|
|
~XDREncoder() {
|
|
buf.freeBuffer();
|
|
}
|
|
|
|
const void* getData(uint32_t* lengthp) const {
|
|
return buf.getData(lengthp);
|
|
}
|
|
|
|
void* forgetData(uint32_t* lengthp) {
|
|
void* data = buf.getData(lengthp);
|
|
buf.setData(nullptr, 0);
|
|
return data;
|
|
}
|
|
};
|
|
|
|
class XDRDecoder : public XDRState<XDR_DECODE> {
|
|
public:
|
|
XDRDecoder(JSContext* cx, const void* data, uint32_t length);
|
|
|
|
};
|
|
|
|
} /* namespace js */
|
|
|
|
#endif /* vm_Xdr_h */
|