diff --git a/pkg/front_end/lib/src/fasta/builder/class_builder.dart b/pkg/front_end/lib/src/fasta/builder/class_builder.dart
index 47a66ca..d545175 100644
--- a/pkg/front_end/lib/src/fasta/builder/class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/class_builder.dart
@@ -31,7 +31,6 @@
 import 'package:kernel/type_environment.dart'
     show SubtypeCheckMode, TypeEnvironment;
 
-import '../dill/dill_member_builder.dart';
 import '../fasta_codes.dart';
 import '../kernel/kernel_helper.dart';
 import '../kernel/redirecting_factory_body.dart' show RedirectingFactoryBody;
@@ -877,28 +876,6 @@
     if (targetBuilder == null) return null;
     if (targetBuilder is FunctionBuilder) {
       targetNode = targetBuilder.function;
-    } else if (targetBuilder is DillConstructorBuilder) {
-      // It seems that the [redirectionTarget.target] is an instance of
-      // [DillMemberBuilder] whenever the redirectee is an implicit constructor,
-      // e.g.
-      //
-      //   class A {
-      //     factory A() = B;
-      //   }
-      //   class B implements A {}
-      //
-      targetNode = targetBuilder.constructor.function;
-    } else if (targetBuilder is DillFactoryBuilder) {
-      // It seems that the [redirectionTarget.target] is an instance of
-      // [DillMemberBuilder] whenever the redirectee is an implicit constructor,
-      // e.g.
-      //
-      //   class A {
-      //     factory A() = B;
-      //   }
-      //   class B implements A {}
-      //
-      targetNode = targetBuilder.procedure.function;
     } else if (targetBuilder is AmbiguousBuilder) {
       // Multiple definitions with the same name: An error has already been
       // issued.
diff --git a/pkg/front_end/lib/src/fasta/builder/procedure_builder.dart b/pkg/front_end/lib/src/fasta/builder/procedure_builder.dart
index 71ca0c2..85e54ac 100644
--- a/pkg/front_end/lib/src/fasta/builder/procedure_builder.dart
+++ b/pkg/front_end/lib/src/fasta/builder/procedure_builder.dart
@@ -7,26 +7,8 @@
 import 'function_builder.dart';
 
 abstract class ProcedureBuilder implements FunctionBuilder {
-  int get charOpenParenOffset;
-
-  ProcedureBuilder? get patchForTesting;
-
-  AsyncMarker get actualAsyncModifier;
-
   Procedure get procedure;
 
   @override
   ProcedureKind get kind;
-
-  Procedure get actualProcedure;
-
-  @override
-  ProcedureBuilder get origin;
-
-  void set asyncModifier(AsyncMarker newModifier);
-
-  bool get isEligibleForTopLevelInference;
-
-  /// Returns `true` if this procedure is declared in an extension declaration.
-  bool get isExtensionMethod;
 }
diff --git a/pkg/front_end/lib/src/fasta/dill/dill_member_builder.dart b/pkg/front_end/lib/src/fasta/dill/dill_member_builder.dart
index 42d99a3..f3046a7 100644
--- a/pkg/front_end/lib/src/fasta/dill/dill_member_builder.dart
+++ b/pkg/front_end/lib/src/fasta/dill/dill_member_builder.dart
@@ -11,6 +11,7 @@
 import '../builder/constructor_builder.dart';
 import '../builder/member_builder.dart';
 
+import '../builder/procedure_builder.dart';
 import '../kernel/hierarchy/class_member.dart' show ClassMember;
 import '../kernel/hierarchy/members_builder.dart' show ClassMembersBuilder;
 import '../kernel/member_covariance.dart';
@@ -64,12 +65,6 @@
   @override
   bool get isFactory => identical(ProcedureKind.Factory, kind);
 
-  /*@override
-  bool get isRedirectingGenerativeConstructor {
-    return isConstructor &&
-        isRedirectingGenerativeConstructorImplementation(member as Constructor);
-  }*/
-
   @override
   bool get isSynthetic {
     final Member member = this.member;
@@ -79,12 +74,6 @@
   @override
   bool get isAssignable => false;
 
-  /*@override
-  void buildMembers(
-      LibraryBuilder library, void Function(Member, BuiltMemberKind) f) {
-    throw new UnsupportedError('DillMemberBuilder.buildMembers');
-  }*/
-
   List<ClassMember>? _localMembers;
   List<ClassMember>? _localSetters;
 
@@ -124,10 +113,23 @@
   bool get isAssignable => field.hasSetter;
 }
 
-class DillGetterBuilder extends DillMemberBuilder {
+abstract class DillProcedureBuilder extends DillMemberBuilder
+    implements ProcedureBuilder {
+  @override
   final Procedure procedure;
 
-  DillGetterBuilder(this.procedure, Builder parent)
+  DillProcedureBuilder(this.procedure, Builder parent)
+      : super(procedure, parent);
+
+  @override
+  ProcedureKind get kind => procedure.kind;
+
+  @override
+  FunctionNode get function => procedure.function;
+}
+
+class DillGetterBuilder extends DillProcedureBuilder {
+  DillGetterBuilder(Procedure procedure, Builder parent)
       : assert(procedure.kind == ProcedureKind.Getter),
         super(procedure, parent);
 
@@ -144,10 +146,8 @@
   Member get invokeTarget => procedure;
 }
 
-class DillSetterBuilder extends DillMemberBuilder {
-  final Procedure procedure;
-
-  DillSetterBuilder(this.procedure, Builder parent)
+class DillSetterBuilder extends DillProcedureBuilder {
+  DillSetterBuilder(Procedure procedure, Builder parent)
       : assert(procedure.kind == ProcedureKind.Setter),
         super(procedure, parent);
 
@@ -164,10 +164,8 @@
   Member? get invokeTarget => null;
 }
 
-class DillMethodBuilder extends DillMemberBuilder {
-  final Procedure procedure;
-
-  DillMethodBuilder(this.procedure, Builder parent)
+class DillMethodBuilder extends DillProcedureBuilder {
+  DillMethodBuilder(Procedure procedure, Builder parent)
       : assert(procedure.kind == ProcedureKind.Method),
         super(procedure, parent);
 
@@ -184,10 +182,8 @@
   Member get invokeTarget => procedure;
 }
 
-class DillOperatorBuilder extends DillMemberBuilder {
-  final Procedure procedure;
-
-  DillOperatorBuilder(this.procedure, Builder parent)
+class DillOperatorBuilder extends DillProcedureBuilder {
+  DillOperatorBuilder(Procedure procedure, Builder parent)
       : assert(procedure.kind == ProcedureKind.Operator),
         super(procedure, parent);
 
@@ -204,11 +200,10 @@
   Member get invokeTarget => procedure;
 }
 
-class DillFactoryBuilder extends DillMemberBuilder {
-  final Procedure procedure;
+class DillFactoryBuilder extends DillProcedureBuilder {
   final Procedure? _factoryTearOff;
 
-  DillFactoryBuilder(this.procedure, this._factoryTearOff, Builder parent)
+  DillFactoryBuilder(Procedure procedure, this._factoryTearOff, Builder parent)
       : super(procedure, parent);
 
   @override
diff --git a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
index 7b98124..f2a6f7f 100644
--- a/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
+++ b/pkg/front_end/lib/src/fasta/kernel/kernel_target.dart
@@ -40,7 +40,6 @@
 import '../builder/void_type_declaration_builder.dart';
 import '../compiler_context.dart' show CompilerContext;
 import '../crash.dart' show withCrashReporting;
-import '../dill/dill_member_builder.dart' show DillMemberBuilder;
 import '../dill/dill_target.dart' show DillTarget;
 import '../kernel/constructor_tearoff_lowering.dart';
 import '../loader.dart' show Loader;
@@ -517,11 +516,7 @@
         declaration = problem.getFirstDeclaration();
       }
       if (declaration is ProcedureBuilder) {
-        mainReference = declaration.actualProcedure.reference;
-      } else if (declaration is DillMemberBuilder) {
-        if (declaration.member is Procedure) {
-          mainReference = declaration.member.reference;
-        }
+        mainReference = declaration.procedure.reference;
       }
     }
     component.setMainMethodAndMode(mainReference, true, compiledMode);
diff --git a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
index 51311fb..c9eacac 100644
--- a/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_class_builder.dart
@@ -569,7 +569,7 @@
       } else {
         assert(
             // This is a synthesized constructor.
-            builder is DillConstructorBuilder,
+            builder is SyntheticSourceConstructorBuilder,
             "Unexpected constructor: $builder.");
       }
     }, includeInjectedConstructors: true);
diff --git a/pkg/front_end/lib/src/fasta/source/source_constructor_builder.dart b/pkg/front_end/lib/src/fasta/source/source_constructor_builder.dart
index 36e33bc..d6c3ae4 100644
--- a/pkg/front_end/lib/src/fasta/source/source_constructor_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_constructor_builder.dart
@@ -245,8 +245,7 @@
     _hasFormalsInferred = true;
   }
 
-  /* ConstructorBuilder | DillConstructorBuilder */
-  Object? _computeSuperTargetBuilder() {
+  ConstructorBuilder? _computeSuperTargetBuilder() {
     Constructor superTarget;
     ClassBuilder superclassBuilder;
 
@@ -280,8 +279,6 @@
           .lookup("", charOffset, library.fileUri);
       if (memberBuilder is ConstructorBuilder) {
         superTarget = memberBuilder.constructor;
-      } else if (memberBuilder is DillConstructorBuilder) {
-        superTarget = memberBuilder.constructor;
       } else {
         // The error in this case should be reported elsewhere.
         return null;
@@ -291,10 +288,7 @@
     MemberBuilder? constructorBuilder =
         superclassBuilder.findConstructorOrFactory(
             superTarget.name.text, charOffset, library.fileUri, library);
-    return constructorBuilder is ConstructorBuilder ||
-            constructorBuilder is DillConstructorBuilder
-        ? constructorBuilder
-        : null;
+    return constructorBuilder is ConstructorBuilder ? constructorBuilder : null;
   }
 
   void finalizeSuperInitializingFormals(ClassHierarchy classHierarchy,
@@ -310,7 +304,7 @@
       }
     }
 
-    Object? superTargetBuilder = _computeSuperTargetBuilder();
+    ConstructorBuilder? superTargetBuilder = _computeSuperTargetBuilder();
     Constructor superTarget;
     List<FormalParameterBuilder>? superFormals;
     if (superTargetBuilder is DeclaredSourceConstructorBuilder) {
@@ -459,7 +453,7 @@
 
   void addSuperParameterDefaultValueCloners(
       List<SynthesizedFunctionNode> synthesizedFunctionNodes) {
-    Object? superTargetBuilder = _computeSuperTargetBuilder();
+    ConstructorBuilder? superTargetBuilder = _computeSuperTargetBuilder();
     if (superTargetBuilder is DeclaredSourceConstructorBuilder) {
       superTargetBuilder
           .addSuperParameterDefaultValueCloners(synthesizedFunctionNodes);
diff --git a/pkg/front_end/lib/src/fasta/source/source_procedure_builder.dart b/pkg/front_end/lib/src/fasta/source/source_procedure_builder.dart
index 861506f..44af31f 100644
--- a/pkg/front_end/lib/src/fasta/source/source_procedure_builder.dart
+++ b/pkg/front_end/lib/src/fasta/source/source_procedure_builder.dart
@@ -24,10 +24,8 @@
 
 class SourceProcedureBuilder extends SourceFunctionBuilderImpl
     implements ProcedureBuilder {
-  @override
   final int charOpenParenOffset;
 
-  @override
   AsyncMarker actualAsyncModifier = AsyncMarker.Sync;
 
   @override
@@ -106,7 +104,6 @@
     }
   }
 
-  @override
   ProcedureBuilder? get patchForTesting =>
       dataForTesting?.patchForTesting as ProcedureBuilder?;
 
@@ -121,14 +118,12 @@
     return bodyInternal;
   }
 
-  @override
   void set asyncModifier(AsyncMarker newModifier) {
     actualAsyncModifier = newModifier;
     function.asyncMarker = actualAsyncModifier;
     function.dartAsyncMarker = actualAsyncModifier;
   }
 
-  @override
   bool get isEligibleForTopLevelInference {
     if (isDeclarationInstanceMember) {
       if (returnType == null) return true;
@@ -141,7 +136,6 @@
     return false;
   }
 
-  @override
   bool get isExtensionMethod {
     return parent is ExtensionBuilder;
   }
@@ -155,7 +149,6 @@
   @override
   Procedure get procedure => isPatch ? origin.procedure : _procedure;
 
-  @override
   Procedure get actualProcedure => _procedure;
 
   @override
diff --git a/runtime/platform/globals.h b/runtime/platform/globals.h
index 8e8c737..2a2c087 100644
--- a/runtime/platform/globals.h
+++ b/runtime/platform/globals.h
@@ -653,7 +653,7 @@
 // gcc enough that it can no longer see that you have cast one pointer
 // type to another thus avoiding the warning.
 template <class D, class S>
-inline D bit_cast(const S& source) {
+DART_FORCE_INLINE D bit_cast(const S& source) {
   static_assert(sizeof(D) == sizeof(S),
                 "Source and destination must have the same size");
 
@@ -669,7 +669,7 @@
 // obscure details in the C++ standard that make reinterpret_cast
 // virtually useless.
 template <class D, class S>
-inline D bit_copy(const S& source) {
+DART_FORCE_INLINE D bit_copy(const S& source) {
   D destination;
   // This use of memcpy is safe: source and destination cannot overlap.
   memcpy(&destination, reinterpret_cast<const void*>(&source),
diff --git a/runtime/vm/app_snapshot.cc b/runtime/vm/app_snapshot.cc
index de02c85..fd5ab028 100644
--- a/runtime/vm/app_snapshot.cc
+++ b/runtime/vm/app_snapshot.cc
@@ -2820,7 +2820,7 @@
       s->AssignRef(map);
       AutoTraceObject(map);
       const intptr_t length = UntaggedCompressedStackMaps::SizeField::decode(
-          map->untag()->payload()->flags_and_size);
+          map->untag()->payload()->flags_and_size());
       s->WriteUnsigned(length);
       target_memory_size_ +=
           compiler::target::CompressedStackMaps::InstanceSize(length);
@@ -2832,9 +2832,9 @@
     for (intptr_t i = 0; i < count; i++) {
       CompressedStackMapsPtr map = objects_[i];
       AutoTraceObject(map);
-      s->WriteUnsigned(map->untag()->payload()->flags_and_size);
+      s->WriteUnsigned(map->untag()->payload()->flags_and_size());
       const intptr_t length = UntaggedCompressedStackMaps::SizeField::decode(
-          map->untag()->payload()->flags_and_size);
+          map->untag()->payload()->flags_and_size());
       uint8_t* cdata =
           reinterpret_cast<uint8_t*>(map->untag()->payload()->data());
       s->WriteBytes(cdata, length);
@@ -2874,7 +2874,7 @@
           static_cast<CompressedStackMapsPtr>(d->Ref(id));
       Deserializer::InitializeHeader(map, kCompressedStackMapsCid,
                                      CompressedStackMaps::InstanceSize(length));
-      map->untag()->payload()->flags_and_size = flags_and_size;
+      map->untag()->payload()->set_flags_and_size(flags_and_size);
       uint8_t* cdata =
           reinterpret_cast<uint8_t*>(map->untag()->payload()->data());
       d->ReadBytes(cdata, length);
@@ -6978,7 +6978,7 @@
 
     // Now write collected stack maps after the binary search table.
     auto write_stack_map = [&](CompressedStackMapsPtr smap) {
-      const auto flags_and_size = smap->untag()->payload()->flags_and_size;
+      const auto flags_and_size = smap->untag()->payload()->flags_and_size();
       const auto payload_size =
           UntaggedCompressedStackMaps::SizeField::decode(flags_and_size);
       pc_mapping.WriteFixed<uint32_t>(flags_and_size);
diff --git a/runtime/vm/compiler/runtime_offsets_list.h b/runtime/vm/compiler/runtime_offsets_list.h
index 1328b23..e252e4d 100644
--- a/runtime/vm/compiler/runtime_offsets_list.h
+++ b/runtime/vm/compiler/runtime_offsets_list.h
@@ -350,7 +350,7 @@
   SIZEOF(CodeSourceMap, HeaderSize, UntaggedCodeSourceMap)                     \
   SIZEOF(CompressedStackMaps, ObjectHeaderSize, UntaggedCompressedStackMaps)   \
   SIZEOF(CompressedStackMaps, PayloadHeaderSize,                               \
-         UntaggedCompressedStackMaps::Payload)                                 \
+         UntaggedCompressedStackMaps::Payload::FlagsAndSizeHeader)             \
   SIZEOF(Context, header_size, UntaggedContext)                                \
   SIZEOF(Double, InstanceSize, UntaggedDouble)                                 \
   SIZEOF(DynamicLibrary, InstanceSize, UntaggedDynamicLibrary)                 \
diff --git a/runtime/vm/image_snapshot.cc b/runtime/vm/image_snapshot.cc
index e812345..36c7d34 100644
--- a/runtime/vm/image_snapshot.cc
+++ b/runtime/vm/image_snapshot.cc
@@ -529,7 +529,7 @@
       const CompressedStackMaps& map = CompressedStackMaps::Cast(obj);
       const intptr_t payload_size = map.payload_size();
       stream->WriteFixed<uint32_t>(
-          map.ptr()->untag()->payload()->flags_and_size);
+          map.ptr()->untag()->payload()->flags_and_size());
       stream->WriteBytes(map.ptr()->untag()->payload()->data(), payload_size);
     } else if (obj.IsCodeSourceMap()) {
       const CodeSourceMap& map = CodeSourceMap::Cast(obj);
diff --git a/runtime/vm/object.cc b/runtime/vm/object.cc
index 6fd3ef4..9bb4bb7 100644
--- a/runtime/vm/object.cc
+++ b/runtime/vm/object.cc
@@ -1035,8 +1035,7 @@
     CompressedStackMaps::initializeHandle(
         empty_compressed_stackmaps_,
         static_cast<CompressedStackMapsPtr>(address + kHeapObjectTag));
-    empty_compressed_stackmaps_->StoreNonPointer(
-        &empty_compressed_stackmaps_->untag()->payload()->flags_and_size, 0);
+    empty_compressed_stackmaps_->untag()->payload()->set_flags_and_size(0);
     empty_compressed_stackmaps_->SetCanonical();
   }
 
@@ -15074,12 +15073,10 @@
         Heap::kOld, CompressedStackMaps::ContainsCompressedPointers());
     NoSafepointScope no_safepoint;
     result ^= raw;
-    result.StoreNonPointer(
-        &result.untag()->payload()->flags_and_size,
+    result.untag()->payload()->set_flags_and_size(
         UntaggedCompressedStackMaps::GlobalTableBit::encode(is_global_table) |
-            UntaggedCompressedStackMaps::UsesTableBit::encode(
-                uses_global_table) |
-            UntaggedCompressedStackMaps::SizeField::encode(size));
+        UntaggedCompressedStackMaps::UsesTableBit::encode(uses_global_table) |
+        UntaggedCompressedStackMaps::SizeField::encode(size));
     auto cursor =
         result.UnsafeMutableNonPointer(result.untag()->payload()->data());
     memcpy(cursor, payload, size);  // NOLINT
diff --git a/runtime/vm/object.h b/runtime/vm/object.h
index 67a9e89..c402aab 100644
--- a/runtime/vm/object.h
+++ b/runtime/vm/object.h
@@ -5883,7 +5883,7 @@
   uintptr_t payload_size() const { return PayloadSizeOf(ptr()); }
   static uintptr_t PayloadSizeOf(const CompressedStackMapsPtr raw) {
     return UntaggedCompressedStackMaps::SizeField::decode(
-        raw->untag()->payload()->flags_and_size);
+        raw->untag()->payload()->flags_and_size());
   }
 
   const uint8_t* data() const { return ptr()->untag()->payload()->data(); }
@@ -5891,8 +5891,8 @@
   // Methods to allow use with PointerKeyValueTrait to create sets of CSMs.
   bool Equals(const CompressedStackMaps& other) const {
     // All of the table flags and payload size must match.
-    if (untag()->payload()->flags_and_size !=
-        other.untag()->payload()->flags_and_size) {
+    if (untag()->payload()->flags_and_size() !=
+        other.untag()->payload()->flags_and_size()) {
       return false;
     }
     NoSafepointScope no_safepoint;
@@ -5902,7 +5902,7 @@
 
   static intptr_t HeaderSize() {
     return sizeof(UntaggedCompressedStackMaps) +
-           sizeof(UntaggedCompressedStackMaps::Payload);
+           sizeof(UntaggedCompressedStackMaps::Payload::FlagsAndSizeHeader);
   }
   static intptr_t UnroundedSize(CompressedStackMapsPtr maps) {
     return UnroundedSize(CompressedStackMaps::PayloadSizeOf(maps));
@@ -5920,13 +5920,13 @@
   bool UsesGlobalTable() const { return UsesGlobalTable(ptr()); }
   static bool UsesGlobalTable(const CompressedStackMapsPtr raw) {
     return UntaggedCompressedStackMaps::UsesTableBit::decode(
-        raw->untag()->payload()->flags_and_size);
+        raw->untag()->payload()->flags_and_size());
   }
 
   bool IsGlobalTable() const { return IsGlobalTable(ptr()); }
   static bool IsGlobalTable(const CompressedStackMapsPtr raw) {
     return UntaggedCompressedStackMaps::GlobalTableBit::decode(
-        raw->untag()->payload()->flags_and_size);
+        raw->untag()->payload()->flags_and_size());
   }
 
   static CompressedStackMapsPtr NewInlined(const void* payload, intptr_t size) {
@@ -5976,18 +5976,18 @@
 
     uintptr_t payload_size() const {
       return UntaggedCompressedStackMaps::SizeField::decode(
-          payload()->flags_and_size);
+          payload()->flags_and_size());
     }
     const uint8_t* data() const { return payload()->data(); }
 
     bool UsesGlobalTable() const {
       return UntaggedCompressedStackMaps::UsesTableBit::decode(
-          payload()->flags_and_size);
+          payload()->flags_and_size());
     }
 
     bool IsGlobalTable() const {
       return UntaggedCompressedStackMaps::GlobalTableBit::decode(
-          payload()->flags_and_size);
+          payload()->flags_and_size());
     }
 
    private:
diff --git a/runtime/vm/raw_object.h b/runtime/vm/raw_object.h
index b0b62cd..ff0a766 100644
--- a/runtime/vm/raw_object.h
+++ b/runtime/vm/raw_object.h
@@ -1987,11 +1987,26 @@
   VISIT_NOTHING();
 
  public:
-  struct Payload {
+  // Note: AOT snapshots pack these structures without any padding in between
+  // so payload structure should not have any alignment requirements.
+  // alignas(1) is here to trigger a compiler error if we violate this.
+  struct alignas(1) Payload {
+    using FlagsAndSizeHeader = uint32_t;
+
     // The most significant bits are the length of the encoded payload, in
     // bytes (excluding the header itself). The low bits determine the
     // expected payload contents, as described below.
-    uint32_t flags_and_size;
+    DART_FORCE_INLINE FlagsAndSizeHeader flags_and_size() const {
+      // Note: |this| does not necessarily satisfy alignment requirements
+      // of uint32_t so we should use bit_cast.
+      return bit_copy<FlagsAndSizeHeader, Payload>(*this);
+    }
+
+    DART_FORCE_INLINE void set_flags_and_size(FlagsAndSizeHeader value) {
+      // Note: |this| does not necessarily satisfy alignment requirements
+      // of uint32_t hence the byte copy below.
+      memcpy(reinterpret_cast<void*>(this), &value, sizeof(value));  // NOLINT
+    }
 
     // Variable length data follows here. The contents of the payload depend on
     // the type of CompressedStackMaps (CSM) being represented. There are three
@@ -2044,10 +2059,15 @@
     // done where the payload is decoded up to the entry whose PC offset
     // is greater or equal to the given PC.
 
-    uint8_t* data() { OPEN_ARRAY_START(uint8_t, uint8_t); }
-    const uint8_t* data() const { OPEN_ARRAY_START(uint8_t, uint8_t); }
+    uint8_t* data() {
+      return reinterpret_cast<uint8_t*>(this) + sizeof(FlagsAndSizeHeader);
+    }
+
+    const uint8_t* data() const {
+      return reinterpret_cast<const uint8_t*>(this) +
+             sizeof(FlagsAndSizeHeader);
+    }
   };
-  static_assert(sizeof(Payload) == sizeof(uint32_t));
 
  private:
   // We are using OPEN_ARRAY_START rather than embedding Payload directly into
@@ -2055,17 +2075,20 @@
   // padding at the end of UntaggedCompressedStackMaps - so we would not be
   // able to use sizeof(UntaggedCompressedStackMaps) as the size of the header
   // anyway.
-  Payload* payload() { OPEN_ARRAY_START(Payload, uint32_t); }
-  const Payload* payload() const { OPEN_ARRAY_START(Payload, uint32_t); }
+  Payload* payload() { OPEN_ARRAY_START(Payload, uint8_t); }
+  const Payload* payload() const { OPEN_ARRAY_START(Payload, uint8_t); }
 
-  class GlobalTableBit : public BitField<uint32_t, bool, 0, 1> {};
-  class UsesTableBit
-      : public BitField<uint32_t, bool, GlobalTableBit::kNextBit, 1> {};
+  class GlobalTableBit
+      : public BitField<Payload::FlagsAndSizeHeader, bool, 0, 1> {};
+  class UsesTableBit : public BitField<Payload::FlagsAndSizeHeader,
+                                       bool,
+                                       GlobalTableBit::kNextBit,
+                                       1> {};
   class SizeField
-      : public BitField<uint32_t,
-                        uint32_t,
+      : public BitField<Payload::FlagsAndSizeHeader,
+                        Payload::FlagsAndSizeHeader,
                         UsesTableBit::kNextBit,
-                        sizeof(Payload::flags_and_size) * kBitsPerByte -
+                        sizeof(Payload::FlagsAndSizeHeader) * kBitsPerByte -
                             UsesTableBit::kNextBit> {};
 
   friend class Object;
diff --git a/tools/VERSION b/tools/VERSION
index 38b9c41..777b780 100644
--- a/tools/VERSION
+++ b/tools/VERSION
@@ -27,5 +27,5 @@
 MAJOR 2
 MINOR 16
 PATCH 0
-PRERELEASE 150
+PRERELEASE 151
 PRERELEASE_PATCH 0
\ No newline at end of file