Better inlining of type tests.

runtime/vm/flow_graph_optimizer.cc

 // Copyright (c) 2013, 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.
 
 #include "vm/flow_graph_optimizer.h"
 
 #include "vm/bit_vector.h"
 #include "vm/cha.h"
 #include "vm/cpu.h"
 #include "vm/dart_entry.h"
@@ skipping 3541 matching lines @@
     if (defn->IsRedefinition()) {
       defn = defn->AsRedefinition()->value()->definition();
     } else {
       defn = defn->AsAssertAssignable()->value()->definition();
     }
   }
   return defn;
 }
 
 
+// Returns true if checking against this type is a direct class id comparison.
+static bool TypeCheckAsClassEquality(const AbstractType& type) {
+  ASSERT(type.IsFinalized() && !type.IsMalformedOrMalbounded());
+  // Requires CHA, which can be applied in optimized code only,

[regis, 2014/03/03 17:54:25]

Comment ending with a comma.

[Florian Schneider, 2014/03/03 18:09:50]

Done.

+  if (!FLAG_use_cha) return false;
+  if (!type.IsInstantiated()) return false;
+  const Class& type_class = Class::Handle(type.type_class());
+  // Signature classes have different type checking rules.
+  if (type_class.IsSignatureClass()) return false;
+  // Could be an interface check?
+  if (type_class.is_implemented()) return false;
+  const intptr_t type_cid = type_class.id();
+  if (CHA::HasSubclasses(type_cid)) return false;
+  const intptr_t num_type_args = type_class.NumTypeArguments();
+  if (num_type_args > 0) {
+    // Only raw types can be directly compared, thus disregarding type
+    // arguments.
+    const intptr_t num_type_params = type_class.NumTypeParameters();
+    const intptr_t from_index = num_type_args - num_type_params;
+    const TypeArguments& type_arguments =
+        TypeArguments::Handle(type.arguments());
+    const bool is_raw_type = type_arguments.IsNull() ||
+        type_arguments.IsRaw(from_index, num_type_params);
+    return is_raw_type;
+  }
+  return true;
+}
+
+
 // TODO(srdjan): Use ICData to check if always true or false.
 void FlowGraphOptimizer::ReplaceWithInstanceOf(InstanceCallInstr* call) {
   ASSERT(Token::IsTypeTestOperator(call->token_kind()));
   Definition* left = call->ArgumentAt(0);
   Definition* instantiator = call->ArgumentAt(1);
   Definition* type_args = call->ArgumentAt(2);
   const AbstractType& type =
       AbstractType::Cast(call->ArgumentAt(3)->AsConstant()->value());
   const bool negate = Bool::Cast(
       OriginalDefinition(call->ArgumentAt(4))->AsConstant()->value()).value();
@@ skipping 11 matching lines @@
         PushArgumentInstr* push = call->PushArgumentAt(i);
         push->ReplaceUsesWith(push->value()->definition());
         push->RemoveFromGraph();
       }
       call->ReplaceUsesWith(bool_const);
       ASSERT(current_iterator()->Current() == call);
       current_iterator()->RemoveCurrentFromGraph();
       return;
     }
   }
+
+  if (TypeCheckAsClassEquality(type)) {

[srdjan, 2014/03/03 18:13:25]

For next CL eventually: how about supporting a set of cid-s, e.g., if the class
has only a small number of subclasses?

[Florian Schneider, 2014/03/04 10:22:52]

Definitely.

+    LoadClassIdInstr* left_cid = new LoadClassIdInstr(new Value(left));
+    InsertBefore(call,
+                 left_cid,
+                 NULL,
+                 Definition::kValue);
+    const intptr_t type_cid = Class::Handle(type.type_class()).id();
+    ConstantInstr* cid =
+        flow_graph()->GetConstant(Smi::Handle(Smi::New(type_cid)));
+
+    StrictCompareInstr* check_cid =
+        new StrictCompareInstr(call->token_pos(),
+                               negate ? Token::kNE_STRICT : Token::kEQ_STRICT,
+                               new Value(left_cid),
+                               new Value(cid),
+                               false);  // No number check.
+    ReplaceCall(call, check_cid);
+    return;
+  }
+
   InstanceOfInstr* instance_of =
       new InstanceOfInstr(call->token_pos(),
                           new Value(left),
                           new Value(instantiator),
                           new Value(type_args),
                           type,
                           negate,
                           call->deopt_id());
   ReplaceCall(call, instance_of);
 }
@@ skipping 5007 matching lines @@
   }
 
   // Insert materializations at environment uses.
   for (intptr_t i = 0; i < exits.length(); i++) {
     CreateMaterializationAt(exits[i], alloc, alloc->cls(), *fields);
   }
 }
 
 
 }  // namespace dart