Attempt to do direct class comparison for type checks using CHA.

runtime/vm/flow_graph_compiler.cc

 // Copyright (c) 2012, 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/globals.h"  // Needed here to get TARGET_ARCH_XXX.
 
 #include "vm/flow_graph_compiler.h"
 
+#include "vm/cha.h"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/il_printer.h"
 #include "vm/intrinsifier.h"
 #include "vm/locations.h"
 #include "vm/longjump.h"
 #include "vm/object_store.h"
 #include "vm/parser.h"
 #include "vm/stub_code.h"
 #include "vm/symbols.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_scopes, false, "Print scopes of local variables.");
 DECLARE_FLAG(bool, code_comments);
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, intrinsify);
 DECLARE_FLAG(bool, propagate_ic_data);
 DECLARE_FLAG(bool, report_usage_count);
 DECLARE_FLAG(int, optimization_counter_threshold);
+DECLARE_FLAG(bool, use_cha);
 
 void CompilerDeoptInfo::BuildReturnAddress(DeoptInfoBuilder* builder,
                                            const Function& function,
                                            intptr_t slot_ix) {
   builder->AddReturnAddressAfter(function, deopt_id(), slot_ix);
 }
 
 
 void CompilerDeoptInfoWithStub::BuildReturnAddress(DeoptInfoBuilder* builder,
                                                    const Function& function,
@@ skipping 956 matching lines @@
     case kFloat64ArrayCid:
       return FieldAddress(array, index, TIMES_4, Float64Array::data_offset());
     case kUint8ArrayCid:
       return FieldAddress(array, index, TIMES_1, Uint8Array::data_offset());
     default:
       UNIMPLEMENTED();
       return FieldAddress(SPREG, 0);
   }
 }
 
+
+// Returns true if checking against this type is a direct class id comparison.
+bool FlowGraphCompiler::TypeCheckAsClassEquality(const AbstractType& type) {

[regis, 2012/11/29 00:28:32]

ASSERT(type.IsFinalized() && !type.IsMalformed());

[srdjan, 2012/11/29 00:33:36]

Done.

+  // Requires CHA, which can be applied in optimized code only,
+  if (!FLAG_use_cha || !is_optimizing()) return false;
+  if (!type.IsInstantiated()) return false;
+  const Class& type_class = Class::Handle(type.type_class());
+  // 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;
+  if (type_class.HasTypeArguments()) {
+    // Only raw types can be directly compared, thus disregarding type
+    // arguments.
+    const AbstractTypeArguments& type_arguments =
+        AbstractTypeArguments::Handle(type.arguments());
+    const bool is_raw_type = type_arguments.IsNull() ||
+        type_arguments.IsRaw(type_arguments.Length());
+    return is_raw_type;
+  }
+  return true;
+}
+
 }  // namespace dart