Speed up AOT compilation of is-tests.

runtime/vm/precompiler.cc

 // Copyright (c) 2015, 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/precompiler.h"
 
 #include "vm/aot_optimizer.h"
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/branch_optimizer.h"
@@ skipping 227 matching lines @@
 }
 
 
 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 == 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::kOld)) {
+    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;
@@ skipping 3361 matching lines @@
 
   ASSERT(FLAG_precompiled_mode);
   const bool optimized = function.IsOptimizable();  // False for natives.
   DartPrecompilationPipeline pipeline(zone, field_type_map);
   return PrecompileFunctionHelper(precompiler, &pipeline, function, optimized);
 }
 
 #endif  // DART_PRECOMPILER
 
 }  // namespace dart