/* -*- 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_JitCode_h
#define jit_JitCode_h
#include "mozilla/MemoryReporting.h" // MallocSizeOf
#include <stddef.h>
// size_t
#include <stdint.h>
// uint8_t, uint32_t
#include "jstypes.h"
#include "gc/Cell.h" // gc::TenuredCellWithNonGCPointer
#include "gc/GCEnum.h" // AllowGC
#include "js/TraceKind.h" // JS::TraceKind
#include "js/UbiNode.h" // ubi::{TracerConcrete, Size, CourseType}
namespace js {
namespace jit {
class ExecutablePool;
class JitCode;
class MacroAssembler;
enum class CodeKind : uint8_t;
// Header at start of raw code buffer
struct JitCodeHeader {
// Link back to corresponding gcthing
JitCode* jitCode_;
void init(JitCode* jitCode);
static JitCodeHeader* FromExecutable(uint8_t* buffer) {
return (JitCodeHeader*)(buffer -
sizeof(JitCodeHeader));
}
};
class JitCode :
public gc::TenuredCellWithNonGCPointer<uint8_t> {
friend class gc::CellAllocator;
public:
// Raw code pointer, stored in the cell header.
uint8_t* raw()
const {
return headerPtr(); }
// Raw pointer to the allocated memory to be able to modify the JitCodePointer
// which is stored above the code.
uint8_t* allocatedMemory()
const {
return headerPtr() - headerSize_; }
protected:
ExecutablePool* pool_;
uint32_t bufferSize_;
// Total buffer size. Does not include headerSize_.
uint32_t insnSize_;
// Instruction stream size.
uint32_t dataSize_;
// Size of the read-only data area.
uint32_t jumpRelocTableBytes_;
// Size of the jump relocation table.
uint32_t dataRelocTableBytes_;
// Size of the data relocation table.
uint8_t headerSize_ : 5;
// Number of bytes allocated before codeStart.
uint8_t kind_ : 3;
// jit::CodeKind, for the memory reporters.
bool invalidated_ : 1;
// Whether the code object has been invalidated.
// This is necessary to prevent GC tracing.
bool hasBytecodeMap_ : 1;
// Whether the code object has been registered with
// native=>bytecode mapping tables.
uint8_t localTracingSlots_;
JitCode() =
delete;
JitCode(uint8_t* code, uint32_t bufferSize, uint32_t headerSize,
ExecutablePool* pool, CodeKind kind)
: TenuredCellWithNonGCPointer(code),
pool_(pool),
bufferSize_(bufferSize),
insnSize_(0),
dataSize_(0),
jumpRelocTableBytes_(0),
dataRelocTableBytes_(0),
headerSize_(headerSize),
kind_(uint8_t(kind)),
invalidated_(
false),
hasBytecodeMap_(
false),
localTracingSlots_(0) {
MOZ_ASSERT(CodeKind(kind_) == kind);
MOZ_ASSERT(headerSize_ == headerSize);
}
uint32_t dataOffset()
const {
return insnSize_; }
uint32_t jumpRelocTableOffset()
const {
return dataOffset() + dataSize_; }
uint32_t dataRelocTableOffset()
const {
return jumpRelocTableOffset() + jumpRelocTableBytes_;
}
public:
uint8_t* rawEnd()
const {
return raw() + insnSize_; }
bool containsNativePC(
const void* addr)
const {
const uint8_t* addr_u8 = (
const uint8_t*)addr;
return raw() <= addr_u8 && addr_u8 < rawEnd();
}
size_t instructionsSize()
const {
return insnSize_; }
size_t bufferSize()
const {
return bufferSize_; }
size_t headerSize()
const {
return headerSize_; }
size_t allocatedSize()
const {
return bufferSize_ + headerSize_; }
void traceChildren(JSTracer* trc);
void finalize(JS::GCContext* gcx);
void setInvalidated() { invalidated_ =
true; }
void setHasBytecodeMap() { hasBytecodeMap_ =
true; }
void setLocalTracingSlots(uint8_t localTracingSlots) {
localTracingSlots_ = localTracingSlots;
}
uint8_t localTracingSlots() {
return localTracingSlots_; }
// If this JitCode object has been, effectively, corrupted due to
// invalidation patching, then we have to remember this so we don't try and
// trace relocation entries that may now be corrupt.
bool invalidated()
const {
return !!invalidated_; }
template <
typename T>
T as()
const {
return JS_DATA_TO_FUNC_PTR(T, raw());
}
void copyFrom(MacroAssembler& masm);
static JitCode* FromExecutable(uint8_t* buffer) {
JitCode* code = JitCodeHeader::FromExecutable(buffer)->jitCode_;
MOZ_ASSERT(code->raw() == buffer);
return code;
}
static size_t offsetOfCode() {
return offsetOfHeaderPtr(); }
uint8_t* jumpRelocTable() {
return raw() + jumpRelocTableOffset(); }
// Allocates a new JitCode object which will be managed by the GC. If no
// object can be allocated, nullptr is returned. On failure, |pool| is
// automatically released, so the code may be freed.
template <AllowGC allowGC>
static JitCode*
New(JSContext* cx, uint8_t* code, uint32_t totalSize,
uint32_t headerSize, ExecutablePool* pool, CodeKind kind);
public:
static const JS::TraceKind TraceKind = JS::TraceKind::JitCode;
};
}
// namespace jit
}
// namespace js
// JS::ubi::Nodes can point to js::jit::JitCode instances; they're js::gc::Cell
// instances with no associated compartment.
namespace JS {
namespace ubi {
template <>
class Concrete<js::jit::JitCode> : TracerConcrete<js::jit::JitCode> {
protected:
explicit Concrete(js::jit::JitCode* ptr)
: TracerConcrete<js::jit::JitCode>(ptr) {}
public:
static void construct(
void* storage, js::jit::JitCode* ptr) {
new (storage) Concrete(ptr);
}
CoarseType coarseType()
const final {
return CoarseType::Script; }
Size size(mozilla::MallocSizeOf mallocSizeOf)
const override {
Size size = js::gc::Arena::thingSize(get().asTenured().getAllocKind());
size += get().bufferSize();
size += get().headerSize();
return size;
}
const char16_t*
typeName()
const override {
return concreteTypeName; }
static const char16_t concreteTypeName[];
};
}
// namespace ubi
}
// namespace JS
#endif /* jit_JitCode_h */
