Version 1.1.0-dev.5.7

runtime/vm/flow_graph_builder.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/flow_graph_builder.h"
 
 #include "lib/invocation_mirror.h"
 #include "vm/ast_printer.h"
 #include "vm/bit_vector.h"
 #include "vm/class_finalizer.h"
@@ skipping 949 matching lines @@
     Append(for_effect);
     if (!is_open()) {
       owner()->DeallocateTemps(owner()->temp_count());
       return;
     }
   }
 
   // Call to stub that checks whether the debugger is in single
   // step mode. This call must happen before the contexts are
   // unchained so that captured variables can be inspected.
-  AddInstruction(new DebugStepCheckInstr(node->token_pos()));
+  // No debugger check is done in native functions.
+  const Function& function = owner()->parsed_function()->function();
+  if (!function.is_native()) {
+    AddInstruction(new DebugStepCheckInstr(node->token_pos(),
+                                           PcDescriptors::kReturn));
+  }
 
   Value* return_value = for_value.value();
   if (FLAG_enable_type_checks) {
-    const Function& function = owner()->parsed_function()->function();
     const bool is_implicit_dynamic_getter =
         (!function.is_static() &&
         ((function.kind() == RawFunction::kImplicitGetter) ||
          (function.kind() == RawFunction::kImplicitStaticFinalGetter)));
     // Implicit getters do not need a type check at return, unless they compute
     // the initial value of a static field.
     // The body of a constructor cannot modify the type of the
     // constructed instance, which is passed in as an implicit parameter.
     // However, factories may create an instance of the wrong type.
     if (!is_implicit_dynamic_getter && !function.IsConstructor()) {
       const AbstractType& dst_type =
-          AbstractType::ZoneHandle(
-              owner()->parsed_function()->function().result_type());
+          AbstractType::ZoneHandle(function.result_type());
       return_value = BuildAssignableValue(node->value()->token_pos(),
                                           return_value,
                                           dst_type,
                                           Symbols::FunctionResult());
     }
   }
 
   intptr_t current_context_level = owner()->context_level();
   ASSERT(current_context_level >= 0);
   if (owner()->parsed_function()->saved_entry_context_var() != NULL) {
@@ skipping 2202 matching lines @@
 void ValueGraphVisitor::VisitLoadLocalNode(LoadLocalNode* node) {
   Definition* load = BuildLoadLocal(node->local());
   ReturnDefinition(load);
 }
 
 
 // <Expression> ::= StoreLocal { local: LocalVariable
 //                               value: <Expression> }
 void EffectGraphVisitor::HandleStoreLocal(StoreLocalNode* node,
                                           bool result_is_needed) {
+  // If the right hand side is an expression that does not contain
+  // a safe point for the debugger to stop, add an explicit stub
+  // call.
+  if (node->value()->IsLiteralNode() ||
+      node->value()->IsLoadLocalNode()) {
+    AddInstruction(new DebugStepCheckInstr(node->token_pos(),
+                                           PcDescriptors::kRuntimeCall));
+  }
+
   ValueGraphVisitor for_value(owner());
   node->value()->Visit(&for_value);
   Append(for_value);
   Value* store_value = for_value.value();
   if (FLAG_enable_type_checks) {
     store_value = BuildAssignableValue(node->value()->token_pos(),
                                        store_value,
                                        node->local().type(),
                                        node->local().name());
   }
@@ skipping 820 matching lines @@
                                   LanguageError::kError,
                                   Heap::kNew,
                                   "FlowGraphBuilder Bailout: %s %s",
                                   String::Handle(function.name()).ToCString(),
                                   reason));
   Isolate::Current()->long_jump_base()->Jump(1, error);
 }
 
 
 }  // namespace dart