[vm] Don't insert CheckedSmi* instructions when the interface target suggests it's wrong.

Change-Id: I97e45dc5c74f0d6e9193c0fa95dd679a42133f78
Reviewed-on: https://dart-review.googlesource.com/c/sdk/+/138521
Reviewed-by: Victor Agnez Lima <[email protected]>
Reviewed-by: Martin Kustermann <[email protected]>
Commit-Queue: Samir Jindel <[email protected]>

Author: sjindel-google

runtime/vm/compiler/aot/aot_call_specializer.cc

@@ -220,6 +220,13 @@ bool AotCallSpecializer::TryReplaceWithHaveSameRuntimeType(
 
 static bool HasLikelySmiOperand(InstanceCallInstr* instr) {
   ASSERT(instr->type_args_len() == 0);
+
+  // If Smi is not assignable to the interface target of the call, the receiver
+  // is definitely not a Smi.
+  if (instr->HasNonSmiAssignableInterface(Thread::Current()->zone())) {
+    return false;
+  }
+
   // Phis with at least one known smi are // guessed to be likely smi as well.
   for (intptr_t i = 0; i < instr->ArgumentCount(); ++i) {
     PhiInstr* phi = instr->ArgumentAt(i)->AsPhi();
@@ -472,9 +479,15 @@ bool AotCallSpecializer::TryOptimizeIntegerOperation(TemplateDartCall<0>* instr,
     CompileType* right_type = right_value->Type();
 
     const bool is_equality_op = Token::IsEqualityOperator(op_kind);
-    const bool has_nullable_int_args =
+    bool has_nullable_int_args =
         left_type->IsNullableInt() && right_type->IsNullableInt();
 
+    if (auto* call = instr->AsInstanceCall()) {
+      if (call->HasNonSmiAssignableInterface(zone())) {
+        has_nullable_int_args = false;
+      }
+    }
+
     // NOTE: We cannot use strict comparisons if the receiver has an overridden
     // == operator or if either side can be a double, since 1.0 == 1.
     const bool can_use_strict_compare =

runtime/vm/compiler/backend/il.cc

@@ -4287,19 +4287,26 @@ static RawCode* TwoArgsSmiOpInlineCacheEntry(Token::Kind kind) {
   }
 }
 
+bool InstanceCallBaseInstr::HasNonSmiAssignableInterface(Zone* zone) const {
+  if (!interface_target().IsNull()) {
+    const AbstractType& target_type = AbstractType::Handle(
+        zone, Class::Handle(zone, interface_target().Owner()).RareType());
+    if (!CompileType::Smi().IsAssignableTo(target_type)) {
+      return true;
+    }
+  }
+  return false;
+}
+
 void InstanceCallBaseInstr::UpdateReceiverSminess(Zone* zone) {
   if (FLAG_precompiled_mode && !receiver_is_not_smi()) {
     if (Receiver()->Type()->IsNotSmi()) {
       set_receiver_is_not_smi(true);
       return;
     }
 
-    if (!interface_target().IsNull()) {
-      const AbstractType& target_type = AbstractType::Handle(
-          zone, Class::Handle(zone, interface_target().Owner()).RareType());
-      if (!CompileType::Smi().IsAssignableTo(target_type)) {
-        set_receiver_is_not_smi(true);
-      }
+    if (HasNonSmiAssignableInterface(zone)) {
+      set_receiver_is_not_smi(true);
     }
   }
 }

runtime/vm/compiler/backend/il.h

@@ -61,7 +61,7 @@ class UnboxIntegerInstr;
 namespace compiler {
 class BlockBuilder;
 struct TableSelector;
-}
+}  // namespace compiler
 
 class Value : public ZoneAllocated {
  public:
@@ -239,9 +239,7 @@ class HierarchyInfo : public ThreadStackResource {
     thread->set_hierarchy_info(this);
   }
 
-  ~HierarchyInfo() {
-    thread()->set_hierarchy_info(NULL);
-  }
+  ~HierarchyInfo() { thread()->set_hierarchy_info(NULL); }
 
   const CidRangeVector& SubtypeRangesForClass(const Class& klass,
                                               bool include_abstract,
@@ -3854,6 +3852,8 @@ class InstanceCallBaseInstr : public TemplateDartCall<0> {
   // interface target, CompileType and hints from TFA.
   void UpdateReceiverSminess(Zone* zone);
 
+  bool HasNonSmiAssignableInterface(Zone* zone) const;
+
  protected:
   friend class CallSpecializer;
   void set_ic_data(ICData* value) { ic_data_ = value; }
@@ -7047,6 +7047,10 @@ class CheckedSmiOpInstr : public TemplateDefinition<2, Throws> {
                     TemplateDartCall<0>* call)
       : TemplateDefinition(call->deopt_id()), call_(call), op_kind_(op_kind) {
     ASSERT(call->type_args_len() == 0);
+    ASSERT(!call->IsInstanceCallBase() ||
+           !call->AsInstanceCallBase()->HasNonSmiAssignableInterface(
+               Thread::Current()->zone()));
+
     SetInputAt(0, left);
     SetInputAt(1, right);
   }
@@ -7086,6 +7090,10 @@ class CheckedSmiComparisonInstr : public TemplateComparison<2, Throws> {
         call_(call),
         is_negated_(false) {
     ASSERT(call->type_args_len() == 0);
+    ASSERT(!call->IsInstanceCallBase() ||
+           !call->AsInstanceCallBase()->HasNonSmiAssignableInterface(
+               Thread::Current()->zone()));
+
     SetInputAt(0, left);
     SetInputAt(1, right);
   }

runtime/vm/compiler/call_specializer.cc

@@ -125,13 +125,16 @@ bool CallSpecializer::TryCreateICData(InstanceCallInstr* call) {
         Token::IsEqualityOperator(op_kind) ||
         Token::IsBinaryOperator(op_kind)) {
       // Guess cid: if one of the inputs is a number assume that the other
-      // is a number of same type.
-      const intptr_t cid_0 = class_ids[0];
-      const intptr_t cid_1 = class_ids[1];
-      if ((cid_0 == kDynamicCid) && (IsNumberCid(cid_1))) {
-        class_ids[0] = cid_1;
-      } else if (IsNumberCid(cid_0) && (cid_1 == kDynamicCid)) {
-        class_ids[1] = cid_0;
+      // is a number of same type, unless the interface target tells us this
+      // is impossible.
+      if (!call->HasNonSmiAssignableInterface(zone())) {
+        const intptr_t cid_0 = class_ids[0];
+        const intptr_t cid_1 = class_ids[1];
+        if ((cid_0 == kDynamicCid) && (IsNumberCid(cid_1))) {
+          class_ids[0] = cid_1;
+        } else if (IsNumberCid(cid_0) && (cid_1 == kDynamicCid)) {
+          class_ids[1] = cid_0;
+        }
       }
     }
   }