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

vm/code_generator.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/code_generator.h"
 
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
 #include "vm/dart_api_impl.h"
 #include "vm/dart_entry.h"
@@ skipping 15 matching lines @@
 DEFINE_FLAG(bool, trace_patching, false, "Trace patching of code.");
 DEFINE_FLAG(bool, trace_runtime_calls, false, "Trace runtime calls.");
 DEFINE_FLAG(int, optimization_counter_threshold, 2000,
     "function's usage-counter value before it is optimized, -1 means never.");
 DECLARE_FLAG(bool, enable_type_checks);
 DECLARE_FLAG(bool, trace_type_checks);
 DECLARE_FLAG(bool, report_usage_count);
 DECLARE_FLAG(int, deoptimization_counter_threshold);
 
 
-static StackFrame* GetTopDartFrame(
-    StackFrameIterator* iterator, bool has_stub_frame) {
-  // When runtime calls are made from dart code we assume that we will
-  // always have an exit frame and an optional stub frame before we hit
-  // the first dart frame.
-  StackFrame* exit_frame = iterator->NextFrame();
-  ASSERT(exit_frame != NULL && exit_frame->IsExitFrame());
-  if (has_stub_frame) {
-    StackFrame* stub_frame = iterator->NextFrame();
-    ASSERT(stub_frame != NULL && stub_frame->IsStubFrame());
-  }
-  StackFrame* caller_frame = iterator->NextFrame();
-  ASSERT(caller_frame != NULL && caller_frame->IsDartFrame());
-  return caller_frame;
-}
-
-
 bool CodeGenerator::CanOptimize() {
   return
       !FLAG_report_usage_count &&
       (FLAG_optimization_counter_threshold >= 0) &&
       !Isolate::Current()->debugger()->IsActive();
 }
 
 
 const Array& CodeGenerator::ArgumentsDescriptor(
     int num_arguments,
@@ skipping 290 matching lines @@
     } else {
       // Instantiate type before printing.
       const AbstractType& instantiated_type =
           AbstractType::Handle(type.InstantiateFrom(type_instantiator));
       OS::Print("InstanceOf: '%s' %s '%s' instantiated from '%s'.\n",
                 String::Handle(instance_type.Name()).ToCString(),
                 (result.raw() == Bool::True()) ? "is" : "is !",
                 String::Handle(instantiated_type.Name()).ToCString(),
                 String::Handle(type.Name()).ToCString());
     }
-    StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
-    StackFrame* caller_frame = GetTopDartFrame(&iterator, false);
+    DartFrameIterator iterator;
+    StackFrame* caller_frame = iterator.NextFrame();
     const Function& function = Function::Handle(
         caller_frame->LookupDartFunction());
     OS::Print(" -> Function %s\n", function.ToFullyQualifiedCString());
   }
   if (!result.value() && !malformed_error.IsNull()) {
     // Throw a dynamic type error only if the instanceof test fails.
     String& malformed_error_message =  String::Handle(
         String::New(malformed_error.ToErrorCString()));
     const String& no_name = String::Handle(String::NewSymbol(""));
     Exceptions::CreateAndThrowTypeError(
         location, no_name, no_name, no_name, malformed_error_message);
     UNREACHABLE();
   }
   // Update cache: add class of instance and result.
   if (type.IsInstantiated() &&
       !Class::Handle(type.type_class()).HasTypeArguments()) {
-    StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
-    StackFrame* caller_frame = GetTopDartFrame(&iterator, false);
+    DartFrameIterator iterator;
+    StackFrame* caller_frame = iterator.NextFrame();
     const Code& code = Code::Handle(caller_frame->LookupDartCode());
     ASSERT(!code.IsNull());
     uword loc = code.GetTypeTestAtNodeId(node_id);
     // TODO(srdjan): Check when 'loc' can be 0, once implemented everywhere.
     if (loc != 0) {
       // Found type test cache.
       Array& value = Array::Handle(CodePatcher::GetTypeTestArray(loc));
       const Class& instance_class = Class::Handle(instance.clazz());
 
 #if defined(DEBUG)
@@ skipping 71 matching lines @@
       const AbstractType& instantiated_dst_type = AbstractType::Handle(
           dst_type.InstantiateFrom(dst_type_instantiator));
       OS::Print("TypeCheck: type '%s' %s a subtype of type '%s' of '%s' "
                 "instantiated from '%s'.\n",
                 String::Handle(src_type.Name()).ToCString(),
                 is_instance_of ? "is" : "is not",
                 String::Handle(instantiated_dst_type.Name()).ToCString(),
                 dst_name.ToCString(),
                 String::Handle(dst_type.Name()).ToCString());
     }
-    StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
-    StackFrame* caller_frame = GetTopDartFrame(&iterator, false);
+    DartFrameIterator iterator;
+    StackFrame* caller_frame = iterator.NextFrame();
     const Function& function = Function::Handle(
         caller_frame->LookupDartFunction());
     OS::Print(" -> Function %s\n", function.ToFullyQualifiedCString());
   }
   if (!is_instance_of) {
     String& src_type_name = String::Handle(GetSimpleTypeName(src_instance));
     String& dst_type_name = String::Handle();
     if (!dst_type.IsInstantiated()) {
       // Instantiate dst_type before reporting the error.
       const AbstractType& instantiated_dst_type = AbstractType::Handle(
           dst_type.InstantiateFrom(dst_type_instantiator));
       dst_type_name = instantiated_dst_type.Name();
     } else {
       dst_type_name = dst_type.Name();
     }
     String& malformed_error_message =  String::Handle();
     if (!malformed_error.IsNull()) {
       ASSERT(FLAG_enable_type_checks);
       malformed_error_message = String::New(malformed_error.ToErrorCString());
     }
     Exceptions::CreateAndThrowTypeError(location, src_type_name, dst_type_name,
                                         dst_name, malformed_error_message);
     UNREACHABLE();
   }
   // Update cache: add class of instance and result.
   if (dst_type.IsInstantiated() &&
       !Class::Handle(dst_type.type_class()).HasTypeArguments()) {
-    StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
-    StackFrame* caller_frame = GetTopDartFrame(&iterator, false);
+    DartFrameIterator iterator;
+    StackFrame* caller_frame = iterator.NextFrame();
     const Code& code = Code::Handle(caller_frame->LookupDartCode());
     ASSERT(!code.IsNull());
     uword loc = code.GetTypeTestAtNodeId(node_id);
     if (loc != 0) {
       // Found type test cache.
       Array& value = Array::Handle(CodePatcher::GetTypeTestArray(loc));
       const Class& src_instance_class = Class::Handle(src_instance.clazz());
 
 #if defined(DEBUG)
       // Check for duplicate entries.
@@ skipping 138 matching lines @@
   const Instance& exception = Instance::CheckedHandle(arguments.At(0));
   const Instance& stacktrace = Instance::CheckedHandle(arguments.At(1));
   Exceptions::ReThrow(exception, stacktrace);
 }
 
 
 DEFINE_RUNTIME_ENTRY(PatchStaticCall, 0) {
   // This function is called after successful resolving and compilation of
   // the target method.
   ASSERT(arguments.Count() == kPatchStaticCallRuntimeEntry.argument_count());
-  StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
-  StackFrame* caller_frame = GetTopDartFrame(&iterator, true);
+  DartFrameIterator iterator;
+  StackFrame* caller_frame = iterator.NextFrame();
   uword target = 0;
   Function& target_function = Function::Handle();
   CodePatcher::GetStaticCallAt(caller_frame->pc(), &target_function, &target);
   ASSERT(target_function.HasCode());
   uword new_target = Code::Handle(target_function.CurrentCode()).EntryPoint();
   // Verify that we are not patching repeatedly.
   ASSERT(target != new_target);
   CodePatcher::PatchStaticCallAt(caller_frame->pc(), new_target);
   if (FLAG_trace_patching) {
     OS::Print("PatchStaticCall: patching from 0x%x to '%s' 0x%x\n",
         caller_frame->pc(),
         target_function.ToFullyQualifiedCString(),
         new_target);
   }
 }
 
 
 // Resolves and compiles the target function of an instance call, updates
 // function cache of the receiver's class and returns the compiled code or null.
 // Only the number of named arguments is checked, but not the actual names.
 RawCode* ResolveCompileInstanceCallTarget(Isolate* isolate,
                                           const Instance& receiver) {
   int num_arguments = -1;
   int num_named_arguments = -1;
   uword target = 0;
   String& function_name = String::Handle();
-  StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
-  StackFrame* caller_frame = GetTopDartFrame(&iterator, true);
+  DartFrameIterator iterator;
+  StackFrame* caller_frame = iterator.NextFrame();
   CodePatcher::GetInstanceCallAt(caller_frame->pc(),
                                  &function_name,
                                  &num_arguments,
                                  &num_named_arguments,
                                  &target);
   ASSERT(function_name.IsSymbol());
   Class& receiver_class = Class::Handle();
   if (receiver.IsNull()) {
     // TODO(srdjan): Clarify behavior of null objects.
     receiver_class = isolate->object_store()->object_class();
@@ skipping 117 matching lines @@
     // Null dispatch is slow (e.g., (null).toCString()). The only
     // fast execution with null receiver is the "==" operator.
     // Special handling so that we do not pollute the inline cache with null
     // classes.
     if (FLAG_trace_ic) {
       OS::Print("InlineCacheMissHandler Null receiver target %s\n",
           target_function.ToCString());
     }
     return target_function.raw();
   }
-  StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
-  StackFrame* caller_frame = GetTopDartFrame(&iterator, true);
+  DartFrameIterator iterator;
+  StackFrame* caller_frame = iterator.NextFrame();
   ICData& ic_data = ICData::Handle(
       CodePatcher::GetInstanceCallIcDataAt(caller_frame->pc()));
 #if defined(DEBUG)
   for (intptr_t i = 0; i < ic_data.NumberOfChecks(); i++) {
     GrowableArray<const Class*> classes;
     Function& target = Function::Handle();
     ic_data.GetCheckAt(i, &classes, &target);
     bool matches = true;
     for (intptr_t k = 0; k < classes.length(); k++) {
       if (classes[k]->raw() != args[k]->clazz()) {
@@ skipping 413 matching lines @@
 // The caller must be a static call in a Dart frame, or an entry frame.
 // Patch static call to point to 'new_entry_point'.
 DEFINE_RUNTIME_ENTRY(FixCallersTarget, 1) {
   ASSERT(arguments.Count() == kFixCallersTargetRuntimeEntry.argument_count());
   const Function& function = Function::CheckedHandle(arguments.At(0));
   ASSERT(!function.IsNull());
   ASSERT(function.HasCode());
 
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = iterator.NextFrame();
-  while (frame != NULL && !frame->IsDartFrame() && !frame->IsEntryFrame()) {
+  while (frame != NULL && (frame->IsStubFrame() || frame->IsExitFrame())) {
     frame = iterator.NextFrame();
   }
   ASSERT(frame != NULL);
-  if (frame->IsDartFrame()) {
+  if (!frame->IsEntryFrame()) {
+    ASSERT(frame->IsDartFrame());
     uword target = 0;
     Function& target_function = Function::Handle();
     CodePatcher::GetStaticCallAt(frame->pc(), &target_function, &target);
     ASSERT(target_function.HasCode());
     const uword new_entry_point =
         Code::Handle(function.CurrentCode()).EntryPoint();
     ASSERT(target != new_entry_point);  // Why patch otherwise.
     CodePatcher::PatchStaticCallAt(frame->pc(), new_entry_point);
     if (FLAG_trace_patching) {
       OS::Print("FixCallersTarget: patching from 0x%x to '%s' 0x%x\n",
           frame->pc(),
           target_function.ToFullyQualifiedCString(),
           new_entry_point);
     }
   }
 }
 
 
 // The top Dart frame belongs to the optimized method that needs to be
 // deoptimized. The pc of the Dart frame points to the deoptimization point.
 // Find the node id of the deoptimization point and find the continuation
 // pc in the unoptimized code.
 // Since both unoptimized and optimized code have the same layout, we need only
 // to patch the pc of the Dart frame and to disable/enable appropriate code.
 DEFINE_RUNTIME_ENTRY(Deoptimize, 1) {
   ASSERT(arguments.Count() == kDeoptimizeRuntimeEntry.argument_count());
   const Smi& deoptimization_reason_id = Smi::CheckedHandle(arguments.At(0));
-  StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
-  StackFrame* caller_frame = GetTopDartFrame(&iterator, true);
+  DartFrameIterator iterator;
+  StackFrame* caller_frame = iterator.NextFrame();
   const Code& optimized_code = Code::Handle(caller_frame->LookupDartCode());
   const Function& function = Function::Handle(optimized_code.function());
   ASSERT(!function.IsNull());
   const Code& unoptimized_code = Code::Handle(function.unoptimized_code());
   ASSERT(!optimized_code.IsNull() && optimized_code.is_optimized());
   ASSERT(!unoptimized_code.IsNull() && !unoptimized_code.is_optimized());
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(optimized_code.pc_descriptors());
   ASSERT(!descriptors.IsNull());
   // Locate node id at deoptimization point inside optimized code.
@@ skipping 130 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart