deps: V8: cherry-pick ac0fe8ec from upstream

ofrobots · MylesBorins · commit 8f3b2d7e8a15 · 2018-01-09T04:32:31.000-05:00
Original commit message: [interpreter] Remove TryInstallOptimizedCode Removes the interrupt check and runtime call to TryInstallOptimizedCode from the optimization marker checks (i.e. CompileLazy and InterpreterEntryTrampoline). Instead, we rely on the other interrupt sources (in particular stack checks at function entries and loop headers) to install optimized code for us. This will hopefully not cause regressions, as we have plenty of other interrupt checks, but it may delay optimized code execution for some function by one function call. Bug: v8:6933 Change-Id: Ieadfff7ae2078d2a84085294158ad9a706eb9c64 Reviewed-on: https://chromium-review.googlesource.com/723475 Reviewed-by: Ross McIlroy <rmcilroy@chromium.org> Commit-Queue: Leszek Swirski <leszeks@chromium.org> Cr-Commit-Position: refs/heads/master@{#48667} Ref: https://bugs.chromium.org/p/v8/issues/detail?id=6933 Ref: v8/v8@ac0fe8e PR-URL: #17695 Reviewed-By: Michaël Zasso <targos@protonmail.com> Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl> Reviewed-By: James M Snell <jasnell@gmail.com>
diff --git a/common.gypi b/common.gypi
@@ -27,7 +27,7 @@
 
     # Reset this number to 0 on major V8 upgrades.
     # Increment by one for each non-official patch applied to deps/v8.
-    'v8_embedder_string': '-node.15',
+    'v8_embedder_string': '-node.16',
 
     # Enable disassembler for `--print-code` v8 options
     'v8_enable_disassembler': 1,
diff --git a/deps/v8/src/builtins/arm/builtins-arm.cc b/deps/v8/src/builtins/arm/builtins-arm.cc
@@ -1073,22 +1073,15 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
         Runtime::kCompileOptimized_Concurrent);
 
     {
-      // Otherwise, the marker is InOptimizationQueue.
+      // Otherwise, the marker is InOptimizationQueue, so fall through hoping
+      // that an interrupt will eventually update the slot with optimized code.
       if (FLAG_debug_code) {
         __ cmp(
             optimized_code_entry,
             Operand(Smi::FromEnum(OptimizationMarker::kInOptimizationQueue)));
         __ Assert(eq, kExpectedOptimizationSentinel);
       }
-      // Checking whether the queued function is ready for install is
-      // optional, since we come across interrupts and stack checks elsewhere.
-      // However, not checking may delay installing ready functions, and
-      // always checking would be quite expensive.  A good compromise is to
-      // first check against stack limit as a cue for an interrupt signal.
-      __ LoadRoot(scratch2, Heap::kStackLimitRootIndex);
-      __ cmp(sp, Operand(scratch2));
-      __ b(hs, &fallthrough);
-      GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);
+      __ jmp(&fallthrough);
     }
   }
 
diff --git a/deps/v8/src/builtins/arm64/builtins-arm64.cc b/deps/v8/src/builtins/arm64/builtins-arm64.cc
@@ -1084,22 +1084,15 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
         Runtime::kCompileOptimized_Concurrent);
 
     {
-      // Otherwise, the marker is InOptimizationQueue.
+      // Otherwise, the marker is InOptimizationQueue, so fall through hoping
+      // that an interrupt will eventually update the slot with optimized code.
       if (FLAG_debug_code) {
         __ Cmp(
             optimized_code_entry,
             Operand(Smi::FromEnum(OptimizationMarker::kInOptimizationQueue)));
         __ Assert(eq, kExpectedOptimizationSentinel);
       }
-
-      // Checking whether the queued function is ready for install is optional,
-      // since we come across interrupts and stack checks elsewhere.  However,
-      // not checking may delay installing ready functions, and always checking
-      // would be quite expensive.  A good compromise is to first check against
-      // stack limit as a cue for an interrupt signal.
-      __ CompareRoot(masm->StackPointer(), Heap::kStackLimitRootIndex);
-      __ B(hs, &fallthrough);
-      GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);
+      __ B(&fallthrough);
     }
   }
 
diff --git a/deps/v8/src/builtins/ia32/builtins-ia32.cc b/deps/v8/src/builtins/ia32/builtins-ia32.cc
@@ -715,24 +715,15 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
         Runtime::kCompileOptimized_Concurrent);
 
     {
-      // Otherwise, the marker is InOptimizationQueue.
+      // Otherwise, the marker is InOptimizationQueue, so fall through hoping
+      // that an interrupt will eventually update the slot with optimized code.
       if (FLAG_debug_code) {
         __ cmp(
             optimized_code_entry,
             Immediate(Smi::FromEnum(OptimizationMarker::kInOptimizationQueue)));
         __ Assert(equal, kExpectedOptimizationSentinel);
       }
-
-      // Checking whether the queued function is ready for install is optional,
-      // since we come across interrupts and stack checks elsewhere.  However,
-      // not checking may delay installing ready functions, and always checking
-      // would be quite expensive.  A good compromise is to first check against
-      // stack limit as a cue for an interrupt signal.
-      ExternalReference stack_limit =
-          ExternalReference::address_of_stack_limit(masm->isolate());
-      __ cmp(esp, Operand::StaticVariable(stack_limit));
-      __ j(above_equal, &fallthrough);
-      GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);
+      __ jmp(&fallthrough);
     }
   }
 
diff --git a/deps/v8/src/builtins/mips/builtins-mips.cc b/deps/v8/src/builtins/mips/builtins-mips.cc
@@ -1052,21 +1052,14 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
         Runtime::kCompileOptimized_Concurrent);
 
     {
-      // Otherwise, the marker is InOptimizationQueue.
+      // Otherwise, the marker is InOptimizationQueue, so fall through hoping
+      // that an interrupt will eventually update the slot with optimized code.
       if (FLAG_debug_code) {
         __ Assert(
             eq, kExpectedOptimizationSentinel, optimized_code_entry,
             Operand(Smi::FromEnum(OptimizationMarker::kInOptimizationQueue)));
       }
-
-      // Checking whether the queued function is ready for install is optional,
-      // since we come across interrupts and stack checks elsewhere. However,
-      // not checking may delay installing ready functions, and always checking
-      // would be quite expensive.  A good compromise is to first check against
-      // stack limit as a cue for an interrupt signal.
-      __ LoadRoot(at, Heap::kStackLimitRootIndex);
-      __ Branch(&fallthrough, hs, sp, Operand(at));
-      GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);
+      __ jmp(&fallthrough);
     }
   }
 
diff --git a/deps/v8/src/builtins/mips64/builtins-mips64.cc b/deps/v8/src/builtins/mips64/builtins-mips64.cc
@@ -1054,21 +1054,14 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
         Runtime::kCompileOptimized_Concurrent);
 
     {
-      // Otherwise, the marker is InOptimizationQueue.
+      // Otherwise, the marker is InOptimizationQueue, so fall through hoping
+      // that an interrupt will eventually update the slot with optimized code.
       if (FLAG_debug_code) {
         __ Assert(
             eq, kExpectedOptimizationSentinel, optimized_code_entry,
             Operand(Smi::FromEnum(OptimizationMarker::kInOptimizationQueue)));
       }
-
-      // Checking whether the queued function is ready for install is optional,
-      // since we come across interrupts and stack checks elsewhere. However,
-      // not checking may delay installing ready functions, and always checking
-      // would be quite expensive.  A good compromise is to first check against
-      // stack limit as a cue for an interrupt signal.
-      __ LoadRoot(t0, Heap::kStackLimitRootIndex);
-      __ Branch(&fallthrough, hs, sp, Operand(t0));
-      GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);
+      __ jmp(&fallthrough);
     }
   }
 
diff --git a/deps/v8/src/builtins/ppc/builtins-ppc.cc b/deps/v8/src/builtins/ppc/builtins-ppc.cc
@@ -1081,23 +1081,15 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
         Runtime::kCompileOptimized_Concurrent);
 
     {
-      // Otherwise, the marker is InOptimizationQueue.
+      // Otherwise, the marker is InOptimizationQueue, so fall through hoping
+      // that an interrupt will eventually update the slot with optimized code.
       if (FLAG_debug_code) {
         __ CmpSmiLiteral(
             optimized_code_entry,
             Smi::FromEnum(OptimizationMarker::kInOptimizationQueue), r0);
         __ Assert(eq, kExpectedOptimizationSentinel);
       }
-
-      // Checking whether the queued function is ready for install is optional,
-      // since we come across interrupts and stack checks elsewhere.  However,
-      // not checking may delay installing ready functions, and always checking
-      // would be quite expensive.  A good compromise is to first check against
-      // stack limit as a cue for an interrupt signal.
-      __ LoadRoot(ip, Heap::kStackLimitRootIndex);
-      __ cmpl(sp, ip);
-      __ bge(&fallthrough);
-      GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);
+      __ b(&fallthrough);
     }
   }
 
diff --git a/deps/v8/src/builtins/s390/builtins-s390.cc b/deps/v8/src/builtins/s390/builtins-s390.cc
@@ -1081,22 +1081,15 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
         Runtime::kCompileOptimized_Concurrent);
 
     {
-      // Otherwise, the marker is InOptimizationQueue.
+      // Otherwise, the marker is InOptimizationQueue, so fall through hoping
+      // that an interrupt will eventually update the slot with optimized code.
       if (FLAG_debug_code) {
         __ CmpSmiLiteral(
             optimized_code_entry,
             Smi::FromEnum(OptimizationMarker::kInOptimizationQueue), r0);
         __ Assert(eq, kExpectedOptimizationSentinel);
       }
-
-      // Checking whether the queued function is ready for install is optional,
-      // since we come across interrupts and stack checks elsewhere.  However,
-      // not checking may delay installing ready functions, and always checking
-      // would be quite expensive.  A good compromise is to first check against
-      // stack limit as a cue for an interrupt signal.
-      __ CmpLogicalP(sp, RootMemOperand(Heap::kStackLimitRootIndex));
-      __ bge(&fallthrough, Label::kNear);
-      GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);
+      __ b(&fallthrough, Label::kNear);
     }
   }
 
diff --git a/deps/v8/src/builtins/x64/builtins-x64.cc b/deps/v8/src/builtins/x64/builtins-x64.cc
@@ -798,21 +798,14 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,
         Runtime::kCompileOptimized_Concurrent);
 
     {
-      // Otherwise, the marker is InOptimizationQueue.
+      // Otherwise, the marker is InOptimizationQueue, so fall through hoping
+      // that an interrupt will eventually update the slot with optimized code.
       if (FLAG_debug_code) {
         __ SmiCompare(optimized_code_entry,
                       Smi::FromEnum(OptimizationMarker::kInOptimizationQueue));
         __ Assert(equal, kExpectedOptimizationSentinel);
       }
-
-      // Checking whether the queued function is ready for install is optional,
-      // since we come across interrupts and stack checks elsewhere.  However,
-      // not checking may delay installing ready functions, and always checking
-      // would be quite expensive.  A good compromise is to first check against
-      // stack limit as a cue for an interrupt signal.
-      __ CompareRoot(rsp, Heap::kStackLimitRootIndex);
-      __ j(above_equal, &fallthrough);
-      GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);
+      __ jmp(&fallthrough);
     }
   }
 
diff --git a/deps/v8/src/runtime/runtime-compiler.cc b/deps/v8/src/runtime/runtime-compiler.cc
@@ -340,27 +340,6 @@ RUNTIME_FUNCTION(Runtime_CompileForOnStackReplacement) {
   return NULL;
 }
 
-
-RUNTIME_FUNCTION(Runtime_TryInstallOptimizedCode) {
-  HandleScope scope(isolate);
-  DCHECK_EQ(1, args.length());
-  CONVERT_ARG_HANDLE_CHECKED(JSFunction, function, 0);
-
-  // First check if this is a real stack overflow.
-  StackLimitCheck check(isolate);
-  if (check.JsHasOverflowed(kStackSpaceRequiredForCompilation * KB)) {
-    return isolate->StackOverflow();
-  }
-
-  // Only try to install optimized functions if the interrupt was InstallCode.
-  if (isolate->stack_guard()->CheckAndClearInstallCode()) {
-    isolate->optimizing_compile_dispatcher()->InstallOptimizedFunctions();
-  }
-
-  return (function->IsOptimized()) ? function->code()
-                                   : function->shared()->code();
-}
-
 static Object* CompileGlobalEval(Isolate* isolate, Handle<String> source,
                                  Handle<SharedFunctionInfo> outer_info,
                                  LanguageMode language_mode,
diff --git a/deps/v8/src/runtime/runtime.h b/deps/v8/src/runtime/runtime.h
@@ -115,7 +115,6 @@ namespace internal {
   F(NotifyStubFailure, 0, 1)              \
   F(NotifyDeoptimized, 1, 1)              \
   F(CompileForOnStackReplacement, 1, 1)   \
-  F(TryInstallOptimizedCode, 1, 1)        \
   F(ResolvePossiblyDirectEval, 6, 1)      \
   F(InstantiateAsmJs, 4, 1)
 

Original file line number	Diff line number	Diff line change
`@@ -1073,22 +1073,15 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,`
`1073`	`1073`	`Runtime::kCompileOptimized_Concurrent);`
`1074`	`1074`
`1075`	`1075`	`{`
`1076`		`- // Otherwise, the marker is InOptimizationQueue.`
	`1076`	`+ // Otherwise, the marker is InOptimizationQueue, so fall through hoping`
	`1077`	`+ // that an interrupt will eventually update the slot with optimized code.`
`1077`	`1078`	`if (FLAG_debug_code) {`
`1078`	`1079`	`__ cmp(`
`1079`	`1080`	`optimized_code_entry,`
`1080`	`1081`	`Operand(Smi::FromEnum(OptimizationMarker::kInOptimizationQueue)));`
`1081`	`1082`	`__ Assert(eq, kExpectedOptimizationSentinel);`
`1082`	`1083`	`}`
`1083`		`- // Checking whether the queued function is ready for install is`
`1084`		`- // optional, since we come across interrupts and stack checks elsewhere.`
`1085`		`- // However, not checking may delay installing ready functions, and`
`1086`		`- // always checking would be quite expensive. A good compromise is to`
`1087`		`- // first check against stack limit as a cue for an interrupt signal.`
`1088`		`- __ LoadRoot(scratch2, Heap::kStackLimitRootIndex);`
`1089`		`- __ cmp(sp, Operand(scratch2));`
`1090`		`- __ b(hs, &fallthrough);`
`1091`		`- GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);`
	`1084`	`+ __ jmp(&fallthrough);`
`1092`	`1085`	`}`
`1093`	`1086`	`}`
`1094`	`1087`
Original file line number	Diff line number	Diff line change
`@@ -1084,22 +1084,15 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,`
`1084`	`1084`	`Runtime::kCompileOptimized_Concurrent);`
`1085`	`1085`
`1086`	`1086`	`{`
`1087`		`- // Otherwise, the marker is InOptimizationQueue.`
	`1087`	`+ // Otherwise, the marker is InOptimizationQueue, so fall through hoping`
	`1088`	`+ // that an interrupt will eventually update the slot with optimized code.`
`1088`	`1089`	`if (FLAG_debug_code) {`
`1089`	`1090`	`__ Cmp(`
`1090`	`1091`	`optimized_code_entry,`
`1091`	`1092`	`Operand(Smi::FromEnum(OptimizationMarker::kInOptimizationQueue)));`
`1092`	`1093`	`__ Assert(eq, kExpectedOptimizationSentinel);`
`1093`	`1094`	`}`
`1094`		`-`
`1095`		`- // Checking whether the queued function is ready for install is optional,`
`1096`		`- // since we come across interrupts and stack checks elsewhere. However,`
`1097`		`- // not checking may delay installing ready functions, and always checking`
`1098`		`- // would be quite expensive. A good compromise is to first check against`
`1099`		`- // stack limit as a cue for an interrupt signal.`
`1100`		`- __ CompareRoot(masm->StackPointer(), Heap::kStackLimitRootIndex);`
`1101`		`- __ B(hs, &fallthrough);`
`1102`		`- GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);`
	`1095`	`+ __ B(&fallthrough);`
`1103`	`1096`	`}`
`1104`	`1097`	`}`
`1105`	`1098`
Original file line number	Diff line number	Diff line change
`@@ -1052,21 +1052,14 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,`
`1052`	`1052`	`Runtime::kCompileOptimized_Concurrent);`
`1053`	`1053`
`1054`	`1054`	`{`
`1055`		`- // Otherwise, the marker is InOptimizationQueue.`
	`1055`	`+ // Otherwise, the marker is InOptimizationQueue, so fall through hoping`
	`1056`	`+ // that an interrupt will eventually update the slot with optimized code.`
`1056`	`1057`	`if (FLAG_debug_code) {`
`1057`	`1058`	`__ Assert(`
`1058`	`1059`	`eq, kExpectedOptimizationSentinel, optimized_code_entry,`
`1059`	`1060`	`Operand(Smi::FromEnum(OptimizationMarker::kInOptimizationQueue)));`
`1060`	`1061`	`}`
`1061`		`-`
`1062`		`- // Checking whether the queued function is ready for install is optional,`
`1063`		`- // since we come across interrupts and stack checks elsewhere. However,`
`1064`		`- // not checking may delay installing ready functions, and always checking`
`1065`		`- // would be quite expensive. A good compromise is to first check against`
`1066`		`- // stack limit as a cue for an interrupt signal.`
`1067`		`- __ LoadRoot(at, Heap::kStackLimitRootIndex);`
`1068`		`- __ Branch(&fallthrough, hs, sp, Operand(at));`
`1069`		`- GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);`
	`1062`	`+ __ jmp(&fallthrough);`
`1070`	`1063`	`}`
`1071`	`1064`	`}`
`1072`	`1065`
Original file line number	Diff line number	Diff line change
`@@ -1054,21 +1054,14 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,`
`1054`	`1054`	`Runtime::kCompileOptimized_Concurrent);`
`1055`	`1055`
`1056`	`1056`	`{`
`1057`		`- // Otherwise, the marker is InOptimizationQueue.`
	`1057`	`+ // Otherwise, the marker is InOptimizationQueue, so fall through hoping`
	`1058`	`+ // that an interrupt will eventually update the slot with optimized code.`
`1058`	`1059`	`if (FLAG_debug_code) {`
`1059`	`1060`	`__ Assert(`
`1060`	`1061`	`eq, kExpectedOptimizationSentinel, optimized_code_entry,`
`1061`	`1062`	`Operand(Smi::FromEnum(OptimizationMarker::kInOptimizationQueue)));`
`1062`	`1063`	`}`
`1063`		`-`
`1064`		`- // Checking whether the queued function is ready for install is optional,`
`1065`		`- // since we come across interrupts and stack checks elsewhere. However,`
`1066`		`- // not checking may delay installing ready functions, and always checking`
`1067`		`- // would be quite expensive. A good compromise is to first check against`
`1068`		`- // stack limit as a cue for an interrupt signal.`
`1069`		`- __ LoadRoot(t0, Heap::kStackLimitRootIndex);`
`1070`		`- __ Branch(&fallthrough, hs, sp, Operand(t0));`
`1071`		`- GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);`
	`1064`	`+ __ jmp(&fallthrough);`
`1072`	`1065`	`}`
`1073`	`1066`	`}`
`1074`	`1067`
Original file line number	Diff line number	Diff line change
`@@ -1081,22 +1081,15 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,`
`1081`	`1081`	`Runtime::kCompileOptimized_Concurrent);`
`1082`	`1082`
`1083`	`1083`	`{`
`1084`		`- // Otherwise, the marker is InOptimizationQueue.`
	`1084`	`+ // Otherwise, the marker is InOptimizationQueue, so fall through hoping`
	`1085`	`+ // that an interrupt will eventually update the slot with optimized code.`
`1085`	`1086`	`if (FLAG_debug_code) {`
`1086`	`1087`	`__ CmpSmiLiteral(`
`1087`	`1088`	`optimized_code_entry,`
`1088`	`1089`	`Smi::FromEnum(OptimizationMarker::kInOptimizationQueue), r0);`
`1089`	`1090`	`__ Assert(eq, kExpectedOptimizationSentinel);`
`1090`	`1091`	`}`
`1091`		`-`
`1092`		`- // Checking whether the queued function is ready for install is optional,`
`1093`		`- // since we come across interrupts and stack checks elsewhere. However,`
`1094`		`- // not checking may delay installing ready functions, and always checking`
`1095`		`- // would be quite expensive. A good compromise is to first check against`
`1096`		`- // stack limit as a cue for an interrupt signal.`
`1097`		`- __ CmpLogicalP(sp, RootMemOperand(Heap::kStackLimitRootIndex));`
`1098`		`- __ bge(&fallthrough, Label::kNear);`
`1099`		`- GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);`
	`1092`	`+ __ b(&fallthrough, Label::kNear);`
`1100`	`1093`	`}`
`1101`	`1094`	`}`
`1102`	`1095`
Original file line number	Diff line number	Diff line change
`@@ -798,21 +798,14 @@ static void MaybeTailCallOptimizedCodeSlot(MacroAssembler* masm,`
`798`	`798`	`Runtime::kCompileOptimized_Concurrent);`
`799`	`799`
`800`	`800`	`{`
`801`		`- // Otherwise, the marker is InOptimizationQueue.`
	`801`	`+ // Otherwise, the marker is InOptimizationQueue, so fall through hoping`
	`802`	`+ // that an interrupt will eventually update the slot with optimized code.`
`802`	`803`	`if (FLAG_debug_code) {`
`803`	`804`	`__ SmiCompare(optimized_code_entry,`
`804`	`805`	`Smi::FromEnum(OptimizationMarker::kInOptimizationQueue));`
`805`	`806`	`__ Assert(equal, kExpectedOptimizationSentinel);`
`806`	`807`	`}`
`807`		`-`
`808`		`- // Checking whether the queued function is ready for install is optional,`
`809`		`- // since we come across interrupts and stack checks elsewhere. However,`
`810`		`- // not checking may delay installing ready functions, and always checking`
`811`		`- // would be quite expensive. A good compromise is to first check against`
`812`		`- // stack limit as a cue for an interrupt signal.`
`813`		`- __ CompareRoot(rsp, Heap::kStackLimitRootIndex);`
`814`		`- __ j(above_equal, &fallthrough);`
`815`		`- GenerateTailCallToReturnedCode(masm, Runtime::kTryInstallOptimizedCode);`
	`808`	`+ __ jmp(&fallthrough);`
`816`	`809`	`}`
`817`	`810`	`}`
`818`	`811`