Add a stub_code_space in the heap alongside code_space so that stub code generation happens here an…

vm/object.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/object.h"
 
 #include "platform/assert.h"
 #include "vm/assembler.h"
 #include "vm/bigint_operations.h"
 #include "vm/bootstrap.h"
@@ skipping 5465 matching lines @@
       if (!error.IsNull()) {
         return error.raw();
       }
     }
     lib = lib.next_registered();
   }
   return error.raw();
 }
 
 
-RawInstructions* Instructions::New(intptr_t size) {
+RawInstructions* Instructions::New(intptr_t size, Heap::Space space) {
+  ASSERT(space == Heap::kDartCode || space == Heap::kStubCode);
   const Class& instructions_class = Class::Handle(Object::instructions_class());
   Instructions& result = Instructions::Handle();
   {
     uword aligned_size = Instructions::InstanceSize(size);
-    RawObject* raw = Object::Allocate(instructions_class,
-                                      aligned_size,
-                                      Heap::kExecutable);
+    RawObject* raw = Object::Allocate(instructions_class, aligned_size, space);
     NoGCScope no_gc;
     result ^= raw;
     result.set_size(size);
   }
   return result.raw();
 }
 
 
 const char* Instructions::ToCString() const {
   return "Instructions";
@@ skipping 400 matching lines @@
     RawObject* raw = Object::Allocate(cls, size, Heap::kOld);
     NoGCScope no_gc;
     result ^= raw;
     result.set_pointer_offsets_length(pointer_offsets_length);
     result.set_is_optimized(false);
   }
   return result.raw();
 }
 
 
-RawCode* Code::FinalizeCode(const char* name, Assembler* assembler) {
+RawCode* Code::FinalizeCode(const char* name,
+                            Assembler* assembler,
+                            Heap::Space space) {
   ASSERT(assembler != NULL);
 
   // Allocate the Instructions object.
   Instructions& instrs =
-      Instructions::ZoneHandle(Instructions::New(assembler->CodeSize()));
+      Instructions::ZoneHandle(Instructions::New(assembler->CodeSize(), space));
 
   // Copy the instructions into the instruction area and apply all fixups.
   // Embedded pointers are still in handles at this point.
   MemoryRegion region(reinterpret_cast<void*>(instrs.EntryPoint()),
                       instrs.size());
   assembler->FinalizeInstructions(region);
   DebugInfo* pprof_symbol_generator = Dart::pprof_symbol_generator();
   if (pprof_symbol_generator != NULL) {
     pprof_symbol_generator->AddCode(instrs.EntryPoint(), instrs.size());
     pprof_symbol_generator->AddCodeRegion(name,
@@ skipping 41 matching lines @@
     }
 
     // Hook up Code and Instruction objects.
     instrs.set_code(code.raw());
     code.set_instructions(instrs.raw());
   }
   return code.raw();
 }
 
 
+RawCode* Code::FinalizeCode(const char* name, Assembler* assembler) {
+  return FinalizeCode(name, assembler, Heap::kDartCode);
+}
+
+
+RawCode* Code::FinalizeStubCode(const char* name, Assembler* assembler) {
+  return FinalizeCode(name, assembler, Heap::kStubCode);
+}
+
+
 intptr_t Code::GetTokenIndexOfPC(uword pc) const {
   intptr_t token_index = -1;
   const PcDescriptors& descriptors = PcDescriptors::Handle(pc_descriptors());
   for (intptr_t i = 0; i < descriptors.Length(); i++) {
     if (descriptors.PC(i) == pc) {
       token_index = descriptors.TokenIndex(i);
       break;
     }
   }
   return token_index;
@@ skipping 3242 matching lines @@
   const String& str = String::Handle(pattern());
   const char* format = "JSRegExp: pattern=%s flags=%s";
   intptr_t len = OS::SNPrint(NULL, 0, format, str.ToCString(), Flags());
   char* chars = reinterpret_cast<char*>(
       Isolate::Current()->current_zone()->Allocate(len + 1));
   OS::SNPrint(chars, (len + 1), format, str.ToCString(), Flags());
   return chars;
 }
 
 }  // namespace dart