Reapply "Initial implementation of on-stack replacement (OSR)."

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"
 #include "vm/dart_entry.h"
 #include "vm/debugger.h"
 #include "vm/deopt_instructions.h"
-#include "vm/disassembler.h"
 #include "vm/exceptions.h"
 #include "vm/flags.h"
 #include "vm/flow_graph.h"
 #include "vm/flow_graph_allocator.h"
 #include "vm/flow_graph_builder.h"
 #include "vm/flow_graph_compiler.h"
 #include "vm/flow_graph_inliner.h"
 #include "vm/flow_graph_optimizer.h"
 #include "vm/flow_graph_type_propagator.h"
 #include "vm/il_printer.h"
@@ skipping 208 matching lines @@
   function.SwitchToUnoptimizedCode();
   if (FLAG_trace_compiler) {
     OS::Print("--> restoring entry at %#"Px"\n",
               Code::Handle(function.unoptimized_code()).EntryPoint());
   }
 }
 
 
 // Return false if bailed out.
 static bool CompileParsedFunctionHelper(ParsedFunction* parsed_function,
-                                        bool optimized) {
+                                        bool optimized,
+                                        intptr_t osr_id) {
   const Function& function = parsed_function->function();
   if (optimized && !function.is_optimizable()) {
     return false;
   }
   TimerScope timer(FLAG_compiler_stats, &CompilerStats::codegen_timer);
   bool is_compiled = false;
   Isolate* isolate = Isolate::Current();
   HANDLESCOPE(isolate);
   const intptr_t prev_deopt_id = isolate->deopt_id();
   isolate->set_deopt_id(0);
@@ skipping 19 matching lines @@
             FLAG_deoptimization_counter_threshold) {
           const Code& unoptimized_code =
               Code::Handle(function.unoptimized_code());
           ic_data_array = unoptimized_code.ExtractTypeFeedbackArray();
         }
       }
 
       // Build the flow graph.
       FlowGraphBuilder builder(parsed_function,
                                ic_data_array,
-                               NULL);  // NULL = not inlining.
+                               NULL,  // NULL = not inlining.
+                               osr_id);
       flow_graph = builder.BuildGraph();
     }
 
     if (FLAG_print_flow_graph ||
         (optimized && FLAG_print_flow_graph_optimized)) {
-      FlowGraphPrinter::PrintGraph("Before Optimizations", flow_graph);
+      if (osr_id == Isolate::kNoDeoptId) {
+        FlowGraphPrinter::PrintGraph("Before Optimizations", flow_graph);
+      } else {
+        FlowGraphPrinter::PrintGraph("For OSR", flow_graph);
+      }
     }
 
     if (optimized) {
       TimerScope timer(FLAG_compiler_stats,
                        &CompilerStats::ssa_timer,
                        isolate);
       // Transform to SSA (virtual register 0 and no inlining arguments).
       flow_graph->ComputeSSA(0, NULL);
       DEBUG_ASSERT(flow_graph->VerifyUseLists());
       if (FLAG_print_flow_graph || FLAG_print_flow_graph_optimized) {
@@ skipping 200 matching lines @@
       code.set_is_optimized(optimized);
       graph_compiler.FinalizePcDescriptors(code);
       graph_compiler.FinalizeDeoptInfo(code);
       graph_compiler.FinalizeStackmaps(code);
       graph_compiler.FinalizeVarDescriptors(code);
       graph_compiler.FinalizeExceptionHandlers(code);
       graph_compiler.FinalizeComments(code);
       graph_compiler.FinalizeStaticCallTargetsTable(code);
 
       if (optimized) {
-        CodePatcher::PatchEntry(Code::Handle(function.CurrentCode()));
+        if (osr_id == Isolate::kNoDeoptId) {
+          CodePatcher::PatchEntry(Code::Handle(function.CurrentCode()));
+          if (FLAG_trace_compiler) {
+            OS::Print("--> patching entry %#"Px"\n",
+                      Code::Handle(function.unoptimized_code()).EntryPoint());
+          }
+        }
         function.SetCode(code);
-        if (FLAG_trace_compiler) {
-          OS::Print("--> patching entry %#"Px"\n",
-                    Code::Handle(function.unoptimized_code()).EntryPoint());
-        }
 
         for (intptr_t i = 0; i < guarded_fields.length(); i++) {
           const Field& field = *guarded_fields[i];
           field.RegisterDependentCode(code);
         }
       } else {
         function.set_unoptimized_code(code);
         function.SetCode(code);
         ASSERT(CodePatcher::CodeIsPatchable(code));
       }
@@ skipping 17 matching lines @@
   return is_compiled;
 }
 
 
 static void DisassembleCode(const Function& function, bool optimized) {
   const char* function_fullname = function.ToFullyQualifiedCString();
   OS::Print("Code for %sfunction '%s' {\n",
             optimized ? "optimized " : "",
             function_fullname);
   const Code& code = Code::Handle(function.CurrentCode());
-  const Instructions& instructions =
-      Instructions::Handle(code.instructions());
-  uword start = instructions.EntryPoint();
-  Disassembler::Disassemble(start,
-                            start + instructions.size(),
-                            code.comments());
+  code.Disassemble();
   OS::Print("}\n");
 
   OS::Print("Pointer offsets for function: {\n");
   // Pointer offsets are stored in descending order.
   for (intptr_t i = code.pointer_offsets_length() - 1; i >= 0; i--) {
     const uword addr = code.GetPointerOffsetAt(i) + code.EntryPoint();
     Object& obj = Object::Handle();
     obj = *reinterpret_cast<RawObject**>(addr);
     OS::Print(" %d : %#"Px" '%s'\n",
               code.GetPointerOffsetAt(i), addr, obj.ToCString());
   }
   OS::Print("}\n");
 
   OS::Print("PC Descriptors for function '%s' {\n", function_fullname);
   PcDescriptors::PrintHeaderString();
   const PcDescriptors& descriptors =
       PcDescriptors::Handle(code.pc_descriptors());
   OS::Print("%s}\n", descriptors.ToCString());
 
+  uword start = Instructions::Handle(code.instructions()).EntryPoint();
   const Array& deopt_table = Array::Handle(code.deopt_info_array());
   intptr_t deopt_table_length = DeoptTable::GetLength(deopt_table);
   if (deopt_table_length > 0) {
     OS::Print("DeoptInfo: {\n");
     Smi& offset = Smi::Handle();
     DeoptInfo& info = DeoptInfo::Handle();
     Smi& reason = Smi::Handle();
     for (intptr_t i = 0; i < deopt_table_length; ++i) {
       DeoptTable::GetEntry(deopt_table, i, &offset, &info, &reason);
       OS::Print("%4"Pd": 0x%"Px"  %s  (%s)\n",
@@ skipping 79 matching lines @@
           start + offset.Value(),
           function.ToFullyQualifiedCString(),
           code.raw());
     }
     OS::Print("}\n");
   }
 }
 
 
 static RawError* CompileFunctionHelper(const Function& function,
-                                       bool optimized) {
+                                       bool optimized,
+                                       intptr_t osr_id) {
   Isolate* isolate = Isolate::Current();
   StackZone zone(isolate);
   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);
     isolate->set_long_jump_base(base);
     return Error::null();
   }
   if (setjmp(*jump.Set()) == 0) {
     TIMERSCOPE(time_compilation);
     Timer per_compile_timer(FLAG_trace_compiler, "Compilation time");
     per_compile_timer.Start();
     ParsedFunction* parsed_function = new ParsedFunction(
         Function::ZoneHandle(function.raw()));
     if (FLAG_trace_compiler) {
-      OS::Print("Compiling %sfunction: '%s' @ token %"Pd", size %"Pd"\n",
+      OS::Print("Compiling %s%sfunction: '%s' @ token %"Pd", size %"Pd"\n",
+                (osr_id == Isolate::kNoDeoptId ? "" : "osr "),
                 (optimized ? "optimized " : ""),
                 function.ToFullyQualifiedCString(),
                 function.token_pos(),
                 (function.end_token_pos() - function.token_pos()));
     }
     {
       HANDLESCOPE(isolate);
       Parser::ParseFunction(parsed_function);
       parsed_function->AllocateVariables();
     }
 
     const bool success =
-        CompileParsedFunctionHelper(parsed_function, optimized);
+        CompileParsedFunctionHelper(parsed_function, optimized, osr_id);
     if (optimized && !success) {
       // Optimizer bailed out. Disable optimizations and to never try again.
       if (FLAG_trace_compiler) {
         OS::Print("--> disabling optimizations for '%s'\n",
                   function.ToFullyQualifiedCString());
       } else if (FLAG_trace_failed_optimization_attempts) {
         OS::Print("Cannot optimize: %s\n", function.ToFullyQualifiedCString());
       }
       function.set_is_optimizable(false);
       isolate->set_long_jump_base(base);
@@ skipping 31 matching lines @@
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return error.raw();
   }
   UNREACHABLE();
   return Error::null();
 }
 
 
 RawError* Compiler::CompileFunction(const Function& function) {
-  return CompileFunctionHelper(function, false);  // Non-optimized.
+  return CompileFunctionHelper(function, false, Isolate::kNoDeoptId);
 }
 
 
-RawError* Compiler::CompileOptimizedFunction(const Function& function) {
-  return CompileFunctionHelper(function, true);  // Optimized.
+RawError* Compiler::CompileOptimizedFunction(const Function& function,
+                                             intptr_t osr_id) {
+  return CompileFunctionHelper(function, true, osr_id);
 }
 
 
 RawError* Compiler::CompileParsedFunction(
     ParsedFunction* parsed_function) {
   Isolate* isolate = Isolate::Current();
   LongJump* base = isolate->long_jump_base();
   LongJump jump;
   isolate->set_long_jump_base(&jump);
   if (setjmp(*jump.Set()) == 0) {
     // Non-optimized code generator.
-    CompileParsedFunctionHelper(parsed_function, false);
+    CompileParsedFunctionHelper(parsed_function, false, Isolate::kNoDeoptId);
     if (FLAG_disassemble) {
       DisassembleCode(parsed_function->function(), false);
     }
     isolate->set_long_jump_base(base);
     return Error::null();
   } else {
     Error& error = Error::Handle();
     // We got an error during compilation.
     error = isolate->object_store()->sticky_error();
     isolate->object_store()->clear_sticky_error();
@@ skipping 66 matching lines @@
     // would compile func automatically. We are checking fewer invariants
     // here.
     ParsedFunction* parsed_function = new ParsedFunction(func);
     parsed_function->SetNodeSequence(fragment);
     parsed_function->set_default_parameter_values(Array::ZoneHandle());
     parsed_function->EnsureExpressionTemp();
     fragment->scope()->AddVariable(parsed_function->expression_temp_var());
     parsed_function->AllocateVariables();
 
     // Non-optimized code generator.
-    CompileParsedFunctionHelper(parsed_function, false);
+    CompileParsedFunctionHelper(parsed_function, false, Isolate::kNoDeoptId);
 
     const Object& result = Object::Handle(
         DartEntry::InvokeFunction(func, Object::empty_array()));
     isolate->set_long_jump_base(base);
     return result.raw();
   } else {
     const Object& result =
       Object::Handle(isolate->object_store()->sticky_error());
     isolate->object_store()->clear_sticky_error();
     isolate->set_long_jump_base(base);
     return result.raw();
   }
   UNREACHABLE();
   return Object::null();
 }
 
 }  // namespace dart