Remove the special stub code region as we don't need it anymore. With the new frame layout conventi…

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 5646 matching lines @@
       if (!error.IsNull()) {
         return error.raw();
       }
     }
     lib = lib.next_registered();
   }
   return error.raw();
 }
 
 
-RawInstructions* Instructions::New(intptr_t size, Heap::Space space) {
-  ASSERT(space == Heap::kDartCode || space == Heap::kStubCode);
+RawInstructions* Instructions::New(intptr_t size) {
   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, space);
+    RawObject* raw = Object::Allocate(instructions_class,
+                                      aligned_size,
+                                      Heap::kCode);
     NoGCScope no_gc;
     // TODO(iposva): Remove premarking once old and code spaces are merged.
     raw->SetMarkBit();
     result ^= raw;
     result.set_size(size);
   }
   return result.raw();
 }
 
 
@@ skipping 457 matching lines @@
     NoGCScope no_gc;
     result ^= raw;
     result.set_pointer_offsets_length(pointer_offsets_length);
     result.set_is_optimized(false);
     result.set_comments(Comments::New(0));
   }
   return result.raw();
 }
 
 
-RawCode* Code::FinalizeCode(const char* name,
-                            Assembler* assembler,
-                            Heap::Space space) {
+RawCode* Code::FinalizeCode(const char* name, Assembler* assembler) {
   ASSERT(assembler != NULL);
 
   // Allocate the Instructions object.
   Instructions& instrs =
-      Instructions::ZoneHandle(Instructions::New(assembler->CodeSize(), space));
+      Instructions::ZoneHandle(Instructions::New(assembler->CodeSize()));
 
   // 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) {
     ASSERT(strlen(name) != 0);
     pprof_symbol_generator->AddCode(instrs.EntryPoint(), instrs.size());
@@ skipping 46 matching lines @@
     instrs.set_code(code.raw());
     code.set_instructions(instrs.raw());
   }
   return code.raw();
 }
 
 
 RawCode* Code::FinalizeCode(const Function& function, Assembler* assembler) {
   // Calling ToFullyQualifiedCString is very expensive, try to avoid it.
   if (FLAG_generate_gdb_symbols || (Dart::pprof_symbol_generator() != NULL)) {
-    return FinalizeCode(function.ToFullyQualifiedCString(),
-                        assembler,
-                        Heap::kDartCode);
+    return FinalizeCode(function.ToFullyQualifiedCString(), assembler);
   } else {
-    return FinalizeCode("", assembler, Heap::kDartCode);
+    return FinalizeCode("", assembler);
   }
 }
 
 
-RawCode* Code::FinalizeStubCode(const char* name, Assembler* assembler) {
-  return FinalizeCode(name, assembler, Heap::kStubCode);
-}
-
-
 // Check if object matches find condition.
 bool Code::FindRawCodeVisitor::FindObject(RawObject* obj) {
   return RawInstructions::ContainsPC(obj, pc_);
 }
 
 
 RawCode* Code::LookupCode(uword pc) {
   Isolate* isolate = Isolate::Current();
   NoGCScope no_gc;
   FindRawCodeVisitor visitor(pc);
   RawInstructions* instr;
   instr = isolate->heap()->FindObjectInCodeSpace(&visitor);
   if (instr != Instructions::null()) {
     return instr->ptr()->code_;
   }
-  instr = isolate->heap()->FindObjectInStubCodeSpace(&visitor);
-  if (instr != Instructions::null()) {
-    return instr->ptr()->code_;
-  }
   return Code::null();
 }
 
 
 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);
@@ skipping 3731 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