rpms/qt5-qtwebengine
3
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
0d029998f5
qt5-qtwebengine/qtwebengine-opensource-src-5.8.0-no-sse2.patch

5312 lines
202 KiB
Diff
Raw Normal View History

Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/breakpad/src/build/common.gypi qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/breakpad/src/build/common.gypi
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/breakpad/src/build/common.gypi 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/breakpad/src/build/common.gypi 2017-03-05 17:26:14.507159420 +0100
no-sse2.patch: Fix/simplify disable_sse2 logic in breakpad/src/build/common.gypi That file is not really used in QtWebEngine anyway, but simply defaulting disable_sse2 to 1 is the right thing. The variable is ignored on everything other than ia32 (i686) anyway, even on x64 (x86_64). And setting conditional defaults might not work as expected in gyp.
2016-01-17 05:32:37 +00:00
@@ -80,8 +80,8 @@
# The system root for cross-compiles. Default: none.
'sysroot%': '',
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
no-sse2.patch: Fix/simplify disable_sse2 logic in breakpad/src/build/common.gypi That file is not really used in QtWebEngine anyway, but simply defaulting disable_sse2 to 1 is the right thing. The variable is ignored on everything other than ia32 (i686) anyway, even on x64 (x86_64). And setting conditional defaults might not work as expected in gyp.
2016-01-17 05:32:37 +00:00
- # On Linux, we build with sse2 for Chromium builds.
- 'disable_sse2%': 0,
+ # Do not assume SSE2 by default (Fedora patch).
+ 'disable_sse2%': 1
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
},
'target_arch%': '<(target_arch)',
no-sse2.patch: Fix/simplify disable_sse2 logic in breakpad/src/build/common.gypi That file is not really used in QtWebEngine anyway, but simply defaulting disable_sse2 to 1 is the right thing. The variable is ignored on everything other than ia32 (i686) anyway, even on x64 (x86_64). And setting conditional defaults might not work as expected in gyp.
2016-01-17 05:32:37 +00:00
@@ -725,17 +725,13 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
'conditions': [
['disable_sse2==0', {
'cflags': [
- '-march=pentium4',
'-msse2',
'-mfpmath=sse',
],
}],
],
- # -mmmx allows mmintrin.h to be used for mmx intrinsics.
- # video playback is mmx and sse2 optimized.
'cflags': [
'-m32',
- '-mmmx',
],
'ldflags': [
'-m32',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/build/common.gypi qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/build/common.gypi
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/build/common.gypi 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/build/common.gypi 2017-03-05 17:26:14.612157862 +0100
@@ -3861,15 +3861,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
# value used during computation does not change depending on
# how the compiler optimized the code, since the value is
# always kept in its specified precision.
- #
- # Refer to http://crbug.com/348761 for rationale behind SSE2
- # being a minimum requirement for 32-bit Linux builds and
- # http://crbug.com/313032 for an example where this has "bit"
- # us in the past.
'cflags': [
- '-msse2',
- '-mfpmath=sse',
- '-mmmx', # Allows mmintrin.h for MMX intrinsics.
'-m32',
],
'ldflags': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/cc/BUILD.gn qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/cc/BUILD.gn
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/cc/BUILD.gn 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/cc/BUILD.gn 2017-03-05 17:38:41.416050535 +0100
@@ -537,13 +537,6 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
"trees/tree_synchronizer.h",
]
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
- if (current_cpu == "x86" || current_cpu == "x64") {
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
- sources += [
- "raster/texture_compressor_etc1_sse.cc",
- "raster/texture_compressor_etc1_sse.h",
- ]
- }
-
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
configs += [ "//build/config:precompiled_headers" ]
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
public_deps = [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -553,6 +546,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
deps = [
"//base",
"//base/third_party/dynamic_annotations",
+ "//cc:cc_opts",
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
"//cc/proto",
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
"//cc/surfaces:surface_id",
"//gpu",
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -581,6 +575,36 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
}
}
+source_set("cc_opts") {
+ public_deps = [
+ "//cc:cc_opts_sse",
+ ]
+}
+
+source_set("cc_opts_sse") {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ if (current_cpu == "x86" || current_cpu == "x64") {
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ deps = [
+ "//base",
+ ]
+
+ defines = [ "CC_IMPLEMENTATION=1" ]
+
+ if (!is_debug && (is_win || is_android)) {
+ configs -= [ "//build/config/compiler:optimize" ]
+ configs += [ "//build/config/compiler:optimize_max" ]
+ }
+
+ sources = [
+ "raster/texture_compressor.h",
+ "raster/texture_compressor_etc1.h",
+ "raster/texture_compressor_etc1_sse.cc",
+ "raster/texture_compressor_etc1_sse.h",
+ ]
+
+ cflags = [ "-msse2" ]
+ }
+}
+
source_set("test_support") {
testonly = true
sources = [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/cc/cc.gyp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/cc/cc.gyp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/cc/cc.gyp 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/cc/cc.gyp 2017-03-05 17:26:26.081987615 +0100
@@ -602,14 +602,6 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
'includes': [
'../build/android/increase_size_for_speed.gypi',
],
- 'conditions': [
- ['target_arch == "ia32" or target_arch == "x64"', {
- 'sources': [
- 'raster/texture_compressor_etc1_sse.cc',
- 'raster/texture_compressor_etc1_sse.h',
- ],
- }],
- ],
},
{
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
# GN version: "//cc/proto"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -678,6 +670,7 @@
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
'<(DEPTH)/ui/events/events.gyp:events_base',
'<(DEPTH)/ui/gfx/gfx.gyp:gfx',
'<(DEPTH)/ui/gfx/gfx.gyp:gfx_geometry',
+ 'cc_opts',
],
'defines': [
'CC_SURFACES_IMPLEMENTATION=1',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -714,5 +707,41 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
'../build/android/increase_size_for_speed.gypi',
],
},
+ {
+ 'target_name': 'cc_opts',
+ 'type': 'static_library',
+ 'conditions': [
+ ['target_arch == "ia32" or target_arch == "x64"', {
+ 'defines': [
+ 'CC_IMPLEMENTATION=1',
+ ],
+ 'dependencies': [
+ 'cc_opts_sse',
+ ]
+ }],
+ ],
+ },
+ {
+ 'target_name': 'cc_opts_sse',
+ 'type': 'static_library',
+ 'dependencies': [
+ '<(DEPTH)/base/base.gyp:base',
+ ],
+ 'conditions': [
+ ['target_arch == "ia32" or target_arch == "x64"', {
+ 'defines': [
+ 'CC_IMPLEMENTATION=1',
+ ],
+ 'sources': [
+ # Conditional compilation for SSE2 code on x86 and x64 machines
+ 'raster/texture_compressor_etc1_sse.cc',
+ 'raster/texture_compressor_etc1_sse.h',
+ ],
+ 'cflags': [
+ '-msse2',
+ ],
+ }],
+ ],
+ },
],
}
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/BUILD.gn qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/BUILD.gn
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/BUILD.gn 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/BUILD.gn 2017-03-05 17:26:26.082987600 +0100
@@ -312,13 +312,13 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
}
if (current_cpu == "x86" || current_cpu == "x64") {
- sources += [
- "simd/convert_rgb_to_yuv_sse2.cc",
- "simd/convert_rgb_to_yuv_ssse3.cc",
- "simd/convert_yuv_to_rgb_x86.cc",
- "simd/filter_yuv_sse2.cc",
+ sources += [ "simd/convert_yuv_to_rgb_x86.cc" ]
+ deps += [
+ ":media_yasm",
+ ":media_mmx",
+ ":media_sse",
+ ":media_sse2",
]
- deps += [ ":media_yasm" ]
}
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
if (is_linux || is_win) {
@@ -534,10 +534,47 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
}
if (current_cpu == "x86" || current_cpu == "x64") {
+ source_set("media_mmx") {
+ sources = [ "simd/filter_yuv_mmx.cc" ]
+ configs += [ "//media:media_config" ]
+ if (!is_win) {
+ cflags = [ "-mmmx" ]
+ }
+ }
+
+ source_set("media_sse") {
+ sources = [
+ "simd/sinc_resampler_sse.cc",
+ ]
+ configs += [
+ "//media:media_config",
+ "//media:media_implementation",
+ ]
+ if (!is_win) {
+ cflags = [ "-msse" ]
+ }
+ }
+
+ source_set("media_sse2") {
+ sources = [
+ "simd/convert_rgb_to_yuv_sse2.cc",
+ "simd/convert_rgb_to_yuv_ssse3.cc",
+ "simd/filter_yuv_sse2.cc",
+ ]
+ configs += [
+ "//media:media_config",
+ "//media:media_implementation",
+ ]
+ if (!is_win) {
+ cflags = [ "-msse2" ]
+ }
+ }
+
import("//third_party/yasm/yasm_assemble.gni")
yasm_assemble("media_yasm") {
sources = [
"simd/convert_rgb_to_yuv_ssse3.asm",
+ "simd/convert_yuv_to_rgb_mmx.asm",
"simd/convert_yuv_to_rgb_sse.asm",
"simd/convert_yuva_to_argb_mmx.asm",
"simd/empty_register_state_mmx.asm",
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/media.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/media.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/media.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/media.cc 2017-03-05 17:44:02.063267153 +0100
@@ -10,6 +10,8 @@
#include "base/metrics/field_trial.h"
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#include "base/trace_event/trace_event.h"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
#include "media/base/media_switches.h"
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+#include "media/base/sinc_resampler.h"
+#include "media/base/vector_math.h"
#include "media/base/yuv_convert.h"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
#if defined(OS_ANDROID)
@@ -40,6 +42,8 @@
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
TRACE_EVENT_WARMUP_CATEGORY("media");
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
// Perform initialization of libraries which require runtime CPU detection.
+ vector_math::Initialize();
+ SincResampler::InitializeCPUSpecificFeatures();
InitializeCPUSpecificYUVConversions();
#if !defined(MEDIA_DISABLE_FFMPEG)
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb.h qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb.h
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb.h 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb.h 2017-03-05 17:26:26.083987585 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -65,6 +65,17 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
int rgbstride,
YUVType yuv_type);
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+MEDIA_EXPORT void ConvertYUVToRGB32_MMX(const uint8_t* yplane,
+ const uint8_t* uplane,
+ const uint8_t* vplane,
+ uint8_t* rgbframe,
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ int width,
+ int height,
+ int ystride,
+ int uvstride,
+ int rgbstride,
+ YUVType yuv_type);
+
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
MEDIA_EXPORT void ConvertYUVAToARGB_MMX(const uint8_t* yplane,
const uint8_t* uplane,
const uint8_t* vplane,
@@ -124,6 +135,13 @@
ptrdiff_t width,
const int16_t* convert_table);
+MEDIA_EXPORT void ConvertYUVToRGB32Row_MMX(const uint8_t* yplane,
+ const uint8_t* uplane,
+ const uint8_t* vplane,
+ uint8_t* rgbframe,
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ ptrdiff_t width,
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ const int16_t* convert_table);
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
MEDIA_EXPORT void ConvertYUVToRGB32Row_SSE(const uint8_t* yplane,
const uint8_t* uplane,
const uint8_t* vplane,
@@ -131,6 +149,14 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
ptrdiff_t width,
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
const int16_t* convert_table);
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+MEDIA_EXPORT void ScaleYUVToRGB32Row_MMX(const uint8_t* y_buf,
+ const uint8_t* u_buf,
+ const uint8_t* v_buf,
+ uint8_t* rgb_buf,
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ ptrdiff_t width,
+ ptrdiff_t source_dx,
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ const int16_t* convert_table);
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
MEDIA_EXPORT void ScaleYUVToRGB32Row_SSE(const uint8_t* y_buf,
const uint8_t* u_buf,
const uint8_t* v_buf,
@@ -147,6 +173,14 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
ptrdiff_t source_dx,
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
const int16_t* convert_table);
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+MEDIA_EXPORT void LinearScaleYUVToRGB32Row_MMX(const uint8_t* y_buf,
+ const uint8_t* u_buf,
+ const uint8_t* v_buf,
+ uint8_t* rgb_buf,
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ ptrdiff_t width,
+ ptrdiff_t source_dx,
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ const int16_t* convert_table);
+
MEDIA_EXPORT void LinearScaleYUVToRGB32Row_SSE(const uint8_t* y_buf,
const uint8_t* u_buf,
const uint8_t* v_buf,
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_mmx.asm qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_mmx.asm
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_mmx.asm 1970-01-01 01:00:00.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_mmx.asm 2017-03-05 17:26:26.167986340 +0100
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
@@ -0,0 +1,23 @@
+; Copyright (c) 2011 The Chromium 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 "third_party/x86inc/x86inc.asm"
+
+;
+; This file uses MMX instructions.
+;
+ SECTION_TEXT
+ CPU MMX
+
+; Use movq to save the output.
+%define MOVQ movq
+
+; extern "C" void ConvertYUVToRGB32Row_MMX(const uint8* y_buf,
+; const uint8* u_buf,
+; const uint8* v_buf,
+; uint8* rgb_buf,
+; ptrdiff_t width,
+; const int16* convert_table);
+%define SYMBOL ConvertYUVToRGB32Row_MMX
+%include "convert_yuv_to_rgb_mmx.inc"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_x86.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_x86.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_x86.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_x86.cc 2017-03-05 17:26:26.167986340 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -47,6 +47,34 @@
EmptyRegisterState();
}
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+void ConvertYUVToRGB32_MMX(const uint8_t* yplane,
+ const uint8_t* uplane,
+ const uint8_t* vplane,
+ uint8_t* rgbframe,
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ int width,
+ int height,
+ int ystride,
+ int uvstride,
+ int rgbstride,
+ YUVType yuv_type) {
+ unsigned int y_shift = GetVerticalShift(yuv_type);
+ for (int y = 0; y < height; ++y) {
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ uint8_t* rgb_row = rgbframe + y * rgbstride;
+ const uint8_t* y_ptr = yplane + y * ystride;
+ const uint8_t* u_ptr = uplane + (y >> y_shift) * uvstride;
+ const uint8_t* v_ptr = vplane + (y >> y_shift) * uvstride;
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+
+ ConvertYUVToRGB32Row_MMX(y_ptr,
+ u_ptr,
+ v_ptr,
+ rgb_row,
+ width,
+ GetLookupTable(yuv_type));
+ }
+
+ EmptyRegisterState();
+}
+
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
void ConvertYUVToRGB32_SSE(const uint8_t* yplane,
const uint8_t* uplane,
const uint8_t* vplane,
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/filter_yuv.h qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/filter_yuv.h
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/filter_yuv.h 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/filter_yuv.h 2017-03-05 17:26:26.167986340 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -20,6 +20,12 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
int source_width,
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
uint8_t source_y_fraction);
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+MEDIA_EXPORT void FilterYUVRows_MMX(uint8_t* ybuf,
+ const uint8_t* y0_ptr,
+ const uint8_t* y1_ptr,
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ int source_width,
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ uint8_t source_y_fraction);
+
MEDIA_EXPORT void FilterYUVRows_SSE2(uint8_t* ybuf,
const uint8_t* y0_ptr,
const uint8_t* y1_ptr,
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/filter_yuv_mmx.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/filter_yuv_mmx.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/filter_yuv_mmx.cc 1970-01-01 01:00:00.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/filter_yuv_mmx.cc 2017-03-05 17:26:26.167986340 +0100
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
@@ -0,0 +1,79 @@
+// Copyright (c) 2011 The Chromium Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+#if defined(_MSC_VER)
+#include <intrin.h>
+#else
+#include <mmintrin.h>
+#endif
+
+#include "build/build_config.h"
+#include "media/base/simd/filter_yuv.h"
+
+namespace media {
+
+#if defined(COMPILER_MSVC)
+// Warning 4799 is about calling emms before the function exits.
+// We calls emms in a frame level so suppress this warning.
+#pragma warning(push)
+#pragma warning(disable: 4799)
+#endif
+
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+void FilterYUVRows_MMX(uint8_t* dest,
+ const uint8_t* src0,
+ const uint8_t* src1,
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ int width,
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ uint8_t fraction) {
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ int pixel = 0;
+
+ // Process the unaligned bytes first.
+ int unaligned_width =
+ (8 - (reinterpret_cast<uintptr_t>(dest) & 7)) & 7;
+ while (pixel < width && pixel < unaligned_width) {
+ dest[pixel] = (src0[pixel] * (256 - fraction) +
+ src1[pixel] * fraction) >> 8;
+ ++pixel;
+ }
+
+ __m64 zero = _mm_setzero_si64();
+ __m64 src1_fraction = _mm_set1_pi16(fraction);
+ __m64 src0_fraction = _mm_set1_pi16(256 - fraction);
+ const __m64* src0_64 = reinterpret_cast<const __m64*>(src0 + pixel);
+ const __m64* src1_64 = reinterpret_cast<const __m64*>(src1 + pixel);
+ __m64* dest64 = reinterpret_cast<__m64*>(dest + pixel);
+ __m64* end64 = reinterpret_cast<__m64*>(
+ reinterpret_cast<uintptr_t>(dest + width) & ~7);
+
+ while (dest64 < end64) {
+ __m64 src0 = *src0_64++;
+ __m64 src1 = *src1_64++;
+ __m64 src2 = _mm_unpackhi_pi8(src0, zero);
+ __m64 src3 = _mm_unpackhi_pi8(src1, zero);
+ src0 = _mm_unpacklo_pi8(src0, zero);
+ src1 = _mm_unpacklo_pi8(src1, zero);
+ src0 = _mm_mullo_pi16(src0, src0_fraction);
+ src1 = _mm_mullo_pi16(src1, src1_fraction);
+ src2 = _mm_mullo_pi16(src2, src0_fraction);
+ src3 = _mm_mullo_pi16(src3, src1_fraction);
+ src0 = _mm_add_pi16(src0, src1);
+ src2 = _mm_add_pi16(src2, src3);
+ src0 = _mm_srli_pi16(src0, 8);
+ src2 = _mm_srli_pi16(src2, 8);
+ src0 = _mm_packs_pu16(src0, src2);
+ *dest64++ = src0;
+ pixel += 8;
+ }
+
+ while (pixel < width) {
+ dest[pixel] = (src0[pixel] * (256 - fraction) +
+ src1[pixel] * fraction) >> 8;
+ ++pixel;
+ }
+}
+
+#if defined(COMPILER_MSVC)
+#pragma warning(pop)
+#endif
+
+} // namespace media
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/sinc_resampler_sse.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/sinc_resampler_sse.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/sinc_resampler_sse.cc 1970-01-01 01:00:00.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/sinc_resampler_sse.cc 2017-03-05 17:26:26.168986325 +0100
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
@@ -0,0 +1,50 @@
+// Copyright 2013 The Chromium 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 "media/base/sinc_resampler.h"
+
+#include <xmmintrin.h>
+
+namespace media {
+
+float SincResampler::Convolve_SSE(const float* input_ptr, const float* k1,
+ const float* k2,
+ double kernel_interpolation_factor) {
+ __m128 m_input;
+ __m128 m_sums1 = _mm_setzero_ps();
+ __m128 m_sums2 = _mm_setzero_ps();
+
+ // Based on |input_ptr| alignment, we need to use loadu or load. Unrolling
+ // these loops hurt performance in local testing.
+ if (reinterpret_cast<uintptr_t>(input_ptr) & 0x0F) {
+ for (int i = 0; i < kKernelSize; i += 4) {
+ m_input = _mm_loadu_ps(input_ptr + i);
+ m_sums1 = _mm_add_ps(m_sums1, _mm_mul_ps(m_input, _mm_load_ps(k1 + i)));
+ m_sums2 = _mm_add_ps(m_sums2, _mm_mul_ps(m_input, _mm_load_ps(k2 + i)));
+ }
+ } else {
+ for (int i = 0; i < kKernelSize; i += 4) {
+ m_input = _mm_load_ps(input_ptr + i);
+ m_sums1 = _mm_add_ps(m_sums1, _mm_mul_ps(m_input, _mm_load_ps(k1 + i)));
+ m_sums2 = _mm_add_ps(m_sums2, _mm_mul_ps(m_input, _mm_load_ps(k2 + i)));
+ }
+ }
+
+ // Linearly interpolate the two "convolutions".
+ m_sums1 = _mm_mul_ps(m_sums1, _mm_set_ps1(
+ static_cast<float>(1.0 - kernel_interpolation_factor)));
+ m_sums2 = _mm_mul_ps(m_sums2, _mm_set_ps1(
+ static_cast<float>(kernel_interpolation_factor)));
+ m_sums1 = _mm_add_ps(m_sums1, m_sums2);
+
+ // Sum components together.
+ float result;
+ m_sums2 = _mm_add_ps(_mm_movehl_ps(m_sums1, m_sums1), m_sums1);
+ _mm_store_ss(&result, _mm_add_ss(m_sums2, _mm_shuffle_ps(
+ m_sums2, m_sums2, 1)));
+
+ return result;
+}
+
+} // namespace media
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/vector_math_sse.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/vector_math_sse.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/simd/vector_math_sse.cc 1970-01-01 01:00:00.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/simd/vector_math_sse.cc 2017-03-05 17:26:26.168986325 +0100
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
@@ -0,0 +1,118 @@
+// Copyright 2013 The Chromium 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 "media/base/vector_math_testing.h"
+
+#include <algorithm>
+
+#include <xmmintrin.h> // NOLINT
+
+namespace media {
+namespace vector_math {
+
+void FMUL_SSE(const float src[], float scale, int len, float dest[]) {
+ const int rem = len % 4;
+ const int last_index = len - rem;
+ __m128 m_scale = _mm_set_ps1(scale);
+ for (int i = 0; i < last_index; i += 4)
+ _mm_store_ps(dest + i, _mm_mul_ps(_mm_load_ps(src + i), m_scale));
+
+ // Handle any remaining values that wouldn't fit in an SSE pass.
+ for (int i = last_index; i < len; ++i)
+ dest[i] = src[i] * scale;
+}
+
+void FMAC_SSE(const float src[], float scale, int len, float dest[]) {
+ const int rem = len % 4;
+ const int last_index = len - rem;
+ __m128 m_scale = _mm_set_ps1(scale);
+ for (int i = 0; i < last_index; i += 4) {
+ _mm_store_ps(dest + i, _mm_add_ps(_mm_load_ps(dest + i),
+ _mm_mul_ps(_mm_load_ps(src + i), m_scale)));
+ }
+
+ // Handle any remaining values that wouldn't fit in an SSE pass.
+ for (int i = last_index; i < len; ++i)
+ dest[i] += src[i] * scale;
+}
+
+// Convenience macro to extract float 0 through 3 from the vector |a|. This is
+// needed because compilers other than clang don't support access via
+// operator[]().
+#define EXTRACT_FLOAT(a, i) \
+ (i == 0 ? \
+ _mm_cvtss_f32(a) : \
+ _mm_cvtss_f32(_mm_shuffle_ps(a, a, i)))
+
+std::pair<float, float> EWMAAndMaxPower_SSE(
+ float initial_value, const float src[], int len, float smoothing_factor) {
+ // When the recurrence is unrolled, we see that we can split it into 4
+ // separate lanes of evaluation:
+ //
+ // y[n] = a(S[n]^2) + (1-a)(y[n-1])
+ // = a(S[n]^2) + (1-a)^1(aS[n-1]^2) + (1-a)^2(aS[n-2]^2) + ...
+ // = z[n] + (1-a)^1(z[n-1]) + (1-a)^2(z[n-2]) + (1-a)^3(z[n-3])
+ //
+ // where z[n] = a(S[n]^2) + (1-a)^4(z[n-4]) + (1-a)^8(z[n-8]) + ...
+ //
+ // Thus, the strategy here is to compute z[n], z[n-1], z[n-2], and z[n-3] in
+ // each of the 4 lanes, and then combine them to give y[n].
+
+ const int rem = len % 4;
+ const int last_index = len - rem;
+
+ const __m128 smoothing_factor_x4 = _mm_set_ps1(smoothing_factor);
+ const float weight_prev = 1.0f - smoothing_factor;
+ const __m128 weight_prev_x4 = _mm_set_ps1(weight_prev);
+ const __m128 weight_prev_squared_x4 =
+ _mm_mul_ps(weight_prev_x4, weight_prev_x4);
+ const __m128 weight_prev_4th_x4 =
+ _mm_mul_ps(weight_prev_squared_x4, weight_prev_squared_x4);
+
+ // Compute z[n], z[n-1], z[n-2], and z[n-3] in parallel in lanes 3, 2, 1 and
+ // 0, respectively.
+ __m128 max_x4 = _mm_setzero_ps();
+ __m128 ewma_x4 = _mm_setr_ps(0.0f, 0.0f, 0.0f, initial_value);
+ int i;
+ for (i = 0; i < last_index; i += 4) {
+ ewma_x4 = _mm_mul_ps(ewma_x4, weight_prev_4th_x4);
+ const __m128 sample_x4 = _mm_load_ps(src + i);
+ const __m128 sample_squared_x4 = _mm_mul_ps(sample_x4, sample_x4);
+ max_x4 = _mm_max_ps(max_x4, sample_squared_x4);
+ // Note: The compiler optimizes this to a single multiply-and-accumulate
+ // instruction:
+ ewma_x4 = _mm_add_ps(ewma_x4,
+ _mm_mul_ps(sample_squared_x4, smoothing_factor_x4));
+ }
+
+ // y[n] = z[n] + (1-a)^1(z[n-1]) + (1-a)^2(z[n-2]) + (1-a)^3(z[n-3])
+ float ewma = EXTRACT_FLOAT(ewma_x4, 3);
+ ewma_x4 = _mm_mul_ps(ewma_x4, weight_prev_x4);
+ ewma += EXTRACT_FLOAT(ewma_x4, 2);
+ ewma_x4 = _mm_mul_ps(ewma_x4, weight_prev_x4);
+ ewma += EXTRACT_FLOAT(ewma_x4, 1);
+ ewma_x4 = _mm_mul_ss(ewma_x4, weight_prev_x4);
+ ewma += EXTRACT_FLOAT(ewma_x4, 0);
+
+ // Fold the maximums together to get the overall maximum.
+ max_x4 = _mm_max_ps(max_x4,
+ _mm_shuffle_ps(max_x4, max_x4, _MM_SHUFFLE(3, 3, 1, 1)));
+ max_x4 = _mm_max_ss(max_x4, _mm_shuffle_ps(max_x4, max_x4, 2));
+
+ std::pair<float, float> result(ewma, EXTRACT_FLOAT(max_x4, 0));
+
+ // Handle remaining values at the end of |src|.
+ for (; i < len; ++i) {
+ result.first *= weight_prev;
+ const float sample = src[i];
+ const float sample_squared = sample * sample;
+ result.first += sample_squared * smoothing_factor;
+ result.second = std::max(result.second, sample_squared);
+ }
+
+ return result;
+}
+
+} // namespace vector_math
+} // namespace media
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/sinc_resampler.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/sinc_resampler.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/sinc_resampler.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/sinc_resampler.cc 2017-03-05 17:26:26.168986325 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -81,17 +81,12 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#include <cmath>
#include <limits>
+#include "base/cpu.h"
#include "base/logging.h"
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#include "build/build_config.h"
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
-#if defined(ARCH_CPU_X86_FAMILY)
-#include <xmmintrin.h>
-#define CONVOLVE_FUNC Convolve_SSE
-#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
+#if defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
#include <arm_neon.h>
-#define CONVOLVE_FUNC Convolve_NEON
-#else
-#define CONVOLVE_FUNC Convolve_C
#endif
namespace media {
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -112,10 +107,41 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
return sinc_scale_factor;
}
+#undef CONVOLVE_FUNC
+
static int CalculateChunkSize(int block_size_, double io_ratio) {
return block_size_ / io_ratio;
}
+// If we know the minimum architecture at compile time, avoid CPU detection.
+// Force NaCl code to use C routines since (at present) nothing there uses these
+// methods and plumbing the -msse built library is non-trivial.
+#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_NACL)
+#if defined(__SSE__)
+#define CONVOLVE_FUNC Convolve_SSE
+void SincResampler::InitializeCPUSpecificFeatures() {}
+#else
+// X86 CPU detection required. Functions will be set by
+// InitializeCPUSpecificFeatures().
+#define CONVOLVE_FUNC g_convolve_proc_
+
+typedef float (*ConvolveProc)(const float*, const float*, const float*, double);
+static ConvolveProc g_convolve_proc_ = NULL;
+
+void SincResampler::InitializeCPUSpecificFeatures() {
+ CHECK(!g_convolve_proc_);
+ g_convolve_proc_ = base::CPU().has_sse() ? Convolve_SSE : Convolve_C;
+}
+#endif
+#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
+#define CONVOLVE_FUNC Convolve_NEON
+void SincResampler::InitializeCPUSpecificFeatures() {}
+#else
+// Unknown architecture.
+#define CONVOLVE_FUNC Convolve_C
+void SincResampler::InitializeCPUSpecificFeatures() {}
+#endif
+
SincResampler::SincResampler(double io_sample_rate_ratio,
int request_frames,
const ReadCB& read_cb)
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -343,46 +369,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
kernel_interpolation_factor * sum2);
}
-#if defined(ARCH_CPU_X86_FAMILY)
-float SincResampler::Convolve_SSE(const float* input_ptr, const float* k1,
- const float* k2,
- double kernel_interpolation_factor) {
- __m128 m_input;
- __m128 m_sums1 = _mm_setzero_ps();
- __m128 m_sums2 = _mm_setzero_ps();
-
- // Based on |input_ptr| alignment, we need to use loadu or load. Unrolling
- // these loops hurt performance in local testing.
- if (reinterpret_cast<uintptr_t>(input_ptr) & 0x0F) {
- for (int i = 0; i < kKernelSize; i += 4) {
- m_input = _mm_loadu_ps(input_ptr + i);
- m_sums1 = _mm_add_ps(m_sums1, _mm_mul_ps(m_input, _mm_load_ps(k1 + i)));
- m_sums2 = _mm_add_ps(m_sums2, _mm_mul_ps(m_input, _mm_load_ps(k2 + i)));
- }
- } else {
- for (int i = 0; i < kKernelSize; i += 4) {
- m_input = _mm_load_ps(input_ptr + i);
- m_sums1 = _mm_add_ps(m_sums1, _mm_mul_ps(m_input, _mm_load_ps(k1 + i)));
- m_sums2 = _mm_add_ps(m_sums2, _mm_mul_ps(m_input, _mm_load_ps(k2 + i)));
- }
- }
-
- // Linearly interpolate the two "convolutions".
- m_sums1 = _mm_mul_ps(m_sums1, _mm_set_ps1(
- static_cast<float>(1.0 - kernel_interpolation_factor)));
- m_sums2 = _mm_mul_ps(m_sums2, _mm_set_ps1(
- static_cast<float>(kernel_interpolation_factor)));
- m_sums1 = _mm_add_ps(m_sums1, m_sums2);
-
- // Sum components together.
- float result;
- m_sums2 = _mm_add_ps(_mm_movehl_ps(m_sums1, m_sums1), m_sums1);
- _mm_store_ss(&result, _mm_add_ss(m_sums2, _mm_shuffle_ps(
- m_sums2, m_sums2, 1)));
-
- return result;
-}
-#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
+#if defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
float SincResampler::Convolve_NEON(const float* input_ptr, const float* k1,
const float* k2,
double kernel_interpolation_factor) {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/sinc_resampler.h qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/sinc_resampler.h
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/sinc_resampler.h 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/sinc_resampler.h 2017-03-05 17:26:26.169986310 +0100
@@ -36,6 +36,10 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
kKernelStorageSize = kKernelSize * (kKernelOffsetCount + 1),
};
+ // Selects runtime specific CPU features like SSE. Must be called before
+ // using SincResampler.
+ static void InitializeCPUSpecificFeatures();
+
// Callback type for providing more data into the resampler. Expects |frames|
// of data to be rendered into |destination|; zero padded if not enough frames
// are available to satisfy the request.
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/sinc_resampler_perftest.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/sinc_resampler_perftest.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/sinc_resampler_perftest.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/sinc_resampler_perftest.cc 2017-03-05 17:26:26.169986310 +0100
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
@@ -4,6 +4,7 @@
#include "base/bind.h"
#include "base/bind_helpers.h"
+#include "base/cpu.h"
#include "base/time/time.h"
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#include "build/build_config.h"
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#include "media/base/sinc_resampler.h"
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -61,6 +62,9 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
&resampler, SincResampler::Convolve_C, true, "unoptimized_aligned");
#if defined(CONVOLVE_FUNC)
+#if defined(ARCH_CPU_X86_FAMILY)
+ ASSERT_TRUE(base::CPU().has_sse());
+#endif
RunConvolveBenchmark(
&resampler, SincResampler::CONVOLVE_FUNC, true, "optimized_aligned");
RunConvolveBenchmark(
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/sinc_resampler_unittest.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/sinc_resampler_unittest.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/sinc_resampler_unittest.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/sinc_resampler_unittest.cc 2017-03-05 17:26:26.169986310 +0100
@@ -10,6 +10,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#include "base/bind.h"
#include "base/bind_helpers.h"
+#include "base/cpu.h"
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#include "base/macros.h"
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#include "base/strings/string_number_conversions.h"
#include "base/time/time.h"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -166,6 +167,10 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
static const double kKernelInterpolationFactor = 0.5;
TEST(SincResamplerTest, Convolve) {
+#if defined(ARCH_CPU_X86_FAMILY)
+ ASSERT_TRUE(base::CPU().has_sse());
+#endif
+
// Initialize a dummy resampler.
MockSource mock_source;
SincResampler resampler(
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/vector_math.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/vector_math.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/vector_math.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/vector_math.cc 2017-03-05 17:26:26.170986295 +0100
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
@@ -7,12 +7,17 @@
#include <algorithm>
+#include "base/cpu.h"
#include "base/logging.h"
#include "build/build_config.h"
+namespace media {
+namespace vector_math {
+
+// If we know the minimum architecture at compile time, avoid CPU detection.
// NaCl does not allow intrinsics.
#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_NACL)
-#include <xmmintrin.h>
+#if defined(__SSE__)
// Don't use custom SSE versions where the auto-vectorized C version performs
// better, which is anywhere clang is used.
#if !defined(__clang__)
@@ -23,20 +28,52 @@
#define FMUL_FUNC FMUL_C
#endif
#define EWMAAndMaxPower_FUNC EWMAAndMaxPower_SSE
+void Initialize() {}
+#else
+// X86 CPU detection required. Functions will be set by Initialize().
+#if !defined(__clang__)
+#define FMAC_FUNC g_fmac_proc_
+#define FMUL_FUNC g_fmul_proc_
+#else
+#define FMAC_FUNC FMAC_C
+#define FMUL_FUNC FMUL_C
+#endif
+#define EWMAAndMaxPower_FUNC g_ewma_power_proc_
+
+#if !defined(__clang__)
+typedef void (*MathProc)(const float src[], float scale, int len, float dest[]);
+static MathProc g_fmac_proc_ = NULL;
+static MathProc g_fmul_proc_ = NULL;
+#endif
+typedef std::pair<float, float> (*EWMAAndMaxPowerProc)(
+ float initial_value, const float src[], int len, float smoothing_factor);
+static EWMAAndMaxPowerProc g_ewma_power_proc_ = NULL;
+
+void Initialize() {
+ CHECK(!g_fmac_proc_);
+ CHECK(!g_fmul_proc_);
+ CHECK(!g_ewma_power_proc_);
+ const bool kUseSSE = base::CPU().has_sse();
+#if !defined(__clang__)
+ g_fmac_proc_ = kUseSSE ? FMAC_SSE : FMAC_C;
+ g_fmul_proc_ = kUseSSE ? FMUL_SSE : FMUL_C;
+#endif
+ g_ewma_power_proc_ = kUseSSE ? EWMAAndMaxPower_SSE : EWMAAndMaxPower_C;
+}
+#endif
#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
#include <arm_neon.h>
#define FMAC_FUNC FMAC_NEON
#define FMUL_FUNC FMUL_NEON
#define EWMAAndMaxPower_FUNC EWMAAndMaxPower_NEON
+void Initialize() {}
#else
#define FMAC_FUNC FMAC_C
#define FMUL_FUNC FMUL_C
#define EWMAAndMaxPower_FUNC EWMAAndMaxPower_C
+void Initialize() {}
#endif
-namespace media {
-namespace vector_math {
-
void FMAC(const float src[], float scale, int len, float dest[]) {
// Ensure |src| and |dest| are 16-byte aligned.
DCHECK_EQ(0u, reinterpret_cast<uintptr_t>(src) & (kRequiredAlignment - 1));
@@ -89,111 +126,6 @@
return result;
}
-#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_NACL)
-void FMUL_SSE(const float src[], float scale, int len, float dest[]) {
- const int rem = len % 4;
- const int last_index = len - rem;
- __m128 m_scale = _mm_set_ps1(scale);
- for (int i = 0; i < last_index; i += 4)
- _mm_store_ps(dest + i, _mm_mul_ps(_mm_load_ps(src + i), m_scale));
-
- // Handle any remaining values that wouldn't fit in an SSE pass.
- for (int i = last_index; i < len; ++i)
- dest[i] = src[i] * scale;
-}
-
-void FMAC_SSE(const float src[], float scale, int len, float dest[]) {
- const int rem = len % 4;
- const int last_index = len - rem;
- __m128 m_scale = _mm_set_ps1(scale);
- for (int i = 0; i < last_index; i += 4) {
- _mm_store_ps(dest + i, _mm_add_ps(_mm_load_ps(dest + i),
- _mm_mul_ps(_mm_load_ps(src + i), m_scale)));
- }
-
- // Handle any remaining values that wouldn't fit in an SSE pass.
- for (int i = last_index; i < len; ++i)
- dest[i] += src[i] * scale;
-}
-
-// Convenience macro to extract float 0 through 3 from the vector |a|. This is
-// needed because compilers other than clang don't support access via
-// operator[]().
-#define EXTRACT_FLOAT(a, i) \
- (i == 0 ? \
- _mm_cvtss_f32(a) : \
- _mm_cvtss_f32(_mm_shuffle_ps(a, a, i)))
-
-std::pair<float, float> EWMAAndMaxPower_SSE(
- float initial_value, const float src[], int len, float smoothing_factor) {
- // When the recurrence is unrolled, we see that we can split it into 4
- // separate lanes of evaluation:
- //
- // y[n] = a(S[n]^2) + (1-a)(y[n-1])
- // = a(S[n]^2) + (1-a)^1(aS[n-1]^2) + (1-a)^2(aS[n-2]^2) + ...
- // = z[n] + (1-a)^1(z[n-1]) + (1-a)^2(z[n-2]) + (1-a)^3(z[n-3])
- //
- // where z[n] = a(S[n]^2) + (1-a)^4(z[n-4]) + (1-a)^8(z[n-8]) + ...
- //
- // Thus, the strategy here is to compute z[n], z[n-1], z[n-2], and z[n-3] in
- // each of the 4 lanes, and then combine them to give y[n].
-
- const int rem = len % 4;
- const int last_index = len - rem;
-
- const __m128 smoothing_factor_x4 = _mm_set_ps1(smoothing_factor);
- const float weight_prev = 1.0f - smoothing_factor;
- const __m128 weight_prev_x4 = _mm_set_ps1(weight_prev);
- const __m128 weight_prev_squared_x4 =
- _mm_mul_ps(weight_prev_x4, weight_prev_x4);
- const __m128 weight_prev_4th_x4 =
- _mm_mul_ps(weight_prev_squared_x4, weight_prev_squared_x4);
-
- // Compute z[n], z[n-1], z[n-2], and z[n-3] in parallel in lanes 3, 2, 1 and
- // 0, respectively.
- __m128 max_x4 = _mm_setzero_ps();
- __m128 ewma_x4 = _mm_setr_ps(0.0f, 0.0f, 0.0f, initial_value);
- int i;
- for (i = 0; i < last_index; i += 4) {
- ewma_x4 = _mm_mul_ps(ewma_x4, weight_prev_4th_x4);
- const __m128 sample_x4 = _mm_load_ps(src + i);
- const __m128 sample_squared_x4 = _mm_mul_ps(sample_x4, sample_x4);
- max_x4 = _mm_max_ps(max_x4, sample_squared_x4);
- // Note: The compiler optimizes this to a single multiply-and-accumulate
- // instruction:
- ewma_x4 = _mm_add_ps(ewma_x4,
- _mm_mul_ps(sample_squared_x4, smoothing_factor_x4));
- }
-
- // y[n] = z[n] + (1-a)^1(z[n-1]) + (1-a)^2(z[n-2]) + (1-a)^3(z[n-3])
- float ewma = EXTRACT_FLOAT(ewma_x4, 3);
- ewma_x4 = _mm_mul_ps(ewma_x4, weight_prev_x4);
- ewma += EXTRACT_FLOAT(ewma_x4, 2);
- ewma_x4 = _mm_mul_ps(ewma_x4, weight_prev_x4);
- ewma += EXTRACT_FLOAT(ewma_x4, 1);
- ewma_x4 = _mm_mul_ss(ewma_x4, weight_prev_x4);
- ewma += EXTRACT_FLOAT(ewma_x4, 0);
-
- // Fold the maximums together to get the overall maximum.
- max_x4 = _mm_max_ps(max_x4,
- _mm_shuffle_ps(max_x4, max_x4, _MM_SHUFFLE(3, 3, 1, 1)));
- max_x4 = _mm_max_ss(max_x4, _mm_shuffle_ps(max_x4, max_x4, 2));
-
- std::pair<float, float> result(ewma, EXTRACT_FLOAT(max_x4, 0));
-
- // Handle remaining values at the end of |src|.
- for (; i < len; ++i) {
- result.first *= weight_prev;
- const float sample = src[i];
- const float sample_squared = sample * sample;
- result.first += sample_squared * smoothing_factor;
- result.second = std::max(result.second, sample_squared);
- }
-
- return result;
-}
-#endif
-
#if defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
void FMAC_NEON(const float src[], float scale, int len, float dest[]) {
const int rem = len % 4;
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/vector_math.h qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/vector_math.h
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/vector_math.h 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/vector_math.h 2017-03-05 17:26:26.170986295 +0100
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
@@ -15,6 +15,11 @@
// Required alignment for inputs and outputs to all vector math functions
enum { kRequiredAlignment = 16 };
+// Selects runtime specific optimizations such as SSE. Must be called prior to
+// calling FMAC() or FMUL(). Called during media library initialization; most
+// users should never have to call this.
+MEDIA_EXPORT void Initialize();
+
// Multiply each element of |src| (up to |len|) by |scale| and add to |dest|.
// |src| and |dest| must be aligned by kRequiredAlignment.
MEDIA_EXPORT void FMAC(const float src[], float scale, int len, float dest[]);
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/vector_math_perftest.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/vector_math_perftest.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/vector_math_perftest.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/vector_math_perftest.cc 2017-03-05 17:26:26.171986280 +0100
@@ -5,6 +5,7 @@
#include <memory>
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#include "base/macros.h"
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+#include "base/cpu.h"
#include "base/memory/aligned_memory.h"
#include "base/time/time.h"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
#include "build/build_config.h"
@@ -82,15 +83,11 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
DISALLOW_COPY_AND_ASSIGN(VectorMathPerfTest);
};
-// Define platform dependent function names for SIMD optimized methods.
+// Define platform independent function name for FMAC* perf tests.
#if defined(ARCH_CPU_X86_FAMILY)
#define FMAC_FUNC FMAC_SSE
-#define FMUL_FUNC FMUL_SSE
-#define EWMAAndMaxPower_FUNC EWMAAndMaxPower_SSE
#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
#define FMAC_FUNC FMAC_NEON
-#define FMUL_FUNC FMUL_NEON
-#define EWMAAndMaxPower_FUNC EWMAAndMaxPower_NEON
#endif
// Benchmark for each optimized vector_math::FMAC() method.
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -99,6 +96,9 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
RunBenchmark(
vector_math::FMAC_C, true, "vector_math_fmac", "unoptimized");
#if defined(FMAC_FUNC)
+#if defined(ARCH_CPU_X86_FAMILY)
+ ASSERT_TRUE(base::CPU().has_sse());
+#endif
// Benchmark FMAC_FUNC() with unaligned size.
ASSERT_NE((kVectorSize - 1) % (vector_math::kRequiredAlignment /
sizeof(float)), 0U);
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -112,12 +112,24 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#endif
}
+#undef FMAC_FUNC
+
+// Define platform independent function name for FMULBenchmark* tests.
+#if defined(ARCH_CPU_X86_FAMILY)
+#define FMUL_FUNC FMUL_SSE
+#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
+#define FMUL_FUNC FMUL_NEON
+#endif
+
// Benchmark for each optimized vector_math::FMUL() method.
TEST_F(VectorMathPerfTest, FMUL) {
// Benchmark FMUL_C().
RunBenchmark(
vector_math::FMUL_C, true, "vector_math_fmul", "unoptimized");
#if defined(FMUL_FUNC)
+#if defined(ARCH_CPU_X86_FAMILY)
+ ASSERT_TRUE(base::CPU().has_sse());
+#endif
// Benchmark FMUL_FUNC() with unaligned size.
ASSERT_NE((kVectorSize - 1) % (vector_math::kRequiredAlignment /
sizeof(float)), 0U);
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -131,6 +143,14 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#endif
}
+#undef FMUL_FUNC
+
+#if defined(ARCH_CPU_X86_FAMILY)
+#define EWMAAndMaxPower_FUNC EWMAAndMaxPower_SSE
+#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON)
+#define EWMAAndMaxPower_FUNC EWMAAndMaxPower_NEON
+#endif
+
// Benchmark for each optimized vector_math::EWMAAndMaxPower() method.
TEST_F(VectorMathPerfTest, EWMAAndMaxPower) {
// Benchmark EWMAAndMaxPower_C().
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -139,6 +159,9 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
"vector_math_ewma_and_max_power",
"unoptimized");
#if defined(EWMAAndMaxPower_FUNC)
+#if defined(ARCH_CPU_X86_FAMILY)
+ ASSERT_TRUE(base::CPU().has_sse());
+#endif
// Benchmark EWMAAndMaxPower_FUNC() with unaligned size.
ASSERT_NE((kVectorSize - 1) % (vector_math::kRequiredAlignment /
sizeof(float)), 0U);
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -156,4 +179,6 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#endif
}
+#undef EWMAAndMaxPower_FUNC
+
} // namespace media
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/vector_math_testing.h qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/vector_math_testing.h
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/vector_math_testing.h 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/vector_math_testing.h 2017-03-05 17:26:26.171986280 +0100
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
@@ -19,7 +19,7 @@
MEDIA_EXPORT std::pair<float, float> EWMAAndMaxPower_C(
float initial_value, const float src[], int len, float smoothing_factor);
-#if defined(ARCH_CPU_X86_FAMILY) && !defined(OS_NACL)
+#if defined(ARCH_CPU_X86_FAMILY)
MEDIA_EXPORT void FMAC_SSE(const float src[], float scale, int len,
float dest[]);
MEDIA_EXPORT void FMUL_SSE(const float src[], float scale, int len,
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/vector_math_unittest.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/vector_math_unittest.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/vector_math_unittest.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/vector_math_unittest.cc 2017-03-05 17:26:26.172986265 +0100
@@ -9,6 +9,7 @@
#include <memory>
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#include "base/macros.h"
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+#include "base/cpu.h"
#include "base/memory/aligned_memory.h"
#include "base/strings/string_number_conversions.h"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
#include "base/strings/stringize_macros.h"
@@ -78,6 +79,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#if defined(ARCH_CPU_X86_FAMILY)
{
+ ASSERT_TRUE(base::CPU().has_sse());
SCOPED_TRACE("FMAC_SSE");
FillTestVectors(kInputFillValue, kOutputFillValue);
vector_math::FMAC_SSE(
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -119,6 +121,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#if defined(ARCH_CPU_X86_FAMILY)
{
+ ASSERT_TRUE(base::CPU().has_sse());
SCOPED_TRACE("FMUL_SSE");
FillTestVectors(kInputFillValue, kOutputFillValue);
vector_math::FMUL_SSE(
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -227,6 +230,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#if defined(ARCH_CPU_X86_FAMILY)
{
+ ASSERT_TRUE(base::CPU().has_sse());
SCOPED_TRACE("EWMAAndMaxPower_SSE");
const std::pair<float, float>& result = vector_math::EWMAAndMaxPower_SSE(
initial_value_, data_.get(), data_len_, smoothing_factor_);
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/yuv_convert.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/yuv_convert.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/yuv_convert.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/yuv_convert.cc 2017-03-05 17:26:26.173986250 +0100
@@ -32,7 +32,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#include "media/base/simd/convert_yuv_to_rgb.h"
#include "media/base/simd/filter_yuv.h"
-#if defined(ARCH_CPU_X86_FAMILY)
+#if defined(ARCH_CPU_X86_FAMILY) && defined(__MMX__)
#if defined(COMPILER_MSVC)
#include <intrin.h>
#else
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -133,7 +133,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
// Empty SIMD registers state after using them.
void EmptyRegisterStateStub() {}
-#if defined(MEDIA_MMX_INTRINSICS_AVAILABLE)
+#if defined(MEDIA_MMX_INTRINSICS_AVAILABLE) && defined(__MMX__)
void EmptyRegisterStateIntrinsic() { _mm_empty(); }
#endif
typedef void (*EmptyRegisterStateProc)();
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -247,34 +247,46 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
// Assembly code confuses MemorySanitizer. Also not available in iOS builds.
#if defined(ARCH_CPU_X86_FAMILY) && !defined(MEMORY_SANITIZER) && \
!defined(OS_IOS)
- g_convert_yuva_to_argb_proc_ = ConvertYUVAToARGB_MMX;
+ base::CPU cpu;
+ if (cpu.has_mmx()) {
+ g_convert_yuv_to_rgb32_row_proc_ = ConvertYUVToRGB32Row_MMX;
+ g_scale_yuv_to_rgb32_row_proc_ = ScaleYUVToRGB32Row_MMX;
+ g_convert_yuv_to_rgb32_proc_ = ConvertYUVToRGB32_MMX;
+ g_convert_yuva_to_argb_proc_ = ConvertYUVAToARGB_MMX;
+ g_linear_scale_yuv_to_rgb32_row_proc_ = LinearScaleYUVToRGB32Row_MMX;
#if defined(MEDIA_MMX_INTRINSICS_AVAILABLE)
- g_empty_register_state_proc_ = EmptyRegisterStateIntrinsic;
+ g_filter_yuv_rows_proc_ = FilterYUVRows_MMX;
+#endif
+#if defined(MEDIA_MMX_INTRINSICS_AVAILABLE) && defined(__MMX__)
+ g_empty_register_state_proc_ = EmptyRegisterStateIntrinsic;
#else
- g_empty_register_state_proc_ = EmptyRegisterState_MMX;
+ g_empty_register_state_proc_ = EmptyRegisterState_MMX;
#endif
+ }
- g_convert_yuv_to_rgb32_row_proc_ = ConvertYUVToRGB32Row_SSE;
- g_convert_yuv_to_rgb32_proc_ = ConvertYUVToRGB32_SSE;
+ if (cpu.has_sse()) {
+ g_convert_yuv_to_rgb32_row_proc_ = ConvertYUVToRGB32Row_SSE;
+ g_scale_yuv_to_rgb32_row_proc_ = ScaleYUVToRGB32Row_SSE;
+ g_linear_scale_yuv_to_rgb32_row_proc_ = LinearScaleYUVToRGB32Row_SSE;
+ g_convert_yuv_to_rgb32_proc_ = ConvertYUVToRGB32_SSE;
+ }
- g_filter_yuv_rows_proc_ = FilterYUVRows_SSE2;
- g_convert_rgb32_to_yuv_proc_ = ConvertRGB32ToYUV_SSE2;
+ if (cpu.has_sse2()) {
+ g_filter_yuv_rows_proc_ = FilterYUVRows_SSE2;
+ g_convert_rgb32_to_yuv_proc_ = ConvertRGB32ToYUV_SSE2;
#if defined(ARCH_CPU_X86_64)
- g_scale_yuv_to_rgb32_row_proc_ = ScaleYUVToRGB32Row_SSE2_X64;
+ g_scale_yuv_to_rgb32_row_proc_ = ScaleYUVToRGB32Row_SSE2_X64;
- // Technically this should be in the MMX section, but MSVC will optimize out
- // the export of LinearScaleYUVToRGB32Row_MMX, which is required by the unit
- // tests, if that decision can be made at compile time. Since all X64 CPUs
- // have SSE2, we can hack around this by making the selection here.
- g_linear_scale_yuv_to_rgb32_row_proc_ = LinearScaleYUVToRGB32Row_MMX_X64;
-#else
- g_scale_yuv_to_rgb32_row_proc_ = ScaleYUVToRGB32Row_SSE;
- g_linear_scale_yuv_to_rgb32_row_proc_ = LinearScaleYUVToRGB32Row_SSE;
+ // Technically this should be in the MMX section, but MSVC will optimize out
+ // the export of LinearScaleYUVToRGB32Row_MMX, which is required by the unit
+ // tests, if that decision can be made at compile time. Since all X64 CPUs
+ // have SSE2, we can hack around this by making the selection here.
+ g_linear_scale_yuv_to_rgb32_row_proc_ = LinearScaleYUVToRGB32Row_MMX_X64;
#endif
+ }
- base::CPU cpu;
if (cpu.has_ssse3()) {
g_convert_rgb24_to_yuv_proc_ = &ConvertRGB24ToYUV_SSSE3;
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/yuv_convert_perftest.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/yuv_convert_perftest.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/yuv_convert_perftest.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/yuv_convert_perftest.cc 2017-03-05 17:26:26.173986250 +0100
@@ -71,6 +71,29 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
DISALLOW_COPY_AND_ASSIGN(YUVConvertPerfTest);
};
+TEST_F(YUVConvertPerfTest, ConvertYUVToRGB32Row_MMX) {
+ ASSERT_TRUE(base::CPU().has_mmx());
+
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ base::TimeTicks start = base::TimeTicks::Now();
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ for (int i = 0; i < kPerfTestIterations; ++i) {
+ for (int row = 0; row < kSourceHeight; ++row) {
+ int chroma_row = row / 2;
+ ConvertYUVToRGB32Row_MMX(
+ yuv_bytes_.get() + row * kSourceWidth,
+ yuv_bytes_.get() + kSourceUOffset + (chroma_row * kSourceWidth / 2),
+ yuv_bytes_.get() + kSourceVOffset + (chroma_row * kSourceWidth / 2),
+ rgb_bytes_converted_.get(),
+ kWidth,
+ GetLookupTable(YV12));
+ }
+ }
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ media::EmptyRegisterState();
+ double total_time_seconds = (base::TimeTicks::Now() - start).InSecondsF();
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ perf_test::PrintResult(
+ "yuv_convert_perftest", "", "ConvertYUVToRGB32Row_MMX",
+ kPerfTestIterations / total_time_seconds, "runs/s", true);
+}
+
TEST_F(YUVConvertPerfTest, ConvertYUVToRGB32Row_SSE) {
ASSERT_TRUE(base::CPU().has_sse());
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -161,9 +184,32 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
}
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#endif
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
-// 64-bit release + component builds on Windows are too smart and optimizes
-// away the function being tested.
-#if defined(OS_WIN) && (defined(ARCH_CPU_X86) || !defined(COMPONENT_BUILD))
+TEST_F(YUVConvertPerfTest, ScaleYUVToRGB32Row_MMX) {
+ ASSERT_TRUE(base::CPU().has_mmx());
+
+ const int kSourceDx = 80000; // This value means a scale down.
+
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ base::TimeTicks start = base::TimeTicks::Now();
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ for (int i = 0; i < kPerfTestIterations; ++i) {
+ for (int row = 0; row < kSourceHeight; ++row) {
+ int chroma_row = row / 2;
+ ScaleYUVToRGB32Row_MMX(
+ yuv_bytes_.get() + row * kSourceWidth,
+ yuv_bytes_.get() + kSourceUOffset + (chroma_row * kSourceWidth / 2),
+ yuv_bytes_.get() + kSourceVOffset + (chroma_row * kSourceWidth / 2),
+ rgb_bytes_converted_.get(),
+ kWidth,
+ kSourceDx,
+ GetLookupTable(YV12));
+ }
+ }
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ media::EmptyRegisterState();
+ double total_time_seconds = (base::TimeTicks::Now() - start).InSecondsF();
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ perf_test::PrintResult(
+ "yuv_convert_perftest", "", "ScaleYUVToRGB32Row_MMX",
+ kPerfTestIterations / total_time_seconds, "runs/s", true);
+}
+
TEST_F(YUVConvertPerfTest, ScaleYUVToRGB32Row_SSE) {
ASSERT_TRUE(base::CPU().has_sse());
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -190,6 +236,32 @@
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
kPerfTestIterations / total_time_seconds, "runs/s", true);
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
}
+TEST_F(YUVConvertPerfTest, LinearScaleYUVToRGB32Row_MMX) {
+ ASSERT_TRUE(base::CPU().has_mmx());
+
+ const int kSourceDx = 80000; // This value means a scale down.
+
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ base::TimeTicks start = base::TimeTicks::Now();
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ for (int i = 0; i < kPerfTestIterations; ++i) {
+ for (int row = 0; row < kSourceHeight; ++row) {
+ int chroma_row = row / 2;
+ LinearScaleYUVToRGB32Row_MMX(
+ yuv_bytes_.get() + row * kSourceWidth,
+ yuv_bytes_.get() + kSourceUOffset + (chroma_row * kSourceWidth / 2),
+ yuv_bytes_.get() + kSourceVOffset + (chroma_row * kSourceWidth / 2),
+ rgb_bytes_converted_.get(),
+ kWidth,
+ kSourceDx,
+ GetLookupTable(YV12));
+ }
+ }
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ media::EmptyRegisterState();
+ double total_time_seconds = (base::TimeTicks::Now() - start).InSecondsF();
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ perf_test::PrintResult(
+ "yuv_convert_perftest", "", "LinearScaleYUVToRGB32Row_MMX",
+ kPerfTestIterations / total_time_seconds, "runs/s", true);
+}
+
TEST_F(YUVConvertPerfTest, LinearScaleYUVToRGB32Row_SSE) {
ASSERT_TRUE(base::CPU().has_sse());
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -215,7 +287,6 @@
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
"yuv_convert_perftest", "", "LinearScaleYUVToRGB32Row_SSE",
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
kPerfTestIterations / total_time_seconds, "runs/s", true);
}
-#endif // defined(OS_WIN) && (ARCH_CPU_X86 || COMPONENT_BUILD)
#endif // !defined(ARCH_CPU_ARM_FAMILY) && !defined(ARCH_CPU_MIPS_FAMILY)
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/yuv_convert_unittest.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/yuv_convert_unittest.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/base/yuv_convert_unittest.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/base/yuv_convert_unittest.cc 2017-03-05 17:26:26.174986235 +0100
@@ -643,6 +643,37 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
EXPECT_EQ(0, error);
}
+TEST(YUVConvertTest, ConvertYUVToRGB32Row_MMX) {
+ base::CPU cpu;
+ if (!cpu.has_mmx()) {
+ LOG(WARNING) << "System not supported. Test skipped.";
+ return;
+ }
+
+ scoped_ptr<uint8[]> yuv_bytes(new uint8[kYUV12Size]);
+ scoped_ptr<uint8[]> rgb_bytes_reference(new uint8[kRGBSize]);
+ scoped_ptr<uint8[]> rgb_bytes_converted(new uint8[kRGBSize]);
+ ReadYV12Data(&yuv_bytes);
+
+ const int kWidth = 167;
+ ConvertYUVToRGB32Row_C(yuv_bytes.get(),
+ yuv_bytes.get() + kSourceUOffset,
+ yuv_bytes.get() + kSourceVOffset,
+ rgb_bytes_reference.get(),
+ kWidth,
+ GetLookupTable(YV12));
+ ConvertYUVToRGB32Row_MMX(yuv_bytes.get(),
+ yuv_bytes.get() + kSourceUOffset,
+ yuv_bytes.get() + kSourceVOffset,
+ rgb_bytes_converted.get(),
+ kWidth,
+ GetLookupTable(YV12));
+ media::EmptyRegisterState();
+ EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
+ rgb_bytes_converted.get(),
+ kWidth * kBpp));
+}
+
TEST(YUVConvertTest, ConvertYUVToRGB32Row_SSE) {
base::CPU cpu;
if (!cpu.has_sse()) {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -674,9 +705,40 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
kWidth * kBpp));
}
-// 64-bit release + component builds on Windows are too smart and optimizes
-// away the function being tested.
-#if defined(OS_WIN) && (defined(ARCH_CPU_X86) || !defined(COMPONENT_BUILD))
+TEST(YUVConvertTest, ScaleYUVToRGB32Row_MMX) {
+ base::CPU cpu;
+ if (!cpu.has_mmx()) {
+ LOG(WARNING) << "System not supported. Test skipped.";
+ return;
+ }
+
+ scoped_ptr<uint8[]> yuv_bytes(new uint8[kYUV12Size]);
+ scoped_ptr<uint8[]> rgb_bytes_reference(new uint8[kRGBSize]);
+ scoped_ptr<uint8[]> rgb_bytes_converted(new uint8[kRGBSize]);
+ ReadYV12Data(&yuv_bytes);
+
+ const int kWidth = 167;
+ const int kSourceDx = 80000; // This value means a scale down.
+ ScaleYUVToRGB32Row_C(yuv_bytes.get(),
+ yuv_bytes.get() + kSourceUOffset,
+ yuv_bytes.get() + kSourceVOffset,
+ rgb_bytes_reference.get(),
+ kWidth,
+ kSourceDx,
+ GetLookupTable(YV12));
+ ScaleYUVToRGB32Row_MMX(yuv_bytes.get(),
+ yuv_bytes.get() + kSourceUOffset,
+ yuv_bytes.get() + kSourceVOffset,
+ rgb_bytes_converted.get(),
+ kWidth,
+ kSourceDx,
+ GetLookupTable(YV12));
+ media::EmptyRegisterState();
+ EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
+ rgb_bytes_converted.get(),
+ kWidth * kBpp));
+}
+
TEST(YUVConvertTest, ScaleYUVToRGB32Row_SSE) {
base::CPU cpu;
if (!cpu.has_sse()) {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -711,6 +773,40 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
kWidth * kBpp));
}
+TEST(YUVConvertTest, LinearScaleYUVToRGB32Row_MMX) {
+ base::CPU cpu;
+ if (!cpu.has_mmx()) {
+ LOG(WARNING) << "System not supported. Test skipped.";
+ return;
+ }
+
+ scoped_ptr<uint8[]> yuv_bytes(new uint8[kYUV12Size]);
+ scoped_ptr<uint8[]> rgb_bytes_reference(new uint8[kRGBSize]);
+ scoped_ptr<uint8[]> rgb_bytes_converted(new uint8[kRGBSize]);
+ ReadYV12Data(&yuv_bytes);
+
+ const int kWidth = 167;
+ const int kSourceDx = 80000; // This value means a scale down.
+ LinearScaleYUVToRGB32Row_C(yuv_bytes.get(),
+ yuv_bytes.get() + kSourceUOffset,
+ yuv_bytes.get() + kSourceVOffset,
+ rgb_bytes_reference.get(),
+ kWidth,
+ kSourceDx,
+ GetLookupTable(YV12));
+ LinearScaleYUVToRGB32Row_MMX(yuv_bytes.get(),
+ yuv_bytes.get() + kSourceUOffset,
+ yuv_bytes.get() + kSourceVOffset,
+ rgb_bytes_converted.get(),
+ kWidth,
+ kSourceDx,
+ GetLookupTable(YV12));
+ media::EmptyRegisterState();
+ EXPECT_EQ(0, memcmp(rgb_bytes_reference.get(),
+ rgb_bytes_converted.get(),
+ kWidth * kBpp));
+}
+
TEST(YUVConvertTest, LinearScaleYUVToRGB32Row_SSE) {
base::CPU cpu;
if (!cpu.has_sse()) {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -744,7 +840,6 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
rgb_bytes_converted.get(),
kWidth * kBpp));
}
-#endif // defined(OS_WIN) && (ARCH_CPU_X86 || COMPONENT_BUILD)
TEST(YUVConvertTest, FilterYUVRows_C_OutOfBounds) {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
std::unique_ptr<uint8_t[]> src(new uint8_t[16]);
@@ -761,6 +856,30 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
}
}
+#if defined(MEDIA_MMX_INTRINSICS_AVAILABLE)
+TEST(YUVConvertTest, FilterYUVRows_MMX_OutOfBounds) {
+ base::CPU cpu;
+ if (!cpu.has_mmx()) {
+ LOG(WARNING) << "System not supported. Test skipped.";
+ return;
+ }
+
+ scoped_ptr<uint8[]> src(new uint8[16]);
+ scoped_ptr<uint8[]> dst(new uint8[16]);
+
+ memset(src.get(), 0xff, 16);
+ memset(dst.get(), 0, 16);
+
+ media::FilterYUVRows_MMX(dst.get(), src.get(), src.get(), 1, 255);
+ media::EmptyRegisterState();
+
+ EXPECT_EQ(255u, dst[0]);
+ for (int i = 1; i < 16; ++i) {
+ EXPECT_EQ(0u, dst[i]);
+ }
+}
+#endif // defined(MEDIA_MMX_INTRINSICS_AVAILABLE)
+
TEST(YUVConvertTest, FilterYUVRows_SSE2_OutOfBounds) {
base::CPU cpu;
if (!cpu.has_sse2()) {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -782,6 +901,38 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
}
}
+#if defined(MEDIA_MMX_INTRINSICS_AVAILABLE)
+TEST(YUVConvertTest, FilterYUVRows_MMX_UnalignedDestination) {
+ base::CPU cpu;
+ if (!cpu.has_mmx()) {
+ LOG(WARNING) << "System not supported. Test skipped.";
+ return;
+ }
+
+ const int kSize = 32;
+ scoped_ptr<uint8[]> src(new uint8[kSize]);
+ scoped_ptr<uint8[]> dst_sample(new uint8[kSize]);
+ scoped_ptr<uint8[]> dst(new uint8[kSize]);
+
+ memset(dst_sample.get(), 0, kSize);
+ memset(dst.get(), 0, kSize);
+ for (int i = 0; i < kSize; ++i)
+ src[i] = 100 + i;
+
+ media::FilterYUVRows_C(dst_sample.get(),
+ src.get(), src.get(), 17, 128);
+
+ // Generate an unaligned output address.
+ uint8* dst_ptr =
+ reinterpret_cast<uint8*>(
+ (reinterpret_cast<uintptr_t>(dst.get() + 8) & ~7) + 1);
+ media::FilterYUVRows_MMX(dst_ptr, src.get(), src.get(), 17, 128);
+ media::EmptyRegisterState();
+
+ EXPECT_EQ(0, memcmp(dst_sample.get(), dst_ptr, 17));
+}
+#endif // defined(MEDIA_MMX_INTRINSICS_AVAILABLE)
+
TEST(YUVConvertTest, FilterYUVRows_SSE2_UnalignedDestination) {
base::CPU cpu;
if (!cpu.has_sse2()) {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/BUILD.gn qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/BUILD.gn
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/BUILD.gn 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/BUILD.gn 2017-03-05 17:26:26.175986220 +0100
@@ -805,6 +805,26 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
"//base",
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
"//ui/gfx/geometry",
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
]
+ if (current_cpu == "x86" || current_cpu == "x64") {
+ deps += [
+ ":shared_memory_support_sse",
+ ]
+ }
+}
+
+if (current_cpu == "x86" || current_cpu == "x64") {
+ source_set("shared_memory_support_sse") {
+ sources = [
+ "base/simd/vector_math_sse.cc",
+ ]
+ configs += [
+ "//media:media_config",
+ "//media:media_implementation",
+ ]
+ if (!is_win) {
+ cflags = [ "-msse" ]
+ }
+ }
}
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
# TODO(watk): Refactor tests that could be made to run on Android. See
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/media.gyp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/media.gyp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/media/media.gyp 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/media/media.gyp 2017-03-05 17:51:56.424188330 +0100
@@ -1020,12 +1020,12 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
['target_arch=="ia32" or target_arch=="x64"', {
'dependencies': [
'media_asm',
+ 'media_mmx',
+ 'media_sse',
+ 'media_sse2',
],
'sources': [
- 'base/simd/convert_rgb_to_yuv_sse2.cc',
- 'base/simd/convert_rgb_to_yuv_ssse3.cc',
'base/simd/convert_yuv_to_rgb_x86.cc',
- 'base/simd/filter_yuv_sse2.cc',
],
}],
['OS!="linux" and OS!="win"', {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -1616,6 +1616,11 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
'USE_NEON'
],
}],
+ ['target_arch=="ia32" or target_arch=="x64"', {
+ 'dependencies': [
+ 'shared_memory_support_sse'
+ ],
+ }],
],
},
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
{
@@ -1633,6 +1638,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
'type': 'static_library',
'sources': [
'base/simd/convert_rgb_to_yuv_ssse3.asm',
+ 'base/simd/convert_yuv_to_rgb_mmx.asm',
'base/simd/convert_yuv_to_rgb_sse.asm',
'base/simd/convert_yuva_to_argb_mmx.asm',
'base/simd/empty_register_state_mmx.asm',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -1713,6 +1719,75 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
'../third_party/yasm/yasm_compile.gypi',
],
},
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ {
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ # GN version: //media/base:media_mmx
+ 'target_name': 'media_mmx',
+ 'type': 'static_library',
+ 'cflags': [
+ '-mmmx',
+ ],
+ 'defines': [
+ 'MEDIA_IMPLEMENTATION',
+ ],
+ 'include_dirs': [
+ '..',
+ ],
+ 'sources': [
+ 'base/simd/filter_yuv_mmx.cc',
+ ],
+ },
+ {
+ # GN version: //media/base:media_sse
+ 'target_name': 'media_sse',
+ 'type': 'static_library',
+ 'cflags': [
+ '-msse',
+ ],
+ 'defines': [
+ 'MEDIA_IMPLEMENTATION',
+ ],
+ 'include_dirs': [
+ '..',
+ ],
+ 'sources': [
+ 'base/simd/sinc_resampler_sse.cc',
+ ],
+ },
+ {
+ # GN version: //media/base:media_sse2
+ 'target_name': 'media_sse2',
+ 'type': 'static_library',
+ 'cflags': [
+ '-msse2',
+ ],
+ 'defines': [
+ 'MEDIA_IMPLEMENTATION',
+ ],
+ 'include_dirs': [
+ '..',
+ ],
+ 'sources': [
+ 'base/simd/convert_rgb_to_yuv_sse2.cc',
+ 'base/simd/convert_rgb_to_yuv_ssse3.cc',
+ 'base/simd/filter_yuv_sse2.cc',
+ ],
+ },
+ {
+ 'target_name': 'shared_memory_support_sse',
+ 'type': 'static_library',
+ 'cflags': [
+ '-msse',
+ ],
+ 'defines': [
+ 'MEDIA_IMPLEMENTATION',
+ ],
+ 'include_dirs': [
+ '..',
+ ],
+ 'sources': [
+ 'base/simd/vector_math_sse.cc',
+ ],
+ },
], # targets
}],
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
['OS=="win"', {
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/skia/BUILD.gn qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/skia/BUILD.gn
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/skia/BUILD.gn 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/skia/BUILD.gn 2017-03-05 17:56:08.829413581 +0100
@@ -329,11 +329,6 @@
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
if (!is_ios) {
sources += [ "ext/platform_canvas.cc" ]
}
- if (!is_ios && (current_cpu == "x86" || current_cpu == "x64")) {
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
- sources += [ "ext/convolver_SSE2.cc" ]
- } else if (current_cpu == "mipsel" && mips_dsp_rev >= 2) {
- sources += [ "ext/convolver_mips_dspr2.cc" ]
- }
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
# The skia gypi values are relative to the skia_dir, so we need to rebase.
sources += gypi_skia_core.sources
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -642,7 +637,15 @@
if (skia_build_no_opts) {
sources = gypi_skia_opts.none_sources
} else if (current_cpu == "x86" || current_cpu == "x64") {
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
- sources = gypi_skia_opts.sse2_sources
+ sources = gypi_skia_opts.sse2_sources +
+ [
+ # Chrome-specific.
+ "ext/convolver_SSE2.cc",
+ "ext/convolver_SSE2.h",
+ ]
+ if (!is_win || is_clang) {
+ cflags += [ "-msse2" ]
+ }
deps += [
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
":skia_opts_avx",
":skia_opts_avx2",
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -677,6 +680,13 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
if (mips_dsp_rev >= 1) {
sources = gypi_skia_opts.mips_dsp_sources
+ if (mips_dsp_rev >= 2) {
+ sources += [
+ # Chrome-specific.
+ "ext/convolver_mips_dspr2.cc",
+ "ext/convolver_mips_dspr2.h",
+ ]
+ }
} else {
sources = gypi_skia_opts.none_sources
}
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/skia/ext/convolver.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/skia/ext/convolver.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/skia/ext/convolver.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/skia/ext/convolver.cc 2017-03-05 17:26:26.176986205 +0100
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
@@ -362,10 +362,13 @@
void SetupSIMD(ConvolveProcs *procs) {
#ifdef SIMD_SSE2
- procs->extra_horizontal_reads = 3;
- procs->convolve_vertically = &ConvolveVertically_SSE2;
- procs->convolve_4rows_horizontally = &Convolve4RowsHorizontally_SSE2;
- procs->convolve_horizontally = &ConvolveHorizontally_SSE2;
+ base::CPU cpu;
+ if (cpu.has_sse2()) {
+ procs->extra_horizontal_reads = 3;
+ procs->convolve_vertically = &ConvolveVertically_SSE2;
+ procs->convolve_4rows_horizontally = &Convolve4RowsHorizontally_SSE2;
+ procs->convolve_horizontally = &ConvolveHorizontally_SSE2;
+ }
#elif defined SIMD_MIPS_DSPR2
procs->extra_horizontal_reads = 3;
procs->convolve_vertically = &ConvolveVertically_mips_dspr2;
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/skia/ext/convolver.h qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/skia/ext/convolver.h
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/skia/ext/convolver.h 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/skia/ext/convolver.h 2017-03-05 17:26:26.239985269 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -11,6 +11,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#include <vector>
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#include "build/build_config.h"
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+#include "base/cpu.h"
#include "third_party/skia/include/core/SkSize.h"
#include "third_party/skia/include/core/SkTypes.h"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/skia/skia_chrome.gypi qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/skia/skia_chrome.gypi
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/skia/skia_chrome.gypi 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/skia/skia_chrome.gypi 2017-03-05 17:26:26.239985269 +0100
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
@@ -9,6 +9,7 @@
{
'dependencies': [
'skia_library',
+ 'skia_chrome_opts',
'../base/base.gyp:base',
'../base/third_party/dynamic_annotations/dynamic_annotations.gyp:dynamic_annotations',
],
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -67,22 +68,16 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
'ext/skia_utils_base.cc',
],
}],
+ ['OS == "ios"', {
+ 'dependencies!': [
+ 'skia_chrome_opts',
+ ],
+ }],
[ 'OS != "android" and (OS != "linux" or use_cairo==1)', {
'sources!': [
'ext/bitmap_platform_device_skia.cc',
],
}],
- [ 'OS != "ios" and target_arch != "arm" and target_arch != "mipsel" and \
- target_arch != "arm64" and target_arch != "mips64el"', {
- 'sources': [
- 'ext/convolver_SSE2.cc',
- ],
- }],
- [ 'target_arch == "mipsel" and mips_dsp_rev >= 2',{
- 'sources': [
- 'ext/convolver_mips_dspr2.cc',
- ],
- }],
],
'target_conditions': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/skia/skia.gyp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/skia/skia.gyp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/skia/skia.gyp 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/skia/skia.gyp 2017-03-05 17:26:26.239985269 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -128,6 +128,37 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
# targets that are not dependent upon the component type
'targets': [
{
+ 'target_name': 'skia_chrome_opts',
+ 'type': 'static_library',
+ 'include_dirs': [
+ '..',
+ 'config',
+ '../third_party/skia/include/core',
+ ],
+ 'conditions': [
+ [ 'os_posix == 1 and OS != "mac" and OS != "android" and \
+ target_arch != "arm" and target_arch != "mipsel" and \
+ target_arch != "arm64" and target_arch != "mips64el"', {
+ 'cflags': [
+ '-msse2',
+ ],
+ }],
+ [ 'target_arch != "arm" and target_arch != "mipsel" and \
+ target_arch != "arm64" and target_arch != "mips64el"', {
+ 'sources': [
+ 'ext/convolver_SSE2.cc',
+ 'ext/convolver_SSE2.h',
+ ],
+ }],
+ [ 'target_arch == "mipsel" and mips_dsp_rev >= 2',{
+ 'sources': [
+ 'ext/convolver_mips_dspr2.cc',
+ 'ext/convolver_mips_dspr2.h',
+ ],
+ }],
+ ],
+ },
+ {
'target_name': 'image_operations_bench',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
# The optimize: 'max' scattered throughout are particularly
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
# important when compiled by MSVC 2013, which seems
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/skia/skia_library_opts.gyp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/skia/skia_library_opts.gyp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/skia/skia_library_opts.gyp 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/skia/skia_library_opts.gyp 2017-03-05 17:26:26.239985269 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -19,10 +19,22 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
},
'targets': [
- # SSE files have to be built in a separate target, because gcc needs
- # different -msse flags for different SSE levels which enable use of SSE
- # intrinsics but also allow emission of SSE2 instructions for scalar code.
- # gyp does not allow per-file compiler flags.
+ # Due to an unfortunate intersection of lameness between gcc and gyp,
+ # we have to build the *_SSE2.cpp files in a separate target. The
+ # gcc lameness is that, in order to compile SSE2 intrinsics code, it
+ # must be passed the -msse2 flag. However, with this flag, it may
+ # emit SSE2 instructions even for scalar code, such as the CPUID
+ # test used to test for the presence of SSE2. So that, and all other
+ # code must be compiled *without* -msse2. The gyp lameness is that it
+ # does not allow file-specific CFLAGS, so we must create this extra
+ # target for those files to be compiled with -msse2.
+ #
+ # This is actually only a problem on 32-bit Linux (all Intel Macs have
+ # SSE2, Linux x86_64 has SSE2 by definition, and MSC will happily emit
+ # SSE2 from instrinsics, which generating plain ol' 386 for everything
+ # else). However, to keep the .gyp file simple and avoid platform-specific
+ # build breakage, we do this on all platforms.
+
# For about the same reason, we need to compile the ARM opts files
# separately as well.
{
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -45,12 +57,13 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
],
'include_dirs': [ '<@(include_dirs)' ],
'conditions': [
+ [ 'os_posix == 1 and OS != "mac" and OS != "android" and \
+ target_arch != "arm" and target_arch != "arm64" and \
+ target_arch != "mipsel" and target_arch != "mips64el"', {
+ 'cflags': [ '-msse2' ],
+ }],
[ 'target_arch != "arm" and target_arch != "mipsel" and \
target_arch != "arm64" and target_arch != "mips64el"', {
- # Chrome builds with -msse2 locally, so sse2_sources could in theory
- # be in the regular skia target. But we need skia_opts for arm
- # anyway, so putting sse2_sources here is simpler than making this
- # conditionally a type none target on x86.
'sources': [ '<@(sse2_sources)' ],
'dependencies': [
'skia_opts_ssse3',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/qcms/BUILD.gn qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/qcms/BUILD.gn
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/qcms/BUILD.gn 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/qcms/BUILD.gn 2017-03-05 17:26:26.240985255 +0100
@@ -31,8 +31,8 @@
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
]
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
if (current_cpu == "x86" || current_cpu == "x64") {
- defines = [ "SSE2_ENABLE" ]
- sources += [ "src/transform-sse2.c" ]
+ defines = [ "SSE2_ENABLE" ] # runtime detection
+ deps = [ "qcms_sse2" ]
}
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
}
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -75,3 +75,15 @@
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
public_configs = [ ":qcms_config" ]
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
}
}
+
+source_set("qcms_sse2") {
+ configs -= [ "//build/config/compiler:chromium_code" ]
+ configs += [ "//build/config/compiler:no_chromium_code" ]
+ public_configs = [ ":qcms_config" ]
+
+ if (current_cpu == "x86" || current_cpu == "x64") {
+ defines = [ "SSE2_ENABLE" ]
+ sources = [ "src/transform-sse2.c" ]
+ cflags = [ "-msse2" ]
+ }
+}
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/qcms/qcms.gyp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/qcms/qcms.gyp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/qcms/qcms.gyp 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/qcms/qcms.gyp 2017-03-05 18:01:48.843328633 +0100
@@ -52,10 +52,10 @@
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
'conditions': [
['target_arch=="ia32" or target_arch=="x64"', {
'defines': [
- 'SSE2_ENABLE',
+ 'SSE2_ENABLE', # runtime detection
],
- 'sources': [
- 'src/transform-sse2.c',
+ 'dependencies': [
+ 'qcms_sse2',
],
}],
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
],
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -68,6 +68,29 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
}],
],
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
},
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
+ {
+ 'target_name': 'qcms_sse2',
+ 'type': 'static_library',
+ 'conditions': [
+ ['target_arch == "ia32" or target_arch == "x64"', {
+ 'defines': [
+ 'SSE2_ENABLE',
+ ],
+ 'sources': [
+ # Conditional compilation for SSE2 code on x86 and x64 machines
+ 'src/transform-sse2.c',
+ ],
+ 'cflags': [
+ '-msse2',
+ ],
+ }],
+ ],
+ 'direct_dependent_settings': {
+ 'include_dirs': [
+ './src',
+ ],
+ },
+ },
],
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
'conditions': [
['disable_qcms == 0', {
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp 2017-03-05 17:26:26.240985255 +0100
no-sse2 patch: Also fix AudioParamTimeline.cpp in Blink's webaudio src/3rdparty/chromium/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp
2016-07-18 23:24:13 +00:00
@@ -32,7 +32,7 @@
#include "wtf/MathExtras.h"
#include <algorithm>
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
#include <emmintrin.h>
#endif
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -575,7 +575,7 @@
no-sse2 patch: Also fix AudioParamTimeline.cpp in Blink's webaudio src/3rdparty/chromium/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp
2016-07-18 23:24:13 +00:00
// First handle linear and exponential ramps which require looking ahead to the next event.
if (nextEventType == ParamEvent::LinearRampToValue) {
const float valueDelta = value2 - value1;
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
// Minimize in-loop operations. Calculate starting value and increment. Next step: value += inc.
// value = value1 + (currentFrame/sampleRate - time1) * k * (value2 - value1);
// inc = 4 / sampleRate * k * (value2 - value1);
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -738,7 +738,7 @@
no-sse2 patch: Also fix AudioParamTimeline.cpp in Blink's webaudio src/3rdparty/chromium/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp
2016-07-18 23:24:13 +00:00
for (; writeIndex < fillToFrame; ++writeIndex)
values[writeIndex] = target;
} else {
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
// Resolve recursion by expanding constants to achieve a 4-step loop unrolling.
// v1 = v0 + (t - v0) * c
// v2 = v1 + (t - v1) * c
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -843,7 +843,7 @@
no-sse2 patch: Also fix AudioParamTimeline.cpp in Blink's webaudio src/3rdparty/chromium/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp
2016-07-18 23:24:13 +00:00
// Render the stretched curve data using linear interpolation. Oversampled
// curve data can be provided if sharp discontinuities are desired.
unsigned k = 0;
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
const __m128 vCurveVirtualIndex = _mm_set_ps1(curveVirtualIndex);
const __m128 vCurvePointsPerFrame = _mm_set_ps1(curvePointsPerFrame);
const __m128 vNumberOfCurvePointsM1 = _mm_set_ps1(numberOfCurvePoints - 1);
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.cpp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.cpp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.cpp 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.cpp 2017-03-05 18:09:17.132624414 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -26,6 +26,9 @@
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+// include this first to get it before the CPU() function-like macro
+#include "base/cpu.h"
+
#include "platform/audio/DirectConvolver.h"
#if OS(MACOSX)
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -35,22 +38,44 @@
no-sse2.patch: remove -ffloat-store, fix DirectConvolver FTBFS * Remove the -ffloat-store workaround: The media player issue that caused problems with x87 floating point (and ultimately made upstream require SSE2) should already be fixed / worked around by: https://crrev.com/d2c745b13c93ecff5108bed57d8e052126715492 So I will only readd -ffloat-store if people request it, and even then, only to specific parts of code and not everything. * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ DirectConvolver.cpp to not require SSE2 on x86. (No runtime detection, sorry.) * Update the changelog date in the specfile.
2016-01-17 01:34:08 +00:00
#include "platform/audio/VectorMath.h"
#include "wtf/CPU.h"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
-#if (CPU(X86) || CPU(X86_64)) && !OS(MACOSX)
+#if ((CPU(X86) && defined(__SSE2__)) || CPU(X86_64)) && !OS(MACOSX)
no-sse2.patch: remove -ffloat-store, fix DirectConvolver FTBFS * Remove the -ffloat-store workaround: The media player issue that caused problems with x87 floating point (and ultimately made upstream require SSE2) should already be fixed / worked around by: https://crrev.com/d2c745b13c93ecff5108bed57d8e052126715492 So I will only readd -ffloat-store if people request it, and even then, only to specific parts of code and not everything. * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ DirectConvolver.cpp to not require SSE2 on x86. (No runtime detection, sorry.) * Update the changelog date in the specfile.
2016-01-17 01:34:08 +00:00
#include <emmintrin.h>
#endif
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+#if defined(BUILD_ONLY_THE_SSE2_PARTS) && !defined(__SSE2__)
+#error SSE2 parts must be built with -msse2
+#endif
+
namespace blink {
using namespace VectorMath;
+#ifndef BUILD_ONLY_THE_SSE2_PARTS
+
DirectConvolver::DirectConvolver(size_t inputBlockSize)
: m_inputBlockSize(inputBlockSize)
, m_buffer(inputBlockSize * 2)
{
+#if CPU(X86)
+ base::CPU cpu;
+ m_haveSSE2 = cpu.has_sse2();
+#endif
}
+#endif
+
+#ifdef BUILD_ONLY_THE_SSE2_PARTS
+void DirectConvolver::m_processSSE2(AudioFloatArray* convolutionKernel, const float* sourceP, float* destP, size_t framesToProcess)
+#else
void DirectConvolver::process(AudioFloatArray* convolutionKernel, const float* sourceP, float* destP, size_t framesToProcess)
+#endif
{
+#if CPU(X86) && !defined(__SSE2__)
+ if (m_haveSSE2) {
+ m_processSSE2(convolutionKernel, sourceP, destP, framesToProcess);
+ return;
+ }
+#endif
ASSERT(framesToProcess == m_inputBlockSize);
if (framesToProcess != m_inputBlockSize)
return;
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -82,7 +107,7 @@
no-sse2.patch: remove -ffloat-store, fix DirectConvolver FTBFS * Remove the -ffloat-store workaround: The media player issue that caused problems with x87 floating point (and ultimately made upstream require SSE2) should already be fixed / worked around by: https://crrev.com/d2c745b13c93ecff5108bed57d8e052126715492 So I will only readd -ffloat-store if people request it, and even then, only to specific parts of code and not everything. * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ DirectConvolver.cpp to not require SSE2 on x86. (No runtime detection, sorry.) * Update the changelog date in the specfile.
2016-01-17 01:34:08 +00:00
#endif // CPU(X86)
#else
size_t i = 0;
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
// Convolution using SSE2. Currently only do this if both |kernelSize| and |framesToProcess|
// are multiples of 4. If not, use the straightforward loop below.
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -392,7 +417,7 @@
no-sse2.patch: remove -ffloat-store, fix DirectConvolver FTBFS * Remove the -ffloat-store workaround: The media player issue that caused problems with x87 floating point (and ultimately made upstream require SSE2) should already be fixed / worked around by: https://crrev.com/d2c745b13c93ecff5108bed57d8e052126715492 So I will only readd -ffloat-store if people request it, and even then, only to specific parts of code and not everything. * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ DirectConvolver.cpp to not require SSE2 on x86. (No runtime detection, sorry.) * Update the changelog date in the specfile.
2016-01-17 01:34:08 +00:00
}
destP[i++] = sum;
}
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
}
#endif
#endif // OS(MACOSX)
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -401,10 +426,14 @@
memcpy(m_buffer.data(), inputP, sizeof(float) * framesToProcess);
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
}
+#ifndef BUILD_ONLY_THE_SSE2_PARTS
+
void DirectConvolver::reset()
{
m_buffer.zero();
}
+#endif
+
} // namespace blink
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.h qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.h
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.h 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.h 2017-03-05 17:26:26.241985240 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -32,6 +32,7 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
#include "platform/PlatformExport.h"
#include "platform/audio/AudioArray.h"
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#include "wtf/Allocator.h"
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+#include "wtf/CPU.h"
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#include "wtf/Noncopyable.h"
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
namespace blink {
@@ -50,6 +51,11 @@
size_t m_inputBlockSize;
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
AudioFloatArray m_buffer;
+
no-sse2.patch: Fix typos in the patched header files
2016-01-17 04:10:15 +00:00
+#if CPU(X86)
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+ bool m_haveSSE2;
+ void m_processSSE2(AudioFloatArray* convolutionKernel, const float* sourceP, float* destP, size_t framesToProcess);
+#endif
};
} // namespace blink
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolverSSE2.cpp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolverSSE2.cpp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolverSSE2.cpp 1970-01-01 01:00:00.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolverSSE2.cpp 2017-03-05 17:26:26.242985225 +0100
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
@@ -0,0 +1,2 @@
+#define BUILD_ONLY_THE_SSE2_PARTS
+#include "DirectConvolver.cpp"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.cpp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.cpp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.cpp 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.cpp 2017-03-05 17:26:26.242985225 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -26,15 +26,22 @@
* THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+// include this first to get it before the CPU() function-like macro
+#include "base/cpu.h"
+
#include "platform/audio/SincResampler.h"
#include "platform/audio/AudioBus.h"
#include "wtf/CPU.h"
#include "wtf/MathExtras.h"
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
#include <emmintrin.h>
#endif
+#if defined(BUILD_ONLY_THE_SSE2_PARTS) && !defined(__SSE2__)
+#error SSE2 parts must be built with -msse2
+#endif
+
// Input buffer layout, dividing the total buffer into regions (r0 - r5):
//
// |----------------|----------------------------------------------------------------|----------------|
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -64,6 +71,8 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
namespace blink {
+#ifndef BUILD_ONLY_THE_SSE2_PARTS
+
SincResampler::SincResampler(double scaleFactor, unsigned kernelSize, unsigned numberOfKernelOffsets)
: m_scaleFactor(scaleFactor)
, m_kernelSize(kernelSize)
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -77,6 +86,10 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
, m_sourceProvider(nullptr)
, m_isBufferPrimed(false)
{
+#if CPU(X86)
+ base::CPU cpu;
+ m_haveSSE2 = cpu.has_sse2();
+#endif
initializeKernel();
}
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -193,8 +206,20 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
}
}
+#endif
+
+#ifdef BUILD_ONLY_THE_SSE2_PARTS
+void SincResampler::m_processSSE2(AudioSourceProvider* sourceProvider, float* destination, size_t framesToProcess)
+#else
void SincResampler::process(AudioSourceProvider* sourceProvider, float* destination, size_t framesToProcess)
+#endif
{
+#if CPU(X86) && !defined(__SSE2__)
+ if (m_haveSSE2) {
+ m_processSSE2(sourceProvider, destination, framesToProcess);
+ return;
+ }
+#endif
bool isGood = sourceProvider && m_blockSize > m_kernelSize && m_inputBuffer.size() >= m_blockSize + m_kernelSize && !(m_kernelSize % 2);
ASSERT(isGood);
if (!isGood)
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -256,7 +281,7 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
{
float input;
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
// If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed seperately.
while ((reinterpret_cast<uintptr_t>(inputP) & 0x0F) && n) {
CONVOLVE_ONE_SAMPLE
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.h qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.h
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.h 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.h 2017-03-05 17:26:26.305984290 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -33,6 +33,7 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
#include "platform/audio/AudioArray.h"
#include "platform/audio/AudioSourceProvider.h"
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#include "wtf/Allocator.h"
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+#include "wtf/CPU.h"
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#include "wtf/Noncopyable.h"
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
namespace blink {
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -84,6 +85,11 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
// The buffer is primed once at the very beginning of processing.
bool m_isBufferPrimed;
+
no-sse2.patch: Fix typos in the patched header files
2016-01-17 04:10:15 +00:00
+#if CPU(X86)
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+ bool m_haveSSE2;
+ void m_processSSE2(AudioSourceProvider*, float* destination, size_t framesToProcess);
+#endif
};
} // namespace blink
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResamplerSSE2.cpp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResamplerSSE2.cpp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResamplerSSE2.cpp 1970-01-01 01:00:00.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResamplerSSE2.cpp 2017-03-05 17:26:26.305984290 +0100
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
@@ -0,0 +1,2 @@
+#define BUILD_ONLY_THE_SSE2_PARTS
+#include "SincResampler.cpp"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.cpp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.cpp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.cpp 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.cpp 2017-03-05 17:26:26.306984275 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -22,6 +22,9 @@
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+// include this first to get it before the CPU() function-like macro
+#include "base/cpu.h"
+
#include "platform/audio/VectorMath.h"
#include "wtf/Assertions.h"
#include "wtf/CPU.h"
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -32,10 +35,14 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
#include <Accelerate/Accelerate.h>
#endif
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
#include <emmintrin.h>
#endif
+#if defined(BUILD_ONLY_THE_SSE2_PARTS) && !defined(__SSE2__)
+#error SSE2 parts must be built with -msse2
+#endif
+
#if HAVE(ARM_NEON_INTRINSICS)
#include <arm_neon.h>
#endif
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -118,11 +125,25 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
}
#else
+#ifdef BUILD_ONLY_THE_SSE2_PARTS
+namespace SSE2 {
+#endif
+
+#if CPU(X86) && !defined(__SSE2__)
+static base::CPU cpu;
+#endif
+
void vsma(const float* sourceP, int sourceStride, const float* scale, float* destP, int destStride, size_t framesToProcess)
{
+#if CPU(X86) && !defined(__SSE2__)
+ if (cpu.has_sse2()) {
+ blink::VectorMath::SSE2::vsma(sourceP, sourceStride, scale, destP, destStride, framesToProcess);
+ return;
+ }
+#endif
int n = framesToProcess;
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
if ((sourceStride == 1) && (destStride == 1)) {
float k = *scale;
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -193,9 +214,15 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
void vsmul(const float* sourceP, int sourceStride, const float* scale, float* destP, int destStride, size_t framesToProcess)
{
+#if CPU(X86) && !defined(__SSE2__)
+ if (cpu.has_sse2()) {
+ blink::VectorMath::SSE2::vsmul(sourceP, sourceStride, scale, destP, destStride, framesToProcess);
+ return;
+ }
+#endif
int n = framesToProcess;
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
if ((sourceStride == 1) && (destStride == 1)) {
float k = *scale;
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -266,16 +293,22 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
sourceP += sourceStride;
destP += destStride;
}
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
}
#endif
}
void vadd(const float* source1P, int sourceStride1, const float* source2P, int sourceStride2, float* destP, int destStride, size_t framesToProcess)
{
+#if CPU(X86) && !defined(__SSE2__)
+ if (cpu.has_sse2()) {
+ blink::VectorMath::SSE2::vadd(source1P, sourceStride1, source2P, sourceStride2, destP, destStride, framesToProcess);
+ return;
+ }
+#endif
int n = framesToProcess;
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
if ((sourceStride1 ==1) && (sourceStride2 == 1) && (destStride == 1)) {
// If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
while ((reinterpret_cast<size_t>(source1P) & 0x0F) && n) {
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -378,17 +411,23 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
source2P += sourceStride2;
destP += destStride;
}
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
}
#endif
}
void vmul(const float* source1P, int sourceStride1, const float* source2P, int sourceStride2, float* destP, int destStride, size_t framesToProcess)
{
+#if CPU(X86) && !defined(__SSE2__)
+ if (cpu.has_sse2()) {
+ blink::VectorMath::SSE2::vmul(source1P, sourceStride1, source2P, sourceStride2, destP, destStride, framesToProcess);
+ return;
+ }
+#endif
int n = framesToProcess;
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
if ((sourceStride1 == 1) && (sourceStride2 == 1) && (destStride == 1)) {
// If the source1P address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
while ((reinterpret_cast<uintptr_t>(source1P) & 0x0F) && n) {
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -460,8 +499,14 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
void zvmul(const float* real1P, const float* imag1P, const float* real2P, const float* imag2P, float* realDestP, float* imagDestP, size_t framesToProcess)
{
+#if CPU(X86) && !defined(__SSE2__)
+ if (cpu.has_sse2()) {
+ blink::VectorMath::SSE2::zvmul(real1P, imag1P, real2P, imag2P, realDestP, imagDestP, framesToProcess);
+ return;
+ }
+#endif
unsigned i = 0;
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
// Only use the SSE optimization in the very common case that all addresses are 16-byte aligned.
// Otherwise, fall through to the scalar code below.
if (!(reinterpret_cast<uintptr_t>(real1P) & 0x0F)
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -516,10 +561,16 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
void vsvesq(const float* sourceP, int sourceStride, float* sumP, size_t framesToProcess)
{
+#if CPU(X86) && !defined(__SSE2__)
+ if (cpu.has_sse2()) {
+ blink::VectorMath::SSE2::vsvesq(sourceP, sourceStride, sumP, framesToProcess);
+ return;
+ }
+#endif
int n = framesToProcess;
float sum = 0;
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
if (sourceStride == 1) {
// If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
while ((reinterpret_cast<uintptr_t>(sourceP) & 0x0F) && n) {
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -581,10 +632,16 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
void vmaxmgv(const float* sourceP, int sourceStride, float* maxP, size_t framesToProcess)
{
+#if CPU(X86) && !defined(__SSE2__)
+ if (cpu.has_sse2()) {
+ blink::VectorMath::SSE2::vmaxmgv(sourceP, sourceStride, maxP, framesToProcess);
+ return;
+ }
+#endif
int n = framesToProcess;
float max = 0;
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
if (sourceStride == 1) {
// If the sourceP address is not 16-byte aligned, the first several frames (at most three) should be processed separately.
while ((reinterpret_cast<uintptr_t>(sourceP) & 0x0F) && n) {
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -648,6 +705,8 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
*maxP = max;
}
+#ifndef BUILD_ONLY_THE_SSE2_PARTS
+
void vclip(const float* sourceP, int sourceStride, const float* lowThresholdP, const float* highThresholdP, float* destP, int destStride, size_t framesToProcess)
{
int n = framesToProcess;
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -678,6 +737,12 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
}
}
+#endif
+
+#ifdef BUILD_ONLY_THE_SSE2_PARTS
+} // namespace SSE2
+#endif
+
#endif // OS(MACOSX)
} // namespace VectorMath
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.h qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.h
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.h 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.h 2017-03-05 17:26:26.306984275 +0100
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
@@ -26,6 +26,7 @@
#define VectorMath_h
#include "platform/PlatformExport.h"
+#include "wtf/CPU.h"
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
#include "wtf/build_config.h"
#include <cstddef>
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -55,6 +56,28 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
// Copies elements while clipping values to the threshold inputs.
PLATFORM_EXPORT void vclip(const float* sourceP, int sourceStride, const float* lowThresholdP, const float* highThresholdP, float* destP, int destStride, size_t framesToProcess);
no-sse2.patch: Fix typos in the patched header files
2016-01-17 04:10:15 +00:00
+#if CPU(X86)
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+namespace SSE2 {
+// Vector scalar multiply and then add.
+PLATFORM_EXPORT void vsma(const float* sourceP, int sourceStride, const float* scale, float* destP, int destStride, size_t framesToProcess);
+
+PLATFORM_EXPORT void vsmul(const float* sourceP, int sourceStride, const float* scale, float* destP, int destStride, size_t framesToProcess);
+PLATFORM_EXPORT void vadd(const float* source1P, int sourceStride1, const float* source2P, int sourceStride2, float* destP, int destStride, size_t framesToProcess);
+
+// Finds the maximum magnitude of a float vector.
+PLATFORM_EXPORT void vmaxmgv(const float* sourceP, int sourceStride, float* maxP, size_t framesToProcess);
+
+// Sums the squares of a float vector's elements.
+PLATFORM_EXPORT void vsvesq(const float* sourceP, int sourceStride, float* sumP, size_t framesToProcess);
+
+// For an element-by-element multiply of two float vectors.
+PLATFORM_EXPORT void vmul(const float* source1P, int sourceStride1, const float* source2P, int sourceStride2, float* destP, int destStride, size_t framesToProcess);
+
+// Multiplies two complex vectors.
+PLATFORM_EXPORT void zvmul(const float* real1P, const float* imag1P, const float* real2P, const float* imag2P, float* realDestP, float* imagDestP, size_t framesToProcess);
+}
+#endif
+
} // namespace VectorMath
} // namespace blink
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMathSSE2.cpp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMathSSE2.cpp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMathSSE2.cpp 1970-01-01 01:00:00.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMathSSE2.cpp 2017-03-05 17:26:26.307984260 +0100
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
@@ -0,0 +1,2 @@
+#define BUILD_ONLY_THE_SSE2_PARTS
+#include "VectorMath.cpp"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/blink_platform.gyp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/blink_platform.gyp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/blink_platform.gyp 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/blink_platform.gyp 2017-03-05 17:26:26.307984260 +0100
@@ -392,6 +392,11 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
'<(DEPTH)/third_party/openmax_dl/dl/dl.gyp:openmax_dl',
],
}],
+ ['target_arch == "ia32"', {
+ 'dependencies': [
+ 'blink_sse2',
+ ],
+ }],
['target_arch=="arm"', {
'dependencies': [
'blink_arm_neon',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -406,6 +411,36 @@
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
}],
],
},
+ {
+ 'target_name': 'blink_sse2',
+ 'conditions': [
no-sse2.patch: Fix typos * Fix typo in blink_platform.gyp. * Restore the v8 parts that accidentally went missing.
2016-01-17 03:46:25 +00:00
+ ['target_arch=="ia32"', {
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+ 'type': 'static_library',
+ 'dependencies': [
+ '<(DEPTH)/third_party/khronos/khronos.gyp:khronos_headers',
no-sse2.patch: Switch back to gold, blink_platform.gyp fixes * Revert the change to force the BFD ld, that was not the issue. * Make some fixes to my blink_sse2 target in blink_platform.gyp: - add missing dependencies to get the needed feature_defines, - add missing target defines, - add -mfpmath=sse in addition to -msse2 because this is floating-point math and we should definitely not do x87 in the SSE2-optimized versions of the functions.
2016-01-17 21:45:33 +00:00
+ '../config.gyp:config',
+ '../wtf/wtf.gyp:wtf',
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+ 'blink_common',
no-sse2.patch: Switch back to gold, blink_platform.gyp fixes * Revert the change to force the BFD ld, that was not the issue. * Make some fixes to my blink_sse2 target in blink_platform.gyp: - add missing dependencies to get the needed feature_defines, - add missing target defines, - add -mfpmath=sse in addition to -msse2 because this is floating-point math and we should definitely not do x87 in the SSE2-optimized versions of the functions.
2016-01-17 21:45:33 +00:00
+ 'blink_heap_asm_stubs',
+ ],
+ 'defines': [
+ 'BLINK_PLATFORM_IMPLEMENTATION=1',
+ 'INSIDE_BLINK',
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+ ],
+ 'sources': [
+ 'audio/DirectConvolverSSE2.cpp',
+ 'audio/SincResamplerSSE2.cpp',
+ 'audio/VectorMathSSE2.cpp',
+ ],
no-sse2.patch: Switch back to gold, blink_platform.gyp fixes * Revert the change to force the BFD ld, that was not the issue. * Make some fixes to my blink_sse2 target in blink_platform.gyp: - add missing dependencies to get the needed feature_defines, - add missing target defines, - add -mfpmath=sse in addition to -msse2 because this is floating-point math and we should definitely not do x87 in the SSE2-optimized versions of the functions.
2016-01-17 21:45:33 +00:00
+ 'cflags': [
+ '-msse2',
+ '-mfpmath=sse',
+ ],
no-sse2.patch: fix audio/VectorMath and audio/SincResampler FTBFS * Fix src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/ SincResampler.cpp and VectorMath.cpp to not require SSE2 on x86 (including runtime detection). * Also add runtime detection for DirectConvolver.cpp.
2016-01-17 03:30:41 +00:00
+ },{ # target_arch != "ia32"
+ 'type': 'none',
+ }],
+ ],
+ },
# The *NEON.cpp files fail to compile when -mthumb is passed. Force
# them to build in ARM mode.
# See https://bugs.webkit.org/show_bug.cgi?id=62916.
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/cpu/x86/WebGLImageConversionSSE.h qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/cpu/x86/WebGLImageConversionSSE.h
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/cpu/x86/WebGLImageConversionSSE.h 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/cpu/x86/WebGLImageConversionSSE.h 2017-03-05 17:26:26.308984245 +0100
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
@@ -5,7 +5,7 @@
#ifndef WebGLImageConversionSSE_h
#define WebGLImageConversionSSE_h
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
#include <emmintrin.h>
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp 2017-03-05 17:26:26.309984231 +0100
@@ -423,7 +423,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
const uint32_t* source32 = reinterpret_cast_ptr<const uint32_t*>(source);
uint32_t* destination32 = reinterpret_cast_ptr<uint32_t*>(destination);
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
SIMD::unpackOneRowOfBGRA8LittleToRGBA8(source32, destination32, pixelsPerRow);
#endif
for (unsigned i = 0; i < pixelsPerRow; ++i) {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -442,7 +442,7 @@
no-sse2 patch: Fix conditionals in 3 more sections of WebGLImageConversion.cpp
2016-07-18 20:53:48 +00:00
template<> void unpack<WebGLImageConversion::DataFormatRGBA5551, uint16_t, uint8_t>(const uint16_t* source, uint8_t* destination, unsigned pixelsPerRow)
{
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
SIMD::unpackOneRowOfRGBA5551LittleToRGBA8(source, destination, pixelsPerRow);
#endif
#if HAVE(ARM_NEON_INTRINSICS)
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -464,7 +464,7 @@
no-sse2 patch: Fix conditionals in 3 more sections of WebGLImageConversion.cpp
2016-07-18 20:53:48 +00:00
template<> void unpack<WebGLImageConversion::DataFormatRGBA4444, uint16_t, uint8_t>(const uint16_t* source, uint8_t* destination, unsigned pixelsPerRow)
{
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
SIMD::unpackOneRowOfRGBA4444LittleToRGBA8(source, destination, pixelsPerRow);
#endif
#if HAVE(ARM_NEON_INTRINSICS)
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -630,7 +630,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
// FIXME: this routine is lossy and must be removed.
template<> void pack<WebGLImageConversion::DataFormatR8, WebGLImageConversion::AlphaDoUnmultiply, uint8_t, uint8_t>(const uint8_t* source, uint8_t* destination, unsigned pixelsPerRow)
{
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
SIMD::packOneRowOfRGBA8LittleToR8(source, destination, pixelsPerRow);
#endif
for (unsigned i = 0; i < pixelsPerRow; ++i) {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -667,7 +667,7 @@
no-sse2 patch: Fix conditionals in 3 more sections of WebGLImageConversion.cpp
2016-07-18 20:53:48 +00:00
// FIXME: this routine is lossy and must be removed.
template<> void pack<WebGLImageConversion::DataFormatRA8, WebGLImageConversion::AlphaDoUnmultiply, uint8_t, uint8_t>(const uint8_t* source, uint8_t* destination, unsigned pixelsPerRow)
{
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
SIMD::packOneRowOfRGBA8LittleToRA8(source, destination, pixelsPerRow);
#endif
for (unsigned i = 0; i < pixelsPerRow; ++i) {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -741,7 +741,7 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
// FIXME: this routine is lossy and must be removed.
template<> void pack<WebGLImageConversion::DataFormatRGBA8, WebGLImageConversion::AlphaDoUnmultiply, uint8_t, uint8_t>(const uint8_t* source, uint8_t* destination, unsigned pixelsPerRow)
{
-#if CPU(X86) || CPU(X86_64)
+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64)
SIMD::packOneRowOfRGBA8LittleToRGBA8(source, destination, pixelsPerRow);
#else
for (unsigned i = 0; i < pixelsPerRow; ++i) {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/webrtc/common_audio/real_fourier.cc qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/webrtc/common_audio/real_fourier.cc
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/webrtc/common_audio/real_fourier.cc 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/third_party/webrtc/common_audio/real_fourier.cc 2017-03-05 18:14:44.694725685 +0100
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
@@ -14,6 +14,7 @@
#include "webrtc/common_audio/real_fourier_ooura.h"
#include "webrtc/common_audio/real_fourier_openmax.h"
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
#include "webrtc/common_audio/signal_processing/include/signal_processing_library.h"
no-sse2 patch: Fix/update the location of cpu_features_wrapper.h It moved from "webrtc/system_wrappers/interface/cpu_features_wrapper.h" to "webrtc/system_wrappers/include/cpu_features_wrapper.h".
2016-07-18 17:28:55 +00:00
+#include "webrtc/system_wrappers/include/cpu_features_wrapper.h"
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
namespace webrtc {
Fix no-sse2 patch. The patch tool insists on symmetric context for some reason.
2016-02-24 13:08:39 +00:00
@@ -23,7 +24,15 @@
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
std::unique_ptr<RealFourier> RealFourier::Create(int fft_order) {
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#if defined(RTC_USE_OPENMAX_DL)
+#if defined(WEBRTC_ARCH_X86_FAMILY) && !defined(__SSE2__)
+ // x86 CPU detection required.
+ if (WebRtc_GetCPUInfo(kSSE2))
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ return std::unique_ptr<RealFourier>(new RealFourierOpenmax(fft_order));
no-sse2 patch: Fix FFT (RealFourier) in webrtc on non-SSE2 x86 * Tue Feb 23 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.0-0.18.beta - no-sse2 patch: Fix FFT (RealFourier) in webrtc on non-SSE2 x86
2016-02-24 03:50:18 +00:00
+ else
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ return std::unique_ptr<RealFourier>(new RealFourierOoura(fft_order));
no-sse2 patch: Fix FFT (RealFourier) in webrtc on non-SSE2 x86 * Tue Feb 23 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.0-0.18.beta - no-sse2 patch: Fix FFT (RealFourier) in webrtc on non-SSE2 x86
2016-02-24 03:50:18 +00:00
+#else
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
return std::unique_ptr<RealFourier>(new RealFourierOpenmax(fft_order));
no-sse2 patch: Fix FFT (RealFourier) in webrtc on non-SSE2 x86 * Tue Feb 23 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.0-0.18.beta - no-sse2 patch: Fix FFT (RealFourier) in webrtc on non-SSE2 x86
2016-02-24 03:50:18 +00:00
+#endif
Do not require SSE2 on i686 See https://bugzilla.redhat.com/show_bug.cgi?id=1244196#c22 for the history of the patch. Compared to the last revision there (v5): * I fixed WebGLImageConversion.cpp to not assume SSE2 on x86. Unfortunately, it would be really hard to make runtime detection work there, because it uses intrinsics in inline templates, and GCC only supports intrinsics when building the whole code for the vector instruction set. So I had to turn off that SSE2 code entirely when __SSE2__ is not defined at compile time. * I fixed webrtc to check for SSE2 at runtime (using the runtime checking code that webrtc already has and uses in several places) before attempting to use OpenMAX on x86. OpenMAX requires SSE2. So we just fall back to the Ooura implementation of FFTs when needed. TODO: build V8 shared and twice (once for x87, once for SSE2)
2016-01-16 23:17:04 +00:00
#else
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
return std::unique_ptr<RealFourier>(new RealFourierOoura(fft_order));
Fix no-sse2 patch. The patch tool insists on symmetric context for some reason.
2016-02-24 13:08:39 +00:00
#endif
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/tools/gyp/pylib/gyp/generator/ninja.py qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/tools/gyp/pylib/gyp/generator/ninja.py
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/tools/gyp/pylib/gyp/generator/ninja.py 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/tools/gyp/pylib/gyp/generator/ninja.py 2017-03-05 17:26:26.310984216 +0100
@@ -1345,6 +1345,8 @@
no-sse2.patch: Add built .so files to the link line In the long run, we may end up doing this manually because we will need to handle V8 specially in the QMake stuff anyway (install it, ensure we only link the x87 version and let the SSE2 version magically act as a drop-in replacement, add an rpath), but try like this for now.
2016-01-18 02:06:07 +00:00
# Make sure that we have relative paths to our out/(Release|Debug), where we generate our .pri file, and then prepend $$PWD to them.
prefixed_objects = ['$$PWD/' + o for o in toAbsPaths(objects)]
prefixed_archives = ['$$PWD/' + o for o in toAbsPaths(libs)]
+ if len(solibs):
+ prefixed_solibs = ['$$PWD/' + so for so in toAbsPaths(solibs)]
pri_file.write("QMAKE_LFLAGS += %s\n" % qmakeLiteral(' '.join(prefixed_lflags)))
pri_file.write("OBJECTS += %s\n" % qmakeLiteral(' '.join(prefixed_objects)))
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -1353,6 +1355,8 @@
Rebase no-sse2 patch, fix file list - Rebase no-sse2 patch - Update file list for 5.6.0 RC (resources now in resources/ subdirectory) - Tag translations with correct %lang tags
2016-02-25 00:24:47 +00:00
pri_file.write("LIBS_PRIVATE += -Wl,--start-group %s -Wl,--end-group\n" % qmakeLiteral(' '.join(prefixed_archives)))
no-sse2.patch: Add built .so files to the link line In the long run, we may end up doing this manually because we will need to handle V8 specially in the QMake stuff anyway (install it, ensure we only link the x87 version and let the SSE2 version magically act as a drop-in replacement, add an rpath), but try like this for now.
2016-01-18 02:06:07 +00:00
else:
pri_file.write("LIBS_PRIVATE += %s\n" % qmakeLiteral(' '.join(prefixed_archives)))
+ if len(solibs):
+ pri_file.write("LIBS_PRIVATE += %s\n" % qmakeLiteral(' '.join(prefixed_solibs)))
# External libs have to come after objects/archives, the linker resolve them in order.
pri_file.write("LIBS_PRIVATE += %s\n" % qmakeLiteral(' '.join(prefixed_library_dirs + prefixed_libraries)))
# Make sure that if ninja modifies one of the inputs, qmake/make will link again.
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/BUILD.gn qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/v8/BUILD.gn
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/BUILD.gn 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/v8/BUILD.gn 2017-03-05 18:22:29.296777508 +0100
@@ -1523,41 +1523,41 @@
no-sse2.patch: Fix typos * Fix typo in blink_platform.gyp. * Restore the v8 parts that accidentally went missing.
2016-01-17 03:46:25 +00:00
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
if (v8_target_cpu == "x86") {
no-sse2.patch: Fix typos * Fix typo in blink_platform.gyp. * Restore the v8 parts that accidentally went missing.
2016-01-17 03:46:25 +00:00
sources += [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
- "src/compiler/ia32/code-generator-ia32.cc",
- "src/compiler/ia32/instruction-codes-ia32.h",
- "src/compiler/ia32/instruction-scheduler-ia32.cc",
- "src/compiler/ia32/instruction-selector-ia32.cc",
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
- "src/crankshaft/ia32/lithium-codegen-ia32.cc",
- "src/crankshaft/ia32/lithium-codegen-ia32.h",
- "src/crankshaft/ia32/lithium-gap-resolver-ia32.cc",
- "src/crankshaft/ia32/lithium-gap-resolver-ia32.h",
- "src/crankshaft/ia32/lithium-ia32.cc",
- "src/crankshaft/ia32/lithium-ia32.h",
- "src/debug/ia32/debug-ia32.cc",
- "src/full-codegen/ia32/full-codegen-ia32.cc",
no-sse2.patch: Fix typos * Fix typo in blink_platform.gyp. * Restore the v8 parts that accidentally went missing.
2016-01-17 03:46:25 +00:00
- "src/ia32/assembler-ia32-inl.h",
- "src/ia32/assembler-ia32.cc",
- "src/ia32/assembler-ia32.h",
- "src/ia32/builtins-ia32.cc",
- "src/ia32/code-stubs-ia32.cc",
- "src/ia32/code-stubs-ia32.h",
- "src/ia32/codegen-ia32.cc",
- "src/ia32/codegen-ia32.h",
- "src/ia32/cpu-ia32.cc",
- "src/ia32/deoptimizer-ia32.cc",
- "src/ia32/disasm-ia32.cc",
- "src/ia32/frames-ia32.cc",
- "src/ia32/frames-ia32.h",
- "src/ia32/interface-descriptors-ia32.cc",
- "src/ia32/macro-assembler-ia32.cc",
- "src/ia32/macro-assembler-ia32.h",
- "src/ic/ia32/access-compiler-ia32.cc",
- "src/ic/ia32/handler-compiler-ia32.cc",
- "src/ic/ia32/ic-compiler-ia32.cc",
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
- "src/ic/ia32/ic-ia32.cc",
no-sse2.patch: Fix typos * Fix typo in blink_platform.gyp. * Restore the v8 parts that accidentally went missing.
2016-01-17 03:46:25 +00:00
- "src/ic/ia32/stub-cache-ia32.cc",
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
- "src/regexp/ia32/regexp-macro-assembler-ia32.cc",
- "src/regexp/ia32/regexp-macro-assembler-ia32.h",
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ "src/compiler/x87/code-generator-x87.cc",
+ "src/compiler/x87/instruction-codes-x87.h",
+ "src/compiler/x87/instruction-scheduler-x87.cc",
+ "src/compiler/x87/instruction-selector-x87.cc",
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ "src/crankshaft/x87/lithium-codegen-x87.cc",
+ "src/crankshaft/x87/lithium-codegen-x87.h",
+ "src/crankshaft/x87/lithium-gap-resolver-x87.cc",
+ "src/crankshaft/x87/lithium-gap-resolver-x87.h",
+ "src/crankshaft/x87/lithium-x87.cc",
+ "src/crankshaft/x87/lithium-x87.h",
+ "src/debug/x87/debug-x87.cc",
+ "src/full-codegen/x87/full-codegen-x87.cc",
no-sse2.patch: Fix typos * Fix typo in blink_platform.gyp. * Restore the v8 parts that accidentally went missing.
2016-01-17 03:46:25 +00:00
+ "src/x87/assembler-x87-inl.h",
+ "src/x87/assembler-x87.cc",
+ "src/x87/assembler-x87.h",
+ "src/x87/builtins-x87.cc",
+ "src/x87/code-stubs-x87.cc",
+ "src/x87/code-stubs-x87.h",
+ "src/x87/codegen-x87.cc",
+ "src/x87/codegen-x87.h",
+ "src/x87/cpu-x87.cc",
+ "src/x87/deoptimizer-x87.cc",
+ "src/x87/disasm-x87.cc",
+ "src/x87/frames-x87.cc",
+ "src/x87/frames-x87.h",
+ "src/x87/interface-descriptors-x87.cc",
+ "src/x87/macro-assembler-x87.cc",
+ "src/x87/macro-assembler-x87.h",
+ "src/ic/x87/access-compiler-x87.cc",
+ "src/ic/x87/handler-compiler-x87.cc",
+ "src/ic/x87/ic-compiler-x87.cc",
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ "src/ic/x87/ic-x87.cc",
no-sse2.patch: Fix typos * Fix typo in blink_platform.gyp. * Restore the v8 parts that accidentally went missing.
2016-01-17 03:46:25 +00:00
+ "src/ic/x87/stub-cache-x87.cc",
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ "src/regexp/x87/regexp-macro-assembler-x87.cc",
+ "src/regexp/x87/regexp-macro-assembler-x87.h",
no-sse2.patch: Fix typos * Fix typo in blink_platform.gyp. * Restore the v8 parts that accidentally went missing.
2016-01-17 03:46:25 +00:00
]
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
} else if (v8_target_cpu == "x64") {
no-sse2.patch: Fix typos * Fix typo in blink_platform.gyp. * Restore the v8 parts that accidentally went missing.
2016-01-17 03:46:25 +00:00
sources += [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/gypfiles/standalone.gypi qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/v8/gypfiles/standalone.gypi
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/gypfiles/standalone.gypi 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/v8/gypfiles/standalone.gypi 2017-03-05 18:20:24.988636550 +0100
@@ -159,6 +159,9 @@
}, {
'gomadir': '<!(/bin/echo -n ${HOME}/goma)',
}],
+ ['target_arch=="ia32"', {
+ 'v8_target_arch%': 'x87',
+ }],
['host_arch!="ppc" and host_arch!="ppc64" and host_arch!="ppc64le" and host_arch!="s390" and host_arch!="s390x"', {
'host_clang%': 1,
}, {
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/gypfiles/toolchain.gypi qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/v8/gypfiles/toolchain.gypi
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/gypfiles/toolchain.gypi 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/v8/gypfiles/toolchain.gypi 2017-03-05 17:27:34.951965375 +0100
@@ -95,6 +95,9 @@
'binutils_dir%': '',
'conditions': [
+ ['target_arch=="ia32"', {
+ 'v8_target_arch%': 'x87',
+ }],
['OS=="linux" and host_arch=="x64"', {
'binutils_dir%': 'third_party/binutils/Linux_x64/Release/bin',
}],
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/src/make-v8-sse2-gyp.sh qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/v8/src/make-v8-sse2-gyp.sh
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/src/make-v8-sse2-gyp.sh 1970-01-01 01:00:00.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/v8/src/make-v8-sse2-gyp.sh 2017-03-05 17:27:34.953965345 +0100
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
@@ -0,0 +1,56 @@
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+#!/bin/sh
+# This script renames the v8 targets to _sse2 names so that they do not conflict
+# with the non-SSE2 versions.
+
+# Copyright 2016 Kevin Kofler. 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
+# with the distribution.
+# * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived
+# from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+# add comment noting that the file is generated
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+echo "# Generated from v8.gyp by make-v8-sse2-gyp.sh" >v8_sse2.gyp
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+# rename all target names
+SUBTARGETS=`grep "'target_name': '" v8.gyp | sed -e "s/^.*'target_name': '//g" -e "s/',$//g"`
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+SEDS=
+for SUBTARGET in $SUBTARGETS ; do
no-sse2.patch: Fix another error in v8_sse2.gyp (by fixing make-v8-sse2-gyp.sh)
2016-01-19 03:11:36 +00:00
+ SEDS=$SEDS\ -e\ "s/'$SUBTARGET\(['#]\)/'${SUBTARGET}_sse2\1/g"
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+done
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+# in addition:
+# * set v8_target_arch to "ia32" (instead of "x87")
+# * rename all actions
+# * fix mksnapshot_exec to match the renamed target
+# * rename the generated snapshot.cc (but not mksnapshot.cc) to snapshot_sse2.cc
+# * rename the generated *libraries.cc to *libraries_sse2.cc
+# * rename the generated *.bin to *_sse2.bin
+# * set product_name and product_dir for the v8_sse2 target
no-sse2.patch: Fix invalid gyp syntax in v8_sse2.gyp (by fixing make-v8-sse2-gyp.sh)
2016-01-19 02:52:05 +00:00
+sed -e "s/^\( 'variables': {\)/\1\n 'v8_target_arch': 'ia32',/g" \
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ -e "s/\('action_name': '\)/\1v8_sse2_/g" \
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ $SEDS \
+ -e "s/\('mksnapshot_exec': '.*mksnapshot\)/\1_sse2/g" \
+ -e "s#/snapshot\.cc#/snapshot_sse2.cc#g" \
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ -e "s/libraries\.cc/libraries_sse2.cc/g" \
+ -e "s/\.bin/_sse2.bin/g" \
no-sse2.patch: Fix the output path in v8_sse2.gyp (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 04:54:16 +00:00
+ -e "s#^\( *\)\('target_name': 'v8_sse2',\)#\1\2\n\1'product_name': 'v8',\n\1'product_dir': '<(PRODUCT_DIR)/lib/sse2',#g" \
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ v8.gyp >>v8_sse2.gyp
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/src/v8.gyp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/v8/src/v8.gyp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/src/v8.gyp 2017-01-03 10:28:53.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/v8/src/v8.gyp 2017-03-05 17:30:17.500552662 +0100
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -36,6 +36,14 @@
'v8_experimental_extra_library_files%': [],
no-sse2.patch: Build V8 as a shared library on i686 * Mon Jan 18 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.0-0.14.beta.nosse2.1 - Build V8 as a shared library on i686 to allow for swappable backends This is the first prerequisite step towards building both the x87 and SSE2 backends.
2016-01-18 00:10:42 +00:00
'mksnapshot_exec': '<(PRODUCT_DIR)/<(EXECUTABLE_PREFIX)mksnapshot<(EXECUTABLE_SUFFIX)',
'remove_v8base_debug_symbols%': 0,
+ 'conditions': [
+ # build V8 shared on ia32 so we can swap x87 vs. SSE2 builds
+ ['target_arch == "ia32"', {
+ 'v8_component%': 'shared_library',
+ }, {
+ 'v8_component%': '<(component)',
+ }],
+ ],
},
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
'includes': ['../gypfiles/toolchain.gypi', '../gypfiles/features.gypi'],
no-sse2.patch: Build V8 as a shared library on i686 * Mon Jan 18 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.0-0.14.beta.nosse2.1 - Build V8 as a shared library on i686 to allow for swappable backends This is the first prerequisite step towards building both the x87 and SSE2 backends.
2016-01-18 00:10:42 +00:00
'targets': [
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -49,8 +57,8 @@
no-sse2.patch: Build V8 as a shared library on i686 * Mon Jan 18 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.0-0.14.beta.nosse2.1 - Build V8 as a shared library on i686 to allow for swappable backends This is the first prerequisite step towards building both the x87 and SSE2 backends.
2016-01-18 00:10:42 +00:00
}, {
'toolsets': ['target'],
}],
- ['component=="shared_library"', {
- 'type': '<(component)',
+ ['v8_component=="shared_library"', {
+ 'type': '<(v8_component)',
'sources': [
# Note: on non-Windows we still build this file so that gyp
# has some sources to link into the component.
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
@@ -161,7 +169,7 @@
no-sse2.patch: Build V8 as a shared library on i686 * Mon Jan 18 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.0-0.14.beta.nosse2.1 - Build V8 as a shared library on i686 to allow for swappable backends This is the first prerequisite step towards building both the x87 and SSE2 backends.
2016-01-18 00:10:42 +00:00
'js2c',
],
}],
- ['component=="shared_library"', {
+ ['v8_component=="shared_library"', {
'defines': [
'V8_SHARED',
'BUILDING_V8_SHARED',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -253,7 +261,7 @@
no-sse2.patch: Build V8 as a shared library on i686 * Mon Jan 18 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.0-0.14.beta.nosse2.1 - Build V8 as a shared library on i686 to allow for swappable backends This is the first prerequisite step towards building both the x87 and SSE2 backends.
2016-01-18 00:10:42 +00:00
'toolsets': ['target'],
'dependencies': ['js2c'],
}],
- ['component=="shared_library"', {
+ ['v8_component=="shared_library"', {
'defines': [
'BUILDING_V8_SHARED',
'V8_SHARED',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -281,7 +289,7 @@
no-sse2.patch: Build V8 as a shared library on i686 * Mon Jan 18 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.0-0.14.beta.nosse2.1 - Build V8 as a shared library on i686 to allow for swappable backends This is the first prerequisite step towards building both the x87 and SSE2 backends.
2016-01-18 00:10:42 +00:00
'natives_blob',
],
}],
- ['component=="shared_library"', {
+ ['v8_component=="shared_library"', {
'defines': [
'V8_SHARED',
'BUILDING_V8_SHARED',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -1608,7 +1616,7 @@
no-sse2.patch: Build V8 as a shared library on i686 * Mon Jan 18 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.0-0.14.beta.nosse2.1 - Build V8 as a shared library on i686 to allow for swappable backends This is the first prerequisite step towards building both the x87 and SSE2 backends.
2016-01-18 00:10:42 +00:00
# See http://crbug.com/485155.
'msvs_shard': 4,
}],
- ['component=="shared_library"', {
+ ['v8_component=="shared_library"', {
'defines': [
'BUILDING_V8_SHARED',
'V8_SHARED',
Revert "adjust sse2 patch to use src/3rdparty/chromium/v8/src/v8_sse2.gyp location instead" This reverts commit 859bcea06035e9881438601e34e662fa86fd85ee. The file must not be moved back, the outdated reference to the old location must be fixed instead.
2017-03-31 00:50:27 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/src/v8_sse2.gyp qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/v8/src/v8_sse2.gyp
--- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/src/v8_sse2.gyp 1970-01-01 01:00:00.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/3rdparty/chromium/v8/src/v8_sse2.gyp 2017-03-05 18:25:37.781958850 +0100
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -0,0 +1,2313 @@
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+# Generated from v8.gyp by make-v8-sse2-gyp.sh
+# 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
+# with the distribution.
+# * Neither the name of Google Inc. nor the names of its
+# contributors may be used to endorse or promote products derived
+# from this software without specific prior written permission.
+#
+# THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+# "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+# LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+# A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+# OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+# SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+# LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+# DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+# THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+# (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+# OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+{
+ 'variables': {
no-sse2.patch: Fix invalid gyp syntax in v8_sse2.gyp (by fixing make-v8-sse2-gyp.sh)
2016-01-19 02:52:05 +00:00
+ 'v8_target_arch': 'ia32',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'v8_code': 1,
+ 'v8_random_seed%': 314159265,
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ 'v8_vector_stores%': 0,
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'embed_script%': "",
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'warmup_script%': "",
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'v8_extra_library_files%': [],
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ 'v8_experimental_extra_library_files%': [],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'mksnapshot_exec': '<(PRODUCT_DIR)/<(EXECUTABLE_PREFIX)mksnapshot_sse2<(EXECUTABLE_SUFFIX)',
+ 'remove_v8base_debug_symbols%': 0,
+ 'conditions': [
+ # build V8 shared on ia32 so we can swap x87 vs. SSE2 builds
+ ['target_arch == "ia32"', {
+ 'v8_component%': 'shared_library',
+ }, {
+ 'v8_component%': '<(component)',
+ }],
+ ],
+ },
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'includes': ['../gypfiles/toolchain.gypi', '../gypfiles/features.gypi'],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'targets': [
+ {
no-sse2.patch: Fix invalid gyp syntax in v8_sse2.gyp (by fixing make-v8-sse2-gyp.sh)
2016-01-19 02:52:05 +00:00
+ 'target_name': 'v8_sse2',
+ 'product_name': 'v8',
no-sse2.patch: Fix the output path in v8_sse2.gyp (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 04:54:16 +00:00
+ 'product_dir': '<(PRODUCT_DIR)/lib/sse2',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'dependencies_traverse': 1,
+ 'dependencies': ['v8_maybe_snapshot_sse2'],
+ 'conditions': [
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host', 'target'],
+ }, {
+ 'toolsets': ['target'],
+ }],
+ ['v8_component=="shared_library"', {
+ 'type': '<(v8_component)',
+ 'sources': [
+ # Note: on non-Windows we still build this file so that gyp
+ # has some sources to link into the component.
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'v8dll-main.cc',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'include_dirs': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '..',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'defines': [
+ 'V8_SHARED',
+ 'BUILDING_V8_SHARED',
+ ],
+ 'direct_dependent_settings': {
+ 'defines': [
+ 'V8_SHARED',
+ 'USING_V8_SHARED',
+ ],
+ },
+ 'target_conditions': [
+ ['OS=="android" and _toolset=="target"', {
+ 'libraries': [
+ '-llog',
+ ],
+ 'include_dirs': [
+ 'src/common/android/include',
+ ],
+ }],
+ ],
+ 'conditions': [
+ ['OS=="mac"', {
+ 'xcode_settings': {
+ 'OTHER_LDFLAGS': ['-dynamiclib', '-all_load']
+ },
+ }],
+ ['soname_version!=""', {
+ 'product_extension': 'so.<(soname_version)',
+ }],
+ ],
+ },
+ {
+ 'type': 'none',
+ }],
+ ],
+ 'direct_dependent_settings': {
+ 'include_dirs': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../include',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ },
+ },
+ {
+ # This rule delegates to either v8_snapshot, v8_nosnapshot, or
+ # v8_external_snapshot, depending on the current variables.
+ # The intention is to make the 'calling' rules a bit simpler.
+ 'target_name': 'v8_maybe_snapshot_sse2',
+ 'type': 'none',
+ 'conditions': [
+ ['v8_use_snapshot!="true"', {
+ # The dependency on v8_base should come from a transitive
+ # dependency however the Android toolchain requires libv8_base.a
+ # to appear before libv8_snapshot.a so it's listed explicitly.
+ 'dependencies': ['v8_base_sse2', 'v8_nosnapshot_sse2'],
+ }],
+ ['v8_use_snapshot=="true" and v8_use_external_startup_data==0', {
+ # The dependency on v8_base should come from a transitive
+ # dependency however the Android toolchain requires libv8_base.a
+ # to appear before libv8_snapshot.a so it's listed explicitly.
+ 'dependencies': ['v8_base_sse2', 'v8_snapshot_sse2'],
+ }],
+ ['v8_use_snapshot=="true" and v8_use_external_startup_data==1 and want_separate_host_toolset==0', {
+ 'dependencies': ['v8_base_sse2', 'v8_external_snapshot_sse2'],
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'inputs': [ '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', ],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ }],
+ ['v8_use_snapshot=="true" and v8_use_external_startup_data==1 and want_separate_host_toolset==1', {
+ 'dependencies': ['v8_base_sse2', 'v8_external_snapshot_sse2'],
+ 'target_conditions': [
+ ['_toolset=="host"', {
+ 'inputs': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(PRODUCT_DIR)/snapshot_blob_host_sse2.bin',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }, {
+ 'inputs': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(PRODUCT_DIR)/snapshot_blob_sse2.bin',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ],
+ }],
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host', 'target'],
+ }, {
+ 'toolsets': ['target'],
+ }],
+ ]
+ },
+ {
+ 'target_name': 'v8_snapshot_sse2',
+ 'type': 'static_library',
+ 'conditions': [
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host', 'target'],
+ 'dependencies': [
no-sse2.patch: Fix another error in v8_sse2.gyp (by fixing make-v8-sse2-gyp.sh)
2016-01-19 03:11:36 +00:00
+ 'mksnapshot_sse2#host',
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'js2c_sse2#host',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }, {
+ 'toolsets': ['target'],
+ 'dependencies': [
+ 'mksnapshot_sse2',
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'js2c_sse2',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['v8_component=="shared_library"', {
+ 'defines': [
+ 'V8_SHARED',
+ 'BUILDING_V8_SHARED',
+ ],
+ 'direct_dependent_settings': {
+ 'defines': [
+ 'V8_SHARED',
+ 'USING_V8_SHARED',
+ ],
+ },
+ }],
+ ],
+ 'dependencies': [
+ 'v8_base_sse2',
+ ],
+ 'include_dirs+': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '..',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'sources': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/libraries_sse2.cc',
+ '<(SHARED_INTERMEDIATE_DIR)/experimental-libraries_sse2.cc',
+ '<(SHARED_INTERMEDIATE_DIR)/extras-libraries_sse2.cc',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/experimental-extras-libraries_sse2.cc',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ '<(INTERMEDIATE_DIR)/snapshot_sse2.cc',
+ ],
+ 'actions': [
+ {
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'action_name': 'v8_sse2_run_mksnapshot',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'inputs': [
+ '<(mksnapshot_exec)',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ ],
+ 'conditions': [
+ ['embed_script!=""', {
+ 'inputs': [
+ '<(embed_script)',
+ ],
+ }],
+ ['warmup_script!=""', {
+ 'inputs': [
+ '<(warmup_script)',
+ ],
+ }],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'outputs': [
+ '<(INTERMEDIATE_DIR)/snapshot_sse2.cc',
+ ],
+ 'variables': {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'mksnapshot_flags': [],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'conditions': [
+ ['v8_random_seed!=0', {
+ 'mksnapshot_flags': ['--random-seed', '<(v8_random_seed)'],
+ }],
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ ['v8_vector_stores!=0', {
+ 'mksnapshot_flags': ['--vector-stores'],
+ }],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ },
+ 'action': [
+ '<(mksnapshot_exec)',
+ '<@(mksnapshot_flags)',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '--startup_src', '<@(INTERMEDIATE_DIR)/snapshot_sse2.cc',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ '<(embed_script)',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '<(warmup_script)',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ },
+ ],
+ },
+ {
+ 'target_name': 'v8_nosnapshot_sse2',
+ 'type': 'static_library',
+ 'dependencies': [
+ 'v8_base_sse2',
+ ],
+ 'include_dirs+': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '..',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'sources': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/libraries_sse2.cc',
+ '<(SHARED_INTERMEDIATE_DIR)/experimental-libraries_sse2.cc',
+ '<(SHARED_INTERMEDIATE_DIR)/extras-libraries_sse2.cc',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/experimental-extras-libraries_sse2.cc',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'snapshot/snapshot-empty.cc',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'conditions': [
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host', 'target'],
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'dependencies': ['js2c_sse2#host'],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ }, {
+ 'toolsets': ['target'],
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'dependencies': ['js2c_sse2'],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ }],
+ ['v8_component=="shared_library"', {
+ 'defines': [
+ 'BUILDING_V8_SHARED',
+ 'V8_SHARED',
+ ],
+ }],
+ ]
+ },
+ {
+ 'target_name': 'v8_external_snapshot_sse2',
+ 'type': 'static_library',
+ 'conditions': [
+ [ 'v8_use_external_startup_data==1', {
+ 'conditions': [
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host', 'target'],
+ 'dependencies': [
no-sse2.patch: Fix another error in v8_sse2.gyp (by fixing make-v8-sse2-gyp.sh)
2016-01-19 03:11:36 +00:00
+ 'mksnapshot_sse2#host',
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'js2c_sse2#host',
+ 'natives_blob_sse2',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ]}, {
+ 'toolsets': ['target'],
+ 'dependencies': [
+ 'mksnapshot_sse2',
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'js2c_sse2',
+ 'natives_blob_sse2',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['v8_component=="shared_library"', {
+ 'defines': [
+ 'V8_SHARED',
+ 'BUILDING_V8_SHARED',
+ ],
+ 'direct_dependent_settings': {
+ 'defines': [
+ 'V8_SHARED',
+ 'USING_V8_SHARED',
+ ],
+ },
+ }],
+ ],
+ 'dependencies': [
+ 'v8_base_sse2',
+ ],
+ 'include_dirs+': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '..',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'snapshot/natives-external.cc',
+ 'snapshot/snapshot-external.cc',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'actions': [
+ {
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'action_name': 'v8_sse2_run_mksnapshot (external)',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'inputs': [
+ '<(mksnapshot_exec)',
+ ],
+ 'variables': {
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'mksnapshot_flags': [],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'conditions': [
+ ['v8_random_seed!=0', {
+ 'mksnapshot_flags': ['--random-seed', '<(v8_random_seed)'],
+ }],
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ ['v8_vector_stores!=0', {
+ 'mksnapshot_flags': ['--vector-stores'],
+ }],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ },
+ 'conditions': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ ['embed_script!=""', {
+ 'inputs': [
+ '<(embed_script)',
+ ],
+ }],
+ ['warmup_script!=""', {
+ 'inputs': [
+ '<(warmup_script)',
+ ],
+ }],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ['want_separate_host_toolset==1', {
+ 'target_conditions': [
+ ['_toolset=="host"', {
+ 'outputs': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(PRODUCT_DIR)/snapshot_blob_host_sse2.bin',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'action': [
+ '<(mksnapshot_exec)',
+ '<@(mksnapshot_flags)',
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '--startup_blob', '<(PRODUCT_DIR)/snapshot_blob_host_sse2.bin',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ '<(embed_script)',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '<(warmup_script)',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }, {
+ 'outputs': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(PRODUCT_DIR)/snapshot_blob_sse2.bin',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'action': [
+ '<(mksnapshot_exec)',
+ '<@(mksnapshot_flags)',
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '--startup_blob', '<(PRODUCT_DIR)/snapshot_blob_sse2.bin',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ '<(embed_script)',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '<(warmup_script)',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ],
+ }, {
+ 'outputs': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(PRODUCT_DIR)/snapshot_blob_sse2.bin',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'action': [
+ '<(mksnapshot_exec)',
+ '<@(mksnapshot_flags)',
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '--startup_blob', '<(PRODUCT_DIR)/snapshot_blob_sse2.bin',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ '<(embed_script)',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '<(warmup_script)',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ],
+ },
+ ],
+ }],
+ ],
+ },
+ {
+ 'target_name': 'v8_base_sse2',
+ 'type': 'static_library',
+ 'dependencies': [
+ 'v8_libbase_sse2',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'v8_libsampler_sse2',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'variables': {
+ 'optimize': 'max',
+ },
+ 'include_dirs+': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '..',
+ '<(DEPTH)',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'sources': [ ### gcmole(all) ###
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../include/v8-debug.h',
+ '../include/v8-experimental.h',
+ '../include/v8-platform.h',
+ '../include/v8-profiler.h',
+ '../include/v8-testing.h',
+ '../include/v8-util.h',
+ '../include/v8-version.h',
+ '../include/v8.h',
+ '../include/v8config.h',
+ 'accessors.cc',
+ 'accessors.h',
+ 'address-map.cc',
+ 'address-map.h',
+ 'allocation.cc',
+ 'allocation.h',
+ 'allocation-site-scopes.cc',
+ 'allocation-site-scopes.h',
+ 'api-experimental.cc',
+ 'api-experimental.h',
+ 'api.cc',
+ 'api.h',
+ 'api-arguments-inl.h',
+ 'api-arguments.cc',
+ 'api-arguments.h',
+ 'api-natives.cc',
+ 'api-natives.h',
+ 'arguments.cc',
+ 'arguments.h',
+ 'assembler.cc',
+ 'assembler.h',
+ 'assert-scope.h',
+ 'assert-scope.cc',
+ 'ast/ast-expression-rewriter.cc',
+ 'ast/ast-expression-rewriter.h',
+ 'ast/ast-expression-visitor.cc',
+ 'ast/ast-expression-visitor.h',
+ 'ast/ast-literal-reindexer.cc',
+ 'ast/ast-literal-reindexer.h',
+ 'ast/ast-numbering.cc',
+ 'ast/ast-numbering.h',
+ 'ast/ast-type-bounds.h',
+ 'ast/ast-value-factory.cc',
+ 'ast/ast-value-factory.h',
+ 'ast/ast.cc',
+ 'ast/ast.h',
+ 'ast/modules.cc',
+ 'ast/modules.h',
+ 'ast/prettyprinter.cc',
+ 'ast/prettyprinter.h',
+ 'ast/scopeinfo.cc',
+ 'ast/scopeinfo.h',
+ 'ast/scopes.cc',
+ 'ast/scopes.h',
+ 'ast/variables.cc',
+ 'ast/variables.h',
+ 'background-parsing-task.cc',
+ 'background-parsing-task.h',
+ 'bailout-reason.cc',
+ 'bailout-reason.h',
+ 'basic-block-profiler.cc',
+ 'basic-block-profiler.h',
+ 'bignum-dtoa.cc',
+ 'bignum-dtoa.h',
+ 'bignum.cc',
+ 'bignum.h',
+ 'bit-vector.cc',
+ 'bit-vector.h',
+ 'bootstrapper.cc',
+ 'bootstrapper.h',
+ 'builtins.cc',
+ 'builtins.h',
+ 'cached-powers.cc',
+ 'cached-powers.h',
+ 'cancelable-task.cc',
+ 'cancelable-task.h',
+ 'char-predicates.cc',
+ 'char-predicates-inl.h',
+ 'char-predicates.h',
+ 'checks.h',
+ 'code-events.h',
+ 'code-factory.cc',
+ 'code-factory.h',
+ 'code-stub-assembler.cc',
+ 'code-stub-assembler.h',
+ 'code-stubs.cc',
+ 'code-stubs.h',
+ 'code-stubs-hydrogen.cc',
+ 'codegen.cc',
+ 'codegen.h',
+ 'collector.h',
+ 'compilation-cache.cc',
+ 'compilation-cache.h',
+ 'compilation-dependencies.cc',
+ 'compilation-dependencies.h',
+ 'compilation-statistics.cc',
+ 'compilation-statistics.h',
+ 'compiler/access-builder.cc',
+ 'compiler/access-builder.h',
+ 'compiler/access-info.cc',
+ 'compiler/access-info.h',
+ 'compiler/all-nodes.cc',
+ 'compiler/all-nodes.h',
+ 'compiler/ast-graph-builder.cc',
+ 'compiler/ast-graph-builder.h',
+ 'compiler/ast-loop-assignment-analyzer.cc',
+ 'compiler/ast-loop-assignment-analyzer.h',
+ 'compiler/basic-block-instrumentor.cc',
+ 'compiler/basic-block-instrumentor.h',
+ 'compiler/branch-elimination.cc',
+ 'compiler/branch-elimination.h',
+ 'compiler/bytecode-branch-analysis.cc',
+ 'compiler/bytecode-branch-analysis.h',
+ 'compiler/bytecode-graph-builder.cc',
+ 'compiler/bytecode-graph-builder.h',
+ 'compiler/c-linkage.cc',
+ 'compiler/checkpoint-elimination.cc',
+ 'compiler/checkpoint-elimination.h',
+ 'compiler/code-generator-impl.h',
+ 'compiler/code-generator.cc',
+ 'compiler/code-generator.h',
+ 'compiler/code-assembler.cc',
+ 'compiler/code-assembler.h',
+ 'compiler/common-node-cache.cc',
+ 'compiler/common-node-cache.h',
+ 'compiler/common-operator-reducer.cc',
+ 'compiler/common-operator-reducer.h',
+ 'compiler/common-operator.cc',
+ 'compiler/common-operator.h',
+ 'compiler/control-builders.cc',
+ 'compiler/control-builders.h',
+ 'compiler/control-equivalence.cc',
+ 'compiler/control-equivalence.h',
+ 'compiler/control-flow-optimizer.cc',
+ 'compiler/control-flow-optimizer.h',
+ 'compiler/dead-code-elimination.cc',
+ 'compiler/dead-code-elimination.h',
+ 'compiler/diamond.h',
+ 'compiler/effect-control-linearizer.cc',
+ 'compiler/effect-control-linearizer.h',
+ 'compiler/escape-analysis.cc',
+ 'compiler/escape-analysis.h',
+ "compiler/escape-analysis-reducer.cc",
+ "compiler/escape-analysis-reducer.h",
+ 'compiler/frame.cc',
+ 'compiler/frame.h',
+ 'compiler/frame-elider.cc',
+ 'compiler/frame-elider.h',
+ "compiler/frame-states.cc",
+ "compiler/frame-states.h",
+ 'compiler/gap-resolver.cc',
+ 'compiler/gap-resolver.h',
+ 'compiler/graph-reducer.cc',
+ 'compiler/graph-reducer.h',
+ 'compiler/graph-replay.cc',
+ 'compiler/graph-replay.h',
+ 'compiler/graph-trimmer.cc',
+ 'compiler/graph-trimmer.h',
+ 'compiler/graph-visualizer.cc',
+ 'compiler/graph-visualizer.h',
+ 'compiler/graph.cc',
+ 'compiler/graph.h',
+ 'compiler/instruction-codes.h',
+ 'compiler/instruction-selector-impl.h',
+ 'compiler/instruction-selector.cc',
+ 'compiler/instruction-selector.h',
+ 'compiler/instruction-scheduler.cc',
+ 'compiler/instruction-scheduler.h',
+ 'compiler/instruction.cc',
+ 'compiler/instruction.h',
+ 'compiler/int64-lowering.cc',
+ 'compiler/int64-lowering.h',
+ 'compiler/js-builtin-reducer.cc',
+ 'compiler/js-builtin-reducer.h',
+ 'compiler/js-call-reducer.cc',
+ 'compiler/js-call-reducer.h',
+ 'compiler/js-context-specialization.cc',
+ 'compiler/js-context-specialization.h',
+ 'compiler/js-create-lowering.cc',
+ 'compiler/js-create-lowering.h',
+ 'compiler/js-frame-specialization.cc',
+ 'compiler/js-frame-specialization.h',
+ 'compiler/js-generic-lowering.cc',
+ 'compiler/js-generic-lowering.h',
+ 'compiler/js-global-object-specialization.cc',
+ 'compiler/js-global-object-specialization.h',
+ 'compiler/js-graph.cc',
+ 'compiler/js-graph.h',
+ 'compiler/js-inlining.cc',
+ 'compiler/js-inlining.h',
+ 'compiler/js-inlining-heuristic.cc',
+ 'compiler/js-inlining-heuristic.h',
+ 'compiler/js-intrinsic-lowering.cc',
+ 'compiler/js-intrinsic-lowering.h',
+ 'compiler/js-native-context-specialization.cc',
+ 'compiler/js-native-context-specialization.h',
+ 'compiler/js-operator.cc',
+ 'compiler/js-operator.h',
+ 'compiler/js-typed-lowering.cc',
+ 'compiler/js-typed-lowering.h',
+ 'compiler/jump-threading.cc',
+ 'compiler/jump-threading.h',
+ 'compiler/linkage.cc',
+ 'compiler/linkage.h',
+ 'compiler/liveness-analyzer.cc',
+ 'compiler/liveness-analyzer.h',
+ 'compiler/live-range-separator.cc',
+ 'compiler/live-range-separator.h',
+ 'compiler/load-elimination.cc',
+ 'compiler/load-elimination.h',
+ 'compiler/loop-analysis.cc',
+ 'compiler/loop-analysis.h',
+ 'compiler/loop-peeling.cc',
+ 'compiler/loop-peeling.h',
+ 'compiler/machine-operator-reducer.cc',
+ 'compiler/machine-operator-reducer.h',
+ 'compiler/machine-operator.cc',
+ 'compiler/machine-operator.h',
+ 'compiler/memory-optimizer.cc',
+ 'compiler/memory-optimizer.h',
+ 'compiler/move-optimizer.cc',
+ 'compiler/move-optimizer.h',
+ 'compiler/node-aux-data.h',
+ 'compiler/node-cache.cc',
+ 'compiler/node-cache.h',
+ 'compiler/node-marker.cc',
+ 'compiler/node-marker.h',
+ 'compiler/node-matchers.cc',
+ 'compiler/node-matchers.h',
+ 'compiler/node-properties.cc',
+ 'compiler/node-properties.h',
+ 'compiler/node.cc',
+ 'compiler/node.h',
+ 'compiler/opcodes.cc',
+ 'compiler/opcodes.h',
+ 'compiler/operation-typer.cc',
+ 'compiler/operation-typer.h',
+ 'compiler/operator-properties.cc',
+ 'compiler/operator-properties.h',
+ 'compiler/operator.cc',
+ 'compiler/operator.h',
+ 'compiler/osr.cc',
+ 'compiler/osr.h',
+ 'compiler/pipeline.cc',
+ 'compiler/pipeline.h',
+ 'compiler/pipeline-statistics.cc',
+ 'compiler/pipeline-statistics.h',
+ 'compiler/raw-machine-assembler.cc',
+ 'compiler/raw-machine-assembler.h',
+ 'compiler/redundancy-elimination.cc',
+ 'compiler/redundancy-elimination.h',
+ 'compiler/register-allocator.cc',
+ 'compiler/register-allocator.h',
+ 'compiler/register-allocator-verifier.cc',
+ 'compiler/register-allocator-verifier.h',
+ 'compiler/representation-change.cc',
+ 'compiler/representation-change.h',
+ 'compiler/schedule.cc',
+ 'compiler/schedule.h',
+ 'compiler/scheduler.cc',
+ 'compiler/scheduler.h',
+ 'compiler/select-lowering.cc',
+ 'compiler/select-lowering.h',
+ 'compiler/simplified-lowering.cc',
+ 'compiler/simplified-lowering.h',
+ 'compiler/simplified-operator-reducer.cc',
+ 'compiler/simplified-operator-reducer.h',
+ 'compiler/simplified-operator.cc',
+ 'compiler/simplified-operator.h',
+ 'compiler/source-position.cc',
+ 'compiler/source-position.h',
+ 'compiler/state-values-utils.cc',
+ 'compiler/state-values-utils.h',
+ 'compiler/store-store-elimination.cc',
+ 'compiler/store-store-elimination.h',
+ 'compiler/tail-call-optimization.cc',
+ 'compiler/tail-call-optimization.h',
+ 'compiler/type-hint-analyzer.cc',
+ 'compiler/type-hint-analyzer.h',
+ 'compiler/type-hints.cc',
+ 'compiler/type-hints.h',
+ 'compiler/typer.cc',
+ 'compiler/typer.h',
+ 'compiler/value-numbering-reducer.cc',
+ 'compiler/value-numbering-reducer.h',
+ 'compiler/verifier.cc',
+ 'compiler/verifier.h',
+ 'compiler/wasm-compiler.cc',
+ 'compiler/wasm-compiler.h',
+ 'compiler/wasm-linkage.cc',
+ 'compiler/zone-pool.cc',
+ 'compiler/zone-pool.h',
+ 'compiler.cc',
+ 'compiler.h',
+ 'context-measure.cc',
+ 'context-measure.h',
+ 'contexts-inl.h',
+ 'contexts.cc',
+ 'contexts.h',
+ 'conversions-inl.h',
+ 'conversions.cc',
+ 'conversions.h',
+ 'counters-inl.h',
+ 'counters.cc',
+ 'counters.h',
+ 'crankshaft/compilation-phase.cc',
+ 'crankshaft/compilation-phase.h',
+ 'crankshaft/hydrogen-alias-analysis.h',
+ 'crankshaft/hydrogen-bce.cc',
+ 'crankshaft/hydrogen-bce.h',
+ 'crankshaft/hydrogen-canonicalize.cc',
+ 'crankshaft/hydrogen-canonicalize.h',
+ 'crankshaft/hydrogen-check-elimination.cc',
+ 'crankshaft/hydrogen-check-elimination.h',
+ 'crankshaft/hydrogen-dce.cc',
+ 'crankshaft/hydrogen-dce.h',
+ 'crankshaft/hydrogen-dehoist.cc',
+ 'crankshaft/hydrogen-dehoist.h',
+ 'crankshaft/hydrogen-environment-liveness.cc',
+ 'crankshaft/hydrogen-environment-liveness.h',
+ 'crankshaft/hydrogen-escape-analysis.cc',
+ 'crankshaft/hydrogen-escape-analysis.h',
+ 'crankshaft/hydrogen-flow-engine.h',
+ 'crankshaft/hydrogen-gvn.cc',
+ 'crankshaft/hydrogen-gvn.h',
+ 'crankshaft/hydrogen-infer-representation.cc',
+ 'crankshaft/hydrogen-infer-representation.h',
+ 'crankshaft/hydrogen-infer-types.cc',
+ 'crankshaft/hydrogen-infer-types.h',
+ 'crankshaft/hydrogen-instructions.cc',
+ 'crankshaft/hydrogen-instructions.h',
+ 'crankshaft/hydrogen-load-elimination.cc',
+ 'crankshaft/hydrogen-load-elimination.h',
+ 'crankshaft/hydrogen-mark-deoptimize.cc',
+ 'crankshaft/hydrogen-mark-deoptimize.h',
+ 'crankshaft/hydrogen-mark-unreachable.cc',
+ 'crankshaft/hydrogen-mark-unreachable.h',
+ 'crankshaft/hydrogen-osr.cc',
+ 'crankshaft/hydrogen-osr.h',
+ 'crankshaft/hydrogen-range-analysis.cc',
+ 'crankshaft/hydrogen-range-analysis.h',
+ 'crankshaft/hydrogen-redundant-phi.cc',
+ 'crankshaft/hydrogen-redundant-phi.h',
+ 'crankshaft/hydrogen-removable-simulates.cc',
+ 'crankshaft/hydrogen-removable-simulates.h',
+ 'crankshaft/hydrogen-representation-changes.cc',
+ 'crankshaft/hydrogen-representation-changes.h',
+ 'crankshaft/hydrogen-sce.cc',
+ 'crankshaft/hydrogen-sce.h',
+ 'crankshaft/hydrogen-store-elimination.cc',
+ 'crankshaft/hydrogen-store-elimination.h',
+ 'crankshaft/hydrogen-types.cc',
+ 'crankshaft/hydrogen-types.h',
+ 'crankshaft/hydrogen-uint32-analysis.cc',
+ 'crankshaft/hydrogen-uint32-analysis.h',
+ 'crankshaft/hydrogen.cc',
+ 'crankshaft/hydrogen.h',
+ 'crankshaft/lithium-allocator-inl.h',
+ 'crankshaft/lithium-allocator.cc',
+ 'crankshaft/lithium-allocator.h',
+ 'crankshaft/lithium-codegen.cc',
+ 'crankshaft/lithium-codegen.h',
+ 'crankshaft/lithium.cc',
+ 'crankshaft/lithium.h',
+ 'crankshaft/lithium-inl.h',
+ 'crankshaft/typing.cc',
+ 'crankshaft/typing.h',
+ 'crankshaft/unique.h',
+ 'date.cc',
+ 'date.h',
+ 'dateparser-inl.h',
+ 'dateparser.cc',
+ 'dateparser.h',
+ 'debug/debug-evaluate.cc',
+ 'debug/debug-evaluate.h',
+ 'debug/debug-frames.cc',
+ 'debug/debug-frames.h',
+ 'debug/debug-scopes.cc',
+ 'debug/debug-scopes.h',
+ 'debug/debug.cc',
+ 'debug/debug.h',
+ 'debug/liveedit.cc',
+ 'debug/liveedit.h',
+ 'deoptimizer.cc',
+ 'deoptimizer.h',
+ 'disasm.h',
+ 'disassembler.cc',
+ 'disassembler.h',
+ 'diy-fp.cc',
+ 'diy-fp.h',
+ 'double.h',
+ 'dtoa.cc',
+ 'dtoa.h',
+ 'effects.h',
+ 'eh-frame.cc',
+ 'eh-frame.h',
+ 'elements-kind.cc',
+ 'elements-kind.h',
+ 'elements.cc',
+ 'elements.h',
+ 'execution.cc',
+ 'execution.h',
+ 'extensions/externalize-string-extension.cc',
+ 'extensions/externalize-string-extension.h',
+ 'extensions/free-buffer-extension.cc',
+ 'extensions/free-buffer-extension.h',
+ 'extensions/gc-extension.cc',
+ 'extensions/gc-extension.h',
+ 'extensions/ignition-statistics-extension.cc',
+ 'extensions/ignition-statistics-extension.h',
+ 'extensions/statistics-extension.cc',
+ 'extensions/statistics-extension.h',
+ 'extensions/trigger-failure-extension.cc',
+ 'extensions/trigger-failure-extension.h',
+ 'external-reference-table.cc',
+ 'external-reference-table.h',
+ 'factory.cc',
+ 'factory.h',
+ 'fast-accessor-assembler.cc',
+ 'fast-accessor-assembler.h',
+ 'fast-dtoa.cc',
+ 'fast-dtoa.h',
+ 'field-index.h',
+ 'field-index-inl.h',
+ 'field-type.cc',
+ 'field-type.h',
+ 'fixed-dtoa.cc',
+ 'fixed-dtoa.h',
+ 'flag-definitions.h',
+ 'flags.cc',
+ 'flags.h',
+ 'frames-inl.h',
+ 'frames.cc',
+ 'frames.h',
+ 'full-codegen/full-codegen.cc',
+ 'full-codegen/full-codegen.h',
+ 'futex-emulation.cc',
+ 'futex-emulation.h',
+ 'gdb-jit.cc',
+ 'gdb-jit.h',
+ 'global-handles.cc',
+ 'global-handles.h',
+ 'globals.h',
+ 'handles-inl.h',
+ 'handles.cc',
+ 'handles.h',
+ 'heap-symbols.h',
+ 'heap/array-buffer-tracker-inl.h',
+ 'heap/array-buffer-tracker.cc',
+ 'heap/array-buffer-tracker.h',
+ 'heap/memory-reducer.cc',
+ 'heap/memory-reducer.h',
+ 'heap/gc-idle-time-handler.cc',
+ 'heap/gc-idle-time-handler.h',
+ 'heap/gc-tracer.cc',
+ 'heap/gc-tracer.h',
+ 'heap/heap-inl.h',
+ 'heap/heap.cc',
+ 'heap/heap.h',
+ 'heap/incremental-marking-inl.h',
+ 'heap/incremental-marking-job.cc',
+ 'heap/incremental-marking-job.h',
+ 'heap/incremental-marking.cc',
+ 'heap/incremental-marking.h',
+ 'heap/mark-compact-inl.h',
+ 'heap/mark-compact.cc',
+ 'heap/mark-compact.h',
+ 'heap/object-stats.cc',
+ 'heap/object-stats.h',
+ 'heap/objects-visiting-inl.h',
+ 'heap/objects-visiting.cc',
+ 'heap/objects-visiting.h',
+ 'heap/page-parallel-job.h',
+ 'heap/remembered-set.cc',
+ 'heap/remembered-set.h',
+ 'heap/scavenge-job.h',
+ 'heap/scavenge-job.cc',
+ 'heap/scavenger-inl.h',
+ 'heap/scavenger.cc',
+ 'heap/scavenger.h',
+ 'heap/slot-set.h',
+ 'heap/spaces-inl.h',
+ 'heap/spaces.cc',
+ 'heap/spaces.h',
+ 'heap/store-buffer.cc',
+ 'heap/store-buffer.h',
+ 'i18n.cc',
+ 'i18n.h',
+ 'icu_util.cc',
+ 'icu_util.h',
+ 'ic/access-compiler.cc',
+ 'ic/access-compiler.h',
+ 'ic/call-optimization.cc',
+ 'ic/call-optimization.h',
+ 'ic/handler-compiler.cc',
+ 'ic/handler-compiler.h',
+ 'ic/ic-inl.h',
+ 'ic/ic-state.cc',
+ 'ic/ic-state.h',
+ 'ic/ic.cc',
+ 'ic/ic.h',
+ 'ic/ic-compiler.cc',
+ 'ic/ic-compiler.h',
+ 'identity-map.cc',
+ 'identity-map.h',
+ 'interface-descriptors.cc',
+ 'interface-descriptors.h',
+ 'interpreter/bytecodes.cc',
+ 'interpreter/bytecodes.h',
+ 'interpreter/bytecode-array-builder.cc',
+ 'interpreter/bytecode-array-builder.h',
+ 'interpreter/bytecode-array-iterator.cc',
+ 'interpreter/bytecode-array-iterator.h',
+ 'interpreter/bytecode-array-writer.cc',
+ 'interpreter/bytecode-array-writer.h',
+ 'interpreter/bytecode-dead-code-optimizer.cc',
+ 'interpreter/bytecode-dead-code-optimizer.h',
+ 'interpreter/bytecode-label.h',
+ 'interpreter/bytecode-generator.cc',
+ 'interpreter/bytecode-generator.h',
+ 'interpreter/bytecode-peephole-optimizer.cc',
+ 'interpreter/bytecode-peephole-optimizer.h',
+ 'interpreter/bytecode-pipeline.cc',
+ 'interpreter/bytecode-pipeline.h',
+ 'interpreter/bytecode-register-allocator.cc',
+ 'interpreter/bytecode-register-allocator.h',
+ 'interpreter/bytecode-register-optimizer.cc',
+ 'interpreter/bytecode-register-optimizer.h',
+ 'interpreter/bytecode-traits.h',
+ 'interpreter/constant-array-builder.cc',
+ 'interpreter/constant-array-builder.h',
+ 'interpreter/control-flow-builders.cc',
+ 'interpreter/control-flow-builders.h',
+ 'interpreter/handler-table-builder.cc',
+ 'interpreter/handler-table-builder.h',
+ 'interpreter/interpreter.cc',
+ 'interpreter/interpreter.h',
+ 'interpreter/interpreter-assembler.cc',
+ 'interpreter/interpreter-assembler.h',
+ 'interpreter/interpreter-intrinsics.cc',
+ 'interpreter/interpreter-intrinsics.h',
+ 'interpreter/source-position-table.cc',
+ 'interpreter/source-position-table.h',
+ 'isolate-inl.h',
+ 'isolate.cc',
+ 'isolate.h',
+ 'json-parser.cc',
+ 'json-parser.h',
+ 'json-stringifier.cc',
+ 'json-stringifier.h',
+ 'keys.h',
+ 'keys.cc',
+ 'layout-descriptor-inl.h',
+ 'layout-descriptor.cc',
+ 'layout-descriptor.h',
+ 'list-inl.h',
+ 'list.h',
+ 'locked-queue-inl.h',
+ 'locked-queue.h',
+ 'log-inl.h',
+ 'log-utils.cc',
+ 'log-utils.h',
+ 'log.cc',
+ 'log.h',
+ 'lookup.cc',
+ 'lookup.h',
+ 'macro-assembler.h',
+ 'machine-type.cc',
+ 'machine-type.h',
+ 'messages.cc',
+ 'messages.h',
+ 'msan.h',
+ 'objects-body-descriptors-inl.h',
+ 'objects-body-descriptors.h',
+ 'objects-debug.cc',
+ 'objects-inl.h',
+ 'objects-printer.cc',
+ 'objects.cc',
+ 'objects.h',
+ 'optimizing-compile-dispatcher.cc',
+ 'optimizing-compile-dispatcher.h',
+ 'ostreams.cc',
+ 'ostreams.h',
+ 'parsing/expression-classifier.h',
+ 'parsing/func-name-inferrer.cc',
+ 'parsing/func-name-inferrer.h',
+ 'parsing/parameter-initializer-rewriter.cc',
+ 'parsing/parameter-initializer-rewriter.h',
+ 'parsing/parser-base.h',
+ 'parsing/parser.cc',
+ 'parsing/parser.h',
+ 'parsing/pattern-rewriter.cc',
+ 'parsing/preparse-data-format.h',
+ 'parsing/preparse-data.cc',
+ 'parsing/preparse-data.h',
+ 'parsing/preparser.cc',
+ 'parsing/preparser.h',
+ 'parsing/rewriter.cc',
+ 'parsing/rewriter.h',
+ 'parsing/scanner-character-streams.cc',
+ 'parsing/scanner-character-streams.h',
+ 'parsing/scanner.cc',
+ 'parsing/scanner.h',
+ 'parsing/token.cc',
+ 'parsing/token.h',
+ 'pending-compilation-error-handler.cc',
+ 'pending-compilation-error-handler.h',
+ 'perf-jit.cc',
+ 'perf-jit.h',
+ 'profiler/allocation-tracker.cc',
+ 'profiler/allocation-tracker.h',
+ 'profiler/circular-queue-inl.h',
+ 'profiler/circular-queue.h',
+ 'profiler/cpu-profiler-inl.h',
+ 'profiler/cpu-profiler.cc',
+ 'profiler/cpu-profiler.h',
+ 'profiler/heap-profiler.cc',
+ 'profiler/heap-profiler.h',
+ 'profiler/heap-snapshot-generator-inl.h',
+ 'profiler/heap-snapshot-generator.cc',
+ 'profiler/heap-snapshot-generator.h',
+ 'profiler/profiler-listener.cc',
+ 'profiler/profiler-listener.h',
+ 'profiler/profile-generator-inl.h',
+ 'profiler/profile-generator.cc',
+ 'profiler/profile-generator.h',
+ 'profiler/sampling-heap-profiler.cc',
+ 'profiler/sampling-heap-profiler.h',
+ 'profiler/strings-storage.cc',
+ 'profiler/strings-storage.h',
+ 'profiler/tick-sample.cc',
+ 'profiler/tick-sample.h',
+ 'profiler/unbound-queue-inl.h',
+ 'profiler/unbound-queue.h',
+ 'property-descriptor.cc',
+ 'property-descriptor.h',
+ 'property-details.h',
+ 'property.cc',
+ 'property.h',
+ 'prototype.h',
+ 'regexp/bytecodes-irregexp.h',
+ 'regexp/interpreter-irregexp.cc',
+ 'regexp/interpreter-irregexp.h',
+ 'regexp/jsregexp-inl.h',
+ 'regexp/jsregexp.cc',
+ 'regexp/jsregexp.h',
+ 'regexp/regexp-ast.cc',
+ 'regexp/regexp-ast.h',
+ 'regexp/regexp-macro-assembler-irregexp-inl.h',
+ 'regexp/regexp-macro-assembler-irregexp.cc',
+ 'regexp/regexp-macro-assembler-irregexp.h',
+ 'regexp/regexp-macro-assembler-tracer.cc',
+ 'regexp/regexp-macro-assembler-tracer.h',
+ 'regexp/regexp-macro-assembler.cc',
+ 'regexp/regexp-macro-assembler.h',
+ 'regexp/regexp-parser.cc',
+ 'regexp/regexp-parser.h',
+ 'regexp/regexp-stack.cc',
+ 'regexp/regexp-stack.h',
+ 'register-configuration.cc',
+ 'register-configuration.h',
+ 'runtime-profiler.cc',
+ 'runtime-profiler.h',
+ 'runtime/runtime-array.cc',
+ 'runtime/runtime-atomics.cc',
+ 'runtime/runtime-classes.cc',
+ 'runtime/runtime-collections.cc',
+ 'runtime/runtime-compiler.cc',
+ 'runtime/runtime-date.cc',
+ 'runtime/runtime-debug.cc',
+ 'runtime/runtime-forin.cc',
+ 'runtime/runtime-function.cc',
+ 'runtime/runtime-futex.cc',
+ 'runtime/runtime-generator.cc',
+ 'runtime/runtime-i18n.cc',
+ 'runtime/runtime-internal.cc',
+ 'runtime/runtime-interpreter.cc',
+ 'runtime/runtime-literals.cc',
+ 'runtime/runtime-liveedit.cc',
+ 'runtime/runtime-maths.cc',
+ 'runtime/runtime-numbers.cc',
+ 'runtime/runtime-object.cc',
+ 'runtime/runtime-operators.cc',
+ 'runtime/runtime-proxy.cc',
+ 'runtime/runtime-regexp.cc',
+ 'runtime/runtime-scopes.cc',
+ 'runtime/runtime-simd.cc',
+ 'runtime/runtime-strings.cc',
+ 'runtime/runtime-symbol.cc',
+ 'runtime/runtime-test.cc',
+ 'runtime/runtime-typedarray.cc',
+ 'runtime/runtime-utils.h',
+ 'runtime/runtime.cc',
+ 'runtime/runtime.h',
+ 'safepoint-table.cc',
+ 'safepoint-table.h',
+ 'signature.h',
+ 'simulator.h',
+ 'small-pointer-list.h',
+ 'snapshot/code-serializer.cc',
+ 'snapshot/code-serializer.h',
+ 'snapshot/deserializer.cc',
+ 'snapshot/deserializer.h',
+ 'snapshot/natives.h',
+ 'snapshot/natives-common.cc',
+ 'snapshot/partial-serializer.cc',
+ 'snapshot/partial-serializer.h',
+ 'snapshot/serializer.cc',
+ 'snapshot/serializer.h',
+ 'snapshot/serializer-common.cc',
+ 'snapshot/serializer-common.h',
+ 'snapshot/snapshot.h',
+ 'snapshot/snapshot-common.cc',
+ 'snapshot/snapshot-source-sink.cc',
+ 'snapshot/snapshot-source-sink.h',
+ 'snapshot/startup-serializer.cc',
+ 'snapshot/startup-serializer.h',
+ 'source-position.h',
+ 'splay-tree.h',
+ 'splay-tree-inl.h',
+ 'startup-data-util.cc',
+ 'startup-data-util.h',
+ 'string-builder.cc',
+ 'string-builder.h',
+ 'string-search.h',
+ 'string-stream.cc',
+ 'string-stream.h',
+ 'strtod.cc',
+ 'strtod.h',
+ 'ic/stub-cache.cc',
+ 'ic/stub-cache.h',
+ 'tracing/trace-event.cc',
+ 'tracing/trace-event.h',
+ 'transitions-inl.h',
+ 'transitions.cc',
+ 'transitions.h',
+ 'type-cache.cc',
+ 'type-cache.h',
+ 'type-feedback-vector-inl.h',
+ 'type-feedback-vector.cc',
+ 'type-feedback-vector.h',
+ 'type-info.cc',
+ 'type-info.h',
+ 'types.cc',
+ 'types.h',
+ 'typing-asm.cc',
+ 'typing-asm.h',
+ 'unicode-inl.h',
+ 'unicode.cc',
+ 'unicode.h',
+ 'unicode-cache-inl.h',
+ 'unicode-cache.h',
+ 'unicode-decoder.cc',
+ 'unicode-decoder.h',
+ 'uri.cc',
+ 'uri.h',
+ 'utils-inl.h',
+ 'utils.cc',
+ 'utils.h',
+ 'v8.cc',
+ 'v8.h',
+ 'v8memory.h',
+ 'v8threads.cc',
+ 'v8threads.h',
+ 'vector.h',
+ 'version.cc',
+ 'version.h',
+ 'vm-state-inl.h',
+ 'vm-state.h',
+ 'wasm/asm-types.cc',
+ 'wasm/asm-types.h',
+ 'wasm/asm-wasm-builder.cc',
+ 'wasm/asm-wasm-builder.h',
+ 'wasm/ast-decoder.cc',
+ 'wasm/ast-decoder.h',
+ 'wasm/decoder.h',
+ 'wasm/encoder.cc',
+ 'wasm/encoder.h',
+ 'wasm/leb-helper.h',
+ 'wasm/module-decoder.cc',
+ 'wasm/module-decoder.h',
+ 'wasm/switch-logic.h',
+ 'wasm/switch-logic.cc',
+ 'wasm/wasm-debug.cc',
+ 'wasm/wasm-debug.h',
+ 'wasm/wasm-external-refs.cc',
+ 'wasm/wasm-external-refs.h',
+ 'wasm/wasm-function-name-table.cc',
+ 'wasm/wasm-function-name-table.h',
+ 'wasm/wasm-js.cc',
+ 'wasm/wasm-js.h',
+ 'wasm/wasm-macro-gen.h',
+ 'wasm/wasm-module.cc',
+ 'wasm/wasm-module.h',
+ 'wasm/wasm-interpreter.cc',
+ 'wasm/wasm-interpreter.h',
+ 'wasm/wasm-opcodes.cc',
+ 'wasm/wasm-opcodes.h',
+ 'wasm/wasm-result.cc',
+ 'wasm/wasm-result.h',
+ 'zone.cc',
+ 'zone.h',
+ 'zone-allocator.h',
+ 'zone-containers.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'conditions': [
+ ['OS!="win" and remove_v8base_debug_symbols==1', {
+ 'cflags!': ['-g', '-gdwarf-4'],
+ }],
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host', 'target'],
+ }, {
+ 'toolsets': ['target'],
+ }],
+ ['v8_target_arch=="arm"', {
+ 'sources': [ ### gcmole(arch:arm) ###
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'arm/assembler-arm-inl.h',
+ 'arm/assembler-arm.cc',
+ 'arm/assembler-arm.h',
+ 'arm/builtins-arm.cc',
+ 'arm/code-stubs-arm.cc',
+ 'arm/code-stubs-arm.h',
+ 'arm/codegen-arm.cc',
+ 'arm/codegen-arm.h',
+ 'arm/constants-arm.h',
+ 'arm/constants-arm.cc',
+ 'arm/cpu-arm.cc',
+ 'arm/deoptimizer-arm.cc',
+ 'arm/disasm-arm.cc',
+ 'arm/frames-arm.cc',
+ 'arm/frames-arm.h',
+ 'arm/interface-descriptors-arm.cc',
+ 'arm/interface-descriptors-arm.h',
+ 'arm/macro-assembler-arm.cc',
+ 'arm/macro-assembler-arm.h',
+ 'arm/simulator-arm.cc',
+ 'arm/simulator-arm.h',
+ 'compiler/arm/code-generator-arm.cc',
+ 'compiler/arm/instruction-codes-arm.h',
+ 'compiler/arm/instruction-scheduler-arm.cc',
+ 'compiler/arm/instruction-selector-arm.cc',
+ 'crankshaft/arm/lithium-arm.cc',
+ 'crankshaft/arm/lithium-arm.h',
+ 'crankshaft/arm/lithium-codegen-arm.cc',
+ 'crankshaft/arm/lithium-codegen-arm.h',
+ 'crankshaft/arm/lithium-gap-resolver-arm.cc',
+ 'crankshaft/arm/lithium-gap-resolver-arm.h',
+ 'debug/arm/debug-arm.cc',
+ 'full-codegen/arm/full-codegen-arm.cc',
+ 'ic/arm/access-compiler-arm.cc',
+ 'ic/arm/handler-compiler-arm.cc',
+ 'ic/arm/ic-arm.cc',
+ 'ic/arm/ic-compiler-arm.cc',
+ 'ic/arm/stub-cache-arm.cc',
+ 'regexp/arm/regexp-macro-assembler-arm.cc',
+ 'regexp/arm/regexp-macro-assembler-arm.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['v8_target_arch=="arm64"', {
+ 'sources': [ ### gcmole(arch:arm64) ###
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'arm64/assembler-arm64.cc',
+ 'arm64/assembler-arm64.h',
+ 'arm64/assembler-arm64-inl.h',
+ 'arm64/builtins-arm64.cc',
+ 'arm64/codegen-arm64.cc',
+ 'arm64/codegen-arm64.h',
+ 'arm64/code-stubs-arm64.cc',
+ 'arm64/code-stubs-arm64.h',
+ 'arm64/constants-arm64.h',
+ 'arm64/cpu-arm64.cc',
+ 'arm64/decoder-arm64.cc',
+ 'arm64/decoder-arm64.h',
+ 'arm64/decoder-arm64-inl.h',
+ 'arm64/deoptimizer-arm64.cc',
+ 'arm64/disasm-arm64.cc',
+ 'arm64/disasm-arm64.h',
+ 'arm64/frames-arm64.cc',
+ 'arm64/frames-arm64.h',
+ 'arm64/instructions-arm64.cc',
+ 'arm64/instructions-arm64.h',
+ 'arm64/instrument-arm64.cc',
+ 'arm64/instrument-arm64.h',
+ 'arm64/interface-descriptors-arm64.cc',
+ 'arm64/interface-descriptors-arm64.h',
+ 'arm64/macro-assembler-arm64.cc',
+ 'arm64/macro-assembler-arm64.h',
+ 'arm64/macro-assembler-arm64-inl.h',
+ 'arm64/simulator-arm64.cc',
+ 'arm64/simulator-arm64.h',
+ 'arm64/utils-arm64.cc',
+ 'arm64/utils-arm64.h',
+ 'compiler/arm64/code-generator-arm64.cc',
+ 'compiler/arm64/instruction-codes-arm64.h',
+ 'compiler/arm64/instruction-scheduler-arm64.cc',
+ 'compiler/arm64/instruction-selector-arm64.cc',
+ 'crankshaft/arm64/delayed-masm-arm64.cc',
+ 'crankshaft/arm64/delayed-masm-arm64.h',
+ 'crankshaft/arm64/delayed-masm-arm64-inl.h',
+ 'crankshaft/arm64/lithium-arm64.cc',
+ 'crankshaft/arm64/lithium-arm64.h',
+ 'crankshaft/arm64/lithium-codegen-arm64.cc',
+ 'crankshaft/arm64/lithium-codegen-arm64.h',
+ 'crankshaft/arm64/lithium-gap-resolver-arm64.cc',
+ 'crankshaft/arm64/lithium-gap-resolver-arm64.h',
+ 'debug/arm64/debug-arm64.cc',
+ 'full-codegen/arm64/full-codegen-arm64.cc',
+ 'ic/arm64/access-compiler-arm64.cc',
+ 'ic/arm64/handler-compiler-arm64.cc',
+ 'ic/arm64/ic-arm64.cc',
+ 'ic/arm64/ic-compiler-arm64.cc',
+ 'ic/arm64/stub-cache-arm64.cc',
+ 'regexp/arm64/regexp-macro-assembler-arm64.cc',
+ 'regexp/arm64/regexp-macro-assembler-arm64.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['v8_target_arch=="ia32"', {
+ 'sources': [ ### gcmole(arch:ia32) ###
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'ia32/assembler-ia32-inl.h',
+ 'ia32/assembler-ia32.cc',
+ 'ia32/assembler-ia32.h',
+ 'ia32/builtins-ia32.cc',
+ 'ia32/code-stubs-ia32.cc',
+ 'ia32/code-stubs-ia32.h',
+ 'ia32/codegen-ia32.cc',
+ 'ia32/codegen-ia32.h',
+ 'ia32/cpu-ia32.cc',
+ 'ia32/deoptimizer-ia32.cc',
+ 'ia32/disasm-ia32.cc',
+ 'ia32/frames-ia32.cc',
+ 'ia32/frames-ia32.h',
+ 'ia32/interface-descriptors-ia32.cc',
+ 'ia32/macro-assembler-ia32.cc',
+ 'ia32/macro-assembler-ia32.h',
+ 'compiler/ia32/code-generator-ia32.cc',
+ 'compiler/ia32/instruction-codes-ia32.h',
+ 'compiler/ia32/instruction-scheduler-ia32.cc',
+ 'compiler/ia32/instruction-selector-ia32.cc',
+ 'crankshaft/ia32/lithium-codegen-ia32.cc',
+ 'crankshaft/ia32/lithium-codegen-ia32.h',
+ 'crankshaft/ia32/lithium-gap-resolver-ia32.cc',
+ 'crankshaft/ia32/lithium-gap-resolver-ia32.h',
+ 'crankshaft/ia32/lithium-ia32.cc',
+ 'crankshaft/ia32/lithium-ia32.h',
+ 'debug/ia32/debug-ia32.cc',
+ 'full-codegen/ia32/full-codegen-ia32.cc',
+ 'ic/ia32/access-compiler-ia32.cc',
+ 'ic/ia32/handler-compiler-ia32.cc',
+ 'ic/ia32/ic-ia32.cc',
+ 'ic/ia32/ic-compiler-ia32.cc',
+ 'ic/ia32/stub-cache-ia32.cc',
+ 'regexp/ia32/regexp-macro-assembler-ia32.cc',
+ 'regexp/ia32/regexp-macro-assembler-ia32.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['v8_target_arch=="x87"', {
+ 'sources': [ ### gcmole(arch:x87) ###
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'x87/assembler-x87-inl.h',
+ 'x87/assembler-x87.cc',
+ 'x87/assembler-x87.h',
+ 'x87/builtins-x87.cc',
+ 'x87/code-stubs-x87.cc',
+ 'x87/code-stubs-x87.h',
+ 'x87/codegen-x87.cc',
+ 'x87/codegen-x87.h',
+ 'x87/cpu-x87.cc',
+ 'x87/deoptimizer-x87.cc',
+ 'x87/disasm-x87.cc',
+ 'x87/frames-x87.cc',
+ 'x87/frames-x87.h',
+ 'x87/interface-descriptors-x87.cc',
+ 'x87/macro-assembler-x87.cc',
+ 'x87/macro-assembler-x87.h',
+ 'compiler/x87/code-generator-x87.cc',
+ 'compiler/x87/instruction-codes-x87.h',
+ 'compiler/x87/instruction-scheduler-x87.cc',
+ 'compiler/x87/instruction-selector-x87.cc',
+ 'crankshaft/x87/lithium-codegen-x87.cc',
+ 'crankshaft/x87/lithium-codegen-x87.h',
+ 'crankshaft/x87/lithium-gap-resolver-x87.cc',
+ 'crankshaft/x87/lithium-gap-resolver-x87.h',
+ 'crankshaft/x87/lithium-x87.cc',
+ 'crankshaft/x87/lithium-x87.h',
+ 'debug/x87/debug-x87.cc',
+ 'full-codegen/x87/full-codegen-x87.cc',
+ 'ic/x87/access-compiler-x87.cc',
+ 'ic/x87/handler-compiler-x87.cc',
+ 'ic/x87/ic-x87.cc',
+ 'ic/x87/ic-compiler-x87.cc',
+ 'ic/x87/stub-cache-x87.cc',
+ 'regexp/x87/regexp-macro-assembler-x87.cc',
+ 'regexp/x87/regexp-macro-assembler-x87.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['v8_target_arch=="mips" or v8_target_arch=="mipsel"', {
+ 'sources': [ ### gcmole(arch:mipsel) ###
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'mips/assembler-mips.cc',
+ 'mips/assembler-mips.h',
+ 'mips/assembler-mips-inl.h',
+ 'mips/builtins-mips.cc',
+ 'mips/codegen-mips.cc',
+ 'mips/codegen-mips.h',
+ 'mips/code-stubs-mips.cc',
+ 'mips/code-stubs-mips.h',
+ 'mips/constants-mips.cc',
+ 'mips/constants-mips.h',
+ 'mips/cpu-mips.cc',
+ 'mips/deoptimizer-mips.cc',
+ 'mips/disasm-mips.cc',
+ 'mips/frames-mips.cc',
+ 'mips/frames-mips.h',
+ 'mips/interface-descriptors-mips.cc',
+ 'mips/macro-assembler-mips.cc',
+ 'mips/macro-assembler-mips.h',
+ 'mips/simulator-mips.cc',
+ 'mips/simulator-mips.h',
+ 'compiler/mips/code-generator-mips.cc',
+ 'compiler/mips/instruction-codes-mips.h',
+ 'compiler/mips/instruction-scheduler-mips.cc',
+ 'compiler/mips/instruction-selector-mips.cc',
+ 'crankshaft/mips/lithium-codegen-mips.cc',
+ 'crankshaft/mips/lithium-codegen-mips.h',
+ 'crankshaft/mips/lithium-gap-resolver-mips.cc',
+ 'crankshaft/mips/lithium-gap-resolver-mips.h',
+ 'crankshaft/mips/lithium-mips.cc',
+ 'crankshaft/mips/lithium-mips.h',
+ 'full-codegen/mips/full-codegen-mips.cc',
+ 'debug/mips/debug-mips.cc',
+ 'ic/mips/access-compiler-mips.cc',
+ 'ic/mips/handler-compiler-mips.cc',
+ 'ic/mips/ic-mips.cc',
+ 'ic/mips/ic-compiler-mips.cc',
+ 'ic/mips/stub-cache-mips.cc',
+ 'regexp/mips/regexp-macro-assembler-mips.cc',
+ 'regexp/mips/regexp-macro-assembler-mips.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ ['v8_target_arch=="mips64" or v8_target_arch=="mips64el"', {
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'sources': [ ### gcmole(arch:mips64el) ###
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'mips64/assembler-mips64.cc',
+ 'mips64/assembler-mips64.h',
+ 'mips64/assembler-mips64-inl.h',
+ 'mips64/builtins-mips64.cc',
+ 'mips64/codegen-mips64.cc',
+ 'mips64/codegen-mips64.h',
+ 'mips64/code-stubs-mips64.cc',
+ 'mips64/code-stubs-mips64.h',
+ 'mips64/constants-mips64.cc',
+ 'mips64/constants-mips64.h',
+ 'mips64/cpu-mips64.cc',
+ 'mips64/deoptimizer-mips64.cc',
+ 'mips64/disasm-mips64.cc',
+ 'mips64/frames-mips64.cc',
+ 'mips64/frames-mips64.h',
+ 'mips64/interface-descriptors-mips64.cc',
+ 'mips64/macro-assembler-mips64.cc',
+ 'mips64/macro-assembler-mips64.h',
+ 'mips64/simulator-mips64.cc',
+ 'mips64/simulator-mips64.h',
+ 'compiler/mips64/code-generator-mips64.cc',
+ 'compiler/mips64/instruction-codes-mips64.h',
+ 'compiler/mips64/instruction-scheduler-mips64.cc',
+ 'compiler/mips64/instruction-selector-mips64.cc',
+ 'crankshaft/mips64/lithium-codegen-mips64.cc',
+ 'crankshaft/mips64/lithium-codegen-mips64.h',
+ 'crankshaft/mips64/lithium-gap-resolver-mips64.cc',
+ 'crankshaft/mips64/lithium-gap-resolver-mips64.h',
+ 'crankshaft/mips64/lithium-mips64.cc',
+ 'crankshaft/mips64/lithium-mips64.h',
+ 'debug/mips64/debug-mips64.cc',
+ 'full-codegen/mips64/full-codegen-mips64.cc',
+ 'ic/mips64/access-compiler-mips64.cc',
+ 'ic/mips64/handler-compiler-mips64.cc',
+ 'ic/mips64/ic-mips64.cc',
+ 'ic/mips64/ic-compiler-mips64.cc',
+ 'ic/mips64/stub-cache-mips64.cc',
+ 'regexp/mips64/regexp-macro-assembler-mips64.cc',
+ 'regexp/mips64/regexp-macro-assembler-mips64.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['v8_target_arch=="x64" or v8_target_arch=="x32"', {
+ 'sources': [ ### gcmole(arch:x64) ###
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'crankshaft/x64/lithium-codegen-x64.cc',
+ 'crankshaft/x64/lithium-codegen-x64.h',
+ 'crankshaft/x64/lithium-gap-resolver-x64.cc',
+ 'crankshaft/x64/lithium-gap-resolver-x64.h',
+ 'crankshaft/x64/lithium-x64.cc',
+ 'crankshaft/x64/lithium-x64.h',
+ 'x64/assembler-x64-inl.h',
+ 'x64/assembler-x64.cc',
+ 'x64/assembler-x64.h',
+ 'x64/builtins-x64.cc',
+ 'x64/code-stubs-x64.cc',
+ 'x64/code-stubs-x64.h',
+ 'x64/codegen-x64.cc',
+ 'x64/codegen-x64.h',
+ 'x64/cpu-x64.cc',
+ 'x64/deoptimizer-x64.cc',
+ 'x64/disasm-x64.cc',
+ 'x64/frames-x64.cc',
+ 'x64/frames-x64.h',
+ 'x64/interface-descriptors-x64.cc',
+ 'x64/macro-assembler-x64.cc',
+ 'x64/macro-assembler-x64.h',
+ 'debug/x64/debug-x64.cc',
+ 'full-codegen/x64/full-codegen-x64.cc',
+ 'ic/x64/access-compiler-x64.cc',
+ 'ic/x64/handler-compiler-x64.cc',
+ 'ic/x64/ic-x64.cc',
+ 'ic/x64/ic-compiler-x64.cc',
+ 'ic/x64/stub-cache-x64.cc',
+ 'regexp/x64/regexp-macro-assembler-x64.cc',
+ 'regexp/x64/regexp-macro-assembler-x64.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['v8_target_arch=="x64"', {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'compiler/x64/code-generator-x64.cc',
+ 'compiler/x64/instruction-codes-x64.h',
+ 'compiler/x64/instruction-scheduler-x64.cc',
+ 'compiler/x64/instruction-selector-x64.cc',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['v8_target_arch=="ppc" or v8_target_arch=="ppc64"', {
+ 'sources': [ ### gcmole(arch:ppc) ###
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'compiler/ppc/code-generator-ppc.cc',
+ 'compiler/ppc/instruction-codes-ppc.h',
+ 'compiler/ppc/instruction-scheduler-ppc.cc',
+ 'compiler/ppc/instruction-selector-ppc.cc',
+ 'crankshaft/ppc/lithium-ppc.cc',
+ 'crankshaft/ppc/lithium-ppc.h',
+ 'crankshaft/ppc/lithium-codegen-ppc.cc',
+ 'crankshaft/ppc/lithium-codegen-ppc.h',
+ 'crankshaft/ppc/lithium-gap-resolver-ppc.cc',
+ 'crankshaft/ppc/lithium-gap-resolver-ppc.h',
+ 'debug/ppc/debug-ppc.cc',
+ 'full-codegen/ppc/full-codegen-ppc.cc',
+ 'ic/ppc/access-compiler-ppc.cc',
+ 'ic/ppc/handler-compiler-ppc.cc',
+ 'ic/ppc/ic-ppc.cc',
+ 'ic/ppc/ic-compiler-ppc.cc',
+ 'ic/ppc/stub-cache-ppc.cc',
+ 'ppc/assembler-ppc-inl.h',
+ 'ppc/assembler-ppc.cc',
+ 'ppc/assembler-ppc.h',
+ 'ppc/builtins-ppc.cc',
+ 'ppc/code-stubs-ppc.cc',
+ 'ppc/code-stubs-ppc.h',
+ 'ppc/codegen-ppc.cc',
+ 'ppc/codegen-ppc.h',
+ 'ppc/constants-ppc.h',
+ 'ppc/constants-ppc.cc',
+ 'ppc/cpu-ppc.cc',
+ 'ppc/deoptimizer-ppc.cc',
+ 'ppc/disasm-ppc.cc',
+ 'ppc/frames-ppc.cc',
+ 'ppc/frames-ppc.h',
+ 'ppc/interface-descriptors-ppc.cc',
+ 'ppc/macro-assembler-ppc.cc',
+ 'ppc/macro-assembler-ppc.h',
+ 'ppc/simulator-ppc.cc',
+ 'ppc/simulator-ppc.h',
+ 'regexp/ppc/regexp-macro-assembler-ppc.cc',
+ 'regexp/ppc/regexp-macro-assembler-ppc.h',
+ ],
+ }],
+ ['v8_target_arch=="s390" or v8_target_arch=="s390x"', {
+ 'sources': [ ### gcmole(arch:s390) ###
+ 'compiler/s390/code-generator-s390.cc',
+ 'compiler/s390/instruction-codes-s390.h',
+ 'compiler/s390/instruction-scheduler-s390.cc',
+ 'compiler/s390/instruction-selector-s390.cc',
+ 'crankshaft/s390/lithium-codegen-s390.cc',
+ 'crankshaft/s390/lithium-codegen-s390.h',
+ 'crankshaft/s390/lithium-gap-resolver-s390.cc',
+ 'crankshaft/s390/lithium-gap-resolver-s390.h',
+ 'crankshaft/s390/lithium-s390.cc',
+ 'crankshaft/s390/lithium-s390.h',
+ 'debug/s390/debug-s390.cc',
+ 'full-codegen/s390/full-codegen-s390.cc',
+ 'ic/s390/access-compiler-s390.cc',
+ 'ic/s390/handler-compiler-s390.cc',
+ 'ic/s390/ic-compiler-s390.cc',
+ 'ic/s390/ic-s390.cc',
+ 'ic/s390/stub-cache-s390.cc',
+ 'regexp/s390/regexp-macro-assembler-s390.cc',
+ 'regexp/s390/regexp-macro-assembler-s390.h',
+ 's390/assembler-s390.cc',
+ 's390/assembler-s390.h',
+ 's390/assembler-s390-inl.h',
+ 's390/builtins-s390.cc',
+ 's390/codegen-s390.cc',
+ 's390/codegen-s390.h',
+ 's390/code-stubs-s390.cc',
+ 's390/code-stubs-s390.h',
+ 's390/constants-s390.cc',
+ 's390/constants-s390.h',
+ 's390/cpu-s390.cc',
+ 's390/deoptimizer-s390.cc',
+ 's390/disasm-s390.cc',
+ 's390/frames-s390.cc',
+ 's390/frames-s390.h',
+ 's390/interface-descriptors-s390.cc',
+ 's390/macro-assembler-s390.cc',
+ 's390/macro-assembler-s390.h',
+ 's390/simulator-s390.cc',
+ 's390/simulator-s390.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['OS=="win"', {
+ 'variables': {
+ 'gyp_generators': '<!(echo $GYP_GENERATORS)',
+ },
+ 'msvs_disabled_warnings': [4351, 4355, 4800],
+ # When building Official, the .lib is too large and exceeds the 2G
+ # limit. This breaks it into multiple pieces to avoid the limit.
+ # See http://crbug.com/485155.
+ 'msvs_shard': 4,
+ }],
+ ['v8_component=="shared_library"', {
+ 'defines': [
+ 'BUILDING_V8_SHARED',
+ 'V8_SHARED',
+ ],
+ }],
+ ['v8_postmortem_support=="true"', {
+ 'sources': [
+ '<(SHARED_INTERMEDIATE_DIR)/debug-support.cc',
+ ]
+ }],
+ ['v8_enable_i18n_support==1', {
+ 'dependencies': [
+ '<(icu_gyp_path):icui18n',
+ '<(icu_gyp_path):icuuc',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ ],
+ 'conditions': [
+ ['icu_use_data_file_flag==1', {
+ 'defines': ['ICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_FILE'],
+ }, { # else icu_use_data_file_flag !=1
+ 'conditions': [
+ ['OS=="win"', {
+ 'defines': ['ICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_SHARED'],
+ }, {
+ 'defines': ['ICU_UTIL_DATA_IMPL=ICU_UTIL_DATA_STATIC'],
+ }],
+ ],
+ }],
+ ],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ }, { # v8_enable_i18n_support==0
+ 'sources!': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'i18n.cc',
+ 'i18n.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['OS=="win" and v8_enable_i18n_support==1', {
+ 'dependencies': [
+ '<(icu_gyp_path):icudata',
+ ],
+ }],
+ ],
+ },
+ {
+ 'target_name': 'v8_libbase_sse2',
+ 'type': 'static_library',
+ 'variables': {
+ 'optimize': 'max',
+ },
+ 'include_dirs+': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '..',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/accounting-allocator.cc',
+ 'base/accounting-allocator.h',
+ 'base/adapters.h',
+ 'base/atomic-utils.h',
+ 'base/atomicops.h',
+ 'base/atomicops_internals_arm64_gcc.h',
+ 'base/atomicops_internals_arm_gcc.h',
+ 'base/atomicops_internals_atomicword_compat.h',
+ 'base/atomicops_internals_mac.h',
+ 'base/atomicops_internals_mips_gcc.h',
+ 'base/atomicops_internals_mips64_gcc.h',
+ 'base/atomicops_internals_portable.h',
+ 'base/atomicops_internals_ppc_gcc.h',
+ 'base/atomicops_internals_s390_gcc.h',
+ 'base/atomicops_internals_tsan.h',
+ 'base/atomicops_internals_x86_gcc.cc',
+ 'base/atomicops_internals_x86_gcc.h',
+ 'base/atomicops_internals_x86_msvc.h',
+ 'base/bits.cc',
+ 'base/bits.h',
+ 'base/build_config.h',
+ 'base/compiler-specific.h',
+ 'base/cpu.cc',
+ 'base/cpu.h',
+ 'base/division-by-constant.cc',
+ 'base/division-by-constant.h',
+ 'base/file-utils.cc',
+ 'base/file-utils.h',
+ 'base/flags.h',
+ 'base/format-macros.h',
+ 'base/functional.cc',
+ 'base/functional.h',
+ 'base/hashmap.h',
+ 'base/ieee754.cc',
+ 'base/ieee754.h',
+ 'base/iterator.h',
+ 'base/lazy-instance.h',
+ 'base/logging.cc',
+ 'base/logging.h',
+ 'base/macros.h',
+ 'base/once.cc',
+ 'base/once.h',
+ 'base/platform/elapsed-timer.h',
+ 'base/platform/time.cc',
+ 'base/platform/time.h',
+ 'base/platform/condition-variable.cc',
+ 'base/platform/condition-variable.h',
+ 'base/platform/mutex.cc',
+ 'base/platform/mutex.h',
+ 'base/platform/platform.h',
+ 'base/platform/semaphore.cc',
+ 'base/platform/semaphore.h',
+ 'base/safe_conversions.h',
+ 'base/safe_conversions_impl.h',
+ 'base/safe_math.h',
+ 'base/safe_math_impl.h',
+ 'base/smart-pointers.h',
+ 'base/sys-info.cc',
+ 'base/sys-info.h',
+ 'base/utils/random-number-generator.cc',
+ 'base/utils/random-number-generator.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'conditions': [
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host', 'target'],
+ }, {
+ 'toolsets': ['target'],
+ }],
+ ['OS=="linux"', {
+ 'conditions': [
+ ['nacl_target_arch=="none"', {
+ 'link_settings': {
+ 'libraries': [
+ '-ldl',
+ '-lrt'
+ ],
+ },
+ }, {
+ 'defines': [
+ 'V8_LIBRT_NOT_AVAILABLE=1',
+ ],
+ }],
+ ],
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-linux.cc',
+ 'base/platform/platform-posix.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }
+ ],
+ ['OS=="android"', {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-posix.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'link_settings': {
+ 'target_conditions': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ ['_toolset=="host" and host_os!="mac"', {
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ # Only include libdl and librt on host builds because they
+ # are included by default on Android target builds, and we
+ # don't want to re-include them here since this will change
+ # library order and break (see crbug.com/469973).
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ # These libraries do not exist on Mac hosted builds.
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'libraries': [
+ '-ldl',
+ '-lrt'
+ ]
+ }]
+ ]
+ },
+ 'conditions': [
+ ['host_os=="mac"', {
+ 'target_conditions': [
+ ['_toolset=="host"', {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-macos.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ]
+ }, {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-linux.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ]
+ }],
+ ],
+ }, {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-linux.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ]
+ }],
+ ],
+ },
+ ],
+ ['OS=="qnx"', {
+ 'link_settings': {
+ 'target_conditions': [
+ ['_toolset=="host" and host_os=="linux"', {
+ 'libraries': [
+ '-lrt'
+ ],
+ }],
+ ['_toolset=="target"', {
+ 'libraries': [
+ '-lbacktrace'
+ ],
+ }],
+ ],
+ },
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-posix.cc',
+ 'base/qnx-math.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'target_conditions': [
+ ['_toolset=="host" and host_os=="linux"', {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-linux.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['_toolset=="host" and host_os=="mac"', {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-macos.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ['_toolset=="target"', {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-qnx.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ],
+ },
+ ],
+ ['OS=="freebsd"', {
+ 'link_settings': {
+ 'libraries': [
+ '-L/usr/local/lib -lexecinfo',
+ ]},
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-freebsd.cc',
+ 'base/platform/platform-posix.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }
+ ],
+ ['OS=="openbsd"', {
+ 'link_settings': {
+ 'libraries': [
+ '-L/usr/local/lib -lexecinfo',
+ ]},
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-openbsd.cc',
+ 'base/platform/platform-posix.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }
+ ],
+ ['OS=="netbsd"', {
+ 'link_settings': {
+ 'libraries': [
+ '-L/usr/pkg/lib -Wl,-R/usr/pkg/lib -lexecinfo',
+ ]},
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-openbsd.cc',
+ 'base/platform/platform-posix.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }
+ ],
+ ['OS=="aix"', {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-aix.cc',
+ 'base/platform/platform-posix.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ]},
+ ],
+ ['OS=="solaris"', {
+ 'link_settings': {
+ 'libraries': [
+ '-lnsl -lrt',
+ ]},
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-solaris.cc',
+ 'base/platform/platform-posix.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }
+ ],
+ ['OS=="mac"', {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-macos.cc',
+ 'base/platform/platform-posix.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ]},
+ ],
+ ['OS=="win"', {
+ 'defines': [
+ '_CRT_RAND_S' # for rand_s()
+ ],
+ 'variables': {
+ 'gyp_generators': '<!(echo $GYP_GENERATORS)',
+ },
+ 'conditions': [
+ ['gyp_generators=="make"', {
+ 'variables': {
+ 'build_env': '<!(uname -o)',
+ },
+ 'conditions': [
+ ['build_env=="Cygwin"', {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-cygwin.cc',
+ 'base/platform/platform-posix.cc'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }, {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-win32.cc',
+ 'base/win32-headers.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ],
+ 'link_settings': {
+ 'libraries': [ '-lwinmm', '-lws2_32' ],
+ },
+ }, {
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'base/platform/platform-win32.cc',
+ 'base/win32-headers.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'msvs_disabled_warnings': [4351, 4355, 4800],
+ 'link_settings': {
+ 'libraries': [ '-lwinmm.lib', '-lws2_32.lib' ],
+ },
+ }],
+ ],
+ }],
+ ],
+ },
+ {
+ 'target_name': 'v8_libplatform_sse2',
+ 'type': 'static_library',
+ 'variables': {
+ 'optimize': 'max',
+ },
+ 'dependencies': [
+ 'v8_libbase_sse2',
+ ],
+ 'include_dirs+': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '..',
+ '../include',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../include/libplatform/libplatform.h',
+ 'libplatform/default-platform.cc',
+ 'libplatform/default-platform.h',
+ 'libplatform/task-queue.cc',
+ 'libplatform/task-queue.h',
+ 'libplatform/worker-thread.cc',
+ 'libplatform/worker-thread.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'conditions': [
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host', 'target'],
+ }, {
+ 'toolsets': ['target'],
+ }],
+ ],
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'direct_dependent_settings': {
+ 'include_dirs': [
+ '../include',
+ ],
+ },
+ },
+ {
+ 'target_name': 'v8_libsampler_sse2',
+ 'type': 'static_library',
+ 'variables': {
+ 'optimize': 'max',
+ },
+ 'dependencies': [
+ 'v8_libbase_sse2',
+ ],
+ 'include_dirs+': [
+ '..',
+ '../include',
+ ],
+ 'sources': [
+ 'libsampler/v8-sampler.cc',
+ 'libsampler/v8-sampler.h'
+ ],
+ 'conditions': [
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host', 'target'],
+ }, {
+ 'toolsets': ['target'],
+ }],
+ ],
+ 'direct_dependent_settings': {
+ 'include_dirs': [
+ '../include',
+ ],
+ },
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ },
+ {
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'target_name': 'natives_blob_sse2',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'type': 'none',
+ 'conditions': [
+ [ 'v8_use_external_startup_data==1', {
+ 'conditions': [
+ ['want_separate_host_toolset==1', {
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'dependencies': ['js2c_sse2#host'],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ }, {
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'dependencies': ['js2c_sse2'],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ }],
+ ],
+ 'actions': [{
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'action_name': 'v8_sse2_concatenate_natives_blob',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'inputs': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/concatenate-files.py',
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/libraries_sse2.bin',
+ '<(SHARED_INTERMEDIATE_DIR)/libraries-experimental_sse2.bin',
+ '<(SHARED_INTERMEDIATE_DIR)/libraries-extras_sse2.bin',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/libraries-experimental-extras_sse2.bin',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'conditions': [
+ ['want_separate_host_toolset==1', {
+ 'target_conditions': [
+ ['_toolset=="host"', {
+ 'outputs': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(PRODUCT_DIR)/natives_blob_host_sse2.bin',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'action': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'python', '<@(_inputs)', '<(PRODUCT_DIR)/natives_blob_host_sse2.bin'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }, {
+ 'outputs': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(PRODUCT_DIR)/natives_blob_sse2.bin',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'action': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'python', '<@(_inputs)', '<(PRODUCT_DIR)/natives_blob_sse2.bin'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ],
+ }, {
+ 'outputs': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(PRODUCT_DIR)/natives_blob_sse2.bin',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'action': [
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'python', '<@(_inputs)', '<(PRODUCT_DIR)/natives_blob_sse2.bin'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
+ ],
+ }],
+ }],
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host', 'target'],
+ }, {
+ 'toolsets': ['target'],
+ }],
+ ]
+ },
+ {
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'target_name': 'js2c_sse2',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'type': 'none',
+ 'conditions': [
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host'],
+ }, {
+ 'toolsets': ['target'],
+ }],
+ ],
+ 'variables': {
+ 'library_files': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'js/macros.py',
+ 'messages.h',
+ 'js/prologue.js',
+ 'js/runtime.js',
+ 'js/v8natives.js',
+ 'js/symbol.js',
+ 'js/array.js',
+ 'js/string.js',
+ 'js/math.js',
+ 'third_party/fdlibm/fdlibm.js',
+ 'js/regexp.js',
+ 'js/arraybuffer.js',
+ 'js/typedarray.js',
+ 'js/iterator-prototype.js',
+ 'js/collection.js',
+ 'js/weak-collection.js',
+ 'js/collection-iterator.js',
+ 'js/promise.js',
+ 'js/messages.js',
+ 'js/array-iterator.js',
+ 'js/string-iterator.js',
+ 'js/templates.js',
+ 'js/spread.js',
+ 'js/proxy.js',
+ 'debug/mirrors.js',
+ 'debug/debug.js',
+ 'debug/liveedit.js',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'experimental_library_files': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'js/macros.py',
+ 'messages.h',
+ 'js/harmony-atomics.js',
+ 'js/harmony-sharedarraybuffer.js',
+ 'js/harmony-simd.js',
+ 'js/harmony-string-padding.js',
+ 'js/promise-extra.js',
+ 'js/harmony-async-await.js'
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'libraries_bin_file': '<(SHARED_INTERMEDIATE_DIR)/libraries_sse2.bin',
+ 'libraries_experimental_bin_file': '<(SHARED_INTERMEDIATE_DIR)/libraries-experimental_sse2.bin',
+ 'libraries_extras_bin_file': '<(SHARED_INTERMEDIATE_DIR)/libraries-extras_sse2.bin',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ 'libraries_experimental_extras_bin_file': '<(SHARED_INTERMEDIATE_DIR)/libraries-experimental-extras_sse2.bin',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'conditions': [
+ ['v8_enable_i18n_support==1', {
+ 'library_files': ['js/i18n.js'],
+ 'experimental_library_files': [
+ 'js/icu-case-mapping.js',
+ 'js/intl-extra.js',
+ ],
+ }],
+ ],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ },
+ 'actions': [
+ {
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'action_name': 'v8_sse2_js2c',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'inputs': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ '<@(library_files)',
+ ],
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ 'outputs': ['<(SHARED_INTERMEDIATE_DIR)/libraries_sse2.cc'],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'action': [
+ 'python',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/libraries_sse2.cc',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'CORE',
+ '<@(library_files)',
+ ],
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ },
+ {
+ 'action_name': 'v8_sse2_js2c_bin',
+ 'inputs': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '<@(library_files)',
+ ],
+ 'outputs': ['<@(libraries_bin_file)'],
+ 'action': [
+ 'python',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/libraries_sse2.cc',
+ 'CORE',
+ '<@(library_files)',
+ '--startup_blob', '<@(libraries_bin_file)',
+ '--nojs',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ },
+ {
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'action_name': 'v8_sse2_js2c_experimental',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'inputs': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ '<@(experimental_library_files)',
+ ],
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ 'outputs': ['<(SHARED_INTERMEDIATE_DIR)/experimental-libraries_sse2.cc'],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'action': [
+ 'python',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/experimental-libraries_sse2.cc',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'EXPERIMENTAL',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '<@(experimental_library_files)',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ },
+ {
+ 'action_name': 'v8_sse2_js2c_experimental_bin',
+ 'inputs': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '<@(experimental_library_files)',
+ ],
+ 'outputs': ['<@(libraries_experimental_bin_file)'],
+ 'action': [
+ 'python',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/experimental-libraries_sse2.cc',
+ 'EXPERIMENTAL',
+ '<@(experimental_library_files)',
+ '--startup_blob', '<@(libraries_experimental_bin_file)',
+ '--nojs',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ },
+ {
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'action_name': 'v8_sse2_js2c_extras',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'inputs': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ '<@(v8_extra_library_files)',
+ ],
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ 'outputs': ['<(SHARED_INTERMEDIATE_DIR)/extras-libraries_sse2.cc'],
+ 'action': [
+ 'python',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/extras-libraries_sse2.cc',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ 'EXTRAS',
+ '<@(v8_extra_library_files)',
+ ],
+ },
+ {
+ 'action_name': 'v8_sse2_js2c_extras_bin',
+ 'inputs': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '<@(v8_extra_library_files)',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ 'outputs': ['<@(libraries_extras_bin_file)'],
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'action': [
+ 'python',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/extras-libraries_sse2.cc',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'EXTRAS',
+ '<@(v8_extra_library_files)',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '--startup_blob', '<@(libraries_extras_bin_file)',
+ '--nojs',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ },
+ {
+ 'action_name': 'v8_sse2_js2c_experimental_extras',
+ 'inputs': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '<@(v8_experimental_extra_library_files)',
+ ],
+ 'outputs': [
+ '<(SHARED_INTERMEDIATE_DIR)/experimental-extras-libraries_sse2.cc',
+ ],
+ 'action': [
+ 'python',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/experimental-extras-libraries_sse2.cc',
+ 'EXPERIMENTAL_EXTRAS',
+ '<@(v8_experimental_extra_library_files)',
+ ],
+ },
+ {
+ 'action_name': 'v8_sse2_js2c_experimental_extras_bin',
+ 'inputs': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '<@(v8_experimental_extra_library_files)',
+ ],
+ 'outputs': ['<@(libraries_experimental_extras_bin_file)'],
+ 'action': [
+ 'python',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/js2c.py',
Rebase the no-sse2 patch Now all patches should be rebased.
2016-07-17 19:06:36 +00:00
+ '<(SHARED_INTERMEDIATE_DIR)/experimental-extras-libraries_sse2.cc',
+ 'EXPERIMENTAL_EXTRAS',
+ '<@(v8_experimental_extra_library_files)',
+ '--startup_blob', '<@(libraries_experimental_extras_bin_file)',
+ '--nojs',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ },
+ ],
+ },
+ {
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'target_name': 'postmortem-metadata_sse2',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'type': 'none',
+ 'variables': {
+ 'heapobject_files': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'objects.h',
+ 'objects-inl.h',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ },
+ 'actions': [
+ {
no-sse2.patch: More v8_sse2.gyp fixes, ensure everything is renamed (again, by fixing the make-v8-sse2-gyp.sh script)
2016-01-19 03:58:50 +00:00
+ 'action_name': 'v8_sse2_gen-postmortem-metadata',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ 'inputs': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/gen-postmortem-metadata.py',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ '<@(heapobject_files)',
+ ],
+ 'outputs': [
+ '<(SHARED_INTERMEDIATE_DIR)/debug-support.cc',
+ ],
+ 'action': [
+ 'python',
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '../tools/gen-postmortem-metadata.py',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ '<@(_outputs)',
+ '<@(heapobject_files)'
+ ]
+ }
+ ]
+ },
+ {
+ 'target_name': 'mksnapshot_sse2',
+ 'type': 'executable',
+ 'dependencies': ['v8_base_sse2', 'v8_nosnapshot_sse2', 'v8_libplatform_sse2'],
+ 'include_dirs+': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ '..',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'sources': [
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
+ 'snapshot/mksnapshot.cc',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ 'conditions': [
+ ['v8_enable_i18n_support==1', {
+ 'dependencies': [
+ '<(icu_gyp_path):icui18n',
+ '<(icu_gyp_path):icuuc',
+ ]
+ }],
+ ['want_separate_host_toolset==1', {
+ 'toolsets': ['host'],
+ }, {
+ 'toolsets': ['target'],
+ }],
+ ],
+ },
+ ],
+}
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/core/core_module.pro qtwebengine-opensource-src-5.8.0-no-sse2/src/core/core_module.pro
--- qtwebengine-opensource-src-5.8.0/src/core/core_module.pro 2017-01-03 11:35:11.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/core/core_module.pro 2017-03-05 17:30:17.502552632 +0100
no-sse2.patch: Install the shared libraries, don't link the sse2 one
2016-01-19 13:55:13 +00:00
@@ -9,6 +9,29 @@
error("Could not find the linking information that gyp should have generated.")
}
+# find the shared libraries in the link line
+# remove those in lib/sse2 that are only replacements for the normal ones
+# collect all shared libraries so they can be installed
+for(private_lib, LIBS_PRIVATE) {
+ contains(private_lib, .*\.so) {
+ contains(private_lib, .*/lib/sse2/.*) {
+ LIBS_PRIVATE -= $$private_lib
+ shlibs_sse2 += $$private_lib
+ } else {
+ shlibs += $$private_lib
+ }
+ }
+}
+
+# set the shared libraries to be installed
+# add an rpath to their installation location
+shlib_install_path = $$[QT_INSTALL_LIBS]/qtwebengine
+!isEmpty(shlibs) {
+ shlibs.files += $$shlibs
+ shlibs_sse2.files += $$shlibs_sse2
+ LIBS_PRIVATE += -Wl,--rpath,$$shlib_install_path
+}
+
load(qt_module)
api_library_name = qtwebenginecoreapi$$qtPlatformTargetSuffix()
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
@@ -74,7 +97,12 @@
Update to 5.6.1 * Fri Jun 10 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.1-1 - Update to 5.6.1 - Rebase linux-pri patch (drop the parts already fixed upstream) - Drop backported chimera-nss-init patch, already applied upstream - Rebase no-sse2 patch (the core_module.pro change)
2016-06-10 23:32:18 +00:00
locales.path = $$[QT_INSTALL_TRANSLATIONS]/qtwebengine_locales
resources.CONFIG += no_check_exist
Rebase no-sse2 patch, fix file list - Rebase no-sse2 patch - Update file list for 5.6.0 RC (resources now in resources/ subdirectory) - Tag translations with correct %lang tags
2016-02-25 00:24:47 +00:00
resources.path = $$[QT_INSTALL_DATA]/resources
Update to 5.6.1 * Fri Jun 10 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.1-1 - Update to 5.6.1 - Rebase linux-pri patch (drop the parts already fixed upstream) - Drop backported chimera-nss-init patch, already applied upstream - Rebase no-sse2 patch (the core_module.pro change)
2016-06-10 23:32:18 +00:00
- INSTALLS += locales resources
no-sse2.patch: Install the shared libraries, don't link the sse2 one
2016-01-19 13:55:13 +00:00
+ # install the shared libraries
+ shlibs.CONFIG += no_check_exist
+ shlibs.path = $$shlib_install_path
+ shlibs_sse2.CONFIG += no_check_exist
+ shlibs_sse2.path = $$shlib_install_path/sse2
Update to 5.6.1 * Fri Jun 10 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.1-1 - Update to 5.6.1 - Rebase linux-pri patch (drop the parts already fixed upstream) - Drop backported chimera-nss-init patch, already applied upstream - Rebase no-sse2 patch (the core_module.pro change)
2016-06-10 23:32:18 +00:00
+ INSTALLS += locales resources shlibs shlibs_sse2
no-sse2.patch: Install the shared libraries, don't link the sse2 one
2016-01-19 13:55:13 +00:00
Update to 5.6.1 * Fri Jun 10 2016 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.6.1-1 - Update to 5.6.1 - Rebase linux-pri patch (drop the parts already fixed upstream) - Drop backported chimera-nss-init patch, already applied upstream - Rebase no-sse2 patch (the core_module.pro change)
2016-06-10 23:32:18 +00:00
!use?(system_icu) {
icu.CONFIG += no_check_exist
Update to 5.8.0 - Fix FTBFS in the WTF part of Blink/WebKit with GCC 7
2017-03-26 19:48:05 +00:00
diff -Nur qtwebengine-opensource-src-5.8.0/src/core/qtwebengine.gypi qtwebengine-opensource-src-5.8.0-no-sse2/src/core/qtwebengine.gypi
--- qtwebengine-opensource-src-5.8.0/src/core/qtwebengine.gypi 2017-01-03 11:35:11.000000000 +0100
+++ qtwebengine-opensource-src-5.8.0-no-sse2/src/core/qtwebengine.gypi 2017-03-05 17:30:17.503552617 +0100
@@ -63,6 +63,11 @@
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
},
},
'conditions': [
+ ['target_arch=="ia32"', {
+ 'dependencies': [
Fix no-sse2 patch FTBFS (on i686) * Fri Mar 31 2017 Kevin Kofler <Kevin@tigcc.ticalc.org> - 5.8.0-4 - Fix no-sse2 patch FTBFS (on i686)
2017-03-31 00:54:55 +00:00
+ '<(chromium_src_dir)/v8/src/v8_sse2.gyp:v8_sse2',
no-sse2.patch: Build both the x87 version and the SSE2 version of V8 on i686 Note that almost all the patch size increase is from the v8_sse2.gyp file that is automatically generated from v8.gyp using a small script I wrote, which is also included in the patch.
2016-01-19 02:32:24 +00:00
+ ],
+ }],
['OS=="win" and win_use_allocator_shim==1', {
'dependencies': [
'<(chromium_src_dir)/base/allocator/allocator.gyp:allocator',
Reference in New Issue Copy Permalink