Alexander Markov
135443706b
Previously, vectors of type arguments were expanded to include type arguments corresponding to superclasses both in the instances of generic classes and in Type objects (after type finalization). As a result, Type objects after finalization could be recursive and need to use extra TypeRef objects to break loops. The finalization of types was very complex and sometimes slow. This change simplifies the representation of Type objects: now they always have short type argument vectors, corresponding only to the type parameters of their own classes (both before and after finalization). Vectors of type arguments in the instances of generic classes are still expanded/flattened. This greatly simplifies type finalization, makes Type objects non-recursive and removes the need to create and handle excessive TypeRefs for type arguments corresponding to superclasses, as those type arguments are no longer included into types. The only remaining use of TypeRefs is for bounds of type parameters. In order to expand/flatten type arguments, new methods Type::GetInstanceTypeArguments / Class::GetInstanceTypeArguments are introduced. They build canonical declaration type arguments once (for each class), and then instantiate them as needed. There are also simple helper methods to shrink type arguments (TypeArguments::FromInstanceTypeArguments) and expand type arguments without filling type arguments corresponding to superclasses (TypeArguments::ToInstantiatorTypeArguments). Time of edge case 'regress_51960_test' 15min -> 300ms. TEST=ci, runtime/tests/vm/dart/regress_51960_test.dart Fixes https://github.com/dart-lang/sdk/issues/52022 Fixes https://github.com/dart-lang/sdk/issues/51960 Change-Id: I75b466b74698a33c0bb5e1dcbd29542e413812a1 Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/295060 Reviewed-by: Ryan Macnak <rmacnak@google.com> Commit-Queue: Alexander Markov <alexmarkov@google.com>
120 lines
4.2 KiB
C++
120 lines
4.2 KiB
C++
// Copyright (c) 2012, the Dart project authors. Please see the AUTHORS file
|
|
// for details. All rights reserved. Use of this source code is governed by a
|
|
// BSD-style license that can be found in the LICENSE file.
|
|
|
|
#ifndef RUNTIME_VM_CLASS_FINALIZER_H_
|
|
#define RUNTIME_VM_CLASS_FINALIZER_H_
|
|
|
|
#include <memory>
|
|
|
|
#include "vm/allocation.h"
|
|
#include "vm/growable_array.h"
|
|
#include "vm/object.h"
|
|
|
|
namespace dart {
|
|
|
|
// Traverses all pending, unfinalized classes, validates and marks them as
|
|
// finalized.
|
|
class ClassFinalizer : public AllStatic {
|
|
public:
|
|
// Modes for finalization. The ordering is relevant.
|
|
enum FinalizationKind {
|
|
kFinalize, // Finalize type and type arguments.
|
|
kCanonicalize // Finalize and canonicalize.
|
|
};
|
|
|
|
// Finalize given type.
|
|
static AbstractTypePtr FinalizeType(
|
|
const AbstractType& type,
|
|
FinalizationKind finalization = kCanonicalize);
|
|
|
|
// Return false if we still have classes pending to be finalized.
|
|
static bool AllClassesFinalized();
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
// Useful for sorting classes to make dispatch faster.
|
|
static void SortClasses();
|
|
static void RemapClassIds(intptr_t* old_to_new_cid);
|
|
static void RehashTypes();
|
|
static void ClearAllCode(bool including_nonchanging_cids = false);
|
|
#endif // !defined(DART_PRECOMPILED_RUNTIME)
|
|
|
|
// Return whether processing pending classes (ObjectStore::pending_classes_)
|
|
// failed. The function returns true if the processing was successful.
|
|
// If processing fails, an error message is set in the sticky error field
|
|
// in the object store.
|
|
static bool ProcessPendingClasses();
|
|
|
|
// Finalize the types appearing in the declaration of class 'cls', i.e. its
|
|
// type parameters and their upper bounds, its super type and interfaces.
|
|
// Note that the fields and functions have not been parsed yet (unless cls
|
|
// is an anonymous top level class).
|
|
static void FinalizeTypesInClass(const Class& cls);
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
// Register class in the lists of direct subclasses and direct implementors.
|
|
static void RegisterClassInHierarchy(Zone* zone, const Class& cls);
|
|
#endif // !defined(DART_PRECOMPILED_RUNTIME)
|
|
|
|
// Ensures members of the class are loaded, class layout is finalized and size
|
|
// registered in class table.
|
|
static void FinalizeClass(const Class& cls);
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
// Makes class instantiatable and usable by generated code.
|
|
static ErrorPtr AllocateFinalizeClass(const Class& cls);
|
|
|
|
// Completes loading of the class, this populates the function
|
|
// and fields of the class.
|
|
//
|
|
// Returns Error::null() if there is no loading error.
|
|
static ErrorPtr LoadClassMembers(const Class& cls);
|
|
|
|
// Verify that the classes have been properly prefinalized. This is
|
|
// needed during bootstrapping where the classes have been preloaded.
|
|
static void VerifyBootstrapClasses();
|
|
#endif // !defined(DART_PRECOMPILED_RUNTIME)
|
|
|
|
private:
|
|
// Finalize given type argument vector.
|
|
static TypeArgumentsPtr FinalizeTypeArguments(
|
|
Zone* zone,
|
|
const TypeArguments& type_args,
|
|
FinalizationKind finalization = kCanonicalize);
|
|
|
|
// Finalize the types in the signature and the signature itself.
|
|
static AbstractTypePtr FinalizeSignature(
|
|
Zone* zone,
|
|
const FunctionType& signature,
|
|
FinalizationKind finalization = kCanonicalize);
|
|
|
|
static AbstractTypePtr FinalizeRecordType(
|
|
Zone* zone,
|
|
const RecordType& record,
|
|
FinalizationKind finalization = kCanonicalize);
|
|
|
|
static void FinalizeTypeParameters(
|
|
Zone* zone,
|
|
const Class& cls,
|
|
const FunctionType& signature,
|
|
FinalizationKind finalization = kCanonicalize);
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
static void FinalizeMemberTypes(const Class& cls);
|
|
static void PrintClassInformation(const Class& cls);
|
|
#endif // !defined(DART_PRECOMPILED_RUNTIME)
|
|
|
|
static void ReportError(const Error& error);
|
|
static void ReportError(const char* format, ...) PRINTF_ATTRIBUTE(1, 2);
|
|
|
|
#if !defined(DART_PRECOMPILED_RUNTIME)
|
|
// Verify implicit offsets recorded in the VM for direct access to fields of
|
|
// Dart instances (e.g: _TypedListView, _ByteDataView).
|
|
static void VerifyImplicitFieldOffsets();
|
|
#endif // !defined(DART_PRECOMPILED_RUNTIME)
|
|
};
|
|
|
|
} // namespace dart
|
|
|
|
#endif // RUNTIME_VM_CLASS_FINALIZER_H_
|