A64: Synchronize with r16599.

src/compiler.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 349 matching lines @@
   // The encoding is as a signed value, with parameters and receiver using
   // the negative indices and locals the non-negative ones.
   const int parameter_limit = -LUnallocated::kMinFixedSlotIndex;
   Scope* scope = info()->scope();
   if ((scope->num_parameters() + 1) > parameter_limit) {
     info()->set_bailout_reason(kTooManyParameters);
     return AbortOptimization();
   }
 
   const int locals_limit = LUnallocated::kMaxFixedSlotIndex;
-  if (!info()->osr_ast_id().IsNone() &&
+  if (info()->is_osr() &&
       scope->num_parameters() + 1 + scope->num_stack_slots() > locals_limit) {
     info()->set_bailout_reason(kTooManyParametersLocals);
     return AbortOptimization();
   }
 
   // Take --hydrogen-filter into account.
   if (!info()->closure()->PassesFilter(FLAG_hydrogen_filter)) {
     info()->AbortOptimization();
     return SetLastStatus(BAILED_OUT);
   }
@@ skipping 505 matching lines @@
   }
   Compiler::RecordFunctionCompilation(Logger::LAZY_COMPILE_TAG, info, shared);
 }
 
 
 static void InsertCodeIntoOptimizedCodeMap(CompilationInfo* info) {
   Handle<Code> code = info->code();
   if (code->kind() != Code::OPTIMIZED_FUNCTION) return;  // Nothing to do.
 
   // Cache non-OSR optimized code.
-  if (FLAG_cache_optimized_code && info->osr_ast_id().IsNone()) {
+  if (FLAG_cache_optimized_code && !info->is_osr()) {
     Handle<JSFunction> function = info->closure();
     Handle<SharedFunctionInfo> shared(function->shared());
     Handle<FixedArray> literals(function->literals());
     Handle<Context> native_context(function->context()->native_context());
     SharedFunctionInfo::AddToOptimizedCodeMap(
         shared, native_context, code, literals);
   }
 }
 
 
 static bool InstallCodeFromOptimizedCodeMap(CompilationInfo* info) {
   if (!info->IsOptimizing()) return false;  // Nothing to look up.
 
   // Lookup non-OSR optimized code.
-  if (FLAG_cache_optimized_code && info->osr_ast_id().IsNone()) {
+  if (FLAG_cache_optimized_code && !info->is_osr()) {
     Handle<SharedFunctionInfo> shared = info->shared_info();
     Handle<JSFunction> function = info->closure();
     ASSERT(!function.is_null());
     Handle<Context> native_context(function->context()->native_context());
     int index = shared->SearchOptimizedCodeMap(*native_context);
     if (index > 0) {
       if (FLAG_trace_opt) {
         PrintF("[found optimized code for ");
         function->ShortPrint();
         PrintF("]\n");
@@ skipping 35 matching lines @@
 
     // Compile the code.
     if (!MakeCode(info)) {
       if (!isolate->has_pending_exception()) {
         isolate->StackOverflow();
       }
     } else {
       InstallCodeCommon(info);
 
       if (info->IsOptimizing()) {
+        // Optimized code successfully created.
         Handle<Code> code = info->code();
         ASSERT(shared->scope_info() != ScopeInfo::Empty(isolate));
+        // TODO(titzer): Only replace the code if it was not an OSR compile.
         info->closure()->ReplaceCode(*code);
         InsertCodeIntoOptimizedCodeMap(info);
         return true;
-      } else {
+      } else if (!info->is_osr()) {
+        // Compilation failed. Replace with full code if not OSR compile.
         return InstallFullCode(info);
       }
     }
   }
 
   ASSERT(info->code().is_null());
   return false;
 }
 
 
@@ skipping 168 matching lines @@
   // Check for optimized activations of this function.
   for (JavaScriptFrameIterator it(isolate); !it.done(); it.Advance()) {
     JavaScriptFrame* frame = it.frame();
     if (frame->is_optimized() && frame->function() == *function) return false;
   }
 
   return true;
 }
 
 
-BailoutId Compiler::CompileForOnStackReplacement(Handle<JSFunction> function) {
+Handle<Code> Compiler::CompileForOnStackReplacement(
+      Handle<JSFunction> function) {
   Isolate* isolate = function->GetIsolate();
-  // We have hit a back edge in an unoptimized frame for a function that was
-  // selected for on-stack replacement.  Find the unoptimized code object.
   Handle<Code> unoptimized(function->shared()->code(), isolate);
 
   Deoptimizer::RevertInterruptCode(isolate, *unoptimized);
   if (FLAG_trace_osr) {
     PrintF("[OSR - restored original interrupt calls in ");
     function->PrintName();
     PrintF("]\n");
   }
 
-  if (!IsSuitableForOnStackReplacement(isolate, function, unoptimized)) {
-    return BailoutId::None();
-  }
+  if (IsSuitableForOnStackReplacement(isolate, function, unoptimized)) {
+    // Find the PC offset in unoptimized code and translate to an AST id.
+    uint32_t pc_offset = CurrentPcOffset(isolate, function, unoptimized);
+    BailoutId ast_id = unoptimized->TranslatePcOffsetToAstId(pc_offset);
+    ASSERT(!ast_id.IsNone());
+    if (FLAG_trace_osr) {
+      PrintF("[OSR - replacing at AST id %d in ", ast_id.ToInt());
+      function->PrintName();
+      PrintF("]\n");
+    }
 
-  uint32_t pc_offset = CurrentPcOffset(isolate, function, unoptimized);
+    // Attempt OSR compilation.
+    Handle<Code> result = JSFunction::CompileOsr(
+        function, ast_id, CLEAR_EXCEPTION);
 
-  BailoutId ast_id = unoptimized->TranslatePcOffsetToAstId(pc_offset);
-  ASSERT(!ast_id.IsNone());
-  if (FLAG_trace_osr) {
-    PrintF("[OSR - replacing at AST id %d in ", ast_id.ToInt());
-    function->PrintName();
-    PrintF("]\n");
-  }
-
-  // Try to compile the optimized code.  A true return value from
-  // CompileOptimized means that compilation succeeded, not necessarily
-  // that optimization succeeded.
-  if (JSFunction::CompileOptimized(function, ast_id, CLEAR_EXCEPTION) &&
-      function->IsOptimized()) {
-    DeoptimizationInputData* data = DeoptimizationInputData::cast(
-        function->code()->deoptimization_data());
-    if (data->OsrPcOffset()->value() >= 0) {
+    if (!result.is_null() && result->kind() == Code::OPTIMIZED_FUNCTION) {
+      // OSR compilation succeeded.
+      DeoptimizationInputData* data =
+          DeoptimizationInputData::cast(result->deoptimization_data());
       if (FLAG_trace_osr) {
         PrintF("[OSR - entry, offset %d in optimized code]\n",
             data->OsrPcOffset()->value());
       }
       ASSERT(BailoutId(data->OsrAstId()->value()) == ast_id);
-      return ast_id;
-    }
-  } else {
-    if (FLAG_trace_osr) {
-      PrintF("[OSR - optimization failed for ");
-      function->PrintName();
-      PrintF("]\n");
+      return result;
     }
   }
-  return BailoutId::None();
+
+  if (FLAG_trace_osr) {
+    PrintF("[OSR - attempt failed for ");
+    function->PrintName();
+    PrintF("]\n");
+  }
+  return Handle<Code>::null();
 }
 
 
-BailoutId Compiler::CompileForConcurrentOSR(Handle<JSFunction> function) {
+Handle<Code> Compiler::CompileForConcurrentOSR(Handle<JSFunction> function) {
   Isolate* isolate = function->GetIsolate();
   Handle<Code> unoptimized(function->shared()->code(), isolate);
 
   uint32_t pc_offset = CurrentPcOffset(isolate, function, unoptimized);
 
   if (isolate->optimizing_compiler_thread()->
           IsQueuedForOSR(function, pc_offset)) {
     // Still waiting for the optimizing compiler thread to finish.  Carry on.
     if (FLAG_trace_osr) {
       PrintF("[COSR - polling recompile tasks for ");
       function->PrintName();
       PrintF("]\n");
     }
-    return BailoutId::None();
+    return Handle<Code>::null();
   }
 
   OptimizingCompiler* compiler = isolate->optimizing_compiler_thread()->
                                      FindReadyOSRCandidate(function, pc_offset);
 
   if (compiler != NULL) {
     if (FLAG_trace_osr) {
       PrintF("[COSR - optimization complete for ");
       function->PrintName();
       PrintF(", restoring interrupt calls]\n");
     }
     Deoptimizer::RevertInterruptCode(isolate, *unoptimized);
 
-    BailoutId ast_id = compiler->info()->osr_ast_id();
-
+    // TODO(titzer): don't install the OSR code into the function.
     bool succeeded = InstallOptimizedCode(compiler);
 
     isolate->optimizing_compiler_thread()->RemoveStaleOSRCandidates();
 
     if (!succeeded) {
       if (FLAG_trace_osr) {
         PrintF("[COSR - optimization failed for ");
         function->PrintName();
         PrintF("]\n");
       }
-      return BailoutId::None();
+      return Handle<Code>::null();
     }
+    Handle<Code> result = compiler->info()->code();
 
-    DeoptimizationInputData* data = DeoptimizationInputData::cast(
-        function->code()->deoptimization_data());
+    // Check the result matches our expectations, and don't use it otherwise.
+    if (result->kind() == Code::OPTIMIZED_FUNCTION) {
+      DeoptimizationInputData* data =
+          DeoptimizationInputData::cast(result->deoptimization_data());
 
-    if (data->OsrPcOffset()->value() >= 0) {
-      ASSERT(BailoutId(data->OsrAstId()->value()) == ast_id);
-      if (FLAG_trace_osr) {
-        PrintF("[COSR - entry at AST id %d, offset %d in optimized code]\n",
-               ast_id.ToInt(), data->OsrPcOffset()->value());
+      if (data->OsrPcOffset()->value() >= 0) {
+        BailoutId ast_id = compiler->info()->osr_ast_id();
+        ASSERT(BailoutId(data->OsrAstId()->value()) == ast_id);
+        if (FLAG_trace_osr) {
+          PrintF("[COSR - entry at AST id %d, offset %d in optimized code]\n",
+                 ast_id.ToInt(), data->OsrPcOffset()->value());
+        }
+        return result;
       }
-      return ast_id;
     }
-    return BailoutId::None();
+    return Handle<Code>::null();
   }
 
   if (!IsSuitableForOnStackReplacement(isolate, function, unoptimized)) {
     if (FLAG_trace_osr) {
       PrintF("[COSR - ");
       function->PrintName();
       PrintF(" is unsuitable, restoring interrupt calls]\n");
     }
     Deoptimizer::RevertInterruptCode(isolate, *unoptimized);
-    return BailoutId::None();
+    return Handle<Code>::null();
   }
 
   if (!RecompileConcurrent(function, pc_offset)) {
     Deoptimizer::RevertInterruptCode(isolate, *unoptimized);
   }
-  return BailoutId::None();
+  return Handle<Code>::null();
 }
 
 
 Handle<SharedFunctionInfo> Compiler::BuildFunctionInfo(FunctionLiteral* literal,
                                                        Handle<Script> script) {
   // Precondition: code has been parsed and scopes have been analyzed.
   CompilationInfoWithZone info(script);
   info.SetFunction(literal);
   info.SetScope(literal->scope());
   info.SetLanguageMode(literal->scope()->language_mode());
@@ skipping 152 matching lines @@
   AllowHandleDereference allow_deref;
   bool tracing_on = info()->IsStub()
       ? FLAG_trace_hydrogen_stubs
       : (FLAG_trace_hydrogen &&
          info()->closure()->PassesFilter(FLAG_trace_hydrogen_filter));
   return (tracing_on &&
       OS::StrChr(const_cast<char*>(FLAG_trace_phase), name_[0]) != NULL);
 }
 
 } }  // namespace v8::internal