Simplify representation of stack frames. Remove the special types DartFrame/StubFrame and instead u…

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 326 matching lines @@
       // 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());
     }
     DartFrameIterator iterator;
-    DartFrame* caller_frame = iterator.NextFrame();
+    StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);

[srdjan, 2012/04/24 23:19:41]

Should we add here and elsewhere an assert that caller_frame IsDartFrame?

[siva, 2012/04/25 01:14:20]

Done.

     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()) {
     DartFrameIterator iterator;
-    DartFrame* caller_frame = iterator.NextFrame();
+    StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
     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());
 
@@ skipping 73 matching lines @@
           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());
     }
     DartFrameIterator iterator;
-    DartFrame* caller_frame = iterator.NextFrame();
+    StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
     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()) {
     DartFrameIterator iterator;
-    DartFrame* caller_frame = iterator.NextFrame();
+    StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
     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)
@@ skipping 140 matching lines @@
   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());
   DartFrameIterator iterator;
-  DartFrame* caller_frame = iterator.NextFrame();
+  StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   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) {
   DartFrameIterator iterator;
-  DartFrame* caller_frame = iterator.NextFrame();
+  StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   int num_arguments = -1;
   int num_named_arguments = -1;
   uword target = 0;
   String& function_name = String::Handle();
   CodePatcher::GetInstanceCallAt(caller_frame->pc(),
                                  &function_name,
                                  &num_arguments,
                                  &num_named_arguments,
                                  &target);
@@ skipping 123 matching lines @@
     // 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();
   }
   DartFrameIterator iterator;
-  DartFrame* caller_frame = iterator.NextFrame();
+  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 446 matching lines @@
 // 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));
   DartFrameIterator iterator;
-  DartFrame* caller_frame = iterator.NextFrame();
+  StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   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());
@@ skipping 131 matching lines @@
       }
     }
   }
   // The cache is null terminated, therefore the loop above should never
   // terminate by itself.
   UNREACHABLE();
   return Code::null();
 }
 
 }  // namespace dart