VM: [Kernel] Allocate objects in KernelReader/kernel::FlowGraphBuilder in Heap::kOld if appropriate

runtime/vm/kernel_reader.cc

 // Copyright (c) 2016, 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/kernel_reader.h"
 
 #include <string.h>
 
 #include "vm/dart_api_impl.h"
 #include "vm/longjump.h"
@@ skipping 86 matching lines @@
     : program_(program),
       thread_(dart::Thread::Current()),
       zone_(thread_->zone()),
       isolate_(thread_->isolate()),
       scripts_(Array::ZoneHandle(zone_)),
       translation_helper_(this, thread_, zone_, isolate_),
       type_translator_(&translation_helper_,
                        &active_class_,
                        /*finalize=*/false) {
   intptr_t source_file_count = program_->line_starting_table().size();
-  scripts_ = Array::New(source_file_count);
+  scripts_ = Array::New(source_file_count, Heap::kOld);
 }
 
 Object& KernelReader::ReadProgram() {
   LongJumpScope jump;
   if (setjmp(*jump.Set()) == 0) {
     Procedure* main = program_->main_method();
     Library* kernel_main_library = Library::Cast(main->parent());
 
     intptr_t length = program_->libraries().length();
     for (intptr_t i = 0; i < length; i++) {
@@ skipping 140 matching lines @@
   if (kernel_normal_class->super_class() != NULL) {
     AbstractType& super_type =
         T.TranslateTypeWithoutFinalization(kernel_normal_class->super_class());
     if (super_type.IsMalformed()) H.ReportError("Malformed super type");
     klass->set_super_type(super_type);
   }
 
   // Build implemented interface types
   intptr_t interface_count = kernel_klass->implemented_classes().length();
   const dart::Array& interfaces =
-      dart::Array::Handle(Z, dart::Array::New(interface_count));
+      dart::Array::Handle(Z, dart::Array::New(interface_count, Heap::kOld));
   for (intptr_t i = 0; i < interface_count; i++) {
     InterfaceType* kernel_interface_type =
         kernel_klass->implemented_classes()[i];
     const AbstractType& type =
         T.TranslateTypeWithoutFinalization(kernel_interface_type);
     if (type.IsMalformed()) H.ReportError("Malformed interface type.");
     interfaces.SetAt(i, type);
   }
   klass->set_interfaces(interfaces);
   if (kernel_klass->is_abstract()) klass->set_is_abstract();
@@ skipping 149 matching lines @@
     return PatchClass::ZoneHandle(Z, PatchClass::New(klass, correct_script));
   }
   return klass;
 }
 
 Script& KernelReader::ScriptAt(intptr_t source_uri_index) {
   Script& script = Script::ZoneHandle(Z);
   script ^= scripts_.At(source_uri_index);
   if (script.IsNull()) {
     String* uri = program_->source_uri_table().strings()[source_uri_index];
-    script = Script::New(H.DartString(uri), dart::String::ZoneHandle(Z),
-                         RawScript::kKernelTag);
+    script = Script::New(H.DartString(uri, Heap::kOld),
+                         dart::String::ZoneHandle(Z), RawScript::kKernelTag);
     scripts_.SetAt(source_uri_index, script);
     intptr_t* line_starts =
         program_->line_starting_table().valuesFor(source_uri_index);
     intptr_t line_count = line_starts[0];
-    Array& array_object = Array::Handle(Z, Array::New(line_count));
+    Array& array_object = Array::Handle(Z, Array::New(line_count, Heap::kOld));
     Smi& value = Smi::Handle(Z);
     for (intptr_t i = 0; i < line_count; ++i) {
       value = Smi::New(line_starts[i + 1]);
       array_object.SetAt(i, value);
     }
     script.set_line_starts(array_object);
   }
   return script;
 }
 
@@ skipping 253 matching lines @@
   initializer_fun.set_is_debuggable(false);
   initializer_fun.set_is_reflectable(false);
   initializer_fun.set_is_inlinable(false);
   return new (zone) ParsedFunction(thread, initializer_fun);
 }
 
 
 }  // namespace kernel
 }  // namespace dart
 #endif  // !defined(DART_PRECOMPILED_RUNTIME)