[VM] Improve AssertAssignable/InstanceOf by having a fast case for non-generic, instantiated types

When the type to test against is instantiated and has no type arguments
there is a high probability that we receive instances of that class or
subclasses at runtime.

This CL therefore extends the fast-path of AssertAssignable/InstanceOf
by checking whether the instance class id is within the cid ranges that
directly/indirectly implement/extend the type to test against.

Currently we have an almost depth-first preorder numbering of class ids
in AOT, but there are exceptions.  So each class can have a number of
cid-ranges as subclasses / classes which implement it's interface.

This seems to improve performance of dart-aot-v2
  * flutter stock build by 15+%
  * DeltaBlueClosures by 10+%

and reduces code size on
  * flutter gallery by -3%

Issue #31798

Change-Id: I07dd91589cc3fcd8c5952bdba339e2e2a459e08e
Reviewed-on: https://dart-review.googlesource.com/35620
Commit-Queue: Martin Kustermann <[email protected]>
Reviewed-by: Régis Crelier <[email protected]>
Reviewed-by: Vyacheslav Egorov <[email protected]>

Author: mkustermann

runtime/vm/class_table.cc

@@ -190,15 +190,6 @@ void ClassTable::AllocateIndex(intptr_t index) {
   }
 }
 
-void ClassTable::RegisterAt(intptr_t index, const Class& cls) {
-  ASSERT(Thread::Current()->IsMutatorThread());
-  ASSERT(index != kIllegalCid);
-  ASSERT(index >= kNumPredefinedCids);
-  AllocateIndex(index);
-  cls.set_id(index);
-  table_[index] = cls.raw();
-}
-
 #if defined(DEBUG)
 void ClassTable::Unregister(intptr_t index) {
   table_[index] = 0;

runtime/vm/class_table.h

@@ -191,8 +191,6 @@ class ClassTable {
 
   void AllocateIndex(intptr_t index);
 
-  void RegisterAt(intptr_t index, const Class& cls);
-
 #if defined(DEBUG)
   void Unregister(intptr_t index);
 #endif

runtime/vm/compiler/aot/aot_call_specializer.cc

@@ -994,13 +994,13 @@ bool AotCallSpecializer::TryReplaceInstanceOfWithRangeCheck(
     return false;
   }
 
-  TypeRangeCache* cache = precompiler_->type_range_cache();
-  if (cache == NULL) {
+  HierarchyInfo* hi = thread()->hierarchy_info();
+  if (hi == NULL) {
     return false;
   }
 
   intptr_t lower_limit, upper_limit;
-  if (!cache->InstanceOfHasClassRange(type, &lower_limit, &upper_limit)) {
+  if (!hi->InstanceOfHasClassRange(type, &lower_limit, &upper_limit)) {
     return false;
   }
 
@@ -1068,13 +1068,13 @@ bool AotCallSpecializer::TryReplaceTypeCastWithRangeCheck(
     return false;
   }
 
-  TypeRangeCache* cache = precompiler_->type_range_cache();
-  if (cache == NULL) {
+  HierarchyInfo* hi = thread()->hierarchy_info();
+  if (hi == NULL) {
     return false;
   }
 
   intptr_t lower_limit, upper_limit;
-  if (!cache->InstanceOfHasClassRange(type, &lower_limit, &upper_limit)) {
+  if (!hi->InstanceOfHasClassRange(type, &lower_limit, &upper_limit)) {
     return false;
   }
 

runtime/vm/compiler/aot/precompiler.cc

@@ -211,13 +211,6 @@ TypeRangeCache::TypeRangeCache(Precompiler* precompiler,
     lower_limits_[i] = kNotComputed;
     upper_limits_[i] = kNotComputed;
   }
-  ASSERT(precompiler->type_range_cache() == NULL);
-  precompiler->set_type_range_cache(this);
-}
-
-TypeRangeCache::~TypeRangeCache() {
-  ASSERT(precompiler_->type_range_cache() == this);
-  precompiler_->set_type_range_cache(NULL);
 }
 
 RawError* Precompiler::CompileAll(
@@ -235,98 +228,6 @@ RawError* Precompiler::CompileAll(
   }
 }
 
-bool TypeRangeCache::InstanceOfHasClassRange(const AbstractType& type,
-                                             intptr_t* lower_limit,
-                                             intptr_t* upper_limit) {
-  ASSERT(type.IsFinalized() && !type.IsMalformedOrMalbounded());
-
-  if (!type.IsInstantiated()) return false;
-  if (type.IsFunctionType()) return false;
-  if (type.IsDartFunctionType()) return false;
-
-  Zone* zone = thread_->zone();
-  const TypeArguments& type_arguments =
-      TypeArguments::Handle(zone, type.arguments());
-  if (!type_arguments.IsNull() &&
-      !type_arguments.IsRaw(0, type_arguments.Length()))
-    return false;
-
-  intptr_t type_cid = type.type_class_id();
-  if (lower_limits_[type_cid] == kNotContiguous) return false;
-  if (lower_limits_[type_cid] != kNotComputed) {
-    *lower_limit = lower_limits_[type_cid];
-    *upper_limit = upper_limits_[type_cid];
-    return true;
-  }
-
-  *lower_limit = -1;
-  *upper_limit = -1;
-  intptr_t last_matching_cid = -1;
-
-  ClassTable* table = thread_->isolate()->class_table();
-  Class& cls = Class::Handle(zone);
-  AbstractType& cls_type = AbstractType::Handle(zone);
-  for (intptr_t cid = kInstanceCid; cid < table->NumCids(); cid++) {
-    // Create local zone because deep hierarchies may allocate lots of handles
-    // within one iteration of this loop.
-    StackZone stack_zone(thread_);
-    HANDLESCOPE(thread_);
-
-    if (!table->HasValidClassAt(cid)) continue;
-    if (cid == kTypeArgumentsCid) continue;
-    if (cid == kVoidCid) continue;
-    if (cid == kDynamicCid) continue;
-    if (cid == kNullCid) continue;  // Instance is not at Bottom like Null type.
-    cls = table->At(cid);
-    if (cls.is_abstract()) continue;
-    if (cls.is_patch()) continue;
-    if (cls.IsTopLevel()) continue;
-
-    cls_type = cls.RareType();
-    if (cls_type.IsSubtypeOf(type, NULL, NULL, Heap::kNew)) {
-      last_matching_cid = cid;
-      if (*lower_limit == -1) {
-        // Found beginning of range.
-        *lower_limit = cid;
-      } else if (*upper_limit == -1) {
-        // Expanding range.
-      } else {
-        // Found a second range.
-        lower_limits_[type_cid] = kNotContiguous;
-        return false;
-      }
-    } else {
-      if (*lower_limit == -1) {
-        // Still before range.
-      } else if (*upper_limit == -1) {
-        // Found end of range.
-        *upper_limit = last_matching_cid;
-      } else {
-        // After range.
-      }
-    }
-  }
-  if (*lower_limit == -1) {
-    // Not implemented by any concrete class.
-    *lower_limit = kIllegalCid;
-    *upper_limit = kIllegalCid;
-  }
-
-  if (*upper_limit == -1) {
-    ASSERT(last_matching_cid != -1);
-    *upper_limit = last_matching_cid;
-  }
-
-  if (FLAG_trace_precompiler) {
-    THR_Print("Type check for %s is cid range [%" Pd ", %" Pd "]\n",
-              type.ToCString(), *lower_limit, *upper_limit);
-  }
-
-  lower_limits_[type_cid] = *lower_limit;
-  upper_limits_[type_cid] = *upper_limit;
-  return true;
-}
-
 Precompiler::Precompiler(Thread* thread)
     : thread_(thread),
       zone_(NULL),
@@ -354,7 +255,6 @@ Precompiler::Precompiler(Thread* thread)
       types_to_retain_(),
       consts_to_retain_(),
       field_type_map_(),
-      type_range_cache_(NULL),
       error_(Error::Handle()),
       get_runtime_type_is_unique_(false) {}
 
@@ -375,7 +275,10 @@ void Precompiler::DoCompileAll(
       ASSERT(Error::Handle(Z, T->sticky_error()).IsNull());
 
       ClassFinalizer::SortClasses();
-      TypeRangeCache trc(this, T, I->class_table()->NumCids());
+
+      // The cid-ranges of subclasses of a class are e.g. used for is/as checks
+      // as well as other type checks.
+      HierarchyInfo hierarchy_info(T);
 
       // Precompile static initializers to compute result type information.
       PrecompileStaticInitializers();

runtime/vm/compiler/aot/precompiler.h

@@ -343,10 +343,6 @@ class Precompiler : public ValueObject {
   }
 
   FieldTypeMap* field_type_map() { return &field_type_map_; }
-  TypeRangeCache* type_range_cache() { return type_range_cache_; }
-  void set_type_range_cache(TypeRangeCache* value) {
-    type_range_cache_ = value;
-  }
 
   static void PopulateWithICData(const Function& func, FlowGraph* graph);
 
@@ -433,7 +429,6 @@ class Precompiler : public ValueObject {
   AbstractTypeSet types_to_retain_;
   InstanceSet consts_to_retain_;
   FieldTypeMap field_type_map_;
-  TypeRangeCache* type_range_cache_;
   CidMap feedback_cid_map_;
   FunctionFeedbackMap function_feedback_map_;
   Error& error_;

runtime/vm/compiler/assembler/assembler_ia32.h

@@ -643,6 +643,10 @@ class Assembler : public ValueObject {
   void AddImmediate(Register reg, const Immediate& imm);
   void SubImmediate(Register reg, const Immediate& imm);
 
+  void CompareImmediate(Register reg, int32_t immediate) {
+    cmpl(reg, Immediate(immediate));
+  }
+
   void Drop(intptr_t stack_elements);
 
   void LoadIsolate(Register dst);

runtime/vm/compiler/assembler/assembler_x64.h

@@ -582,6 +582,9 @@ class Assembler : public ValueObject {
 
   void CompareImmediate(Register reg, const Immediate& imm);
   void CompareImmediate(const Address& address, const Immediate& imm);
+  void CompareImmediate(Register reg, int32_t immediate) {
+    return CompareImmediate(reg, Immediate(immediate));
+  }
 
   void testl(Register reg, const Immediate& imm) { testq(reg, imm); }
   void testb(const Address& address, const Immediate& imm);

runtime/vm/compiler/backend/flow_graph_compiler.cc

@@ -1148,7 +1148,7 @@ void FlowGraphCompiler::GenerateStaticCall(intptr_t deopt_id,
   }
 }
 
-void FlowGraphCompiler::GenerateNumberTypeCheck(Register kClassIdReg,
+void FlowGraphCompiler::GenerateNumberTypeCheck(Register class_id_reg,
                                                 const AbstractType& type,
                                                 Label* is_instance_lbl,
                                                 Label* is_not_instance_lbl) {
@@ -1164,10 +1164,10 @@ void FlowGraphCompiler::GenerateNumberTypeCheck(Register kClassIdReg,
   } else if (type.IsDoubleType()) {
     args.Add(kDoubleCid);
   }
-  CheckClassIds(kClassIdReg, args, is_instance_lbl, is_not_instance_lbl);
+  CheckClassIds(class_id_reg, args, is_instance_lbl, is_not_instance_lbl);
 }
 
-void FlowGraphCompiler::GenerateStringTypeCheck(Register kClassIdReg,
+void FlowGraphCompiler::GenerateStringTypeCheck(Register class_id_reg,
                                                 Label* is_instance_lbl,
                                                 Label* is_not_instance_lbl) {
   assembler()->Comment("StringTypeCheck");
@@ -1176,18 +1176,18 @@ void FlowGraphCompiler::GenerateStringTypeCheck(Register kClassIdReg,
   args.Add(kTwoByteStringCid);
   args.Add(kExternalOneByteStringCid);
   args.Add(kExternalTwoByteStringCid);
-  CheckClassIds(kClassIdReg, args, is_instance_lbl, is_not_instance_lbl);
+  CheckClassIds(class_id_reg, args, is_instance_lbl, is_not_instance_lbl);
 }
 
-void FlowGraphCompiler::GenerateListTypeCheck(Register kClassIdReg,
+void FlowGraphCompiler::GenerateListTypeCheck(Register class_id_reg,
                                               Label* is_instance_lbl) {
   assembler()->Comment("ListTypeCheck");
   Label unknown;
   GrowableArray<intptr_t> args;
   args.Add(kArrayCid);
   args.Add(kGrowableObjectArrayCid);
   args.Add(kImmutableArrayCid);
-  CheckClassIds(kClassIdReg, args, is_instance_lbl, &unknown);
+  CheckClassIds(class_id_reg, args, is_instance_lbl, &unknown);
   assembler()->Bind(&unknown);
 }
 #endif  // !defined(TARGET_ARCH_DBC)
@@ -1813,7 +1813,7 @@ void FlowGraphCompiler::EmitTestAndCall(const CallTargets& targets,
   int bias = 0;
 
   // Value is not Smi.
-  EmitTestAndCallLoadCid();
+  EmitTestAndCallLoadCid(EmitTestCidRegister());
 
   int last_check = which_case_to_skip == length - 1 ? length - 2 : length - 1;
 
@@ -1832,7 +1832,8 @@ void FlowGraphCompiler::EmitTestAndCall(const CallTargets& targets,
     Label next_test;
     if (!complete || !is_last_check) {
       bias = EmitTestAndCallCheckCid(is_last_check ? failed : &next_test,
-                                     targets[i], bias);
+                                     EmitTestCidRegister(), targets[i], bias,
+                                     /*jump_on_miss =*/true);
     }
     // Do not use the code from the function, but let the code be patched so
     // that we can record the outgoing edges to other code.
@@ -1852,6 +1853,42 @@ void FlowGraphCompiler::EmitTestAndCall(const CallTargets& targets,
                                 token_index, locs, try_index);
   }
 }
+
+bool FlowGraphCompiler::GenerateSubclassTypeCheck(Register class_id_reg,
+                                                  const Class& type_class,
+                                                  Label* is_subtype) {
+  HierarchyInfo* hi = Thread::Current()->hierarchy_info();
+  if (hi != NULL) {
+    // We test up to 4 different cid ranges, if we would need to test more in
+    // order to get a definite answer we fall back to the old mechanism (namely
+    // of going into the subtyping cache)
+    static const intptr_t kMaxNumberOfCidRangesToTest = 4;
+
+    const CidRangeVector& ranges = hi->SubtypeRangesForClass(type_class);
+    if (ranges.length() <= kMaxNumberOfCidRangesToTest) {
+      Label fail;
+      int bias = 0;
+      for (intptr_t i = 0; i < ranges.length(); ++i) {
+        const CidRange& range = ranges[i];
+        if (!range.IsIllegalRange()) {
+          bias = EmitTestAndCallCheckCid(is_subtype, class_id_reg, range, bias,
+                                         /*jump_on_miss=*/false);
+        }
+      }
+      __ Bind(&fail);
+      return true;
+    }
+  }
+
+  // We don't have cid-ranges for subclasses, so we'll just test against the
+  // class directly if it's non-abstract.
+  if (!type_class.is_abstract()) {
+    __ CompareImmediate(class_id_reg, type_class.id());
+    __ BranchIf(EQUAL, is_subtype);
+  }
+  return false;
+}
+
 #undef __
 #endif
 

runtime/vm/compiler/backend/flow_graph_compiler.h

@@ -397,6 +397,13 @@ class FlowGraphCompiler : public ValueObject {
                                Label* is_not_instance_lbl);
   void GenerateListTypeCheck(Register kClassIdReg, Label* is_instance_lbl);
 
+  // Returns true if no further checks are necessary but the code coming after
+  // the emitted code here is still required do a runtime call (for the negative
+  // case of throwing an exception).
+  bool GenerateSubclassTypeCheck(Register class_id_reg,
+                                 const Class& type_class,
+                                 Label* is_subtype_lbl);
+
   void EmitOptimizedInstanceCall(const StubEntry& stub_entry,
                                  const ICData& ic_data,
                                  intptr_t deopt_id,
@@ -651,17 +658,22 @@ class FlowGraphCompiler : public ValueObject {
                                            intptr_t max_immediate);
 
   // More helpers for EmitTestAndCall.
+
+  static Register EmitTestCidRegister();
+
   void EmitTestAndCallLoadReceiver(intptr_t count_without_type_args,
                                    const Array& arguments_descriptor);
 
   void EmitTestAndCallSmiBranch(Label* label, bool jump_if_smi);
 
-  void EmitTestAndCallLoadCid();
+  void EmitTestAndCallLoadCid(Register class_id_reg);
 
   // Returns new class-id bias.
-  int EmitTestAndCallCheckCid(Label* next_label,
+  int EmitTestAndCallCheckCid(Label* label,
+                              Register class_id_reg,
                               const CidRange& range,
-                              int bias);
+                              int bias,
+                              bool jump_on_miss = true);
 
 // DBC handles type tests differently from all other architectures due
 // to its interpreted nature.