From 7816e88f62f2da31954d17cc5c755d88ebe1625f Mon Sep 17 00:00:00 2001 From: Helio Chissini de Castro Date: May 31 2017 13:43:14 +0000 Subject: Prep webengine 5.9.0 --- diff --git a/.gitignore b/.gitignore index 0983a72..3eee6b2 100644 --- a/.gitignore +++ b/.gitignore @@ -5,3 +5,4 @@ /qtwebengine-opensource-src-5.7.0-clean.tar.xz /qtwebengine-opensource-src-5.7.1-clean.tar.xz /qtwebengine-opensource-src-5.8.0-clean.tar.xz +/qtwebengine-opensource-src-5.9.0-clean.tar.xz diff --git a/0001-qtwebengine-opensource-src-5.9.0-webrtc-neon-detect.patch b/0001-qtwebengine-opensource-src-5.9.0-webrtc-neon-detect.patch new file mode 100644 index 0000000..7c48a10 --- /dev/null +++ b/0001-qtwebengine-opensource-src-5.9.0-webrtc-neon-detect.patch @@ -0,0 +1,27 @@ +From bef192680ca3c78493c064d7b4a21b79afa92c3e Mon Sep 17 00:00:00 2001 +From: Helio Chissini de Castro +Date: Wed, 31 May 2017 10:41:10 +0200 +Subject: [PATCH] qtwebengine-opensource-src-5.9.0-webrtc-neon-detect + +--- + src/3rdparty/chromium/third_party/webrtc/system_wrappers/BUILD.gn | 4 +--- + 1 file changed, 1 insertion(+), 3 deletions(-) + +diff --git a/src/3rdparty/chromium/third_party/webrtc/system_wrappers/BUILD.gn b/src/3rdparty/chromium/third_party/webrtc/system_wrappers/BUILD.gn +index 8bed25e27..b0cc2a5e3 100644 +--- a/src/3rdparty/chromium/third_party/webrtc/system_wrappers/BUILD.gn ++++ b/src/3rdparty/chromium/third_party/webrtc/system_wrappers/BUILD.gn +@@ -93,9 +93,7 @@ rtc_static_library("system_wrappers") { + if (is_linux) { + defines += [ "WEBRTC_THREAD_RR" ] + +- if (!build_with_chromium) { +- deps += [ ":cpu_features_linux" ] +- } ++ deps += [ ":cpu_features_linux" ] + + libs += [ "rt" ] + } +-- +2.13.0 + diff --git a/0002-qtwebengine-opensource-src-5.9.0-system-nspr-prtime.patch b/0002-qtwebengine-opensource-src-5.9.0-system-nspr-prtime.patch new file mode 100644 index 0000000..5bc39ee --- /dev/null +++ b/0002-qtwebengine-opensource-src-5.9.0-system-nspr-prtime.patch @@ -0,0 +1,54 @@ +From 60434d58353db516e795e12817e1953700f9e5e4 Mon Sep 17 00:00:00 2001 +From: Helio Chissini de Castro +Date: Wed, 31 May 2017 10:46:36 +0200 +Subject: [PATCH] qtwebengine-opensource-src-5.9.0-system-nspr-prtime + +--- + src/3rdparty/chromium/base/BUILD.gn | 2 -- + src/3rdparty/chromium/base/time/pr_time_unittest.cc | 2 +- + src/3rdparty/chromium/base/time/time.cc | 2 +- + 3 files changed, 2 insertions(+), 4 deletions(-) + +diff --git a/src/3rdparty/chromium/base/BUILD.gn b/src/3rdparty/chromium/base/BUILD.gn +index f2672cba7..66f2be1ff 100644 +--- a/src/3rdparty/chromium/base/BUILD.gn ++++ b/src/3rdparty/chromium/base/BUILD.gn +@@ -833,8 +833,6 @@ component("base") { + "third_party/dmg_fp/g_fmt.cc", + "third_party/icu/icu_utf.cc", + "third_party/icu/icu_utf.h", +- "third_party/nspr/prtime.cc", +- "third_party/nspr/prtime.h", + "third_party/superfasthash/superfasthash.c", + "threading/non_thread_safe.h", + "threading/non_thread_safe_impl.cc", +diff --git a/src/3rdparty/chromium/base/time/pr_time_unittest.cc b/src/3rdparty/chromium/base/time/pr_time_unittest.cc +index 3f1a348ae..8f1a11e51 100644 +--- a/src/3rdparty/chromium/base/time/pr_time_unittest.cc ++++ b/src/3rdparty/chromium/base/time/pr_time_unittest.cc +@@ -7,7 +7,7 @@ + + #include "base/compiler_specific.h" + #include "base/macros.h" +-#include "base/third_party/nspr/prtime.h" ++#include + #include "base/time/time.h" + #include "build/build_config.h" + #include "testing/gtest/include/gtest/gtest.h" +diff --git a/src/3rdparty/chromium/base/time/time.cc b/src/3rdparty/chromium/base/time/time.cc +index 4e942015f..29fde71dd 100644 +--- a/src/3rdparty/chromium/base/time/time.cc ++++ b/src/3rdparty/chromium/base/time/time.cc +@@ -13,8 +13,8 @@ + #include "base/lazy_instance.h" + #include "base/logging.h" + #include "base/macros.h" ++#include + #include "base/strings/stringprintf.h" +-#include "base/third_party/nspr/prtime.h" + #include "build/build_config.h" + + namespace base { +-- +2.13.0 + diff --git a/0003-qtwebengine-opensource-src-5.9.0-system-icu-utf.patch b/0003-qtwebengine-opensource-src-5.9.0-system-icu-utf.patch new file mode 100644 index 0000000..c7fc67f --- /dev/null +++ b/0003-qtwebengine-opensource-src-5.9.0-system-icu-utf.patch @@ -0,0 +1,552 @@ +From 63abd7883643841941505c82d42589d8d6814478 Mon Sep 17 00:00:00 2001 +From: Helio Chissini de Castro +Date: Wed, 31 May 2017 11:16:12 +0200 +Subject: [PATCH] qtwebengine-opensource-src-5.9.0-system-icu-utf + +--- + src/3rdparty/chromium/base/BUILD.gn | 2 -- + src/3rdparty/chromium/base/files/file_path.cc | 6 ++--- + src/3rdparty/chromium/base/json/json_parser.cc | 28 ++++++++++---------- + src/3rdparty/chromium/base/json/string_escape.cc | 2 +- + src/3rdparty/chromium/base/strings/pattern.cc | 9 +++---- + src/3rdparty/chromium/base/strings/string_split.cc | 2 +- + src/3rdparty/chromium/base/strings/string_util.cc | 10 ++++---- + .../base/strings/utf_string_conversion_utils.cc | 28 ++++++++++---------- + .../chromium/base/third_party/icu/icu_utf.cc | 30 +++++++++++----------- + .../browser/devtools/devtools_io_context.cc | 4 +-- + .../chromium/net/cert/internal/parse_name.cc | 6 ++--- + .../chromium/ui/base/ime/input_method_chromeos.cc | 2 +- + src/3rdparty/chromium/ui/gfx/utf16_indexing.cc | 4 +-- + 13 files changed, 65 insertions(+), 68 deletions(-) + +diff --git a/src/3rdparty/chromium/base/BUILD.gn b/src/3rdparty/chromium/base/BUILD.gn +index 66f2be1ff..51faf08ad 100644 +--- a/src/3rdparty/chromium/base/BUILD.gn ++++ b/src/3rdparty/chromium/base/BUILD.gn +@@ -831,8 +831,6 @@ component("base") { + "third_party/dmg_fp/dmg_fp.h", + "third_party/dmg_fp/dtoa_wrapper.cc", + "third_party/dmg_fp/g_fmt.cc", +- "third_party/icu/icu_utf.cc", +- "third_party/icu/icu_utf.h", + "third_party/superfasthash/superfasthash.c", + "threading/non_thread_safe.h", + "threading/non_thread_safe_impl.cc", +diff --git a/src/3rdparty/chromium/base/files/file_path.cc b/src/3rdparty/chromium/base/files/file_path.cc +index cff862ae1..b17b46e5f 100644 +--- a/src/3rdparty/chromium/base/files/file_path.cc ++++ b/src/3rdparty/chromium/base/files/file_path.cc +@@ -18,7 +18,7 @@ + + #if defined(OS_MACOSX) + #include "base/mac/scoped_cftyperef.h" +-#include "base/third_party/icu/icu_utf.h" ++#include + #endif + + #if defined(OS_WIN) +@@ -1156,9 +1156,9 @@ inline int HFSReadNextNonIgnorableCodepoint(const char* string, + int* index) { + int codepoint = 0; + while (*index < length && codepoint == 0) { +- // CBU8_NEXT returns a value < 0 in error cases. For purposes of string ++ // U8_NEXT returns a value < 0 in error cases. For purposes of string + // comparison, we just use that value and flag it with DCHECK. +- CBU8_NEXT(string, *index, length, codepoint); ++ U8_NEXT(string, *index, length, codepoint); + DCHECK_GT(codepoint, 0); + if (codepoint > 0) { + // Check if there is a subtable for this upper byte. +diff --git a/src/3rdparty/chromium/base/json/json_parser.cc b/src/3rdparty/chromium/base/json/json_parser.cc +index cd427da9e..82ff9773c 100644 +--- a/src/3rdparty/chromium/base/json/json_parser.cc ++++ b/src/3rdparty/chromium/base/json/json_parser.cc +@@ -16,7 +16,7 @@ + #include "base/strings/stringprintf.h" + #include "base/strings/utf_string_conversion_utils.h" + #include "base/strings/utf_string_conversions.h" +-#include "base/third_party/icu/icu_utf.h" ++#include + #include "base/values.h" + + namespace base { +@@ -630,21 +630,21 @@ bool JSONParser::ConsumeStringRaw(StringBuilder* out) { + + while (CanConsume(1)) { + int start_index = index_; +- pos_ = start_pos_ + index_; // CBU8_NEXT is postcrement. +- CBU8_NEXT(start_pos_, index_, length, next_char); ++ pos_ = start_pos_ + index_; // U8_NEXT is postcrement. ++ U8_NEXT(start_pos_, index_, length, next_char); + if (next_char < 0 || !IsValidCharacter(next_char)) { + if ((options_ & JSON_REPLACE_INVALID_CHARACTERS) == 0) { + ReportError(JSONReader::JSON_UNSUPPORTED_ENCODING, 1); + return false; + } +- CBU8_NEXT(start_pos_, start_index, length, next_char); ++ U8_NEXT(start_pos_, start_index, length, next_char); + string.Convert(); + string.AppendString(kUnicodeReplacementString); + continue; + } + + if (next_char == '"') { +- --index_; // Rewind by one because of CBU8_NEXT. ++ --index_; // Rewind by one because of U8_NEXT. + out->Swap(&string); + return true; + } +@@ -774,10 +774,10 @@ bool JSONParser::DecodeUTF16(std::string* dest_string) { + + // If this is a high surrogate, consume the next code unit to get the + // low surrogate. +- if (CBU16_IS_SURROGATE(code_unit16_high)) { ++ if (U16_IS_SURROGATE(code_unit16_high)) { + // Make sure this is the high surrogate. If not, it's an encoding + // error. +- if (!CBU16_IS_SURROGATE_LEAD(code_unit16_high)) ++ if (!U16_IS_SURROGATE_LEAD(code_unit16_high)) + return false; + + // Make sure that the token has more characters to consume the +@@ -794,24 +794,24 @@ bool JSONParser::DecodeUTF16(std::string* dest_string) { + + NextNChars(3); + +- if (!CBU16_IS_TRAIL(code_unit16_low)) { ++ if (!U16_IS_TRAIL(code_unit16_low)) { + return false; + } + + uint32_t code_point = +- CBU16_GET_SUPPLEMENTARY(code_unit16_high, code_unit16_low); ++ U16_GET_SUPPLEMENTARY(code_unit16_high, code_unit16_low); + if (!IsValidCharacter(code_point)) + return false; + + offset = 0; +- CBU8_APPEND_UNSAFE(code_unit8, offset, code_point); ++ U8_APPEND_UNSAFE(code_unit8, offset, code_point); + } else { + // Not a surrogate. +- DCHECK(CBU16_IS_SINGLE(code_unit16_high)); ++ DCHECK(U16_IS_SINGLE(code_unit16_high)); + if (!IsValidCharacter(code_unit16_high)) + return false; + +- CBU8_APPEND_UNSAFE(code_unit8, offset, code_unit16_high); ++ U8_APPEND_UNSAFE(code_unit8, offset, code_unit16_high); + } + + dest_string->append(code_unit8); +@@ -828,9 +828,9 @@ void JSONParser::DecodeUTF8(const int32_t& point, StringBuilder* dest) { + } else { + char utf8_units[4] = { 0 }; + int offset = 0; +- CBU8_APPEND_UNSAFE(utf8_units, offset, point); ++ U8_APPEND_UNSAFE(utf8_units, offset, point); + dest->Convert(); +- // CBU8_APPEND_UNSAFE can overwrite up to 4 bytes, so utf8_units may not be ++ // U8_APPEND_UNSAFE can overwrite up to 4 bytes, so utf8_units may not be + // zero terminated at this point. |offset| contains the correct length. + dest->AppendString(std::string(utf8_units, offset)); + } +diff --git a/src/3rdparty/chromium/base/json/string_escape.cc b/src/3rdparty/chromium/base/json/string_escape.cc +index f67fa93bf..907b80a73 100644 +--- a/src/3rdparty/chromium/base/json/string_escape.cc ++++ b/src/3rdparty/chromium/base/json/string_escape.cc +@@ -14,7 +14,7 @@ + #include "base/strings/stringprintf.h" + #include "base/strings/utf_string_conversion_utils.h" + #include "base/strings/utf_string_conversions.h" +-#include "base/third_party/icu/icu_utf.h" ++#include + + namespace base { + +diff --git a/src/3rdparty/chromium/base/strings/pattern.cc b/src/3rdparty/chromium/base/strings/pattern.cc +index af30aab86..7df8f7255 100644 +--- a/src/3rdparty/chromium/base/strings/pattern.cc ++++ b/src/3rdparty/chromium/base/strings/pattern.cc +@@ -3,8 +3,7 @@ + // found in the LICENSE file. + + #include "base/strings/pattern.h" +- +-#include "base/third_party/icu/icu_utf.h" ++#include + + namespace base { + +@@ -39,7 +38,7 @@ static void EatSameChars(const CHAR** pattern, const CHAR* pattern_end, + const CHAR* string_next = *string; + base_icu::UChar32 pattern_char = next(&pattern_next, pattern_end); + if (pattern_char == next(&string_next, string_end) && +- pattern_char != CBU_SENTINEL) { ++ pattern_char != U_SENTINEL) { + *pattern = pattern_next; + *string = string_next; + } else { +@@ -136,7 +135,7 @@ struct NextCharUTF8 { + base_icu::UChar32 operator()(const char** p, const char* end) { + base_icu::UChar32 c; + int offset = 0; +- CBU8_NEXT(*p, offset, end - *p, c); ++ U8_NEXT(*p, offset, end - *p, c); + *p += offset; + return c; + } +@@ -146,7 +145,7 @@ struct NextCharUTF16 { + base_icu::UChar32 operator()(const char16** p, const char16* end) { + base_icu::UChar32 c; + int offset = 0; +- CBU16_NEXT(*p, offset, end - *p, c); ++ U16_NEXT(*p, offset, end - *p, c); + *p += offset; + return c; + } +diff --git a/src/3rdparty/chromium/base/strings/string_split.cc b/src/3rdparty/chromium/base/strings/string_split.cc +index a8180b24d..ac771a0f0 100644 +--- a/src/3rdparty/chromium/base/strings/string_split.cc ++++ b/src/3rdparty/chromium/base/strings/string_split.cc +@@ -8,7 +8,7 @@ + + #include "base/logging.h" + #include "base/strings/string_util.h" +-#include "base/third_party/icu/icu_utf.h" ++#include + + namespace base { + +diff --git a/src/3rdparty/chromium/base/strings/string_util.cc b/src/3rdparty/chromium/base/strings/string_util.cc +index cb668ed7f..542f12819 100644 +--- a/src/3rdparty/chromium/base/strings/string_util.cc ++++ b/src/3rdparty/chromium/base/strings/string_util.cc +@@ -25,7 +25,7 @@ + #include "base/memory/singleton.h" + #include "base/strings/utf_string_conversion_utils.h" + #include "base/strings/utf_string_conversions.h" +-#include "base/third_party/icu/icu_utf.h" ++#include + #include "build/build_config.h" + + namespace base { +@@ -357,19 +357,19 @@ void TruncateUTF8ToByteSize(const std::string& input, + } + DCHECK_LE(byte_size, + static_cast(std::numeric_limits::max())); +- // Note: This cast is necessary because CBU8_NEXT uses int32_ts. ++ // Note: This cast is necessary because U8_NEXT uses int32_ts. + int32_t truncation_length = static_cast(byte_size); + int32_t char_index = truncation_length - 1; + const char* data = input.data(); + +- // Using CBU8, we will move backwards from the truncation point ++ // Using U8, we will move backwards from the truncation point + // to the beginning of the string looking for a valid UTF8 + // character. Once a full UTF8 character is found, we will + // truncate the string to the end of that character. + while (char_index >= 0) { + int32_t prev = char_index; + base_icu::UChar32 code_point = 0; +- CBU8_NEXT(data, char_index, truncation_length, code_point); ++ U8_NEXT(data, char_index, truncation_length, code_point); + if (!IsValidCharacter(code_point) || + !IsValidCodepoint(code_point)) { + char_index = prev - 1; +@@ -522,7 +522,7 @@ bool IsStringUTF8(const StringPiece& str) { + + while (char_index < src_len) { + int32_t code_point; +- CBU8_NEXT(src, char_index, src_len, code_point); ++ U8_NEXT(src, char_index, src_len, code_point); + if (!IsValidCharacter(code_point)) + return false; + } +diff --git a/src/3rdparty/chromium/base/strings/utf_string_conversion_utils.cc b/src/3rdparty/chromium/base/strings/utf_string_conversion_utils.cc +index 3101a6028..7f7d84b3c 100644 +--- a/src/3rdparty/chromium/base/strings/utf_string_conversion_utils.cc ++++ b/src/3rdparty/chromium/base/strings/utf_string_conversion_utils.cc +@@ -4,7 +4,7 @@ + + #include "base/strings/utf_string_conversion_utils.h" + +-#include "base/third_party/icu/icu_utf.h" ++#include + + namespace base { + +@@ -18,7 +18,7 @@ bool ReadUnicodeCharacter(const char* src, + // use a signed type for code_point. But this function returns false + // on error anyway, so code_point_out is unsigned. + int32_t code_point; +- CBU8_NEXT(src, *char_index, src_len, code_point); ++ U8_NEXT(src, *char_index, src_len, code_point); + *code_point_out = static_cast(code_point); + + // The ICU macro above moves to the next char, we want to point to the last +@@ -33,16 +33,16 @@ bool ReadUnicodeCharacter(const char16* src, + int32_t src_len, + int32_t* char_index, + uint32_t* code_point) { +- if (CBU16_IS_SURROGATE(src[*char_index])) { +- if (!CBU16_IS_SURROGATE_LEAD(src[*char_index]) || ++ if (U16_IS_SURROGATE(src[*char_index])) { ++ if (!U16_IS_SURROGATE_LEAD(src[*char_index]) || + *char_index + 1 >= src_len || +- !CBU16_IS_TRAIL(src[*char_index + 1])) { ++ !U16_IS_TRAIL(src[*char_index + 1])) { + // Invalid surrogate pair. + return false; + } + + // Valid surrogate pair. +- *code_point = CBU16_GET_SUPPLEMENTARY(src[*char_index], ++ *code_point = U16_GET_SUPPLEMENTARY(src[*char_index], + src[*char_index + 1]); + (*char_index)++; + } else { +@@ -76,30 +76,30 @@ size_t WriteUnicodeCharacter(uint32_t code_point, std::string* output) { + } + + +- // CBU8_APPEND_UNSAFE can append up to 4 bytes. ++ // U8_APPEND_UNSAFE can append up to 4 bytes. + size_t char_offset = output->length(); + size_t original_char_offset = char_offset; +- output->resize(char_offset + CBU8_MAX_LENGTH); ++ output->resize(char_offset + U8_MAX_LENGTH); + +- CBU8_APPEND_UNSAFE(&(*output)[0], char_offset, code_point); ++ U8_APPEND_UNSAFE(&(*output)[0], char_offset, code_point); + +- // CBU8_APPEND_UNSAFE will advance our pointer past the inserted character, so ++ // U8_APPEND_UNSAFE will advance our pointer past the inserted character, so + // it will represent the new length of the string. + output->resize(char_offset); + return char_offset - original_char_offset; + } + + size_t WriteUnicodeCharacter(uint32_t code_point, string16* output) { +- if (CBU16_LENGTH(code_point) == 1) { ++ if (U16_LENGTH(code_point) == 1) { + // Thie code point is in the Basic Multilingual Plane (BMP). + output->push_back(static_cast(code_point)); + return 1; + } + // Non-BMP characters use a double-character encoding. + size_t char_offset = output->length(); +- output->resize(char_offset + CBU16_MAX_LENGTH); +- CBU16_APPEND_UNSAFE(&(*output)[0], char_offset, code_point); +- return CBU16_MAX_LENGTH; ++ output->resize(char_offset + U16_MAX_LENGTH); ++ U16_APPEND_UNSAFE(&(*output)[0], char_offset, code_point); ++ return U16_MAX_LENGTH; + } + + // Generalized Unicode converter ----------------------------------------------- +diff --git a/src/3rdparty/chromium/base/third_party/icu/icu_utf.cc b/src/3rdparty/chromium/base/third_party/icu/icu_utf.cc +index 2b67c5d9c..7ca6a6e0f 100644 +--- a/src/3rdparty/chromium/base/third_party/icu/icu_utf.cc ++++ b/src/3rdparty/chromium/base/third_party/icu/icu_utf.cc +@@ -17,7 +17,7 @@ + * that would otherwise be too long as macros. + */ + +-#include "base/third_party/icu/icu_utf.h" ++#include + + namespace base_icu { + +@@ -35,14 +35,14 @@ namespace base_icu { + * + * @deprecated ICU 2.4. Obsolete, see utf_old.h. + */ +-#define CBUTF8_ERROR_VALUE_1 0x15 ++#define UTF8_ERROR_VALUE_1 0x15 + + /** + * See documentation on UTF8_ERROR_VALUE_1 for details. + * + * @deprecated ICU 2.4. Obsolete, see utf_old.h. + */ +-#define CBUTF8_ERROR_VALUE_2 0x9f ++#define UTF8_ERROR_VALUE_2 0x9f + + + /** +@@ -51,7 +51,7 @@ namespace base_icu { + * + * @deprecated ICU 2.4. Obsolete, see utf_old.h. + */ +-#define CBUTF_ERROR_VALUE 0xffff ++#define UTF_ERROR_VALUE 0xffff + + /* + * This table could be replaced on many machines by +@@ -103,7 +103,7 @@ utf8_minLegal[4]={ 0, 0x80, 0x800, 0x10000 }; + + static const UChar32 + utf8_errorValue[6]={ +- CBUTF8_ERROR_VALUE_1, CBUTF8_ERROR_VALUE_2, CBUTF_ERROR_VALUE, 0x10ffff, ++ UTF8_ERROR_VALUE_1, UTF8_ERROR_VALUE_2, UTF_ERROR_VALUE, 0x10ffff, + 0x3ffffff, 0x7fffffff + }; + +@@ -135,11 +135,11 @@ UChar32 utf8_nextCharSafeBody(const uint8_t* s, + UChar32 c, + UBool strict) { + int32_t i = *pi; +- uint8_t count = CBU8_COUNT_TRAIL_BYTES(c); ++ uint8_t count = U8_COUNT_TRAIL_BYTES(c); + if((i)+count<=(length)) { + uint8_t trail, illegal = 0; + +- CBU8_MASK_LEAD_BYTE((c), count); ++ U8_MASK_LEAD_BYTE((c), count); + /* count==0 for illegally leading trail bytes and the illegal bytes 0xfe and 0xff */ + switch(count) { + /* each branch falls through to the next one */ +@@ -169,9 +169,9 @@ UChar32 utf8_nextCharSafeBody(const uint8_t* s, + break; + case 0: + if(strict>=0) { +- return CBUTF8_ERROR_VALUE_1; ++ return UTF8_ERROR_VALUE_1; + } else { +- return CBU_SENTINEL; ++ return U_SENTINEL; + } + /* no default branch to optimize switch() - all values are covered */ + } +@@ -189,21 +189,21 @@ UChar32 utf8_nextCharSafeBody(const uint8_t* s, + + /* correct sequence - all trail bytes have (b7..b6)==(10)? */ + /* illegal is also set if count>=4 */ +- if(illegal || (c)0 && CBU8_IS_TRAIL(s[i])) { ++ while(count>0 && U8_IS_TRAIL(s[i])) { + ++(i); + --count; + } + if(strict>=0) { + c=utf8_errorValue[errorCount-count]; + } else { +- c=CBU_SENTINEL; ++ c=U_SENTINEL; + } +- } else if((strict)>0 && CBU_IS_UNICODE_NONCHAR(c)) { ++ } else if((strict)>0 && U_IS_UNICODE_NONCHAR(c)) { + /* strict: forbid non-characters like U+fffe */ + c=utf8_errorValue[count]; + } +@@ -211,13 +211,13 @@ UChar32 utf8_nextCharSafeBody(const uint8_t* s, + /* error handling */ + int32_t i0 = i; + /* don't just set (i)=(length) in case there is an illegal sequence */ +- while((i)<(length) && CBU8_IS_TRAIL(s[i])) { ++ while((i)<(length) && U8_IS_TRAIL(s[i])) { + ++(i); + } + if(strict>=0) { + c=utf8_errorValue[i-i0]; + } else { +- c=CBU_SENTINEL; ++ c=U_SENTINEL; + } + } + *pi=i; +diff --git a/src/3rdparty/chromium/content/browser/devtools/devtools_io_context.cc b/src/3rdparty/chromium/content/browser/devtools/devtools_io_context.cc +index 55f65f8c3..a7d616115 100644 +--- a/src/3rdparty/chromium/content/browser/devtools/devtools_io_context.cc ++++ b/src/3rdparty/chromium/content/browser/devtools/devtools_io_context.cc +@@ -8,7 +8,7 @@ + #include "base/files/file_util.h" + #include "base/strings/string_number_conversions.h" + #include "base/strings/string_util.h" +-#include "base/third_party/icu/icu_utf.h" ++#include + #include "content/public/browser/browser_thread.h" + + namespace content { +@@ -87,7 +87,7 @@ void Stream::ReadOnFileThread(off_t position, size_t max_size, + } else { + // Provided client has requested sufficient large block, make their + // life easier by not truncating in the middle of a UTF-8 character. +- if (size_got > 6 && !CBU8_IS_SINGLE(buffer[size_got - 1])) { ++ if (size_got > 6 && !U8_IS_SINGLE(buffer[size_got - 1])) { + base::TruncateUTF8ToByteSize(buffer, size_got, &buffer); + size_got = buffer.size(); + } else { +diff --git a/src/3rdparty/chromium/net/cert/internal/parse_name.cc b/src/3rdparty/chromium/net/cert/internal/parse_name.cc +index bb9b64051..5eaeb52d0 100644 +--- a/src/3rdparty/chromium/net/cert/internal/parse_name.cc ++++ b/src/3rdparty/chromium/net/cert/internal/parse_name.cc +@@ -10,7 +10,7 @@ + #include "base/strings/utf_string_conversion_utils.h" + #include "base/strings/utf_string_conversions.h" + #include "base/sys_byteorder.h" +-#include "base/third_party/icu/icu_utf.h" ++#include + + namespace net { + +@@ -35,7 +35,7 @@ bool ConvertBmpStringValue(const der::Input& in, std::string* out) { + + // BMPString only supports codepoints in the Basic Multilingual Plane; + // surrogates are not allowed. +- if (CBU_IS_SURROGATE(c)) ++ if (U_IS_SURROGATE(c)) + return false; + } + return base::UTF16ToUTF8(in_16bit.data(), in_16bit.size(), out); +@@ -55,7 +55,7 @@ bool ConvertUniversalStringValue(const der::Input& in, std::string* out) { + for (const uint32_t c : in_32bit) { + // UniversalString is UCS-4 in big-endian order. + uint32_t codepoint = base::NetToHost32(c); +- if (!CBU_IS_UNICODE_CHAR(codepoint)) ++ if (!U_IS_UNICODE_CHAR(codepoint)) + return false; + + base::WriteUnicodeCharacter(codepoint, out); +diff --git a/src/3rdparty/chromium/ui/base/ime/input_method_chromeos.cc b/src/3rdparty/chromium/ui/base/ime/input_method_chromeos.cc +index a8ac9028f..8fa5d2a64 100644 +--- a/src/3rdparty/chromium/ui/base/ime/input_method_chromeos.cc ++++ b/src/3rdparty/chromium/ui/base/ime/input_method_chromeos.cc +@@ -17,7 +17,7 @@ + #include "base/strings/string_util.h" + #include "base/strings/utf_string_conversions.h" + #include "base/sys_info.h" +-#include "base/third_party/icu/icu_utf.h" ++#include + #include "ui/base/ime/chromeos/ime_keyboard.h" + #include "ui/base/ime/chromeos/input_method_manager.h" + #include "ui/base/ime/composition_text.h" +diff --git a/src/3rdparty/chromium/ui/gfx/utf16_indexing.cc b/src/3rdparty/chromium/ui/gfx/utf16_indexing.cc +index c7f38de0d..08a0ff5fb 100644 +--- a/src/3rdparty/chromium/ui/gfx/utf16_indexing.cc ++++ b/src/3rdparty/chromium/ui/gfx/utf16_indexing.cc +@@ -5,13 +5,13 @@ + #include "ui/gfx/utf16_indexing.h" + + #include "base/logging.h" +-#include "base/third_party/icu/icu_utf.h" ++#include + + namespace gfx { + + bool IsValidCodePointIndex(const base::string16& s, size_t index) { + return index == 0 || index == s.length() || +- !(CBU16_IS_TRAIL(s[index]) && CBU16_IS_LEAD(s[index - 1])); ++ !(U16_IS_TRAIL(s[index]) && U16_IS_LEAD(s[index - 1])); + } + + ptrdiff_t UTF16IndexToOffset(const base::string16& s, size_t base, size_t pos) { +-- +2.13.0 + diff --git a/0004-qtwebengine-opensource-src-5.9.0-no-sse2.patch b/0004-qtwebengine-opensource-src-5.9.0-no-sse2.patch new file mode 100644 index 0000000..5df622b --- /dev/null +++ b/0004-qtwebengine-opensource-src-5.9.0-no-sse2.patch @@ -0,0 +1,4971 @@ +From 844246bd10971ec348f044bc7a13acb17b9ce033 Mon Sep 17 00:00:00 2001 +From: Helio Chissini de Castro +Date: Wed, 31 May 2017 14:38:20 +0200 +Subject: [PATCH] qtwebengine-opensource-src-5.9.0-no-sse2 + +--- + .../chromium/breakpad/src/build/common.gypi | 8 +- + src/3rdparty/chromium/cc/BUILD.gn | 39 +- + src/3rdparty/chromium/media/BUILD.gn | 20 + + src/3rdparty/chromium/media/base/BUILD.gn | 48 +- + src/3rdparty/chromium/media/base/media.cc | 4 + + .../chromium/media/base/simd/convert_yuv_to_rgb.h | 34 + + .../media/base/simd/convert_yuv_to_rgb_mmx.asm | 24 + + .../media/base/simd/convert_yuv_to_rgb_x86.cc | 56 + + src/3rdparty/chromium/media/base/simd/filter_yuv.h | 6 + + .../chromium/media/base/simd/filter_yuv_mmx.cc | 79 + + .../chromium/media/base/simd/sinc_resampler_sse.cc | 50 + + .../chromium/media/base/simd/vector_math_sse.cc | 118 + + src/3rdparty/chromium/media/base/sinc_resampler.cc | 81 +- + src/3rdparty/chromium/media/base/sinc_resampler.h | 4 + + .../chromium/media/base/sinc_resampler_perftest.cc | 4 + + .../chromium/media/base/sinc_resampler_unittest.cc | 5 + + src/3rdparty/chromium/media/base/vector_math.cc | 150 +- + src/3rdparty/chromium/media/base/vector_math.h | 5 + + .../chromium/media/base/vector_math_perftest.cc | 35 +- + .../chromium/media/base/vector_math_testing.h | 2 +- + .../chromium/media/base/vector_math_unittest.cc | 4 + + src/3rdparty/chromium/media/base/yuv_convert.cc | 50 +- + .../chromium/media/base/yuv_convert_perftest.cc | 79 +- + .../chromium/media/base/yuv_convert_unittest.cc | 159 +- + src/3rdparty/chromium/skia/BUILD.gn | 52 +- + src/3rdparty/chromium/skia/ext/convolver.cc | 11 +- + src/3rdparty/chromium/skia/ext/convolver.h | 1 + + .../Source/modules/webaudio/AudioParamTimeline.cpp | 8 +- + .../Source/platform/audio/DirectConvolver.cpp | 40 +- + .../WebKit/Source/platform/audio/DirectConvolver.h | 7 + + .../WebKit/Source/platform/audio/SincResampler.cpp | 31 +- + .../WebKit/Source/platform/audio/SincResampler.h | 7 + + .../WebKit/Source/platform/audio/VectorMath.cpp | 97 +- + .../WebKit/Source/platform/audio/VectorMath.h | 23 + + .../graphics/cpu/x86/WebGLImageConversionSSE.h | 2 +- + .../platform/graphics/gpu/WebGLImageConversion.cpp | 12 +- + src/3rdparty/chromium/third_party/qcms/BUILD.gn | 17 +- + .../webrtc/common_audio/real_fourier.cc | 9 + + src/3rdparty/chromium/v8/BUILD.gn | 72 +- + src/3rdparty/chromium/v8/src/make-v8-sse2-gyp.sh | 56 + + src/3rdparty/chromium/v8/src/v8.gyp | 12 +- + src/3rdparty/chromium/v8/src/v8_sse2.gyp | 2313 ++++++++++++++++++++ + src/core/core_module.pro | 30 +- + 43 files changed, 3537 insertions(+), 327 deletions(-) + create mode 100644 src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_mmx.asm + create mode 100644 src/3rdparty/chromium/media/base/simd/filter_yuv_mmx.cc + create mode 100644 src/3rdparty/chromium/media/base/simd/sinc_resampler_sse.cc + create mode 100644 src/3rdparty/chromium/media/base/simd/vector_math_sse.cc + create mode 100644 src/3rdparty/chromium/v8/src/make-v8-sse2-gyp.sh + create mode 100644 src/3rdparty/chromium/v8/src/v8_sse2.gyp + +diff --git a/src/3rdparty/chromium/breakpad/src/build/common.gypi b/src/3rdparty/chromium/breakpad/src/build/common.gypi +index b9466a325..8ad78e24f 100644 +--- a/src/3rdparty/chromium/breakpad/src/build/common.gypi ++++ b/src/3rdparty/chromium/breakpad/src/build/common.gypi +@@ -80,8 +80,8 @@ + # The system root for cross-compiles. Default: none. + 'sysroot%': '', + +- # On Linux, we build with sse2 for Chromium builds. +- 'disable_sse2%': 0, ++ # Do not assume SSE2 by default (Fedora patch). ++ 'disable_sse2%': 1, + }, + + 'target_arch%': '<(target_arch)', +@@ -725,17 +725,13 @@ + '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', +diff --git a/src/3rdparty/chromium/cc/BUILD.gn b/src/3rdparty/chromium/cc/BUILD.gn +index e461a898d..b50659b89 100644 +--- a/src/3rdparty/chromium/cc/BUILD.gn ++++ b/src/3rdparty/chromium/cc/BUILD.gn +@@ -567,13 +567,6 @@ component("cc") { + "trees/tree_synchronizer.h", + ] + +- if (current_cpu == "x86" || current_cpu == "x64") { +- sources += [ +- "raster/texture_compressor_etc1_sse.cc", +- "raster/texture_compressor_etc1_sse.h", +- ] +- } +- + configs += [ "//build/config:precompiled_headers" ] + + public_deps = [ +@@ -583,6 +576,7 @@ component("cc") { + deps = [ + "//base", + "//base/third_party/dynamic_annotations", ++ "//cc:cc_opts", + "//cc/proto", + "//cc/surfaces:surface_id", + "//gpu", +@@ -612,6 +606,37 @@ component("cc") { + } + } + ++source_set("cc_opts") { ++ public_deps = [ ++ "//cc:cc_opts_sse", ++ ] ++} ++ ++source_set("cc_opts_sse") { ++ if (current_cpu == "x86" || current_cpu == "x64") { ++ 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" ] ++ } ++} ++ ++ + static_library("test_support") { + testonly = true + sources = [ +diff --git a/src/3rdparty/chromium/media/BUILD.gn b/src/3rdparty/chromium/media/BUILD.gn +index 652aad4d9..063254830 100644 +--- a/src/3rdparty/chromium/media/BUILD.gn ++++ b/src/3rdparty/chromium/media/BUILD.gn +@@ -832,6 +832,26 @@ component("shared_memory_support") { + "//base", + "//ui/gfx/geometry", + ] ++ 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" ] ++ } ++ } + } + + # TODO(watk): Refactor tests that could be made to run on Android. See +diff --git a/src/3rdparty/chromium/media/base/BUILD.gn b/src/3rdparty/chromium/media/base/BUILD.gn +index d288ec787..fac712c00 100644 +--- a/src/3rdparty/chromium/media/base/BUILD.gn ++++ b/src/3rdparty/chromium/media/base/BUILD.gn +@@ -336,11 +336,12 @@ target(link_target_type, "base") { + } + + 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" ] + } +@@ -539,10 +540,47 @@ source_set("perftests") { + } + + 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", +diff --git a/src/3rdparty/chromium/media/base/media.cc b/src/3rdparty/chromium/media/base/media.cc +index 38daf05b8..bb43b405f 100644 +--- a/src/3rdparty/chromium/media/base/media.cc ++++ b/src/3rdparty/chromium/media/base/media.cc +@@ -10,6 +10,8 @@ + #include "base/metrics/field_trial.h" + #include "base/trace_event/trace_event.h" + #include "media/base/media_switches.h" ++#include "media/base/sinc_resampler.h" ++#include "media/base/vector_math.h" + #include "media/base/yuv_convert.h" + + #if defined(OS_ANDROID) +@@ -40,6 +42,8 @@ class MediaInitializer { + TRACE_EVENT_WARMUP_CATEGORY("media"); + + // Perform initialization of libraries which require runtime CPU detection. ++ vector_math::Initialize(); ++ SincResampler::InitializeCPUSpecificFeatures(); + InitializeCPUSpecificYUVConversions(); + + #if !defined(MEDIA_DISABLE_FFMPEG) +diff --git a/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb.h b/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb.h +index a421ff566..8373fde90 100644 +--- a/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb.h ++++ b/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb.h +@@ -65,6 +65,17 @@ MEDIA_EXPORT void ConvertYUVToRGB32_SSE(const uint8_t* yplane, + int rgbstride, + YUVType yuv_type); + ++MEDIA_EXPORT void ConvertYUVToRGB32_MMX(const uint8_t* yplane, ++ const uint8_t* uplane, ++ const uint8_t* vplane, ++ uint8_t* rgbframe, ++ int width, ++ int height, ++ int ystride, ++ int uvstride, ++ int rgbstride, ++ YUVType yuv_type); ++ + MEDIA_EXPORT void ConvertYUVAToARGB_MMX(const uint8_t* yplane, + const uint8_t* uplane, + const uint8_t* vplane, +@@ -86,6 +97,13 @@ MEDIA_EXPORT void ScaleYUVToRGB32Row_C(const uint8_t* y_buf, + ptrdiff_t source_dx, + 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, ++ ptrdiff_t width, ++ const int16_t* convert_table); ++ + MEDIA_EXPORT void LinearScaleYUVToRGB32Row_C(const uint8_t* y_buf, + const uint8_t* u_buf, + const uint8_t* v_buf, +@@ -94,6 +112,14 @@ MEDIA_EXPORT void LinearScaleYUVToRGB32Row_C(const uint8_t* y_buf, + ptrdiff_t source_dx, + const int16_t* convert_table); + ++MEDIA_EXPORT void ScaleYUVToRGB32Row_MMX(const uint8_t* y_buf, ++ const uint8_t* u_buf, ++ const uint8_t* v_buf, ++ uint8_t* rgb_buf, ++ ptrdiff_t width, ++ ptrdiff_t source_dx, ++ const int16_t* convert_table); ++ + MEDIA_EXPORT void LinearScaleYUVToRGB32RowWithRange_C( + const uint8_t* y_buf, + const uint8_t* u_buf, +@@ -104,6 +130,14 @@ MEDIA_EXPORT void LinearScaleYUVToRGB32RowWithRange_C( + int source_dx, + const int16_t* convert_table); + ++MEDIA_EXPORT void LinearScaleYUVToRGB32Row_MMX(const uint8_t* y_buf, ++ const uint8_t* u_buf, ++ const uint8_t* v_buf, ++ uint8_t* rgb_buf, ++ ptrdiff_t width, ++ ptrdiff_t source_dx, ++ const int16_t* convert_table); ++ + } // namespace media + + // Assembly functions are declared without namespace. +diff --git a/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_mmx.asm b/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_mmx.asm +new file mode 100644 +index 000000000..3650c9f73 +--- /dev/null ++++ b/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_mmx.asm +@@ -0,0 +1,24 @@ ++; 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" ++ +diff --git a/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_x86.cc b/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_x86.cc +index a06799bfd..819bb60a8 100644 +--- a/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_x86.cc ++++ b/src/3rdparty/chromium/media/base/simd/convert_yuv_to_rgb_x86.cc +@@ -47,6 +47,62 @@ void ConvertYUVAToARGB_MMX(const uint8_t* yplane, + EmptyRegisterState(); + } + ++void ConvertYUVToRGB32_MMX(const uint8_t* yplane, ++ const uint8_t* uplane, ++ const uint8_t* vplane, ++ uint8_t* rgbframe, ++ 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) { ++ 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; ++ ++ ConvertYUVToRGB32Row_MMX(y_ptr, ++ u_ptr, ++ v_ptr, ++ rgb_row, ++ width, ++ GetLookupTable(yuv_type)); ++ } ++ ++ EmptyRegisterState(); ++} ++ ++void ConvertYUVToRGB32_MMX(const uint8_t* yplane, ++ const uint8_t* uplane, ++ const uint8_t* vplane, ++ uint8_t* rgbframe, ++ 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) { ++ 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; ++ ++ ConvertYUVToRGB32Row_MMX(y_ptr, ++ u_ptr, ++ v_ptr, ++ rgb_row, ++ width, ++ GetLookupTable(yuv_type)); ++ } ++ ++ EmptyRegisterState(); ++} ++ + void ConvertYUVToRGB32_SSE(const uint8_t* yplane, + const uint8_t* uplane, + const uint8_t* vplane, +diff --git a/src/3rdparty/chromium/media/base/simd/filter_yuv.h b/src/3rdparty/chromium/media/base/simd/filter_yuv.h +index af30bd133..206fb7f11 100644 +--- a/src/3rdparty/chromium/media/base/simd/filter_yuv.h ++++ b/src/3rdparty/chromium/media/base/simd/filter_yuv.h +@@ -20,6 +20,12 @@ MEDIA_EXPORT void FilterYUVRows_C(uint8_t* ybuf, + int source_width, + uint8_t source_y_fraction); + ++MEDIA_EXPORT void FilterYUVRows_MMX(uint8_t* ybuf, ++ const uint8_t* y0_ptr, ++ const uint8_t* y1_ptr, ++ int source_width, ++ uint8_t source_y_fraction); ++ + MEDIA_EXPORT void FilterYUVRows_SSE2(uint8_t* ybuf, + const uint8_t* y0_ptr, + const uint8_t* y1_ptr, +diff --git a/src/3rdparty/chromium/media/base/simd/filter_yuv_mmx.cc b/src/3rdparty/chromium/media/base/simd/filter_yuv_mmx.cc +new file mode 100644 +index 000000000..416aca699 +--- /dev/null ++++ b/src/3rdparty/chromium/media/base/simd/filter_yuv_mmx.cc +@@ -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 ++#else ++#include ++#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 ++ ++void FilterYUVRows_MMX(uint8_t* dest, ++ const uint8_t* src0, ++ const uint8_t* src1, ++ int width, ++ uint8_t fraction) { ++ int pixel = 0; ++ ++ // Process the unaligned bytes first. ++ int unaligned_width = ++ (8 - (reinterpret_cast(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(src0 + pixel); ++ const __m64* src1_64 = reinterpret_cast(src1 + pixel); ++ __m64* dest64 = reinterpret_cast<__m64*>(dest + pixel); ++ __m64* end64 = reinterpret_cast<__m64*>( ++ reinterpret_cast(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 +diff --git a/src/3rdparty/chromium/media/base/simd/sinc_resampler_sse.cc b/src/3rdparty/chromium/media/base/simd/sinc_resampler_sse.cc +new file mode 100644 +index 000000000..c5d03dc48 +--- /dev/null ++++ b/src/3rdparty/chromium/media/base/simd/sinc_resampler_sse.cc +@@ -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 ++ ++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(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(1.0 - kernel_interpolation_factor))); ++ m_sums2 = _mm_mul_ps(m_sums2, _mm_set_ps1( ++ static_cast(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 +diff --git a/src/3rdparty/chromium/media/base/simd/vector_math_sse.cc b/src/3rdparty/chromium/media/base/simd/vector_math_sse.cc +new file mode 100644 +index 000000000..c2121225c +--- /dev/null ++++ b/src/3rdparty/chromium/media/base/simd/vector_math_sse.cc +@@ -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 ++ ++#include // 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 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 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 +diff --git a/src/3rdparty/chromium/media/base/sinc_resampler.cc b/src/3rdparty/chromium/media/base/sinc_resampler.cc +index cffb0c9d6..010775544 100644 +--- a/src/3rdparty/chromium/media/base/sinc_resampler.cc ++++ b/src/3rdparty/chromium/media/base/sinc_resampler.cc +@@ -81,17 +81,12 @@ + #include + #include + ++#include "base/cpu.h" + #include "base/logging.h" + #include "build/build_config.h" + +-#if defined(ARCH_CPU_X86_FAMILY) +-#include +-#define CONVOLVE_FUNC Convolve_SSE +-#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON) ++#if defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON) + #include +-#define CONVOLVE_FUNC Convolve_NEON +-#else +-#define CONVOLVE_FUNC Convolve_C + #endif + + namespace media { +@@ -112,10 +107,41 @@ static double SincScaleFactor(double io_ratio) { + 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) +@@ -328,46 +354,7 @@ float SincResampler::Convolve_C(const float* input_ptr, const float* k1, + 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(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(1.0 - kernel_interpolation_factor))); +- m_sums2 = _mm_mul_ps(m_sums2, _mm_set_ps1( +- static_cast(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) { +diff --git a/src/3rdparty/chromium/media/base/sinc_resampler.h b/src/3rdparty/chromium/media/base/sinc_resampler.h +index afbd2abc9..9e3df2c55 100644 +--- a/src/3rdparty/chromium/media/base/sinc_resampler.h ++++ b/src/3rdparty/chromium/media/base/sinc_resampler.h +@@ -36,6 +36,10 @@ class MEDIA_EXPORT SincResampler { + 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. +diff --git a/src/3rdparty/chromium/media/base/sinc_resampler_perftest.cc b/src/3rdparty/chromium/media/base/sinc_resampler_perftest.cc +index 9cb7f4f2e..285382490 100644 +--- a/src/3rdparty/chromium/media/base/sinc_resampler_perftest.cc ++++ b/src/3rdparty/chromium/media/base/sinc_resampler_perftest.cc +@@ -4,6 +4,7 @@ + + #include "base/bind.h" + #include "base/bind_helpers.h" ++#include "base/cpu.h" + #include "base/time/time.h" + #include "build/build_config.h" + #include "media/base/sinc_resampler.h" +@@ -61,6 +62,9 @@ TEST(SincResamplerPerfTest, Convolve) { + &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( +diff --git a/src/3rdparty/chromium/media/base/sinc_resampler_unittest.cc b/src/3rdparty/chromium/media/base/sinc_resampler_unittest.cc +index 8dd346ee4..7401eee96 100644 +--- a/src/3rdparty/chromium/media/base/sinc_resampler_unittest.cc ++++ b/src/3rdparty/chromium/media/base/sinc_resampler_unittest.cc +@@ -10,6 +10,7 @@ + + #include "base/bind.h" + #include "base/bind_helpers.h" ++#include "base/cpu.h" + #include "base/macros.h" + #include "base/strings/string_number_conversions.h" + #include "base/time/time.h" +@@ -166,6 +167,10 @@ TEST(SincResamplerTest, DISABLED_SetRatioBench) { + 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( +diff --git a/src/3rdparty/chromium/media/base/vector_math.cc b/src/3rdparty/chromium/media/base/vector_math.cc +index 578290538..e041d8d4c 100644 +--- a/src/3rdparty/chromium/media/base/vector_math.cc ++++ b/src/3rdparty/chromium/media/base/vector_math.cc +@@ -7,12 +7,17 @@ + + #include + ++#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 ++#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 (*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 + #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(src) & (kRequiredAlignment - 1)); +@@ -89,111 +126,6 @@ std::pair EWMAAndMaxPower_C( + 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 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 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; +diff --git a/src/3rdparty/chromium/media/base/vector_math.h b/src/3rdparty/chromium/media/base/vector_math.h +index a148ca050..0a2cb06f6 100644 +--- a/src/3rdparty/chromium/media/base/vector_math.h ++++ b/src/3rdparty/chromium/media/base/vector_math.h +@@ -15,6 +15,11 @@ namespace vector_math { + // 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[]); +diff --git a/src/3rdparty/chromium/media/base/vector_math_perftest.cc b/src/3rdparty/chromium/media/base/vector_math_perftest.cc +index 59b259dc2..c4c89a3b5 100644 +--- a/src/3rdparty/chromium/media/base/vector_math_perftest.cc ++++ b/src/3rdparty/chromium/media/base/vector_math_perftest.cc +@@ -5,6 +5,7 @@ + #include + + #include "base/macros.h" ++#include "base/cpu.h" + #include "base/memory/aligned_memory.h" + #include "base/time/time.h" + #include "build/build_config.h" +@@ -82,15 +83,11 @@ class VectorMathPerfTest : public testing::Test { + 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. +@@ -99,6 +96,9 @@ TEST_F(VectorMathPerfTest, FMAC) { + 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); +@@ -112,12 +112,24 @@ TEST_F(VectorMathPerfTest, FMAC) { + #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); +@@ -131,6 +143,14 @@ TEST_F(VectorMathPerfTest, FMUL) { + #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(). +@@ -139,6 +159,9 @@ TEST_F(VectorMathPerfTest, EWMAAndMaxPower) { + "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); +@@ -156,4 +179,6 @@ TEST_F(VectorMathPerfTest, EWMAAndMaxPower) { + #endif + } + ++#undef EWMAAndMaxPower_FUNC ++ + } // namespace media +diff --git a/src/3rdparty/chromium/media/base/vector_math_testing.h b/src/3rdparty/chromium/media/base/vector_math_testing.h +index 9240fbf54..b0b304409 100644 +--- a/src/3rdparty/chromium/media/base/vector_math_testing.h ++++ b/src/3rdparty/chromium/media/base/vector_math_testing.h +@@ -19,7 +19,7 @@ MEDIA_EXPORT void FMUL_C(const float src[], float scale, int len, float dest[]); + MEDIA_EXPORT std::pair 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, +diff --git a/src/3rdparty/chromium/media/base/vector_math_unittest.cc b/src/3rdparty/chromium/media/base/vector_math_unittest.cc +index 3fcb3fad4..c4e8586aa 100644 +--- a/src/3rdparty/chromium/media/base/vector_math_unittest.cc ++++ b/src/3rdparty/chromium/media/base/vector_math_unittest.cc +@@ -9,6 +9,7 @@ + #include + + #include "base/macros.h" ++#include "base/cpu.h" + #include "base/memory/aligned_memory.h" + #include "base/strings/string_number_conversions.h" + #include "base/strings/stringize_macros.h" +@@ -78,6 +79,7 @@ TEST_F(VectorMathTest, FMAC) { + + #if defined(ARCH_CPU_X86_FAMILY) + { ++ ASSERT_TRUE(base::CPU().has_sse()); + SCOPED_TRACE("FMAC_SSE"); + FillTestVectors(kInputFillValue, kOutputFillValue); + vector_math::FMAC_SSE( +@@ -119,6 +121,7 @@ TEST_F(VectorMathTest, FMUL) { + + #if defined(ARCH_CPU_X86_FAMILY) + { ++ ASSERT_TRUE(base::CPU().has_sse()); + SCOPED_TRACE("FMUL_SSE"); + FillTestVectors(kInputFillValue, kOutputFillValue); + vector_math::FMUL_SSE( +@@ -227,6 +230,7 @@ class EWMATestScenario { + + #if defined(ARCH_CPU_X86_FAMILY) + { ++ ASSERT_TRUE(base::CPU().has_sse()); + SCOPED_TRACE("EWMAAndMaxPower_SSE"); + const std::pair& result = vector_math::EWMAAndMaxPower_SSE( + initial_value_, data_.get(), data_len_, smoothing_factor_); +diff --git a/src/3rdparty/chromium/media/base/yuv_convert.cc b/src/3rdparty/chromium/media/base/yuv_convert.cc +index 2cdd9b1fd..2fc643416 100644 +--- a/src/3rdparty/chromium/media/base/yuv_convert.cc ++++ b/src/3rdparty/chromium/media/base/yuv_convert.cc +@@ -32,7 +32,7 @@ + #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 + #else +@@ -133,7 +133,7 @@ static const int16_t* g_table_rec709_ptr = NULL; + + // 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)(); +@@ -247,34 +247,46 @@ void InitializeCPUSpecificYUVConversions() { + // 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; + +diff --git a/src/3rdparty/chromium/media/base/yuv_convert_perftest.cc b/src/3rdparty/chromium/media/base/yuv_convert_perftest.cc +index ddf777cf3..f5520fd58 100644 +--- a/src/3rdparty/chromium/media/base/yuv_convert_perftest.cc ++++ b/src/3rdparty/chromium/media/base/yuv_convert_perftest.cc +@@ -71,6 +71,29 @@ class YUVConvertPerfTest : public testing::Test { + DISALLOW_COPY_AND_ASSIGN(YUVConvertPerfTest); + }; + ++TEST_F(YUVConvertPerfTest, ConvertYUVToRGB32Row_MMX) { ++ ASSERT_TRUE(base::CPU().has_mmx()); ++ ++ base::TimeTicks start = base::TimeTicks::Now(); ++ 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)); ++ } ++ } ++ media::EmptyRegisterState(); ++ double total_time_seconds = (base::TimeTicks::Now() - start).InSecondsF(); ++ 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()); + +@@ -161,9 +184,32 @@ TEST_F(YUVConvertPerfTest, I422AlphaToARGBRow_SSSE3) { + } + #endif + +-// 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. ++ ++ base::TimeTicks start = base::TimeTicks::Now(); ++ 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)); ++ } ++ } ++ media::EmptyRegisterState(); ++ double total_time_seconds = (base::TimeTicks::Now() - start).InSecondsF(); ++ 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()); + +@@ -190,6 +236,32 @@ TEST_F(YUVConvertPerfTest, ScaleYUVToRGB32Row_SSE) { + kPerfTestIterations / total_time_seconds, "runs/s", true); + } + ++TEST_F(YUVConvertPerfTest, LinearScaleYUVToRGB32Row_MMX) { ++ ASSERT_TRUE(base::CPU().has_mmx()); ++ ++ const int kSourceDx = 80000; // This value means a scale down. ++ ++ base::TimeTicks start = base::TimeTicks::Now(); ++ 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)); ++ } ++ } ++ media::EmptyRegisterState(); ++ double total_time_seconds = (base::TimeTicks::Now() - start).InSecondsF(); ++ 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()); + +@@ -215,7 +287,6 @@ TEST_F(YUVConvertPerfTest, LinearScaleYUVToRGB32Row_SSE) { + "yuv_convert_perftest", "", "LinearScaleYUVToRGB32Row_SSE", + 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) + +diff --git a/src/3rdparty/chromium/media/base/yuv_convert_unittest.cc b/src/3rdparty/chromium/media/base/yuv_convert_unittest.cc +index ec872c89b..801466add 100644 +--- a/src/3rdparty/chromium/media/base/yuv_convert_unittest.cc ++++ b/src/3rdparty/chromium/media/base/yuv_convert_unittest.cc +@@ -643,6 +643,37 @@ TEST(YUVConvertTest, RGB32ToYUV_SSE2_MatchReference) { + 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 yuv_bytes(new uint8[kYUV12Size]); ++ scoped_ptr rgb_bytes_reference(new uint8[kRGBSize]); ++ scoped_ptr 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()) { +@@ -674,9 +705,40 @@ TEST(YUVConvertTest, ConvertYUVToRGB32Row_SSE) { + 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 yuv_bytes(new uint8[kYUV12Size]); ++ scoped_ptr rgb_bytes_reference(new uint8[kRGBSize]); ++ scoped_ptr 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()) { +@@ -711,6 +773,40 @@ TEST(YUVConvertTest, ScaleYUVToRGB32Row_SSE) { + kWidth * kBpp)); + } + ++TEST(YUVConvertTest, LinearScaleYUVToRGB32Row_MMX) { ++ base::CPU cpu; ++ if (!cpu.has_mmx()) { ++ LOG(WARNING) << "System not supported. Test skipped."; ++ return; ++ } ++ ++ scoped_ptr yuv_bytes(new uint8[kYUV12Size]); ++ scoped_ptr rgb_bytes_reference(new uint8[kRGBSize]); ++ scoped_ptr 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()) { +@@ -744,7 +840,6 @@ TEST(YUVConvertTest, LinearScaleYUVToRGB32Row_SSE) { + rgb_bytes_converted.get(), + kWidth * kBpp)); + } +-#endif // defined(OS_WIN) && (ARCH_CPU_X86 || COMPONENT_BUILD) + + TEST(YUVConvertTest, FilterYUVRows_C_OutOfBounds) { + std::unique_ptr src(new uint8_t[16]); +@@ -761,6 +856,30 @@ TEST(YUVConvertTest, FilterYUVRows_C_OutOfBounds) { + } + } + ++#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 src(new uint8[16]); ++ scoped_ptr 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()) { +@@ -782,6 +901,38 @@ TEST(YUVConvertTest, FilterYUVRows_SSE2_OutOfBounds) { + } + } + ++#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 src(new uint8[kSize]); ++ scoped_ptr dst_sample(new uint8[kSize]); ++ scoped_ptr 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( ++ (reinterpret_cast(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()) { +diff --git a/src/3rdparty/chromium/skia/BUILD.gn b/src/3rdparty/chromium/skia/BUILD.gn +index 55854ffe6..9a1d4ec0f 100644 +--- a/src/3rdparty/chromium/skia/BUILD.gn ++++ b/src/3rdparty/chromium/skia/BUILD.gn +@@ -1,38 +1,3 @@ +-# Copyright (c) 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. +- +-import("//build/config/features.gni") +-import("//build/config/ui.gni") +-import("//printing/features/features.gni") +-import("//testing/test.gni") +-import("//third_party/skia/gn/shared_sources.gni") +- +-if (current_cpu == "arm") { +- import("//build/config/arm.gni") +-} +-if (current_cpu == "mipsel" || current_cpu == "mips64el") { +- import("//build/config/mips.gni") +-} +- +-skia_support_gpu = !is_ios +-skia_support_pdf = !is_ios && (enable_basic_printing || enable_print_preview) +- +-# When building Chrome for iOS with GYP, the target cpu is not known during +-# the invocation of gyp. This cause the iOS build to use non-optimised skia. +-# Replicate this with GN to avoid introducing regression as recommended by +-# the OWNERS of skia. +- +-declare_args() { +- skia_whitelist_serialized_typefaces = false +- +- # TODO(crbug.com/607933): Once GYP is no longer supported, port iOS to use +- # optimised skia. +- skia_build_no_opts = is_ios +-} +- +-# External-facing config for dependent code. +-config("skia_config") { + include_dirs = [ + "config", + "ext", +@@ -608,7 +573,15 @@ source_set("skia_opts") { + if (skia_build_no_opts) { + sources = skia_opts.none_sources + } else if (current_cpu == "x86" || current_cpu == "x64") { +- sources = skia_opts.sse2_sources ++ sources = skia_opts.sse2_sources + ++ [ ++ # Chrome-specific. ++ "ext/convolver_SSE2.cc", ++ "ext/convolver_SSE2.h", ++ ] ++ if (!is_win || is_clang) { ++ cflags += [ "-msse2" ] ++ } + deps += [ + ":skia_opts_avx", + ":skia_opts_hsw", +@@ -644,6 +617,13 @@ source_set("skia_opts") { + + if (mips_dsp_rev >= 1) { + sources = 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 = skia_opts.none_sources + } +diff --git a/src/3rdparty/chromium/skia/ext/convolver.cc b/src/3rdparty/chromium/skia/ext/convolver.cc +index 092fefaa9..4b40ffd2c 100644 +--- a/src/3rdparty/chromium/skia/ext/convolver.cc ++++ b/src/3rdparty/chromium/skia/ext/convolver.cc +@@ -362,10 +362,13 @@ struct ConvolveProcs { + + 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; +diff --git a/src/3rdparty/chromium/skia/ext/convolver.h b/src/3rdparty/chromium/skia/ext/convolver.h +index 1f33d4c0f..f7cd4770a 100644 +--- a/src/3rdparty/chromium/skia/ext/convolver.h ++++ b/src/3rdparty/chromium/skia/ext/convolver.h +@@ -11,6 +11,7 @@ + #include + + #include "build/build_config.h" ++#include "base/cpu.h" + #include "third_party/skia/include/core/SkSize.h" + #include "third_party/skia/include/core/SkTypes.h" + +diff --git a/src/3rdparty/chromium/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp b/src/3rdparty/chromium/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp +index 8e558f439..20ba17688 100644 +--- a/src/3rdparty/chromium/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp ++++ b/src/3rdparty/chromium/third_party/WebKit/Source/modules/webaudio/AudioParamTimeline.cpp +@@ -31,7 +31,7 @@ + #include "wtf/MathExtras.h" + #include + +-#if CPU(X86) || CPU(X86_64) ++#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64) + #include + #endif + +@@ -662,7 +662,7 @@ float AudioParamTimeline::valuesForFrameRangeImpl(size_t startFrame, + // 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) + if (fillToFrame > writeIndex) { + // Minimize in-loop operations. Calculate starting value and increment. + // Next step: value += inc. +@@ -841,7 +841,7 @@ float AudioParamTimeline::valuesForFrameRangeImpl(size_t startFrame, + for (; writeIndex < fillToFrame; ++writeIndex) + values[writeIndex] = target; + } else { +-#if CPU(X86) || CPU(X86_64) ++#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64) + if (fillToFrame > writeIndex) { + // Resolve recursion by expanding constants to achieve a 4-step + // loop unrolling. +@@ -959,7 +959,7 @@ float AudioParamTimeline::valuesForFrameRangeImpl(size_t startFrame, + // 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) + if (fillToFrame > writeIndex) { + const __m128 vCurveVirtualIndex = _mm_set_ps1(curveVirtualIndex); + const __m128 vCurvePointsPerFrame = +diff --git a/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.cpp b/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.cpp +index a77ec195c..d76c2d015 100644 +--- a/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.cpp ++++ b/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.cpp +@@ -26,6 +26,9 @@ + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + ++// include this first to get it before the CPU() function-like macro ++#include "base/cpu.h" ++ + #include "platform/audio/DirectConvolver.h" + + #if OS(MACOSX) +@@ -35,21 +38,45 @@ + #include "platform/audio/VectorMath.h" + #include "wtf/CPU.h" + +-#if (CPU(X86) || CPU(X86_64)) && !OS(MACOSX) ++#if ((CPU(X86) && defined(__SSE2__)) || CPU(X86_64)) && !OS(MACOSX) + #include + #endif + ++#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) {} ++ : 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) { ++ size_t framesToProcess) ++#endif ++{ ++#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64) ++ if (m_haveSSE2) { ++ m_processSSE2(convolutionKernel, sourceP, destP, framesToProcess); ++ return; ++ } ++#endif + ASSERT(framesToProcess == m_inputBlockSize); + if (framesToProcess != m_inputBlockSize) + return; +@@ -83,7 +110,7 @@ void DirectConvolver::process(AudioFloatArray* convolutionKernel, + #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. +@@ -397,7 +424,7 @@ void DirectConvolver::process(AudioFloatArray* convolutionKernel, + } + destP[i++] = sum; + } +-#if CPU(X86) || CPU(X86_64) ++#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64) + } + #endif + #endif // OS(MACOSX) +@@ -406,8 +433,9 @@ void DirectConvolver::process(AudioFloatArray* convolutionKernel, + memcpy(m_buffer.data(), inputP, sizeof(float) * framesToProcess); + } + ++#ifndef BUILD_ONLY_THE_SSE2_PARTS + void DirectConvolver::reset() { + m_buffer.zero(); + } +- ++#endif + } // namespace blink +diff --git a/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.h b/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.h +index 848f6aa73..78ea0d84c 100644 +--- a/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.h ++++ b/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/DirectConvolver.h +@@ -32,6 +32,7 @@ + #include "platform/PlatformExport.h" + #include "platform/audio/AudioArray.h" + #include "wtf/Allocator.h" ++#include "wtf/CPU.h" + #include "wtf/Noncopyable.h" + + namespace blink { +@@ -54,6 +55,12 @@ class PLATFORM_EXPORT DirectConvolver { + size_t m_inputBlockSize; + + AudioFloatArray m_buffer; ++ ++#if CPU(X86) ++ bool m_haveSSE2; ++ void m_processSSE2(AudioFloatArray* convolutionKernel, const float* sourceP, float* destP, size_t framesToProcess); ++#endif ++ + }; + + } // namespace blink +diff --git a/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.cpp b/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.cpp +index e7ca2c77d..a0ad93953 100644 +--- a/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.cpp ++++ b/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.cpp +@@ -26,15 +26,22 @@ + * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. + */ + ++// 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 + #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): + // + // |----------------|-----------------------------------------|----------------| +@@ -66,6 +73,8 @@ + + namespace blink { + ++#ifndef BUILD_ONLY_THE_SSE2_PARTS ++ + SincResampler::SincResampler(double scaleFactor, + unsigned kernelSize, + unsigned numberOfKernelOffsets) +@@ -81,6 +90,10 @@ SincResampler::SincResampler(double scaleFactor, + m_sourceFramesAvailable(0), + m_sourceProvider(nullptr), + m_isBufferPrimed(false) { ++#if CPU(X86) ++ base::CPU cpu; ++ m_haveSSE2 = cpu.has_sse2(); ++#endif + initializeKernel(); + } + +@@ -200,10 +213,22 @@ void SincResampler::process(const float* source, + remaining -= framesThisTime; + } + } ++#endif //BUILD_ONLY_THE_SSE2_PARTS + ++#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) { ++ 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); +@@ -269,7 +294,7 @@ void SincResampler::process(AudioSourceProvider* sourceProvider, + { + 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(inputP) & 0x0F) && n) { +diff --git a/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.h b/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.h +index b96ec94cf..4b6b3293e 100644 +--- a/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.h ++++ b/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/SincResampler.h +@@ -33,6 +33,7 @@ + #include "platform/audio/AudioArray.h" + #include "platform/audio/AudioSourceProvider.h" + #include "wtf/Allocator.h" ++#include "wtf/CPU.h" + #include "wtf/Noncopyable.h" + + namespace blink { +@@ -96,6 +97,12 @@ class PLATFORM_EXPORT SincResampler { + + // The buffer is primed once at the very beginning of processing. + bool m_isBufferPrimed; ++ ++#if CPU(X86) ++ bool m_haveSSE2; ++ void m_processSSE2(AudioSourceProvider*, float* destination, size_t framesToProcess); ++#endif ++ }; + }; + + } // namespace blink +diff --git a/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.cpp b/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.cpp +index 8f3592cd7..ba9fc1a73 100644 +--- a/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.cpp ++++ b/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.cpp +@@ -23,6 +23,9 @@ + * DAMAGE. + */ + ++// 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" +@@ -33,10 +36,14 @@ + #include + #endif + +-#if CPU(X86) || CPU(X86_64) ++#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64) + #include + #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 + #endif +@@ -165,15 +172,30 @@ void vclip(const float* sourceP, + } + #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) { +- int n = 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; + +@@ -269,9 +291,16 @@ void vsmul(const float* sourceP, + 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; + +@@ -360,7 +389,7 @@ void vsmul(const float* sourceP, + sourceP += sourceStride; + destP += destStride; + } +-#if CPU(X86) || CPU(X86_64) ++#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64) + } + #endif + } +@@ -372,9 +401,16 @@ void vadd(const float* source1P, + float* destP, + int destStride, + size_t framesToProcess) { +- int n = framesToProcess; ++#if CPU(X86) && !defined(__SSE2__) ++ if (cpu.has_sse2()) { ++ blink::VectorMath::SSE2::vadd(source1P, sourceStride1, source2P, sourceStride2, destP, destStride, framesToProcess); ++ return; ++ } ++#endif + +-#if CPU(X86) || CPU(X86_64) ++ int n = framesToProcess; ++ ++#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. +@@ -501,7 +537,7 @@ void vadd(const float* source1P, + source2P += sourceStride2; + destP += destStride; + } +-#if CPU(X86) || CPU(X86_64) ++#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64) + } + #endif + } +@@ -513,9 +549,16 @@ void vmul(const float* source1P, + float* destP, + int destStride, + size_t framesToProcess) { +- int n = 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. +@@ -614,8 +657,15 @@ void zvmul(const float* real1P, + 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(real1P) & 0x0F) && +@@ -671,10 +721,17 @@ void vsvesq(const float* sourceP, + int sourceStride, + float* sumP, + size_t framesToProcess) { +- int n = 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. +@@ -740,10 +797,16 @@ 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. +@@ -839,6 +902,7 @@ void vclip(const float* sourceP, + float* destP, + int destStride, + size_t framesToProcess) { ++#ifndef BUILD_ONLY_THE_SSE2_PARTS + int n = framesToProcess; + float lowThreshold = *lowThresholdP; + float highThreshold = *highThresholdP; +@@ -888,6 +952,11 @@ void vclip(const float* sourceP, + destP += destStride; + } + } ++#endif ++ ++#ifdef BUILD_ONLY_THE_SSE2_PARTS ++} // namespace SSE2 ++#endif + + #endif // OS(MACOSX) + +diff --git a/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.h b/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.h +index 8f375071c..d92e5b85e 100644 +--- a/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.h ++++ b/src/3rdparty/chromium/third_party/WebKit/Source/platform/audio/VectorMath.h +@@ -27,6 +27,7 @@ + #define VectorMath_h + + #include "platform/PlatformExport.h" ++#include "wtf/CPU.h" + #include "wtf/build_config.h" + #include + +@@ -97,6 +98,28 @@ PLATFORM_EXPORT void vclip(const float* sourceP, + int destStride, + size_t framesToProcess); + ++#if CPU(X86) ++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 + +diff --git a/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/cpu/x86/WebGLImageConversionSSE.h b/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/cpu/x86/WebGLImageConversionSSE.h +index e30fcb464..4b3437057 100644 +--- a/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/cpu/x86/WebGLImageConversionSSE.h ++++ b/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/cpu/x86/WebGLImageConversionSSE.h +@@ -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 + +diff --git a/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp b/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp +index be417ea88..e79034424 100644 +--- a/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp ++++ b/src/3rdparty/chromium/third_party/WebKit/Source/platform/graphics/gpu/WebGLImageConversion.cpp +@@ -441,7 +441,7 @@ void unpack( + const uint32_t* source32 = reinterpret_cast_ptr(source); + uint32_t* destination32 = reinterpret_cast_ptr(destination); + +-#if CPU(X86) || CPU(X86_64) ++#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64) + SIMD::unpackOneRowOfBGRA8LittleToRGBA8(source32, destination32, pixelsPerRow); + #endif + #if HAVE(MIPS_MSA_INTRINSICS) +@@ -467,7 +467,7 @@ void unpack( + 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) +@@ -496,7 +496,7 @@ void unpack( + 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) +@@ -711,7 +711,7 @@ void pack(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 + #if HAVE(MIPS_MSA_INTRINSICS) +@@ -768,7 +768,7 @@ void pack(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 + #if HAVE(MIPS_MSA_INTRINSICS) +@@ -880,7 +880,7 @@ void pack(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); + #endif + #if HAVE(MIPS_MSA_INTRINSICS) +diff --git a/src/3rdparty/chromium/third_party/qcms/BUILD.gn b/src/3rdparty/chromium/third_party/qcms/BUILD.gn +index 1183569be..771dd02c8 100644 +--- a/src/3rdparty/chromium/third_party/qcms/BUILD.gn ++++ b/src/3rdparty/chromium/third_party/qcms/BUILD.gn +@@ -30,8 +30,8 @@ static_library("qcms") { + ] + + if (current_cpu == "x86" || current_cpu == "x64") { +- defines = [ "SSE2_ENABLE" ] +- sources += [ "src/transform-sse2.c" ] ++ defines = [ "SSE2_ENABLE" ] # runtime detection ++ deps = [ "qcms_sse2" ] + } + } + +@@ -74,3 +74,16 @@ if (!disable_qcms) { + public_configs = [ ":qcms_config" ] + } + } ++ ++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" ] ++ } ++} ++ +diff --git a/src/3rdparty/chromium/third_party/webrtc/common_audio/real_fourier.cc b/src/3rdparty/chromium/third_party/webrtc/common_audio/real_fourier.cc +index e721346f3..ef5a4e4a7 100644 +--- a/src/3rdparty/chromium/third_party/webrtc/common_audio/real_fourier.cc ++++ b/src/3rdparty/chromium/third_party/webrtc/common_audio/real_fourier.cc +@@ -14,6 +14,7 @@ + #include "webrtc/common_audio/real_fourier_ooura.h" + #include "webrtc/common_audio/real_fourier_openmax.h" + #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h" ++#include "webrtc/system_wrappers/include/cpu_features_wrapper.h" + + namespace webrtc { + +@@ -23,7 +24,15 @@ const size_t RealFourier::kFftBufferAlignment = 32; + + std::unique_ptr RealFourier::Create(int fft_order) { + #if defined(RTC_USE_OPENMAX_DL) ++#if defined(WEBRTC_ARCH_X86_FAMILY) && !defined(__SSE2__) ++ // x86 CPU detection required. ++ if (WebRtc_GetCPUInfo(kSSE2)) ++ return std::unique_ptr(new RealFourierOpenmax(fft_order)); ++ else ++ return std::unique_ptr(new RealFourierOoura(fft_order)); ++#else + return std::unique_ptr(new RealFourierOpenmax(fft_order)); ++#endif + #else + return std::unique_ptr(new RealFourierOoura(fft_order)); + #endif +diff --git a/src/3rdparty/chromium/v8/BUILD.gn b/src/3rdparty/chromium/v8/BUILD.gn +index 9b209dfff..d88261d53 100644 +--- a/src/3rdparty/chromium/v8/BUILD.gn ++++ b/src/3rdparty/chromium/v8/BUILD.gn +@@ -1769,43 +1769,41 @@ v8_static_library("v8_base") { + + if (v8_current_cpu == "x86") { + sources += [ ### gcmole(arch:ia32) ### +- "src/builtins/ia32/builtins-ia32.cc", +- "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", +- "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", +- "src/ia32/assembler-ia32-inl.h", +- "src/ia32/assembler-ia32.cc", +- "src/ia32/assembler-ia32.h", +- "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/ia32/simulator-ia32.cc", +- "src/ia32/simulator-ia32.h", +- "src/ic/ia32/access-compiler-ia32.cc", +- "src/ic/ia32/handler-compiler-ia32.cc", +- "src/ic/ia32/ic-compiler-ia32.cc", +- "src/ic/ia32/ic-ia32.cc", +- "src/ic/ia32/stub-cache-ia32.cc", +- "src/regexp/ia32/regexp-macro-assembler-ia32.cc", +- "src/regexp/ia32/regexp-macro-assembler-ia32.h", ++ "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", ++ "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", ++ "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", ++ "src/ic/x87/ic-x87.cc", ++ "src/ic/x87/stub-cache-x87.cc", ++ "src/regexp/x87/regexp-macro-assembler-x87.cc", ++ "src/regexp/x87/regexp-macro-assembler-x87.h", + ] + } else if (v8_current_cpu == "x64") { + sources += [ ### gcmole(arch:x64) ### +diff --git a/src/3rdparty/chromium/v8/src/make-v8-sse2-gyp.sh b/src/3rdparty/chromium/v8/src/make-v8-sse2-gyp.sh +new file mode 100644 +index 000000000..0e7ec1621 +--- /dev/null ++++ b/src/3rdparty/chromium/v8/src/make-v8-sse2-gyp.sh +@@ -0,0 +1,56 @@ ++#!/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. ++ ++# add comment noting that the file is generated ++echo "# Generated from v8.gyp by make-v8-sse2-gyp.sh" >v8_sse2.gyp ++# rename all target names ++SUBTARGETS=`grep "'target_name': '" v8.gyp | sed -e "s/^.*'target_name': '//g" -e "s/',$//g"` ++SEDS= ++for SUBTARGET in $SUBTARGETS ; do ++ SEDS=$SEDS\ -e\ "s/'$SUBTARGET\(['#]\)/'${SUBTARGET}_sse2\1/g" ++done ++# 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 ++sed -e "s/^\( 'variables': {\)/\1\n 'v8_target_arch': 'ia32',/g" \ ++ -e "s/\('action_name': '\)/\1v8_sse2_/g" \ ++ $SEDS \ ++ -e "s/\('mksnapshot_exec': '.*mksnapshot\)/\1_sse2/g" \ ++ -e "s#/snapshot\.cc#/snapshot_sse2.cc#g" \ ++ -e "s/libraries\.cc/libraries_sse2.cc/g" \ ++ -e "s/\.bin/_sse2.bin/g" \ ++ -e "s#^\( *\)\('target_name': 'v8_sse2',\)#\1\2\n\1'product_name': 'v8',\n\1'product_dir': '<(PRODUCT_DIR)/lib/sse2',#g" \ ++ v8.gyp >>v8_sse2.gyp +diff --git a/src/3rdparty/chromium/v8/src/v8.gyp b/src/3rdparty/chromium/v8/src/v8.gyp +index 020ec0928..2add932fc 100644 +--- a/src/3rdparty/chromium/v8/src/v8.gyp ++++ b/src/3rdparty/chromium/v8/src/v8.gyp +@@ -51,8 +51,8 @@ + }, { + '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. +@@ -151,7 +151,7 @@ + 'js2c', + ], + }], +- ['component=="shared_library"', { ++ ['v8_component=="shared_library"', { + 'defines': [ + 'BUILDING_V8_SHARED', + ], +@@ -243,7 +243,7 @@ + 'toolsets': ['target'], + 'dependencies': ['js2c'], + }], +- ['component=="shared_library"', { ++ ['v8_component=="shared_library"', { + 'defines': [ + 'BUILDING_V8_SHARED', + ], +@@ -270,7 +270,7 @@ + 'natives_blob', + ], + }], +- ['component=="shared_library"', { ++ ['v8_component=="shared_library"', { + 'defines': [ + 'BUILDING_V8_SHARED', + ], +@@ -1727,7 +1727,7 @@ + # See http://crbug.com/485155. + 'msvs_shard': 4, + }], +- ['component=="shared_library"', { ++ ['v8_component=="shared_library"', { + 'defines': [ + 'BUILDING_V8_SHARED', + ], +diff --git a/src/3rdparty/chromium/v8/src/v8_sse2.gyp b/src/3rdparty/chromium/v8/src/v8_sse2.gyp +new file mode 100644 +index 000000000..140b071a6 +--- /dev/null ++++ b/src/3rdparty/chromium/v8/src/v8_sse2.gyp +@@ -0,0 +1,2313 @@ ++# 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': { ++ 'v8_target_arch': 'ia32', ++ 'v8_code': 1, ++ 'v8_random_seed%': 314159265, ++ 'v8_vector_stores%': 0, ++ 'embed_script%': "", ++ 'warmup_script%': "", ++ 'v8_extra_library_files%': [], ++ 'v8_experimental_extra_library_files%': [], ++ '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)', ++ }], ++ ], ++ }, ++ 'includes': ['../gypfiles/toolchain.gypi', '../gypfiles/features.gypi'], ++ 'targets': [ ++ { ++ 'target_name': 'v8_sse2', ++ 'product_name': 'v8', ++ 'product_dir': '<(PRODUCT_DIR)/lib/sse2', ++ '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. ++ 'v8dll-main.cc', ++ ], ++ 'include_dirs': [ ++ '..', ++ ], ++ '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': [ ++ '../include', ++ ], ++ }, ++ }, ++ { ++ # 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'], ++ 'inputs': [ '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', ], ++ }], ++ ['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': [ ++ '<(PRODUCT_DIR)/snapshot_blob_host_sse2.bin', ++ ], ++ }, { ++ 'inputs': [ ++ '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', ++ ], ++ }], ++ ], ++ }], ++ ['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': [ ++ 'mksnapshot_sse2#host', ++ 'js2c_sse2#host', ++ ], ++ }, { ++ 'toolsets': ['target'], ++ 'dependencies': [ ++ 'mksnapshot_sse2', ++ 'js2c_sse2', ++ ], ++ }], ++ ['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+': [ ++ '..', ++ ], ++ 'sources': [ ++ '<(SHARED_INTERMEDIATE_DIR)/libraries_sse2.cc', ++ '<(SHARED_INTERMEDIATE_DIR)/experimental-libraries_sse2.cc', ++ '<(SHARED_INTERMEDIATE_DIR)/extras-libraries_sse2.cc', ++ '<(SHARED_INTERMEDIATE_DIR)/experimental-extras-libraries_sse2.cc', ++ '<(INTERMEDIATE_DIR)/snapshot_sse2.cc', ++ ], ++ 'actions': [ ++ { ++ 'action_name': 'v8_sse2_run_mksnapshot', ++ 'inputs': [ ++ '<(mksnapshot_exec)', ++ ], ++ 'conditions': [ ++ ['embed_script!=""', { ++ 'inputs': [ ++ '<(embed_script)', ++ ], ++ }], ++ ['warmup_script!=""', { ++ 'inputs': [ ++ '<(warmup_script)', ++ ], ++ }], ++ ], ++ 'outputs': [ ++ '<(INTERMEDIATE_DIR)/snapshot_sse2.cc', ++ ], ++ 'variables': { ++ 'mksnapshot_flags': [], ++ 'conditions': [ ++ ['v8_random_seed!=0', { ++ 'mksnapshot_flags': ['--random-seed', '<(v8_random_seed)'], ++ }], ++ ['v8_vector_stores!=0', { ++ 'mksnapshot_flags': ['--vector-stores'], ++ }], ++ ], ++ }, ++ 'action': [ ++ '<(mksnapshot_exec)', ++ '<@(mksnapshot_flags)', ++ '--startup_src', '<@(INTERMEDIATE_DIR)/snapshot_sse2.cc', ++ '<(embed_script)', ++ '<(warmup_script)', ++ ], ++ }, ++ ], ++ }, ++ { ++ 'target_name': 'v8_nosnapshot_sse2', ++ 'type': 'static_library', ++ 'dependencies': [ ++ 'v8_base_sse2', ++ ], ++ 'include_dirs+': [ ++ '..', ++ ], ++ 'sources': [ ++ '<(SHARED_INTERMEDIATE_DIR)/libraries_sse2.cc', ++ '<(SHARED_INTERMEDIATE_DIR)/experimental-libraries_sse2.cc', ++ '<(SHARED_INTERMEDIATE_DIR)/extras-libraries_sse2.cc', ++ '<(SHARED_INTERMEDIATE_DIR)/experimental-extras-libraries_sse2.cc', ++ 'snapshot/snapshot-empty.cc', ++ ], ++ 'conditions': [ ++ ['want_separate_host_toolset==1', { ++ 'toolsets': ['host', 'target'], ++ 'dependencies': ['js2c_sse2#host'], ++ }, { ++ 'toolsets': ['target'], ++ 'dependencies': ['js2c_sse2'], ++ }], ++ ['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': [ ++ 'mksnapshot_sse2#host', ++ 'js2c_sse2#host', ++ 'natives_blob_sse2', ++ ]}, { ++ 'toolsets': ['target'], ++ 'dependencies': [ ++ 'mksnapshot_sse2', ++ 'js2c_sse2', ++ 'natives_blob_sse2', ++ ], ++ }], ++ ['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+': [ ++ '..', ++ ], ++ 'sources': [ ++ 'snapshot/natives-external.cc', ++ 'snapshot/snapshot-external.cc', ++ ], ++ 'actions': [ ++ { ++ 'action_name': 'v8_sse2_run_mksnapshot (external)', ++ 'inputs': [ ++ '<(mksnapshot_exec)', ++ ], ++ 'variables': { ++ 'mksnapshot_flags': [], ++ 'conditions': [ ++ ['v8_random_seed!=0', { ++ 'mksnapshot_flags': ['--random-seed', '<(v8_random_seed)'], ++ }], ++ ['v8_vector_stores!=0', { ++ 'mksnapshot_flags': ['--vector-stores'], ++ }], ++ ], ++ }, ++ 'conditions': [ ++ ['embed_script!=""', { ++ 'inputs': [ ++ '<(embed_script)', ++ ], ++ }], ++ ['warmup_script!=""', { ++ 'inputs': [ ++ '<(warmup_script)', ++ ], ++ }], ++ ['want_separate_host_toolset==1', { ++ 'target_conditions': [ ++ ['_toolset=="host"', { ++ 'outputs': [ ++ '<(PRODUCT_DIR)/snapshot_blob_host_sse2.bin', ++ ], ++ 'action': [ ++ '<(mksnapshot_exec)', ++ '<@(mksnapshot_flags)', ++ '--startup_blob', '<(PRODUCT_DIR)/snapshot_blob_host_sse2.bin', ++ '<(embed_script)', ++ '<(warmup_script)', ++ ], ++ }, { ++ 'outputs': [ ++ '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', ++ ], ++ 'action': [ ++ '<(mksnapshot_exec)', ++ '<@(mksnapshot_flags)', ++ '--startup_blob', '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', ++ '<(embed_script)', ++ '<(warmup_script)', ++ ], ++ }], ++ ], ++ }, { ++ 'outputs': [ ++ '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', ++ ], ++ 'action': [ ++ '<(mksnapshot_exec)', ++ '<@(mksnapshot_flags)', ++ '--startup_blob', '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', ++ '<(embed_script)', ++ '<(warmup_script)', ++ ], ++ }], ++ ], ++ }, ++ ], ++ }], ++ ], ++ }, ++ { ++ 'target_name': 'v8_base_sse2', ++ 'type': 'static_library', ++ 'dependencies': [ ++ 'v8_libbase_sse2', ++ 'v8_libsampler_sse2', ++ ], ++ 'variables': { ++ 'optimize': 'max', ++ }, ++ 'include_dirs+': [ ++ '..', ++ '<(DEPTH)', ++ ], ++ 'sources': [ ### gcmole(all) ### ++ '../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', ++ ], ++ '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) ### ++ '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', ++ ], ++ }], ++ ['v8_target_arch=="arm64"', { ++ 'sources': [ ### gcmole(arch:arm64) ### ++ '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', ++ ], ++ }], ++ ['v8_target_arch=="ia32"', { ++ 'sources': [ ### gcmole(arch:ia32) ### ++ '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', ++ ], ++ }], ++ ['v8_target_arch=="x87"', { ++ 'sources': [ ### gcmole(arch:x87) ### ++ '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', ++ ], ++ }], ++ ['v8_target_arch=="mips" or v8_target_arch=="mipsel"', { ++ 'sources': [ ### gcmole(arch:mipsel) ### ++ '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', ++ ], ++ }], ++ ['v8_target_arch=="mips64" or v8_target_arch=="mips64el"', { ++ 'sources': [ ### gcmole(arch:mips64el) ### ++ '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', ++ ], ++ }], ++ ['v8_target_arch=="x64" or v8_target_arch=="x32"', { ++ 'sources': [ ### gcmole(arch:x64) ### ++ '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', ++ ], ++ }], ++ ['v8_target_arch=="x64"', { ++ 'sources': [ ++ 'compiler/x64/code-generator-x64.cc', ++ 'compiler/x64/instruction-codes-x64.h', ++ 'compiler/x64/instruction-scheduler-x64.cc', ++ 'compiler/x64/instruction-selector-x64.cc', ++ ], ++ }], ++ ['v8_target_arch=="ppc" or v8_target_arch=="ppc64"', { ++ 'sources': [ ### gcmole(arch:ppc) ### ++ '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', ++ ], ++ }], ++ ['OS=="win"', { ++ 'variables': { ++ 'gyp_generators': ' +Date: Wed, 31 May 2017 15:02:52 +0200 +Subject: [PATCH] qtwebengine-opensource-src-5.9.-openmax-dl-neon + +--- + .../chromium/third_party/openmax_dl/dl/dl.gyp | 9 ---- + .../third_party/openmax_dl/dl/sp/src/arm/detect.c | 56 ++++++++++++++++++---- + 2 files changed, 48 insertions(+), 17 deletions(-) + +diff --git a/src/3rdparty/chromium/third_party/openmax_dl/dl/dl.gyp b/src/3rdparty/chromium/third_party/openmax_dl/dl/dl.gyp +index 2b0826fe1..20b4b1f35 100644 +--- a/src/3rdparty/chromium/third_party/openmax_dl/dl/dl.gyp ++++ b/src/3rdparty/chromium/third_party/openmax_dl/dl/dl.gyp +@@ -219,15 +219,6 @@ + 'conditions': [ + ['arm_neon_optional==1', { + # Run-time NEON detection. +- 'dependencies': [ +- '../../../build/android/ndk.gyp:cpu_features', +- ], +- 'link_settings' : { +- 'libraries': [ +- # To get the __android_log_print routine +- '-llog', +- ], +- }, + 'sources': [ + # Detection routine + 'sp/src/arm/detect.c', +diff --git a/src/3rdparty/chromium/third_party/openmax_dl/dl/sp/src/arm/detect.c b/src/3rdparty/chromium/third_party/openmax_dl/dl/sp/src/arm/detect.c +index 57bfe4089..94a3f7ddc 100644 +--- a/src/3rdparty/chromium/third_party/openmax_dl/dl/sp/src/arm/detect.c ++++ b/src/3rdparty/chromium/third_party/openmax_dl/dl/sp/src/arm/detect.c +@@ -9,13 +9,57 @@ + * + */ + +-#include +- +-#include "android/log.h" + #include "dl/sp/api/omxSP.h" + ++// For ArmCpuCaps() ++#include ++#include ++ ++// based on libvpx arm_cpudetect.c ++static int ArmCpuCaps(const char* cpuinfo_name) { ++ char cpuinfo_line[512]; ++ FILE* f = fopen(cpuinfo_name, "r"); ++ if (!f) { ++ // Assume Neon if /proc/cpuinfo is unavailable. ++ // This will occur for Chrome sandbox for Pepper or Render process. ++ return 1; ++ } ++ while (fgets(cpuinfo_line, sizeof(cpuinfo_line) - 1, f)) { ++ if (memcmp(cpuinfo_line, "Features", 8) == 0) { ++ char* p = strstr(cpuinfo_line, " neon"); ++ if (p && (p[5] == ' ' || p[5] == '\n')) { ++ fclose(f); ++ return 1; ++ } ++ // aarch64 uses asimd for Neon. ++ p = strstr(cpuinfo_line, " asimd"); ++ if (p && (p[6] == ' ' || p[6] == '\n')) { ++ fclose(f); ++ return 1; ++ } ++ } ++ } ++ fclose(f); ++ return 0; ++} ++ + int omxSP_HasArmNeon() { +- return (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0; ++#if defined(__arm__) || defined(__aarch64__) ++// gcc -mfpu=neon defines __ARM_NEON__ ++// __ARM_NEON__ generates code that requires Neon. NaCL also requires Neon. ++// For Linux, /proc/cpuinfo can be tested but without that assume Neon. ++#if defined(__ARM_NEON__) || defined(__native_client__) || !defined(__linux__) ++ return 1; ++// For aarch64(arm64), /proc/cpuinfo's feature is not complete, e.g. no neon ++// flag in it. ++// So for aarch64, neon enabling is hard coded here. ++#elif defined(__aarch64__) ++ return 1; ++#else ++ // Linux arm parse text file for neon detect. ++ return ArmCpuCaps("/proc/cpuinfo"); ++#endif ++#endif // __arm__ + } + + static void SetFFTRoutines() { +@@ -24,13 +68,9 @@ static void SetFFTRoutines() { + * forward and inverse FFTs + */ + if (omxSP_HasArmNeon()) { +- __android_log_print(ANDROID_LOG_INFO, "OpenMAX DL FFT", +- "Using NEON FFT"); + omxSP_FFTFwd_RToCCS_F32 = omxSP_FFTFwd_RToCCS_F32_Sfs; + omxSP_FFTInv_CCSToR_F32 = omxSP_FFTInv_CCSToR_F32_Sfs; + } else { +- __android_log_print(ANDROID_LOG_INFO, "OpenMAX DL FFT", +- "Using non-NEON FFT"); + omxSP_FFTFwd_RToCCS_F32 = omxSP_FFTFwd_RToCCS_F32_Sfs_vfp; + omxSP_FFTInv_CCSToR_F32 = omxSP_FFTInv_CCSToR_F32_Sfs_vfp; + } +-- +2.13.0 + diff --git a/0006-qtwebengine-opensource-src-5.9.0-linux-pri.patch b/0006-qtwebengine-opensource-src-5.9.0-linux-pri.patch new file mode 100644 index 0000000..92c12de --- /dev/null +++ b/0006-qtwebengine-opensource-src-5.9.0-linux-pri.patch @@ -0,0 +1,33 @@ +From a7885b823a2d3fc853f532fb5ae3a43a3e9967c0 Mon Sep 17 00:00:00 2001 +From: Helio Chissini de Castro +Date: Wed, 31 May 2017 15:13:15 +0200 +Subject: [PATCH] qtwebengine-opensource-src-5.9.0-linux-pri + +--- + src/core/config/linux.pri | 12 ++++++++++++ + 1 file changed, 12 insertions(+) + +diff --git a/src/core/config/linux.pri b/src/core/config/linux.pri +index 24951cd07..c28e3b312 100644 +--- a/src/core/config/linux.pri ++++ b/src/core/config/linux.pri +@@ -147,4 +147,16 @@ host_build { + use?(system_icu): gn_args += use_system_icu=true icu_use_data_file=false + use?(system_ffmpeg): gn_args += use_system_ffmpeg=true + #use?(system_protobuf): gn_args += use_system_protobuf=true ++ ++ # some more system packages, that are not checked for for some reason ++ gn_args += use_system_re2=true ++ ++ # yasm is only used on x86, and passing use_system_yasm makes the build fail on ++ # other architectures (e.g., ARM), so make it conditional on the architecture ++ contains(QT_ARCH, "x86_64")|contains(QT_ARCH, "i386") { ++ gn_args += use_system_yasm=true ++ } ++ ++ #link libpci instead of dlopening it, our Qt packaging depends on it anyway ++ gn_args += linux_link_libpci=true + } +-- +2.13.0 + diff --git a/0007-qtwebengine-opensource-src-5.9.0-no-icudtl-dat.patch b/0007-qtwebengine-opensource-src-5.9.0-no-icudtl-dat.patch new file mode 100644 index 0000000..bf97a76 --- /dev/null +++ b/0007-qtwebengine-opensource-src-5.9.0-no-icudtl-dat.patch @@ -0,0 +1,41 @@ +From 99294d646e58bcbedc5987a1816fed592290566f Mon Sep 17 00:00:00 2001 +From: Helio Chissini de Castro +Date: Wed, 31 May 2017 15:16:56 +0200 +Subject: [PATCH] qtwebengine-opensource-src-5.9.0-no-icudtl-dat + +--- + src/core/web_engine_library_info.cpp | 17 ----------------- + 1 file changed, 17 deletions(-) + +diff --git a/src/core/web_engine_library_info.cpp b/src/core/web_engine_library_info.cpp +index f46f8f425..96cd48ac4 100644 +--- a/src/core/web_engine_library_info.cpp ++++ b/src/core/web_engine_library_info.cpp +@@ -254,24 +254,7 @@ QString icuDataPath() + #if defined(OS_MACOSX) && defined(QT_MAC_FRAMEWORK_BUILD) + return getResourcesPath(frameworkBundle()); + #else +- static bool initialized = false; + static QString potentialResourcesPath = QLibraryInfo::location(QLibraryInfo::DataPath) % QLatin1String("/resources"); +- if (!initialized) { +- initialized = true; +- if (!QFileInfo::exists(potentialResourcesPath % QLatin1String("/icudtl.dat"))) { +- qWarning("Qt WebEngine ICU data not found at %s. Trying parent directory...", qPrintable(potentialResourcesPath)); +- potentialResourcesPath = QLibraryInfo::location(QLibraryInfo::DataPath); +- } +- if (!QFileInfo::exists(potentialResourcesPath % QLatin1String("/icudtl.dat"))) { +- qWarning("Qt WebEngine ICU data not found at %s. Trying application directory...", qPrintable(potentialResourcesPath)); +- potentialResourcesPath = QCoreApplication::applicationDirPath(); +- } +- if (!QFileInfo::exists(potentialResourcesPath % QLatin1String("/icudtl.dat"))) { +- qWarning("Qt WebEngine ICU data not found at %s. Trying fallback directory... The application MAY NOT work.", qPrintable(potentialResourcesPath)); +- potentialResourcesPath = fallbackDir(); +- } +- } +- + return potentialResourcesPath; + #endif + } +-- +2.13.0 + diff --git a/qt5-qtwebengine.spec b/qt5-qtwebengine.spec index 5ddbf65..b039a74 100644 --- a/qt5-qtwebengine.spec +++ b/qt5-qtwebengine.spec @@ -40,8 +40,8 @@ Summary: Qt5 - QtWebEngine components Name: qt5-qtwebengine -Version: 5.8.0 -Release: 14%{?dist} +Version: 5.9.0 +Release: 1%{?dist} # See LICENSE.GPL LICENSE.LGPL LGPL_EXCEPTION.txt, for details # See also http://qt-project.org/doc/qt-5.0/qtdoc/licensing.html @@ -51,68 +51,40 @@ URL: http://www.qt.io # cleaned tarball with patent-encumbered codecs removed from the bundled FFmpeg # wget http://download.qt.io/official_releases/qt/5.8/5.8.0/submodules/qtwebengine-opensource-src-5.8.0.tar.xz # ./clean_qtwebengine.sh 5.8.0 -Source0: qtwebengine-opensource-src-%{version}-clean.tar.xz +Source0: https://download.qt.io/official_releases/qt/5.9/5.9.0/submodules/qtwebengine-opensource-src-5.9.0.tar.xz # cleanup scripts used above Source1: clean_qtwebengine.sh Source2: clean_ffmpeg.sh Source3: get_free_ffmpeg_source_files.py # macros Source10: macros.qt5-qtwebengine -# some tweaks to linux.pri (system libs, link libpci, run unbundling script) -Patch0: qtwebengine-opensource-src-5.7.0-linux-pri.patch -# quick hack to avoid checking for the nonexistent icudtl.dat and silence the -# resulting warnings - not upstreamable as is because it removes the fallback -# mechanism for the ICU data directory (which is not used in our builds because -# we use the system ICU, which embeds the data statically) completely -Patch1: qtwebengine-opensource-src-5.6.0-no-icudtl-dat.patch -# fix extractCFlag to also look in QMAKE_CFLAGS_RELEASE, needed to detect the -# ARM flags with our %%qmake_qt5 macro, including for the next patch -Patch2: qtwebengine-opensource-src-5.6.0-beta-fix-extractcflag.patch -# disable NEON vector instructions on ARM where the NEON code FTBFS due to -# GCC bug https://bugzilla.redhat.com/show_bug.cgi?id=1282495 -# otherwise, we use the arm-fpu-fix below instead (which this patch contains) -Patch3: qtwebengine-opensource-src-5.7.1-no-neon.patch +# webrtc: enable the CPU feature detection for ARM Linux also for Chromium +Patch0: 0001-qtwebengine-opensource-src-5.9.0-webrtc-neon-detect.patch # use the system NSPR prtime (based on Debian patch) # We already depend on NSPR, so it is useless to copy these functions here. # Debian uses this just fine, and I don't see relevant modifications either. -Patch4: qtwebengine-opensource-src-5.8.0-system-nspr-prtime.patch +Patch1: 0002-qtwebengine-opensource-src-5.9.0-system-nspr-prtime.patch # use the system ICU UTF functions # We already depend on ICU, so it is useless to copy these functions here. # I checked the history of that directory, and other than the renames I am # undoing, there were no modifications at all. Must be applied after Patch5. -Patch5: qtwebengine-opensource-src-5.8.0-system-icu-utf.patch +Patch2: 0003-qtwebengine-opensource-src-5.9.0-system-icu-utf.patch # do not require SSE2 on i686 # cumulative revert of upstream reviews 187423002, 308003004, 511773002 (parts # relevant to QtWebEngine only), 516543004, 1152053004 and 1161853008, along # with some custom fixes and improvements # also build V8 shared and twice on i686 (once for x87, once for SSE2) # TODO: For 5.9, we will need the GN files updated (where not done yet), too. -Patch6: qtwebengine-opensource-src-5.8.0-no-sse2.patch -# fix ARM NEON handling in webrtc gyp files -# Fix video_processing.gypi to only build NEON files when actually requested -# (i.e., not if arm_neon=0 arm_neon_optional=0). -Patch7: qtwebengine-opensource-src-5.7.0-webrtc-neon.patch -# fix missing ARM -mfpu setting (see the comment in the no-neon patch above) -Patch9: qtwebengine-opensource-src-5.7.1-arm-fpu-fix.patch +Patch3: 0004-qtwebengine-opensource-src-5.9.0-no-sse2.patch # remove Android dependencies from openmax_dl ARM NEON detection (detect.c) -Patch10: qtwebengine-opensource-src-5.7.1-openmax-dl-neon.patch -# chromium-skia: build SkUtilsArm.cpp also on non-Android ARM -Patch11: qtwebengine-opensource-src-5.7.1-skia-neon.patch -# webrtc: enable the CPU feature detection for ARM Linux also for Chromium -Patch12: qtwebengine-opensource-src-5.8.0-webrtc-neon-detect.patch -# fix FTBFS in V8 with GCC 7 (by Ben Noordhuis, backported from Chromium RPM) -Patch13: qtwebengine-opensource-src-5.8.0-v8-gcc7.patch -# fix FTBFS in PDFium with GCC 7: backport upstream cleanup removing that code -# https://codereview.chromium.org/2154503002 -Patch14: qtwebengine-opensource-src-5.8.0-pdfium-gcc7.patch -# fix FTBFS in the WTF part of Blink/WebKit with GCC 7 -Patch15: qtwebengine-opensource-src-5.8.0-wtf-gcc7.patch -# FTBFS using qt < 5.8 -Patch20: qtwebengine-opensource-src-5.8.0-qt57.patch -# upstream fix for blank pages when a link opens in a new tab -Patch100: qtwebengine-opensource-src-5.8.0-fix-open-in-new-tab.patch -# upstream fix for non-functional dead keys in text fields -Patch101: qtwebengine-opensource-src-5.8.0-fix-dead-keys.patch +Patch4: 0005-qtwebengine-opensource-src-5.9.-openmax-dl-neon.patch +# some tweaks to linux.pri (system libs, link libpci, run unbundling script) +Patch5: 0006-qtwebengine-opensource-src-5.9.0-linux-pri.patch +# quick hack to avoid checking for the nonexistent icudtl.dat and silence the +# resulting warnings - not upstreamable as is because it removes the fallback +# mechanism for the ICU data directory (which is not used in our builds because +# we use the system ICU, which embeds the data statically) completely +Patch6: 0007-qtwebengine-opensource-src-5.9.0-no-icudtl-dat.patch %if 0%{?fedora} && 0%{?fedora} < 25 # work around missing qt5_qtwebengine_arches macro on F24 @@ -340,28 +312,16 @@ BuildArch: noarch %prep -%setup -q -n %{qt_module}-opensource-src-%{version}%{?prerelease:-%{prerelease}} -%patch0 -p1 -b .linux-pri -%patch1 -p1 -b .no-icudtl-dat -%patch2 -p1 -b .fix-extractcflag +%setup -q -n %{qt_module}-opensource-src-%{version} %if 0%{?arm_neon} -%patch9 -p1 -b .arm-fpu-fix -%else -%patch3 -p1 -b .no-neon +%patch0 -p1 -b .webrtc-neon-detect %endif -%patch4 -p1 -b .system-nspr-prtime -%patch5 -p1 -b .system-icu-utf -%patch6 -p1 -b .no-sse2 -%patch7 -p1 -b .webrtc-neon -%patch10 -p1 -b .openmax-dl-neon -%patch11 -p1 -b .skia-neon -%patch12 -p1 -b .webrtc-neon-detect -%patch13 -p1 -b .v8-gcc7 -%patch14 -p1 -b .pdfium-gcc7 -%patch15 -p1 -b .wtf-gcc7 -%patch20 -p1 -b .qt57 -%patch100 -p1 -b .fix-open-in-new-tab -%patch101 -p1 -b .fix-dead-keys +%patch1 -p1 -b .system-nspr-prtime +%patch2 -p1 -b .system-icu-utf +%patch3 -p1 -b .no-sse2 +%patch4 -p1 -b .openmax-dl-neon +%patch5 -p1 -b .linux-pri +%patch6 -p1 -b .no-icudtl # fix // in #include in content/renderer/gpu to avoid debugedit failure sed -i -e 's!gpu//!gpu/!g' \ src/3rdparty/chromium/content/renderer/gpu/compositor_forwarding_message_filter.cc @@ -572,6 +532,9 @@ done %changelog +* Wed May 31 2017 Helio Chissini de Castro - 5.9.0-1 +- Upstream official release + * Sat May 13 2017 Rex Dieter - 5.8.0-14 - fix rpm macros diff --git a/qtwebengine-opensource-src-5.6.0-beta-fix-extractcflag.patch b/qtwebengine-opensource-src-5.6.0-beta-fix-extractcflag.patch deleted file mode 100644 index 8beae69..0000000 --- a/qtwebengine-opensource-src-5.6.0-beta-fix-extractcflag.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff -ur qtwebengine-opensource-src-5.6.0-beta/tools/qmake/mkspecs/features/functions.prf qtwebengine-opensource-src-5.6.0-beta-fix-extractcflag/tools/qmake/mkspecs/features/functions.prf ---- qtwebengine-opensource-src-5.6.0-beta/tools/qmake/mkspecs/features/functions.prf 2015-12-14 16:27:24.000000000 +0100 -+++ qtwebengine-opensource-src-5.6.0-beta-fix-extractcflag/tools/qmake/mkspecs/features/functions.prf 2016-01-10 18:15:23.942032985 +0100 -@@ -87,7 +87,7 @@ - } - - defineReplace(extractCFlag) { -- CFLAGS = $$QMAKE_CC $$QMAKE_CFLAGS -+ CFLAGS = $$QMAKE_CC $$QMAKE_CFLAGS $$QMAKE_CFLAGS_RELEASE - OPTION = $$find(CFLAGS, $$1) - OPTION = $$split(OPTION, =) - return ($$member(OPTION, 1)) diff --git a/qtwebengine-opensource-src-5.6.0-no-icudtl-dat.patch b/qtwebengine-opensource-src-5.6.0-no-icudtl-dat.patch deleted file mode 100644 index 00cbfc2..0000000 --- a/qtwebengine-opensource-src-5.6.0-no-icudtl-dat.patch +++ /dev/null @@ -1,28 +0,0 @@ -diff -ur qtwebengine-opensource-src-5.6.0/src/core/web_engine_library_info.cpp qtwebengine-opensource-src-5.6.0-no-icudtl-dat/src/core/web_engine_library_info.cpp ---- qtwebengine-opensource-src-5.6.0/src/core/web_engine_library_info.cpp 2016-03-03 17:02:28.000000000 +0100 -+++ qtwebengine-opensource-src-5.6.0-no-icudtl-dat/src/core/web_engine_library_info.cpp 2016-03-18 03:08:24.385444415 +0100 -@@ -207,24 +207,7 @@ - #if defined(OS_MACOSX) && defined(QT_MAC_FRAMEWORK_BUILD) - return getResourcesPath(frameworkBundle()); - #else -- static bool initialized = false; - static QString potentialResourcesPath = QLibraryInfo::location(QLibraryInfo::DataPath) % QLatin1String("/resources"); -- if (!initialized) { -- initialized = true; -- if (!QFileInfo::exists(potentialResourcesPath % QLatin1String("/icudtl.dat"))) { -- qWarning("Qt WebEngine ICU data not found at %s. Trying parent directory...", qPrintable(potentialResourcesPath)); -- potentialResourcesPath = QLibraryInfo::location(QLibraryInfo::DataPath); -- } -- if (!QFileInfo::exists(potentialResourcesPath % QLatin1String("/icudtl.dat"))) { -- qWarning("Qt WebEngine ICU data not found at %s. Trying application directory...", qPrintable(potentialResourcesPath)); -- potentialResourcesPath = QCoreApplication::applicationDirPath(); -- } -- if (!QFileInfo::exists(potentialResourcesPath % QLatin1String("/icudtl.dat"))) { -- qWarning("Qt WebEngine ICU data not found at %s. Trying fallback directory... The application MAY NOT work.", qPrintable(potentialResourcesPath)); -- potentialResourcesPath = fallbackDir(); -- } -- } -- - return potentialResourcesPath; - #endif - } diff --git a/qtwebengine-opensource-src-5.7.0-linux-pri.patch b/qtwebengine-opensource-src-5.7.0-linux-pri.patch deleted file mode 100644 index 321a1d7..0000000 --- a/qtwebengine-opensource-src-5.7.0-linux-pri.patch +++ /dev/null @@ -1,26 +0,0 @@ -diff -ur qtwebengine-opensource-src-5.7.0/src/core/config/linux.pri qtwebengine-opensource-src-5.7.0-linux-pri/src/core/config/linux.pri ---- qtwebengine-opensource-src-5.7.0/src/core/config/linux.pri 2016-06-07 06:20:06.000000000 +0200 -+++ qtwebengine-opensource-src-5.7.0-linux-pri/src/core/config/linux.pri 2016-07-17 22:18:17.312471202 +0200 -@@ -46,3 +46,22 @@ - use?(system_icu): GYP_CONFIG += use_system_icu=1 icu_use_data_file_flag=0 - use?(system_ffmpeg): GYP_CONFIG += use_system_ffmpeg=1 - use?(system_protobuf): GYP_CONFIG += use_system_protobuf=1 -+ -+# some more system packages, that are not checked for for some reason -+GYP_CONFIG += use_system_re2=1 -+ -+# yasm is only used on x86, and passing use_system_yasm makes the build fail on -+# other architectures (e.g., ARM), so make it conditional on the architecture -+contains(QT_ARCH, "x86_64")|contains(QT_ARCH, "i386") { -+ GYP_CONFIG += use_system_yasm=1 -+} -+ -+# link libpci instead of dlopening it, our Qt packaging depends on it anyway -+GYP_CONFIG += linux_link_libpci=1 -+ -+# run the unbundling script Chromium provides -+CHROMIUM_SRC_DIR = "$$QTWEBENGINE_ROOT/$$getChromiumSrcDir()" -+R_G_F_PY = "$$CHROMIUM_SRC_DIR/build/linux/unbundle/replace_gyp_files.py" -+R_G_F_PY_ARGS = "-D use_system_re2=1" -+log("Running python $$R_G_F_PY $$R_G_F_PY_ARGS$${EOL}") -+!system("python $$R_G_F_PY $$R_G_F_PY_ARGS"): error("-- unbundling failed") diff --git a/qtwebengine-opensource-src-5.7.1-openmax-dl-neon.patch b/qtwebengine-opensource-src-5.7.1-openmax-dl-neon.patch deleted file mode 100644 index 08ff6e5..0000000 --- a/qtwebengine-opensource-src-5.7.1-openmax-dl-neon.patch +++ /dev/null @@ -1,98 +0,0 @@ -diff -ur qtwebengine-opensource-src-5.7.1/src/3rdparty/chromium/third_party/openmax_dl/dl/dl.gyp qtwebengine-opensource-src-5.7.1-openmax-dl-neon/src/3rdparty/chromium/third_party/openmax_dl/dl/dl.gyp ---- qtwebengine-opensource-src-5.7.1/src/3rdparty/chromium/third_party/openmax_dl/dl/dl.gyp 2016-11-07 15:46:18.000000000 +0100 -+++ qtwebengine-opensource-src-5.7.1-openmax-dl-neon/src/3rdparty/chromium/third_party/openmax_dl/dl/dl.gyp 2016-12-03 22:50:19.369158276 +0100 -@@ -219,15 +219,6 @@ - 'conditions': [ - ['arm_neon_optional==1', { - # Run-time NEON detection. -- 'dependencies': [ -- '../../../build/android/ndk.gyp:cpu_features', -- ], -- 'link_settings' : { -- 'libraries': [ -- # To get the __android_log_print routine -- '-llog', -- ], -- }, - 'sources': [ - # Detection routine - 'sp/src/arm/detect.c', -diff -ur qtwebengine-opensource-src-5.7.1/src/3rdparty/chromium/third_party/openmax_dl/dl/sp/src/arm/detect.c qtwebengine-opensource-src-5.7.1-openmax-dl-neon/src/3rdparty/chromium/third_party/openmax_dl/dl/sp/src/arm/detect.c ---- qtwebengine-opensource-src-5.7.1/src/3rdparty/chromium/third_party/openmax_dl/dl/sp/src/arm/detect.c 2016-11-07 15:46:18.000000000 +0100 -+++ qtwebengine-opensource-src-5.7.1-openmax-dl-neon/src/3rdparty/chromium/third_party/openmax_dl/dl/sp/src/arm/detect.c 2016-12-03 22:48:13.745095083 +0100 -@@ -9,13 +9,57 @@ - * - */ - --#include -- --#include "android/log.h" - #include "dl/sp/api/omxSP.h" - -+// For ArmCpuCaps() -+#include -+#include -+ -+// based on libvpx arm_cpudetect.c -+static int ArmCpuCaps(const char* cpuinfo_name) { -+ char cpuinfo_line[512]; -+ FILE* f = fopen(cpuinfo_name, "r"); -+ if (!f) { -+ // Assume Neon if /proc/cpuinfo is unavailable. -+ // This will occur for Chrome sandbox for Pepper or Render process. -+ return 1; -+ } -+ while (fgets(cpuinfo_line, sizeof(cpuinfo_line) - 1, f)) { -+ if (memcmp(cpuinfo_line, "Features", 8) == 0) { -+ char* p = strstr(cpuinfo_line, " neon"); -+ if (p && (p[5] == ' ' || p[5] == '\n')) { -+ fclose(f); -+ return 1; -+ } -+ // aarch64 uses asimd for Neon. -+ p = strstr(cpuinfo_line, " asimd"); -+ if (p && (p[6] == ' ' || p[6] == '\n')) { -+ fclose(f); -+ return 1; -+ } -+ } -+ } -+ fclose(f); -+ return 0; -+} -+ - int omxSP_HasArmNeon() { -- return (android_getCpuFeatures() & ANDROID_CPU_ARM_FEATURE_NEON) != 0; -+#if defined(__arm__) || defined(__aarch64__) -+// gcc -mfpu=neon defines __ARM_NEON__ -+// __ARM_NEON__ generates code that requires Neon. NaCL also requires Neon. -+// For Linux, /proc/cpuinfo can be tested but without that assume Neon. -+#if defined(__ARM_NEON__) || defined(__native_client__) || !defined(__linux__) -+ return 1; -+// For aarch64(arm64), /proc/cpuinfo's feature is not complete, e.g. no neon -+// flag in it. -+// So for aarch64, neon enabling is hard coded here. -+#elif defined(__aarch64__) -+ return 1; -+#else -+ // Linux arm parse text file for neon detect. -+ return ArmCpuCaps("/proc/cpuinfo"); -+#endif -+#endif // __arm__ - } - - static void SetFFTRoutines() { -@@ -24,13 +68,9 @@ - * forward and inverse FFTs - */ - if (omxSP_HasArmNeon()) { -- __android_log_print(ANDROID_LOG_INFO, "OpenMAX DL FFT", -- "Using NEON FFT"); - omxSP_FFTFwd_RToCCS_F32 = omxSP_FFTFwd_RToCCS_F32_Sfs; - omxSP_FFTInv_CCSToR_F32 = omxSP_FFTInv_CCSToR_F32_Sfs; - } else { -- __android_log_print(ANDROID_LOG_INFO, "OpenMAX DL FFT", -- "Using non-NEON FFT"); - omxSP_FFTFwd_RToCCS_F32 = omxSP_FFTFwd_RToCCS_F32_Sfs_vfp; - omxSP_FFTInv_CCSToR_F32 = omxSP_FFTInv_CCSToR_F32_Sfs_vfp; - } diff --git a/qtwebengine-opensource-src-5.7.1-skia-neon.patch b/qtwebengine-opensource-src-5.7.1-skia-neon.patch deleted file mode 100644 index c9b385b..0000000 --- a/qtwebengine-opensource-src-5.7.1-skia-neon.patch +++ /dev/null @@ -1,15 +0,0 @@ -diff -ur qtwebengine-opensource-src-5.7.1/src/3rdparty/chromium/skia/skia_library.gypi qtwebengine-opensource-src-5.7.1-skia-neon/src/3rdparty/chromium/skia/skia_library.gypi ---- qtwebengine-opensource-src-5.7.1/src/3rdparty/chromium/skia/skia_library.gypi 2016-11-07 15:46:18.000000000 +0100 -+++ qtwebengine-opensource-src-5.7.1-skia-neon/src/3rdparty/chromium/skia/skia_library.gypi 2016-12-04 14:34:12.531877529 +0100 -@@ -159,6 +159,11 @@ - '../build/android/ndk.gyp:cpu_features', - ], - }], -+ [ 'OS != "android" and target_arch == "arm"', { -+ 'sources': [ -+ '../third_party/skia/src/core/SkUtilsArm.cpp', -+ ], -+ }], - [ 'desktop_linux == 1 or chromeos == 1 or qt_os=="embedded_linux"', { - 'dependencies': [ - '../build/linux/system.gyp:fontconfig', diff --git a/qtwebengine-opensource-src-5.8.0-fix-dead-keys.patch b/qtwebengine-opensource-src-5.8.0-fix-dead-keys.patch deleted file mode 100644 index a0cf81c..0000000 --- a/qtwebengine-opensource-src-5.8.0-fix-dead-keys.patch +++ /dev/null @@ -1,40 +0,0 @@ -From 31374ba98829e984c7600419c0e5fa71b96fc530 Mon Sep 17 00:00:00 2001 -From: Peter Varga -Date: Fri, 24 Mar 2017 14:31:02 +0100 -Subject: Forward input method events to RWHV in widget - -Task-number: QTBUG-58362 -Change-Id: Id4cf57c60da17538b224bb9bc91277c324c6a55d -Reviewed-by: Viktor Engelmann -Reviewed-by: Allan Sandfeld Jensen ---- - .../render_widget_host_view_qt_delegate_widget.cpp | 9 +++++++++ - 1 file changed, 9 insertions(+) - -diff --git a/src/webenginewidgets/render_widget_host_view_qt_delegate_widget.cpp b/src/webenginewidgets/render_widget_host_view_qt_delegate_widget.cpp -index 14c4d72..fd58a07 100644 ---- a/src/webenginewidgets/render_widget_host_view_qt_delegate_widget.cpp -+++ b/src/webenginewidgets/render_widget_host_view_qt_delegate_widget.cpp -@@ -84,10 +84,19 @@ protected: - { - m_client->forwardEvent(event); - } -+ void inputMethodEvent(QInputMethodEvent *event) override -+ { -+ m_client->forwardEvent(event); -+ } - QSGNode *updatePaintNode(QSGNode *oldNode, UpdatePaintNodeData *) override - { - return m_client->updatePaintNode(oldNode); - } -+ -+ QVariant inputMethodQuery(Qt::InputMethodQuery query) const override -+ { -+ return m_client->inputMethodQuery(query); -+ } - private: - RenderWidgetHostViewQtDelegateClient *m_client; - }; --- -cgit v1.0-4-g1e03 - diff --git a/qtwebengine-opensource-src-5.8.0-fix-open-in-new-tab.patch b/qtwebengine-opensource-src-5.8.0-fix-open-in-new-tab.patch deleted file mode 100644 index c95a712..0000000 --- a/qtwebengine-opensource-src-5.8.0-fix-open-in-new-tab.patch +++ /dev/null @@ -1,46 +0,0 @@ -From 8e147ed3be7740092de233a2a7c67ec890069649 Mon Sep 17 00:00:00 2001 -From: =?UTF-8?q?Michael=20Br=C3=BCning?= -Date: Mon, 13 Mar 2017 11:13:56 +0100 -Subject: Remove stale parent connection when initializing delegate as a child - -When clicking on a blank link target, the constructor of the -RenderWidgetHostViewQtDelegateWidget instance for the newly created -view is called with the originating QWebEngineView as its parent -and will connect its removeParentBeforeParentDelete slot to the -originating view's destroyed signal. - -This leads to the situation where the delegate's parent will be set to -null when the originating view is closed, causing the view to display -only an empty widget with the actual web contents remaining live in -the background. - -This patch removes the connection to the old view when initializing -the delegate as a child of the QWebEnginePagePrivate instance. The -addition to the layout updates the parent and child relationship -between the view and the delegate internally. - -Task-number: QTBUG-58381 -Change-Id: I448380478c2bcfcfbddaee8a35caf46010e57972 -Reviewed-by: Florian Bruhin -Reviewed-by: Joerg Bornemann ---- - src/webenginewidgets/render_widget_host_view_qt_delegate_widget.cpp | 3 +++ - 1 file changed, 3 insertions(+) - -diff --git a/src/webenginewidgets/render_widget_host_view_qt_delegate_widget.cpp b/src/webenginewidgets/render_widget_host_view_qt_delegate_widget.cpp -index e7ad5b1..14c4d72 100644 ---- a/src/webenginewidgets/render_widget_host_view_qt_delegate_widget.cpp -+++ b/src/webenginewidgets/render_widget_host_view_qt_delegate_widget.cpp -@@ -163,6 +163,9 @@ void RenderWidgetHostViewQtDelegateWidget::initAsChild(WebContentsAdapterClient* - - QWebEnginePagePrivate *pagePrivate = static_cast(container); - if (pagePrivate->view) { -+ if (parentWidget()) -+ disconnect(parentWidget(), &QObject::destroyed, -+ this, &RenderWidgetHostViewQtDelegateWidget::removeParentBeforeParentDelete); - pagePrivate->view->layout()->addWidget(this); - pagePrivate->view->setFocusProxy(this); - show(); --- -cgit v1.0-4-g1e03 - diff --git a/qtwebengine-opensource-src-5.8.0-no-sse2.patch b/qtwebengine-opensource-src-5.8.0-no-sse2.patch deleted file mode 100644 index ee15329..0000000 --- a/qtwebengine-opensource-src-5.8.0-no-sse2.patch +++ /dev/null @@ -1,5311 +0,0 @@ -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 -@@ -80,8 +80,8 @@ - # The system root for cross-compiles. Default: none. - 'sysroot%': '', - -- # On Linux, we build with sse2 for Chromium builds. -- 'disable_sse2%': 0, -+ # Do not assume SSE2 by default (Fedora patch). -+ 'disable_sse2%': 1 - }, - - 'target_arch%': '<(target_arch)', -@@ -725,17 +725,13 @@ - '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', -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 @@ - # 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': [ -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 @@ - "trees/tree_synchronizer.h", - ] - -- if (current_cpu == "x86" || current_cpu == "x64") { -- sources += [ -- "raster/texture_compressor_etc1_sse.cc", -- "raster/texture_compressor_etc1_sse.h", -- ] -- } -- - configs += [ "//build/config:precompiled_headers" ] - - public_deps = [ -@@ -553,6 +546,7 @@ - deps = [ - "//base", - "//base/third_party/dynamic_annotations", -+ "//cc:cc_opts", - "//cc/proto", - "//cc/surfaces:surface_id", - "//gpu", -@@ -581,6 +575,36 @@ - } - } - -+source_set("cc_opts") { -+ public_deps = [ -+ "//cc:cc_opts_sse", -+ ] -+} -+ -+source_set("cc_opts_sse") { -+ if (current_cpu == "x86" || current_cpu == "x64") { -+ 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 = [ -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 @@ - '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', -- ], -- }], -- ], - }, - { - # GN version: "//cc/proto" -@@ -678,6 +670,7 @@ - '<(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', -@@ -714,5 +707,41 @@ - '../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', -+ ], -+ }], -+ ], -+ }, - ], - } -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 @@ - } - - 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" ] - } - - if (is_linux || is_win) { -@@ -534,10 +534,47 @@ - } - - 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", -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" - #include "base/trace_event/trace_event.h" - #include "media/base/media_switches.h" -+#include "media/base/sinc_resampler.h" -+#include "media/base/vector_math.h" - #include "media/base/yuv_convert.h" - - #if defined(OS_ANDROID) -@@ -40,6 +42,8 @@ - TRACE_EVENT_WARMUP_CATEGORY("media"); - - // Perform initialization of libraries which require runtime CPU detection. -+ vector_math::Initialize(); -+ SincResampler::InitializeCPUSpecificFeatures(); - InitializeCPUSpecificYUVConversions(); - - #if !defined(MEDIA_DISABLE_FFMPEG) -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 -@@ -65,6 +65,17 @@ - int rgbstride, - YUVType yuv_type); - -+MEDIA_EXPORT void ConvertYUVToRGB32_MMX(const uint8_t* yplane, -+ const uint8_t* uplane, -+ const uint8_t* vplane, -+ uint8_t* rgbframe, -+ int width, -+ int height, -+ int ystride, -+ int uvstride, -+ int rgbstride, -+ YUVType yuv_type); -+ - 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, -+ ptrdiff_t width, -+ const int16_t* convert_table); -+ - MEDIA_EXPORT void ConvertYUVToRGB32Row_SSE(const uint8_t* yplane, - const uint8_t* uplane, - const uint8_t* vplane, -@@ -131,6 +149,14 @@ - ptrdiff_t width, - const int16_t* convert_table); - -+MEDIA_EXPORT void ScaleYUVToRGB32Row_MMX(const uint8_t* y_buf, -+ const uint8_t* u_buf, -+ const uint8_t* v_buf, -+ uint8_t* rgb_buf, -+ ptrdiff_t width, -+ ptrdiff_t source_dx, -+ const int16_t* convert_table); -+ - MEDIA_EXPORT void ScaleYUVToRGB32Row_SSE(const uint8_t* y_buf, - const uint8_t* u_buf, - const uint8_t* v_buf, -@@ -147,6 +173,14 @@ - ptrdiff_t source_dx, - const int16_t* convert_table); - -+MEDIA_EXPORT void LinearScaleYUVToRGB32Row_MMX(const uint8_t* y_buf, -+ const uint8_t* u_buf, -+ const uint8_t* v_buf, -+ uint8_t* rgb_buf, -+ ptrdiff_t width, -+ ptrdiff_t source_dx, -+ 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, -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 -@@ -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" -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 -@@ -47,6 +47,34 @@ - EmptyRegisterState(); - } - -+void ConvertYUVToRGB32_MMX(const uint8_t* yplane, -+ const uint8_t* uplane, -+ const uint8_t* vplane, -+ uint8_t* rgbframe, -+ 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) { -+ 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; -+ -+ ConvertYUVToRGB32Row_MMX(y_ptr, -+ u_ptr, -+ v_ptr, -+ rgb_row, -+ width, -+ GetLookupTable(yuv_type)); -+ } -+ -+ EmptyRegisterState(); -+} -+ - void ConvertYUVToRGB32_SSE(const uint8_t* yplane, - const uint8_t* uplane, - const uint8_t* vplane, -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 -@@ -20,6 +20,12 @@ - int source_width, - uint8_t source_y_fraction); - -+MEDIA_EXPORT void FilterYUVRows_MMX(uint8_t* ybuf, -+ const uint8_t* y0_ptr, -+ const uint8_t* y1_ptr, -+ int source_width, -+ uint8_t source_y_fraction); -+ - MEDIA_EXPORT void FilterYUVRows_SSE2(uint8_t* ybuf, - const uint8_t* y0_ptr, - const uint8_t* y1_ptr, -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 -@@ -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 -+#else -+#include -+#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 -+ -+void FilterYUVRows_MMX(uint8_t* dest, -+ const uint8_t* src0, -+ const uint8_t* src1, -+ int width, -+ uint8_t fraction) { -+ int pixel = 0; -+ -+ // Process the unaligned bytes first. -+ int unaligned_width = -+ (8 - (reinterpret_cast(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(src0 + pixel); -+ const __m64* src1_64 = reinterpret_cast(src1 + pixel); -+ __m64* dest64 = reinterpret_cast<__m64*>(dest + pixel); -+ __m64* end64 = reinterpret_cast<__m64*>( -+ reinterpret_cast(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 -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 -@@ -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 -+ -+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(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(1.0 - kernel_interpolation_factor))); -+ m_sums2 = _mm_mul_ps(m_sums2, _mm_set_ps1( -+ static_cast(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 -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 -@@ -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 -+ -+#include // 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 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 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 -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 -@@ -81,17 +81,12 @@ - #include - #include - -+#include "base/cpu.h" - #include "base/logging.h" - #include "build/build_config.h" - --#if defined(ARCH_CPU_X86_FAMILY) --#include --#define CONVOLVE_FUNC Convolve_SSE --#elif defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON) -+#if defined(ARCH_CPU_ARM_FAMILY) && defined(USE_NEON) - #include --#define CONVOLVE_FUNC Convolve_NEON --#else --#define CONVOLVE_FUNC Convolve_C - #endif - - namespace media { -@@ -112,10 +107,41 @@ - 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) -@@ -343,46 +369,7 @@ - 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(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(1.0 - kernel_interpolation_factor))); -- m_sums2 = _mm_mul_ps(m_sums2, _mm_set_ps1( -- static_cast(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) { -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 @@ - 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. -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 -@@ -4,6 +4,7 @@ - - #include "base/bind.h" - #include "base/bind_helpers.h" -+#include "base/cpu.h" - #include "base/time/time.h" - #include "build/build_config.h" - #include "media/base/sinc_resampler.h" -@@ -61,6 +62,9 @@ - &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( -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 @@ - - #include "base/bind.h" - #include "base/bind_helpers.h" -+#include "base/cpu.h" - #include "base/macros.h" - #include "base/strings/string_number_conversions.h" - #include "base/time/time.h" -@@ -166,6 +167,10 @@ - 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( -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 -@@ -7,12 +7,17 @@ - - #include - -+#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 -+#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 (*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 - #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(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 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 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; -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 -@@ -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[]); -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 - - #include "base/macros.h" -+#include "base/cpu.h" - #include "base/memory/aligned_memory.h" - #include "base/time/time.h" - #include "build/build_config.h" -@@ -82,15 +83,11 @@ - 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. -@@ -99,6 +96,9 @@ - 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); -@@ -112,12 +112,24 @@ - #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); -@@ -131,6 +143,14 @@ - #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(). -@@ -139,6 +159,9 @@ - "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); -@@ -156,4 +179,6 @@ - #endif - } - -+#undef EWMAAndMaxPower_FUNC -+ - } // namespace media -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 -@@ -19,7 +19,7 @@ - MEDIA_EXPORT std::pair 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, -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 - - #include "base/macros.h" -+#include "base/cpu.h" - #include "base/memory/aligned_memory.h" - #include "base/strings/string_number_conversions.h" - #include "base/strings/stringize_macros.h" -@@ -78,6 +79,7 @@ - - #if defined(ARCH_CPU_X86_FAMILY) - { -+ ASSERT_TRUE(base::CPU().has_sse()); - SCOPED_TRACE("FMAC_SSE"); - FillTestVectors(kInputFillValue, kOutputFillValue); - vector_math::FMAC_SSE( -@@ -119,6 +121,7 @@ - - #if defined(ARCH_CPU_X86_FAMILY) - { -+ ASSERT_TRUE(base::CPU().has_sse()); - SCOPED_TRACE("FMUL_SSE"); - FillTestVectors(kInputFillValue, kOutputFillValue); - vector_math::FMUL_SSE( -@@ -227,6 +230,7 @@ - - #if defined(ARCH_CPU_X86_FAMILY) - { -+ ASSERT_TRUE(base::CPU().has_sse()); - SCOPED_TRACE("EWMAAndMaxPower_SSE"); - const std::pair& result = vector_math::EWMAAndMaxPower_SSE( - initial_value_, data_.get(), data_len_, smoothing_factor_); -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 @@ - #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 - #else -@@ -133,7 +133,7 @@ - - // 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)(); -@@ -247,34 +247,46 @@ - // 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; - -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 @@ - DISALLOW_COPY_AND_ASSIGN(YUVConvertPerfTest); - }; - -+TEST_F(YUVConvertPerfTest, ConvertYUVToRGB32Row_MMX) { -+ ASSERT_TRUE(base::CPU().has_mmx()); -+ -+ base::TimeTicks start = base::TimeTicks::Now(); -+ 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)); -+ } -+ } -+ media::EmptyRegisterState(); -+ double total_time_seconds = (base::TimeTicks::Now() - start).InSecondsF(); -+ 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()); - -@@ -161,9 +184,32 @@ - } - #endif - --// 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. -+ -+ base::TimeTicks start = base::TimeTicks::Now(); -+ 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)); -+ } -+ } -+ media::EmptyRegisterState(); -+ double total_time_seconds = (base::TimeTicks::Now() - start).InSecondsF(); -+ 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()); - -@@ -190,6 +236,32 @@ - kPerfTestIterations / total_time_seconds, "runs/s", true); - } - -+TEST_F(YUVConvertPerfTest, LinearScaleYUVToRGB32Row_MMX) { -+ ASSERT_TRUE(base::CPU().has_mmx()); -+ -+ const int kSourceDx = 80000; // This value means a scale down. -+ -+ base::TimeTicks start = base::TimeTicks::Now(); -+ 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)); -+ } -+ } -+ media::EmptyRegisterState(); -+ double total_time_seconds = (base::TimeTicks::Now() - start).InSecondsF(); -+ 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()); - -@@ -215,7 +287,6 @@ - "yuv_convert_perftest", "", "LinearScaleYUVToRGB32Row_SSE", - 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) - -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 @@ - 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 yuv_bytes(new uint8[kYUV12Size]); -+ scoped_ptr rgb_bytes_reference(new uint8[kRGBSize]); -+ scoped_ptr 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()) { -@@ -674,9 +705,40 @@ - 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 yuv_bytes(new uint8[kYUV12Size]); -+ scoped_ptr rgb_bytes_reference(new uint8[kRGBSize]); -+ scoped_ptr 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()) { -@@ -711,6 +773,40 @@ - kWidth * kBpp)); - } - -+TEST(YUVConvertTest, LinearScaleYUVToRGB32Row_MMX) { -+ base::CPU cpu; -+ if (!cpu.has_mmx()) { -+ LOG(WARNING) << "System not supported. Test skipped."; -+ return; -+ } -+ -+ scoped_ptr yuv_bytes(new uint8[kYUV12Size]); -+ scoped_ptr rgb_bytes_reference(new uint8[kRGBSize]); -+ scoped_ptr 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()) { -@@ -744,7 +840,6 @@ - rgb_bytes_converted.get(), - kWidth * kBpp)); - } --#endif // defined(OS_WIN) && (ARCH_CPU_X86 || COMPONENT_BUILD) - - TEST(YUVConvertTest, FilterYUVRows_C_OutOfBounds) { - std::unique_ptr src(new uint8_t[16]); -@@ -761,6 +856,30 @@ - } - } - -+#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 src(new uint8[16]); -+ scoped_ptr 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()) { -@@ -782,6 +901,38 @@ - } - } - -+#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 src(new uint8[kSize]); -+ scoped_ptr dst_sample(new uint8[kSize]); -+ scoped_ptr 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( -+ (reinterpret_cast(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()) { -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 @@ - "//base", - "//ui/gfx/geometry", - ] -+ 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" ] -+ } -+ } - } - - # TODO(watk): Refactor tests that could be made to run on Android. See -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 @@ - ['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"', { -@@ -1616,6 +1616,11 @@ - 'USE_NEON' - ], - }], -+ ['target_arch=="ia32" or target_arch=="x64"', { -+ 'dependencies': [ -+ 'shared_memory_support_sse' -+ ], -+ }], - ], - }, - { -@@ -1633,6 +1638,7 @@ - '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', -@@ -1713,6 +1719,75 @@ - '../third_party/yasm/yasm_compile.gypi', - ], - }, -+ { -+ # 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 - }], - ['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 @@ - if (!is_ios) { - sources += [ "ext/platform_canvas.cc" ] - } -- if (!is_ios && (current_cpu == "x86" || current_cpu == "x64")) { -- sources += [ "ext/convolver_SSE2.cc" ] -- } else if (current_cpu == "mipsel" && mips_dsp_rev >= 2) { -- sources += [ "ext/convolver_mips_dspr2.cc" ] -- } - - # The skia gypi values are relative to the skia_dir, so we need to rebase. - sources += gypi_skia_core.sources -@@ -642,7 +637,15 @@ - if (skia_build_no_opts) { - sources = gypi_skia_opts.none_sources - } else if (current_cpu == "x86" || current_cpu == "x64") { -- 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 += [ - ":skia_opts_avx", - ":skia_opts_avx2", -@@ -677,6 +680,13 @@ - - 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 - } -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 -@@ -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; -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 -@@ -11,6 +11,7 @@ - #include - - #include "build/build_config.h" -+#include "base/cpu.h" - #include "third_party/skia/include/core/SkSize.h" - #include "third_party/skia/include/core/SkTypes.h" - -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 -@@ -9,6 +9,7 @@ - { - 'dependencies': [ - 'skia_library', -+ 'skia_chrome_opts', - '../base/base.gyp:base', - '../base/third_party/dynamic_annotations/dynamic_annotations.gyp:dynamic_annotations', - ], -@@ -67,22 +68,16 @@ - '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': [ -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 -@@ -128,6 +128,37 @@ - # 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', - # The optimize: 'max' scattered throughout are particularly - # 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 -@@ -19,10 +19,22 @@ - }, - - '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. - { -@@ -45,12 +57,13 @@ - ], - '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', -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 @@ - ] - - if (current_cpu == "x86" || current_cpu == "x64") { -- defines = [ "SSE2_ENABLE" ] -- sources += [ "src/transform-sse2.c" ] -+ defines = [ "SSE2_ENABLE" ] # runtime detection -+ deps = [ "qcms_sse2" ] - } - } - -@@ -75,3 +75,15 @@ - public_configs = [ ":qcms_config" ] - } - } -+ -+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" ] -+ } -+} -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 @@ - 'conditions': [ - ['target_arch=="ia32" or target_arch=="x64"', { - 'defines': [ -- 'SSE2_ENABLE', -+ 'SSE2_ENABLE', # runtime detection - ], -- 'sources': [ -- 'src/transform-sse2.c', -+ 'dependencies': [ -+ 'qcms_sse2', - ], - }], - ], -@@ -68,6 +68,29 @@ - }], - ], - }, -+ { -+ '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', -+ ], -+ }, -+ }, - ], - '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 -@@ -32,7 +32,7 @@ - #include "wtf/MathExtras.h" - #include - --#if CPU(X86) || CPU(X86_64) -+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64) - #include - #endif - -@@ -575,7 +575,7 @@ - // 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); -@@ -738,7 +738,7 @@ - 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 -@@ -843,7 +843,7 @@ - // 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); -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 -@@ -26,6 +26,9 @@ - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -+// include this first to get it before the CPU() function-like macro -+#include "base/cpu.h" -+ - #include "platform/audio/DirectConvolver.h" - - #if OS(MACOSX) -@@ -35,22 +38,44 @@ - #include "platform/audio/VectorMath.h" - #include "wtf/CPU.h" - --#if (CPU(X86) || CPU(X86_64)) && !OS(MACOSX) -+#if ((CPU(X86) && defined(__SSE2__)) || CPU(X86_64)) && !OS(MACOSX) - #include - #endif - -+#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; -@@ -82,7 +107,7 @@ - #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. - -@@ -392,7 +417,7 @@ - } - destP[i++] = sum; - } --#if CPU(X86) || CPU(X86_64) -+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64) - } - #endif - #endif // OS(MACOSX) -@@ -401,10 +426,14 @@ - memcpy(m_buffer.data(), inputP, sizeof(float) * framesToProcess); - } - -+#ifndef BUILD_ONLY_THE_SSE2_PARTS -+ - void DirectConvolver::reset() - { - m_buffer.zero(); - } - -+#endif -+ - } // namespace blink - -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 -@@ -32,6 +32,7 @@ - #include "platform/PlatformExport.h" - #include "platform/audio/AudioArray.h" - #include "wtf/Allocator.h" -+#include "wtf/CPU.h" - #include "wtf/Noncopyable.h" - - namespace blink { -@@ -50,6 +51,11 @@ - size_t m_inputBlockSize; - - AudioFloatArray m_buffer; -+ -+#if CPU(X86) -+ bool m_haveSSE2; -+ void m_processSSE2(AudioFloatArray* convolutionKernel, const float* sourceP, float* destP, size_t framesToProcess); -+#endif - }; - - } // namespace blink -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 -@@ -0,0 +1,2 @@ -+#define BUILD_ONLY_THE_SSE2_PARTS -+#include "DirectConvolver.cpp" -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 -@@ -26,15 +26,22 @@ - * THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -+// 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 - #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): - // - // |----------------|----------------------------------------------------------------|----------------| -@@ -64,6 +71,8 @@ - - namespace blink { - -+#ifndef BUILD_ONLY_THE_SSE2_PARTS -+ - SincResampler::SincResampler(double scaleFactor, unsigned kernelSize, unsigned numberOfKernelOffsets) - : m_scaleFactor(scaleFactor) - , m_kernelSize(kernelSize) -@@ -77,6 +86,10 @@ - , m_sourceProvider(nullptr) - , m_isBufferPrimed(false) - { -+#if CPU(X86) -+ base::CPU cpu; -+ m_haveSSE2 = cpu.has_sse2(); -+#endif - initializeKernel(); - } - -@@ -193,8 +206,20 @@ - } - } - -+#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) -@@ -256,7 +281,7 @@ - { - 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(inputP) & 0x0F) && n) { - CONVOLVE_ONE_SAMPLE -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 -@@ -33,6 +33,7 @@ - #include "platform/audio/AudioArray.h" - #include "platform/audio/AudioSourceProvider.h" - #include "wtf/Allocator.h" -+#include "wtf/CPU.h" - #include "wtf/Noncopyable.h" - - namespace blink { -@@ -84,6 +85,11 @@ - - // The buffer is primed once at the very beginning of processing. - bool m_isBufferPrimed; -+ -+#if CPU(X86) -+ bool m_haveSSE2; -+ void m_processSSE2(AudioSourceProvider*, float* destination, size_t framesToProcess); -+#endif - }; - - } // namespace blink -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 -@@ -0,0 +1,2 @@ -+#define BUILD_ONLY_THE_SSE2_PARTS -+#include "SincResampler.cpp" -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 -@@ -22,6 +22,9 @@ - * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. - */ - -+// 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" -@@ -32,10 +35,14 @@ - #include - #endif - --#if CPU(X86) || CPU(X86_64) -+#if (CPU(X86) && defined(__SSE2__)) || CPU(X86_64) - #include - #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 - #endif -@@ -118,11 +125,25 @@ - } - #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; - -@@ -193,9 +214,15 @@ - - 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; - -@@ -266,16 +293,22 @@ - 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(source1P) & 0x0F) && n) { -@@ -378,17 +411,23 @@ - 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(source1P) & 0x0F) && n) { -@@ -460,8 +499,14 @@ - - 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(real1P) & 0x0F) -@@ -516,10 +561,16 @@ - - 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(sourceP) & 0x0F) && n) { -@@ -581,10 +632,16 @@ - - 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(sourceP) & 0x0F) && n) { -@@ -648,6 +705,8 @@ - *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; -@@ -678,6 +737,12 @@ - } - } - -+#endif -+ -+#ifdef BUILD_ONLY_THE_SSE2_PARTS -+} // namespace SSE2 -+#endif -+ - #endif // OS(MACOSX) - - } // namespace VectorMath -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 -@@ -26,6 +26,7 @@ - #define VectorMath_h - - #include "platform/PlatformExport.h" -+#include "wtf/CPU.h" - #include "wtf/build_config.h" - #include - -@@ -55,6 +56,28 @@ - // 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); - -+#if CPU(X86) -+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 - -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 -@@ -0,0 +1,2 @@ -+#define BUILD_ONLY_THE_SSE2_PARTS -+#include "VectorMath.cpp" -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 @@ - '<(DEPTH)/third_party/openmax_dl/dl/dl.gyp:openmax_dl', - ], - }], -+ ['target_arch == "ia32"', { -+ 'dependencies': [ -+ 'blink_sse2', -+ ], -+ }], - ['target_arch=="arm"', { - 'dependencies': [ - 'blink_arm_neon', -@@ -406,6 +411,36 @@ - }], - ], - }, -+ { -+ 'target_name': 'blink_sse2', -+ 'conditions': [ -+ ['target_arch=="ia32"', { -+ 'type': 'static_library', -+ 'dependencies': [ -+ '<(DEPTH)/third_party/khronos/khronos.gyp:khronos_headers', -+ '../config.gyp:config', -+ '../wtf/wtf.gyp:wtf', -+ 'blink_common', -+ 'blink_heap_asm_stubs', -+ ], -+ 'defines': [ -+ 'BLINK_PLATFORM_IMPLEMENTATION=1', -+ 'INSIDE_BLINK', -+ ], -+ 'sources': [ -+ 'audio/DirectConvolverSSE2.cpp', -+ 'audio/SincResamplerSSE2.cpp', -+ 'audio/VectorMathSSE2.cpp', -+ ], -+ 'cflags': [ -+ '-msse2', -+ '-mfpmath=sse', -+ ], -+ },{ # 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. -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 -@@ -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 - -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 @@ - const uint32_t* source32 = reinterpret_cast_ptr(source); - uint32_t* destination32 = reinterpret_cast_ptr(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) { -@@ -442,7 +442,7 @@ - - template<> void unpack(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) -@@ -464,7 +464,7 @@ - - template<> void unpack(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) -@@ -630,7 +630,7 @@ - // FIXME: this routine is lossy and must be removed. - template<> void pack(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) { -@@ -667,7 +667,7 @@ - // FIXME: this routine is lossy and must be removed. - template<> void pack(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) { -@@ -741,7 +741,7 @@ - // FIXME: this routine is lossy and must be removed. - template<> void pack(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) { -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 -@@ -14,6 +14,7 @@ - #include "webrtc/common_audio/real_fourier_ooura.h" - #include "webrtc/common_audio/real_fourier_openmax.h" - #include "webrtc/common_audio/signal_processing/include/signal_processing_library.h" -+#include "webrtc/system_wrappers/include/cpu_features_wrapper.h" - - namespace webrtc { - -@@ -23,7 +24,15 @@ - - std::unique_ptr RealFourier::Create(int fft_order) { - #if defined(RTC_USE_OPENMAX_DL) -+#if defined(WEBRTC_ARCH_X86_FAMILY) && !defined(__SSE2__) -+ // x86 CPU detection required. -+ if (WebRtc_GetCPUInfo(kSSE2)) -+ return std::unique_ptr(new RealFourierOpenmax(fft_order)); -+ else -+ return std::unique_ptr(new RealFourierOoura(fft_order)); -+#else - return std::unique_ptr(new RealFourierOpenmax(fft_order)); -+#endif - #else - return std::unique_ptr(new RealFourierOoura(fft_order)); - #endif -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 @@ - # 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))) -@@ -1353,6 +1355,8 @@ - pri_file.write("LIBS_PRIVATE += -Wl,--start-group %s -Wl,--end-group\n" % qmakeLiteral(' '.join(prefixed_archives))) - 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. -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 @@ - - if (v8_target_cpu == "x86") { - sources += [ -- "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", -- "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", -- "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", -- "src/ic/ia32/ic-ia32.cc", -- "src/ic/ia32/stub-cache-ia32.cc", -- "src/regexp/ia32/regexp-macro-assembler-ia32.cc", -- "src/regexp/ia32/regexp-macro-assembler-ia32.h", -+ "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", -+ "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", -+ "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", -+ "src/ic/x87/ic-x87.cc", -+ "src/ic/x87/stub-cache-x87.cc", -+ "src/regexp/x87/regexp-macro-assembler-x87.cc", -+ "src/regexp/x87/regexp-macro-assembler-x87.h", - ] - } else if (v8_target_cpu == "x64") { - sources += [ -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': 'v8_sse2.gyp -+# rename all target names -+SUBTARGETS=`grep "'target_name': '" v8.gyp | sed -e "s/^.*'target_name': '//g" -e "s/',$//g"` -+SEDS= -+for SUBTARGET in $SUBTARGETS ; do -+ SEDS=$SEDS\ -e\ "s/'$SUBTARGET\(['#]\)/'${SUBTARGET}_sse2\1/g" -+done -+# 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 -+sed -e "s/^\( 'variables': {\)/\1\n 'v8_target_arch': 'ia32',/g" \ -+ -e "s/\('action_name': '\)/\1v8_sse2_/g" \ -+ $SEDS \ -+ -e "s/\('mksnapshot_exec': '.*mksnapshot\)/\1_sse2/g" \ -+ -e "s#/snapshot\.cc#/snapshot_sse2.cc#g" \ -+ -e "s/libraries\.cc/libraries_sse2.cc/g" \ -+ -e "s/\.bin/_sse2.bin/g" \ -+ -e "s#^\( *\)\('target_name': 'v8_sse2',\)#\1\2\n\1'product_name': 'v8',\n\1'product_dir': '<(PRODUCT_DIR)/lib/sse2',#g" \ -+ v8.gyp >>v8_sse2.gyp -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 -@@ -36,6 +36,14 @@ - 'v8_experimental_extra_library_files%': [], - '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)', -+ }], -+ ], - }, - 'includes': ['../gypfiles/toolchain.gypi', '../gypfiles/features.gypi'], - 'targets': [ -@@ -49,8 +57,8 @@ - }, { - '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. -@@ -161,7 +169,7 @@ - 'js2c', - ], - }], -- ['component=="shared_library"', { -+ ['v8_component=="shared_library"', { - 'defines': [ - 'V8_SHARED', - 'BUILDING_V8_SHARED', -@@ -253,7 +261,7 @@ - 'toolsets': ['target'], - 'dependencies': ['js2c'], - }], -- ['component=="shared_library"', { -+ ['v8_component=="shared_library"', { - 'defines': [ - 'BUILDING_V8_SHARED', - 'V8_SHARED', -@@ -281,7 +289,7 @@ - 'natives_blob', - ], - }], -- ['component=="shared_library"', { -+ ['v8_component=="shared_library"', { - 'defines': [ - 'V8_SHARED', - 'BUILDING_V8_SHARED', -@@ -1608,7 +1616,7 @@ - # See http://crbug.com/485155. - 'msvs_shard': 4, - }], -- ['component=="shared_library"', { -+ ['v8_component=="shared_library"', { - 'defines': [ - 'BUILDING_V8_SHARED', - 'V8_SHARED', -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 -@@ -0,0 +1,2313 @@ -+# 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': { -+ 'v8_target_arch': 'ia32', -+ 'v8_code': 1, -+ 'v8_random_seed%': 314159265, -+ 'v8_vector_stores%': 0, -+ 'embed_script%': "", -+ 'warmup_script%': "", -+ 'v8_extra_library_files%': [], -+ 'v8_experimental_extra_library_files%': [], -+ '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)', -+ }], -+ ], -+ }, -+ 'includes': ['../gypfiles/toolchain.gypi', '../gypfiles/features.gypi'], -+ 'targets': [ -+ { -+ 'target_name': 'v8_sse2', -+ 'product_name': 'v8', -+ 'product_dir': '<(PRODUCT_DIR)/lib/sse2', -+ '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. -+ 'v8dll-main.cc', -+ ], -+ 'include_dirs': [ -+ '..', -+ ], -+ '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': [ -+ '../include', -+ ], -+ }, -+ }, -+ { -+ # 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'], -+ 'inputs': [ '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', ], -+ }], -+ ['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': [ -+ '<(PRODUCT_DIR)/snapshot_blob_host_sse2.bin', -+ ], -+ }, { -+ 'inputs': [ -+ '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', -+ ], -+ }], -+ ], -+ }], -+ ['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': [ -+ 'mksnapshot_sse2#host', -+ 'js2c_sse2#host', -+ ], -+ }, { -+ 'toolsets': ['target'], -+ 'dependencies': [ -+ 'mksnapshot_sse2', -+ 'js2c_sse2', -+ ], -+ }], -+ ['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+': [ -+ '..', -+ ], -+ 'sources': [ -+ '<(SHARED_INTERMEDIATE_DIR)/libraries_sse2.cc', -+ '<(SHARED_INTERMEDIATE_DIR)/experimental-libraries_sse2.cc', -+ '<(SHARED_INTERMEDIATE_DIR)/extras-libraries_sse2.cc', -+ '<(SHARED_INTERMEDIATE_DIR)/experimental-extras-libraries_sse2.cc', -+ '<(INTERMEDIATE_DIR)/snapshot_sse2.cc', -+ ], -+ 'actions': [ -+ { -+ 'action_name': 'v8_sse2_run_mksnapshot', -+ 'inputs': [ -+ '<(mksnapshot_exec)', -+ ], -+ 'conditions': [ -+ ['embed_script!=""', { -+ 'inputs': [ -+ '<(embed_script)', -+ ], -+ }], -+ ['warmup_script!=""', { -+ 'inputs': [ -+ '<(warmup_script)', -+ ], -+ }], -+ ], -+ 'outputs': [ -+ '<(INTERMEDIATE_DIR)/snapshot_sse2.cc', -+ ], -+ 'variables': { -+ 'mksnapshot_flags': [], -+ 'conditions': [ -+ ['v8_random_seed!=0', { -+ 'mksnapshot_flags': ['--random-seed', '<(v8_random_seed)'], -+ }], -+ ['v8_vector_stores!=0', { -+ 'mksnapshot_flags': ['--vector-stores'], -+ }], -+ ], -+ }, -+ 'action': [ -+ '<(mksnapshot_exec)', -+ '<@(mksnapshot_flags)', -+ '--startup_src', '<@(INTERMEDIATE_DIR)/snapshot_sse2.cc', -+ '<(embed_script)', -+ '<(warmup_script)', -+ ], -+ }, -+ ], -+ }, -+ { -+ 'target_name': 'v8_nosnapshot_sse2', -+ 'type': 'static_library', -+ 'dependencies': [ -+ 'v8_base_sse2', -+ ], -+ 'include_dirs+': [ -+ '..', -+ ], -+ 'sources': [ -+ '<(SHARED_INTERMEDIATE_DIR)/libraries_sse2.cc', -+ '<(SHARED_INTERMEDIATE_DIR)/experimental-libraries_sse2.cc', -+ '<(SHARED_INTERMEDIATE_DIR)/extras-libraries_sse2.cc', -+ '<(SHARED_INTERMEDIATE_DIR)/experimental-extras-libraries_sse2.cc', -+ 'snapshot/snapshot-empty.cc', -+ ], -+ 'conditions': [ -+ ['want_separate_host_toolset==1', { -+ 'toolsets': ['host', 'target'], -+ 'dependencies': ['js2c_sse2#host'], -+ }, { -+ 'toolsets': ['target'], -+ 'dependencies': ['js2c_sse2'], -+ }], -+ ['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': [ -+ 'mksnapshot_sse2#host', -+ 'js2c_sse2#host', -+ 'natives_blob_sse2', -+ ]}, { -+ 'toolsets': ['target'], -+ 'dependencies': [ -+ 'mksnapshot_sse2', -+ 'js2c_sse2', -+ 'natives_blob_sse2', -+ ], -+ }], -+ ['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+': [ -+ '..', -+ ], -+ 'sources': [ -+ 'snapshot/natives-external.cc', -+ 'snapshot/snapshot-external.cc', -+ ], -+ 'actions': [ -+ { -+ 'action_name': 'v8_sse2_run_mksnapshot (external)', -+ 'inputs': [ -+ '<(mksnapshot_exec)', -+ ], -+ 'variables': { -+ 'mksnapshot_flags': [], -+ 'conditions': [ -+ ['v8_random_seed!=0', { -+ 'mksnapshot_flags': ['--random-seed', '<(v8_random_seed)'], -+ }], -+ ['v8_vector_stores!=0', { -+ 'mksnapshot_flags': ['--vector-stores'], -+ }], -+ ], -+ }, -+ 'conditions': [ -+ ['embed_script!=""', { -+ 'inputs': [ -+ '<(embed_script)', -+ ], -+ }], -+ ['warmup_script!=""', { -+ 'inputs': [ -+ '<(warmup_script)', -+ ], -+ }], -+ ['want_separate_host_toolset==1', { -+ 'target_conditions': [ -+ ['_toolset=="host"', { -+ 'outputs': [ -+ '<(PRODUCT_DIR)/snapshot_blob_host_sse2.bin', -+ ], -+ 'action': [ -+ '<(mksnapshot_exec)', -+ '<@(mksnapshot_flags)', -+ '--startup_blob', '<(PRODUCT_DIR)/snapshot_blob_host_sse2.bin', -+ '<(embed_script)', -+ '<(warmup_script)', -+ ], -+ }, { -+ 'outputs': [ -+ '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', -+ ], -+ 'action': [ -+ '<(mksnapshot_exec)', -+ '<@(mksnapshot_flags)', -+ '--startup_blob', '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', -+ '<(embed_script)', -+ '<(warmup_script)', -+ ], -+ }], -+ ], -+ }, { -+ 'outputs': [ -+ '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', -+ ], -+ 'action': [ -+ '<(mksnapshot_exec)', -+ '<@(mksnapshot_flags)', -+ '--startup_blob', '<(PRODUCT_DIR)/snapshot_blob_sse2.bin', -+ '<(embed_script)', -+ '<(warmup_script)', -+ ], -+ }], -+ ], -+ }, -+ ], -+ }], -+ ], -+ }, -+ { -+ 'target_name': 'v8_base_sse2', -+ 'type': 'static_library', -+ 'dependencies': [ -+ 'v8_libbase_sse2', -+ 'v8_libsampler_sse2', -+ ], -+ 'variables': { -+ 'optimize': 'max', -+ }, -+ 'include_dirs+': [ -+ '..', -+ '<(DEPTH)', -+ ], -+ 'sources': [ ### gcmole(all) ### -+ '../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', -+ ], -+ '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) ### -+ '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', -+ ], -+ }], -+ ['v8_target_arch=="arm64"', { -+ 'sources': [ ### gcmole(arch:arm64) ### -+ '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', -+ ], -+ }], -+ ['v8_target_arch=="ia32"', { -+ 'sources': [ ### gcmole(arch:ia32) ### -+ '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', -+ ], -+ }], -+ ['v8_target_arch=="x87"', { -+ 'sources': [ ### gcmole(arch:x87) ### -+ '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', -+ ], -+ }], -+ ['v8_target_arch=="mips" or v8_target_arch=="mipsel"', { -+ 'sources': [ ### gcmole(arch:mipsel) ### -+ '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', -+ ], -+ }], -+ ['v8_target_arch=="mips64" or v8_target_arch=="mips64el"', { -+ 'sources': [ ### gcmole(arch:mips64el) ### -+ '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', -+ ], -+ }], -+ ['v8_target_arch=="x64" or v8_target_arch=="x32"', { -+ 'sources': [ ### gcmole(arch:x64) ### -+ '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', -+ ], -+ }], -+ ['v8_target_arch=="x64"', { -+ 'sources': [ -+ 'compiler/x64/code-generator-x64.cc', -+ 'compiler/x64/instruction-codes-x64.h', -+ 'compiler/x64/instruction-scheduler-x64.cc', -+ 'compiler/x64/instruction-selector-x64.cc', -+ ], -+ }], -+ ['v8_target_arch=="ppc" or v8_target_arch=="ppc64"', { -+ 'sources': [ ### gcmole(arch:ppc) ### -+ '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', -+ ], -+ }], -+ ['OS=="win"', { -+ 'variables': { -+ 'gyp_generators': ' pObj = param.ToV8Object(); -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/Document.cpp qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/Document.cpp ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/Document.cpp 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/Document.cpp 2017-03-06 13:04:01.783297575 +0100 -@@ -411,22 +411,20 @@ - - int nlength = params.size(); - if (nlength == 9) { -- if (params[8].GetType() == CJS_Value::VT_fxobject) { -+ if (params[8].GetType() == CJS_Value::VT_object) { - v8::Local pObj = params[8].ToV8Object(); -- { -- if (FXJS_GetObjDefnID(pObj) == CJS_PrintParamsObj::g_nObjDefnID) { -- if (CJS_Object* pJSObj = params[8].ToCJSObject()) { -- if (PrintParamsObj* pprintparamsObj = -- (PrintParamsObj*)pJSObj->GetEmbedObject()) { -- bUI = pprintparamsObj->bUI; -- nStart = pprintparamsObj->nStart; -- nEnd = pprintparamsObj->nEnd; -- bSilent = pprintparamsObj->bSilent; -- bShrinkToFit = pprintparamsObj->bShrinkToFit; -- bPrintAsImage = pprintparamsObj->bPrintAsImage; -- bReverse = pprintparamsObj->bReverse; -- bAnnotations = pprintparamsObj->bAnnotations; -- } -+ if (FXJS_GetObjDefnID(pObj) == CJS_PrintParamsObj::g_nObjDefnID) { -+ if (CJS_Object* pJSObj = params[8].ToCJSObject()) { -+ if (PrintParamsObj* pprintparamsObj = -+ static_cast(pJSObj->GetEmbedObject())) { -+ bUI = pprintparamsObj->bUI; -+ nStart = pprintparamsObj->nStart; -+ nEnd = pprintparamsObj->nEnd; -+ bSilent = pprintparamsObj->bSilent; -+ bShrinkToFit = pprintparamsObj->bShrinkToFit; -+ bPrintAsImage = pprintparamsObj->bPrintAsImage; -+ bReverse = pprintparamsObj->bReverse; -+ bAnnotations = pprintparamsObj->bAnnotations; - } - } - } -@@ -597,18 +595,16 @@ - v8::Local pObj = params[0].ToV8Object(); - v8::Local pValue = FXJS_GetObjectElement(isolate, pObj, L"cURL"); - if (!pValue.IsEmpty()) -- strURL = -- CJS_Value(pRuntime, pValue, GET_VALUE_TYPE(pValue)).ToCFXWideString(); -+ strURL = CJS_Value(pRuntime, pValue).ToCFXWideString(); - - pValue = FXJS_GetObjectElement(isolate, pObj, L"bFDF"); -- bFDF = CJS_Value(pRuntime, pValue, GET_VALUE_TYPE(pValue)).ToBool(); -+ bFDF = CJS_Value(pRuntime, pValue).ToBool(); - - pValue = FXJS_GetObjectElement(isolate, pObj, L"bEmpty"); -- bEmpty = CJS_Value(pRuntime, pValue, GET_VALUE_TYPE(pValue)).ToBool(); -+ bEmpty = CJS_Value(pRuntime, pValue).ToBool(); - - pValue = FXJS_GetObjectElement(isolate, pObj, L"aFields"); -- aFields.Attach( -- CJS_Value(pRuntime, pValue, GET_VALUE_TYPE(pValue)).ToV8Array()); -+ aFields.Attach(CJS_Value(pRuntime, pValue).ToV8Array()); - } - - CPDFSDK_InterForm* pInterForm = m_pDocument->GetInterForm(); -@@ -691,25 +687,22 @@ - v8::Local pObj = params[0].ToV8Object(); - - v8::Local pValue = FXJS_GetObjectElement(isolate, pObj, L"bUI"); -- bUI = CJS_Value(pRuntime, pValue, GET_VALUE_TYPE(pValue)).ToInt(); -+ bUI = CJS_Value(pRuntime, pValue).ToInt(); - - pValue = FXJS_GetObjectElement(isolate, pObj, L"cTo"); -- cTo = CJS_Value(pRuntime, pValue, GET_VALUE_TYPE(pValue)).ToCFXWideString(); -+ cTo = CJS_Value(pRuntime, pValue).ToCFXWideString(); - - pValue = FXJS_GetObjectElement(isolate, pObj, L"cCc"); -- cCc = CJS_Value(pRuntime, pValue, GET_VALUE_TYPE(pValue)).ToCFXWideString(); -+ cCc = CJS_Value(pRuntime, pValue).ToCFXWideString(); - - pValue = FXJS_GetObjectElement(isolate, pObj, L"cBcc"); -- cBcc = -- CJS_Value(pRuntime, pValue, GET_VALUE_TYPE(pValue)).ToCFXWideString(); -+ cBcc = CJS_Value(pRuntime, pValue).ToCFXWideString(); - - pValue = FXJS_GetObjectElement(isolate, pObj, L"cSubject"); -- cSubject = -- CJS_Value(pRuntime, pValue, GET_VALUE_TYPE(pValue)).ToCFXWideString(); -+ cSubject = CJS_Value(pRuntime, pValue).ToCFXWideString(); - - pValue = FXJS_GetObjectElement(isolate, pObj, L"cMsg"); -- cMsg = -- CJS_Value(pRuntime, pValue, GET_VALUE_TYPE(pValue)).ToCFXWideString(); -+ cMsg = CJS_Value(pRuntime, pValue).ToCFXWideString(); - } - - pRuntime->BeginBlock(); -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/global.cpp qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/global.cpp ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/global.cpp 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/global.cpp 2017-03-06 13:04:01.785297546 +0100 -@@ -17,63 +17,6 @@ - #include "fpdfsdk/javascript/cjs_context.h" - #include "fpdfsdk/javascript/resource.h" - --// Helper class for compile-time calculation of hash values in order to --// avoid having global object initializers. --template --struct CHash; -- --// Only needed to hash single-character strings. --template --struct CHash { -- static const unsigned value = N; --}; -- --template --struct CHash { -- static const unsigned value = (ACC * 1313LLU + N) & 0xFFFFFFFF; --}; -- --template --struct CHash { -- static const unsigned value = CHash::value, Ns...>::value; --}; -- --const unsigned int JSCONST_nStringHash = -- CHash<'s', 't', 'r', 'i', 'n', 'g'>::value; --const unsigned int JSCONST_nNumberHash = -- CHash<'n', 'u', 'm', 'b', 'e', 'r'>::value; --const unsigned int JSCONST_nBoolHash = -- CHash<'b', 'o', 'o', 'l', 'e', 'a', 'n'>::value; --const unsigned int JSCONST_nDateHash = CHash<'d', 'a', 't', 'e'>::value; --const unsigned int JSCONST_nObjectHash = -- CHash<'o', 'b', 'j', 'e', 'c', 't'>::value; --const unsigned int JSCONST_nFXobjHash = CHash<'f', 'x', 'o', 'b', 'j'>::value; --const unsigned int JSCONST_nNullHash = CHash<'n', 'u', 'l', 'l'>::value; --const unsigned int JSCONST_nUndefHash = -- CHash<'u', 'n', 'd', 'e', 'f', 'i', 'n', 'e', 'd'>::value; -- --static unsigned JS_CalcHash(const wchar_t* main) { -- return (unsigned)FX_HashCode_GetW(CFX_WideStringC(main), false); --} -- --#ifndef NDEBUG --class HashVerify { -- public: -- HashVerify(); --} g_hashVerify; -- --HashVerify::HashVerify() { -- ASSERT(JSCONST_nStringHash == JS_CalcHash(kFXJSValueNameString)); -- ASSERT(JSCONST_nNumberHash == JS_CalcHash(kFXJSValueNameNumber)); -- ASSERT(JSCONST_nBoolHash == JS_CalcHash(kFXJSValueNameBoolean)); -- ASSERT(JSCONST_nDateHash == JS_CalcHash(kFXJSValueNameDate)); -- ASSERT(JSCONST_nObjectHash == JS_CalcHash(kFXJSValueNameObject)); -- ASSERT(JSCONST_nFXobjHash == JS_CalcHash(kFXJSValueNameFxobj)); -- ASSERT(JSCONST_nNullHash == JS_CalcHash(kFXJSValueNameNull)); -- ASSERT(JSCONST_nUndefHash == JS_CalcHash(kFXJSValueNameUndefined)); --} --#endif -- - BEGIN_JS_STATIC_CONST(CJS_Global) - END_JS_STATIC_CONST() - -@@ -335,9 +278,8 @@ - CFX_WideString ws = - FXJS_ToString(isolate, FXJS_GetArrayElement(isolate, pKeyList, i)); - CFX_ByteString sKey = ws.UTF8Encode(); -- - v8::Local v = FXJS_GetObjectElement(isolate, pObj, ws); -- switch (GET_VALUE_TYPE(v)) { -+ switch (CJS_Value::GetValueType(v)) { - case CJS_Value::VT_number: { - CJS_KeyValue* pObjElement = new CJS_KeyValue; - pObjElement->nType = JS_GLOBALDATA_TYPE_NUMBER; -@@ -353,8 +295,7 @@ - array.Add(pObjElement); - } break; - case CJS_Value::VT_string: { -- CFX_ByteString sValue = -- CJS_Value(pRuntime, v, CJS_Value::VT_string).ToCFXByteString(); -+ CFX_ByteString sValue = CJS_Value(pRuntime, v).ToCFXByteString(); - CJS_KeyValue* pObjElement = new CJS_KeyValue; - pObjElement->nType = JS_GLOBALDATA_TYPE_STRING; - pObjElement->sKey = sKey; -@@ -500,26 +441,3 @@ - m_mapGlobal[propname] = pNewData; - return TRUE; - } -- --CJS_Value::Type GET_VALUE_TYPE(v8::Local p) { -- const unsigned int nHash = JS_CalcHash(FXJS_GetTypeof(p)); -- -- if (nHash == JSCONST_nUndefHash) -- return CJS_Value::VT_undefined; -- if (nHash == JSCONST_nNullHash) -- return CJS_Value::VT_null; -- if (nHash == JSCONST_nStringHash) -- return CJS_Value::VT_string; -- if (nHash == JSCONST_nNumberHash) -- return CJS_Value::VT_number; -- if (nHash == JSCONST_nBoolHash) -- return CJS_Value::VT_boolean; -- if (nHash == JSCONST_nDateHash) -- return CJS_Value::VT_date; -- if (nHash == JSCONST_nObjectHash) -- return CJS_Value::VT_object; -- if (nHash == JSCONST_nFXobjHash) -- return CJS_Value::VT_fxobject; -- -- return CJS_Value::VT_unknown; --} -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/JS_Define.h qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/JS_Define.h ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/JS_Define.h 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/JS_Define.h 2017-03-06 13:04:01.783297575 +0100 -@@ -111,7 +111,7 @@ - CJS_Object* pJSObj = (CJS_Object*)FXJS_GetPrivate(isolate, info.Holder()); - C* pObj = reinterpret_cast(pJSObj->GetEmbedObject()); - CFX_WideString sError; -- CJS_PropValue propValue(CJS_Value(pRuntime, value, CJS_Value::VT_unknown)); -+ CJS_PropValue propValue(CJS_Value(pRuntime, value)); - propValue.StartSetting(); - if (!(pObj->*M)(pContext, propValue, sError)) { - FXJS_Error(isolate, JSFormatErrorString(class_name_string, prop_name_string, -@@ -149,7 +149,7 @@ - IJS_Context* pContext = pRuntime->GetCurrentContext(); - std::vector parameters; - for (unsigned int i = 0; i < (unsigned int)info.Length(); i++) { -- parameters.push_back(CJS_Value(pRuntime, info[i], CJS_Value::VT_unknown)); -+ parameters.push_back(CJS_Value(pRuntime, info[i])); - } - CJS_Value valueRes(pRuntime); - CJS_Object* pJSObj = (CJS_Object*)FXJS_GetPrivate(isolate, info.Holder()); -@@ -404,7 +404,7 @@ - CFX_WideString propname = CFX_WideString::FromUTF8( - CFX_ByteStringC(*utf8_value, utf8_value.length())); - CFX_WideString sError; -- CJS_PropValue PropValue(CJS_Value(pRuntime, value, CJS_Value::VT_unknown)); -+ CJS_PropValue PropValue(CJS_Value(pRuntime, value)); - PropValue.StartSetting(); - if (!pObj->DoProperty(pContext, propname.c_str(), PropValue, sError)) { - FXJS_Error(isolate, JSFormatErrorString(class_name, "PutProperty", sError)); -@@ -447,7 +447,7 @@ - IJS_Context* pContext = pRuntime->GetCurrentContext(); - std::vector parameters; - for (unsigned int i = 0; i < (unsigned int)info.Length(); i++) { -- parameters.push_back(CJS_Value(pRuntime, info[i], CJS_Value::VT_unknown)); -+ parameters.push_back(CJS_Value(pRuntime, info[i])); - } - CJS_Value valueRes(pRuntime); - CFX_WideString sError; -@@ -485,6 +485,4 @@ - } \ - } - --CJS_Value::Type GET_VALUE_TYPE(v8::Local p); -- - #endif // FPDFSDK_JAVASCRIPT_JS_DEFINE_H_ -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/JS_Value.cpp qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/JS_Value.cpp ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/JS_Value.cpp 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/JS_Value.cpp 2017-03-06 13:10:30.896809956 +0100 -@@ -22,11 +22,10 @@ - return *(double*)g_nan; - } - --CJS_Value::CJS_Value(CJS_Runtime* pRuntime) -- : m_eType(VT_unknown), m_pJSRuntime(pRuntime) {} -+CJS_Value::CJS_Value(CJS_Runtime* pRuntime) : m_pJSRuntime(pRuntime) {} - --CJS_Value::CJS_Value(CJS_Runtime* pRuntime, v8::Local pValue, Type t) -- : m_eType(t), m_pValue(pValue), m_pJSRuntime(pRuntime) {} -+CJS_Value::CJS_Value(CJS_Runtime* pRuntime, v8::Local pValue) -+ : m_pValue(pValue), m_pJSRuntime(pRuntime) {} - - CJS_Value::CJS_Value(CJS_Runtime* pRuntime, const int& iValue) - : m_pJSRuntime(pRuntime) { -@@ -48,23 +47,11 @@ - operator=(dValue); - } - --CJS_Value::CJS_Value(CJS_Runtime* pRuntime, v8::Local pJsObj) -- : m_pJSRuntime(pRuntime) { -- operator=(pJsObj); --} -- - CJS_Value::CJS_Value(CJS_Runtime* pRuntime, CJS_Object* pJsObj) - : m_pJSRuntime(pRuntime) { - operator=(pJsObj); - } - --CJS_Value::CJS_Value(CJS_Runtime* pRuntime, CJS_Document* pJsDoc) -- : m_pJSRuntime(pRuntime) { -- m_eType = VT_object; -- if (pJsDoc) -- m_pValue = pJsDoc->ToV8Object(); --} -- - CJS_Value::CJS_Value(CJS_Runtime* pRuntime, const FX_WCHAR* pWstr) - : m_pJSRuntime(pRuntime) { - operator=(pWstr); -@@ -84,19 +71,17 @@ - - CJS_Value::CJS_Value(const CJS_Value& other) = default; - --void CJS_Value::Attach(v8::Local pValue, Type t) { -+void CJS_Value::Attach(v8::Local pValue) { - m_pValue = pValue; -- m_eType = t; - } - - void CJS_Value::Attach(CJS_Value* pValue) { - if (pValue) -- Attach(pValue->ToV8Value(), pValue->GetType()); -+ Attach(pValue->ToV8Value()); - } - - void CJS_Value::Detach() { - m_pValue = v8::Local(); -- m_eType = VT_unknown; - } - - int CJS_Value::ToInt() const { -@@ -146,7 +131,7 @@ - - void CJS_Value::MaybeCoerceToNumber() { - bool bAllowNaN = false; -- if (m_eType == VT_string) { -+ if (GetType() == VT_string) { - CFX_ByteString bstr = ToCFXByteString(); - if (bstr.GetLength() == 0) - return; -@@ -162,32 +147,26 @@ - if (std::isnan(num->Value()) && !bAllowNaN) - return; - m_pValue = num; -- m_eType = VT_number; - } - - void CJS_Value::operator=(int iValue) { - m_pValue = FXJS_NewNumber(m_pJSRuntime->GetIsolate(), iValue); -- m_eType = VT_number; - } - - void CJS_Value::operator=(bool bValue) { - m_pValue = FXJS_NewBoolean(m_pJSRuntime->GetIsolate(), bValue); -- m_eType = VT_boolean; - } - - void CJS_Value::operator=(double dValue) { - m_pValue = FXJS_NewNumber(m_pJSRuntime->GetIsolate(), dValue); -- m_eType = VT_number; - } - - void CJS_Value::operator=(float fValue) { - m_pValue = FXJS_NewNumber(m_pJSRuntime->GetIsolate(), fValue); -- m_eType = VT_number; - } - - void CJS_Value::operator=(v8::Local pObj) { - m_pValue = FXJS_NewObject(m_pJSRuntime->GetIsolate(), pObj); -- m_eType = VT_fxobject; - } - - void CJS_Value::operator=(CJS_Object* pObj) { -@@ -195,21 +174,12 @@ - operator=(pObj->ToV8Object()); - } - --void CJS_Value::operator=(CJS_Document* pJsDoc) { -- m_eType = VT_object; -- if (pJsDoc) { -- m_pValue = pJsDoc->ToV8Object(); -- } --} -- - void CJS_Value::operator=(const FX_WCHAR* pWstr) { - m_pValue = FXJS_NewString(m_pJSRuntime->GetIsolate(), (wchar_t*)pWstr); -- m_eType = VT_string; - } - - void CJS_Value::SetNull() { - m_pValue = FXJS_NewNull(); -- m_eType = VT_null; - } - - void CJS_Value::operator=(const FX_CHAR* pStr) { -@@ -219,36 +189,34 @@ - void CJS_Value::operator=(CJS_Array& array) { - m_pValue = - FXJS_NewObject2(m_pJSRuntime->GetIsolate(), (v8::Local)array); -- m_eType = VT_object; - } - - void CJS_Value::operator=(CJS_Date& date) { - m_pValue = FXJS_NewDate(m_pJSRuntime->GetIsolate(), (double)date); -- m_eType = VT_date; - } - - void CJS_Value::operator=(CJS_Value value) { - m_pValue = value.ToV8Value(); -- m_eType = value.m_eType; - m_pJSRuntime = value.m_pJSRuntime; - } - --CJS_Value::Type CJS_Value::GetType() const { -- if (m_pValue.IsEmpty()) -+// static -+CJS_Value::Type CJS_Value::GetValueType(v8::Local value) { -+ if (value.IsEmpty()) - return VT_unknown; -- if (m_pValue->IsString()) -+ if (value->IsString()) - return VT_string; -- if (m_pValue->IsNumber()) -+ if (value->IsNumber()) - return VT_number; -- if (m_pValue->IsBoolean()) -+ if (value->IsBoolean()) - return VT_boolean; -- if (m_pValue->IsDate()) -+ if (value->IsDate()) - return VT_date; -- if (m_pValue->IsObject()) -+ if (value->IsObject()) - return VT_object; -- if (m_pValue->IsNull()) -+ if (value->IsNull()) - return VT_null; -- if (m_pValue->IsUndefined()) -+ if (value->IsUndefined()) - return VT_undefined; - return VT_unknown; - } -@@ -427,7 +395,7 @@ - return; - v8::Local p = - FXJS_GetArrayElement(m_pJSRuntime->GetIsolate(), m_pArray, index); -- value.Attach(p, CJS_Value::VT_object); -+ value.Attach(p); - } - - void CJS_Array::SetElement(unsigned index, CJS_Value value) { -@@ -899,7 +867,7 @@ - v8::Local v8Value = - FXJS_GetObjectElement(pRuntime->GetIsolate(), pObj, property); - if (!v8Value->IsUndefined()) -- result[i] = CJS_Value(pRuntime, v8Value, CJS_Value::VT_unknown); -+ result[i] = CJS_Value(pRuntime, v8Value); - } - va_end(ap); - return result; -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/JS_Value.h qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/JS_Value.h ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/JS_Value.h 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/javascript/JS_Value.h 2017-03-06 13:04:01.784297561 +0100 -@@ -27,20 +27,17 @@ - VT_boolean, - VT_date, - VT_object, -- VT_fxobject, - VT_null, - VT_undefined - }; - - CJS_Value(CJS_Runtime* pRuntime); -- CJS_Value(CJS_Runtime* pRuntime, v8::Local pValue, Type t); -+ CJS_Value(CJS_Runtime* pRuntime, v8::Local pValue); - CJS_Value(CJS_Runtime* pRuntime, const int& iValue); - CJS_Value(CJS_Runtime* pRuntime, const double& dValue); - CJS_Value(CJS_Runtime* pRuntime, const float& fValue); - CJS_Value(CJS_Runtime* pRuntime, const bool& bValue); -- CJS_Value(CJS_Runtime* pRuntime, v8::Local); -- CJS_Value(CJS_Runtime* pRuntime, CJS_Object*); -- CJS_Value(CJS_Runtime* pRuntime, CJS_Document*); -+ CJS_Value(CJS_Runtime* pRuntime, CJS_Object* pObj); - CJS_Value(CJS_Runtime* pRuntime, const FX_CHAR* pStr); - CJS_Value(CJS_Runtime* pRuntime, const FX_WCHAR* pWstr); - CJS_Value(CJS_Runtime* pRuntime, CJS_Array& array); -@@ -49,11 +46,12 @@ - CJS_Value(const CJS_Value& other); - - void SetNull(); -- void Attach(v8::Local pValue, Type t); -+ void Attach(v8::Local pValue); - void Attach(CJS_Value* pValue); - void Detach(); - -- Type GetType() const; -+ static Type GetValueType(v8::Local value); -+ Type GetType() const { return GetValueType(m_pValue); } - int ToInt() const; - bool ToBool() const; - double ToDouble() const; -@@ -66,8 +64,7 @@ - v8::Local ToV8Value() const; - - // Replace the current |m_pValue| with a v8::Number if possible -- // to make one from the current |m_pValue|, updating |m_eType| -- // as appropriate to indicate the result. -+ // to make one from the current |m_pValue|. - void MaybeCoerceToNumber(); - - void operator=(int iValue); -@@ -75,7 +72,6 @@ - void operator=(double val); - void operator=(float val); - void operator=(CJS_Object* val); -- void operator=(CJS_Document* val); - void operator=(v8::Local val); - void operator=(CJS_Array& val); - void operator=(CJS_Date& val); -@@ -91,7 +87,6 @@ - CJS_Runtime* GetJSRuntime() const { return m_pJSRuntime; } - - protected: -- Type m_eType; - v8::Local m_pValue; - CJS_Runtime* m_pJSRuntime; - }; -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/jsapi/fxjs_v8.cpp qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/jsapi/fxjs_v8.cpp ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/jsapi/fxjs_v8.cpp 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/jsapi/fxjs_v8.cpp 2017-03-06 13:06:10.884476877 +0100 -@@ -10,15 +10,6 @@ - - #include "core/fxcrt/include/fx_basic.h" - --const wchar_t kFXJSValueNameString[] = L"string"; --const wchar_t kFXJSValueNameNumber[] = L"number"; --const wchar_t kFXJSValueNameBoolean[] = L"boolean"; --const wchar_t kFXJSValueNameDate[] = L"date"; --const wchar_t kFXJSValueNameObject[] = L"object"; --const wchar_t kFXJSValueNameFxobj[] = L"fxobj"; --const wchar_t kFXJSValueNameNull[] = L"null"; --const wchar_t kFXJSValueNameUndefined[] = L"undefined"; -- - // Keep this consistent with the values defined in gin/public/context_holder.h - // (without actually requiring a dependency on gin itself for the standalone - // embedders of PDFIum). The value we want to use is: -@@ -540,26 +531,6 @@ - .ToLocalChecked()); - } - --const wchar_t* FXJS_GetTypeof(v8::Local pObj) { -- if (pObj.IsEmpty()) -- return nullptr; -- if (pObj->IsString()) -- return kFXJSValueNameString; -- if (pObj->IsNumber()) -- return kFXJSValueNameNumber; -- if (pObj->IsBoolean()) -- return kFXJSValueNameBoolean; -- if (pObj->IsDate()) -- return kFXJSValueNameDate; -- if (pObj->IsObject()) -- return kFXJSValueNameObject; -- if (pObj->IsNull()) -- return kFXJSValueNameNull; -- if (pObj->IsUndefined()) -- return kFXJSValueNameUndefined; -- return nullptr; --} -- - void FXJS_SetPrivate(v8::Isolate* pIsolate, - v8::Local pObj, - void* p) { -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/jsapi/include/fxjs_v8.h qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/jsapi/include/fxjs_v8.h ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/jsapi/include/fxjs_v8.h 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-pdfium-gcc7/src/3rdparty/chromium/third_party/pdfium/fpdfsdk/jsapi/include/fxjs_v8.h 2017-03-06 13:06:40.283062272 +0100 -@@ -118,15 +118,6 @@ - FXJS_PerIsolateData(); - }; - --extern const wchar_t kFXJSValueNameString[]; --extern const wchar_t kFXJSValueNameNumber[]; --extern const wchar_t kFXJSValueNameBoolean[]; --extern const wchar_t kFXJSValueNameDate[]; --extern const wchar_t kFXJSValueNameObject[]; --extern const wchar_t kFXJSValueNameFxobj[]; --extern const wchar_t kFXJSValueNameNull[]; --extern const wchar_t kFXJSValueNameUndefined[]; -- - class FXJS_ArrayBufferAllocator : public v8::ArrayBuffer::Allocator { - void* Allocate(size_t length) override; - void* AllocateUninitialized(size_t length) override; -@@ -209,7 +200,6 @@ - bool bStatic = false); - v8::Local FXJS_GetThisObj(v8::Isolate* pIsolate); - int FXJS_GetObjDefnID(v8::Local pObj); --const wchar_t* FXJS_GetTypeof(v8::Local pObj); - - void FXJS_SetPrivate(v8::Isolate* pIsolate, - v8::Local pObj, diff --git a/qtwebengine-opensource-src-5.8.0-qt57.patch b/qtwebengine-opensource-src-5.8.0-qt57.patch deleted file mode 100644 index 480ae11..0000000 --- a/qtwebengine-opensource-src-5.8.0-qt57.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff -up qtwebengine-opensource-src-5.8.0/src/core/proxy_config_service_qt.cpp.qt58 qtwebengine-opensource-src-5.8.0/src/core/proxy_config_service_qt.cpp ---- qtwebengine-opensource-src-5.8.0/src/core/proxy_config_service_qt.cpp.qt58 2017-01-03 04:35:11.000000000 -0600 -+++ qtwebengine-opensource-src-5.8.0/src/core/proxy_config_service_qt.cpp 2017-03-24 14:43:55.120363292 -0500 -@@ -109,7 +109,7 @@ net::ProxyConfigService::ConfigAvailabil - } - m_qtApplicationProxy = qtProxy; - m_qtProxyConfig = net::ProxyConfig(); --#if QT_VERSION >= QT_VERSION_CHECK(5, 7, 0) -+#if QT_VERSION >= QT_VERSION_CHECK(5, 8, 0) - if (qtProxy.type() == QNetworkProxy::NoProxy - && QNetworkProxyFactory::usesSystemConfiguration()) { - *config = systemConfig; diff --git a/qtwebengine-opensource-src-5.8.0-system-icu-utf.patch b/qtwebengine-opensource-src-5.8.0-system-icu-utf.patch deleted file mode 100644 index dff88b5..0000000 --- a/qtwebengine-opensource-src-5.8.0-system-icu-utf.patch +++ /dev/null @@ -1,362 +0,0 @@ -diff -ur qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/base.gypi qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/base.gypi ---- qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/base.gypi 2017-03-05 16:48:14.206027229 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/base.gypi 2017-03-05 16:50:49.266714740 +0100 -@@ -674,8 +674,6 @@ - 'third_party/dmg_fp/dmg_fp.h', - 'third_party/dmg_fp/dtoa_wrapper.cc', - 'third_party/dmg_fp/g_fmt.cc', -- 'third_party/icu/icu_utf.cc', -- 'third_party/icu/icu_utf.h', - 'third_party/superfasthash/superfasthash.c', - 'third_party/xdg_mime/xdgmime.h', - 'threading/non_thread_safe.h', -diff -ur qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/BUILD.gn qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/BUILD.gn ---- qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/BUILD.gn 2017-03-05 16:48:14.207027214 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/BUILD.gn 2017-03-05 16:50:49.267714725 +0100 -@@ -801,8 +801,6 @@ - "third_party/dmg_fp/dmg_fp.h", - "third_party/dmg_fp/dtoa_wrapper.cc", - "third_party/dmg_fp/g_fmt.cc", -- "third_party/icu/icu_utf.cc", -- "third_party/icu/icu_utf.h", - "third_party/superfasthash/superfasthash.c", - "threading/non_thread_safe.h", - "threading/non_thread_safe_impl.cc", -diff -ur qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/files/file_path.cc qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/files/file_path.cc ---- qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/files/file_path.cc 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/files/file_path.cc 2017-03-05 16:50:49.267714725 +0100 -@@ -18,7 +18,7 @@ - - #if defined(OS_MACOSX) - #include "base/mac/scoped_cftyperef.h" --#include "base/third_party/icu/icu_utf.h" -+#include - #endif - - #if defined(OS_WIN) -@@ -1150,9 +1150,9 @@ - int* index) { - int codepoint = 0; - while (*index < length && codepoint == 0) { -- // CBU8_NEXT returns a value < 0 in error cases. For purposes of string -+ // U8_NEXT returns a value < 0 in error cases. For purposes of string - // comparison, we just use that value and flag it with DCHECK. -- CBU8_NEXT(string, *index, length, codepoint); -+ U8_NEXT(string, *index, length, codepoint); - DCHECK_GT(codepoint, 0); - if (codepoint > 0) { - // Check if there is a subtable for this upper byte. -diff -ur qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/json/json_parser.cc qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/json/json_parser.cc ---- qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/json/json_parser.cc 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/json/json_parser.cc 2017-03-05 16:50:49.268714710 +0100 -@@ -16,7 +16,7 @@ - #include "base/strings/stringprintf.h" - #include "base/strings/utf_string_conversion_utils.h" - #include "base/strings/utf_string_conversions.h" --#include "base/third_party/icu/icu_utf.h" -+#include - #include "base/values.h" - - namespace base { -@@ -631,8 +631,8 @@ - int32_t next_char = 0; - - while (CanConsume(1)) { -- pos_ = start_pos_ + index_; // CBU8_NEXT is postcrement. -- CBU8_NEXT(start_pos_, index_, length, next_char); -+ pos_ = start_pos_ + index_; // U8_NEXT is postcrement. -+ U8_NEXT(start_pos_, index_, length, next_char); - if (next_char < 0 || !IsValidCharacter(next_char)) { - ReportError(JSONReader::JSON_UNSUPPORTED_ENCODING, 1); - return false; -@@ -725,7 +725,7 @@ - return false; - } - } else if (next_char == '"') { -- --index_; // Rewind by one because of CBU8_NEXT. -+ --index_; // Rewind by one because of U8_NEXT. - out->Swap(&string); - return true; - } else { -@@ -765,10 +765,10 @@ - - // If this is a high surrogate, consume the next code unit to get the - // low surrogate. -- if (CBU16_IS_SURROGATE(code_unit16_high)) { -+ if (U16_IS_SURROGATE(code_unit16_high)) { - // Make sure this is the high surrogate. If not, it's an encoding - // error. -- if (!CBU16_IS_SURROGATE_LEAD(code_unit16_high)) -+ if (!U16_IS_SURROGATE_LEAD(code_unit16_high)) - return false; - - // Make sure that the token has more characters to consume the -@@ -785,24 +785,24 @@ - - NextNChars(3); - -- if (!CBU16_IS_TRAIL(code_unit16_low)) { -+ if (!U16_IS_TRAIL(code_unit16_low)) { - return false; - } - - uint32_t code_point = -- CBU16_GET_SUPPLEMENTARY(code_unit16_high, code_unit16_low); -+ U16_GET_SUPPLEMENTARY(code_unit16_high, code_unit16_low); - if (!IsValidCharacter(code_point)) - return false; - - offset = 0; -- CBU8_APPEND_UNSAFE(code_unit8, offset, code_point); -+ U8_APPEND_UNSAFE(code_unit8, offset, code_point); - } else { - // Not a surrogate. -- DCHECK(CBU16_IS_SINGLE(code_unit16_high)); -+ DCHECK(U16_IS_SINGLE(code_unit16_high)); - if (!IsValidCharacter(code_unit16_high)) - return false; - -- CBU8_APPEND_UNSAFE(code_unit8, offset, code_unit16_high); -+ U8_APPEND_UNSAFE(code_unit8, offset, code_unit16_high); - } - - dest_string->append(code_unit8); -@@ -819,9 +819,9 @@ - } else { - char utf8_units[4] = { 0 }; - int offset = 0; -- CBU8_APPEND_UNSAFE(utf8_units, offset, point); -+ U8_APPEND_UNSAFE(utf8_units, offset, point); - dest->Convert(); -- // CBU8_APPEND_UNSAFE can overwrite up to 4 bytes, so utf8_units may not be -+ // U8_APPEND_UNSAFE can overwrite up to 4 bytes, so utf8_units may not be - // zero terminated at this point. |offset| contains the correct length. - dest->AppendString(std::string(utf8_units, offset)); - } -diff -ur qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/json/string_escape.cc qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/json/string_escape.cc ---- qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/json/string_escape.cc 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/json/string_escape.cc 2017-03-05 16:50:49.268714710 +0100 -@@ -14,7 +14,7 @@ - #include "base/strings/stringprintf.h" - #include "base/strings/utf_string_conversion_utils.h" - #include "base/strings/utf_string_conversions.h" --#include "base/third_party/icu/icu_utf.h" -+#include - - namespace base { - -diff -ur qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/strings/pattern.cc qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/strings/pattern.cc ---- qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/strings/pattern.cc 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/strings/pattern.cc 2017-03-05 16:50:49.404712681 +0100 -@@ -4,13 +4,13 @@ - - #include "base/strings/pattern.h" - --#include "base/third_party/icu/icu_utf.h" -+#include - - namespace base { - - namespace { - --static bool IsWildcard(base_icu::UChar32 character) { -+static bool IsWildcard(UChar32 character) { - return character == '*' || character == '?'; - } - -@@ -37,9 +37,9 @@ - // Check if the chars match, if so, increment the ptrs. - const CHAR* pattern_next = *pattern; - const CHAR* string_next = *string; -- base_icu::UChar32 pattern_char = next(&pattern_next, pattern_end); -+ UChar32 pattern_char = next(&pattern_next, pattern_end); - if (pattern_char == next(&string_next, string_end) && -- pattern_char != CBU_SENTINEL) { -+ pattern_char != U_SENTINEL) { - *pattern = pattern_next; - *string = string_next; - } else { -@@ -133,20 +133,20 @@ - } - - struct NextCharUTF8 { -- base_icu::UChar32 operator()(const char** p, const char* end) { -- base_icu::UChar32 c; -+ UChar32 operator()(const char** p, const char* end) { -+ UChar32 c; - int offset = 0; -- CBU8_NEXT(*p, offset, end - *p, c); -+ U8_NEXT(*p, offset, end - *p, c); - *p += offset; - return c; - } - }; - - struct NextCharUTF16 { -- base_icu::UChar32 operator()(const char16** p, const char16* end) { -- base_icu::UChar32 c; -+ UChar32 operator()(const char16** p, const char16* end) { -+ UChar32 c; - int offset = 0; -- CBU16_NEXT(*p, offset, end - *p, c); -+ U16_NEXT(*p, offset, end - *p, c); - *p += offset; - return c; - } -diff -ur qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/strings/string_split.cc qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/strings/string_split.cc ---- qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/strings/string_split.cc 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/strings/string_split.cc 2017-03-05 16:50:49.404712681 +0100 -@@ -8,7 +8,7 @@ - - #include "base/logging.h" - #include "base/strings/string_util.h" --#include "base/third_party/icu/icu_utf.h" -+#include - - namespace base { - -diff -ur qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/strings/string_util.cc qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/strings/string_util.cc ---- qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/strings/string_util.cc 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/strings/string_util.cc 2017-03-05 16:50:49.404712681 +0100 -@@ -25,7 +25,7 @@ - #include "base/memory/singleton.h" - #include "base/strings/utf_string_conversion_utils.h" - #include "base/strings/utf_string_conversions.h" --#include "base/third_party/icu/icu_utf.h" -+#include - #include "build/build_config.h" - - namespace base { -@@ -357,19 +357,19 @@ - } - DCHECK_LE(byte_size, - static_cast(std::numeric_limits::max())); -- // Note: This cast is necessary because CBU8_NEXT uses int32_ts. -+ // Note: This cast is necessary because U8_NEXT uses int32_ts. - int32_t truncation_length = static_cast(byte_size); - int32_t char_index = truncation_length - 1; - const char* data = input.data(); - -- // Using CBU8, we will move backwards from the truncation point -+ // Using U8, we will move backwards from the truncation point - // to the beginning of the string looking for a valid UTF8 - // character. Once a full UTF8 character is found, we will - // truncate the string to the end of that character. - while (char_index >= 0) { - int32_t prev = char_index; -- base_icu::UChar32 code_point = 0; -- CBU8_NEXT(data, char_index, truncation_length, code_point); -+ UChar32 code_point = 0; -+ U8_NEXT(data, char_index, truncation_length, code_point); - if (!IsValidCharacter(code_point) || - !IsValidCodepoint(code_point)) { - char_index = prev - 1; -@@ -522,7 +522,7 @@ - - while (char_index < src_len) { - int32_t code_point; -- CBU8_NEXT(src, char_index, src_len, code_point); -+ U8_NEXT(src, char_index, src_len, code_point); - if (!IsValidCharacter(code_point)) - return false; - } -diff -ur qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/strings/utf_string_conversion_utils.cc qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/strings/utf_string_conversion_utils.cc ---- qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/strings/utf_string_conversion_utils.cc 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/base/strings/utf_string_conversion_utils.cc 2017-03-05 16:50:49.404712681 +0100 -@@ -4,7 +4,7 @@ - - #include "base/strings/utf_string_conversion_utils.h" - --#include "base/third_party/icu/icu_utf.h" -+#include - - namespace base { - -@@ -18,7 +18,7 @@ - // use a signed type for code_point. But this function returns false - // on error anyway, so code_point_out is unsigned. - int32_t code_point; -- CBU8_NEXT(src, *char_index, src_len, code_point); -+ U8_NEXT(src, *char_index, src_len, code_point); - *code_point_out = static_cast(code_point); - - // The ICU macro above moves to the next char, we want to point to the last -@@ -33,16 +33,16 @@ - int32_t src_len, - int32_t* char_index, - uint32_t* code_point) { -- if (CBU16_IS_SURROGATE(src[*char_index])) { -- if (!CBU16_IS_SURROGATE_LEAD(src[*char_index]) || -+ if (U16_IS_SURROGATE(src[*char_index])) { -+ if (!U16_IS_SURROGATE_LEAD(src[*char_index]) || - *char_index + 1 >= src_len || -- !CBU16_IS_TRAIL(src[*char_index + 1])) { -+ !U16_IS_TRAIL(src[*char_index + 1])) { - // Invalid surrogate pair. - return false; - } - - // Valid surrogate pair. -- *code_point = CBU16_GET_SUPPLEMENTARY(src[*char_index], -+ *code_point = U16_GET_SUPPLEMENTARY(src[*char_index], - src[*char_index + 1]); - (*char_index)++; - } else { -@@ -76,30 +76,30 @@ - } - - -- // CBU8_APPEND_UNSAFE can append up to 4 bytes. -+ // U8_APPEND_UNSAFE can append up to 4 bytes. - size_t char_offset = output->length(); - size_t original_char_offset = char_offset; -- output->resize(char_offset + CBU8_MAX_LENGTH); -+ output->resize(char_offset + U8_MAX_LENGTH); - -- CBU8_APPEND_UNSAFE(&(*output)[0], char_offset, code_point); -+ U8_APPEND_UNSAFE(&(*output)[0], char_offset, code_point); - -- // CBU8_APPEND_UNSAFE will advance our pointer past the inserted character, so -+ // U8_APPEND_UNSAFE will advance our pointer past the inserted character, so - // it will represent the new length of the string. - output->resize(char_offset); - return char_offset - original_char_offset; - } - - size_t WriteUnicodeCharacter(uint32_t code_point, string16* output) { -- if (CBU16_LENGTH(code_point) == 1) { -+ if (U16_LENGTH(code_point) == 1) { - // Thie code point is in the Basic Multilingual Plane (BMP). - output->push_back(static_cast(code_point)); - return 1; - } - // Non-BMP characters use a double-character encoding. - size_t char_offset = output->length(); -- output->resize(char_offset + CBU16_MAX_LENGTH); -- CBU16_APPEND_UNSAFE(&(*output)[0], char_offset, code_point); -- return CBU16_MAX_LENGTH; -+ output->resize(char_offset + U16_MAX_LENGTH); -+ U16_APPEND_UNSAFE(&(*output)[0], char_offset, code_point); -+ return U16_MAX_LENGTH; - } - - // Generalized Unicode converter ----------------------------------------------- -diff -ur qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/ui/gfx/utf16_indexing.cc qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/ui/gfx/utf16_indexing.cc ---- qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/ui/gfx/utf16_indexing.cc 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-icu-utf/src/3rdparty/chromium/ui/gfx/utf16_indexing.cc 2017-03-05 16:50:49.405712666 +0100 -@@ -5,13 +5,13 @@ - #include "ui/gfx/utf16_indexing.h" - - #include "base/logging.h" --#include "base/third_party/icu/icu_utf.h" -+#include - - namespace gfx { - - bool IsValidCodePointIndex(const base::string16& s, size_t index) { - return index == 0 || index == s.length() || -- !(CBU16_IS_TRAIL(s[index]) && CBU16_IS_LEAD(s[index - 1])); -+ !(U16_IS_TRAIL(s[index]) && U16_IS_LEAD(s[index - 1])); - } - - ptrdiff_t UTF16IndexToOffset(const base::string16& s, size_t base, size_t pos) { diff --git a/qtwebengine-opensource-src-5.8.0-system-nspr-prtime.patch b/qtwebengine-opensource-src-5.8.0-system-nspr-prtime.patch deleted file mode 100644 index 4f17325..0000000 --- a/qtwebengine-opensource-src-5.8.0-system-nspr-prtime.patch +++ /dev/null @@ -1,48 +0,0 @@ -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/base/base.gypi qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/base.gypi ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/base/base.gypi 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/base.gypi 2017-03-05 16:48:14.206027229 +0100 -@@ -676,8 +676,6 @@ - 'third_party/dmg_fp/g_fmt.cc', - 'third_party/icu/icu_utf.cc', - 'third_party/icu/icu_utf.h', -- 'third_party/nspr/prtime.cc', -- 'third_party/nspr/prtime.h', - 'third_party/superfasthash/superfasthash.c', - 'third_party/xdg_mime/xdgmime.h', - 'threading/non_thread_safe.h', -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/base/BUILD.gn qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/BUILD.gn ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/base/BUILD.gn 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/BUILD.gn 2017-03-05 16:48:14.207027214 +0100 -@@ -803,8 +803,6 @@ - "third_party/dmg_fp/g_fmt.cc", - "third_party/icu/icu_utf.cc", - "third_party/icu/icu_utf.h", -- "third_party/nspr/prtime.cc", -- "third_party/nspr/prtime.h", - "third_party/superfasthash/superfasthash.c", - "threading/non_thread_safe.h", - "threading/non_thread_safe_impl.cc", -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/base/time/pr_time_unittest.cc qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/time/pr_time_unittest.cc ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/base/time/pr_time_unittest.cc 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/time/pr_time_unittest.cc 2017-03-05 16:48:14.208027199 +0100 -@@ -7,7 +7,7 @@ - - #include "base/compiler_specific.h" - #include "base/macros.h" --#include "base/third_party/nspr/prtime.h" -+#include - #include "base/time/time.h" - #include "build/build_config.h" - #include "testing/gtest/include/gtest/gtest.h" -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/base/time/time.cc qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/time/time.cc ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/base/time/time.cc 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-system-nspr-prtime/src/3rdparty/chromium/base/time/time.cc 2017-03-05 16:48:14.298025856 +0100 -@@ -14,7 +14,7 @@ - #include "base/logging.h" - #include "base/macros.h" - #include "base/strings/stringprintf.h" --#include "base/third_party/nspr/prtime.h" -+#include - #include "build/build_config.h" - - namespace base { diff --git a/qtwebengine-opensource-src-5.8.0-v8-gcc7.patch b/qtwebengine-opensource-src-5.8.0-v8-gcc7.patch deleted file mode 100644 index 8a87503..0000000 --- a/qtwebengine-opensource-src-5.8.0-v8-gcc7.patch +++ /dev/null @@ -1,71 +0,0 @@ -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/src/objects-body-descriptors.h qtwebengine-opensource-src-5.8.0-gcc7/src/3rdparty/chromium/v8/src/objects-body-descriptors.h ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/src/objects-body-descriptors.h 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-gcc7/src/3rdparty/chromium/v8/src/objects-body-descriptors.h 2017-03-06 02:05:57.848394582 +0100 -@@ -99,7 +99,7 @@ - - template - static inline void IterateBody(HeapObject* obj, int object_size) { -- IterateBody(obj); -+ IterateBody(obj); - } - }; - -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/src/objects.h qtwebengine-opensource-src-5.8.0-gcc7/src/3rdparty/chromium/v8/src/objects.h ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/src/objects.h 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-gcc7/src/3rdparty/chromium/v8/src/objects.h 2017-03-06 02:05:57.990392454 +0100 -@@ -3193,22 +3193,10 @@ - public: - typedef Shape ShapeT; - -- // Wrapper methods -- inline uint32_t Hash(Key key) { -- if (Shape::UsesSeed) { -- return Shape::SeededHash(key, GetHeap()->HashSeed()); -- } else { -- return Shape::Hash(key); -- } -- } -- -- inline uint32_t HashForObject(Key key, Object* object) { -- if (Shape::UsesSeed) { -- return Shape::SeededHashForObject(key, GetHeap()->HashSeed(), object); -- } else { -- return Shape::HashForObject(key, object); -- } -- } -+ // Wrapper methods. Defined in src/objects-inl.h -+ // to break a cycle with src/heap/heap.h. -+ inline uint32_t Hash(Key key); -+ inline uint32_t HashForObject(Key key, Object* object); - - // Returns a new HashTable object. - MUST_USE_RESULT static Handle New( -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/src/objects-inl.h qtwebengine-opensource-src-5.8.0-gcc7/src/3rdparty/chromium/v8/src/objects-inl.h ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/v8/src/objects-inl.h 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-gcc7/src/3rdparty/chromium/v8/src/objects-inl.h 2017-03-06 02:05:57.992392424 +0100 -@@ -38,6 +38,25 @@ - namespace v8 { - namespace internal { - -+template -+uint32_t HashTable::Hash(Key key) { -+ if (Shape::UsesSeed) { -+ return Shape::SeededHash(key, GetHeap()->HashSeed()); -+ } else { -+ return Shape::Hash(key); -+ } -+} -+ -+template -+uint32_t HashTable::HashForObject(Key key, -+ Object* object) { -+ if (Shape::UsesSeed) { -+ return Shape::SeededHashForObject(key, GetHeap()->HashSeed(), object); -+ } else { -+ return Shape::HashForObject(key, object); -+ } -+} -+ - PropertyDetails::PropertyDetails(Smi* smi) { - value_ = smi->value(); - } diff --git a/qtwebengine-opensource-src-5.8.0-webrtc-neon-detect.patch b/qtwebengine-opensource-src-5.8.0-webrtc-neon-detect.patch deleted file mode 100644 index 8e26dbe..0000000 --- a/qtwebengine-opensource-src-5.8.0-webrtc-neon-detect.patch +++ /dev/null @@ -1,32 +0,0 @@ -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/webrtc/system_wrappers/BUILD.gn qtwebengine-opensource-src-5.8.0-webrtc-neon-detect/src/3rdparty/chromium/third_party/webrtc/system_wrappers/BUILD.gn ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/webrtc/system_wrappers/BUILD.gn 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-webrtc-neon-detect/src/3rdparty/chromium/third_party/webrtc/system_wrappers/BUILD.gn 2017-03-05 17:08:43.547748044 +0100 -@@ -108,9 +108,7 @@ - if (is_linux) { - defines += [ "WEBRTC_THREAD_RR" ] - -- if (!build_with_chromium) { -- deps += [ ":cpu_features_linux" ] -- } -+ deps += [ ":cpu_features_linux" ] - - libs += [ "rt" ] - } -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/webrtc/system_wrappers/system_wrappers.gyp qtwebengine-opensource-src-5.8.0-webrtc-neon-detect/src/3rdparty/chromium/third_party/webrtc/system_wrappers/system_wrappers.gyp ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/webrtc/system_wrappers/system_wrappers.gyp 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-webrtc-neon-detect/src/3rdparty/chromium/third_party/webrtc/system_wrappers/system_wrappers.gyp 2017-03-05 17:07:01.869254856 +0100 -@@ -112,12 +112,8 @@ - 'defines': [ - 'WEBRTC_THREAD_RR', - ], -- 'conditions': [ -- ['build_with_chromium==0', { -- 'dependencies': [ -- 'cpu_features_webrtc.gyp:cpu_features_linux', -- ], -- }], -+ 'dependencies': [ -+ 'cpu_features_webrtc.gyp:cpu_features_linux', - ], - 'link_settings': { - 'libraries': [ '-lrt', ], diff --git a/qtwebengine-opensource-src-5.8.0-wtf-gcc7.patch b/qtwebengine-opensource-src-5.8.0-wtf-gcc7.patch deleted file mode 100644 index f679530..0000000 --- a/qtwebengine-opensource-src-5.8.0-wtf-gcc7.patch +++ /dev/null @@ -1,12 +0,0 @@ -diff -ur qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/wtf/LinkedHashSet.h qtwebengine-opensource-src-5.8.0-wtf-gcc7/src/3rdparty/chromium/third_party/WebKit/Source/wtf/LinkedHashSet.h ---- qtwebengine-opensource-src-5.8.0/src/3rdparty/chromium/third_party/WebKit/Source/wtf/LinkedHashSet.h 2017-01-03 10:28:53.000000000 +0100 -+++ qtwebengine-opensource-src-5.8.0-wtf-gcc7/src/3rdparty/chromium/third_party/WebKit/Source/wtf/LinkedHashSet.h 2017-03-07 03:00:44.783316233 +0100 -@@ -542,6 +542,8 @@ - return *this; - } - -+inline void swapAnchor(LinkedHashSetNodeBase& a, LinkedHashSetNodeBase& b); -+ - template - inline void LinkedHashSet::swap(LinkedHashSet& other) - { diff --git a/sources b/sources index 805aa50..fb92ca3 100644 --- a/sources +++ b/sources @@ -1 +1 @@ -SHA512 (qtwebengine-opensource-src-5.8.0-clean.tar.xz) = 18a49156da8d2e21fb0fe4781646c753c82d616964dd14b0651a1097b2a79a5ddb852dbdcc838d1e9e9a4ec460dd77fbab78a03672f5e827ab061fdf97db4a25 +SHA512 (qtwebengine-opensource-src-5.9.0-clean.tar.xz) = b80070b267bffb29a17f8fbf9da8c9f9fe6d59c12bccb3710370b1c830f0f162199341266da6c24563e75f17f6f9d850fd762f58ab1fafc2535f432d6180c98c