Line data    Source code

       1             : // Copyright 2017 the V8 project authors. All rights reserved.
       2             : // Use of this source code is governed by a BSD-style license that can be
       3             : // found in the LICENSE file.
       4             : 
       5             : #ifndef V8_WASM_WASM_OBJECTS_INL_H_
       6             : #define V8_WASM_WASM_OBJECTS_INL_H_
       7             : 
       8             : #include "src/wasm/wasm-objects.h"
       9             : 
      10             : #include "src/contexts-inl.h"
      11             : #include "src/heap/heap-inl.h"
      12             : #include "src/objects/foreign-inl.h"
      13             : #include "src/objects/heap-number-inl.h"
      14             : #include "src/objects/js-array-buffer-inl.h"
      15             : #include "src/objects/managed.h"
      16             : #include "src/objects/oddball-inl.h"
      17             : #include "src/v8memory.h"
      18             : #include "src/wasm/wasm-code-manager.h"
      19             : #include "src/wasm/wasm-module.h"
      20             : 
      21             : // Has to be the last include (doesn't have include guards)
      22             : #include "src/objects/object-macros.h"
      23             : 
      24             : namespace v8 {
      25             : namespace internal {
      26             : 
      27         342 : OBJECT_CONSTRUCTORS_IMPL(WasmExceptionObject, JSObject)
      28         846 : OBJECT_CONSTRUCTORS_IMPL(WasmExceptionTag, Struct)
      29     2307096 : OBJECT_CONSTRUCTORS_IMPL(WasmExportedFunctionData, Struct)
      30     1022152 : OBJECT_CONSTRUCTORS_IMPL(WasmDebugInfo, Struct)
      31       43992 : OBJECT_CONSTRUCTORS_IMPL(WasmGlobalObject, JSObject)
      32    55755864 : OBJECT_CONSTRUCTORS_IMPL(WasmInstanceObject, JSObject)
      33      210842 : OBJECT_CONSTRUCTORS_IMPL(WasmMemoryObject, JSObject)
      34    13687378 : OBJECT_CONSTRUCTORS_IMPL(WasmModuleObject, JSObject)
      35       63198 : OBJECT_CONSTRUCTORS_IMPL(WasmTableObject, JSObject)
      36       17242 : OBJECT_CONSTRUCTORS_IMPL(AsmWasmData, Struct)
      37             : 
      38             : NEVER_READ_ONLY_SPACE_IMPL(WasmDebugInfo)
      39             : 
      40      511076 : CAST_ACCESSOR(WasmDebugInfo)
      41         171 : CAST_ACCESSOR(WasmExceptionObject)
      42         423 : CAST_ACCESSOR(WasmExceptionTag)
      43     1153547 : CAST_ACCESSOR(WasmExportedFunctionData)
      44       21996 : CAST_ACCESSOR(WasmGlobalObject)
      45    27877932 : CAST_ACCESSOR(WasmInstanceObject)
      46      105420 : CAST_ACCESSOR(WasmMemoryObject)
      47     6843689 : CAST_ACCESSOR(WasmModuleObject)
      48       31599 : CAST_ACCESSOR(WasmTableObject)
      49        8621 : CAST_ACCESSOR(AsmWasmData)
      50             : 
      51             : #define OPTIONAL_ACCESSORS(holder, name, type, offset) \
      52             :   bool holder::has_##name() {                          \
      53             :     return !READ_FIELD(*this, offset)->IsUndefined();  \
      54             :   }                                                    \
      55             :   ACCESSORS(holder, name, type, offset)
      56             : 
      57             : #define READ_PRIMITIVE_FIELD(p, type, offset) \
      58             :   (*reinterpret_cast<type const*>(FIELD_ADDR(p, offset)))
      59             : 
      60             : #define WRITE_PRIMITIVE_FIELD(p, type, offset, value) \
      61             :   (*reinterpret_cast<type*>(FIELD_ADDR(p, offset)) = value)
      62             : 
      63             : #define PRIMITIVE_ACCESSORS(holder, name, type, offset) \
      64             :   type holder::name() const {                           \
      65             :     return READ_PRIMITIVE_FIELD(this, type, offset);    \
      66             :   }                                                     \
      67             :   void holder::set_##name(type value) {                 \
      68             :     WRITE_PRIMITIVE_FIELD(this, type, offset, value);   \
      69             :   }
      70             : 
      71             : // WasmModuleObject
      72    22800247 : ACCESSORS(WasmModuleObject, managed_native_module, Managed<wasm::NativeModule>,
      73             :           kNativeModuleOffset)
      74     8126077 : ACCESSORS(WasmModuleObject, export_wrappers, FixedArray, kExportWrappersOffset)
      75     8155871 : ACCESSORS(WasmModuleObject, script, Script, kScriptOffset)
      76    19778910 : ACCESSORS(WasmModuleObject, weak_instance_list, WeakArrayList,
      77             :           kWeakInstanceListOffset)
      78       31642 : OPTIONAL_ACCESSORS(WasmModuleObject, asm_js_offset_table, ByteArray,
      79             :                    kAsmJsOffsetTableOffset)
      80      303577 : OPTIONAL_ACCESSORS(WasmModuleObject, breakpoint_infos, FixedArray,
      81             :                    kBreakPointInfosOffset)
      82    15172010 : wasm::NativeModule* WasmModuleObject::native_module() const {
      83    30344045 :   return managed_native_module()->raw();
      84             : }
      85         277 : std::shared_ptr<wasm::NativeModule> WasmModuleObject::shared_native_module()
      86             :     const {
      87         554 :   return managed_native_module()->get();
      88             : }
      89             : const wasm::WasmModule* WasmModuleObject::module() const {
      90             :   // TODO(clemensh): Remove this helper (inline in callers).
      91     6108961 :   return native_module()->module();
      92             : }
      93             : void WasmModuleObject::reset_breakpoint_infos() {
      94             :   WRITE_FIELD(this, kBreakPointInfosOffset,
      95             :               GetReadOnlyRoots().undefined_value());
      96             : }
      97             : bool WasmModuleObject::is_asm_js() {
      98      173974 :   bool asm_js = module()->origin == wasm::kAsmJsOrigin;
      99             :   DCHECK_EQ(asm_js, script()->IsUserJavaScript());
     100             :   DCHECK_EQ(asm_js, has_asm_js_offset_table());
     101             :   return asm_js;
     102             : }
     103             : 
     104             : // WasmTableObject
     105      104265 : ACCESSORS(WasmTableObject, functions, FixedArray, kFunctionsOffset)
     106       15696 : ACCESSORS(WasmTableObject, maximum_length, Object, kMaximumLengthOffset)
     107       41283 : ACCESSORS(WasmTableObject, dispatch_tables, FixedArray, kDispatchTablesOffset)
     108             : 
     109             : // WasmMemoryObject
     110      611199 : ACCESSORS(WasmMemoryObject, array_buffer, JSArrayBuffer, kArrayBufferOffset)
     111       87327 : SMI_ACCESSORS(WasmMemoryObject, maximum_pages, kMaximumPagesOffset)
     112      484471 : OPTIONAL_ACCESSORS(WasmMemoryObject, instances, WeakArrayList, kInstancesOffset)
     113             : 
     114             : // WasmGlobalObject
     115      103077 : ACCESSORS(WasmGlobalObject, untagged_buffer, JSArrayBuffer,
     116             :           kUntaggedBufferOffset)
     117        2664 : ACCESSORS(WasmGlobalObject, tagged_buffer, FixedArray, kTaggedBufferOffset)
     118       50481 : SMI_ACCESSORS(WasmGlobalObject, offset, kOffsetOffset)
     119       93141 : SMI_ACCESSORS(WasmGlobalObject, flags, kFlagsOffset)
     120       34308 : BIT_FIELD_ACCESSORS(WasmGlobalObject, flags, type, WasmGlobalObject::TypeBits)
     121       44487 : BIT_FIELD_ACCESSORS(WasmGlobalObject, flags, is_mutable,
     122             :                     WasmGlobalObject::IsMutableBit)
     123             : 
     124             : int WasmGlobalObject::type_size() const {
     125             :   return wasm::ValueTypes::ElementSizeInBytes(type());
     126             : }
     127             : 
     128       20241 : Address WasmGlobalObject::address() const {
     129             :   DCHECK_NE(type(), wasm::kWasmAnyRef);
     130             :   DCHECK_LE(offset() + type_size(), untagged_buffer()->byte_length());
     131       60723 :   return Address(untagged_buffer()->backing_store()) + offset();
     132             : }
     133             : 
     134             : int32_t WasmGlobalObject::GetI32() {
     135        3969 :   return ReadLittleEndianValue<int32_t>(address());
     136             : }
     137             : 
     138             : int64_t WasmGlobalObject::GetI64() {
     139          90 :   return ReadLittleEndianValue<int64_t>(address());
     140             : }
     141             : 
     142             : float WasmGlobalObject::GetF32() {
     143        3708 :   return ReadLittleEndianValue<float>(address());
     144             : }
     145             : 
     146             : double WasmGlobalObject::GetF64() {
     147        1971 :   return ReadLittleEndianValue<double>(address());
     148             : }
     149             : 
     150         288 : Handle<Object> WasmGlobalObject::GetAnyRef() {
     151             :   DCHECK_EQ(type(), wasm::kWasmAnyRef);
     152         576 :   return handle(tagged_buffer()->get(offset()), GetIsolate());
     153             : }
     154             : 
     155             : void WasmGlobalObject::SetI32(int32_t value) {
     156        4014 :   WriteLittleEndianValue<int32_t>(address(), value);
     157             : }
     158             : 
     159             : void WasmGlobalObject::SetI64(int64_t value) {
     160          90 :   WriteLittleEndianValue<int64_t>(address(), value);
     161             : }
     162             : 
     163             : void WasmGlobalObject::SetF32(float value) {
     164        4383 :   WriteLittleEndianValue<float>(address(), value);
     165             : }
     166             : 
     167             : void WasmGlobalObject::SetF64(double value) {
     168        2016 :   WriteLittleEndianValue<double>(address(), value);
     169             : }
     170             : 
     171         189 : void WasmGlobalObject::SetAnyRef(Handle<Object> value) {
     172             :   DCHECK_EQ(type(), wasm::kWasmAnyRef);
     173         189 :   tagged_buffer()->set(offset(), *value);
     174         189 : }
     175             : 
     176             : // WasmInstanceObject
     177     9316152 : PRIMITIVE_ACCESSORS(WasmInstanceObject, memory_start, byte*, kMemoryStartOffset)
     178     9322265 : PRIMITIVE_ACCESSORS(WasmInstanceObject, memory_size, size_t, kMemorySizeOffset)
     179     9300338 : PRIMITIVE_ACCESSORS(WasmInstanceObject, memory_mask, size_t, kMemoryMaskOffset)
     180     1518792 : PRIMITIVE_ACCESSORS(WasmInstanceObject, isolate_root, Address,
     181             :                     kIsolateRootOffset)
     182     1518792 : PRIMITIVE_ACCESSORS(WasmInstanceObject, stack_limit_address, Address,
     183             :                     kStackLimitAddressOffset)
     184     1518792 : PRIMITIVE_ACCESSORS(WasmInstanceObject, real_stack_limit_address, Address,
     185             :                     kRealStackLimitAddressOffset)
     186     1660862 : PRIMITIVE_ACCESSORS(WasmInstanceObject, imported_function_targets, Address*,
     187             :                     kImportedFunctionTargetsOffset)
     188     2913455 : PRIMITIVE_ACCESSORS(WasmInstanceObject, globals_start, byte*,
     189             :                     kGlobalsStartOffset)
     190     1519089 : PRIMITIVE_ACCESSORS(WasmInstanceObject, imported_mutable_globals, Address*,
     191             :                     kImportedMutableGlobalsOffset)
     192     1532862 : PRIMITIVE_ACCESSORS(WasmInstanceObject, indirect_function_table_size, uint32_t,
     193             :                     kIndirectFunctionTableSizeOffset)
     194    24293974 : PRIMITIVE_ACCESSORS(WasmInstanceObject, indirect_function_table_sig_ids,
     195             :                     uint32_t*, kIndirectFunctionTableSigIdsOffset)
     196    24290229 : PRIMITIVE_ACCESSORS(WasmInstanceObject, indirect_function_table_targets,
     197             :                     Address*, kIndirectFunctionTableTargetsOffset)
     198     1518791 : PRIMITIVE_ACCESSORS(WasmInstanceObject, jump_table_start, Address,
     199             :                     kJumpTableStartOffset)
     200     1518873 : PRIMITIVE_ACCESSORS(WasmInstanceObject, data_segment_starts, Address*,
     201             :                     kDataSegmentStartsOffset)
     202     1518873 : PRIMITIVE_ACCESSORS(WasmInstanceObject, data_segment_sizes, uint32_t*,
     203             :                     kDataSegmentSizesOffset)
     204     1518873 : PRIMITIVE_ACCESSORS(WasmInstanceObject, dropped_data_segments, byte*,
     205             :                     kDroppedDataSegmentsOffset)
     206     1521043 : PRIMITIVE_ACCESSORS(WasmInstanceObject, dropped_elem_segments, byte*,
     207             :                     kDroppedElemSegmentsOffset)
     208             : 
     209    22667331 : ACCESSORS(WasmInstanceObject, module_object, WasmModuleObject,
     210             :           kModuleObjectOffset)
     211    71712508 : ACCESSORS(WasmInstanceObject, exports_object, JSObject, kExportsObjectOffset)
     212     7727814 : ACCESSORS(WasmInstanceObject, native_context, Context, kNativeContextOffset)
     213      422956 : OPTIONAL_ACCESSORS(WasmInstanceObject, memory_object, WasmMemoryObject,
     214             :                    kMemoryObjectOffset)
     215       19570 : OPTIONAL_ACCESSORS(WasmInstanceObject, untagged_globals_buffer, JSArrayBuffer,
     216             :                    kUntaggedGlobalsBufferOffset)
     217         720 : OPTIONAL_ACCESSORS(WasmInstanceObject, tagged_globals_buffer, FixedArray,
     218             :                    kTaggedGlobalsBufferOffset)
     219        1926 : OPTIONAL_ACCESSORS(WasmInstanceObject, imported_mutable_globals_buffers,
     220             :                    FixedArray, kImportedMutableGlobalsBuffersOffset)
     221     2528854 : OPTIONAL_ACCESSORS(WasmInstanceObject, debug_info, WasmDebugInfo,
     222             :                    kDebugInfoOffset)
     223        9468 : OPTIONAL_ACCESSORS(WasmInstanceObject, table_object, WasmTableObject,
     224             :                    kTableObjectOffset)
     225     8020062 : ACCESSORS(WasmInstanceObject, imported_function_refs, FixedArray,
     226             :           kImportedFunctionRefsOffset)
     227    68324132 : OPTIONAL_ACCESSORS(WasmInstanceObject, indirect_function_table_refs, FixedArray,
     228             :                    kIndirectFunctionTableRefsOffset)
     229     7604196 : OPTIONAL_ACCESSORS(WasmInstanceObject, managed_native_allocations, Foreign,
     230             :                    kManagedNativeAllocationsOffset)
     231        4410 : OPTIONAL_ACCESSORS(WasmInstanceObject, exceptions_table, FixedArray,
     232             :                    kExceptionsTableOffset)
     233     7593960 : ACCESSORS(WasmInstanceObject, undefined_value, Oddball, kUndefinedValueOffset)
     234     7593956 : ACCESSORS(WasmInstanceObject, null_value, Oddball, kNullValueOffset)
     235     7593957 : ACCESSORS(WasmInstanceObject, centry_stub, Code, kCEntryStubOffset)
     236             : 
     237             : inline bool WasmInstanceObject::has_indirect_function_table() {
     238             :   return indirect_function_table_sig_ids() != nullptr;
     239             : }
     240             : 
     241             : void WasmInstanceObject::clear_padding() {
     242             :   if (FIELD_SIZE(kOptionalPaddingOffset) != 0) {
     243             :     DCHECK_EQ(4, FIELD_SIZE(kOptionalPaddingOffset));
     244     1518792 :     memset(reinterpret_cast<void*>(address() + kOptionalPaddingOffset), 0,
     245     1518792 :            FIELD_SIZE(kOptionalPaddingOffset));
     246             :   }
     247             : }
     248             : 
     249             : IndirectFunctionTableEntry::IndirectFunctionTableEntry(
     250             :     Handle<WasmInstanceObject> instance, int index)
     251    22768052 :     : instance_(instance), index_(index) {
     252             :   DCHECK_GE(index, 0);
     253             :   DCHECK_LT(index, instance->indirect_function_table_size());
     254             : }
     255             : 
     256             : ImportedFunctionEntry::ImportedFunctionEntry(
     257             :     Handle<WasmInstanceObject> instance, int index)
     258      142034 :     : instance_(instance), index_(index) {
     259             :   DCHECK_GE(index, 0);
     260             :   DCHECK_LT(index, instance->module()->num_imported_functions);
     261             : }
     262             : 
     263             : // WasmExceptionObject
     264         729 : ACCESSORS(WasmExceptionObject, serialized_signature, PodArray<wasm::ValueType>,
     265             :           kSerializedSignatureOffset)
     266         702 : ACCESSORS(WasmExceptionObject, exception_tag, HeapObject, kExceptionTagOffset)
     267             : 
     268             : // WasmExportedFunction
     269      514384 : WasmExportedFunction::WasmExportedFunction(Address ptr) : JSFunction(ptr) {
     270             :   SLOW_DCHECK(IsWasmExportedFunction(*this));
     271      514384 : }
     272      514386 : CAST_ACCESSOR(WasmExportedFunction)
     273             : 
     274             : // WasmExportedFunctionData
     275     2125492 : ACCESSORS(WasmExportedFunctionData, wrapper_code, Code, kWrapperCodeOffset)
     276     2445673 : ACCESSORS(WasmExportedFunctionData, instance, WasmInstanceObject,
     277             :           kInstanceOffset)
     278      265688 : SMI_ACCESSORS(WasmExportedFunctionData, jump_table_offset,
     279             :               kJumpTableOffsetOffset)
     280      765226 : SMI_ACCESSORS(WasmExportedFunctionData, function_index, kFunctionIndexOffset)
     281             : 
     282             : // WasmDebugInfo
     283     6526568 : ACCESSORS(WasmDebugInfo, wasm_instance, WasmInstanceObject, kInstanceOffset)
     284     2622512 : ACCESSORS(WasmDebugInfo, interpreter_handle, Object, kInterpreterHandleOffset)
     285     2292862 : ACCESSORS(WasmDebugInfo, interpreted_functions, FixedArray,
     286             :           kInterpretedFunctionsOffset)
     287        3825 : OPTIONAL_ACCESSORS(WasmDebugInfo, locals_names, FixedArray, kLocalsNamesOffset)
     288       37740 : OPTIONAL_ACCESSORS(WasmDebugInfo, c_wasm_entries, FixedArray,
     289             :                    kCWasmEntriesOffset)
     290       10620 : OPTIONAL_ACCESSORS(WasmDebugInfo, c_wasm_entry_map, Managed<wasm::SignatureMap>,
     291             :                    kCWasmEntryMapOffset)
     292             : 
     293             : #undef OPTIONAL_ACCESSORS
     294             : #undef READ_PRIMITIVE_FIELD
     295             : #undef WRITE_PRIMITIVE_FIELD
     296             : #undef PRIMITIVE_ACCESSORS
     297             : 
     298       17766 : uint32_t WasmTableObject::current_length() { return functions()->length(); }
     299             : 
     300             : bool WasmMemoryObject::has_maximum_pages() { return maximum_pages() >= 0; }
     301             : 
     302             : // WasmExceptionTag
     303         423 : SMI_ACCESSORS(WasmExceptionTag, index, kIndexOffset)
     304             : 
     305             : // AsmWasmData
     306       20561 : ACCESSORS(AsmWasmData, managed_native_module, Managed<wasm::NativeModule>,
     307             :           kManagedNativeModuleOffset)
     308       31833 : ACCESSORS(AsmWasmData, export_wrappers, FixedArray, kExportWrappersOffset)
     309       31833 : ACCESSORS(AsmWasmData, asm_js_offset_table, ByteArray, kAsmJsOffsetTableOffset)
     310       31833 : ACCESSORS(AsmWasmData, uses_bitset, HeapNumber, kUsesBitsetOffset)
     311             : 
     312             : #include "src/objects/object-macros-undef.h"
     313             : 
     314             : }  // namespace internal
     315             : }  // namespace v8
     316             : 
     317             : #endif  // V8_WASM_WASM_OBJECTS_INL_H_