Fix issue 2125: do not reparse a function being deoptimized.

runtime/vm/compiler.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/compiler.h"
 
 #include "vm/assembler.h"
 #include "vm/ast_printer.h"
 #include "vm/code_generator.h"
 #include "vm/code_patcher.h"
@@ skipping 90 matching lines @@
     Parser::ParseCompilationUnit(library, script);
   } else {
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
   }
   isolate->set_long_jump_base(base);
   return error.raw();
 }
 
 
+static void InstallUnoptimizedCode(const Function& function) {
+  // Disable optimized code.
+  ASSERT(function.HasOptimizedCode());
+  // Patch entry of optimized code.
+  CodePatcher::PatchEntry(Code::Handle(function.CurrentCode()));
+  if (FLAG_trace_compiler) {
+    OS::Print("--> patching entry 0x%x\n",
+              Code::Handle(function.CurrentCode()).EntryPoint());
+  }
+  // Use previously compiled code.
+  function.SetCode(Code::Handle(function.unoptimized_code()));
+  CodePatcher::RestoreEntry(Code::Handle(function.unoptimized_code()));
+  if (FLAG_trace_compiler) {
+    OS::Print("--> restoring entry at 0x%x\n",
+              Code::Handle(function.unoptimized_code()).EntryPoint());
+  }
+}
+
+
 static RawError* CompileFunctionHelper(const Function& function,
                                        bool optimized) {
   Isolate* isolate = Isolate::Current();
   Error& error = Error::Handle();
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
+  // Skips parsing if we need to only install unoptimized code.
+  if (!optimized && !Code::Handle(function.unoptimized_code()).IsNull()) {
+    InstallUnoptimizedCode(function);
+    return Error::null();
+  }
   if (setjmp(*jump.Set()) == 0) {
     TIMERSCOPE(time_compilation);
     ParsedFunction parsed_function(function);
     const char* function_fullname = function.ToFullyQualifiedCString();
     if (FLAG_trace_compiler) {
       OS::Print("Compiling %sfunction: '%s' @ token %d\n",
                 (optimized ? "optimized " : ""),
                 function_fullname,
                 function.token_index());
     }
     Parser::ParseFunction(&parsed_function);
     parsed_function.AllocateVariables();
 
     TimerScope timer(FLAG_compiler_stats, &CompilerStats::codegen_timer);
-
     bool is_compiled = false;
     if (FLAG_use_new_compiler) {
       ASSERT(!optimized);
       LongJump* old_base = isolate->long_jump_base();
       LongJump bailout_jump;
       isolate->set_long_jump_base(&bailout_jump);
       if (setjmp(*bailout_jump.Set()) == 0) {
         FlowGraphBuilder graph_builder(parsed_function);
         graph_builder.BuildGraph();
 
@@ skipping 54 matching lines @@
         code_gen.FinalizePcDescriptors(code);
         code_gen.FinalizeStackmaps(code);
         code_gen.FinalizeExceptionHandlers(code);
         function.SetCode(code);
         CodePatcher::PatchEntry(Code::Handle(function.unoptimized_code()));
         if (FLAG_trace_compiler) {
           OS::Print("--> patching entry 0x%x\n",
                     Code::Handle(function.unoptimized_code()).EntryPoint());
         }
       } else {
-        // Unoptimized code.
-        if (Code::Handle(function.unoptimized_code()).IsNull()) {
-          ASSERT(!function.HasCode());
-          // Compiling first time.
-          CodeGenerator code_gen(&assembler, parsed_function);
-          code_gen.GenerateCode();
-          const Code& code =
-              Code::Handle(Code::FinalizeCode(function_fullname, &assembler));
-          code.set_is_optimized(false);
-          code_gen.FinalizePcDescriptors(code);
-          code_gen.FinalizeStackmaps(code);
-          code_gen.FinalizeVarDescriptors(code);
-          code_gen.FinalizeExceptionHandlers(code);
-          function.set_unoptimized_code(code);
-          function.SetCode(code);
-          ASSERT(CodePatcher::CodeIsPatchable(code));
-        } else {
-          // Disable optimized code.
-          ASSERT(function.HasOptimizedCode());
-          // Patch entry of optimized code.
-          CodePatcher::PatchEntry(Code::Handle(function.CurrentCode()));
-          if (FLAG_trace_compiler) {
-            OS::Print("--> patching entry 0x%x\n",
-                      Code::Handle(function.CurrentCode()).EntryPoint());
-          }
-          // Use previously compiled code.
-          function.SetCode(Code::Handle(function.unoptimized_code()));
-          CodePatcher::RestoreEntry(Code::Handle(function.unoptimized_code()));
-          if (FLAG_trace_compiler) {
-            OS::Print("--> restoring entry at 0x%x\n",
-                      Code::Handle(function.unoptimized_code()).EntryPoint());
-          }
-        }
+        // Compile unnoptimized code.
+        ASSERT(!function.HasCode());
+        // Compiling first time.
+        CodeGenerator code_gen(&assembler, parsed_function);
+        code_gen.GenerateCode();
+        const Code& code =
+            Code::Handle(Code::FinalizeCode(function_fullname, &assembler));
+        code.set_is_optimized(false);
+        code_gen.FinalizePcDescriptors(code);
+        code_gen.FinalizeStackmaps(code);
+        code_gen.FinalizeVarDescriptors(code);
+        code_gen.FinalizeExceptionHandlers(code);
+        function.set_unoptimized_code(code);
+        function.SetCode(code);
+        ASSERT(CodePatcher::CodeIsPatchable(code));
       }
     }
     if (FLAG_trace_compiler) {
       OS::Print("--> '%s' entry: 0x%x\n",
                 function_fullname,
                 Code::Handle(function.CurrentCode()).EntryPoint());
     }
     if (Isolate::Current()->debugger()->IsActive()) {
       Isolate::Current()->debugger()->NotifyCompilation(function);
     }
@@ skipping 47 matching lines @@
     // We got an error during compilation.
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
   }
   isolate->set_long_jump_base(base);
   return error.raw();
 }
 
 
 RawError* Compiler::CompileFunction(const Function& function) {
-  return CompileFunctionHelper(function, false);
+  return CompileFunctionHelper(function, false);  // Non-optimized.
 }
 
 
 RawError* Compiler::CompileOptimizedFunction(const Function& function) {
-  return CompileFunctionHelper(function, true);
+  return CompileFunctionHelper(function, true);  // Optimized.
 }
 
 
 RawError* Compiler::CompileAllFunctions(const Class& cls) {
   Error& error = Error::Handle();
   Array& functions = Array::Handle(cls.functions());
   Function& func = Function::Handle();
   for (int i = 0; i < functions.Length(); i++) {
     func ^= functions.At(i);
     ASSERT(!func.IsNull());
@@ skipping 63 matching lines @@
   } else {
     result = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
   }
   isolate->set_long_jump_base(base);
   return result.raw();
 }
 
 
 }  // namespace dart