Remove loading of function object in static calls.

runtime/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/assembler_macros.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 783 matching lines @@
   ASSERT(target_code.EntryPoint() !=
          CodePatcher::GetStaticCallTargetAt(caller_frame->pc()));
   CodePatcher::PatchStaticCallAt(caller_frame->pc(), target_code.EntryPoint());
   caller_code.SetStaticCallTargetCodeAt(caller_frame->pc(), target_code);
   if (FLAG_trace_patching) {
     OS::Print("PatchStaticCall: patching from %#"Px" to '%s' %#"Px"\n",
         caller_frame->pc(),
         target_function.ToFullyQualifiedCString(),
         target_code.EntryPoint());
   }
+  arguments.SetReturn(target_code);
 }
 
 
 // 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;
@@ skipping 47 matching lines @@
   ASSERT(arguments.ArgCount() ==
          kResolveCompileInstanceFunctionRuntimeEntry.argument_count());
   const Instance& receiver = Instance::CheckedHandle(arguments.ArgAt(0));
   const Code& code = Code::Handle(
       ResolveCompileInstanceCallTarget(isolate, receiver));
   arguments.SetReturn(code);
 }
 
 
 // Gets called from debug stub when code reaches a breakpoint.
-//   Arg0: function object of the static function that was about to be called.
-DEFINE_RUNTIME_ENTRY(BreakpointStaticHandler, 1) {
+DEFINE_RUNTIME_ENTRY(BreakpointStaticHandler, 0) {
   ASSERT(arguments.ArgCount() ==
       kBreakpointStaticHandlerRuntimeEntry.argument_count());
   ASSERT(isolate->debugger() != NULL);
   isolate->debugger()->SignalBpReached();
   // Make sure the static function that is about to be called is
   // compiled. The stub will jump to the entry point without any
   // further tests.
-  const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
+  DartFrameIterator iterator;
+  StackFrame* caller_frame = iterator.NextFrame();
+  ASSERT(caller_frame != NULL);
+  const Code& code = Code::Handle(caller_frame->LookupDartCode());
+  const Function& function =
+      Function::Handle(code.GetStaticCallTargetFunctionAt(caller_frame->pc()));
+
   if (!function.HasCode()) {
     const Error& error = Error::Handle(Compiler::CompileFunction(function));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
   }
+  arguments.SetReturn(Code::ZoneHandle(function.CurrentCode()));
 }
 
 
 // Gets called from debug stub when code reaches a breakpoint at a return
 // in Dart code.
 DEFINE_RUNTIME_ENTRY(BreakpointReturnHandler, 0) {
   ASSERT(arguments.ArgCount() ==
          kBreakpointReturnHandlerRuntimeEntry.argument_count());
   ASSERT(isolate->debugger() != NULL);
   isolate->debugger()->SignalBpReached();
@@ skipping 626 matching lines @@
       PrintCaller("Not Optimizable");
     }
     // TODO(5442338): Abort as this should not happen.
     function.set_usage_counter(kLowInvocationCount);
   }
 }
 
 
 // The caller must be a static call in a Dart frame, or an entry frame.
 // Patch static call to point to valid code's entry point.
-DEFINE_RUNTIME_ENTRY(FixCallersTarget, 1) {
+DEFINE_RUNTIME_ENTRY(FixCallersTarget, 0) {
   ASSERT(arguments.ArgCount() ==
       kFixCallersTargetRuntimeEntry.argument_count());
-  const Function& function = Function::CheckedHandle(arguments.ArgAt(0));
-  ASSERT(!function.IsNull());
-  ASSERT(function.HasCode());
 
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = iterator.NextFrame();
   while (frame != NULL && (frame->IsStubFrame() || frame->IsExitFrame())) {
     frame = iterator.NextFrame();
   }
   ASSERT(frame != NULL);
-  if (!frame->IsEntryFrame()) {
-    ASSERT(frame->IsDartFrame());
-    uword target = CodePatcher::GetStaticCallTargetAt(frame->pc());
-    const Code& target_code = Code::Handle(function.CurrentCode());
-    const uword new_entry_point = target_code.EntryPoint();
-    ASSERT(target != new_entry_point);  // Why patch otherwise.
-    CodePatcher::PatchStaticCallAt(frame->pc(), new_entry_point);
-    const Code& code = Code::Handle(frame->LookupDartCode());
-    code.SetStaticCallTargetCodeAt(frame->pc(), target_code);
-    if (FLAG_trace_patching) {
-      OS::Print("FixCallersTarget: patching from %#"Px" to '%s' %#"Px"\n",
-          frame->pc(),
-          Function::Handle(target_code.function()).ToFullyQualifiedCString(),
-          new_entry_point);
-    }
+  if (frame->IsEntryFrame()) {
+    // Since function's current code is always unpatched, the entry frame always
+    // calls to unpatched code.
+    UNREACHABLE();
   }
+  ASSERT(frame->IsDartFrame());
+  const Code& caller_code = Code::Handle(frame->LookupDartCode());
+  const Function& target_function = Function::Handle(
+      caller_code.GetStaticCallTargetFunctionAt(frame->pc()));
+  const Code& target_code = Code::Handle(target_function.CurrentCode());
+  CodePatcher::PatchStaticCallAt(frame->pc(), target_code.EntryPoint());
+  caller_code.SetStaticCallTargetCodeAt(frame->pc(), target_code);
+  if (FLAG_trace_patching) {
+    OS::Print("FixCallersTarget: patching from %#"Px" to '%s' %#"Px"\n",
+        frame->pc(),
+        Function::Handle(target_code.function()).ToFullyQualifiedCString(),
+        target_code.EntryPoint());
+  }
+  arguments.SetReturn(target_code);
 }
 
 
 const char* DeoptReasonToText(intptr_t deopt_id) {
   switch (deopt_id) {
 #define DEOPT_REASON_ID_TO_TEXT(name) case kDeopt##name: return #name;
 DEOPT_REASONS(DEOPT_REASON_ID_TO_TEXT)
 #undef DEOPT_REASON_ID_TO_TEXT
     default:
       UNREACHABLE();
@@ skipping 329 matching lines @@
     intptr_t line, column;
     script.GetTokenLocation(token_pos, &line, &column);
     String& line_string = String::Handle(script.GetLine(line));
     OS::Print("  Function: %s\n", top_function.ToFullyQualifiedCString());
     OS::Print("  Line %"Pd": '%s'\n", line, line_string.ToCString());
   }
 }
 
 
 }  // namespace dart