1 /* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
2 * vim: set ts=8 sts=2 et sw=2 tw=80:
3 * This Source Code Form is subject to the terms of the Mozilla Public
4 * License, v. 2.0. If a copy of the MPL was not distributed with this
5 * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
10 #include "mozilla/MemoryReporting.h" // MallocSizeOf
12 #include <stddef.h> // size_t
13 #include <stdint.h> // uint8_t, uint32_t
17 #include "gc/Cell.h" // gc::TenuredCellWithNonGCPointer
18 #include "gc/GCEnum.h" // AllowGC
19 #include "js/TraceKind.h" // JS::TraceKind
20 #include "js/UbiNode.h" // ubi::{TracerConcrete, Size, CourseType}
29 enum class CodeKind
: uint8_t;
31 // Header at start of raw code buffer
32 struct JitCodeHeader
{
33 // Link back to corresponding gcthing
36 void init(JitCode
* jitCode
);
38 static JitCodeHeader
* FromExecutable(uint8_t* buffer
) {
39 return (JitCodeHeader
*)(buffer
- sizeof(JitCodeHeader
));
43 class JitCode
: public gc::TenuredCellWithNonGCPointer
<uint8_t> {
44 friend class gc::CellAllocator
;
47 // Raw code pointer, stored in the cell header.
48 uint8_t* raw() const { return headerPtr(); }
51 ExecutablePool
* pool_
;
52 uint32_t bufferSize_
; // Total buffer size. Does not include headerSize_.
53 uint32_t insnSize_
; // Instruction stream size.
54 uint32_t dataSize_
; // Size of the read-only data area.
55 uint32_t jumpRelocTableBytes_
; // Size of the jump relocation table.
56 uint32_t dataRelocTableBytes_
; // Size of the data relocation table.
57 uint8_t headerSize_
: 5; // Number of bytes allocated before codeStart.
58 uint8_t kind_
: 3; // jit::CodeKind, for the memory reporters.
59 bool invalidated_
: 1; // Whether the code object has been invalidated.
60 // This is necessary to prevent GC tracing.
61 bool hasBytecodeMap_
: 1; // Whether the code object has been registered with
62 // native=>bytecode mapping tables.
63 uint8_t localTracingSlots_
;
66 JitCode(uint8_t* code
, uint32_t bufferSize
, uint32_t headerSize
,
67 ExecutablePool
* pool
, CodeKind kind
)
68 : TenuredCellWithNonGCPointer(code
),
70 bufferSize_(bufferSize
),
73 jumpRelocTableBytes_(0),
74 dataRelocTableBytes_(0),
75 headerSize_(headerSize
),
78 hasBytecodeMap_(false),
79 localTracingSlots_(0) {
80 MOZ_ASSERT(CodeKind(kind_
) == kind
);
81 MOZ_ASSERT(headerSize_
== headerSize
);
84 uint32_t dataOffset() const { return insnSize_
; }
85 uint32_t jumpRelocTableOffset() const { return dataOffset() + dataSize_
; }
86 uint32_t dataRelocTableOffset() const {
87 return jumpRelocTableOffset() + jumpRelocTableBytes_
;
91 uint8_t* rawEnd() const { return raw() + insnSize_
; }
92 bool containsNativePC(const void* addr
) const {
93 const uint8_t* addr_u8
= (const uint8_t*)addr
;
94 return raw() <= addr_u8
&& addr_u8
< rawEnd();
96 size_t instructionsSize() const { return insnSize_
; }
97 size_t bufferSize() const { return bufferSize_
; }
98 size_t headerSize() const { return headerSize_
; }
100 void traceChildren(JSTracer
* trc
);
101 void finalize(JS::GCContext
* gcx
);
102 void setInvalidated() { invalidated_
= true; }
104 void setHasBytecodeMap() { hasBytecodeMap_
= true; }
106 void setLocalTracingSlots(uint8_t localTracingSlots
) {
107 localTracingSlots_
= localTracingSlots
;
110 uint8_t localTracingSlots() { return localTracingSlots_
; }
112 // If this JitCode object has been, effectively, corrupted due to
113 // invalidation patching, then we have to remember this so we don't try and
114 // trace relocation entries that may now be corrupt.
115 bool invalidated() const { return !!invalidated_
; }
117 template <typename T
>
119 return JS_DATA_TO_FUNC_PTR(T
, raw());
122 void copyFrom(MacroAssembler
& masm
);
124 static JitCode
* FromExecutable(uint8_t* buffer
) {
125 JitCode
* code
= JitCodeHeader::FromExecutable(buffer
)->jitCode_
;
126 MOZ_ASSERT(code
->raw() == buffer
);
130 static size_t offsetOfCode() { return offsetOfHeaderPtr(); }
132 uint8_t* jumpRelocTable() { return raw() + jumpRelocTableOffset(); }
134 // Allocates a new JitCode object which will be managed by the GC. If no
135 // object can be allocated, nullptr is returned. On failure, |pool| is
136 // automatically released, so the code may be freed.
137 template <AllowGC allowGC
>
138 static JitCode
* New(JSContext
* cx
, uint8_t* code
, uint32_t totalSize
,
139 uint32_t headerSize
, ExecutablePool
* pool
, CodeKind kind
);
142 static const JS::TraceKind TraceKind
= JS::TraceKind::JitCode
;
148 // JS::ubi::Nodes can point to js::jit::JitCode instances; they're js::gc::Cell
149 // instances with no associated compartment.
153 class Concrete
<js::jit::JitCode
> : TracerConcrete
<js::jit::JitCode
> {
155 explicit Concrete(js::jit::JitCode
* ptr
)
156 : TracerConcrete
<js::jit::JitCode
>(ptr
) {}
159 static void construct(void* storage
, js::jit::JitCode
* ptr
) {
160 new (storage
) Concrete(ptr
);
163 CoarseType
coarseType() const final
{ return CoarseType::Script
; }
165 Size
size(mozilla::MallocSizeOf mallocSizeOf
) const override
{
166 Size size
= js::gc::Arena::thingSize(get().asTenured().getAllocKind());
167 size
+= get().bufferSize();
168 size
+= get().headerSize();
172 const char16_t
* typeName() const override
{ return concreteTypeName
; }
173 static const char16_t concreteTypeName
[];
179 #endif /* jit_JitCode_h */