| // Copyright 2017 the V8 project authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef V8_WASM_OBJECTS_INL_H_ |
| #define V8_WASM_OBJECTS_INL_H_ |
| |
| #include "src/heap/heap-inl.h" |
| #include "src/wasm/wasm-objects.h" |
| |
| namespace v8 { |
| namespace internal { |
| |
| // Has to be the last include (doesn't have include guards) |
| #include "src/objects/object-macros.h" |
| |
| CAST_ACCESSOR(WasmInstanceObject) |
| CAST_ACCESSOR(WasmMemoryObject) |
| CAST_ACCESSOR(WasmModuleObject) |
| CAST_ACCESSOR(WasmTableObject) |
| |
| #define OPTIONAL_ACCESSORS(holder, name, type, offset) \ |
| bool holder::has_##name() { \ |
| return !READ_FIELD(this, offset)->IsUndefined(GetIsolate()); \ |
| } \ |
| ACCESSORS(holder, name, type, offset) |
| |
| // WasmModuleObject |
| ACCESSORS(WasmModuleObject, compiled_module, WasmCompiledModule, |
| kCompiledModuleOffset) |
| |
| // WasmTableObject |
| ACCESSORS(WasmTableObject, functions, FixedArray, kFunctionsOffset) |
| ACCESSORS(WasmTableObject, maximum_length, Object, kMaximumLengthOffset) |
| ACCESSORS(WasmTableObject, dispatch_tables, FixedArray, kDispatchTablesOffset) |
| |
| // WasmMemoryObject |
| ACCESSORS(WasmMemoryObject, array_buffer, JSArrayBuffer, kArrayBufferOffset) |
| SMI_ACCESSORS(WasmMemoryObject, maximum_pages, kMaximumPagesOffset) |
| OPTIONAL_ACCESSORS(WasmMemoryObject, instances, WeakFixedArray, |
| kInstancesOffset) |
| ACCESSORS(WasmMemoryObject, wasm_context, Managed<WasmContext>, |
| kWasmContextOffset) |
| |
| // WasmInstanceObject |
| ACCESSORS(WasmInstanceObject, compiled_module, WasmCompiledModule, |
| kCompiledModuleOffset) |
| ACCESSORS(WasmInstanceObject, exports_object, JSObject, kExportsObjectOffset) |
| OPTIONAL_ACCESSORS(WasmInstanceObject, memory_object, WasmMemoryObject, |
| kMemoryObjectOffset) |
| OPTIONAL_ACCESSORS(WasmInstanceObject, memory_buffer, JSArrayBuffer, |
| kMemoryBufferOffset) |
| ACCESSORS(WasmInstanceObject, globals_buffer, JSArrayBuffer, |
| kGlobalsBufferOffset) |
| OPTIONAL_ACCESSORS(WasmInstanceObject, debug_info, WasmDebugInfo, |
| kDebugInfoOffset) |
| OPTIONAL_ACCESSORS(WasmInstanceObject, function_tables, FixedArray, |
| kFunctionTablesOffset) |
| OPTIONAL_ACCESSORS(WasmInstanceObject, signature_tables, FixedArray, |
| kSignatureTablesOffset) |
| ACCESSORS(WasmInstanceObject, directly_called_instances, FixedArray, |
| kDirectlyCalledInstancesOffset) |
| ACCESSORS(WasmInstanceObject, js_imports_table, FixedArray, |
| kJsImportsTableOffset) |
| |
| // WasmSharedModuleData |
| ACCESSORS(WasmSharedModuleData, module_bytes, SeqOneByteString, |
| kModuleBytesOffset) |
| ACCESSORS(WasmSharedModuleData, script, Script, kScriptOffset) |
| OPTIONAL_ACCESSORS(WasmSharedModuleData, asm_js_offset_table, ByteArray, |
| kAsmJsOffsetTableOffset) |
| OPTIONAL_ACCESSORS(WasmSharedModuleData, breakpoint_infos, FixedArray, |
| kBreakPointInfosOffset) |
| |
| OPTIONAL_ACCESSORS(WasmSharedModuleData, lazy_compilation_orchestrator, Foreign, |
| kLazyCompilationOrchestratorOffset) |
| |
| OPTIONAL_ACCESSORS(WasmDebugInfo, locals_names, FixedArray, kLocalsNamesOffset) |
| OPTIONAL_ACCESSORS(WasmDebugInfo, c_wasm_entries, FixedArray, |
| kCWasmEntriesOffset) |
| OPTIONAL_ACCESSORS(WasmDebugInfo, c_wasm_entry_map, Managed<wasm::SignatureMap>, |
| kCWasmEntryMapOffset) |
| |
| #undef OPTIONAL_ACCESSORS |
| |
| #define FORWARD_SHARED(type, name) \ |
| type WasmCompiledModule::name() { return shared()->name(); } |
| FORWARD_SHARED(SeqOneByteString*, module_bytes) |
| FORWARD_SHARED(wasm::WasmModule*, module) |
| FORWARD_SHARED(Script*, script) |
| FORWARD_SHARED(bool, is_asm_js) |
| #undef FORWARD_SHARED |
| |
| #define WCM_OBJECT_OR_WEAK(TYPE, NAME, ID, TYPE_CHECK, SETTER_MODIFIER) \ |
| Handle<TYPE> WasmCompiledModule::NAME() const { \ |
| return handle(ptr_to_##NAME()); \ |
| } \ |
| \ |
| MaybeHandle<TYPE> WasmCompiledModule::maybe_##NAME() const { \ |
| if (has_##NAME()) return NAME(); \ |
| return MaybeHandle<TYPE>(); \ |
| } \ |
| \ |
| TYPE* WasmCompiledModule::maybe_ptr_to_##NAME() const { \ |
| Object* obj = get(ID); \ |
| if (!(TYPE_CHECK)) return nullptr; \ |
| return TYPE::cast(obj); \ |
| } \ |
| \ |
| TYPE* WasmCompiledModule::ptr_to_##NAME() const { \ |
| Object* obj = get(ID); \ |
| DCHECK(TYPE_CHECK); \ |
| return TYPE::cast(obj); \ |
| } \ |
| \ |
| bool WasmCompiledModule::has_##NAME() const { \ |
| Object* obj = get(ID); \ |
| return TYPE_CHECK; \ |
| } \ |
| \ |
| void WasmCompiledModule::reset_##NAME() { set_undefined(ID); } \ |
| \ |
| void WasmCompiledModule::set_##NAME(Handle<TYPE> value) { \ |
| set_ptr_to_##NAME(*value); \ |
| } \ |
| void WasmCompiledModule::set_ptr_to_##NAME(TYPE* value) { set(ID, value); } |
| |
| #define WCM_OBJECT(TYPE, NAME) \ |
| WCM_OBJECT_OR_WEAK(TYPE, NAME, kID_##NAME, obj->Is##TYPE(), public) |
| |
| #define WCM_CONST_OBJECT(TYPE, NAME) \ |
| WCM_OBJECT_OR_WEAK(TYPE, NAME, kID_##NAME, obj->Is##TYPE(), private) |
| |
| #define WCM_WASM_OBJECT(TYPE, NAME) \ |
| WCM_OBJECT_OR_WEAK(TYPE, NAME, kID_##NAME, TYPE::Is##TYPE(obj), private) |
| |
| #define WCM_SMALL_CONST_NUMBER(TYPE, NAME) \ |
| TYPE WasmCompiledModule::NAME() const { \ |
| return static_cast<TYPE>(Smi::ToInt(get(kID_##NAME))); \ |
| } \ |
| \ |
| void WasmCompiledModule::set_##NAME(TYPE value) { \ |
| set(kID_##NAME, Smi::FromInt(value)); \ |
| } |
| |
| #define WCM_WEAK_LINK(TYPE, NAME) \ |
| WCM_OBJECT_OR_WEAK(WeakCell, weak_##NAME, kID_##NAME, obj->IsWeakCell(), \ |
| public) \ |
| \ |
| Handle<TYPE> WasmCompiledModule::NAME() const { \ |
| return handle(TYPE::cast(weak_##NAME()->value())); \ |
| } |
| |
| #define WCM_LARGE_NUMBER(TYPE, NAME) \ |
| TYPE WasmCompiledModule::NAME() const { \ |
| Object* value = get(kID_##NAME); \ |
| DCHECK(value->IsMutableHeapNumber()); \ |
| return static_cast<TYPE>(HeapNumber::cast(value)->value()); \ |
| } \ |
| \ |
| void WasmCompiledModule::set_##NAME(TYPE value) { \ |
| Object* number = get(kID_##NAME); \ |
| DCHECK(number->IsMutableHeapNumber()); \ |
| HeapNumber::cast(number)->set_value(static_cast<double>(value)); \ |
| } \ |
| \ |
| void WasmCompiledModule::recreate_##NAME(Handle<WasmCompiledModule> obj, \ |
| Factory* factory, TYPE init_val) { \ |
| Handle<HeapNumber> number = factory->NewHeapNumber( \ |
| static_cast<double>(init_val), MutableMode::MUTABLE, TENURED); \ |
| obj->set(kID_##NAME, *number); \ |
| } \ |
| bool WasmCompiledModule::has_##NAME() const { \ |
| return get(kID_##NAME)->IsMutableHeapNumber(); \ |
| } |
| |
| #define DEFINITION(KIND, TYPE, NAME) WCM_##KIND(TYPE, NAME) |
| WCM_PROPERTY_TABLE(DEFINITION) |
| #undef DECLARATION |
| |
| #undef WCM_CONST_OBJECT |
| #undef WCM_LARGE_NUMBER |
| #undef WCM_OBJECT_OR_WEAK |
| #undef WCM_SMALL_CONST_NUMBER |
| #undef WCM_WEAK_LINK |
| |
| uint32_t WasmTableObject::current_length() { return functions()->length(); } |
| |
| bool WasmTableObject::has_maximum_length() { |
| return maximum_length()->Number() >= 0; |
| } |
| |
| bool WasmMemoryObject::has_maximum_pages() { return maximum_pages() >= 0; } |
| |
| Address WasmCompiledModule::GetGlobalsStartOrNull() const { |
| return has_globals_start() ? reinterpret_cast<Address>(globals_start()) |
| : nullptr; |
| } |
| |
| void WasmCompiledModule::ReplaceCodeTableForTesting( |
| Handle<FixedArray> testing_table) { |
| set_code_table(testing_table); |
| } |
| |
| #include "src/objects/object-macros-undef.h" |
| |
| } // namespace internal |
| } // namespace v8 |
| |
| #endif // V8_WASM_OBJECTS_INL_H_ |