[vm] Remove kFfiPointerCid/kFfiDynamicLibraryCid

There have been duplicate cids

  * kPointerCid / kFfiPointerCid
  * kDynamicLibraryCid / kFfiDynamicLibraryCid

Only one of each made sense. This CL ensures we have only the former.

TEST=ci

Change-Id: Icdcef40c80ed09815da6074a774a02c707f6be37
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/212592
Commit-Queue: Martin Kustermann <[email protected]>
Reviewed-by: Daco Harkes <[email protected]>

Author: mkustermann

runtime/vm/class_finalizer.cc

@@ -1374,7 +1374,7 @@ void ClassFinalizer::VerifyImplicitFieldOffsets() {
   ASSERT(String::EqualsIgnoringPrivateKey(name, expected_name));
 
   // Now verify field offsets of 'Pointer' class.
-  cls = class_table.At(kFfiPointerCid);
+  cls = class_table.At(kPointerCid);
   error = cls.EnsureIsFinalized(thread);
   ASSERT(error.IsNull());
   ASSERT(cls.NumTypeParameters() == 1);

runtime/vm/class_id.h

@@ -159,11 +159,9 @@ typedef uint16_t ClassIdTagType;
   V(Handle)
 
 #define CLASS_LIST_FFI(V)                                                      \
-  V(Pointer)                                                                   \
   V(NativeFunction)                                                            \
   CLASS_LIST_FFI_TYPE_MARKER(V)                                                \
   V(NativeType)                                                                \
-  V(DynamicLibrary)                                                            \
   V(Struct)
 
 #define DART_CLASS_LIST_TYPED_DATA(V)                                          \
@@ -389,7 +387,7 @@ inline bool IsExternalTypedDataClassId(intptr_t index) {
 
 inline bool IsFfiTypeClassId(intptr_t index) {
   switch (index) {
-    case kFfiPointerCid:
+    case kPointerCid:
     case kFfiNativeFunctionCid:
 #define CASE_FFI_CID(name) case kFfi##name##Cid:
       CLASS_LIST_FFI_TYPE_MARKER(CASE_FFI_CID)
@@ -403,6 +401,8 @@ inline bool IsFfiTypeClassId(intptr_t index) {
 
 inline bool IsFfiPredefinedClassId(classid_t class_id) {
   switch (class_id) {
+    case kPointerCid:
+    case kDynamicLibraryCid:
 #define CASE_FFI_CID(name) case kFfi##name##Cid:
     CLASS_LIST_FFI(CASE_FFI_CID)
 #undef CASE_FFI_CID
@@ -414,11 +414,11 @@ inline bool IsFfiPredefinedClassId(classid_t class_id) {
 }
 
 inline bool IsFfiPointerClassId(intptr_t index) {
-  return index == kFfiPointerCid;
+  return index == kPointerCid;
 }
 
 inline bool IsFfiDynamicLibraryClassId(intptr_t index) {
-  return index == kFfiDynamicLibraryCid;
+  return index == kDynamicLibraryCid;
 }
 
 inline bool IsInternalVMdefinedClassId(intptr_t index) {

runtime/vm/compiler/ffi/marshaller.h

@@ -103,7 +103,7 @@ class BaseMarshaller : public ZoneAllocated {
   // Requires boxing or unboxing.
   bool IsPointer(intptr_t arg_index) const {
     return AbstractType::Handle(zone_, CType(arg_index)).type_class_id() ==
-           kFfiPointerCid;
+           kPointerCid;
   }
   bool IsHandle(intptr_t arg_index) const {
     return AbstractType::Handle(zone_, CType(arg_index)).type_class_id() ==

runtime/vm/compiler/ffi/native_type.cc

@@ -372,7 +372,7 @@ static PrimitiveType TypeRepresentation(classid_t class_id) {
       return kFloat;
     case kFfiDoubleCid:
       return kDouble;
-    case kFfiPointerCid:
+    case kPointerCid:
       return compiler::target::kWordSize == 4 ? kUint32 : kInt64;
     case kFfiVoidCid:
       return kVoid;

runtime/vm/compiler/ffi/recognized_method.cc

@@ -13,9 +13,6 @@ namespace compiler {
 namespace ffi {
 
 classid_t ElementTypedDataCid(classid_t class_id) {
-  ASSERT(class_id >= kFfiPointerCid);
-  ASSERT(class_id < kFfiVoidCid);
-  ASSERT(class_id != kFfiNativeFunctionCid);
   switch (class_id) {
     case kFfiInt8Cid:
       return kTypedDataInt8ArrayCid;
@@ -36,7 +33,7 @@ classid_t ElementTypedDataCid(classid_t class_id) {
     case kFfiIntPtrCid:
       return target::kWordSize == 4 ? kTypedDataInt32ArrayCid
                                     : kTypedDataInt64ArrayCid;
-    case kFfiPointerCid:
+    case kPointerCid:
       return target::kWordSize == 4 ? kTypedDataUint32ArrayCid
                                     : kTypedDataUint64ArrayCid;
     case kFfiFloatCid:
@@ -55,14 +52,16 @@ classid_t RecognizedMethodTypeArgCid(MethodRecognizer::Kind kind) {
   case MethodRecognizer::kFfiStore##type:                                      \
     return kFfi##type##Cid;
     CLASS_LIST_FFI_NUMERIC(LOAD_STORE)
-    LOAD_STORE(Pointer)
 #undef LOAD_STORE
     case MethodRecognizer::kFfiLoadFloatUnaligned:
     case MethodRecognizer::kFfiStoreFloatUnaligned:
       return kFfiFloatCid;
     case MethodRecognizer::kFfiLoadDoubleUnaligned:
     case MethodRecognizer::kFfiStoreDoubleUnaligned:
       return kFfiDoubleCid;
+    case MethodRecognizer::kFfiLoadPointer:
+    case MethodRecognizer::kFfiStorePointer:
+      return kPointerCid;
     default:
       UNREACHABLE();
   }

runtime/vm/compiler/frontend/kernel_to_il.cc

@@ -1381,9 +1381,9 @@ FlowGraph* FlowGraphBuilder::BuildGraphOfRecognizedMethod(
           Box(LoadIndexedInstr::RepresentationOfArrayElement(typed_data_cid));
       if (kind == MethodRecognizer::kFfiLoadPointer) {
         const auto class_table = thread_->isolate_group()->class_table();
-        ASSERT(class_table->HasValidClassAt(kFfiPointerCid));
+        ASSERT(class_table->HasValidClassAt(kPointerCid));
         const auto& pointer_class =
-            Class::ZoneHandle(H.zone(), class_table->At(kFfiPointerCid));
+            Class::ZoneHandle(H.zone(), class_table->At(kPointerCid));
 
         // We find the reified type to use for the pointer allocation.
         //
@@ -1441,9 +1441,9 @@ FlowGraph* FlowGraphBuilder::BuildGraphOfRecognizedMethod(
       if (kind == MethodRecognizer::kFfiStorePointer) {
         // Do type check before anything untagged is on the stack.
         const auto class_table = thread_->isolate_group()->class_table();
-        ASSERT(class_table->HasValidClassAt(kFfiPointerCid));
+        ASSERT(class_table->HasValidClassAt(kPointerCid));
         const auto& pointer_class =
-            Class::ZoneHandle(H.zone(), class_table->At(kFfiPointerCid));
+            Class::ZoneHandle(H.zone(), class_table->At(kPointerCid));
         const auto& pointer_type_param =
             TypeParameter::ZoneHandle(pointer_class.TypeParameterAt(0));
 
@@ -1506,9 +1506,9 @@ FlowGraph* FlowGraphBuilder::BuildGraphOfRecognizedMethod(
     } break;
     case MethodRecognizer::kFfiFromAddress: {
       const auto class_table = thread_->isolate_group()->class_table();
-      ASSERT(class_table->HasValidClassAt(kFfiPointerCid));
+      ASSERT(class_table->HasValidClassAt(kPointerCid));
       const auto& pointer_class =
-          Class::ZoneHandle(H.zone(), class_table->At(kFfiPointerCid));
+          Class::ZoneHandle(H.zone(), class_table->At(kPointerCid));
 
       ASSERT(function.NumTypeParameters() == 1);
       ASSERT_EQUAL(function.NumParameters(), 1);

runtime/vm/compiler/runtime_api.cc

@@ -418,8 +418,8 @@ static uword GetInstanceSizeImpl(const dart::Class& handle) {
       return WeakProperty::InstanceSize();
     case kByteBufferCid:
     case kByteDataViewCid:
-    case kFfiPointerCid:
-    case kFfiDynamicLibraryCid:
+    case kPointerCid:
+    case kDynamicLibraryCid:
 #define HANDLE_CASE(clazz) case kFfi##clazz##Cid:
       CLASS_LIST_FFI_TYPE_MARKER(HANDLE_CASE)
 #undef HANDLE_CASE

runtime/vm/message_snapshot.cc

@@ -3128,8 +3128,6 @@ void MessageSerializer::Trace(Object* object) {
     // here that cannot happen in reality)
     ILLEGAL(DynamicLibrary)
     ILLEGAL(Pointer)
-    ILLEGAL(FfiDynamicLibrary)
-    ILLEGAL(FfiPointer)
 
 #undef ILLEGAL
 

runtime/vm/object.cc

@@ -662,12 +662,12 @@ void Object::InitVtables() {
 
   {
     Pointer fake_handle;
-    builtin_vtables_[kFfiPointerCid] = fake_handle.vtable();
+    builtin_vtables_[kPointerCid] = fake_handle.vtable();
   }
 
   {
     DynamicLibrary fake_handle;
-    builtin_vtables_[kFfiDynamicLibraryCid] = fake_handle.vtable();
+    builtin_vtables_[kDynamicLibraryCid] = fake_handle.vtable();
   }
 
 #define INIT_VTABLE(clazz)                                                     \
@@ -2310,12 +2310,12 @@ ErrorPtr Object::Init(IsolateGroup* isolate_group,
     pending_classes.Add(cls);
     RegisterClass(cls, Symbols::FfiNativeFunction(), lib);
 
-    cls = Class::NewPointerClass(kFfiPointerCid, isolate_group);
+    cls = Class::NewPointerClass(kPointerCid, isolate_group);
     object_store->set_ffi_pointer_class(cls);
     pending_classes.Add(cls);
     RegisterClass(cls, Symbols::FfiPointer(), lib);
 
-    cls = Class::New<DynamicLibrary, RTN::DynamicLibrary>(kFfiDynamicLibraryCid,
+    cls = Class::New<DynamicLibrary, RTN::DynamicLibrary>(kDynamicLibraryCid,
                                                           isolate_group);
     cls.set_instance_size(DynamicLibrary::InstanceSize(),
                           compiler::target::RoundedAllocationSize(
@@ -2433,10 +2433,10 @@ ErrorPtr Object::Init(IsolateGroup* isolate_group,
     cls = Class::New<Instance, RTN::Instance>(kFfiNativeFunctionCid,
                                               isolate_group);
 
-    cls = Class::NewPointerClass(kFfiPointerCid, isolate_group);
+    cls = Class::NewPointerClass(kPointerCid, isolate_group);
     object_store->set_ffi_pointer_class(cls);
 
-    cls = Class::New<DynamicLibrary, RTN::DynamicLibrary>(kFfiDynamicLibraryCid,
+    cls = Class::New<DynamicLibrary, RTN::DynamicLibrary>(kDynamicLibraryCid,
                                                           isolate_group);
 
     cls = Class::New<Instance, RTN::Instance>(kByteBufferCid, isolate_group,
@@ -2781,12 +2781,6 @@ ObjectPtr Object::Clone(const Object& orig,
 bool Class::HasCompressedPointers() const {
   const intptr_t cid = id();
   switch (cid) {
-    // Only a couple of FFI cids correspond to actual Dart classes. so they're
-    // explicitly listed here.
-    case kFfiPointerCid:
-      return Pointer::ContainsCompressedPointers();
-    case kFfiDynamicLibraryCid:
-      return DynamicLibrary::ContainsCompressedPointers();
     case kByteBufferCid:
       return ByteBuffer::ContainsCompressedPointers();
 #define HANDLE_CASE(clazz)                                                     \
@@ -4923,9 +4917,9 @@ const char* Class::GenerateUserVisibleName() const {
     case kExternalTypedDataFloat64ArrayCid:
       return Symbols::Float64List().ToCString();
 
-    case kFfiPointerCid:
+    case kPointerCid:
       return Symbols::FfiPointer().ToCString();
-    case kFfiDynamicLibraryCid:
+    case kDynamicLibraryCid:
       return Symbols::FfiDynamicLibrary().ToCString();
 
 #if !defined(PRODUCT)
@@ -20280,7 +20274,7 @@ bool AbstractType::IsDartClosureType() const {
 }
 
 bool AbstractType::IsFfiPointerType() const {
-  return HasTypeClass() && type_class_id() == kFfiPointerCid;
+  return HasTypeClass() && type_class_id() == kPointerCid;
 }
 
 AbstractTypePtr AbstractType::UnwrapFutureOr() const {
@@ -25206,11 +25200,11 @@ PointerPtr Pointer::New(const AbstractType& type_arg,
   type_args = type_args.Canonicalize(thread, nullptr);
 
   const Class& cls =
-      Class::Handle(IsolateGroup::Current()->class_table()->At(kFfiPointerCid));
+      Class::Handle(IsolateGroup::Current()->class_table()->At(kPointerCid));
   cls.EnsureIsAllocateFinalized(Thread::Current());
 
   Pointer& result = Pointer::Handle(zone);
-  result ^= Object::Allocate(kFfiPointerCid, Pointer::InstanceSize(), space,
+  result ^= Object::Allocate(kPointerCid, Pointer::InstanceSize(), space,
                              Pointer::ContainsCompressedPointers());
   result.SetTypeArguments(type_args);
   result.SetNativeAddress(native_address);
@@ -25228,7 +25222,7 @@ const char* Pointer::ToCString() const {
 DynamicLibraryPtr DynamicLibrary::New(void* handle, Heap::Space space) {
   DynamicLibrary& result = DynamicLibrary::Handle();
   result ^=
-      Object::Allocate(kFfiDynamicLibraryCid, DynamicLibrary::InstanceSize(),
+      Object::Allocate(kDynamicLibraryCid, DynamicLibrary::InstanceSize(),
                        space, DynamicLibrary::ContainsCompressedPointers());
   NoSafepointScope no_safepoint;
   result.SetHandle(handle);

runtime/vm/object_graph_copy.cc

@@ -593,8 +593,6 @@ class ObjectCopyBase {
       // here that cannot happen in reality)
       HANDLE_ILLEGAL_CASE(DynamicLibrary)
       HANDLE_ILLEGAL_CASE(Pointer)
-      HANDLE_ILLEGAL_CASE(FfiDynamicLibrary)
-      HANDLE_ILLEGAL_CASE(FfiPointer)
       HANDLE_ILLEGAL_CASE(FunctionType)
       HANDLE_ILLEGAL_CASE(MirrorReference)
       HANDLE_ILLEGAL_CASE(ReceivePort)

runtime/vm/raw_object.cc

@@ -174,7 +174,7 @@ intptr_t UntaggedObject::HeapSizeFromClass(uword tags) const {
         break;
       }
 #undef SIZE_FROM_CLASS
-    case kFfiPointerCid:
+    case kPointerCid:
       instance_size = Pointer::InstanceSize();
       break;
     case kTypeArgumentsCid: {
@@ -327,17 +327,6 @@ intptr_t UntaggedObject::VisitPointersPredefined(ObjectPointerVisitor* visitor,
       size = UntaggedInstance::VisitInstancePointers(raw_obj, visitor);
       break;
     }
-    case kFfiPointerCid: {
-      PointerPtr raw_obj = static_cast<PointerPtr>(this);
-      size = UntaggedPointer::VisitPointerPointers(raw_obj, visitor);
-      break;
-    }
-    case kFfiDynamicLibraryCid: {
-      DynamicLibraryPtr raw_obj = static_cast<DynamicLibraryPtr>(this);
-      size =
-          UntaggedDynamicLibrary::VisitDynamicLibraryPointers(raw_obj, visitor);
-      break;
-    }
 #define RAW_VISITPOINTERS(clazz) case kFfi##clazz##Cid:
       CLASS_LIST_FFI_TYPE_MARKER(RAW_VISITPOINTERS) {
         // NativeType do not have any fields or type arguments.

runtime/vm/service.cc

@@ -5226,7 +5226,7 @@ static void GetDefaultClassesAliases(Thread* thread, JSONStream* js) {
   {                                                                            \
     JSONArray internals(&map, #clazz);                                         \
     DEFINE_ADD_VALUE_F_CID(TypedData##clazz)                                   \
-    DEFINE_ADD_VALUE_F_CID(TypedData##clazz)                                   \
+    DEFINE_ADD_VALUE_F_CID(TypedData##clazz##View)                             \
     DEFINE_ADD_VALUE_F_CID(ExternalTypedData##clazz)                           \
   }
   CLASS_LIST_TYPED_DATA(DEFINE_ADD_MAP_KEY)