[wasm] Allow mixing tagged and untagged fields

In WasmInstanceObject we want to reorder the fields such that fields
that are often accessed from generated code have a small offset (<128
bytes). This requires mixing tagged and untagged fields.
This CL prepares the existing GC support for WasmInstanceObject to only
visit the listed tagged fields.

R=titzer@chromium.org

Bug: chromium:839919
Change-Id: Ia85d7bcfff54af35785b6d573e7e682a26c39ae6
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1538119Reviewed-by: Ben Titzer <titzer@chromium.org>
Commit-Queue: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#60468}

src/objects-body-descriptors-inl.h

@@ -5,8 +5,11 @@
 #ifndef V8_OBJECTS_BODY_DESCRIPTORS_INL_H_
 #define V8_OBJECTS_BODY_DESCRIPTORS_INL_H_
 
-#include "src/feedback-vector.h"
 #include "src/objects-body-descriptors.h"
+
+#include <algorithm>
+
+#include "src/feedback-vector.h"
 #include "src/objects/cell.h"
 #include "src/objects/data-handler.h"
 #include "src/objects/foreign-inl.h"
@@ -658,15 +661,25 @@ class SeqTwoByteString::BodyDescriptor final : public BodyDescriptorBase {
 class WasmInstanceObject::BodyDescriptor final : public BodyDescriptorBase {
  public:
   static bool IsValidSlot(Map map, HeapObject obj, int offset) {
-    if (offset < kMemoryStartOffset) return true;
-    if (offset < kModuleObjectOffset) return false;
+    SLOW_DCHECK(std::is_sorted(std::begin(kTaggedFieldOffsets),
+                               std::end(kTaggedFieldOffsets)));
+    STATIC_ASSERT(sizeof(*kTaggedFieldOffsets) == sizeof(uint16_t));
+    if (offset < int{8 * sizeof(*kTaggedFieldOffsets)} &&
+        std::binary_search(std::begin(kTaggedFieldOffsets),
+                           std::end(kTaggedFieldOffsets),
+                           static_cast<uint16_t>(offset))) {
+      return true;
+    }
     return IsValidJSObjectSlotImpl(map, obj, offset);
   }
 
   template <typename ObjectVisitor>
   static inline void IterateBody(Map map, HeapObject obj, int object_size,
                                  ObjectVisitor* v) {
-    IteratePointers(obj, kPropertiesOrHashOffset, kEndOfTaggedFieldsOffset, v);
+    IteratePointer(obj, kPropertiesOrHashOffset, v);
+    for (uint16_t offset : kTaggedFieldOffsets) {
+      IteratePointer(obj, offset, v);
+    }
     IterateJSObjectBodyImpl(map, obj, kSize, object_size, v);
   }
 

src/wasm/wasm-objects.cc

@@ -1473,6 +1473,10 @@ Address ImportedFunctionEntry::target() {
   return instance_->imported_function_targets()[index_];
 }
 
+// static
+constexpr uint16_t WasmInstanceObject::kTaggedFieldOffsets[];
+
+// static
 bool WasmInstanceObject::EnsureIndirectFunctionTableWithMinimumSize(
     Handle<WasmInstanceObject> instance, uint32_t minimum_size) {
   uint32_t old_size = instance->indirect_function_table_size();

src/wasm/wasm-objects.h

@@ -497,12 +497,10 @@ class WasmInstanceObject : public JSObject {
   V(kNullValueOffset, kTaggedSize)                                        \
   V(kCEntryStubOffset, kTaggedSize)                                       \
   V(kWasmExportedFunctionsOffset, kTaggedSize)                            \
-  V(kEndOfTaggedFieldsOffset, 0)                                          \
   /* Raw data. */                                                         \
   V(kIndirectFunctionTableSizeOffset, kUInt32Size)                        \
   /* Optional padding to align system pointer size fields */              \
   V(kOptionalPaddingOffset, POINTER_SIZE_PADDING(kOptionalPaddingOffset)) \
-  V(kFirstSystemPointerFieldOffset, 0)                                    \
   V(kMemoryStartOffset, kSystemPointerSize)                               \
   V(kMemorySizeOffset, kSizetSize)                                        \
   V(kMemoryMaskOffset, kSizetSize)                                        \
@@ -524,10 +522,31 @@ class WasmInstanceObject : public JSObject {
 
   DEFINE_FIELD_OFFSET_CONSTANTS(JSObject::kHeaderSize,
                                 WASM_INSTANCE_OBJECT_FIELDS)
+  STATIC_ASSERT(IsAligned(kSize, kTaggedSize));
+#define ASSERT_FIELD_ALIGNED(offset, size) \
+  STATIC_ASSERT(size == 0 || IsAligned(offset, size));
+  WASM_INSTANCE_OBJECT_FIELDS(ASSERT_FIELD_ALIGNED)
+#undef ASSERT_FIELD_ALIGNED
 #undef WASM_INSTANCE_OBJECT_FIELDS
 
-  STATIC_ASSERT(IsAligned(kFirstSystemPointerFieldOffset, kSystemPointerSize));
-  STATIC_ASSERT(IsAligned(kSize, kTaggedSize));
+  static constexpr uint16_t kTaggedFieldOffsets[] = {
+      kModuleObjectOffset,
+      kExportsObjectOffset,
+      kNativeContextOffset,
+      kMemoryObjectOffset,
+      kUntaggedGlobalsBufferOffset,
+      kTaggedGlobalsBufferOffset,
+      kImportedMutableGlobalsBuffersOffset,
+      kDebugInfoOffset,
+      kTablesOffset,
+      kImportedFunctionRefsOffset,
+      kIndirectFunctionTableRefsOffset,
+      kManagedNativeAllocationsOffset,
+      kExceptionsTableOffset,
+      kUndefinedValueOffset,
+      kNullValueOffset,
+      kCEntryStubOffset,
+      kWasmExportedFunctionsOffset};
 
   V8_EXPORT_PRIVATE const wasm::WasmModule* module();