libv8 6.3.292.48.0beta1 → 6.3.292.48.0beta2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 61c3bf8a873f670cef6d2846cb09c8e6e8837160
-  data.tar.gz: 3ab377edad709714dfc61f7be3f37f3801ce1b3d
+  metadata.gz: c2c675f05ea4892e6a7f0bd9ec6de233cea27e28
+  data.tar.gz: d09ddbb4549efc47781b8baeab370ae209776377
 SHA512:
-  metadata.gz: 8645f9ffc99b2b8226880f664f088e76f49038138ed73984d546f88fb2a4bb07f659eb7540aa2694442cc6ea7327fbf39283c86d4c459ef44dd87bbecdc86fb6
-  data.tar.gz: 3fdcabaa1d2e7bebd1439a79a79fd0e52ffeebda196fd5b595895314e3128e0ae43a49b1fa17602ffdc1274db1df0eac5a4300f15a777aeaaafc122da70fdc6c
+  metadata.gz: f690ce0e6e410ea38ee9af90abe163a7a239fc079d0758af7d54aa15ff4e902f28d808a4ac299c02f8e25e8fc7de80904d0c8aa06c4e9a94d85bfff2985f33e8
+  data.tar.gz: eca47f78e0897e0c2212fcf5fa8acf392369ee1c7ba0fe724bf03fe72af72462bd7dd6f199c654c8bd64e868c5daf12afc368d1dc9d0c70cb1e7ef6dafdaa4e9

data/CHANGELOG.md

@@ -1,6 +1,7 @@
 ### Unreleased
 
 * Update upstream v8 version to 6.3.292.48
+* Add a fix for https://bugs.chromium.org/p/v8/issues/detail?id=6933
 
 ### v6.2.414.42.0, v6.2.414.42.1 - 2017-10-25
 

data/lib/libv8/version.rb

@@ -1,3 +1,3 @@
 module Libv8
-  VERSION = "6.3.292.48.0beta1"
+  VERSION = "6.3.292.48.0beta2"
 end

data/patches/0001-Build-a-standalone-static-library.patch

@@ -1,4 +1,4 @@
-From cbe264bb5c231d06f64b48413f3f268ca490e00a Mon Sep 17 00:00:00 2001
+From a018c0c78b9d40c9d9787fe969530e40fca5d38a Mon Sep 17 00:00:00 2001
 From: Petko Bordjukov <bordjukov@gmail.com>
 Date: Mon, 25 Jul 2016 00:00:19 +0300
 Subject: [PATCH 1/5] Build a standalone static library
@@ -22,5 +22,5 @@ index 63930d8aef..d0d00d3f67 100644
          'defines!': [
            'DEBUG',
 -- 
-2.14.3
+2.15.1
 

data/patches/0002-Don-t-compile-unnecessary-stuff.patch

@@ -1,4 +1,4 @@
-From 96075b7eeeef64063186d743d1fa36e6de494a6e Mon Sep 17 00:00:00 2001
+From 9ec36a77bb241ee4532553809b1ec7281ea998b1 Mon Sep 17 00:00:00 2001
 From: Petko Bordjukov <bordjukov@gmail.com>
 Date: Fri, 28 Jul 2017 11:11:08 +0300
 Subject: [PATCH 2/5] Don't compile unnecessary stuff
@@ -9,7 +9,7 @@ Subject: [PATCH 2/5] Don't compile unnecessary stuff
  2 files changed, 2 insertions(+), 40 deletions(-)
 
 diff --git a/Makefile b/Makefile
-index eb146ac244..902832af48 100644
+index 167ebf8c08..d9d0b9b306 100644
 --- a/Makefile
 +++ b/Makefile
 @@ -268,14 +268,9 @@ ANDROID_ARCHES = android_ia32 android_x64 android_arm android_arm64 \
@@ -81,5 +81,5 @@ index bc9d9650eb..96820a0ecc 100644
      }
    ]
 -- 
-2.14.3
+2.15.1
 

data/patches/0003-Use-the-fPIC-flag-for-the-static-library.patch

@@ -1,4 +1,4 @@
-From 97bb118756e30cea60216d3e74ba352d76001637 Mon Sep 17 00:00:00 2001
+From 68eadedb9728ee6ce634d646835ef0aab2d23be6 Mon Sep 17 00:00:00 2001
 From: Petko Bordjukov <bordjukov@gmail.com>
 Date: Mon, 25 Jul 2016 00:05:47 +0300
 Subject: [PATCH 3/5] Use the -fPIC flag for the static library
@@ -21,5 +21,5 @@ index d0d00d3f67..f01bd48596 100644
            }],
            [ 'clang==0 and coverage==1', {
 -- 
-2.14.3
+2.15.1
 

data/patches/0004-Do-not-embed-debug-symbols-in-macOS-libraries.patch

@@ -1,4 +1,4 @@
-From b06fb098489c375a4499fb6a62c92a32a0b282d8 Mon Sep 17 00:00:00 2001
+From 943282d83340d51a7749f59708e5dca5bbe96099 Mon Sep 17 00:00:00 2001
 From: Jb Aviat <jb@sqreen.io>
 Date: Mon, 27 Feb 2017 11:14:42 +0200
 Subject: [PATCH 4/5] Do not embed debug symbols in macOS libraries
@@ -21,5 +21,5 @@ index f01bd48596..25ca6b8606 100644
            'GCC_INLINES_ARE_PRIVATE_EXTERN': 'YES',
            'GCC_SYMBOLS_PRIVATE_EXTERN': 'YES',      # -fvisibility=hidden
 -- 
-2.14.3
+2.15.1
 

data/patches/0005-Remove-TryInstallOptimizedCode.patch

@@ -0,0 +1,321 @@
+From 723ed88782dbe9462aba5711a70be628d694bfda Mon Sep 17 00:00:00 2001
+From: Leszek Swirski <leszeks@chromium.org>
+Date: Tue, 17 Oct 2017 17:20:15 +0100
+Subject: [PATCH 5/5] 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}
+---
+ src/builtins/arm/builtins-arm.cc       | 13 +++----------
+ src/builtins/arm64/builtins-arm64.cc   | 13 +++----------
+ src/builtins/ia32/builtins-ia32.cc     | 15 +++------------
+ src/builtins/mips/builtins-mips.cc     | 13 +++----------
+ src/builtins/mips64/builtins-mips64.cc | 13 +++----------
+ src/builtins/ppc/builtins-ppc.cc       | 14 +++-----------
+ src/builtins/s390/builtins-s390.cc     | 13 +++----------
+ src/builtins/x64/builtins-x64.cc       | 13 +++----------
+ src/runtime/runtime-compiler.cc        | 21 ---------------------
+ src/runtime/runtime.h                  |  1 -
+ 10 files changed, 24 insertions(+), 105 deletions(-)
+
+diff --git a/src/builtins/arm/builtins-arm.cc b/src/builtins/arm/builtins-arm.cc
+index bf359d69e9..e8fa690660 100644
+--- a/src/builtins/arm/builtins-arm.cc
++++ b/src/builtins/arm/builtins-arm.cc
+@@ -782,22 +782,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/src/builtins/arm64/builtins-arm64.cc b/src/builtins/arm64/builtins-arm64.cc
+index b1d5d32b9a..7aaa2d0003 100644
+--- a/src/builtins/arm64/builtins-arm64.cc
++++ b/src/builtins/arm64/builtins-arm64.cc
+@@ -788,22 +788,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/src/builtins/ia32/builtins-ia32.cc b/src/builtins/ia32/builtins-ia32.cc
+index ee15025520..a689c3131d 100644
+--- a/src/builtins/ia32/builtins-ia32.cc
++++ b/src/builtins/ia32/builtins-ia32.cc
+@@ -698,24 +698,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/src/builtins/mips/builtins-mips.cc b/src/builtins/mips/builtins-mips.cc
+index e8f846c10a..4835fb0b1b 100644
+--- a/src/builtins/mips/builtins-mips.cc
++++ b/src/builtins/mips/builtins-mips.cc
+@@ -760,21 +760,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/src/builtins/mips64/builtins-mips64.cc b/src/builtins/mips64/builtins-mips64.cc
+index f62750b061..2584444f1f 100644
+--- a/src/builtins/mips64/builtins-mips64.cc
++++ b/src/builtins/mips64/builtins-mips64.cc
+@@ -760,21 +760,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/src/builtins/ppc/builtins-ppc.cc b/src/builtins/ppc/builtins-ppc.cc
+index 3ed3eb686d..c242be5cf8 100644
+--- a/src/builtins/ppc/builtins-ppc.cc
++++ b/src/builtins/ppc/builtins-ppc.cc
+@@ -780,23 +780,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/src/builtins/s390/builtins-s390.cc b/src/builtins/s390/builtins-s390.cc
+index e9ef390c69..aa9e62f217 100644
+--- a/src/builtins/s390/builtins-s390.cc
++++ b/src/builtins/s390/builtins-s390.cc
+@@ -783,22 +783,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/src/builtins/x64/builtins-x64.cc b/src/builtins/x64/builtins-x64.cc
+index 713475cd34..81c92681d5 100644
+--- a/src/builtins/x64/builtins-x64.cc
++++ b/src/builtins/x64/builtins-x64.cc
+@@ -781,21 +781,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/src/runtime/runtime-compiler.cc b/src/runtime/runtime-compiler.cc
+index 1cc00f5b7e..b445037d08 100644
+--- a/src/runtime/runtime-compiler.cc
++++ b/src/runtime/runtime-compiler.cc
+@@ -302,27 +302,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/src/runtime/runtime.h b/src/runtime/runtime.h
+index e7084a8cca..a11d274d25 100644
+--- a/src/runtime/runtime.h
++++ b/src/runtime/runtime.h
+@@ -120,7 +120,6 @@ namespace internal {
+   F(NotifyStubFailure, 0, 1)              \
+   F(NotifyDeoptimized, 0, 1)              \
+   F(CompileForOnStackReplacement, 1, 1)   \
+-  F(TryInstallOptimizedCode, 1, 1)        \
+   F(ResolvePossiblyDirectEval, 6, 1)      \
+   F(InstantiateAsmJs, 4, 1)
+ 
+-- 
+2.15.1
+

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: libv8
 version: !ruby/object:Gem::Version
-  version: 6.3.292.48.0beta1
+  version: 6.3.292.48.0beta2
 platform: ruby
 authors:
 - Charles Lowell
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-12-18 00:00:00.000000000 Z
+date: 2017-12-19 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rake
@@ -89,6 +89,7 @@ files:
 - patches/0002-Don-t-compile-unnecessary-stuff.patch
 - patches/0003-Use-the-fPIC-flag-for-the-static-library.patch
 - patches/0004-Do-not-embed-debug-symbols-in-macOS-libraries.patch
+- patches/0005-Remove-TryInstallOptimizedCode.patch
 - patches/mingw-generate-makefiles.sh
 - scaleway.png
 - spec/compiler/apple_llvm_spec.rb