[vm, compiler] Remove compaction of canonical type tables from precompiler.
Canonical tables are now rebuilt during serialization.
TEST=ci
Change-Id: I4666ca1ed73a6f84b3546d35b394395623bf5854
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/200923
Commit-Queue: Ryan Macnak <rmacnak@google.com>
Reviewed-by: Régis Crelier <regis@google.com>
diff --git a/runtime/vm/compiler/aot/precompiler.cc b/runtime/vm/compiler/aot/precompiler.cc
index 016356d..62d0044 100644
--- a/runtime/vm/compiler/aot/precompiler.cc
+++ b/runtime/vm/compiler/aot/precompiler.cc
@@ -566,10 +566,6 @@
DropFunctions();
DropFields();
TraceTypesFromRetainedClasses();
- DropTypes();
- DropFunctionTypes();
- DropTypeParameters();
- DropTypeArguments();
// Clear these before dropping classes as they may hold onto otherwise
// dead instances of classes we will remove or otherwise unused symbols.
@@ -2275,163 +2271,6 @@
StubCode::TopTypeTypeTest().EntryPoint());
}
-void Precompiler::DropTypes() {
- ObjectStore* object_store = IG->object_store();
- GrowableObjectArray& retained_types =
- GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
- Array& types_array = Array::Handle(Z);
- Type& type = Type::Handle(Z);
- // First drop all the types that are not referenced.
- {
- CanonicalTypeSet types_table(Z, object_store->canonical_types());
- types_array = HashTables::ToArray(types_table, false);
- for (intptr_t i = 0; i < types_array.Length(); i++) {
- type ^= types_array.At(i);
- bool retain = types_to_retain_.HasKey(&type);
- if (retain) {
- retained_types.Add(type);
- } else {
- type.ClearCanonical();
- dropped_type_count_++;
- }
- }
- types_table.Release();
- }
-
- // Now construct a new type table and save in the object store.
- const intptr_t dict_size =
- Utils::RoundUpToPowerOfTwo(retained_types.Length() * 4 / 3);
- types_array = HashTables::New<CanonicalTypeSet>(dict_size, Heap::kOld);
- CanonicalTypeSet types_table(Z, types_array.ptr());
- bool present;
- for (intptr_t i = 0; i < retained_types.Length(); i++) {
- type ^= retained_types.At(i);
- present = types_table.Insert(type);
- ASSERT(!present);
- }
- object_store->set_canonical_types(types_table.Release());
-}
-
-void Precompiler::DropFunctionTypes() {
- ObjectStore* object_store = IG->object_store();
- GrowableObjectArray& retained_types =
- GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
- Array& types_array = Array::Handle(Z);
- FunctionType& type = FunctionType::Handle(Z);
- // First drop all the function types that are not referenced.
- {
- CanonicalFunctionTypeSet types_table(
- Z, object_store->canonical_function_types());
- types_array = HashTables::ToArray(types_table, false);
- for (intptr_t i = 0; i < types_array.Length(); i++) {
- type ^= types_array.At(i);
- bool retain = functiontypes_to_retain_.HasKey(&type);
- if (retain) {
- retained_types.Add(type);
- } else {
- type.ClearCanonical();
- dropped_functiontype_count_++;
- }
- }
- types_table.Release();
- }
-
- // Now construct a new function type table and save in the object store.
- const intptr_t dict_size =
- Utils::RoundUpToPowerOfTwo(retained_types.Length() * 4 / 3);
- types_array =
- HashTables::New<CanonicalFunctionTypeSet>(dict_size, Heap::kOld);
- CanonicalFunctionTypeSet types_table(Z, types_array.ptr());
- bool present;
- for (intptr_t i = 0; i < retained_types.Length(); i++) {
- type ^= retained_types.At(i);
- present = types_table.Insert(type);
- ASSERT(!present);
- }
- object_store->set_canonical_function_types(types_table.Release());
-}
-
-void Precompiler::DropTypeParameters() {
- ObjectStore* object_store = IG->object_store();
- GrowableObjectArray& retained_typeparams =
- GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
- Array& typeparams_array = Array::Handle(Z);
- TypeParameter& typeparam = TypeParameter::Handle(Z);
- // First drop all the type parameters that are not referenced.
- // Note that we only visit 'free-floating' type parameters and not
- // declarations of type parameters contained in the 'type_parameters'
- // array in generic classes and functions.
- {
- CanonicalTypeParameterSet typeparams_table(
- Z, object_store->canonical_type_parameters());
- typeparams_array = HashTables::ToArray(typeparams_table, false);
- for (intptr_t i = 0; i < typeparams_array.Length(); i++) {
- typeparam ^= typeparams_array.At(i);
- bool retain = typeparams_to_retain_.HasKey(&typeparam);
- if (retain) {
- retained_typeparams.Add(typeparam);
- } else {
- typeparam.ClearCanonical();
- dropped_typeparam_count_++;
- }
- }
- typeparams_table.Release();
- }
-
- // Now construct a new type parameter table and save in the object store.
- const intptr_t dict_size =
- Utils::RoundUpToPowerOfTwo(retained_typeparams.Length() * 4 / 3);
- typeparams_array =
- HashTables::New<CanonicalTypeParameterSet>(dict_size, Heap::kOld);
- CanonicalTypeParameterSet typeparams_table(Z, typeparams_array.ptr());
- bool present;
- for (intptr_t i = 0; i < retained_typeparams.Length(); i++) {
- typeparam ^= retained_typeparams.At(i);
- present = typeparams_table.Insert(typeparam);
- ASSERT(!present);
- }
- object_store->set_canonical_type_parameters(typeparams_table.Release());
-}
-
-void Precompiler::DropTypeArguments() {
- ObjectStore* object_store = IG->object_store();
- Array& typeargs_array = Array::Handle(Z);
- GrowableObjectArray& retained_typeargs =
- GrowableObjectArray::Handle(Z, GrowableObjectArray::New());
- TypeArguments& typeargs = TypeArguments::Handle(Z);
- // First drop all the type arguments that are not referenced.
- {
- CanonicalTypeArgumentsSet typeargs_table(
- Z, object_store->canonical_type_arguments());
- typeargs_array = HashTables::ToArray(typeargs_table, false);
- for (intptr_t i = 0; i < typeargs_array.Length(); i++) {
- typeargs ^= typeargs_array.At(i);
- bool retain = typeargs_to_retain_.HasKey(&typeargs);
- if (retain) {
- retained_typeargs.Add(typeargs);
- } else {
- typeargs.ClearCanonical();
- dropped_typearg_count_++;
- }
- }
- typeargs_table.Release();
- }
-
- // Now construct a new type arguments table and save in the object store.
- const intptr_t dict_size =
- Utils::RoundUpToPowerOfTwo(retained_typeargs.Length() * 4 / 3);
- typeargs_array =
- HashTables::New<CanonicalTypeArgumentsSet>(dict_size, Heap::kOld);
- CanonicalTypeArgumentsSet typeargs_table(Z, typeargs_array.ptr());
- bool present;
- for (intptr_t i = 0; i < retained_typeargs.Length(); i++) {
- typeargs ^= retained_typeargs.At(i);
- present = typeargs_table.Insert(typeargs);
- ASSERT(!present);
- }
- object_store->set_canonical_type_arguments(typeargs_table.Release());
-}
-
void Precompiler::TraceTypesFromRetainedClasses() {
auto& lib = Library::Handle(Z);
auto& cls = Class::Handle(Z);
diff --git a/runtime/vm/compiler/aot/precompiler.h b/runtime/vm/compiler/aot/precompiler.h
index c5d14fc..049a12a 100644
--- a/runtime/vm/compiler/aot/precompiler.h
+++ b/runtime/vm/compiler/aot/precompiler.h
@@ -334,10 +334,6 @@
void DropFunctions();
void DropFields();
void TraceTypesFromRetainedClasses();
- void DropTypes();
- void DropFunctionTypes();
- void DropTypeParameters();
- void DropTypeArguments();
void DropMetadata();
void DropLibraryEntries();
void DropClasses();
