[VM] Introduction of type testing stubs - Part 2

This CL starts building type testing stubs specialzed for [Type] objects
we test against.

More specifically, it adds support for:

  * Handling obvious fast cases on the call sites (while still having a
    call to stub for negative case)

  * Handling type tests against type parameters, by loading the value
    of the type parameter on the call sites and invoking it's type testing stub.

  * Specialzed type testing stubs for instantiated types where we can
    do [CidRange]-based subtype-checks.

    ==> e.g. String/List<dynamic>

  * Specialzed type testing stubs for instantiated types where we can
    do [CidRange]-based subclass-checks for the class and
    [CidRange]-based subtype-checks for the type arguments.

    ==> e.g. Widget<State>, where we know [Widget] is only extended and not
	     implemented.

  * Specialzed type testing stubs for certain non-instantiated types where we
    can do [CidRange]-based subclass-checks for the class and
    [CidRange]-based subtype-checks for the instantiated type arguments and
    cid based comparisons for type parameters.  (Note that this fast-case migth
    result in some false-negatives!)

    ==> e.g. _HashMapEntry<K, V>, where we know [_HashMapEntry] is only
	     extended and not implemented.

   This optimizes cases where the caller uses `new HashMap<A, B>()` and only
   uses `A` and `B` as key/values (and not subclasses of it).  The false-negative
   can occur when subtypes of A or B are used.  In such cases we fall back to the
   [SubtypeTestCache]-based imlementation.

Issue #31798

Change-Id: Ic1853977bf55d815755b0d652ec8e20e51efb4cf
Reviewed-on: https://dart-review.googlesource.com/44788
Reviewed-by: Vyacheslav Egorov <[email protected]>
Reviewed-by: Régis Crelier <[email protected]>

Author: mkustermann

runtime/vm/compiler/aot/precompiler.cc

@@ -46,6 +46,7 @@
 #include "vm/timeline.h"
 #include "vm/timer.h"
 #include "vm/type_table.h"
+#include "vm/type_testing_stubs.h"
 #include "vm/unicode.h"
 #include "vm/version.h"
 
@@ -310,6 +311,10 @@ void Precompiler::DoCompileAll(
         // Compile newly found targets and add their callees until we reach a
         // fixed point.
         Iterate();
+
+        // Replace the default type testing stubs installed on [Type]s with new
+        // [Type]-specialized stubs.
+        AttachOptimizedTypeTestingStub();
       }
 
       I->set_compilation_allowed(false);
@@ -1856,6 +1861,61 @@ void Precompiler::DropFields() {
   }
 }
 
+void Precompiler::AttachOptimizedTypeTestingStub() {
+  Isolate::Current()->heap()->CollectAllGarbage();
+  GrowableHandlePtrArray<const AbstractType> types(Z, 200);
+  {
+    class TypesCollector : public ObjectVisitor {
+     public:
+      explicit TypesCollector(Zone* zone,
+                              GrowableHandlePtrArray<const AbstractType>* types)
+          : type_(AbstractType::Handle(zone)), types_(types) {}
+
+      void VisitObject(RawObject* obj) {
+        if (obj->GetClassId() == kTypeCid || obj->GetClassId() == kTypeRefCid) {
+          type_ ^= obj;
+          types_->Add(type_);
+        }
+      }
+
+     private:
+      AbstractType& type_;
+      GrowableHandlePtrArray<const AbstractType>* types_;
+    };
+
+    HeapIterationScope his(T);
+    TypesCollector visitor(Z, &types);
+
+    // Find all type objects in this isolate.
+    I->heap()->VisitObjects(&visitor);
+
+    // Find all type objects in the vm-isolate.
+    Dart::vm_isolate()->heap()->VisitObjects(&visitor);
+  }
+
+  // Since we are potentially changing type objects in the vm-isolate (e.g.
+  // "dynamic") we need to mark it as writable.
+  Dart::vm_isolate()->heap()->WriteProtect(false);
+
+  TypeTestingStubGenerator type_testing_stubs;
+  Instructions& instr = Instructions::Handle();
+  for (intptr_t i = 0; i < types.length(); i++) {
+    const AbstractType& type = types.At(i);
+
+    // [kVectorCid] is excluded because it doesn't have a real class,
+    // corresponding to the class id, in Dart source code.
+    if (type.IsResolved() && !type.IsMalformedOrMalbounded() &&
+        (!type.IsType() || type.type_class_id() != kVectorCid)) {
+      instr = type_testing_stubs.OptimizedCodeForType(type);
+      type.SetTypeTestingStub(instr);
+    }
+  }
+  Dart::vm_isolate()->heap()->WriteProtect(true);
+
+  RELEASE_ASSERT(Object::dynamic_type().type_test_stub_entry_point() !=
+                 StubCode::DefaultTypeTest_entry()->EntryPoint());
+}
+
 void Precompiler::DropTypes() {
   ObjectStore* object_store = I->object_store();
   GrowableObjectArray& retained_types =

runtime/vm/compiler/aot/precompiler.h

@@ -373,6 +373,8 @@ class Precompiler : public ValueObject {
   void TraceConstFunctions();
   void CollectCallbackFields();
 
+  void AttachOptimizedTypeTestingStub();
+
   void TraceForRetainedFunctions();
   void DropFunctions();
   void DropFields();

runtime/vm/compiler/assembler/assembler_arm64.h

@@ -440,6 +440,11 @@ class Assembler : public ValueObject {
 
   void LoadField(Register dst, FieldAddress address) { ldr(dst, address); }
 
+  void CompareWithFieldValue(Register value, FieldAddress address) {
+    ldr(TMP, address);
+    cmp(value, Operand(TMP));
+  }
+
   // Misc. functionality
   intptr_t CodeSize() const { return buffer_.Size(); }
   intptr_t prologue_offset() const { return prologue_offset_; }

runtime/vm/compiler/assembler/assembler_ia32.h

@@ -566,6 +566,7 @@ class Assembler : public ValueObject {
 
   void CompareRegisters(Register a, Register b);
   void BranchIf(Condition condition, Label* label) { j(condition, label); }
+  void LoadField(Register dst, FieldAddress address) { movw(dst, address); }
 
   // Issues a move instruction if 'to' is not the same as 'from'.
   void MoveRegister(Register to, Register from);

runtime/vm/compiler/backend/flow_graph_compiler.cc

@@ -1910,7 +1910,50 @@ void FlowGraphCompiler::GenerateAssertAssignableAOT(
     __ BranchIfSmi(instance_reg, done);
   }
 
-  __ LoadObject(dst_type_reg, dst_type);
+  // We can handle certain types very efficiently on the call site (with a
+  // bailout to the normal stub, which will do a runtime call).
+  if (dst_type.IsTypeParameter()) {
+    const TypeParameter& type_param = TypeParameter::Cast(dst_type);
+    const Register kTypeArgumentsReg = type_param.IsClassTypeParameter()
+                                           ? instantiator_type_args_reg
+                                           : function_type_args_reg;
+
+    // Check if type arguments are null, i.e. equivalent to vector of dynamic.
+    __ CompareObject(kTypeArgumentsReg, Object::null_object());
+    __ BranchIf(EQUAL, done);
+    __ LoadField(dst_type_reg,
+                 FieldAddress(kTypeArgumentsReg, TypeArguments::type_at_offset(
+                                                     type_param.index())));
+  } else {
+    HierarchyInfo* hi = Thread::Current()->hierarchy_info();
+    if (hi != NULL) {
+      const Class& type_class = Class::Handle(zone(), dst_type.type_class());
+
+      // We can use [dst_name_reg], there is no overlap of use.
+      const Register scratch_reg = dst_name_reg;
+
+      bool used_cid_range_check = false;
+      const bool can_use_simple_cid_range_test =
+          hi->CanUseSubtypeRangeCheckFor(dst_type);
+      if (can_use_simple_cid_range_test) {
+        const CidRangeVector& ranges = hi->SubtypeRangesForClass(type_class);
+        if (ranges.length() <= kMaxNumberOfCidRangesToTest) {
+          __ LoadClassIdMayBeSmi(scratch_reg, instance_reg);
+          GenerateSubtypeRangeCheck(scratch_reg, type_class, done);
+          used_cid_range_check = true;
+        }
+      }
+
+      if (!used_cid_range_check && can_use_simple_cid_range_test &&
+          IsListClass(type_class)) {
+        __ LoadClassIdMayBeSmi(scratch_reg, instance_reg);
+        GenerateListTypeCheck(scratch_reg, done);
+        used_cid_range_check = true;
+      }
+    }
+    __ LoadObject(dst_type_reg, dst_type);
+  }
+
   __ LoadObject(dst_name_reg, dst_name);
   __ LoadObject(subtype_cache_reg,
                 SubtypeTestCache::ZoneHandle(zone(), SubtypeTestCache::New()));

runtime/vm/compiler/backend/flow_graph_compiler_arm.cc

@@ -725,7 +725,6 @@ void FlowGraphCompiler::GenerateAssertAssignableAOT(
                               kInstantiatorTypeArgumentsReg,
                               kFunctionTypeArgumentsReg, kSubtypeTestCacheReg,
                               kDstTypeReg, kDstNameReg, &done);
-
   __ LoadField(R9,
                FieldAddress(kDstTypeReg,
                             AbstractType::type_test_stub_entry_point_offset()));

runtime/vm/compiler/backend/il.cc

@@ -143,7 +143,7 @@ void HierarchyInfo::BuildRangesFor(ClassTable* table,
 bool HierarchyInfo::CanUseSubtypeRangeCheckFor(const AbstractType& type) {
   ASSERT(type.IsFinalized() && !type.IsMalformedOrMalbounded());
 
-  if (!type.IsInstantiated() || type.IsFunctionType() ||
+  if (!type.IsInstantiated() || !type.IsType() || type.IsFunctionType() ||
       type.IsDartFunctionType()) {
     return false;
   }
@@ -174,7 +174,7 @@ bool HierarchyInfo::CanUseGenericSubtypeRangeCheckFor(
     const AbstractType& type) {
   ASSERT(type.IsFinalized() && !type.IsMalformedOrMalbounded());
 
-  if (type.IsFunctionType() || type.IsDartFunctionType()) {
+  if (!type.IsType() || type.IsFunctionType() || type.IsDartFunctionType()) {
     return false;
   }
 

runtime/vm/object_store.h

@@ -125,6 +125,7 @@ class ObjectPointerVisitor;
   R_(Code, megamorphic_miss_code)                                              \
   R_(Function, megamorphic_miss_function)                                      \
   RW(Array, obfuscation_map)                                                   \
+  RW(GrowableObjectArray, type_testing_stubs)                                  \
   RW(GrowableObjectArray, changed_in_last_reload)                              \
 // Please remember the last entry must be referred in the 'to' function below.
 

runtime/vm/stub_code_arm.cc

@@ -17,7 +17,6 @@
 #include "vm/object_store.h"
 #include "vm/runtime_entry.h"
 #include "vm/stack_frame.h"
-#include "vm/stub_code.h"
 #include "vm/tags.h"
 #include "vm/type_testing_stubs.h"
 
@@ -1865,20 +1864,10 @@ void StubCode::GenerateDefaultTypeTestStub(Assembler* assembler) {
   Label done;
 
   const Register kInstanceReg = R0;
-  const Register kDstTypeReg = R8;
-
   // Fast case for 'null'.
   __ CompareObject(kInstanceReg, Object::null_object());
   __ BranchIf(EQUAL, &done);
 
-  // Fast case for 'int'.
-  Label not_smi;
-  __ BranchIfNotSmi(kInstanceReg, &not_smi);
-  __ CompareObject(kDstTypeReg, Object::ZoneHandle(Type::IntType()));
-  __ BranchIf(EQUAL, &done);
-  __ Bind(&not_smi);
-
-  // Tail call the [SubtypeTestCache]-based implementation.
   __ ldr(CODE_REG, Address(THR, Thread::slow_type_test_stub_offset()));
   __ ldr(R9, FieldAddress(CODE_REG, Code::entry_point_offset()));
   __ bx(R9);
@@ -1887,6 +1876,56 @@ void StubCode::GenerateDefaultTypeTestStub(Assembler* assembler) {
   __ Ret();
 }
 
+void TypeTestingStubGenerator::BuildOptimizedTypeTestStub(
+    Assembler* assembler,
+    HierarchyInfo* hi,
+    const Type& type,
+    const Class& type_class) {
+  const Register kInstanceReg = R0;
+  const Register kClassIdReg = R9;
+
+  BuildOptimizedTypeTestStubFastCases(assembler, hi, type, type_class,
+                                      kInstanceReg, kClassIdReg);
+
+  __ ldr(CODE_REG, Address(THR, Thread::slow_type_test_stub_offset()));
+  __ ldr(TMP, FieldAddress(CODE_REG, Code::entry_point_offset()));
+  __ bx(TMP);
+}
+
+void TypeTestingStubGenerator::
+    BuildOptimizedSubclassRangeCheckWithTypeArguments(Assembler* assembler,
+                                                      HierarchyInfo* hi,
+                                                      const Class& type_class,
+                                                      const TypeArguments& tp,
+                                                      const TypeArguments& ta) {
+  const Register kInstanceReg = R0;
+  const Register kInstanceTypeArguments = NOTFP;
+  const Register kClassIdReg = R9;
+
+  BuildOptimizedSubclassRangeCheckWithTypeArguments(
+      assembler, hi, type_class, tp, ta, kClassIdReg, kInstanceReg,
+      kInstanceTypeArguments);
+}
+
+void TypeTestingStubGenerator::BuildOptimizedTypeArgumentValueCheck(
+    Assembler* assembler,
+    HierarchyInfo* hi,
+    const AbstractType& type_arg,
+    intptr_t type_param_value_offset_i,
+    Label* check_failed) {
+  const Register kInstantiatorTypeArgumentsReg = R2;
+  const Register kFunctionTypeArgumentsReg = R1;
+  const Register kInstanceTypeArguments = NOTFP;
+
+  const Register kClassIdReg = R9;
+  const Register kOwnTypeArgumentValue = TMP;
+
+  BuildOptimizedTypeArgumentValueCheck(
+      assembler, hi, type_arg, type_param_value_offset_i, kClassIdReg,
+      kInstanceTypeArguments, kInstantiatorTypeArgumentsReg,
+      kFunctionTypeArgumentsReg, kOwnTypeArgumentValue, check_failed);
+}
+
 void StubCode::GenerateUnreachableTypeTestStub(Assembler* assembler) {
   __ Breakpoint();
 }

runtime/vm/stub_code_arm64.cc

@@ -16,6 +16,7 @@
 #include "vm/stack_frame.h"
 #include "vm/stub_code.h"
 #include "vm/tags.h"
+#include "vm/type_testing_stubs.h"
 
 #define __ assembler->
 
@@ -1934,6 +1935,56 @@ void StubCode::GenerateUnreachableTypeTestStub(Assembler* assembler) {
   __ Breakpoint();
 }
 
+void TypeTestingStubGenerator::BuildOptimizedTypeTestStub(
+    Assembler* assembler,
+    HierarchyInfo* hi,
+    const Type& type,
+    const Class& type_class) {
+  const Register kInstanceReg = R0;
+  const Register kClassIdReg = R9;
+
+  BuildOptimizedTypeTestStubFastCases(assembler, hi, type, type_class,
+                                      kInstanceReg, kClassIdReg);
+
+  __ ldr(CODE_REG, Address(THR, Thread::slow_type_test_stub_offset()));
+  __ ldr(R9, FieldAddress(CODE_REG, Code::entry_point_offset()));
+  __ br(R9);
+}
+
+void TypeTestingStubGenerator::
+    BuildOptimizedSubclassRangeCheckWithTypeArguments(Assembler* assembler,
+                                                      HierarchyInfo* hi,
+                                                      const Class& type_class,
+                                                      const TypeArguments& tp,
+                                                      const TypeArguments& ta) {
+  const Register kInstanceReg = R0;
+  const Register kInstanceTypeArguments = R7;
+  const Register kClassIdReg = R9;
+
+  BuildOptimizedSubclassRangeCheckWithTypeArguments(
+      assembler, hi, type_class, tp, ta, kClassIdReg, kInstanceReg,
+      kInstanceTypeArguments);
+}
+
+void TypeTestingStubGenerator::BuildOptimizedTypeArgumentValueCheck(
+    Assembler* assembler,
+    HierarchyInfo* hi,
+    const AbstractType& type_arg,
+    intptr_t type_param_value_offset_i,
+    Label* check_failed) {
+  const Register kInstantiatorTypeArgumentsReg = R1;
+  const Register kFunctionTypeArgumentsReg = R2;
+  const Register kInstanceTypeArguments = R7;
+
+  const Register kClassIdReg = R9;
+  const Register kOwnTypeArgumentValue = TMP;
+
+  BuildOptimizedTypeArgumentValueCheck(
+      assembler, hi, type_arg, type_param_value_offset_i, kClassIdReg,
+      kInstanceTypeArguments, kInstantiatorTypeArgumentsReg,
+      kFunctionTypeArgumentsReg, kOwnTypeArgumentValue, check_failed);
+}
+
 void StubCode::GenerateSlowTypeTestStub(Assembler* assembler) {
   Label done, call_runtime;