[compiler] Make SFI "optimize" flag a "tier up" flag

src/objects.cc

 // Copyright 2015 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #include "src/objects.h"
 
 #include <cmath>
 #include <iomanip>
 #include <memory>
 #include <sstream>
@@ skipping 12180 matching lines @@
     }
   }
   return false;
 }
 
 void JSFunction::MarkForBaseline() {
   Isolate* isolate = GetIsolate();
   set_code_no_write_barrier(
       isolate->builtins()->builtin(Builtins::kCompileBaseline));
   // No write barrier required, since the builtin is part of the root set.
+  if (FLAG_tier_up_shared_functions) {
+    shared()->set_was_marked_for_tier_up(true);
+  }
 }
 
 void JSFunction::MarkForOptimization() {
   Isolate* isolate = GetIsolate();
   DCHECK(!IsOptimized());
   DCHECK(shared()->allows_lazy_compilation() ||
          !shared()->optimization_disabled());
   set_code_no_write_barrier(
       isolate->builtins()->builtin(Builtins::kCompileOptimized));
   // No write barrier required, since the builtin is part of the root set.
+  if (FLAG_tier_up_shared_functions) {
+    shared()->set_was_marked_for_tier_up(true);
+  }
 }
 
 
 void JSFunction::AttemptConcurrentOptimization() {
-  if (FLAG_optimize_shared_functions) {
-    // Mark the shared function for optimization regardless of whether the
-    // optimization is concurrent or not.
-    shared()->set_was_marked_for_optimization(true);
-  }
-
   Isolate* isolate = GetIsolate();
   if (!isolate->concurrent_recompilation_enabled() ||
       isolate->bootstrapper()->IsActive()) {
     MarkForOptimization();
     return;
   }
   DCHECK(!IsInOptimizationQueue());
   DCHECK(!IsOptimized());
   DCHECK(shared()->allows_lazy_compilation() ||
          !shared()->optimization_disabled());
   DCHECK(isolate->concurrent_recompilation_enabled());
   if (FLAG_trace_concurrent_recompilation) {
     PrintF("  ** Marking ");
     ShortPrint();
     PrintF(" for concurrent recompilation.\n");
   }
 
   set_code_no_write_barrier(
       isolate->builtins()->builtin(Builtins::kCompileOptimizedConcurrent));
   // No write barrier required, since the builtin is part of the root set.
+  if (FLAG_tier_up_shared_functions) {
+    shared()->set_was_marked_for_tier_up(true);

[rmcilroy, 2016/10/26 15:07:59]

Could you add the TODO here to mention this doesn't do the optimization
concurrently if we hit the SFI.

[Leszek Swirski, 2016/10/27 09:40:20]

Done.

+  }
 }
 
 // static
 Handle<LiteralsArray> SharedFunctionInfo::FindOrCreateLiterals(
     Handle<SharedFunctionInfo> shared, Handle<Context> native_context) {
   Isolate* isolate = shared->GetIsolate();
   CodeAndLiterals result =
       shared->SearchOptimizedCodeMap(*native_context, BailoutId::None());
   if (result.literals != nullptr) {
     DCHECK(shared->feedback_metadata()->is_empty() ||
@@ skipping 7971 matching lines @@
         ns, Accessors::ModuleNamespaceEntryInfo(isolate, name, attr))
         .Check();
   }
   JSObject::PreventExtensions(ns, THROW_ON_ERROR).ToChecked();
 
   return ns;
 }
 
 }  // namespace internal
 }  // namespace v8