[vm] Only check for Smi once when reloading cid for TTS cid checks.

When generating a type testing stub (TTS) for implemented classes,
multiple cid range check blocks may be generated, each of which
requires reloading the cid. This CL makes it so that only a single
Smi check will be generated the first time the cid is loaded, so
later checks can just load the cid directly without the Smi case.

TEST=vm/cc/TTS

Change-Id: I4d76ee34a03cf4a0def268e9f74a096e3c0deb58
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/238702
Reviewed-by: Slava Egorov <[email protected]>
Commit-Queue: Tess Strickland <[email protected]>

Author: sstrickl

runtime/vm/compiler/backend/il.h

@@ -201,7 +201,9 @@ struct CidRange : public ZoneAllocated {
   CidRange() : cid_start(kIllegalCid), cid_end(kIllegalCid) {}
 
   bool IsSingleCid() const { return cid_start == cid_end; }
-  bool Contains(intptr_t cid) { return cid_start <= cid && cid <= cid_end; }
+  bool Contains(intptr_t cid) const {
+    return cid_start <= cid && cid <= cid_end;
+  }
   int32_t Extent() const { return cid_end - cid_start; }
 
   // The number of class ids this range covers.
@@ -224,7 +226,9 @@ struct CidRangeValue {
       : cid_start(other.cid_start), cid_end(other.cid_end) {}
 
   bool IsSingleCid() const { return cid_start == cid_end; }
-  bool Contains(intptr_t cid) { return cid_start <= cid && cid <= cid_end; }
+  bool Contains(intptr_t cid) const {
+    return cid_start <= cid && cid <= cid_end;
+  }
   int32_t Extent() const { return cid_end - cid_start; }
 
   // The number of class ids this range covers.
@@ -244,6 +248,18 @@ struct CidRangeValue {
 
 typedef MallocGrowableArray<CidRangeValue> CidRangeVector;
 
+class CidRangeVectorUtils : public AllStatic {
+ public:
+  static bool ContainsCid(const CidRangeVector& ranges, intptr_t cid) {
+    for (const CidRangeValue& range : ranges) {
+      if (range.Contains(cid)) {
+        return true;
+      }
+    }
+    return false;
+  }
+};
+
 class HierarchyInfo : public ThreadStackResource {
  public:
   explicit HierarchyInfo(Thread* thread)

runtime/vm/type_testing_stubs.cc

@@ -897,11 +897,26 @@ bool TypeTestingStubGenerator::BuildLoadInstanceTypeArguments(
   CidRangeVector cid_checks_only, type_argument_checks, not_checked;
   SplitOnTypeArgumentTests(hi, type, type_class, ranges, &cid_checks_only,
                            &type_argument_checks, &not_checked);
+  ASSERT(!CidRangeVectorUtils::ContainsCid(type_argument_checks, kSmiCid));
+  const bool smi_valid =
+      CidRangeVectorUtils::ContainsCid(cid_checks_only, kSmiCid);
+  // If we'll generate any cid checks and Smi isn't a valid subtype, then
+  // do a single Smi check here, since each generated check requires a fresh
+  // load of the class id. Otherwise, we'll generate the Smi check as part of
+  // the cid checks only block.
+  if (!smi_valid &&
+      (!cid_checks_only.is_empty() || !type_argument_checks.is_empty())) {
+    __ BranchIfSmi(TypeTestABI::kInstanceReg, load_failed);
+  }
   if (!cid_checks_only.is_empty()) {
     compiler::Label is_subtype, keep_looking;
     compiler::Label* check_failed =
         type_argument_checks.is_empty() ? load_failed : &keep_looking;
-    __ LoadClassIdMayBeSmi(class_id_reg, TypeTestABI::kInstanceReg);
+    if (smi_valid) {
+      __ LoadClassIdMayBeSmi(class_id_reg, TypeTestABI::kInstanceReg);
+    } else {
+      __ LoadClassId(class_id_reg, TypeTestABI::kInstanceReg);
+    }
     BuildOptimizedSubtypeRangeCheck(assembler, cid_checks_only, class_id_reg,
                                     &is_subtype, check_failed);
     __ Bind(&is_subtype);
@@ -929,7 +944,7 @@ bool TypeTestingStubGenerator::BuildLoadInstanceTypeArguments(
       // and avoid emitting a jump to load_succeeded.
       compiler::Label* check_failed =
           i < vectors.length() - 1 ? &keep_looking : load_failed;
-      __ LoadClassIdMayBeSmi(class_id_reg, TypeTestABI::kInstanceReg);
+      __ LoadClassId(class_id_reg, TypeTestABI::kInstanceReg);
       BuildOptimizedSubtypeRangeCheck(assembler, *vector, class_id_reg,
                                       &load_tav, check_failed);
       __ Bind(&load_tav);