[vm,dyn_modules] Support compound pointers in FFI call arguments

TEST=ci (ffi/address_of_test)

Change-Id: If87231c5c9dabb49a904dedd0cc8ef034c16dfe3
Cq-Include-Trybots: luci.dart.try:vm-aot-dyn-linux-debug-x64-try,vm-aot-dyn-linux-product-x64-try,vm-dyn-linux-debug-x64-try,vm-dyn-mac-debug-arm64-try,vm-ffi-dyn-mac-debug-simarm64_arm64-try,vm-ffi-dyn-mac-release-simarm64_arm64-try
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/449069
Reviewed-by: Tess Strickland <[email protected]>
Commit-Queue: Alexander Markov <[email protected]>
Reviewed-by: Ryan Macnak <[email protected]>

Author: alexmarkov

runtime/vm/compiler/compiler_state.cc

@@ -141,41 +141,11 @@ DEFINE_TYPED_LIST_NATIVE_FUNCTION_GETTER(Float64x2, float64x2)
     return *Lower##_class_;                                                    \
   }
 
-DEFINE_CLASS_GETTER(Ffi, Array, array, Array)
-DEFINE_CLASS_GETTER(Ffi, Compound, compound, Compound)
-DEFINE_CLASS_GETTER(Ffi, Struct, struct, Struct)
-DEFINE_CLASS_GETTER(Ffi, Union, union, Union)
 DEFINE_CLASS_GETTER(TypedData, TypedData, typed_data, TypedData)
 DEFINE_CLASS_GETTER(TypedData, TypedList, typed_list, _TypedList)
 
 #undef DEFINE_CLASS_GETTER
 
-const Field& CompilerState::CompoundOffsetInBytesField() {
-  if (compound_offset_in_bytes_field_ == nullptr) {
-    Thread* thread = Thread::Current();
-    Zone* zone = thread->zone();
-    const auto& field =
-        Field::ZoneHandle(zone, CompoundClass().LookupInstanceFieldAllowPrivate(
-                                    Symbols::_offsetInBytes()));
-    ASSERT(!field.IsNull());
-    compound_offset_in_bytes_field_ = &field;
-  }
-  return *compound_offset_in_bytes_field_;
-}
-
-const Field& CompilerState::CompoundTypedDataBaseField() {
-  if (compound_typed_data_base_field_ == nullptr) {
-    Thread* thread = Thread::Current();
-    Zone* zone = thread->zone();
-    const auto& field =
-        Field::ZoneHandle(zone, CompoundClass().LookupInstanceFieldAllowPrivate(
-                                    Symbols::_typedDataBase()));
-    ASSERT(!field.IsNull());
-    compound_typed_data_base_field_ = &field;
-  }
-  return *compound_typed_data_base_field_;
-}
-
 const Field& CompilerState::ErrorStackTraceField() {
   if (error_stack_trace_field_ == nullptr) {
     Thread* thread = Thread::Current();

runtime/vm/compiler/compiler_state.h

@@ -126,15 +126,9 @@ class CompilerState : public ThreadStackResource {
   const Function& TypedListGetFloat64x2();
   const Function& TypedListSetFloat64x2();
 
-  const Class& ArrayClass();
-  const Class& CompoundClass();
   const Class& ErrorClass();
-  const Class& StructClass();
   const Class& TypedDataClass();
-  const Class& UnionClass();
 
-  const Field& CompoundOffsetInBytesField();
-  const Field& CompoundTypedDataBaseField();
   const Field& ErrorStackTraceField();
 
   const Function* function() const { return function_; }

runtime/vm/compiler/ffi/marshaller.cc

@@ -47,7 +47,8 @@ const NativeFunctionType* NativeFunctionTypeFromFunctionType(
   intptr_t variadic_arguments_index = NativeFunctionType::kNoVariadicArguments;
   for (intptr_t i = 0; i < num_arguments; i++) {
     arg_type = c_signature.ParameterTypeAt(i + kNativeParamsStartAt);
-    const bool varargs = arg_type.type_class() == object_store->varargs_class();
+    const bool varargs =
+        arg_type.type_class() == object_store->ffi_varargs_class();
     if (varargs) {
       arg_type = TypeArguments::Handle(zone, Type::Cast(arg_type).arguments())
                      .TypeAt(0);
@@ -119,7 +120,7 @@ AbstractTypePtr BaseMarshaller::CType(intptr_t arg_index) const {
       zone, c_signature_.ParameterTypeAt(last_param_index));
   ObjectStore* object_store = IsolateGroup::Current()->object_store();
   const bool has_varargs =
-      last_arg_type.type_class() == object_store->varargs_class();
+      last_arg_type.type_class() == object_store->ffi_varargs_class();
 
   // Skip #0 argument, the function pointer.
   const intptr_t real_arg_index = arg_index + kNativeParamsStartAt;
@@ -198,15 +199,16 @@ bool BaseMarshaller::IsTypedDataPointer(intptr_t arg_index) const {
 }
 
 static bool IsCompound(Zone* zone, const AbstractType& type) {
-  auto& compiler_state = Thread::Current()->compiler_state();
+  ObjectStore* object_store =
+      Thread::Current()->isolate_group()->object_store();
   auto& cls = Class::Handle(zone, type.type_class());
-  if (cls.id() == compiler_state.CompoundClass().id() ||
-      cls.id() == compiler_state.ArrayClass().id()) {
+  if ((object_store->ffi_compound_class() == cls.ptr()) ||
+      (object_store->ffi_array_class() == cls.ptr())) {
     return true;
   }
   cls ^= cls.SuperClass();
-  if (cls.id() == compiler_state.StructClass().id() ||
-      cls.id() == compiler_state.UnionClass().id()) {
+  if ((object_store->ffi_struct_class() == cls.ptr()) ||
+      (object_store->ffi_union_class() == cls.ptr())) {
     return true;
   }
   return false;

runtime/vm/compiler/frontend/kernel_to_il.cc

@@ -4792,37 +4792,39 @@ Fragment FlowGraphBuilder::WrapTypedDataBaseInCompound(
       Class::ZoneHandle(Z, compound_type.type_class());
   compound_sub_class.EnsureIsFinalized(thread_);
 
-  auto& state = thread_->compiler_state();
+  ObjectStore* object_store = IG->object_store();
 
   Fragment body;
   LocalVariable* typed_data = MakeTemporary("typed_data_base");
   body += AllocateObject(TokenPosition::kNoSource, compound_sub_class, 0);
   LocalVariable* compound = MakeTemporary("compound");
   body += LoadLocal(compound);
   body += LoadLocal(typed_data);
-  body += StoreField(state.CompoundTypedDataBaseField(),
-                     StoreFieldInstr::Kind::kInitializing);
+  body += StoreField(
+      Field::ZoneHandle(Z, object_store->compound_typed_data_base_field()),
+      StoreFieldInstr::Kind::kInitializing);
   body += LoadLocal(compound);
   body += IntConstant(0);
-  body += StoreField(state.CompoundOffsetInBytesField(),
-                     StoreFieldInstr::Kind::kInitializing);
+  body += StoreField(
+      Field::ZoneHandle(Z, object_store->compound_offset_in_bytes_field()),
+      StoreFieldInstr::Kind::kInitializing);
   body += DropTempsPreserveTop(1);  // Drop TypedData.
   return body;
 }
 
 Fragment FlowGraphBuilder::LoadTypedDataBaseFromCompound() {
   Fragment body;
-  auto& state = thread_->compiler_state();
-  body += LoadField(state.CompoundTypedDataBaseField(),
-                    /*calls_initializer=*/false);
+  const auto& field = Field::ZoneHandle(
+      Z, IG->object_store()->compound_typed_data_base_field());
+  body += LoadField(field, /*calls_initializer=*/false);
   return body;
 }
 
 Fragment FlowGraphBuilder::LoadOffsetInBytesFromCompound() {
   Fragment body;
-  auto& state = thread_->compiler_state();
-  body += LoadField(state.CompoundOffsetInBytesField(),
-                    /*calls_initializer=*/false);
+  const auto& field = Field::ZoneHandle(
+      Z, IG->object_store()->compound_offset_in_bytes_field());
+  body += LoadField(field, /*calls_initializer=*/false);
   return body;
 }