From 26a029d407be480d791972afb5975cf62c9360a6 Mon Sep 17 00:00:00 2001 From: Daniel Baumann Date: Fri, 19 Apr 2024 02:47:55 +0200 Subject: Adding upstream version 124.0.1. Signed-off-by: Daniel Baumann --- js/src/wasm/WasmTable.h | 143 ++++++++++++++++++++++++++++++++++++++++++++++++ 1 file changed, 143 insertions(+) create mode 100644 js/src/wasm/WasmTable.h (limited to 'js/src/wasm/WasmTable.h') diff --git a/js/src/wasm/WasmTable.h b/js/src/wasm/WasmTable.h new file mode 100644 index 0000000000..a6e690cdd6 --- /dev/null +++ b/js/src/wasm/WasmTable.h @@ -0,0 +1,143 @@ +/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*- + * vim: set ts=8 sts=2 et sw=2 tw=80: + * + * Copyright 2016 Mozilla Foundation + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +#ifndef wasm_table_h +#define wasm_table_h + +#include "gc/Policy.h" +#include "wasm/WasmCode.h" + +namespace js { +namespace wasm { + +// A Table is an indexable array of opaque values. Tables are first-class +// stateful objects exposed to WebAssembly. asm.js also uses Tables to represent +// its homogeneous function-pointer tables. +// +// A table of FuncRef holds FunctionTableElems, which are (code*,instance*) +// pairs, where the instance must be traced. +// +// A table of AnyRef holds pointers, which must be traced. + +using TableAnyRefVector = GCVector, 0, SystemAllocPolicy>; + +class Table : public ShareableBase { + using InstanceSet = + WeakCache, + StableCellHasher>, + SystemAllocPolicy>>; + using FuncRefVector = Vector; + + WeakHeapPtr maybeObject_; + InstanceSet observers_; + FuncRefVector functions_; // either functions_ has data + TableAnyRefVector objects_; // or objects_, but not both + const RefType elemType_; + const bool isAsmJS_; + uint32_t length_; + const Maybe maximum_; + + template + friend struct js::MallocProvider; + Table(JSContext* cx, const TableDesc& desc, + Handle maybeObject, FuncRefVector&& functions); + Table(JSContext* cx, const TableDesc& desc, + Handle maybeObject, TableAnyRefVector&& objects); + + void tracePrivate(JSTracer* trc); + friend class js::WasmTableObject; + + public: + static RefPtr
create(JSContext* cx, const TableDesc& desc, + Handle maybeObject); + ~Table(); + void trace(JSTracer* trc); + + RefType elemType() const { return elemType_; } + TableRepr repr() const { return elemType_.tableRepr(); } + + bool isAsmJS() const { + MOZ_ASSERT(elemType_.isFuncHierarchy()); + return isAsmJS_; + } + + bool isFunction() const { return elemType().isFuncHierarchy(); } + uint32_t length() const { return length_; } + Maybe maximum() const { return maximum_; } + + // Raw pointer to the table for use in TableInstanceData. + uint8_t* instanceElements() const; + + // set/get/fillFuncRef is allowed only on table-of-funcref. + // get/fillAnyRef is allowed only on table-of-anyref. + // setNull is allowed on either. + + const FunctionTableElem& getFuncRef(uint32_t index) const; + [[nodiscard]] bool getFuncRef(JSContext* cx, uint32_t index, + MutableHandleFunction fun) const; + void setFuncRef(uint32_t index, JSFunction* func); + void setFuncRef(uint32_t index, void* code, Instance* instance); + void fillFuncRef(uint32_t index, uint32_t fillCount, FuncRef ref, + JSContext* cx); + + AnyRef getAnyRef(uint32_t index) const; + void setAnyRef(uint32_t index, AnyRef ref); + void fillAnyRef(uint32_t index, uint32_t fillCount, AnyRef ref); + + // Sets ref automatically using the correct setter depending on the ref and + // table type (setNull, setFuncRef, or setAnyRef) + void setRef(uint32_t index, AnyRef ref); + + // Get the element at index and convert it to a JS value. + [[nodiscard]] bool getValue(JSContext* cx, uint32_t index, + MutableHandleValue result) const; + + void setNull(uint32_t index); + + // Copy entry from |srcTable| at |srcIndex| to this table at |dstIndex|. Used + // by table.copy. May OOM if it needs to box up a function during an upcast. + [[nodiscard]] bool copy(JSContext* cx, const Table& srcTable, + uint32_t dstIndex, uint32_t srcIndex); + + // grow() returns (uint32_t)-1 if it could not grow. + [[nodiscard]] uint32_t grow(uint32_t delta); + [[nodiscard]] bool movingGrowable() const; + [[nodiscard]] bool addMovingGrowObserver(JSContext* cx, + WasmInstanceObject* instance); + + void fillUninitialized(uint32_t index, uint32_t fillCount, HandleAnyRef ref, + JSContext* cx); +#ifdef DEBUG + void assertRangeNull(uint32_t index, uint32_t length) const; + void assertRangeNotNull(uint32_t index, uint32_t length) const; +#endif // DEBUG + + // about:memory reporting: + + size_t sizeOfExcludingThis(MallocSizeOf mallocSizeOf) const; + + size_t gcMallocBytes() const; +}; + +using SharedTable = RefPtr
; +using SharedTableVector = Vector; + +} // namespace wasm +} // namespace js + +#endif // wasm_table_h -- cgit v1.2.3