Improve internal compiler API so that OSR code is never installed on function.

runtime/vm/code_generator.cc

 // Copyright (c) 2013, 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.h"
 #include "vm/ast.h"
 #include "vm/code_patcher.h"
 #include "vm/compiler.h"
@@ skipping 639 matching lines @@
 // Compiles target if necessary.
 DEFINE_RUNTIME_ENTRY(PatchStaticCall, 0) {
   DartFrameIterator iterator;
   StackFrame* caller_frame = iterator.NextFrame();
   ASSERT(caller_frame != NULL);
   const Code& caller_code = Code::Handle(zone, caller_frame->LookupDartCode());
   ASSERT(!caller_code.IsNull());
   ASSERT(caller_code.is_optimized());
   const Function& target_function = Function::Handle(
       zone, caller_code.GetStaticCallTargetFunctionAt(caller_frame->pc()));
-  if (!target_function.HasCode()) {
-    const Error& error =
-        Error::Handle(zone, Compiler::CompileFunction(thread, target_function));
-    if (!error.IsNull()) {
-      Exceptions::PropagateError(error);
-    }
-  }
-  const Code& target_code = Code::Handle(zone, target_function.CurrentCode());
+  const Code& target_code = Code::Handle(zone, target_function.EnsureHasCode());
   // Before patching verify that we are not repeatedly patching to the same
   // target.
   ASSERT(target_code.raw() !=
          CodePatcher::GetStaticCallTargetAt(caller_frame->pc(), caller_code));
   CodePatcher::PatchStaticCallAt(caller_frame->pc(), caller_code, target_code);
   caller_code.SetStaticCallTargetCodeAt(caller_frame->pc(), target_code);
   if (FLAG_trace_patching) {
     THR_Print("PatchStaticCall: patching caller pc %#" Px
               ""
               " to '%s' new entry point %#" Px " (%s)\n",
@@ skipping 255 matching lines @@
 // Handles a static call in unoptimized code that has one argument type not
 // seen before. Compile the target if necessary and update the ICData.
 // Arg0: argument.
 // Arg1: IC data object.
 DEFINE_RUNTIME_ENTRY(StaticCallMissHandlerOneArg, 2) {
   const Instance& arg = Instance::CheckedHandle(arguments.ArgAt(0));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(1));
   // IC data for static call is prepopulated with the statically known target.
   ASSERT(ic_data.NumberOfChecksIs(1));
   const Function& target = Function::Handle(ic_data.GetTargetAt(0));
-  if (!target.HasCode()) {
-    const Error& error =
-        Error::Handle(Compiler::CompileFunction(thread, target));
-    if (!error.IsNull()) {
-      Exceptions::PropagateError(error);
-    }
-  }
+  target.EnsureHasCode();
   ASSERT(!target.IsNull() && target.HasCode());
   ic_data.AddReceiverCheck(arg.GetClassId(), target, 1);
   if (FLAG_trace_ic) {
     DartFrameIterator iterator;
     StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
     OS::PrintErr("StaticCallMissHandler at %#" Px " target %s (%" Pd ")\n",
                  caller_frame->pc(), target.ToCString(), arg.GetClassId());
   }
   arguments.SetReturn(target);
 }
 
 
 // Handles a static call in unoptimized code that has two argument types not
 // seen before. Compile the target if necessary and update the ICData.
 // Arg0: argument 0.
 // Arg1: argument 1.
 // Arg2: IC data object.
 DEFINE_RUNTIME_ENTRY(StaticCallMissHandlerTwoArgs, 3) {
   const Instance& arg0 = Instance::CheckedHandle(arguments.ArgAt(0));
   const Instance& arg1 = Instance::CheckedHandle(arguments.ArgAt(1));
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(2));
   // IC data for static call is prepopulated with the statically known target.
   ASSERT(!ic_data.NumberOfChecksIs(0));
   const Function& target = Function::Handle(ic_data.GetTargetAt(0));
-  if (!target.HasCode()) {
-    const Error& error =
-        Error::Handle(Compiler::CompileFunction(thread, target));
-    if (!error.IsNull()) {
-      Exceptions::PropagateError(error);
-    }
-  }
-  ASSERT(!target.IsNull() && target.HasCode());
+  target.EnsureHasCode();
   GrowableArray<intptr_t> cids(2);
   cids.Add(arg0.GetClassId());
   cids.Add(arg1.GetClassId());
   ic_data.AddCheck(cids, target);
   if (FLAG_trace_ic) {
     DartFrameIterator iterator;
     StackFrame* caller_frame = iterator.NextFrame();
     ASSERT(caller_frame != NULL);
     OS::PrintErr("StaticCallMissHandler at %#" Px " target %s (%" Pd ", %" Pd
                  ")\n",
@@ skipping 321 matching lines @@
 
     if (number_of_checks == 0 && !target_function.HasOptionalParameters() &&
         !Isolate::Current()->compilation_allowed()) {
       // This call site is unlinked: transition to a monomorphic direct call.
       // Note we cannot do this if the target has optional parameters because
       // the monomorphic direct call does not load the arguments descriptor.
       // We cannot do this if we are still in the middle of precompiling because
       // the monomorphic case hides an live instance selector from the
       // treeshaker.
 
-      if (!target_function.HasCode()) {
-        const Error& error =
-            Error::Handle(Compiler::CompileFunction(thread, target_function));
-        if (!error.IsNull()) {
-          Exceptions::PropagateError(error);
-        }
-      }
+      const Code& target_code =
+          Code::Handle(zone, target_function.EnsureHasCode());
 
       DartFrameIterator iterator;
       StackFrame* miss_function_frame = iterator.NextFrame();
       ASSERT(miss_function_frame->IsDartFrame());
       StackFrame* caller_frame = iterator.NextFrame();
       ASSERT(caller_frame->IsDartFrame());
       const Code& caller_code =
           Code::Handle(zone, caller_frame->LookupDartCode());
-      const Code& target_code =
-          Code::Handle(zone, target_function.CurrentCode());
       const Smi& expected_cid =
           Smi::Handle(zone, Smi::New(receiver.GetClassId()));
 
       CodePatcher::PatchSwitchableCallAt(caller_frame->pc(), caller_code,
                                          expected_cid, target_code);
     } else {
       ic_data.AddReceiverCheck(receiver.GetClassId(), target_function);
       if (number_of_checks > FLAG_max_polymorphic_checks) {
         // Switch to megamorphic call.
         const MegamorphicCache& cache = MegamorphicCache::Handle(
@@ skipping 348 matching lines @@
     ASSERT(function.unoptimized_code() != Object::null());
     intptr_t osr_id =
         Code::Handle(function.unoptimized_code()).GetDeoptIdForOsr(frame->pc());
     ASSERT(osr_id != Compiler::kNoOSRDeoptId);
     if (FLAG_trace_osr) {
       OS::Print("Attempting OSR for %s at id=%" Pd ", count=%" Pd "\n",
                 function.ToFullyQualifiedCString(), osr_id,
                 function.usage_counter());
     }
 
-    const Code& original_code = Code::Handle(function.CurrentCode());
     // Since the code is referenced from the frame and the ZoneHandle,
     // it cannot have been removed from the function.
-    ASSERT(!original_code.IsNull());
-    const Error& error = Error::Handle(
+    const Object& result = Object::Handle(
         Compiler::CompileOptimizedFunction(thread, function, osr_id));
-    if (!error.IsNull()) {
-      Exceptions::PropagateError(error);
+    if (result.IsError()) {
+      Exceptions::PropagateError(Error::Cast(result));
     }
 
-    const Code& optimized_code = Code::Handle(function.CurrentCode());
-    // The current code will not be changed in the case that the compiler
-    // bailed out during OSR compilation.
-    if (optimized_code.raw() != original_code.raw()) {
-      // The OSR code does not work for calling the function, so restore the
-      // unoptimized code.  Patch the stack frame to return into the OSR
-      // code.
+    if (!result.IsNull()) {
+      const Code& code = Code::Cast(result);
       uword optimized_entry =
-          Instructions::UncheckedEntryPoint(optimized_code.instructions());
-      function.AttachCode(original_code);
+          Instructions::UncheckedEntryPoint(code.instructions());
       frame->set_pc(optimized_entry);
-      frame->set_pc_marker(optimized_code.raw());
+      frame->set_pc_marker(code.raw());
     }
   }
 }
 
 
 DEFINE_RUNTIME_ENTRY(TraceICCall, 2) {
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(0));
   const Function& function = Function::CheckedHandle(arguments.ArgAt(1));
   DartFrameIterator iterator;
   StackFrame* frame = iterator.NextFrame();
@@ skipping 52 matching lines @@
 
     // Reset usage counter for reoptimization before calling optimizer to
     // prevent recursive triggering of function optimization.
     function.set_usage_counter(0);
     if (FLAG_trace_compiler || FLAG_trace_optimizing_compiler) {
       if (function.HasOptimizedCode()) {
         THR_Print("ReCompiling function: '%s' \n",
                   function.ToFullyQualifiedCString());
       }
     }
-    const Error& error = Error::Handle(
+    const Object& result = Object::Handle(
         zone, Compiler::CompileOptimizedFunction(thread, function));
-    if (!error.IsNull()) {
-      Exceptions::PropagateError(error);
+    if (result.IsError()) {
+      Exceptions::PropagateError(Error::Cast(result));
     }
-    const Code& optimized_code = Code::Handle(zone, function.CurrentCode());
-    ASSERT(!optimized_code.IsNull());
   }
   arguments.SetReturn(function);
 #else
   UNREACHABLE();
 #endif  // !DART_PRECOMPILED_RUNTIME
 }
 
 
 // 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, 0) {
   StackFrameIterator iterator(StackFrameIterator::kDontValidateFrames);
   StackFrame* frame = iterator.NextFrame();
   ASSERT(frame != NULL);
   while (frame->IsStubFrame() || frame->IsExitFrame()) {
     frame = iterator.NextFrame();
     ASSERT(frame != NULL);
   }
   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(zone, frame->LookupDartCode());
   ASSERT(caller_code.is_optimized());
   const Function& target_function = Function::Handle(
       zone, caller_code.GetStaticCallTargetFunctionAt(frame->pc()));
-  if (!target_function.HasCode()) {
-    const Error& error =
-        Error::Handle(zone, Compiler::CompileFunction(thread, target_function));
-    if (!error.IsNull()) {
-      Exceptions::PropagateError(error);
-    }
-  }
-  ASSERT(target_function.HasCode());
 
   const Code& current_target_code =
-      Code::Handle(zone, target_function.CurrentCode());
+      Code::Handle(zone, target_function.EnsureHasCode());
   CodePatcher::PatchStaticCallAt(frame->pc(), caller_code, current_target_code);
   caller_code.SetStaticCallTargetCodeAt(frame->pc(), current_target_code);
   if (FLAG_trace_patching) {
     OS::PrintErr("FixCallersTarget: caller %#" Px
                  " "
                  "target '%s' -> %#" Px "\n",
                  frame->pc(), target_function.ToFullyQualifiedCString(),
                  current_target_code.UncheckedEntryPoint());
   }
   ASSERT(!current_target_code.IsDisabled());
@@ skipping 402 matching lines @@
   const intptr_t elm_size = old_data.ElementSizeInBytes();
   const TypedData& new_data =
       TypedData::Handle(TypedData::New(cid, new_size, Heap::kOld));
   TypedData::Copy(new_data, 0, old_data, 0, old_size * elm_size);
   typed_data_cell.SetAt(0, new_data);
   arguments.SetReturn(new_data);
 }
 
 
 }  // namespace dart