Cleanup handling of {Strong,Weak}Fields sections

This is mainly a torque change, but as a drive-by we get rid of
kStartOfPointerFieldsOffset
kEndOfTaggedFieldsOffset
which often are used to enclose a section of pointers in an object.

Bug: v8:7793
Change-Id: I52d83d09249a3cc6a99e7e7506e154ccfca53a12
Reviewed-on: https://chromium-review.googlesource.com/c/v8/v8/+/1615249
Commit-Queue: Sigurd Schneider <sigurds@chromium.org>
Reviewed-by: Michael Starzinger <mstarzinger@chromium.org>
Reviewed-by: Tobias Tebbi <tebbi@chromium.org>
Reviewed-by: Ulan Degenbaev <ulan@chromium.org>
Cr-Commit-Position: refs/heads/master@{#61722}

src/builtins/base.tq

@@ -230,12 +230,17 @@ extern class SourcePositionTableWithFrameCache extends Struct {
   stack_frame_cache: Object;
 }
 
+// We make this class abstract because it is missing the variable-sized part,
+// which is still impossible to express in Torque.
+@abstract
 extern class DescriptorArray extends HeapObject {
   number_of_all_descriptors: uint16;
   number_of_descriptors: uint16;
   raw_number_of_marked_descriptors: uint16;
   filler16_bits: uint16;
   enum_cache: EnumCache;
+  // DescriptorEntry needs to be a struct with three fields.
+  // desriptors : DescriptorEntry[number_of_all_descriptors]
 }
 
 // These intrinsics should never be called from Torque code. They're used

src/diagnostics/objects-debug.cc

@@ -1697,7 +1697,7 @@ void WasmInstanceObject::WasmInstanceObjectVerify(Isolate* isolate) {
   // Just generically check all tagged fields. Don't check the untagged fields,
   // as some of them might still contain the "undefined" value if the
   // WasmInstanceObject is not fully set up yet.
-  for (int offset = kHeaderSize; offset < kEndOfTaggedFieldsOffset;
+  for (int offset = kHeaderSize; offset < kEndOfStrongFieldsOffset;
        offset += kTaggedSize) {
     VerifyObjectField(isolate, offset);
   }

src/objects-body-descriptors-inl.h

@@ -248,8 +248,11 @@ class JSWeakRef::BodyDescriptor final : public BodyDescriptorBase {
 class SharedFunctionInfo::BodyDescriptor final : public BodyDescriptorBase {
  public:
   static bool IsValidSlot(Map map, HeapObject obj, int offset) {
-    return FixedBodyDescriptor<kStartOfPointerFieldsOffset,
-                               kEndOfTaggedFieldsOffset,
+    static_assert(kEndOfWeakFieldsOffset == kStartOfStrongFieldsOffset,
+                  "Leverage that strong fields directly follow weak fields"
+                  "to call FixedBodyDescriptor<...>::IsValidSlot below");
+    return FixedBodyDescriptor<kStartOfWeakFieldsOffset,
+                               kEndOfStrongFieldsOffset,
                                kAlignedSize>::IsValidSlot(map, obj, offset);
   }
 
@@ -258,7 +261,7 @@ class SharedFunctionInfo::BodyDescriptor final : public BodyDescriptorBase {
                                  ObjectVisitor* v) {
     IterateCustomWeakPointer(obj, kFunctionDataOffset, v);
     IteratePointers(obj, SharedFunctionInfo::kStartOfStrongFieldsOffset,
-                    SharedFunctionInfo::kEndOfTaggedFieldsOffset, v);
+                    SharedFunctionInfo::kEndOfStrongFieldsOffset, v);
   }
 
   static inline int SizeOf(Map map, HeapObject object) {
@@ -714,8 +717,12 @@ class WasmInstanceObject::BodyDescriptor final : public BodyDescriptorBase {
 class Map::BodyDescriptor final : public BodyDescriptorBase {
  public:
   static bool IsValidSlot(Map map, HeapObject obj, int offset) {
-    return offset >= Map::kStartOfPointerFieldsOffset &&
-           offset < Map::kEndOfTaggedFieldsOffset;
+    static_assert(
+        Map::kEndOfStrongFieldsOffset == Map::kStartOfWeakFieldsOffset,
+        "Leverage that weak fields directly follow strong fields for the "
+        "check below");
+    return offset >= Map::kStartOfStrongFieldsOffset &&
+           offset < Map::kEndOfWeakFieldsOffset;
   }
 
   template <typename ObjectVisitor>

src/objects/descriptor-array-inl.h

@@ -92,7 +92,11 @@ int DescriptorArray::SearchWithCache(Isolate* isolate, Name name, Map map) {
 }
 
 ObjectSlot DescriptorArray::GetFirstPointerSlot() {
-  return RawField(DescriptorArray::kStartOfPointerFieldsOffset);
+  static_assert(kEndOfStrongFieldsOffset == kStartOfWeakFieldsOffset,
+                "Weak and strong fields are continuous.");
+  static_assert(kEndOfWeakFieldsOffset == kHeaderSize,
+                "Weak fields extend up to the end of the header.");
+  return RawField(DescriptorArray::kStartOfStrongFieldsOffset);
 }
 
 ObjectSlot DescriptorArray::GetDescriptorSlot(int descriptor) {

src/objects/descriptor-array.h

@@ -141,9 +141,7 @@ class DescriptorArray : public HeapObject {
   // Layout description.
   DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize,
                                 TORQUE_GENERATED_DESCRIPTOR_ARRAY_FIELDS)
-  static constexpr int kHeaderSize = kSize;
-
-  STATIC_ASSERT(IsAligned(kStartOfPointerFieldsOffset, kTaggedSize));
+  STATIC_ASSERT(IsAligned(kStartOfWeakFieldsOffset, kTaggedSize));
   STATIC_ASSERT(IsAligned(kHeaderSize, kTaggedSize));
 
   // Garbage collection support.
@@ -165,8 +163,13 @@ class DescriptorArray : public HeapObject {
   inline ObjectSlot GetKeySlot(int descriptor);
   inline MaybeObjectSlot GetValueSlot(int descriptor);
 
-  using BodyDescriptor =
-    FlexibleWeakBodyDescriptor<kStartOfPointerFieldsOffset>;
+  static_assert(kEndOfStrongFieldsOffset == kStartOfWeakFieldsOffset,
+                "Weak fields follow strong fields.");
+  static_assert(kEndOfWeakFieldsOffset == kHeaderSize,
+                "Weak fields extend up to the end of the header.");
+  // We use this visitor to also visitor to also visit the enum_cache, which is
+  // the only tagged field in the header, and placed at the end of the header.
+  using BodyDescriptor = FlexibleWeakBodyDescriptor<kStartOfStrongFieldsOffset>;
 
   // Layout of descriptor.
   // Naming is consistent with Dictionary classes for easy templating.

src/objects/shared-function-info.h

@@ -119,9 +119,9 @@ class UncompiledData : public HeapObject {
 
   // Layout description.
 #define UNCOMPILED_DATA_FIELDS(V)                                         \
-  V(kStartOfPointerFieldsOffset, 0)                                       \
+  V(kStartOfStrongFieldsOffset, 0)                                        \
   V(kInferredNameOffset, kTaggedSize)                                     \
-  V(kEndOfTaggedFieldsOffset, 0)                                          \
+  V(kEndOfStrongFieldsOffset, 0)                                          \
   /* Raw data fields. */                                                  \
   V(kStartPositionOffset, kInt32Size)                                     \
   V(kEndPositionOffset, kInt32Size)                                       \
@@ -133,8 +133,8 @@ class UncompiledData : public HeapObject {
   DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize, UNCOMPILED_DATA_FIELDS)
 #undef UNCOMPILED_DATA_FIELDS
 
-  using BodyDescriptor = FixedBodyDescriptor<kStartOfPointerFieldsOffset,
-                                             kEndOfTaggedFieldsOffset, kSize>;
+  using BodyDescriptor = FixedBodyDescriptor<kStartOfStrongFieldsOffset,
+                                             kEndOfStrongFieldsOffset, kSize>;
 
   // Clear uninitialized padding space.
   inline void clear_padding();
@@ -180,9 +180,9 @@ class UncompiledDataWithPreparseData : public UncompiledData {
   // Layout description.
 
 #define UNCOMPILED_DATA_WITH_PREPARSE_DATA_FIELDS(V) \
-  V(kStartOfPointerFieldsOffset, 0)                  \
+  V(kStartOfStrongFieldsOffset, 0)                   \
   V(kPreparseDataOffset, kTaggedSize)                \
-  V(kEndOfTaggedFieldsOffset, 0)                     \
+  V(kEndOfStrongFieldsOffset, 0)                     \
   /* Total size. */                                  \
   V(kSize, 0)
 
@@ -195,7 +195,7 @@ class UncompiledDataWithPreparseData : public UncompiledData {
 
   using BodyDescriptor = SubclassBodyDescriptor<
       UncompiledData::BodyDescriptor,
-      FixedBodyDescriptor<kStartOfPointerFieldsOffset, kEndOfTaggedFieldsOffset,
+      FixedBodyDescriptor<kStartOfStrongFieldsOffset, kEndOfStrongFieldsOffset,
                           kSize>>;
 
   OBJECT_CONSTRUCTORS(UncompiledDataWithPreparseData, UncompiledData);

src/wasm/wasm-objects.h

@@ -704,8 +704,8 @@ class WasmCapiFunctionData : public Struct {
   DEFINE_FIELD_OFFSET_CONSTANTS(HeapObject::kHeaderSize,
                                 TORQUE_GENERATED_WASM_CAPI_FUNCTION_DATA_FIELDS)
 
-  STATIC_ASSERT(kStartOfPointerFieldsOffset == kWrapperCodeOffset);
-  typedef FlexibleBodyDescriptor<kStartOfPointerFieldsOffset> BodyDescriptor;
+  STATIC_ASSERT(kStartOfStrongFieldsOffset == kWrapperCodeOffset);
+  typedef FlexibleBodyDescriptor<kStartOfStrongFieldsOffset> BodyDescriptor;
 
   OBJECT_CONSTRUCTORS(WasmCapiFunctionData, Struct);
 };