Simplify CodePatcher::GetStaticCallAt.

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 752 matching lines @@
 
 
 DEFINE_RUNTIME_ENTRY(ReThrow, 2) {
   ASSERT(arguments.ArgCount() == kReThrowRuntimeEntry.argument_count());
   const Instance& exception = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& stacktrace = Instance::CheckedHandle(arguments.ArgAt(1));
   Exceptions::ReThrow(exception, stacktrace);
 }
 
 
+// Patches static call with the target's entry point. Compiles target if
+// necessary.
 DEFINE_RUNTIME_ENTRY(PatchStaticCall, 0) {
-  // This function is called after successful resolving and compilation of
-  // the target method.
   ASSERT(arguments.ArgCount() == kPatchStaticCallRuntimeEntry.argument_count());
   DartFrameIterator iterator;
   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());
+  const Code& caller_code = Code::Handle(caller_frame->LookupDartCode());
+  ASSERT(!caller_code.IsNull());
+  const Function& target_function = Function::Handle(
+      caller_code.GetStaticCallTargetFunctionAt(caller_frame->pc()));
+  if (!target_function.HasCode()) {
+    const Error& error =
+        Error::Handle(Compiler::CompileFunction(target_function));
+    if (!error.IsNull()) {
+      Exceptions::PropagateError(error);
+    }
+  }
   const Code& target_code = Code::Handle(target_function.CurrentCode());
-  uword new_target = target_code.EntryPoint();
-  // Verify that we are not patching repeatedly.
-  ASSERT(target != new_target);
-  CodePatcher::PatchStaticCallAt(caller_frame->pc(), new_target);
-  const Code& code = Code::Handle(caller_frame->LookupDartCode());
-  code.SetStaticCallTargetCodeAt(caller_frame->pc(), target_code);
+  // Before patching verify that we are not repeatedly patching to the same
+  // target.
+  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(),
-        new_target);
+        target_code.EntryPoint());
   }
 }
 
 
 // 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;
@@ skipping 709 matching lines @@
     if (FLAG_trace_failed_optimization_attempts) {
       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 'new_entry_point'.
+// Patch static call to point to valid code's entry point.
 DEFINE_RUNTIME_ENTRY(FixCallersTarget, 1) {
   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 = 0;
-    Function& target_function = Function::Handle();
-    CodePatcher::GetStaticCallAt(frame->pc(), &target_function, &target);
-    ASSERT(target_function.HasCode());
-    ASSERT(target_function.raw() == function.raw());
+    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(),
-          target_function.ToFullyQualifiedCString(),
+          Function::Handle(target_code.function()).ToFullyQualifiedCString(),
           new_entry_point);
     }
   }
 }
 
 
 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)
@@ skipping 332 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