Add more safe points in compiler

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 1688 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());
     }
 
+    // We need to save the original code because the way we check for the
+    // success of the compiler pipeline is to see if it installed the new code.
+    // We also need the original because the pipeline installs the code even
+    // though it is OSR code and not usable for normal entry.
     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(
         Compiler::CompileOptimizedFunction(thread, function, osr_id));
     if (!error.IsNull()) {
       Exceptions::PropagateError(error);
     }
 
     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.
       uword optimized_entry =
           Instructions::UncheckedEntryPoint(optimized_code.instructions());
+      // Unfortunately, while we were compiling, the background compiler may

[Vyacheslav Egorov (Google), 2017/03/27 14:11:51]

The comment is inaccurate: it is background compiler that disables the
unoptimized code. see Function::InstallOptimizedCode - there is a hack there
that prevents disabling of the unoptimized code when we are installing for OSR.

[erikcorry, 2017/03/30 14:10:19]

I now made more serious changes to this section in
https://codereview.chromium.org/2781483005/ so it should be more solid.

+      // have completed a non-OSR compilation of the same code. Our call to the
+      // compiler overwrote the optimized version with an unusable OSR version,
+      // which doesn't have the right entry point.  If it did that it also
+      // disabled the old version, so we have to reenable it before we install
+      // it.  See https://github.com/dart-lang/sdk/issues/29160
+      original_code.Enable();
       function.AttachCode(original_code);
       frame->set_pc(optimized_entry);
       frame->set_pc_marker(optimized_code.raw());
     }
   }
 }
 
 
 DEFINE_RUNTIME_ENTRY(TraceICCall, 2) {
   const ICData& ic_data = ICData::CheckedHandle(arguments.ArgAt(0));
@@ skipping 523 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