Index: head/www/qt5-webengine/Makefile =================================================================== --- head/www/qt5-webengine/Makefile +++ head/www/qt5-webengine/Makefile @@ -110,6 +110,14 @@ CPLUS_INCLUDE_PATH=${LOCALBASE}/include \ ${CONFIGURE_ENV} +.include + +.if ${ARCH:Mmips*} || ${ARCH:Mpowerpc*} || ${ARCH} == sparc64 +PLIST_SUB+= BE="" LE="@comment " +.else +PLIST_SUB+= BE="@comment " LE="" +.endif + post-extract: # Install FreeBSD's freebsd.pri file. ${CP} ${FILESDIR}/freebsd.pri ${WRKSRC}/src/core/config/freebsd.pri @@ -121,6 +129,12 @@ @${CP} ${FILESDIR}/audio_manager_openbsd.* \ ${WRKSRC}/src/3rdparty/chromium/media/audio/openbsd +.if ${ARCH:Mmips*} || ${ARCH:Mpowerpc*} || ${ARCH} == sparc64 +post-patch: + @${REINPLACE_CMD} -e 's/icudtl.dat/icudtb.dat/' \ + ${WRKSRC}/src/core/core_module.pro +.endif + pre-configure: # Link in ${PYTHON_CMD} to ${CONFIGURE_WRKSRC}/bin -- the scripts hardcode 'python' # in too many places to reasonably patch. So just link in ${PYTHON_CMD} to work around @@ -132,4 +146,4 @@ # Rerun syncqt.pl -- otherwise the resulting package misses some forwarding headers. cd ${WRKSRC} && ${QT_BINDIR}/syncqt.pl -version ${QT5_VERSION} -.include +.include Index: head/www/qt5-webengine/files/patch-mkspecs_features_functions.prf =================================================================== --- head/www/qt5-webengine/files/patch-mkspecs_features_functions.prf +++ head/www/qt5-webengine/files/patch-mkspecs_features_functions.prf @@ -1,7 +1,7 @@ Include the freebsd.pri file provided by the port, to pass FreeBSD specific settings to gn. ---- mkspecs/features/functions.prf.orig 2019-01-16 22:42:58 UTC +--- mkspecs/features/functions.prf.orig 2019-05-24 09:01:39 UTC +++ mkspecs/features/functions.prf @@ -82,6 +82,7 @@ defineReplace(gnArgs) { linux: include($$QTWEBENGINE_ROOT/src/core/config/linux.pri) @@ -11,7 +11,15 @@ isEmpty(gn_args): error(No gn_args found please make sure you have valid configuration.) return($$gn_args) } -@@ -101,6 +102,7 @@ defineReplace(gnOS) { +@@ -94,6 +95,7 @@ defineReplace(gnArch) { + contains(qtArch, "arm64"): return(arm64) + contains(qtArch, "mips"): return(mipsel) + contains(qtArch, "mips64"): return(mips64el) ++ contains(qtArch, "power64"): return(ppc64) + return(unknown) + } + +@@ -101,6 +103,7 @@ defineReplace(gnOS) { macos: return(mac) win32: return(win) linux: return(linux) Index: head/www/qt5-webengine/files/patch-mkspecs_features_platform.prf =================================================================== --- head/www/qt5-webengine/files/patch-mkspecs_features_platform.prf +++ head/www/qt5-webengine/files/patch-mkspecs_features_platform.prf @@ -1,4 +1,4 @@ ---- mkspecs/features/platform.prf.orig 2018-11-27 04:10:38 UTC +--- mkspecs/features/platform.prf.orig 2019-05-24 09:01:39 UTC +++ mkspecs/features/platform.prf @@ -11,7 +11,7 @@ defineTest(isQtMinimum) { @@ -9,3 +9,11 @@ if(!gcc:!clang)|intel_icc { skipBuild("Qt WebEngine on Linux requires clang or GCC.") return(false) +@@ -84,6 +84,7 @@ defineTest(isArchSupported) { + contains(QT_ARCH, "arm")|contains(QT_ARCH, "arm64"): return(true) + contains(QT_ARCH, "mips"): return(true) + # contains(QT_ARCH, "mips64"): return(true) ++ contains(QT_ARCH, "power64"): return(true) + + skipBuild("QtWebEngine can only be built for x86, x86-64, ARM, Aarch64, and MIPSel architectures.") + return(false) Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_allocator_partition__allocator_partition__alloc.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_allocator_partition__allocator_partition__alloc.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_allocator_partition__allocator_partition__alloc.cc @@ -0,0 +1,11 @@ +--- src/3rdparty/chromium/base/allocator/partition_allocator/partition_alloc.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/base/allocator/partition_allocator/partition_alloc.cc +@@ -440,7 +440,7 @@ static size_t PartitionPurgePage(internal::PartitionPa + #endif + } + // Terminate the freelist chain. +- *entry_ptr = nullptr; ++ *entry_ptr = internal::PartitionFreelistEntry::Transform(nullptr); + // The freelist head is stored unmasked. + page->freelist_head = + internal::PartitionFreelistEntry::Transform(page->freelist_head); Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_i18n_icu__util.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_i18n_icu__util.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_i18n_icu__util.cc @@ -1,5 +1,5 @@ ---- src/3rdparty/chromium/base/i18n/icu_util.cc.orig 2018-11-13 18:25:11 UTC -+++ src/3rdparty/chromium/base/i18n/icu_util.cc +--- src/3rdparty/chromium/base/i18n/icu_util.cc.orig 2019-05-23 14:39:34.000000000 +0200 ++++ src/3rdparty/chromium/base/i18n/icu_util.cc 2019-10-27 22:58:57.501541000 +0100 @@ -20,7 +20,7 @@ #include "build/build_config.h" #include "third_party/icu/source/common/unicode/putil.h" @@ -9,7 +9,19 @@ #include "third_party/icu/source/i18n/unicode/timezone.h" #endif -@@ -320,7 +320,7 @@ bool InitializeICU() { +@@ -75,7 +75,11 @@ + // No need to change the filename in multiple places (gyp files, windows + // build pkg configurations, etc). 'l' stands for Little Endian. + // This variable is exported through the header file. ++#if defined(ARCH_CPU_LITTLE_ENDIAN) + const char kIcuDataFileName[] = "icudtl.dat"; ++#else ++const char kIcuDataFileName[] = "icudtb.dat"; ++#endif + #if defined(OS_ANDROID) + const char kAndroidAssetsIcuDataFileName[] = "assets/icudtl.dat"; + #endif +@@ -320,7 +324,7 @@ // TODO(jungshik): Some callers do not care about tz at all. If necessary, // add a boolean argument to this function to init'd the default tz only // when requested. Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_memory_shared__memory__mapping__unittest.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_memory_shared__memory__mapping__unittest.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_memory_shared__memory__mapping__unittest.cc @@ -0,0 +1,39 @@ +--- src/3rdparty/chromium/base/memory/shared_memory_mapping_unittest.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/base/memory/shared_memory_mapping_unittest.cc +@@ -12,6 +12,7 @@ + #include "base/containers/span.h" + #include "base/memory/read_only_shared_memory_region.h" + #include "testing/gtest/include/gtest/gtest.h" ++#include "base/sys_byteorder.h" + + namespace base { + +@@ -69,8 +70,8 @@ TEST_F(SharedMemoryMappingTest, SpanWithAutoDeducedEle + + for (size_t i = 0; i < write_span.size(); ++i) + write_span[i] = i + 1; +- EXPECT_EQ(0x04030201u, read_span[0]); +- EXPECT_EQ(0x08070605u, read_span[1]); ++ EXPECT_EQ(HostToNet32(0x01020304u), read_span[0]); ++ EXPECT_EQ(HostToNet32(0x05060708u), read_span[1]); + } + + TEST_F(SharedMemoryMappingTest, SpanWithExplicitElementCount) { +@@ -95,13 +96,13 @@ TEST_F(SharedMemoryMappingTest, SpanWithExplicitElemen + + for (size_t i = 0; i < write_span.size(); ++i) + write_span[i] = i + 1; +- EXPECT_EQ(0x04030201u, read_span[0]); +- EXPECT_EQ(0x08070605u, read_span[1]); +- EXPECT_EQ(0x04030201u, read_span_2[0]); ++ EXPECT_EQ(HostToNet32(0x01020304u), read_span[0]); ++ EXPECT_EQ(HostToNet32(0x05060708u), read_span[1]); ++ EXPECT_EQ(HostToNet32(0x01020304u), read_span_2[0]); + + std::fill(write_span_2.begin(), write_span_2.end(), 0); + EXPECT_EQ(0u, read_span[0]); +- EXPECT_EQ(0x08070605u, read_span[1]); ++ EXPECT_EQ(HostToNet32(0x05060708u), read_span[1]); + EXPECT_EQ(0u, read_span_2[0]); + } + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_metrics_bucket__ranges__unittest.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_metrics_bucket__ranges__unittest.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_metrics_bucket__ranges__unittest.cc @@ -0,0 +1,32 @@ +--- src/3rdparty/chromium/base/metrics/bucket_ranges_unittest.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/base/metrics/bucket_ranges_unittest.cc +@@ -7,6 +7,7 @@ + #include + + #include "testing/gtest/include/gtest/gtest.h" ++#include "base/sys_byteorder.h" + + namespace base { + namespace { +@@ -64,13 +65,21 @@ TEST(BucketRangesTest, Checksum) { + ranges.set_range(2, 2); + + ranges.ResetChecksum(); ++#if defined(ARCH_CPU_LITTLE_ENDIAN) + EXPECT_EQ(289217253u, ranges.checksum()); ++#else ++ EXPECT_EQ(2767231596u, ranges.checksum()); ++#endif + + ranges.set_range(2, 3); + EXPECT_FALSE(ranges.HasValidChecksum()); + + ranges.ResetChecksum(); ++#if defined(ARCH_CPU_LITTLE_ENDIAN) + EXPECT_EQ(2843835776u, ranges.checksum()); ++#else ++ EXPECT_EQ(3556223738u, ranges.checksum()); ++#endif + EXPECT_TRUE(ranges.HasValidChecksum()); + } + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_pickle.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_pickle.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_pickle.cc @@ -0,0 +1,16 @@ +--- src/3rdparty/chromium/base/pickle.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/base/pickle.cc +@@ -82,7 +82,12 @@ inline const char* PickleIterator::GetReadPointerAndAd + } + + bool PickleIterator::ReadBool(bool* result) { +- return ReadBuiltinType(result); ++ int int_result; ++ if (ReadBuiltinType(&int_result)) { ++ *result = static_cast(int_result); ++ return true; ++ } else ++ return false; + } + + bool PickleIterator::ReadInt(int* result) { Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_sha1.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_sha1.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_sha1.cc @@ -0,0 +1,24 @@ +--- src/3rdparty/chromium/base/sha1.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/base/sha1.cc +@@ -110,8 +110,10 @@ void SecureHashAlgorithm::Final() { + Pad(); + Process(); + ++#if defined(ARCH_CPU_LITTLE_ENDIAN) + for (auto& t : H) + t = ByteSwap(t); ++#endif + } + + void SecureHashAlgorithm::Update(const void* data, size_t nbytes) { +@@ -157,8 +159,10 @@ void SecureHashAlgorithm::Process() { + // + // W and M are in a union, so no need to memcpy. + // memcpy(W, M, sizeof(M)); ++#if defined(ARCH_CPU_LITTLE_ENDIAN) + for (t = 0; t < 16; ++t) + W[t] = ByteSwap(W[t]); ++#endif + + // b. + for (t = 16; t < 80; ++t) Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_strings_string__number__conversions__unittest.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_strings_string__number__conversions__unittest.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_strings_string__number__conversions__unittest.cc @@ -0,0 +1,24 @@ +--- src/3rdparty/chromium/base/strings/string_number_conversions_unittest.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/base/strings/string_number_conversions_unittest.cc +@@ -829,12 +829,21 @@ TEST(StringNumberConversionsTest, DoubleToString) { + } + + // The following two values were seen in crashes in the wild. ++#if defined(ARCH_CPU_LITTLE_ENDIAN) + const char input_bytes[8] = {0, 0, 0, 0, '\xee', '\x6d', '\x73', '\x42'}; ++#else ++ const char input_bytes[8] = {'\x42', '\x73', '\x6d', '\xee', 0, 0, 0, 0}; ++#endif + double input = 0; + memcpy(&input, input_bytes, base::size(input_bytes)); + EXPECT_EQ("1335179083776", NumberToString(input)); ++#if defined(ARCH_CPU_LITTLE_ENDIAN) + const char input_bytes2[8] = + {0, 0, 0, '\xa0', '\xda', '\x6c', '\x73', '\x42'}; ++#else ++ const char input_bytes2[8] = ++ {'\x42', '\x73', '\x6c', '\xda', '\xa0', 0, 0, 0}; ++#endif + input = 0; + memcpy(&input, input_bytes2, base::size(input_bytes2)); + EXPECT_EQ("1334890332160", NumberToString(input)); Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_system_sys__info__posix.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_system_sys__info__posix.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_system_sys__info__posix.cc @@ -27,12 +27,14 @@ int SysInfo::NumberOfProcessors() { return g_lazy_number_of_processors.Get().value(); } -@@ -225,6 +225,8 @@ std::string SysInfo::OperatingSystemArchitecture() { +@@ -225,7 +225,9 @@ std::string SysInfo::OperatingSystemArchitecture() { arch = "x86"; } else if (arch == "amd64") { arch = "x86_64"; +- } else if (std::string(info.sysname) == "AIX") { + } else if (arch == "arm64") { + arch = "aarch64"; - } else if (std::string(info.sysname) == "AIX") { ++ } else if (arch == "powerpc" || arch == "powerpc64") { arch = "ppc64"; } + return arch; Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_third__party_dmg__fp_dtoa.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_third__party_dmg__fp_dtoa.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_base_third__party_dmg__fp_dtoa.cc @@ -0,0 +1,14 @@ +--- src/3rdparty/chromium/base/third_party/dmg_fp/dtoa.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/base/third_party/dmg_fp/dtoa.cc +@@ -186,7 +186,11 @@ + * used for input more than STRTOD_DIGLIM digits long (default 40). + */ + ++#ifdef __BIG_ENDIAN__ ++#define IEEE_MC68k ++#else + #define IEEE_8087 ++#endif + #define NO_HEX_FP + + #ifndef Long Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_build_download__nacl__toolchains.py =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_build_download__nacl__toolchains.py +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_build_download__nacl__toolchains.py @@ -0,0 +1,13 @@ +--- src/3rdparty/chromium/build/download_nacl_toolchains.py.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/build/download_nacl_toolchains.py +@@ -11,6 +11,10 @@ import sys + + + def Main(args): ++ # If `disable_nacl=1` is in GYP_DEFINES, exit ++ if 'disable_nacl=1' in os.environ.get('GYP_DEFINES', ''): ++ return 0 ++ + script_dir = os.path.dirname(os.path.abspath(__file__)) + src_dir = os.path.dirname(script_dir) + nacl_dir = os.path.join(src_dir, 'native_client') Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_build_toolchain_linux_BUILD.gn =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_build_toolchain_linux_BUILD.gn +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_build_toolchain_linux_BUILD.gn @@ -1,6 +1,21 @@ ---- src/3rdparty/chromium/build/toolchain/linux/BUILD.gn.orig 2018-11-13 18:25:11 UTC -+++ src/3rdparty/chromium/build/toolchain/linux/BUILD.gn -@@ -14,7 +14,6 @@ clang_toolchain("clang_arm") { +--- src/3rdparty/chromium/build/toolchain/linux/BUILD.gn.orig 2019-05-23 14:39:34.000000000 +0200 ++++ src/3rdparty/chromium/build/toolchain/linux/BUILD.gn 2019-10-29 02:47:24.026830000 +0100 +@@ -5,6 +5,14 @@ + import("//build/config/sysroot.gni") + import("//build/toolchain/gcc_toolchain.gni") + ++clang_toolchain("clang_ppc64") { ++ enable_linker_map = true ++ toolchain_args = { ++ current_cpu = "ppc64" ++ current_os = "linux" ++ } ++} ++ + clang_toolchain("clang_arm") { + toolprefix = "arm-linux-gnueabihf-" + toolchain_args = { +@@ -14,7 +22,6 @@ } clang_toolchain("clang_arm64") { Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_util__unittest.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_util__unittest.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_util__unittest.cc @@ -0,0 +1,24 @@ +--- src/3rdparty/chromium/components/safe_browsing/db/util_unittest.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/components/safe_browsing/db/util_unittest.cc +@@ -12,6 +12,12 @@ + #include "testing/gtest/include/gtest/gtest.h" + #include "url/gurl.h" + ++#if defined(OS_WIN) ++#include ++#elif defined(OS_POSIX) ++#include ++#endif ++ + namespace safe_browsing { + + TEST(SafeBrowsingDbUtilTest, UrlToFullHashes) { +@@ -83,7 +89,7 @@ TEST(SafeBrowsingDbUtilTest, StringToSBFullHashAndSBFu + // 31 chars plus the last \0 as full_hash. + const std::string hash_in = "12345678902234567890323456789012"; + SBFullHash hash_out = StringToSBFullHash(hash_in); +- EXPECT_EQ(0x34333231U, hash_out.prefix); ++ EXPECT_EQ(htonl(0x31323334U), hash_out.prefix); + EXPECT_EQ(0, memcmp(hash_in.data(), hash_out.full_hash, sizeof(SBFullHash))); + + std::string hash_final = SBFullHashToString(hash_out); Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_v4__rice.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_v4__rice.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_v4__rice.cc @@ -0,0 +1,39 @@ +--- src/3rdparty/chromium/components/safe_browsing/db/v4_rice.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/components/safe_browsing/db/v4_rice.cc +@@ -8,6 +8,7 @@ + #include "base/logging.h" + #include "base/numerics/safe_math.h" + #include "base/strings/stringprintf.h" ++#include "base/sys_byteorder.h" + #include "build/build_config.h" + #include "components/safe_browsing/db/v4_rice.h" + +@@ -21,10 +22,6 @@ using ::google::protobuf::RepeatedField; + using ::google::protobuf::int32; + using ::google::protobuf::int64; + +-#if !defined(ARCH_CPU_LITTLE_ENDIAN) || (ARCH_CPU_LITTLE_ENDIAN != 1) +-#error The code below assumes little-endianness. +-#endif +- + namespace safe_browsing { + + namespace { +@@ -117,7 +114,7 @@ V4DecodeResult V4RiceDecoder::DecodePrefixes(const int + out->reserve((num_entries + 1)); + + base::CheckedNumeric last_value(first_value); +- out->push_back(htonl(last_value.ValueOrDie())); ++ out->push_back(base::ByteSwap(static_cast(last_value.ValueOrDie()))); + + if (num_entries > 0) { + V4RiceDecoder decoder(rice_parameter, num_entries, encoded_data); +@@ -136,7 +133,7 @@ V4DecodeResult V4RiceDecoder::DecodePrefixes(const int + + // This flipping is done so that the decoded uint32 is interpreted + // correcly as a string of 4 bytes. +- out->push_back(htonl(last_value.ValueOrDie())); ++ out->push_back(base::ByteSwap(static_cast(last_value.ValueOrDie()))); + } + } + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_v4__rice__unittest.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_v4__rice__unittest.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_components_safe__browsing_db_v4__rice__unittest.cc @@ -0,0 +1,33 @@ +--- src/3rdparty/chromium/components/safe_browsing/db/v4_rice_unittest.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/components/safe_browsing/db/v4_rice_unittest.cc +@@ -6,6 +6,12 @@ + #include "base/logging.h" + #include "testing/platform_test.h" + ++#if defined(OS_WIN) ++#include ++#elif defined(OS_POSIX) ++#include ++#endif ++ + using ::google::protobuf::RepeatedField; + using ::google::protobuf::int32; + +@@ -247,7 +253,7 @@ TEST_F(V4RiceTest, TestDecoderPrefixesWithOneValue) { + EXPECT_EQ(DECODE_SUCCESS, + V4RiceDecoder::DecodePrefixes(0x69F67F51u, 2, 0, "", &out)); + EXPECT_EQ(1u, out.size()); +- EXPECT_EQ(0x69F67F51u, out[0]); ++ EXPECT_EQ(htonl(0x517FF669u), out[0]); + } + + TEST_F(V4RiceTest, TestDecoderPrefixesWithMultipleValues) { +@@ -256,7 +262,7 @@ TEST_F(V4RiceTest, TestDecoderPrefixesWithMultipleValu + V4RiceDecoder::DecodePrefixes( + 5, 28, 3, "\xbf\xa8\x3f\xfb\xf\xf\x5e\x27\xe6\xc3\x1d\xc6\x38", + &out)); +- std::vector expected = {5, 0xad934c0cu, 0x6ff67f56u, 0x81316fceu}; ++ std::vector expected = {htonl(0x05000000), htonl(0x0c4c93adu), htonl(0x567ff66fu), htonl(0xce6f3181u)}; + EXPECT_EQ(expected.size(), out.size()); + for (unsigned i = 0; i < expected.size(); i++) { + EXPECT_EQ(expected[i], out[i]); Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_components_update__client_update__query__params.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_components_update__client_update__query__params.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_components_update__client_update__query__params.cc @@ -1,6 +1,6 @@ ---- src/3rdparty/chromium/components/update_client/update_query_params.cc.orig 2018-11-13 18:25:11 UTC -+++ src/3rdparty/chromium/components/update_client/update_query_params.cc -@@ -38,6 +38,8 @@ const char kOs[] = +--- src/3rdparty/chromium/components/update_client/update_query_params.cc.orig 2019-05-23 14:39:34.000000000 +0200 ++++ src/3rdparty/chromium/components/update_client/update_query_params.cc 2019-10-29 02:42:47.135055000 +0100 +@@ -38,6 +38,8 @@ "fuchsia"; #elif defined(OS_OPENBSD) "openbsd"; @@ -9,3 +9,21 @@ #else #error "unknown os" #endif +@@ -55,6 +57,8 @@ + "mips64el"; + #elif defined(__mips__) + "mipsel"; ++#elif defined(__powerpc64__) ++ "ppc64"; + #else + #error "unknown arch" + #endif +@@ -127,6 +131,8 @@ + return "mips32"; + #elif defined(ARCH_CPU_MIPS64EL) + return "mips64"; ++#elif defined(ARCH_CPU_PPC64) ++ return "ppc64"; + #else + // NOTE: when adding new values here, please remember to update the + // comment in the .h file about possible return values from this function. Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_media_ffmpeg_ffmpeg__common.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_media_ffmpeg_ffmpeg__common.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_media_ffmpeg_ffmpeg__common.cc @@ -0,0 +1,13 @@ +--- src/3rdparty/chromium/media/ffmpeg/ffmpeg_common.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/media/ffmpeg/ffmpeg_common.cc +@@ -686,10 +686,6 @@ ChannelLayout ChannelLayoutToChromeChannelLayout(int64 + } + } + +-#if !defined(ARCH_CPU_LITTLE_ENDIAN) +-#error The code below assumes little-endianness. +-#endif +- + VideoPixelFormat AVPixelFormatToVideoPixelFormat(AVPixelFormat pixel_format) { + // The YUVJ alternatives are FFmpeg's (deprecated, but still in use) way to + // specify a pixel format and full range color combination. Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_media_formats_mp4_box__definitions.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_media_formats_mp4_box__definitions.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_media_formats_mp4_box__definitions.cc @@ -0,0 +1,26 @@ +--- src/3rdparty/chromium/media/formats/mp4/box_definitions.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/media/formats/mp4/box_definitions.cc +@@ -1107,15 +1107,14 @@ bool OpusSpecificBox::Parse(BoxReader* reader) { + RCHECK(reader->Read4(&sample_rate)); + RCHECK(reader->Read2s(&gain_db)); + +-#if !defined(ARCH_CPU_LITTLE_ENDIAN) +-#error The code below assumes little-endianness. +-#endif +- +- memcpy(&extradata[OPUS_EXTRADATA_SKIP_SAMPLES_OFFSET], &codec_delay_in_frames, +- sizeof(codec_delay_in_frames)); +- memcpy(&extradata[OPUS_EXTRADATA_SAMPLE_RATE_OFFSET], &sample_rate, +- sizeof(sample_rate)); +- memcpy(&extradata[OPUS_EXTRADATA_GAIN_OFFSET], &gain_db, sizeof(gain_db)); ++ extradata[OPUS_EXTRADATA_SKIP_SAMPLES_OFFSET] = (codec_delay_in_frames >> 0) & 0xff; ++ extradata[OPUS_EXTRADATA_SKIP_SAMPLES_OFFSET+1] = (codec_delay_in_frames >> 8) & 0xff; ++ extradata[OPUS_EXTRADATA_SAMPLE_RATE_OFFSET] = (sample_rate >> 0) & 0xff; ++ extradata[OPUS_EXTRADATA_SAMPLE_RATE_OFFSET+1] = (sample_rate >> 8) & 0xff; ++ extradata[OPUS_EXTRADATA_SAMPLE_RATE_OFFSET+2] = (sample_rate >> 16) & 0xff; ++ extradata[OPUS_EXTRADATA_SAMPLE_RATE_OFFSET+3] = (sample_rate >> 24) & 0xff; ++ extradata[OPUS_EXTRADATA_GAIN_OFFSET] = (gain_db >> 0) & 0xff; ++ extradata[OPUS_EXTRADATA_GAIN_OFFSET+1] = (gain_db >> 8) & 0xff; + + channel_count = extradata[OPUS_EXTRADATA_CHANNELS_OFFSET]; + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_media_renderers_paint__canvas__video__renderer.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_media_renderers_paint__canvas__video__renderer.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_media_renderers_paint__canvas__video__renderer.cc @@ -0,0 +1,22 @@ +--- src/3rdparty/chromium/media/renderers/paint_canvas_video_renderer.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/media/renderers/paint_canvas_video_renderer.cc +@@ -31,8 +31,7 @@ + + // Skia internal format depends on a platform. On Android it is ABGR, on others + // it is ARGB. +-#if SK_B32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_R32_SHIFT == 16 && \ +- SK_A32_SHIFT == 24 ++#if SK_PMCOLOR_BYTE_ORDER(B,G,R,A) + #define LIBYUV_I420_TO_ARGB libyuv::I420ToARGB + #define LIBYUV_I422_TO_ARGB libyuv::I422ToARGB + #define LIBYUV_I444_TO_ARGB libyuv::I444ToARGB +@@ -42,8 +41,7 @@ + #define LIBYUV_I010_TO_ARGB libyuv::I010ToARGB + #define LIBYUV_H010_TO_ARGB libyuv::H010ToARGB + #define LIBYUV_NV12_TO_ARGB libyuv::NV12ToARGB +-#elif SK_R32_SHIFT == 0 && SK_G32_SHIFT == 8 && SK_B32_SHIFT == 16 && \ +- SK_A32_SHIFT == 24 ++#elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A) + #define LIBYUV_I420_TO_ARGB libyuv::I420ToABGR + #define LIBYUV_I422_TO_ARGB libyuv::I422ToABGR + #define LIBYUV_I444_TO_ARGB libyuv::I444ToABGR Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_net_cert_crl__set.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_net_cert_crl__set.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_net_cert_crl__set.cc @@ -0,0 +1,48 @@ +--- src/3rdparty/chromium/net/cert/crl_set.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/net/cert/crl_set.cc +@@ -6,6 +6,7 @@ + + #include "base/base64.h" + #include "base/json/json_reader.h" ++#include "base/sys_byteorder.h" + #include "base/time/time.h" + #include "base/trace_event/trace_event.h" + #include "base/values.h" +@@ -44,9 +45,9 @@ base::DictionaryValue* ReadHeader(base::StringPiece* d + uint16_t header_len; + if (data->size() < sizeof(header_len)) + return nullptr; +- // Assumes little-endian. + memcpy(&header_len, data->data(), sizeof(header_len)); + data->remove_prefix(sizeof(header_len)); ++ header_len = base::ByteSwapToLE16(header_len); + + if (data->size() < header_len) + return nullptr; +@@ -79,9 +80,9 @@ bool ReadCRL(base::StringPiece* data, + uint32_t num_serials; + if (data->size() < sizeof(num_serials)) + return false; +- // Assumes little endian. + memcpy(&num_serials, data->data(), sizeof(num_serials)); + data->remove_prefix(sizeof(num_serials)); ++ num_serials = base::ByteSwapToLE32(num_serials); + + if (num_serials > 32 * 1024 * 1024) // Sanity check. + return false; +@@ -192,15 +193,6 @@ CRLSet::~CRLSet() = default; + // static + bool CRLSet::Parse(base::StringPiece data, scoped_refptr* out_crl_set) { + TRACE_EVENT0(NetTracingCategory(), "CRLSet::Parse"); +-// Other parts of Chrome assume that we're little endian, so we don't lose +-// anything by doing this. +-#if defined(__BYTE_ORDER) +- // Linux check +- static_assert(__BYTE_ORDER == __LITTLE_ENDIAN, "assumes little endian"); +-#elif defined(__BIG_ENDIAN__) +-// Mac check +-#error assumes little endian +-#endif + + std::unique_ptr header_dict(ReadHeader(&data)); + if (!header_dict.get()) Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_services_service__manager_sandbox_linux_bpf__renderer__policy__linux.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_services_service__manager_sandbox_linux_bpf__renderer__policy__linux.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_services_service__manager_sandbox_linux_bpf__renderer__policy__linux.cc @@ -0,0 +1,14 @@ +--- src/3rdparty/chromium/services/service_manager/sandbox/linux/bpf_renderer_policy_linux.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/services/service_manager/sandbox/linux/bpf_renderer_policy_linux.cc +@@ -15,6 +15,11 @@ + #include "sandbox/linux/system_headers/linux_syscalls.h" + #include "services/service_manager/sandbox/linux/sandbox_linux.h" + ++// On PPC64, TCGETS is defined in terms of struct termios, so we must include termios.h ++#ifdef __powerpc64__ ++#include ++#endif ++ + // TODO(vignatti): replace the local definitions below with #include + // once kernel version 4.6 becomes widely used. + #include Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_skia_config_SkUserConfig.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_skia_config_SkUserConfig.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_skia_config_SkUserConfig.h @@ -0,0 +1,39 @@ +--- src/3rdparty/chromium/skia/config/SkUserConfig.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/skia/config/SkUserConfig.h +@@ -90,11 +90,18 @@ SK_API void SkDebugf_FileLine(const char* file, int li + __FILE__, __LINE__, #cond); } } while (false) + + #if !defined(ANDROID) // On Android, we use the skia default settings. ++#if defined(SK_CPU_BENDIAN) ++#define SK_A32_SHIFT 0 ++#define SK_R32_SHIFT 8 ++#define SK_G32_SHIFT 16 ++#define SK_B32_SHIFT 24 ++#else + #define SK_A32_SHIFT 24 + #define SK_R32_SHIFT 16 + #define SK_G32_SHIFT 8 + #define SK_B32_SHIFT 0 + #endif ++#endif + + #if defined(SK_BUILD_FOR_MAC) + +@@ -107,17 +114,6 @@ SK_API void SkDebugf_FileLine(const char* file, int li + // TODO: skia used to just use hairline, but has improved since then, so + // we should revisit this choice... + #define SK_USE_FREETYPE_EMBOLDEN +- +-#if defined(SK_BUILD_FOR_UNIX) && defined(SK_CPU_BENDIAN) +-// Above we set the order for ARGB channels in registers. I suspect that, on +-// big endian machines, you can keep this the same and everything will work. +-// The in-memory order will be different, of course, but as long as everything +-// is reading memory as words rather than bytes, it will all work. However, if +-// you find that colours are messed up I thought that I would leave a helpful +-// locator for you. Also see the comments in +-// base/gfx/bitmap_platform_device_linux.h +-#error Read the comment at this location +-#endif + + #endif + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_skia_ext_image__operations__unittest.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_skia_ext_image__operations__unittest.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_skia_ext_image__operations__unittest.cc @@ -0,0 +1,59 @@ +--- src/3rdparty/chromium/skia/ext/image_operations_unittest.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/skia/ext/image_operations_unittest.cc +@@ -18,9 +18,11 @@ + #include "skia/ext/image_operations.h" + #include "testing/gtest/include/gtest/gtest.h" + #include "third_party/skia/include/core/SkBitmap.h" ++#include "third_party/skia/include/core/SkColorPriv.h" + #include "third_party/skia/include/core/SkColorSpace.h" + #include "third_party/skia/include/core/SkImageInfo.h" + #include "third_party/skia/include/core/SkRect.h" ++#include "third_party/skia/include/core/SkUnPreMultiply.h" + #include "ui/gfx/codec/png_codec.h" + #include "ui/gfx/geometry/size.h" + +@@ -151,7 +153,7 @@ void DrawCheckerToBitmap(int w, int h, + + bool use_color2 = (x_bit != y_bit); // xor + +- *bmp->getAddr32(x, y) = (use_color2 ? color2 : color1); ++ *bmp->getAddr32(x, y) = SkPreMultiplyColor(use_color2 ? color2 : color1); + } + } + } +@@ -273,7 +275,7 @@ void CheckResizeMethodShouldAverageGrid( + std::max(tested_pixel.max_color_distance, + tested_method.max_color_distance_override); + +- const SkColor actual_color = *dest.getAddr32(x, y); ++ const SkColor actual_color = SkUnPreMultiply::PMColorToColor(*dest.getAddr32(x, y)); + + // Check that the pixels away from the border region are very close + // to the expected average color +@@ -528,7 +530,7 @@ TEST(ImageOperations, ScaleUp) { + for (int src_y = 0; src_y < src_h; ++src_y) { + for (int src_x = 0; src_x < src_w; ++src_x) { + *src.getAddr32(src_x, src_y) = +- SkColorSetARGB(255, 10 + src_x * 100, 10 + src_y * 100, 0); ++ SkPackARGB32(255, 10 + src_x * 100, 10 + src_y * 100, 0); + } + } + +@@ -552,7 +554,7 @@ TEST(ImageOperations, ScaleUp) { + lanczos3(src_x + 0.5 - dst_x_in_src) * + lanczos3(src_y + 0.5 - dst_y_in_src); + sum += coeff; +- SkColor tmp = *src.getAddr32(src_x, src_y); ++ SkColor tmp = SkUnPreMultiply::PMColorToColor(*src.getAddr32(src_x, src_y)); + a += coeff * SkColorGetA(tmp); + r += coeff * SkColorGetR(tmp); + g += coeff * SkColorGetG(tmp); +@@ -571,7 +573,7 @@ TEST(ImageOperations, ScaleUp) { + if (r > 255.0f) r = 255.0f; + if (g > 255.0f) g = 255.0f; + if (b > 255.0f) b = 255.0f; +- SkColor dst_color = *dst.getAddr32(dst_x, dst_y); ++ SkColor dst_color = SkUnPreMultiply::PMColorToColor(*dst.getAddr32(dst_x, dst_y)); + EXPECT_LE(fabs(SkColorGetA(dst_color) - a), 1.5f); + EXPECT_LE(fabs(SkColorGetR(dst_color) - r), 1.5f); + EXPECT_LE(fabs(SkColorGetG(dst_color) - g), 1.5f); Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_abseil-cpp_base_internal_unscaledcycleclock.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_abseil-cpp_base_internal_unscaledcycleclock.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_abseil-cpp_base_internal_unscaledcycleclock.cc @@ -0,0 +1,20 @@ +--- src/3rdparty/chromium/third_party/abseil-cpp/absl/base/internal/unscaledcycleclock.cc.orig 2019-05-23 14:39:34.000000000 +0200 ++++ src/3rdparty/chromium/third_party/abseil-cpp/absl/base/internal/unscaledcycleclock.cc 2019-10-27 21:56:29.777821000 +0100 +@@ -20,7 +20,7 @@ + #include + #endif + +-#if defined(__powerpc__) || defined(__ppc__) ++#if (defined(__powerpc__) || defined(__ppc__)) && defined(__GLIBC__) + #include + #endif + +@@ -53,7 +53,7 @@ + return base_internal::NominalCPUFrequency(); + } + +-#elif defined(__powerpc__) || defined(__ppc__) ++#elif (defined(__powerpc__) || defined(__ppc__)) && defined(__GLIBC__) + + int64_t UnscaledCycleClock::Now() { + return __ppc_get_timebase(); Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_angle_src_libANGLE_Constants.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_angle_src_libANGLE_Constants.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_angle_src_libANGLE_Constants.h @@ -0,0 +1,10 @@ +--- src/3rdparty/chromium/third_party/angle/src/libANGLE/Constants.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/angle/src/libANGLE/Constants.h +@@ -9,6 +9,7 @@ + #ifndef LIBANGLE_CONSTANTS_H_ + #define LIBANGLE_CONSTANTS_H_ + ++#include + #include "common/platform.h" + + namespace gl Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_gpu_webgl__image__conversion.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_gpu_webgl__image__conversion.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_gpu_webgl__image__conversion.cc @@ -0,0 +1,13 @@ +--- src/3rdparty/chromium/third_party/blink/renderer/platform/graphics/gpu/webgl_image_conversion.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/blink/renderer/platform/graphics/gpu/webgl_image_conversion.cc +@@ -456,8 +456,8 @@ void Unpack> 24; \ ++ int alpha = SkGetPackedA32(*bitmap.getAddr32(x, y)); \ + EXPECT_EQ(255, alpha); \ + } \ + } +@@ -61,12 +61,16 @@ namespace blink { + { \ + for (int y = 0; y < bitmap.height(); ++y) \ + for (int x = 0; x < bitmap.width(); ++x) { \ +- int alpha = *bitmap.getAddr32(x, y) >> 24; \ ++ int alpha = SkGetPackedA32(*bitmap.getAddr32(x, y)); \ + bool opaque = opaqueRect.Contains(x, y); \ + EXPECT_EQ(opaque, alpha == 255); \ + } \ + } + ++static inline uint32_t PackARGB32(uint32_t argb) { ++ return SkPackARGB32NoCheck(argb>>24, (argb<<8)>>24, (argb<<16)>>24, (argb<<24)>>24); ++} ++ + TEST(GraphicsContextTest, Recording) { + SkBitmap bitmap; + bitmap.allocN32Pixels(100, 100); +@@ -184,10 +188,10 @@ class GraphicsContextHighConstrastTest : public testin + TEST_F(GraphicsContextHighConstrastTest, MAYBE_NoHighContrast) { + DrawColorsToContext(); + +- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(0, 0)); +- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(1, 0)); +- EXPECT_EQ(0xffff0000, *bitmap_.getAddr32(2, 0)); +- EXPECT_EQ(0xff808080, *bitmap_.getAddr32(3, 0)); ++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(0, 0)); ++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(1, 0)); ++ EXPECT_EQ(PackARGB32(0xffff0000), *bitmap_.getAddr32(2, 0)); ++ EXPECT_EQ(PackARGB32(0xff808080), *bitmap_.getAddr32(3, 0)); + } + + // TODO(crbug.com/850782): Reenable this. +@@ -205,10 +209,10 @@ TEST_F(GraphicsContextHighConstrastTest, MAYBE_HighCon + + DrawColorsToContext(); + +- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(0, 0)); +- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(1, 0)); +- EXPECT_EQ(0xffff0000, *bitmap_.getAddr32(2, 0)); +- EXPECT_EQ(0xff808080, *bitmap_.getAddr32(3, 0)); ++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(0, 0)); ++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(1, 0)); ++ EXPECT_EQ(PackARGB32(0xffff0000), *bitmap_.getAddr32(2, 0)); ++ EXPECT_EQ(PackARGB32(0xff808080), *bitmap_.getAddr32(3, 0)); + } + + // Simple invert for testing. Each color component |c| +@@ -228,10 +232,10 @@ TEST_F(GraphicsContextHighConstrastTest, MAYBE_SimpleI + + DrawColorsToContext(); + +- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(0, 0)); +- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(1, 0)); +- EXPECT_EQ(0xff00ffff, *bitmap_.getAddr32(2, 0)); +- EXPECT_EQ(0xff7f7f7f, *bitmap_.getAddr32(3, 0)); ++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(0, 0)); ++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(1, 0)); ++ EXPECT_EQ(PackARGB32(0xff00ffff), *bitmap_.getAddr32(2, 0)); ++ EXPECT_EQ(PackARGB32(0xff7f7f7f), *bitmap_.getAddr32(3, 0)); + } + + // Invert brightness (with gamma correction). +@@ -250,10 +254,10 @@ TEST_F(GraphicsContextHighConstrastTest, MAYBE_InvertB + + DrawColorsToContext(); + +- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(0, 0)); +- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(1, 0)); +- EXPECT_EQ(0xff00ffff, *bitmap_.getAddr32(2, 0)); +- EXPECT_EQ(0xffdddddd, *bitmap_.getAddr32(3, 0)); ++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(0, 0)); ++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(1, 0)); ++ EXPECT_EQ(PackARGB32(0xff00ffff), *bitmap_.getAddr32(2, 0)); ++ EXPECT_EQ(PackARGB32(0xffdddddd), *bitmap_.getAddr32(3, 0)); + } + + // Invert lightness (in HSL space). +@@ -272,10 +276,10 @@ TEST_F(GraphicsContextHighConstrastTest, MAYBE_InvertL + + DrawColorsToContext(); + +- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(0, 0)); +- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(1, 0)); +- EXPECT_EQ(0xffff0000, *bitmap_.getAddr32(2, 0)); +- EXPECT_EQ(0xffdddddd, *bitmap_.getAddr32(3, 0)); ++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(0, 0)); ++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(1, 0)); ++ EXPECT_EQ(PackARGB32(0xffff0000), *bitmap_.getAddr32(2, 0)); ++ EXPECT_EQ(PackARGB32(0xffdddddd), *bitmap_.getAddr32(3, 0)); + } + + // Invert lightness plus grayscale. +@@ -288,10 +292,10 @@ TEST_F(GraphicsContextHighConstrastTest, InvertLightne + + DrawColorsToContext(); + +- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(0, 0)); +- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(1, 0)); +- EXPECT_EQ(0xffe2e2e2, *bitmap_.getAddr32(2, 0)); +- EXPECT_EQ(0xffdddddd, *bitmap_.getAddr32(3, 0)); ++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(0, 0)); ++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(1, 0)); ++ EXPECT_EQ(PackARGB32(0xffe2e2e2), *bitmap_.getAddr32(2, 0)); ++ EXPECT_EQ(PackARGB32(0xffdddddd), *bitmap_.getAddr32(3, 0)); + } + + // TODO(crbug.com/850782): Reenable this. +@@ -309,10 +313,10 @@ TEST_F(GraphicsContextHighConstrastTest, MAYBE_InvertL + + DrawColorsToContext(); + +- EXPECT_EQ(0xffffffff, *bitmap_.getAddr32(0, 0)); +- EXPECT_EQ(0xff000000, *bitmap_.getAddr32(1, 0)); +- EXPECT_EQ(0xffff0000, *bitmap_.getAddr32(2, 0)); +- EXPECT_EQ(0xffeeeeee, *bitmap_.getAddr32(3, 0)); ++ EXPECT_EQ(PackARGB32(0xffffffff), *bitmap_.getAddr32(0, 0)); ++ EXPECT_EQ(PackARGB32(0xff000000), *bitmap_.getAddr32(1, 0)); ++ EXPECT_EQ(PackARGB32(0xffff0000), *bitmap_.getAddr32(2, 0)); ++ EXPECT_EQ(PackARGB32(0xffeeeeee), *bitmap_.getAddr32(3, 0)); + } + + } // namespace blink Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_highcontrast_highcontrast__classifier.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_highcontrast_highcontrast__classifier.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_graphics_highcontrast_highcontrast__classifier.cc @@ -0,0 +1,79 @@ +--- src/3rdparty/chromium/third_party/blink/renderer/platform/graphics/highcontrast/highcontrast_classifier.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/blink/renderer/platform/graphics/highcontrast/highcontrast_classifier.cc +@@ -1060,55 +1060,47 @@ void DequantizeMinFirst(const int32_t rank, + + // ----------------------------------------------------------------------------- + // CONSTANTS +-// Note that for now, endianness of the target machine needs to match that of +-// the one training was performed on. + // ----------------------------------------------------------------------------- + const int32_t dnn_hiddenlayer_0_weights_part_0_shape[2] = {4, 10}; + const union { +- uint8_t bytes[160]; + float values[40]; + } dnn_hiddenlayer_0_weights_part_0 = {{ +- 0xbc, 0x22, 0x0a, 0xbf, 0xb4, 0x46, 0x8c, 0x3f, 0xba, 0x31, 0x34, 0xbe, +- 0x4c, 0x65, 0xdb, 0xbe, 0xf0, 0x54, 0x5e, 0xbe, 0xc1, 0x5d, 0xb3, 0x3f, +- 0xf4, 0xe6, 0x15, 0xbf, 0x05, 0xc6, 0x34, 0xbf, 0xc0, 0x37, 0x7e, 0xbd, +- 0x6c, 0x35, 0x0b, 0xbf, 0xca, 0x53, 0x26, 0xbf, 0x58, 0xb4, 0x87, 0x3f, +- 0x37, 0xee, 0x39, 0xbf, 0xda, 0xfa, 0xf9, 0xbe, 0x97, 0xc1, 0x06, 0xbf, +- 0xf9, 0x4e, 0x81, 0x3f, 0xb2, 0x44, 0x85, 0xbf, 0x7f, 0x98, 0x7c, 0x3d, +- 0x15, 0x26, 0xbc, 0xbe, 0x5c, 0x48, 0x05, 0x3f, 0xc8, 0xaa, 0xa1, 0xbd, +- 0x35, 0xb3, 0x43, 0xbe, 0xeb, 0x46, 0x91, 0x3f, 0x80, 0x71, 0xe3, 0x3c, +- 0xd1, 0x98, 0x79, 0x3f, 0x3c, 0xd0, 0x0d, 0xbf, 0x1e, 0x02, 0xd3, 0x3e, +- 0x5d, 0x4b, 0xa2, 0xbf, 0x68, 0xac, 0xaa, 0xbd, 0xf8, 0xe1, 0x75, 0x3e, +- 0x4a, 0x9c, 0x27, 0xbe, 0xf8, 0xae, 0xb2, 0xbe, 0x7f, 0x9d, 0x91, 0x3f, +- 0x1e, 0x8b, 0xa8, 0xbe, 0x35, 0x7e, 0xb2, 0x3f, 0xbe, 0x8c, 0xd3, 0xbe, +- 0xf9, 0xcd, 0xb5, 0x3f, 0xa1, 0x50, 0xaa, 0x3f, 0xe4, 0x6d, 0xdd, 0xbe, +- 0x0d, 0xce, 0xd3, 0xbe, ++ -0.539592504501343, 1.09590768814087, -0.175970941781998, -0.428507208824158, ++ -0.217120885848999, 1.40129864215851, -0.5855553150177, -0.706146538257599, ++ -0.0620648860931396, -0.543783903121948, -0.649716019630432, 1.06019115447998, ++ -0.726291120052338, -0.488241970539093, -0.526391446590424, 1.01022255420685, ++ -1.04115891456604, 0.0616688691079617, -0.367478042840958, 0.520635366439819, ++ -0.0789390206336975, -0.19111330807209, 1.13497674465179, 0.0277640819549561, ++ 0.974988043308258, -0.553958654403687, 0.412125527858734, -1.2679249048233, ++ -0.0833366513252258, 0.240119814872742, -0.163682132959366, -0.34899115562439, ++ 1.1376188993454, -0.329186379909515, 1.3944765329361, -0.413183152675629, ++ 1.42034828662872, 1.33058559894562, -0.432479023933411, -0.413681417703629 + }}; + const int32_t dnn_hiddenlayer_0_biases_part_0_shape[1] = {10}; + const union { +- uint8_t bytes[40]; + float values[10]; + } dnn_hiddenlayer_0_biases_part_0 = {{ +- 0x00, 0x00, 0x00, 0x00, 0xbf, 0x6a, 0x53, 0x3e, 0xd3, 0xc1, +- 0xd0, 0x3e, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xd8, 0xc0, 0x3e, +- 0xca, 0xe7, 0x35, 0x3e, 0x23, 0xa5, 0x44, 0x3f, 0x61, 0xfd, +- 0xd2, 0x3e, 0x00, 0x00, 0x00, 0x00, 0xb6, 0xe0, 0x43, 0x3c, ++ 0.0, 0.206461891531944, ++ 0.407728761434555, 0.0, ++ 0.376653373241425, 0.177642017602921, ++ 0.76814478635788, 0.412089377641678, ++ 0.0, 0.0119554307311773 + }}; + const int32_t dnn_logits_biases_part_0_shape[1] = {1}; + const union { +- uint8_t bytes[4]; + float values[1]; + } dnn_logits_biases_part_0 = {{ +- 0x75, 0xca, 0xd7, 0xbe, ++ -0.421466499567032 + }}; + const int32_t dnn_logits_weights_part_0_shape[2] = {10, 1}; + const union { +- uint8_t bytes[40]; + float values[10]; + } dnn_logits_weights_part_0 = {{ +- 0x13, 0x12, 0x39, 0x3f, 0xf3, 0xa5, 0xc2, 0xbf, 0x81, 0x7f, +- 0xbe, 0x3f, 0xf8, 0x17, 0x26, 0x3e, 0xa4, 0x19, 0xa6, 0x3f, +- 0xf0, 0xc9, 0xb7, 0xbf, 0x6a, 0x99, 0xd2, 0x3f, 0x8a, 0x7d, +- 0xe9, 0x3f, 0x83, 0x9a, 0x3a, 0xbf, 0xf1, 0x6c, 0x08, 0x3e, ++ 0.722932040691376, -1.52068936824799, ++ 1.48826611042023, 0.162200808525085, ++ 1.29765748977661, -1.43585014343262, ++ 1.64530682563782, 1.82414364814758, ++ -0.728920161724091, 0.133228078484535 + }}; + + } // anonymous namespace Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_heap_asm_BUILD.gn =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_heap_asm_BUILD.gn +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_heap_asm_BUILD.gn @@ -0,0 +1,13 @@ +--- src/3rdparty/chromium/third_party/blink/renderer/platform/heap/asm/BUILD.gn.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/blink/renderer/platform/heap/asm/BUILD.gn +@@ -46,6 +46,10 @@ if (current_cpu == "x86" || current_cpu == "x64") { + sources = [ + "SaveRegisters_mips64.S", + ] ++ } else if (current_cpu == "ppc64") { ++ sources = [ ++ "SaveRegisters_ppc64.S", ++ ] + } + + if (current_cpu == "arm") { Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_heap_asm_SaveRegisters__ppc64.S =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_heap_asm_SaveRegisters__ppc64.S +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_heap_asm_SaveRegisters__ppc64.S @@ -0,0 +1,63 @@ +--- src/3rdparty/chromium/third_party/blink/renderer/platform/heap/asm/SaveRegisters_ppc64.S.orig 2019-10-27 17:23:52 UTC ++++ src/3rdparty/chromium/third_party/blink/renderer/platform/heap/asm/SaveRegisters_ppc64.S +@@ -0,0 +1,60 @@ ++/* ++ * typedef void (*PushAllRegistersCallback)(SafePointBarrier*, ThreadState*, intptr_t*); ++ * extern "C" void PushAllRegisters(SafePointBarrier*, ThreadState*, PushAllRegistersCallback) ++ */ ++ ++.type PushAllRegisters, %function ++.global PushAllRegisters ++.hidden PushAllRegisters ++PushAllRegisters: ++ // Push all callee-saves registers to get them ++ // on the stack for conservative stack scanning. ++ // Reserve space for callee-saved registers and minimal stack frame. ++ mflr 0 # r0 = LR ++ std 0,16(1) # store LR at addr sp+16 ++ stdu 1,-176(1) # grow stack by 176 bytes and store new stack top ptr to r1 ++ # 3218*8 = min stack non-volatile registers ++ ++ // Save the callee-saved registers ++ std 31,168(1) # store r31 to addr sp+168 ++ std 30,160(1) # etc... ++ std 29,152(1) ++ std 28,144(1) ++ std 27,136(1) ++ std 26,128(1) ++ std 25,120(1) ++ std 24,112(1) ++ std 23,104(1) ++ std 22,96(1) ++ std 21,88(1) ++ std 20,80(1) ++ std 19,72(1) ++ std 18,64(1) ++ std 17,56(1) ++ std 16,48(1) ++ std 15,40(1) ++ std 14,32(1) ++ ++ // Note: the callee-saved floating point registers do not need to be ++ // copied to the stack, because fp registers never hold heap pointers ++ // and so do not need to be kept visible to the garbage collector. ++ ++ // Pass the two first arguments untouched in r3 and r4 and the ++ // stack pointer to the callback. ++ ++ std 2, 24(1) # save r2 to sp+24 addr ++ mtctr 5 # copy 3rd function arg (callback fn pointer) to CTR ++ mr 12, 5 # r12 must hold address of callback we are going to call ++ # for position-idependent functions inside the callback to work ++ mr 5, 1 # set current sp (stack top) as 3rd argument for the callback ++ bctrl # set LR to PC+4 and call the callback ++ ld 2, 24(1) # restore r2 from sp+24 addr ++ ++ // Adjust stack, restore return address and return. ++ // Note: the copied registers do not need to be reloaded here, ++ // because they were preserved by the called routine. ++ addi 1,1,176 # restore original SP by doing sp += 176 ++ ld 0,16(1) # restore original LR from addr sp+16 ++ mtlr 0 # ... copy it to the actual LR ++ blr # return to LR addr ++ Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_bmp_bmp__image__reader.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_bmp_bmp__image__reader.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_bmp_bmp__image__reader.h @@ -0,0 +1,24 @@ +--- src/3rdparty/chromium/third_party/blink/renderer/platform/image-decoders/bmp/bmp_image_reader.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/blink/renderer/platform/image-decoders/bmp/bmp_image_reader.h +@@ -37,6 +37,7 @@ + #include "third_party/blink/renderer/platform/wtf/allocator.h" + #include "third_party/blink/renderer/platform/wtf/cpu.h" + #include "third_party/blink/renderer/platform/wtf/noncopyable.h" ++#include "base/sys_byteorder.h" + + namespace blink { + +@@ -50,11 +51,11 @@ class PLATFORM_EXPORT BMPImageReader final { + // Read a value from |buffer|, converting to an int assuming little + // endianness + static inline uint16_t ReadUint16(const char* buffer) { +- return *reinterpret_cast(buffer); ++ return base::ByteSwapToLE16(*reinterpret_cast(buffer)); + } + + static inline uint32_t ReadUint32(const char* buffer) { +- return *reinterpret_cast(buffer); ++ return base::ByteSwapToLE32(*reinterpret_cast(buffer)); + } + + // |parent| is the decoder that owns us. Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_jpeg_jpeg__image__decoder.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_jpeg_jpeg__image__decoder.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_jpeg_jpeg__image__decoder.cc @@ -0,0 +1,40 @@ +--- src/3rdparty/chromium/third_party/blink/renderer/platform/image-decoders/jpeg/jpeg_image_decoder.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/blink/renderer/platform/image-decoders/jpeg/jpeg_image_decoder.cc +@@ -49,23 +49,30 @@ extern "C" { + #include + } + +-#if defined(ARCH_CPU_BIG_ENDIAN) +-#error Blink assumes a little-endian target. +-#endif +- + #if defined(JCS_ALPHA_EXTENSIONS) + #define TURBO_JPEG_RGB_SWIZZLE +-#if SK_B32_SHIFT // Output little-endian RGBA pixels (Android). ++#if SK_PMCOLOR_BYTE_ORDER(R, G, B, A) + inline J_COLOR_SPACE rgbOutputColorSpace() { + return JCS_EXT_RGBA; + } +-#else // Output little-endian BGRA pixels. ++#elif SK_PMCOLOR_BYTE_ORDER(B, G, R, A) + inline J_COLOR_SPACE rgbOutputColorSpace() { + return JCS_EXT_BGRA; + } ++#elif SK_PMCOLOR_BYTE_ORDER(A, R, G, B) ++inline J_COLOR_SPACE rgbOutputColorSpace() { ++ return JCS_EXT_ARGB; ++} ++#elif SK_PMCOLOR_BYTE_ORDER(A, B, G, R) ++inline J_COLOR_SPACE rgbOutputColorSpace() { ++ return JCS_EXT_ABGR; ++} ++#else ++#error Component order not supported by libjpeg_turbo + #endif + inline bool turboSwizzled(J_COLOR_SPACE colorSpace) { +- return colorSpace == JCS_EXT_RGBA || colorSpace == JCS_EXT_BGRA; ++ return colorSpace == JCS_EXT_RGBA || colorSpace == JCS_EXT_BGRA || ++ colorSpace == JCS_EXT_ABGR || colorSpace == JCS_EXT_ARGB; + } + #else + inline J_COLOR_SPACE rgbOutputColorSpace() { Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_webp_webp__image__decoder.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_webp_webp__image__decoder.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_image-decoders_webp_webp__image__decoder.cc @@ -0,0 +1,29 @@ +--- src/3rdparty/chromium/third_party/blink/renderer/platform/image-decoders/webp/webp_image_decoder.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/blink/renderer/platform/image-decoders/webp/webp_image_decoder.cc +@@ -32,18 +32,20 @@ + #include "third_party/blink/renderer/platform/histogram.h" + #include "third_party/skia/include/core/SkData.h" + +-#if defined(ARCH_CPU_BIG_ENDIAN) +-#error Blink assumes a little-endian target. +-#endif +- +-#if SK_B32_SHIFT // Output little-endian RGBA pixels (Android). ++#if SK_PMCOLOR_BYTE_ORDER(R, G, B, A) + inline WEBP_CSP_MODE outputMode(bool hasAlpha) { + return hasAlpha ? MODE_rgbA : MODE_RGBA; + } +-#else // Output little-endian BGRA pixels. ++#elif SK_PMCOLOR_BYTE_ORDER(B, G, R, A) + inline WEBP_CSP_MODE outputMode(bool hasAlpha) { + return hasAlpha ? MODE_bgrA : MODE_BGRA; + } ++#elif SK_PMCOLOR_BYTE_ORDER(A, R, G, B) ++inline WEBP_CSP_MODE outputMode(bool hasAlpha) { ++ return hasAlpha ? MODE_Argb : MODE_ARGB; ++} ++#else ++#error Component order not supported by libwebp + #endif + + namespace { Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_wtf_dtoa_utils.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_wtf_dtoa_utils.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_blink_renderer_platform_wtf_dtoa_utils.h @@ -0,0 +1,11 @@ +--- src/3rdparty/chromium/third_party/blink/renderer/platform/wtf/dtoa/utils.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/blink/renderer/platform/wtf/dtoa/utils.h +@@ -45,7 +45,7 @@ + // disabled.) + // On Linux,x86 89255e-22 != Div_double(89255.0/1e22) + #if defined(_M_X64) || defined(__x86_64__) || defined(__ARMEL__) || \ +- defined(__aarch64__) || defined(__MIPSEL__) ++ defined(__aarch64__) || defined(__MIPSEL__) || defined(__powerpc64__) + #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 + #elif defined(_M_IX86) || defined(__i386__) + #if defined(_WIN32) Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_BUILD.gn =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_BUILD.gn +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_BUILD.gn @@ -1,6 +1,6 @@ ---- src/3rdparty/chromium/third_party/boringssl/BUILD.gn.orig 2018-11-13 18:25:11 UTC -+++ src/3rdparty/chromium/third_party/boringssl/BUILD.gn -@@ -72,7 +72,7 @@ if (is_win && !is_msan) { +--- src/3rdparty/chromium/third_party/boringssl/BUILD.gn.orig 2019-05-23 14:39:34.000000000 +0200 ++++ src/3rdparty/chromium/third_party/boringssl/BUILD.gn 2019-10-29 02:28:30.690043000 +0100 +@@ -71,7 +77,7 @@ } else if (current_cpu == "x64") { if (is_mac) { sources += crypto_sources_mac_x86_64 @@ -9,7 +9,7 @@ sources += crypto_sources_linux_x86_64 } else { public_configs = [ ":no_asm_config" ] -@@ -80,13 +80,13 @@ if (is_win && !is_msan) { +@@ -79,13 +85,13 @@ } else if (current_cpu == "x86") { if (is_mac) { sources += crypto_sources_mac_x86 @@ -25,7 +25,7 @@ sources += crypto_sources_linux_arm } else if (is_ios) { sources += crypto_sources_ios_arm -@@ -94,7 +94,7 @@ if (is_win && !is_msan) { +@@ -93,10 +99,17 @@ public_configs = [ ":no_asm_config" ] } } else if (current_cpu == "arm64") { @@ -34,3 +34,13 @@ sources += crypto_sources_linux_aarch64 } else if (is_ios) { sources += crypto_sources_ios_aarch64 ++ } else { ++ public_configs = [ ":no_asm_config" ] ++ } ++ } else if (current_cpu == "ppc64") { ++ if (is_linux || is_bsd) { ++ # TODO: ppc64 (be) check ++ sources += crypto_sources_linux_ppc64le + } else { + public_configs = [ ":no_asm_config" ] + } Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_asn1_a__int.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_asn1_a__int.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_asn1_a__int.c @@ -0,0 +1,12 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/asn1/a_int.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/asn1/a_int.c +@@ -369,7 +369,9 @@ int ASN1_INTEGER_set_uint64(ASN1_INTEGER *out, uint64_ + + OPENSSL_free(out->data); + out->data = newdata; ++#ifndef OPENSSL_BIGENDIAN + v = CRYPTO_bswap8(v); ++#endif + memcpy(out->data, &v, sizeof(v)); + + out->type = V_ASN1_INTEGER; Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_chacha_chacha.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_chacha_chacha.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_chacha_chacha.c @@ -0,0 +1,77 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/chacha/chacha.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/chacha/chacha.c +@@ -29,6 +29,14 @@ + (((uint32_t)((p)[0])) | ((uint32_t)((p)[1]) << 8) | \ + ((uint32_t)((p)[2]) << 16) | ((uint32_t)((p)[3]) << 24)) + ++#define U32TO8_LITTLE(p, v) \ ++ { \ ++ (p)[0] = (v >> 0) & 0xff; \ ++ (p)[1] = (v >> 8) & 0xff; \ ++ (p)[2] = (v >> 16) & 0xff; \ ++ (p)[3] = (v >> 24) & 0xff; \ ++ } ++ + // sigma contains the ChaCha constants, which happen to be an ASCII string. + static const uint8_t sigma[16] = { 'e', 'x', 'p', 'a', 'n', 'd', ' ', '3', + '2', '-', 'b', 'y', 't', 'e', ' ', 'k' }; +@@ -45,10 +53,28 @@ static const uint8_t sigma[16] = { 'e', 'x', 'p', 'a', + void CRYPTO_hchacha20(uint8_t out[32], const uint8_t key[32], + const uint8_t nonce[16]) { + uint32_t x[16]; +- OPENSSL_memcpy(x, sigma, sizeof(sigma)); +- OPENSSL_memcpy(&x[4], key, 32); +- OPENSSL_memcpy(&x[12], nonce, 16); ++ int i; + ++ x[0] = U8TO32_LITTLE(sigma + 0); ++ x[1] = U8TO32_LITTLE(sigma + 4); ++ x[2] = U8TO32_LITTLE(sigma + 8); ++ x[3] = U8TO32_LITTLE(sigma + 12); ++ ++ x[4] = U8TO32_LITTLE(key + 0); ++ x[5] = U8TO32_LITTLE(key + 4); ++ x[6] = U8TO32_LITTLE(key + 8); ++ x[7] = U8TO32_LITTLE(key + 12); ++ ++ x[8] = U8TO32_LITTLE(key + 16); ++ x[9] = U8TO32_LITTLE(key + 20); ++ x[10] = U8TO32_LITTLE(key + 24); ++ x[11] = U8TO32_LITTLE(key + 28); ++ ++ x[12] = U8TO32_LITTLE(nonce + 0); ++ x[13] = U8TO32_LITTLE(nonce + 4); ++ x[14] = U8TO32_LITTLE(nonce + 8); ++ x[15] = U8TO32_LITTLE(nonce + 12); ++ + for (size_t i = 0; i < 20; i += 2) { + QUARTERROUND(0, 4, 8, 12) + QUARTERROUND(1, 5, 9, 13) +@@ -60,8 +86,10 @@ void CRYPTO_hchacha20(uint8_t out[32], const uint8_t k + QUARTERROUND(3, 4, 9, 14) + } + +- OPENSSL_memcpy(out, &x[0], sizeof(uint32_t) * 4); +- OPENSSL_memcpy(&out[16], &x[12], sizeof(uint32_t) * 4); ++ for (i = 0; i < 4; ++i) { ++ U32TO8_LITTLE(out + 4 * i, x[i]); ++ U32TO8_LITTLE(&out[16] + 4 * i, x[12+i]); ++ } + } + + #if !defined(OPENSSL_NO_ASM) && \ +@@ -104,14 +132,6 @@ void CRYPTO_chacha_20(uint8_t *out, const uint8_t *in, + } + + #else +- +-#define U32TO8_LITTLE(p, v) \ +- { \ +- (p)[0] = (v >> 0) & 0xff; \ +- (p)[1] = (v >> 8) & 0xff; \ +- (p)[2] = (v >> 16) & 0xff; \ +- (p)[3] = (v >> 24) & 0xff; \ +- } + + // chacha_core performs 20 rounds of ChaCha on the input words in + // |input| and writes the 64 output bytes to |output|. Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_cipher__extra_e__aesgcmsiv.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_cipher__extra_e__aesgcmsiv.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_cipher__extra_e__aesgcmsiv.c @@ -0,0 +1,28 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/cipher_extra/e_aesgcmsiv.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/cipher_extra/e_aesgcmsiv.c +@@ -625,7 +625,11 @@ static void gcm_siv_crypt(uint8_t *out, const uint8_t + for (size_t done = 0; done < in_len;) { + uint8_t keystream[AES_BLOCK_SIZE]; + enc_block(counter.c, keystream, key); ++#ifdef OPENSSL_BIGENDIAN ++ counter.w[0] = CRYPTO_bswap4(CRYPTO_bswap4(counter.w[0]) + 1); ++#else + counter.w[0]++; ++#endif + + size_t todo = AES_BLOCK_SIZE; + if (in_len - done < todo) { +@@ -673,8 +677,13 @@ static void gcm_siv_polyval( + } bitlens; + } length_block; + ++#ifdef OPENSSL_BIGENDIAN ++ length_block.bitlens.ad = CRYPTO_bswap8(ad_len * 8); ++ length_block.bitlens.in = CRYPTO_bswap8(in_len * 8); ++#else + length_block.bitlens.ad = ad_len * 8; + length_block.bitlens.in = in_len * 8; ++#endif + CRYPTO_POLYVAL_update_blocks(&polyval_ctx, length_block.c, + sizeof(length_block)); + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_compiler__test.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_compiler__test.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_compiler__test.cc @@ -0,0 +1,17 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/compiler_test.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/compiler_test.cc +@@ -40,9 +40,13 @@ static void CheckRepresentation(T value) { + UnsignedT value_u = static_cast(value); + EXPECT_EQ(sizeof(UnsignedT), sizeof(T)); + +- // Integers must be little-endian. ++ // Integers must be either big-endian or little-endian. + uint8_t expected[sizeof(UnsignedT)]; ++#ifdef OPENSSL_BIGENDIAN ++ for (size_t i = sizeof(UnsignedT); i-- > 0; ) { ++#else + for (size_t i = 0; i < sizeof(UnsignedT); i++) { ++#endif + expected[i] = static_cast(value_u); + // Divide instead of right-shift to appease compilers that warn if |T| is a + // char. The explicit cast is also needed to appease MSVC if integer Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_curve25519_spake25519.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_curve25519_spake25519.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_curve25519_spake25519.c @@ -0,0 +1,36 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/curve25519/spake25519.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/curve25519/spake25519.c +@@ -339,8 +339,17 @@ static void scalar_double(scalar *s) { + uint32_t carry = 0; + + for (size_t i = 0; i < 8; i++) { +- const uint32_t carry_out = s->words[i] >> 31; +- s->words[i] = (s->words[i] << 1) | carry; ++#ifdef OPENSSL_BIGENDIAN ++ const uint32_t si = CRYPTO_bswap4(s->words[i]); ++#else ++ const uint32_t si = s->words[i]; ++#endif ++ const uint32_t carry_out = si >> 31; ++#ifdef OPENSSL_BIGENDIAN ++ s->words[i] = CRYPTO_bswap4((si << 1) | carry); ++#else ++ s->words[i] = (si << 1) | carry; ++#endif + carry = carry_out; + } + } +@@ -350,8 +359,13 @@ static void scalar_add(scalar *dest, const scalar *src + uint32_t carry = 0; + + for (size_t i = 0; i < 8; i++) { ++#ifdef OPENSSL_BIGENDIAN ++ uint64_t tmp = ((uint64_t)CRYPTO_bswap4(dest->words[i]) + CRYPTO_bswap4(src->words[i])) + carry; ++ dest->words[i] = CRYPTO_bswap4((uint32_t)tmp); ++#else + uint64_t tmp = ((uint64_t)dest->words[i] + src->words[i]) + carry; + dest->words[i] = (uint32_t)tmp; ++#endif + carry = (uint32_t)(tmp >> 32); + } + } Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_evp_scrypt.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_evp_scrypt.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_evp_scrypt.c @@ -0,0 +1,30 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/evp/scrypt.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/evp/scrypt.c +@@ -196,9 +196,27 @@ int EVP_PBE_scrypt(const char *password, size_t passwo + goto err; + } + ++#ifdef OPENSSL_BIGENDIAN ++ uint32_t *B32 = B->words; ++ size_t B_words = B_bytes >> 2; ++ do { ++ *B32 = CRYPTO_bswap4(*B32); ++ B32++; ++ } while(--B_words); ++#endif ++ + for (uint64_t i = 0; i < p; i++) { + scryptROMix(B + 2 * r * i, r, N, T, V); + } ++ ++#ifdef OPENSSL_BIGENDIAN ++ B32 = B->words; ++ B_words = B_bytes >> 2; ++ do { ++ *B32 = CRYPTO_bswap4(*B32); ++ B32++; ++ } while(--B_words); ++#endif + + if (!PKCS5_PBKDF2_HMAC(password, password_len, (const uint8_t *)B, B_bytes, 1, + EVP_sha256(), key_len, out_key)) { Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_bn_bytes.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_bn_bytes.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_bn_bytes.c @@ -0,0 +1,64 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/bn/bytes.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/bn/bytes.c +@@ -136,9 +136,13 @@ BIGNUM *BN_le2bn(const uint8_t *in, size_t len, BIGNUM + // Make sure the top bytes will be zeroed. + ret->d[num_words - 1] = 0; + +- // We only support little-endian platforms, so we can simply memcpy the +- // internal representation. ++#ifdef OPENSSL_BIGENDIAN ++ uint8_t *out = (uint8_t *)ret->d; ++ for (size_t i = 0; i < len; i++) ++ out[i ^ (BN_BYTES-1)] = in[i]; ++#else + OPENSSL_memcpy(ret->d, in, len); ++#endif + return ret; + } + +@@ -157,7 +161,11 @@ size_t BN_bn2bin(const BIGNUM *in, uint8_t *out) { + static int fits_in_bytes(const uint8_t *bytes, size_t num_bytes, size_t len) { + uint8_t mask = 0; + for (size_t i = len; i < num_bytes; i++) { ++#ifdef OPENSSL_BIGENDIAN ++ mask |= bytes[i ^ (BN_BYTES-1)]; ++#else + mask |= bytes[i]; ++#endif + } + return mask == 0; + } +@@ -172,9 +180,13 @@ int BN_bn2le_padded(uint8_t *out, size_t len, const BI + num_bytes = len; + } + +- // We only support little-endian platforms, so we can simply memcpy into the +- // internal representation. ++#ifdef OPENSSL_BIGENDIAN ++ for (size_t i = 0; i < num_bytes; i++) { ++ out[i] = bytes[i ^ (BN_BYTES-1)]; ++ } ++#else + OPENSSL_memcpy(out, bytes, num_bytes); ++#endif + // Pad out the rest of the buffer with zeroes. + OPENSSL_memset(out + num_bytes, 0, len - num_bytes); + return 1; +@@ -190,11 +202,15 @@ int BN_bn2bin_padded(uint8_t *out, size_t len, const B + num_bytes = len; + } + +- // We only support little-endian platforms, so we can simply write the buffer +- // in reverse. ++#ifdef OPENSSL_BIGENDIAN + for (size_t i = 0; i < num_bytes; i++) { ++ out[len - i - 1] = bytes[i ^ (BN_BYTES-1)]; ++ } ++#else ++ for (size_t i = 0; i < num_bytes; i++) { + out[len - i - 1] = bytes[i]; + } ++#endif + // Pad out the rest of the buffer with zeroes. + OPENSSL_memset(out, 0, len - num_bytes); + return 1; Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_ecdsa_ecdsa.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_ecdsa_ecdsa.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_ecdsa_ecdsa.c @@ -0,0 +1,14 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/ecdsa/ecdsa.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/ecdsa/ecdsa.c +@@ -80,7 +80,11 @@ static void digest_to_scalar(const EC_GROUP *group, EC + } + OPENSSL_memset(out, 0, sizeof(EC_SCALAR)); + for (size_t i = 0; i < digest_len; i++) { ++#ifdef OPENSSL_BIGENDIAN ++ out->bytes[i ^ (BN_BYTES-1)] = digest[digest_len - 1 - i]; ++#else + out->bytes[i] = digest[digest_len - 1 - i]; ++#endif + } + + // If it is still too long, truncate remaining bits with a shift. Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_gcm.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_gcm.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_gcm.c @@ -0,0 +1,257 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/gcm.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/gcm.c +@@ -78,6 +78,14 @@ + } \ + } while (0) + ++#ifdef OPENSSL_BIGENDIAN ++#define GCM_bswap4(x) (x) ++#define GCM_bswap8(x) (x) ++#else ++#define GCM_bswap4 CRYPTO_bswap4 ++#define GCM_bswap8 CRYPTO_bswap8 ++#endif ++ + // kSizeTWithoutLower4Bits is a mask that can be used to zero the lower four + // bits of a |size_t|. + static const size_t kSizeTWithoutLower4Bits = (size_t) -16; +@@ -173,8 +181,8 @@ static void gcm_gmult_4bit(uint64_t Xi[2], const u128 + Z.lo ^= Htable[nlo].lo; + } + +- Xi[0] = CRYPTO_bswap8(Z.hi); +- Xi[1] = CRYPTO_bswap8(Z.lo); ++ Xi[0] = GCM_bswap8(Z.hi); ++ Xi[1] = GCM_bswap8(Z.lo); + } + + // Streamed gcm_mult_4bit, see CRYPTO_gcm128_[en|de]crypt for +@@ -233,8 +241,8 @@ static void gcm_ghash_4bit(uint64_t Xi[2], const u128 + Z.lo ^= Htable[nlo].lo; + } + +- Xi[0] = CRYPTO_bswap8(Z.hi); +- Xi[1] = CRYPTO_bswap8(Z.lo); ++ Xi[0] = GCM_bswap8(Z.hi); ++ Xi[1] = GCM_bswap8(Z.lo); + } while (inp += 16, len -= 16); + } + #else // GHASH_ASM +@@ -360,8 +368,8 @@ void CRYPTO_ghash_init(gmult_func *out_mult, ghash_fun + OPENSSL_memcpy(H.c, gcm_key, 16); + + // H is stored in host byte order +- H.u[0] = CRYPTO_bswap8(H.u[0]); +- H.u[1] = CRYPTO_bswap8(H.u[1]); ++ H.u[0] = GCM_bswap8(H.u[0]); ++ H.u[1] = GCM_bswap8(H.u[1]); + + OPENSSL_memcpy(out_key, H.c, 16); + +@@ -474,15 +482,15 @@ void CRYPTO_gcm128_setiv(GCM128_CONTEXT *ctx, const AE + GCM_MUL(ctx, Yi); + } + len0 <<= 3; +- ctx->Yi.u[1] ^= CRYPTO_bswap8(len0); ++ ctx->Yi.u[1] ^= GCM_bswap8(len0); + + GCM_MUL(ctx, Yi); +- ctr = CRYPTO_bswap4(ctx->Yi.d[3]); ++ ctr = GCM_bswap4(ctx->Yi.d[3]); + } + + (*ctx->gcm_key.block)(ctx->Yi.c, ctx->EK0.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + } + + int CRYPTO_gcm128_aad(GCM128_CONTEXT *ctx, const uint8_t *aad, size_t len) { +@@ -580,7 +588,7 @@ int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const A + ctx->ares = 0; + } + +- ctr = CRYPTO_bswap4(ctx->Yi.d[3]); ++ ctr = GCM_bswap4(ctx->Yi.d[3]); + + n = ctx->mres; + if (n) { +@@ -602,7 +610,7 @@ int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const A + if (n == 0) { + (*block)(ctx->Yi.c, ctx->EKi.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + } + ctx->Xi.c[n] ^= out[i] = in[i] ^ ctx->EKi.c[n]; + n = (n + 1) % 16; +@@ -621,7 +629,7 @@ int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const A + while (j) { + (*block)(ctx->Yi.c, ctx->EKi.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + for (size_t i = 0; i < 16; i += sizeof(size_t)) { + store_word_le(out + i, + load_word_le(in + i) ^ ctx->EKi.t[i / sizeof(size_t)]); +@@ -638,7 +646,7 @@ int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const A + while (len >= 16) { + (*block)(ctx->Yi.c, ctx->EKi.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + for (size_t i = 0; i < 16; i += sizeof(size_t)) { + store_word_le(out + i, + load_word_le(in + i) ^ ctx->EKi.t[i / sizeof(size_t)]); +@@ -653,7 +661,7 @@ int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const A + while (len >= 16) { + (*block)(ctx->Yi.c, ctx->EKi.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + for (size_t i = 0; i < 16; i += sizeof(size_t)) { + size_t tmp = load_word_le(in + i) ^ ctx->EKi.t[i / sizeof(size_t)]; + store_word_le(out + i, tmp); +@@ -668,7 +676,7 @@ int CRYPTO_gcm128_encrypt(GCM128_CONTEXT *ctx, const A + if (len) { + (*block)(ctx->Yi.c, ctx->EKi.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + while (len--) { + ctx->Xi.c[n] ^= out[n] = in[n] ^ ctx->EKi.c[n]; + ++n; +@@ -707,7 +715,7 @@ int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const A + ctx->ares = 0; + } + +- ctr = CRYPTO_bswap4(ctx->Yi.d[3]); ++ ctr = GCM_bswap4(ctx->Yi.d[3]); + + n = ctx->mres; + if (n) { +@@ -732,7 +740,7 @@ int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const A + if (n == 0) { + (*block)(ctx->Yi.c, ctx->EKi.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + } + c = in[i]; + out[i] = c ^ ctx->EKi.c[n]; +@@ -754,7 +762,7 @@ int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const A + while (j) { + (*block)(ctx->Yi.c, ctx->EKi.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + for (size_t i = 0; i < 16; i += sizeof(size_t)) { + store_word_le(out + i, + load_word_le(in + i) ^ ctx->EKi.t[i / sizeof(size_t)]); +@@ -771,7 +779,7 @@ int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const A + while (len >= 16) { + (*block)(ctx->Yi.c, ctx->EKi.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + for (size_t i = 0; i < 16; i += sizeof(size_t)) { + store_word_le(out + i, + load_word_le(in + i) ^ ctx->EKi.t[i / sizeof(size_t)]); +@@ -785,7 +793,7 @@ int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const A + while (len >= 16) { + (*block)(ctx->Yi.c, ctx->EKi.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + for (size_t i = 0; i < 16; i += sizeof(size_t)) { + size_t c = load_word_le(in + i); + store_word_le(out + i, c ^ ctx->EKi.t[i / sizeof(size_t)]); +@@ -800,7 +808,7 @@ int CRYPTO_gcm128_decrypt(GCM128_CONTEXT *ctx, const A + if (len) { + (*block)(ctx->Yi.c, ctx->EKi.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + while (len--) { + uint8_t c = in[n]; + ctx->Xi.c[n] ^= c; +@@ -866,13 +874,13 @@ int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx, c + } + #endif + +- ctr = CRYPTO_bswap4(ctx->Yi.d[3]); ++ ctr = GCM_bswap4(ctx->Yi.d[3]); + + #if defined(GHASH) + while (len >= GHASH_CHUNK) { + (*stream)(in, out, GHASH_CHUNK / 16, key, ctx->Yi.c); + ctr += GHASH_CHUNK / 16; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + GHASH(ctx, out, GHASH_CHUNK); + out += GHASH_CHUNK; + in += GHASH_CHUNK; +@@ -885,7 +893,7 @@ int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx, c + + (*stream)(in, out, j, key, ctx->Yi.c); + ctr += (unsigned int)j; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + in += i; + len -= i; + #if defined(GHASH) +@@ -904,7 +912,7 @@ int CRYPTO_gcm128_encrypt_ctr32(GCM128_CONTEXT *ctx, c + if (len) { + (*ctx->gcm_key.block)(ctx->Yi.c, ctx->EKi.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + while (len--) { + ctx->Xi.c[n] ^= out[n] = in[n] ^ ctx->EKi.c[n]; + ++n; +@@ -970,14 +978,14 @@ int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx, c + } + #endif + +- ctr = CRYPTO_bswap4(ctx->Yi.d[3]); ++ ctr = GCM_bswap4(ctx->Yi.d[3]); + + #if defined(GHASH) + while (len >= GHASH_CHUNK) { + GHASH(ctx, in, GHASH_CHUNK); + (*stream)(in, out, GHASH_CHUNK / 16, key, ctx->Yi.c); + ctr += GHASH_CHUNK / 16; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + out += GHASH_CHUNK; + in += GHASH_CHUNK; + len -= GHASH_CHUNK; +@@ -1003,7 +1011,7 @@ int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx, c + #endif + (*stream)(in, out, j, key, ctx->Yi.c); + ctr += (unsigned int)j; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + out += i; + in += i; + len -= i; +@@ -1011,7 +1019,7 @@ int CRYPTO_gcm128_decrypt_ctr32(GCM128_CONTEXT *ctx, c + if (len) { + (*ctx->gcm_key.block)(ctx->Yi.c, ctx->EKi.c, key); + ++ctr; +- ctx->Yi.d[3] = CRYPTO_bswap4(ctr); ++ ctx->Yi.d[3] = GCM_bswap4(ctr); + while (len--) { + uint8_t c = in[n]; + ctx->Xi.c[n] ^= c; +@@ -1036,8 +1044,8 @@ int CRYPTO_gcm128_finish(GCM128_CONTEXT *ctx, const ui + GCM_MUL(ctx, Xi); + } + +- alen = CRYPTO_bswap8(alen); +- clen = CRYPTO_bswap8(clen); ++ alen = GCM_bswap8(alen); ++ clen = GCM_bswap8(clen); + + ctx->Xi.u[0] ^= alen; + ctx->Xi.u[1] ^= clen; Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_internal.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_internal.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_internal.h @@ -0,0 +1,20 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/internal.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/internal.h +@@ -70,11 +70,17 @@ extern "C" { + static inline uint32_t GETU32(const void *in) { + uint32_t v; + OPENSSL_memcpy(&v, in, sizeof(v)); ++#ifdef OPENSSL_BIGENDIAN ++ return v; ++#else + return CRYPTO_bswap4(v); ++#endif + } + + static inline void PUTU32(void *out, uint32_t v) { ++#ifndef OPENSSL_BIGENDIAN + v = CRYPTO_bswap4(v); ++#endif + OPENSSL_memcpy(out, &v, sizeof(v)); + } + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_polyval.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_polyval.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_modes_polyval.c @@ -0,0 +1,29 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/polyval.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/modes/polyval.c +@@ -32,16 +32,26 @@ static void byte_reverse(polyval_block *b) { + // the GHASH field, multiplies that by 'x' and serialises the result back into + // |b|, but with GHASH's backwards bit ordering. + static void reverse_and_mulX_ghash(polyval_block *b) { ++#ifdef OPENSSL_BIGENDIAN ++ uint64_t hi = CRYPTO_bswap8(b->u[0]); ++ uint64_t lo = CRYPTO_bswap8(b->u[1]); ++#else + uint64_t hi = b->u[0]; + uint64_t lo = b->u[1]; ++#endif + const crypto_word_t carry = constant_time_eq_w(hi & 1, 1); + hi >>= 1; + hi |= lo << 63; + lo >>= 1; + lo ^= ((uint64_t) constant_time_select_w(carry, 0xe1, 0)) << 56; + ++#ifdef OPENSSL_BIGENDIAN ++ b->u[0] = lo; ++ b->u[1] = hi; ++#else + b->u[0] = CRYPTO_bswap8(lo); + b->u[1] = CRYPTO_bswap8(hi); ++#endif + } + + // POLYVAL(H, X_1, ..., X_n) = Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_rand_ctrdrbg.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_rand_ctrdrbg.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_fipsmodule_rand_ctrdrbg.c @@ -0,0 +1,15 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/rand/ctrdrbg.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/fipsmodule/rand/ctrdrbg.c +@@ -70,8 +70,12 @@ OPENSSL_STATIC_ASSERT(CTR_DRBG_ENTROPY_LEN % AES_BLOCK + // ctr_inc adds |n| to the last four bytes of |drbg->counter|, treated as a + // big-endian number. + static void ctr32_add(CTR_DRBG_STATE *drbg, uint32_t n) { ++#ifdef OPENSSL_BIGENDIAN ++ drbg->counter.words[3] += n; ++#else + drbg->counter.words[3] = + CRYPTO_bswap4(CRYPTO_bswap4(drbg->counter.words[3]) + n); ++#endif + } + + static int ctr_drbg_update(CTR_DRBG_STATE *drbg, const uint8_t *data, Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_poly1305_poly1305.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_poly1305_poly1305.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_crypto_poly1305_poly1305.c @@ -0,0 +1,19 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/crypto/poly1305/poly1305.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/crypto/poly1305/poly1305.c +@@ -32,10 +32,16 @@ + static uint32_t U8TO32_LE(const uint8_t *m) { + uint32_t r; + OPENSSL_memcpy(&r, m, sizeof(r)); ++#ifdef OPENSSL_BIGENDIAN ++ r = CRYPTO_bswap4(r); ++#endif + return r; + } + + static void U32TO8_LE(uint8_t *m, uint32_t v) { ++#ifdef OPENSSL_BIGENDIAN ++ v = CRYPTO_bswap4(v); ++#endif + OPENSSL_memcpy(m, &v, sizeof(v)); + } + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_include_openssl_base.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_include_openssl_base.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_include_openssl_base.h @@ -0,0 +1,17 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/include/openssl/base.h.orig 2019-05-23 14:39:34.000000000 +0200 ++++ src/3rdparty/chromium/third_party/boringssl/src/include/openssl/base.h 2019-10-29 11:49:25.706601000 +0100 +@@ -96,9 +96,13 @@ + #elif defined(__arm) || defined(__arm__) || defined(_M_ARM) + #define OPENSSL_32_BIT + #define OPENSSL_ARM +-#elif (defined(__PPC64__) || defined(__powerpc64__)) && defined(_LITTLE_ENDIAN) ++#elif (defined(__PPC64__) || defined(__powerpc64__)) && defined(__LITTLE_ENDIAN__) + #define OPENSSL_64_BIT + #define OPENSSL_PPC64LE ++#elif (defined(__PPC64__) || defined(__powerpc64__)) ++#define OPENSSL_64_BIT ++#define OPENSSL_PPC64 ++#define OPENSSL_BIGENDIAN + #elif defined(__mips__) && !defined(__LP64__) + #define OPENSSL_32_BIT + #define OPENSSL_MIPS Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_third__party_fiat_curve25519.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_third__party_fiat_curve25519.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_third__party_fiat_curve25519.c @@ -0,0 +1,19 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/third_party/fiat/curve25519.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/third_party/fiat/curve25519.c +@@ -3032,9 +3032,14 @@ int ED25519_verify(const uint8_t *message, size_t mess + UINT64_C(0x1000000000000000), + }; + for (size_t i = 3;; i--) { +- if (scopy.u64[i] > kOrder[i]) { ++#ifdef OPENSSL_BIGENDIAN ++ const uint64_t n = CRYPTO_bswap8(scopy.u64[i]); ++#else ++ const uint64_t n = scopy.u64[i]; ++#endif ++ if (n > kOrder[i]) { + return 0; +- } else if (scopy.u64[i] < kOrder[i]) { ++ } else if (n < kOrder[i]) { + break; + } else if (i == 0) { + return 0; Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_third__party_fiat_p256.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_third__party_fiat_p256.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_boringssl_src_third__party_fiat_p256.c @@ -0,0 +1,51 @@ +--- src/3rdparty/chromium/third_party/boringssl/src/third_party/fiat/p256.c.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/boringssl/src/third_party/fiat/p256.c +@@ -882,12 +882,24 @@ static void fe_tobytes(uint8_t out[NBYTES], const fe i + } + } + ++#ifdef OPENSSL_BIGENDIAN ++static void fe_tobytes_be(uint8_t out[NBYTES], const fe in) { ++ for (int i = 0; i> (8*(i%sizeof(in[0])))); ++ } ++} ++#endif ++ + static void fe_frombytes(fe out, const uint8_t in[NBYTES]) { + for (int i = 0; ibytes, in); ++#else + fe_tobytes(out->bytes, in); ++#endif + } + + // fe_inv calculates |out| = |in|^{-1} +@@ -1524,7 +1540,11 @@ static char get_bit(const uint8_t *in, int i) { + if (i < 0 || i >= 256) { + return 0; + } ++#ifdef OPENSSL_BIGENDIAN ++ return (in[(i >> 3) ^ (sizeof(BN_ULONG)-1)] >> (i & 7)) & 1; ++#else + return (in[i >> 3] >> (i & 7)) & 1; ++#endif + } + + // Interleaved point multiplication using precomputed point multiples: The Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_crc32c_BUILD.gn =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_crc32c_BUILD.gn +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_crc32c_BUILD.gn @@ -0,0 +1,16 @@ +--- src/3rdparty/chromium/third_party/crc32c/BUILD.gn.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/crc32c/BUILD.gn +@@ -15,12 +15,9 @@ config("crc32c_config") { + ] + + defines = [ +- "BYTE_ORDER_BIG_ENDIAN=0", ++ "BYTE_ORDER_BIG_ENDIAN=__BYTE_ORDER__==__ORDER_BIG_ENDIAN__", + "CRC32C_TESTS_BUILT_WITH_GLOG=0", + ] +- +- # If we ever support big-endian builds, add logic to conditionally enable +- # BYTE_ORDER_BIG_ENDIAN. + + if (target_cpu == "x86" || target_cpu == "x64") { + defines += [ Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_flatbuffers_src_include_flatbuffers_base.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_flatbuffers_src_include_flatbuffers_base.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_flatbuffers_src_include_flatbuffers_base.h @@ -0,0 +1,24 @@ +--- src/3rdparty/chromium/third_party/flatbuffers/src/include/flatbuffers/base.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/flatbuffers/src/include/flatbuffers/base.h +@@ -220,18 +220,15 @@ template T EndianSwap(T t) { + if (sizeof(T) == 1) { // Compile-time if-then's. + return t; + } else if (sizeof(T) == 2) { +- union { T t; uint16_t i; } u; +- u.t = t; ++ union U { T t; uint16_t i; U(const T& t_) : t(t_) {}} u(t); + u.i = FLATBUFFERS_BYTESWAP16(u.i); + return u.t; + } else if (sizeof(T) == 4) { +- union { T t; uint32_t i; } u; +- u.t = t; ++ union U { T t; uint32_t i; U(const T& t_) : t(t_) {}} u(t); + u.i = FLATBUFFERS_BYTESWAP32(u.i); + return u.t; + } else if (sizeof(T) == 8) { +- union { T t; uint64_t i; } u; +- u.t = t; ++ union U { T t; uint64_t i; U(const T& t_) : t(t_) {}} u(t); + u.i = FLATBUFFERS_BYTESWAP64(u.i); + return u.t; + } else { Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_flatbuffers_src_include_flatbuffers_minireflect.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_flatbuffers_src_include_flatbuffers_minireflect.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_flatbuffers_src_include_flatbuffers_minireflect.h @@ -0,0 +1,73 @@ +--- src/3rdparty/chromium/third_party/flatbuffers/src/include/flatbuffers/minireflect.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/flatbuffers/src/include/flatbuffers/minireflect.h +@@ -122,58 +122,58 @@ inline void IterateValue(ElementaryType type, const ui + soffset_t vector_index, IterationVisitor *visitor) { + switch (type) { + case ET_UTYPE: { +- auto tval = *reinterpret_cast(val); ++ auto tval = ReadScalar(val); + visitor->UType(tval, EnumName(tval, type_table)); + break; + } + case ET_BOOL: { +- visitor->Bool(*reinterpret_cast(val) != 0); ++ visitor->Bool(ReadScalar(val) != 0); + break; + } + case ET_CHAR: { +- auto tval = *reinterpret_cast(val); ++ auto tval = ReadScalar(val); + visitor->Char(tval, EnumName(tval, type_table)); + break; + } + case ET_UCHAR: { +- auto tval = *reinterpret_cast(val); ++ auto tval = ReadScalar(val); + visitor->UChar(tval, EnumName(tval, type_table)); + break; + } + case ET_SHORT: { +- auto tval = *reinterpret_cast(val); ++ auto tval = ReadScalar(val); + visitor->Short(tval, EnumName(tval, type_table)); + break; + } + case ET_USHORT: { +- auto tval = *reinterpret_cast(val); ++ auto tval = ReadScalar(val); + visitor->UShort(tval, EnumName(tval, type_table)); + break; + } + case ET_INT: { +- auto tval = *reinterpret_cast(val); ++ auto tval = ReadScalar(val); + visitor->Int(tval, EnumName(tval, type_table)); + break; + } + case ET_UINT: { +- auto tval = *reinterpret_cast(val); ++ auto tval = ReadScalar(val); + visitor->UInt(tval, EnumName(tval, type_table)); + break; + } + case ET_LONG: { +- visitor->Long(*reinterpret_cast(val)); ++ visitor->Long(ReadScalar(val)); + break; + } + case ET_ULONG: { +- visitor->ULong(*reinterpret_cast(val)); ++ visitor->ULong(ReadScalar(val)); + break; + } + case ET_FLOAT: { +- visitor->Float(*reinterpret_cast(val)); ++ visitor->Float(ReadScalar(val)); + break; + } + case ET_DOUBLE: { +- visitor->Double(*reinterpret_cast(val)); ++ visitor->Double(ReadScalar(val)); + break; + } + case ET_STRING: { Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_leveldatabase_port_port__chromium.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_leveldatabase_port_port__chromium.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_leveldatabase_port_port__chromium.h @@ -0,0 +1,15 @@ +--- src/3rdparty/chromium/third_party/leveldatabase/port/port_chromium.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/leveldatabase/port/port_chromium.h +@@ -23,8 +23,11 @@ + namespace leveldb { + namespace port { + +-// Chromium only supports little endian. ++#if ARCH_CPU_LITTLE_ENDIAN + static const bool kLittleEndian = true; ++#else ++static const bool kLittleEndian = false; ++#endif + + class LOCKABLE Mutex { + public: Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_BUILD.gn =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_BUILD.gn +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_BUILD.gn @@ -0,0 +1,14 @@ +--- src/3rdparty/chromium/third_party/libpng/BUILD.gn.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/libpng/BUILD.gn +@@ -93,6 +93,11 @@ source_set("libpng_sources") { + "mips/filter_msa_intrinsics.c", + "mips/mips_init.c", + ] ++ } else if (current_cpu == "ppc64") { ++ sources += [ ++ "powerpc/filter_vsx_intrinsics.c", ++ "powerpc/powerpc_init.c", ++ ] + } + + configs -= [ "//build/config/compiler:chromium_code" ] Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_powerpc_filter__vsx__intrinsics.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_powerpc_filter__vsx__intrinsics.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_powerpc_filter__vsx__intrinsics.c @@ -0,0 +1,770 @@ +--- src/3rdparty/chromium/third_party/libpng/powerpc/filter_vsx_intrinsics.c.orig 2019-10-27 17:23:52 UTC ++++ src/3rdparty/chromium/third_party/libpng/powerpc/filter_vsx_intrinsics.c +@@ -0,0 +1,767 @@ ++/* filter_vsx_intrinsics.c - PowerPC optimised filter functions ++ * ++ * Copyright (c) 2017 Glenn Randers-Pehrson ++ * Written by Vadim Barkov, 2017. ++ * Last changed in libpng 1.6.29 [March 16, 2017] ++ * ++ * This code is released under the libpng license. ++ * For conditions of distribution and use, see the disclaimer ++ * and license in png.h ++ */ ++#include ++#include ++#include "../pngpriv.h" ++ ++#ifdef PNG_READ_SUPPORTED ++ ++/* This code requires -maltivec and -mvsx on the command line: */ ++#if PNG_POWERPC_VSX_IMPLEMENTATION == 1 /* intrinsics code from pngpriv.h */ ++ ++#include ++ ++#if PNG_POWERPC_VSX_OPT > 0 ++ ++#ifndef __VSX__ ++# error "This code requires VSX support (POWER7 and later). Please provide -mvsx compiler flag." ++#endif ++ ++#define vec_ld_unaligned(vec,data) vec = vec_vsx_ld(0,data) ++#define vec_st_unaligned(vec,data) vec_vsx_st(vec,0,data) ++ ++ ++/* Functions in this file look at most 3 pixels (a,b,c) to predict the 4th (d). ++ * They're positioned like this: ++ * prev: c b ++ * row: a d ++ * The Sub filter predicts d=a, Avg d=(a+b)/2, and Paeth predicts d to be ++ * whichever of a, b, or c is closest to p=a+b-c. ++ * ( this is taken from ../intel/filter_sse2_intrinsics.c ) ++ */ ++ ++#define vsx_declare_common_vars(row_info,row,prev_row,offset) \ ++ png_byte i;\ ++ png_bytep rp = row + offset;\ ++ png_const_bytep pp = prev_row;\ ++ png_size_t unaligned_top = 16 - (((png_size_t)rp % 16));\ ++ png_size_t istop;\ ++ if(unaligned_top == 16)\ ++ unaligned_top = 0;\ ++ istop = row_info->rowbytes;\ ++ if((unaligned_top < istop))\ ++ istop -= unaligned_top;\ ++ else{\ ++ unaligned_top = istop;\ ++ istop = 0;\ ++ } ++ ++void png_read_filter_row_up_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ vector unsigned char rp_vec; ++ vector unsigned char pp_vec; ++ vsx_declare_common_vars(row_info,row,prev_row,0) ++ ++ /* Altivec operations require 16-byte aligned data ++ * but input can be unaligned. So we calculate ++ * unaligned part as usual. ++ */ ++ for (i = 0; i < unaligned_top; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); ++ rp++; ++ } ++ ++ /* Using SIMD while we can */ ++ while( istop >= 16 ) ++ { ++ rp_vec = vec_ld(0,rp); ++ vec_ld_unaligned(pp_vec,pp); ++ ++ rp_vec = vec_add(rp_vec,pp_vec); ++ ++ vec_st(rp_vec,0,rp); ++ ++ pp += 16; ++ rp += 16; ++ istop -= 16; ++ } ++ ++ if(istop > 0) ++ { ++ /* If byte count of row is not divisible by 16 ++ * we will process remaining part as usual ++ */ ++ for (i = 0; i < istop; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*pp++)) & 0xff); ++ rp++; ++ } ++} ++ ++} ++ ++static const vector unsigned char VSX_LEFTSHIFTED1_4 = {16,16,16,16, 0, 1, 2, 3,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_LEFTSHIFTED2_4 = {16,16,16,16,16,16,16,16, 4, 5, 6, 7,16,16,16,16}; ++static const vector unsigned char VSX_LEFTSHIFTED3_4 = {16,16,16,16,16,16,16,16,16,16,16,16, 8, 9,10,11}; ++ ++static const vector unsigned char VSX_LEFTSHIFTED1_3 = {16,16,16, 0, 1, 2,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_LEFTSHIFTED2_3 = {16,16,16,16,16,16, 3, 4, 5,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_LEFTSHIFTED3_3 = {16,16,16,16,16,16,16,16,16, 6, 7, 8,16,16,16,16}; ++static const vector unsigned char VSX_LEFTSHIFTED4_3 = {16,16,16,16,16,16,16,16,16,16,16,16, 9,10,11,16}; ++ ++static const vector unsigned char VSX_NOT_SHIFTED1_4 = {16,16,16,16, 4, 5, 6, 7,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_NOT_SHIFTED2_4 = {16,16,16,16,16,16,16,16, 8, 9,10,11,16,16,16,16}; ++static const vector unsigned char VSX_NOT_SHIFTED3_4 = {16,16,16,16,16,16,16,16,16,16,16,16,12,13,14,15}; ++ ++static const vector unsigned char VSX_NOT_SHIFTED1_3 = {16,16,16, 3, 4, 5,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_NOT_SHIFTED2_3 = {16,16,16,16,16,16, 6, 7, 8,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_NOT_SHIFTED3_3 = {16,16,16,16,16,16,16,16,16, 9,10,11,16,16,16,16}; ++static const vector unsigned char VSX_NOT_SHIFTED4_3 = {16,16,16,16,16,16,16,16,16,16,16,16,12,13,14,16}; ++ ++static const vector unsigned char VSX_CHAR_ZERO = {0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0}; ++#ifdef __LITTLE_ENDIAN__ ++ ++static const vector unsigned char VSX_CHAR_TO_SHORT1_4 = { 4,16, 5,16, 6,16, 7,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT2_4 = { 8,16, 9,16,10,16,11,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT3_4 = {12,16,13,16,14,16,15,16,16,16,16,16,16,16,16,16}; ++ ++static const vector unsigned char VSX_SHORT_TO_CHAR1_4 = {16,16,16,16, 0, 2, 4, 6,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR2_4 = {16,16,16,16,16,16,16,16, 0, 2, 4, 6,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR3_4 = {16,16,16,16,16,16,16,16,16,16,16,16, 0, 2, 4, 6}; ++ ++static const vector unsigned char VSX_CHAR_TO_SHORT1_3 = { 3,16, 4,16, 5,16,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT2_3 = { 6,16, 7,16, 8,16,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT3_3 = { 9,16,10,16,11,16,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT4_3 = {12,16,13,16,14,16,16,16,16,16,16,16,16,16,16,16}; ++ ++static const vector unsigned char VSX_SHORT_TO_CHAR1_3 = {16,16,16, 0, 2, 4,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR2_3 = {16,16,16,16,16,16, 0, 2, 4,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR3_3 = {16,16,16,16,16,16,16,16,16, 0, 2, 4,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR4_3 = {16,16,16,16,16,16,16,16,16,16,16,16, 0, 2, 4,16}; ++ ++#elif defined(__BIG_ENDIAN__) ++ ++static const vector unsigned char VSX_CHAR_TO_SHORT1_4 = {16, 4,16, 5,16, 6,16, 7,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT2_4 = {16, 8,16, 9,16,10,16,11,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT3_4 = {16,12,16,13,16,14,16,15,16,16,16,16,16,16,16,16}; ++ ++static const vector unsigned char VSX_SHORT_TO_CHAR1_4 = {16,16,16,16, 1, 3, 5, 7,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR2_4 = {16,16,16,16,16,16,16,16, 1, 3, 5, 7,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR3_4 = {16,16,16,16,16,16,16,16,16,16,16,16, 1, 3, 5, 7}; ++ ++static const vector unsigned char VSX_CHAR_TO_SHORT1_3 = {16, 3,16, 4,16, 5,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT2_3 = {16, 6,16, 7,16, 8,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT3_3 = {16, 9,16,10,16,11,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_CHAR_TO_SHORT4_3 = {16,12,16,13,16,14,16,16,16,16,16,16,16,16,16,16}; ++ ++static const vector unsigned char VSX_SHORT_TO_CHAR1_3 = {16,16,16, 1, 3, 5,16,16,16,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR2_3 = {16,16,16,16,16,16, 1, 3, 5,16,16,16,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR3_3 = {16,16,16,16,16,16,16,16,16, 1, 3, 5,16,16,16,16}; ++static const vector unsigned char VSX_SHORT_TO_CHAR4_3 = {16,16,16,16,16,16,16,16,16,16,16,16, 1, 3, 5,16}; ++ ++#endif ++ ++#define vsx_char_to_short(vec,offset,bpp) (vector unsigned short)vec_perm((vec),VSX_CHAR_ZERO,VSX_CHAR_TO_SHORT##offset##_##bpp) ++#define vsx_short_to_char(vec,offset,bpp) vec_perm(((vector unsigned char)(vec)),VSX_CHAR_ZERO,VSX_SHORT_TO_CHAR##offset##_##bpp) ++ ++#ifdef PNG_USE_ABS ++# define vsx_abs(number) abs(number) ++#else ++# define vsx_abs(number) (number > 0) ? (number) : -(number) ++#endif ++ ++void png_read_filter_row_sub4_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ const png_byte bpp = 4; ++ ++ vector unsigned char rp_vec; ++ vector unsigned char part_vec; ++ ++ vsx_declare_common_vars(row_info,row,prev_row,bpp) ++ ++ PNG_UNUSED(pp) ++ ++ /* Altivec operations require 16-byte aligned data ++ * but input can be unaligned. So we calculate ++ * unaligned part as usual. ++ */ ++ for (i = 0; i < unaligned_top; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); ++ rp++; ++ } ++ ++ /* Using SIMD while we can */ ++ while( istop >= 16 ) ++ { ++ for(i=0;i < bpp ; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); ++ rp++; ++ } ++ rp -= bpp; ++ ++ rp_vec = vec_ld(0,rp); ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_4); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_4); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_4); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ vec_st(rp_vec,0,rp); ++ ++ rp += 16; ++ istop -= 16; ++ } ++ ++ if(istop > 0) ++ for (i = 0; i < istop % 16; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp - bpp))) & 0xff); ++ rp++; ++ } ++ ++} ++ ++void png_read_filter_row_sub3_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ const png_byte bpp = 3; ++ ++ vector unsigned char rp_vec; ++ vector unsigned char part_vec; ++ ++ vsx_declare_common_vars(row_info,row,prev_row,bpp) ++ ++ PNG_UNUSED(pp) ++ ++ /* Altivec operations require 16-byte aligned data ++ * but input can be unaligned. So we calculate ++ * unaligned part as usual. ++ */ ++ for (i = 0; i < unaligned_top; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); ++ rp++; ++ } ++ ++ /* Using SIMD while we can */ ++ while( istop >= 16 ) ++ { ++ for(i=0;i < bpp ; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); ++ rp++; ++ } ++ rp -= bpp; ++ ++ rp_vec = vec_ld(0,rp); ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_3); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_3); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_3); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED4_3); ++ rp_vec = vec_add(rp_vec,part_vec); ++ ++ vec_st(rp_vec,0,rp); ++ rp += 15; ++ istop -= 16; ++ ++ /* Since 16 % bpp = 16 % 3 = 1, last element of array must ++ * be proceeded manually ++ */ ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); ++ rp++; ++ } ++ ++ if(istop > 0) ++ for (i = 0; i < istop % 16; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + (int)(*(rp-bpp))) & 0xff); ++ rp++; ++ } ++} ++ ++void png_read_filter_row_avg4_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ const png_byte bpp = 4; ++ ++ vector unsigned char rp_vec; ++ vector unsigned char pp_vec; ++ vector unsigned char pp_part_vec; ++ vector unsigned char rp_part_vec; ++ vector unsigned char avg_vec; ++ ++ vsx_declare_common_vars(row_info,row,prev_row,bpp) ++ rp -= bpp; ++ if(istop >= bpp) ++ istop -= bpp; ++ ++ for (i = 0; i < bpp; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ ((int)(*pp++) / 2 )) & 0xff); ++ ++ rp++; ++ } ++ ++ /* Altivec operations require 16-byte aligned data ++ * but input can be unaligned. So we calculate ++ * unaligned part as usual. ++ */ ++ for (i = 0; i < unaligned_top; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ ++ rp++; ++ } ++ ++ /* Using SIMD while we can */ ++ while( istop >= 16 ) ++ { ++ for(i=0;i < bpp ; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ ++ rp++; ++ } ++ rp -= bpp; ++ pp -= bpp; ++ ++ vec_ld_unaligned(pp_vec,pp); ++ rp_vec = vec_ld(0,rp); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_4); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED1_4); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_4); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED2_4); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_4); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED3_4); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ vec_st(rp_vec,0,rp); ++ ++ rp += 16; ++ pp += 16; ++ istop -= 16; ++ } ++ ++ if(istop > 0) ++ for (i = 0; i < istop % 16; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ ++ rp++; ++ } ++} ++ ++void png_read_filter_row_avg3_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ const png_byte bpp = 3; ++ ++ vector unsigned char rp_vec; ++ vector unsigned char pp_vec; ++ vector unsigned char pp_part_vec; ++ vector unsigned char rp_part_vec; ++ vector unsigned char avg_vec; ++ ++ vsx_declare_common_vars(row_info,row,prev_row,bpp) ++ rp -= bpp; ++ if(istop >= bpp) ++ istop -= bpp; ++ ++ for (i = 0; i < bpp; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ ((int)(*pp++) / 2 )) & 0xff); ++ ++ rp++; ++ } ++ ++ /* Altivec operations require 16-byte aligned data ++ * but input can be unaligned. So we calculate ++ * unaligned part as usual. ++ */ ++ for (i = 0; i < unaligned_top; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ ++ rp++; ++ } ++ ++ /* Using SIMD while we can */ ++ while( istop >= 16 ) ++ { ++ for(i=0;i < bpp ; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ ++ rp++; ++ } ++ rp -= bpp; ++ pp -= bpp; ++ ++ vec_ld_unaligned(pp_vec,pp); ++ rp_vec = vec_ld(0,rp); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED1_3); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED1_3); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED2_3); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED2_3); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED3_3); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED3_3); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ rp_part_vec = vec_perm(rp_vec,VSX_CHAR_ZERO,VSX_LEFTSHIFTED4_3); ++ pp_part_vec = vec_perm(pp_vec,VSX_CHAR_ZERO,VSX_NOT_SHIFTED4_3); ++ avg_vec = vec_avg(rp_part_vec,pp_part_vec); ++ avg_vec = vec_sub(avg_vec, vec_and(vec_xor(rp_part_vec,pp_part_vec),vec_splat_u8(1))); ++ rp_vec = vec_add(rp_vec,avg_vec); ++ ++ vec_st(rp_vec,0,rp); ++ ++ rp += 15; ++ pp += 15; ++ istop -= 16; ++ ++ /* Since 16 % bpp = 16 % 3 = 1, last element of array must ++ * be proceeded manually ++ */ ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ rp++; ++ } ++ ++ if(istop > 0) ++ for (i = 0; i < istop % 16; i++) ++ { ++ *rp = (png_byte)(((int)(*rp) + ++ (int)(*pp++ + *(rp-bpp)) / 2 ) & 0xff); ++ ++ rp++; ++ } ++} ++ ++/* Bytewise c ? t : e. */ ++#define if_then_else(c,t,e) vec_sel(e,t,c) ++ ++#define vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) {\ ++ c = *(pp - bpp);\ ++ a = *(rp - bpp);\ ++ b = *pp++;\ ++ p = b - c;\ ++ pc = a - c;\ ++ pa = vsx_abs(p);\ ++ pb = vsx_abs(pc);\ ++ pc = vsx_abs(p + pc);\ ++ if (pb < pa) pa = pb, a = b;\ ++ if (pc < pa) a = c;\ ++ a += *rp;\ ++ *rp++ = (png_byte)a;\ ++ } ++ ++void png_read_filter_row_paeth4_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ const png_byte bpp = 4; ++ ++ int a, b, c, pa, pb, pc, p; ++ vector unsigned char rp_vec; ++ vector unsigned char pp_vec; ++ vector unsigned short a_vec,b_vec,c_vec,nearest_vec; ++ vector signed short pa_vec,pb_vec,pc_vec,smallest_vec; ++ ++ vsx_declare_common_vars(row_info,row,prev_row,bpp) ++ rp -= bpp; ++ if(istop >= bpp) ++ istop -= bpp; ++ ++ /* Process the first pixel in the row completely (this is the same as 'up' ++ * because there is only one candidate predictor for the first row). ++ */ ++ for(i = 0; i < bpp ; i++) ++ { ++ *rp = (png_byte)( *rp + *pp); ++ rp++; ++ pp++; ++ } ++ ++ for(i = 0; i < unaligned_top ; i++) ++ { ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++ ++ while( istop >= 16) ++ { ++ for(i = 0; i < bpp ; i++) ++ { ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++ ++ rp -= bpp; ++ pp -= bpp; ++ rp_vec = vec_ld(0,rp); ++ vec_ld_unaligned(pp_vec,pp); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_4),1,4); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED1_4),1,4); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_4),1,4); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,1,4))); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_4),2,4); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED2_4),2,4); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_4),2,4); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,2,4))); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_4),3,4); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED3_4),3,4); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_4),3,4); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,3,4))); ++ ++ vec_st(rp_vec,0,rp); ++ ++ rp += 16; ++ pp += 16; ++ istop -= 16; ++ } ++ ++ if(istop > 0) ++ for (i = 0; i < istop % 16; i++) ++ { ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++} ++ ++void png_read_filter_row_paeth3_vsx(png_row_infop row_info, png_bytep row, ++ png_const_bytep prev_row) ++{ ++ const png_byte bpp = 3; ++ ++ int a, b, c, pa, pb, pc, p; ++ vector unsigned char rp_vec; ++ vector unsigned char pp_vec; ++ vector unsigned short a_vec,b_vec,c_vec,nearest_vec; ++ vector signed short pa_vec,pb_vec,pc_vec,smallest_vec; ++ ++ vsx_declare_common_vars(row_info,row,prev_row,bpp) ++ rp -= bpp; ++ if(istop >= bpp) ++ istop -= bpp; ++ ++ /* Process the first pixel in the row completely (this is the same as 'up' ++ * because there is only one candidate predictor for the first row). ++ */ ++ for(i = 0; i < bpp ; i++) ++ { ++ *rp = (png_byte)( *rp + *pp); ++ rp++; ++ pp++; ++ } ++ ++ for(i = 0; i < unaligned_top ; i++) ++ { ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++ ++ while( istop >= 16) ++ { ++ for(i = 0; i < bpp ; i++) ++ { ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++ ++ rp -= bpp; ++ pp -= bpp; ++ rp_vec = vec_ld(0,rp); ++ vec_ld_unaligned(pp_vec,pp); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_3),1,3); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED1_3),1,3); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED1_3),1,3); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,1,3))); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_3),2,3); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED2_3),2,3); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED2_3),2,3); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,2,3))); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_3),3,3); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED3_3),3,3); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED3_3),3,3); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,3,3))); ++ ++ a_vec = vsx_char_to_short(vec_perm(rp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED4_3),4,3); ++ b_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_NOT_SHIFTED4_3),4,3); ++ c_vec = vsx_char_to_short(vec_perm(pp_vec , VSX_CHAR_ZERO , VSX_LEFTSHIFTED4_3),4,3); ++ pa_vec = (vector signed short) vec_sub(b_vec,c_vec); ++ pb_vec = (vector signed short) vec_sub(a_vec , c_vec); ++ pc_vec = vec_add(pa_vec,pb_vec); ++ pa_vec = vec_abs(pa_vec); ++ pb_vec = vec_abs(pb_vec); ++ pc_vec = vec_abs(pc_vec); ++ smallest_vec = vec_min(pc_vec, vec_min(pa_vec,pb_vec)); ++ nearest_vec = if_then_else( ++ vec_cmpeq(pa_vec,smallest_vec), ++ a_vec, ++ if_then_else( ++ vec_cmpeq(pb_vec,smallest_vec), ++ b_vec, ++ c_vec ++ ) ++ ); ++ rp_vec = vec_add(rp_vec,(vsx_short_to_char(nearest_vec,4,3))); ++ ++ vec_st(rp_vec,0,rp); ++ ++ rp += 15; ++ pp += 15; ++ istop -= 16; ++ ++ /* Since 16 % bpp = 16 % 3 = 1, last element of array must ++ * be proceeded manually ++ */ ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++ ++ if(istop > 0) ++ for (i = 0; i < istop % 16; i++) ++ { ++ vsx_paeth_process(rp,pp,a,b,c,pa,pb,pc,bpp) ++ } ++} ++ ++#endif /* PNG_POWERPC_VSX_OPT > 0 */ ++#endif /* PNG_POWERPC_VSX_IMPLEMENTATION == 1 (intrinsics) */ ++#endif /* READ */ Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_powerpc_powerpc__init.c =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_powerpc_powerpc__init.c +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_libpng_powerpc_powerpc__init.c @@ -0,0 +1,128 @@ +--- src/3rdparty/chromium/third_party/libpng/powerpc/powerpc_init.c.orig 2019-10-27 17:23:52 UTC ++++ src/3rdparty/chromium/third_party/libpng/powerpc/powerpc_init.c +@@ -0,0 +1,125 @@ ++ ++/* powerpc_init.c - POWERPC optimised filter functions ++ * ++ * Copyright (c) 2017 Glenn Randers-Pehrson ++ * Written by Vadim Barkov, 2017. ++ * Last changed in libpng 1.6.29 [March 16, 2017] ++ * ++ * This code is released under the libpng license. ++ * For conditions of distribution and use, see the disclaimer ++ * and license in png.h ++ */ ++/* Below, after checking __linux__, various non-C90 POSIX 1003.1 functions are ++ * called. ++ */ ++#define _POSIX_SOURCE 1 ++ ++#include ++#include "../pngpriv.h" ++ ++#ifdef PNG_READ_SUPPORTED ++ ++#if PNG_POWERPC_VSX_OPT > 0 ++#ifdef PNG_POWERPC_VSX_CHECK_SUPPORTED /* Do run-time checks */ ++/* WARNING: it is strongly recommended that you do not build libpng with ++ * run-time checks for CPU features if at all possible. In the case of the PowerPC ++ * VSX instructions there is no processor-specific way of detecting the ++ * presence of the required support, therefore run-time detection is extremely ++ * OS specific. ++ * ++ * You may set the macro PNG_POWERPC_VSX_FILE to the file name of file containing ++ * a fragment of C source code which defines the png_have_vsx function. There ++ * are a number of implementations in contrib/powerpc-vsx, but the only one that ++ * has partial support is contrib/powerpc-vsx/linux.c - a generic Linux ++ * implementation which reads /proc/cpufino. ++ */ ++#ifndef PNG_POWERPC_VSX_FILE ++# ifdef __linux__ ++# define PNG_POWERPC_VSX_FILE "contrib/powerpc-vsx/linux_aux.c" ++# endif ++#endif ++ ++#ifdef PNG_POWERPC_VSX_FILE ++ ++#include /* for sig_atomic_t */ ++static int png_have_vsx(png_structp png_ptr); ++#include PNG_POWERPC_VSX_FILE ++ ++#else /* PNG_POWERPC_VSX_FILE */ ++# error "PNG_POWERPC_VSX_FILE undefined: no support for run-time POWERPC VSX checks" ++#endif /* PNG_POWERPC_VSX_FILE */ ++#endif /* PNG_POWERPC_VSX_CHECK_SUPPORTED */ ++ ++void ++png_init_filter_functions_vsx(png_structp pp, unsigned int bpp) ++{ ++ /* The switch statement is compiled in for POWERPC_VSX_API, the call to ++ * png_have_vsx is compiled in for POWERPC_VSX_CHECK. If both are defined ++ * the check is only performed if the API has not set the PowerPC option on ++ * or off explicitly. In this case the check controls what happens. ++ */ ++ ++#ifdef PNG_POWERPC_VSX_API_SUPPORTED ++ switch ((pp->options >> PNG_POWERPC_VSX) & 3) ++ { ++ case PNG_OPTION_UNSET: ++ /* Allow the run-time check to execute if it has been enabled - ++ * thus both API and CHECK can be turned on. If it isn't supported ++ * this case will fall through to the 'default' below, which just ++ * returns. ++ */ ++#endif /* PNG_POWERPC_VSX_API_SUPPORTED */ ++#ifdef PNG_POWERPC_VSX_CHECK_SUPPORTED ++ { ++ static volatile sig_atomic_t no_vsx = -1; /* not checked */ ++ ++ if (no_vsx < 0) ++ no_vsx = !png_have_vsx(pp); ++ ++ if (no_vsx) ++ return; ++ } ++#ifdef PNG_POWERPC_VSX_API_SUPPORTED ++ break; ++#endif ++#endif /* PNG_POWERPC_VSX_CHECK_SUPPORTED */ ++ ++#ifdef PNG_POWERPC_VSX_API_SUPPORTED ++ default: /* OFF or INVALID */ ++ return; ++ ++ case PNG_OPTION_ON: ++ /* Option turned on */ ++ break; ++ } ++#endif ++ ++ /* IMPORTANT: any new internal functions used here must be declared using ++ * PNG_INTERNAL_FUNCTION in ../pngpriv.h. This is required so that the ++ * 'prefix' option to configure works: ++ * ++ * ./configure --with-libpng-prefix=foobar_ ++ * ++ * Verify you have got this right by running the above command, doing a build ++ * and examining pngprefix.h; it must contain a #define for every external ++ * function you add. (Notice that this happens automatically for the ++ * initialization function.) ++ */ ++ pp->read_filter[PNG_FILTER_VALUE_UP-1] = png_read_filter_row_up_vsx; ++ ++ if (bpp == 3) ++ { ++ pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub3_vsx; ++ pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg3_vsx; ++ pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth3_vsx; ++ } ++ ++ else if (bpp == 4) ++ { ++ pp->read_filter[PNG_FILTER_VALUE_SUB-1] = png_read_filter_row_sub4_vsx; ++ pp->read_filter[PNG_FILTER_VALUE_AVG-1] = png_read_filter_row_avg4_vsx; ++ pp->read_filter[PNG_FILTER_VALUE_PAETH-1] = png_read_filter_row_paeth4_vsx; ++ } ++} ++#endif /* PNG_POWERPC_VSX_OPT > 0 */ ++#endif /* READ */ Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_modp__b64_BUILD.gn =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_modp__b64_BUILD.gn +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_modp__b64_BUILD.gn @@ -0,0 +1,19 @@ +--- src/3rdparty/chromium/third_party/modp_b64/BUILD.gn.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/modp_b64/BUILD.gn +@@ -2,10 +2,16 @@ + # Use of this source code is governed by a BSD-style license that can be + # found in the LICENSE file. + ++import("//build/config/host_byteorder.gni") ++ + static_library("modp_b64") { + sources = [ + "modp_b64.cc", + "modp_b64.h", + "modp_b64_data.h", + ] ++ ++ if (host_byteorder == "big") { ++ defines = [ "WORDS_BIGENDIAN=1" ] ++ } + } Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_modp__b64_modp__b64.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_modp__b64_modp__b64.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_modp__b64_modp__b64.cc @@ -0,0 +1,11 @@ +--- src/3rdparty/chromium/third_party/modp_b64/modp_b64.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/modp_b64/modp_b64.cc +@@ -118,7 +118,7 @@ size_t modp_b64_encode(char* dest, const char* str, si + } + + #ifdef WORDS_BIGENDIAN /* BIG ENDIAN -- SUN / IBM / MOTOROLA */ +-int modp_b64_decode(char* dest, const char* src, int len) ++size_t modp_b64_decode(char* dest, const char* src, size_t len) + { + if (len == 0) return 0; + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_pdfium_third__party_base_allocator_partition__allocator_page__allocator__constants.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_pdfium_third__party_base_allocator_partition__allocator_page__allocator__constants.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_pdfium_third__party_base_allocator_partition__allocator_page__allocator__constants.h @@ -0,0 +1,11 @@ +--- src/3rdparty/chromium/third_party/pdfium/third_party/base/allocator/partition_allocator/page_allocator_constants.h.orig 2019-05-23 14:39:34.000000000 +0200 ++++ src/3rdparty/chromium/third_party/pdfium/third_party/base/allocator/partition_allocator/page_allocator_constants.h 2019-10-29 15:25:35.191867000 +0100 +@@ -13,7 +13,7 @@ + namespace base { + #if defined(OS_WIN) + static constexpr size_t kPageAllocationGranularityShift = 16; // 64KB +-#elif defined(_MIPS_ARCH_LOONGSON) ++#elif defined(_MIPS_ARCH_LOONGSON) || defined(ARCH_CPU_PPC64) + static constexpr size_t kPageAllocationGranularityShift = 14; // 16KB + #else + static constexpr size_t kPageAllocationGranularityShift = 12; // 4KB Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_include_perfetto_base_utils.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_include_perfetto_base_utils.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_include_perfetto_base_utils.h @@ -0,0 +1,19 @@ +--- src/3rdparty/chromium/third_party/perfetto/include/perfetto/base/utils.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/perfetto/include/perfetto/base/utils.h +@@ -22,6 +22,7 @@ + #include + #include + #include ++#include + #if !PERFETTO_BUILDFLAG(PERFETTO_OS_WIN) + #include + #endif +@@ -91,7 +92,7 @@ struct FreeDeleter { + + template + constexpr T AssumeLittleEndian(T value) { +- static_assert(__BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__, ++ static_assert(std::is_same::value && __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__, + "Unimplemented on big-endian archs"); + return value; + } Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_include_perfetto_protozero_message.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_include_perfetto_protozero_message.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_include_perfetto_protozero_message.h @@ -0,0 +1,16 @@ +--- src/3rdparty/chromium/third_party/perfetto/include/perfetto/protozero/message.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/perfetto/include/perfetto/protozero/message.h +@@ -138,6 +138,13 @@ class PERFETTO_EXPORT Message { + + pos = proto_utils::WriteVarInt(proto_utils::MakeTagFixed(field_id), pos); + memcpy(pos, &value, sizeof(T)); ++#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__ ++ for (size_t i = sizeof(T)/2; i--; ) { ++ uint8_t tmp = pos[i]; ++ pos[i] = pos[sizeof(T)-1-i]; ++ pos[sizeof(T)-1-i] = tmp; ++ } ++#endif + pos += sizeof(T); + // TODO: Optimize memcpy performance, see http://crbug.com/624311 . + WriteToStream(buffer, pos); Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_src_protozero_message.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_src_protozero_message.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_src_protozero_message.cc @@ -0,0 +1,15 @@ +--- src/3rdparty/chromium/third_party/perfetto/src/protozero/message.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/perfetto/src/protozero/message.cc +@@ -21,12 +21,6 @@ + #include "perfetto/base/logging.h" + #include "perfetto/protozero/message_handle.h" + +-#if __BYTE_ORDER__ != __ORDER_LITTLE_ENDIAN__ +-// The memcpy() for float and double below needs to be adjusted if we want to +-// support big endian CPUs. There doesn't seem to be a compelling need today. +-#error Unimplemented for big endian archs. +-#endif +- + namespace protozero { + + // static Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_src_protozero_proto__decoder.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_src_protozero_proto__decoder.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_perfetto_src_protozero_proto__decoder.cc @@ -0,0 +1,12 @@ +--- src/3rdparty/chromium/third_party/perfetto/src/protozero/proto_decoder.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/perfetto/src/protozero/proto_decoder.cc +@@ -29,7 +29,8 @@ using namespace proto_utils; + #define BYTE_SWAP_TO_LE32(x) (x) + #define BYTE_SWAP_TO_LE64(x) (x) + #else +-#error Unimplemented for big endian archs. ++#define BYTE_SWAP_TO_LE32(x) __builtin_bswap32(x) ++#define BYTE_SWAP_TO_LE64(x) __builtin_bswap64(x) + #endif + + ProtoDecoder::Field ProtoDecoder::ReadField() { Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_include_core_SkPostConfig.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_include_core_SkPostConfig.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_include_core_SkPostConfig.h @@ -0,0 +1,15 @@ +--- src/3rdparty/chromium/third_party/skia/include/core/SkPostConfig.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/skia/include/core/SkPostConfig.h +@@ -40,12 +40,6 @@ + # error "must define either SK_CPU_LENDIAN or SK_CPU_BENDIAN" + #endif + +-#if defined(SK_CPU_BENDIAN) && !defined(I_ACKNOWLEDGE_SKIA_DOES_NOT_SUPPORT_BIG_ENDIAN) +- #error "The Skia team is not endian-savvy enough to support big-endian CPUs." +- #error "If you still want to use Skia," +- #error "please define I_ACKNOWLEDGE_SKIA_DOES_NOT_SUPPORT_BIG_ENDIAN." +-#endif +- + /** + * Ensure the port has defined all of SK_X32_SHIFT, or none of them. + */ Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_include_private_GrTypesPriv.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_include_private_GrTypesPriv.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_include_private_GrTypesPriv.h @@ -0,0 +1,12 @@ +--- src/3rdparty/chromium/third_party/skia/include/private/GrTypesPriv.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/skia/include/private/GrTypesPriv.h +@@ -65,9 +65,6 @@ enum GrPixelConfig { + static const int kGrPixelConfigCnt = kLast_GrPixelConfig + 1; + + // Aliases for pixel configs that match skia's byte order. +-#ifndef SK_CPU_LENDIAN +-#error "Skia gpu currently assumes little endian" +-#endif + #if SK_PMCOLOR_BYTE_ORDER(B,G,R,A) + static const GrPixelConfig kSkia8888_GrPixelConfig = kBGRA_8888_GrPixelConfig; + #elif SK_PMCOLOR_BYTE_ORDER(R,G,B,A) Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_codec_SkCodecPriv.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_codec_SkCodecPriv.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_codec_SkCodecPriv.h @@ -0,0 +1,10 @@ +--- src/3rdparty/chromium/third_party/skia/src/codec/SkCodecPriv.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/skia/src/codec/SkCodecPriv.h +@@ -14,6 +14,7 @@ + #include "SkEncodedOrigin.h" + #include "SkImageInfo.h" + #include "SkTypes.h" ++#include "SkEndian.h" + + #ifdef SK_PRINT_CODEC_MESSAGES + #define SkCodecPrintf SkDebugf Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_core_SkColor.cpp =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_core_SkColor.cpp +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_core_SkColor.cpp @@ -0,0 +1,34 @@ +--- src/3rdparty/chromium/third_party/skia/src/core/SkColor.cpp.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/skia/src/core/SkColor.cpp +@@ -108,13 +108,29 @@ SkColor SkHSVToColor(U8CPU a, const SkScalar hsv[3]) { + template <> + SkColor4f SkColor4f::FromColor(SkColor bgra) { + SkColor4f rgba; +- swizzle_rb(Sk4f_fromL32(bgra)).store(rgba.vec()); ++ Sk4f c4f = Sk4f_fromL32(bgra); ++#ifdef SK_CPU_BENDIAN ++ // ARGB -> RGBA ++ c4f = SkNx_shuffle<1, 2, 3, 0>(c4f); ++#else ++ // BGRA -> RGBA ++ c4f = swizzle_rb(c4f); ++#endif ++ c4f.store(rgba.vec()); + return rgba; + } + + template <> + SkColor SkColor4f::toSkColor() const { +- return Sk4f_toL32(swizzle_rb(Sk4f::Load(this->vec()))); ++ Sk4f c4f = Sk4f::Load(this->vec()); ++#ifdef SK_CPU_BENDIAN ++ // RGBA -> ARGB ++ c4f = SkNx_shuffle<3, 0, 1, 2>(c4f); ++#else ++ // RGBA -> BGRA ++ c4f = swizzle_rb(c4f); ++#endif ++ return Sk4f_toL32(c4f); + } + + template <> Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_core_SkPixmap.cpp =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_core_SkPixmap.cpp +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_core_SkPixmap.cpp @@ -0,0 +1,12 @@ +--- src/3rdparty/chromium/third_party/skia/src/core/SkPixmap.cpp.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/skia/src/core/SkPixmap.cpp +@@ -246,7 +246,8 @@ SkColor SkPixmap::getColor(int x, int y) const { + const bool needsUnpremul = (kPremul_SkAlphaType == fInfo.alphaType()); + auto toColor = [needsUnpremul](uint32_t maybePremulColor) { + return needsUnpremul ? SkUnPreMultiply::PMColorToColor(maybePremulColor) +- : SkSwizzle_BGRA_to_PMColor(maybePremulColor); ++ : SkColorSetARGB(SkGetPackedA32(maybePremulColor), SkGetPackedR32(maybePremulColor), ++ SkGetPackedG32(maybePremulColor), SkGetPackedB32(maybePremulColor)); + }; + + switch (this->colorType()) { Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_Sk4px__none.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_Sk4px__none.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_Sk4px__none.h @@ -0,0 +1,10 @@ +--- src/3rdparty/chromium/third_party/skia/src/opts/Sk4px_none.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/skia/src/opts/Sk4px_none.h +@@ -35,7 +35,6 @@ inline Sk4px Sk4px::Wide::div255() const { + } + + inline Sk4px Sk4px::alphas() const { +- static_assert(SK_A32_SHIFT == 24, "This method assumes little-endian."); + return Sk16b((*this)[ 3], (*this)[ 3], (*this)[ 3], (*this)[ 3], + (*this)[ 7], (*this)[ 7], (*this)[ 7], (*this)[ 7], + (*this)[11], (*this)[11], (*this)[11], (*this)[11], Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_SkBlitRow__opts.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_SkBlitRow__opts.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_SkBlitRow__opts.h @@ -0,0 +1,13 @@ +--- src/3rdparty/chromium/third_party/skia/src/opts/SkBlitRow_opts.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/skia/src/opts/SkBlitRow_opts.h +@@ -237,8 +237,8 @@ void blit_row_s32a_opaque(SkPMColor* dst, const SkPMCo + // with chromium:611002 we need to keep it until we figure out where + // the non-premultiplied src values (like 0x00FFFFFF) are coming from. + // TODO(mtklein): sort this out and assert *src is premul here. +- if (*src & 0xFF000000) { +- *dst = (*src >= 0xFF000000) ? *src : SkPMSrcOver(*src, *dst); ++ if (*src & (0xFF << SK_A32_SHIFT)) { ++ *dst = ((*src << (24 - SK_A32_SHIFT)) >= 0xFF000000) ? *src : SkPMSrcOver(*src, *dst); + } + src++; + dst++; Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_SkRasterPipeline__opts.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_SkRasterPipeline__opts.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_opts_SkRasterPipeline__opts.h @@ -1,4 +1,4 @@ ---- src/3rdparty/chromium/third_party/skia/src/opts/SkRasterPipeline_opts.h.orig 2019-05-23 12:39:34 UTC +--- src/3rdparty/chromium/third_party/skia/src/opts/SkRasterPipeline_opts.h.orig 2019-10-27 17:19:53 UTC +++ src/3rdparty/chromium/third_party/skia/src/opts/SkRasterPipeline_opts.h @@ -729,7 +729,10 @@ SI F approx_powf(F x, F y) { } @@ -24,3 +24,107 @@ __fp16 fp16 = __fp16(f); U16 u16; memcpy(&u16, &fp16, sizeof(U16)); +@@ -954,10 +954,17 @@ SI void from_4444(U16 _4444, F* r, F* g, F* b, F* a) { + *a = cast(wide & (15<< 0)) * (1.0f / (15<< 0)); + } + SI void from_8888(U32 _8888, F* r, F* g, F* b, F* a) { ++#ifdef SK_CPU_BENDIAN ++ *r = cast((_8888 >> 24) ) * (1/255.0f); ++ *g = cast((_8888 >> 16) & 0xff) * (1/255.0f); ++ *b = cast((_8888 >> 8) & 0xff) * (1/255.0f); ++ *a = cast((_8888 ) & 0xff) * (1/255.0f); ++#else + *r = cast((_8888 ) & 0xff) * (1/255.0f); + *g = cast((_8888 >> 8) & 0xff) * (1/255.0f); + *b = cast((_8888 >> 16) & 0xff) * (1/255.0f); + *a = cast((_8888 >> 24) ) * (1/255.0f); ++#endif + } + SI void from_1010102(U32 rgba, F* r, F* g, F* b, F* a) { + *r = cast((rgba ) & 0x3ff) * (1/1023.0f); +@@ -1284,10 +1291,17 @@ STAGE(srcover_rgba_8888, const SkRasterPipeline_Memory + auto ptr = ptr_at_xy(ctx, dx,dy); + + U32 dst = load(ptr, tail); ++#ifdef SK_CPU_BENDIAN ++ dr = cast((dst >> 24) ); ++ dg = cast((dst >> 16) & 0xff); ++ db = cast((dst >> 8) & 0xff); ++ da = cast((dst ) & 0xff); ++#else + dr = cast((dst ) & 0xff); + dg = cast((dst >> 8) & 0xff); + db = cast((dst >> 16) & 0xff); + da = cast((dst >> 24) ); ++#endif + // {dr,dg,db,da} are in [0,255] + // { r, g, b, a} are in [0, 1] (but may be out of gamut) + +@@ -1298,10 +1312,17 @@ STAGE(srcover_rgba_8888, const SkRasterPipeline_Memory + // { r, g, b, a} are now in [0,255] (but may be out of gamut) + + // to_unorm() clamps back to gamut. Scaling by 1 since we're already 255-biased. ++#ifdef SK_CPU_BENDIAN ++ dst = to_unorm(r, 1, 255) << 24 ++ | to_unorm(g, 1, 255) << 16 ++ | to_unorm(b, 1, 255) << 8 ++ | to_unorm(a, 1, 255); ++#else + dst = to_unorm(r, 1, 255) + | to_unorm(g, 1, 255) << 8 + | to_unorm(b, 1, 255) << 16 + | to_unorm(a, 1, 255) << 24; ++#endif + store(ptr, dst, tail); + } + +@@ -1700,10 +1721,17 @@ STAGE(gather_8888, const SkRasterPipeline_GatherCtx* c + STAGE(store_8888, const SkRasterPipeline_MemoryCtx* ctx) { + auto ptr = ptr_at_xy(ctx, dx,dy); + ++#ifdef SK_CPU_BENDIAN ++ U32 px = to_unorm(r, 255) << 24 ++ | to_unorm(g, 255) << 16 ++ | to_unorm(b, 255) << 8 ++ | to_unorm(a, 255); ++#else + U32 px = to_unorm(r, 255) + | to_unorm(g, 255) << 8 + | to_unorm(b, 255) << 16 + | to_unorm(a, 255) << 24; ++#endif + store(ptr, px, tail); + } + +@@ -2858,10 +2886,17 @@ SI void from_8888(U32 rgba, U16* r, U16* g, U16* b, U1 + return cast(v); + }; + #endif ++#ifdef SK_CPU_BENDIAN ++ *r = cast_U16(rgba >> 16) >> 8; ++ *g = cast_U16(rgba >> 16) & 255; ++ *b = cast_U16(rgba & 65535) >> 8; ++ *a = cast_U16(rgba & 65535) & 255; ++#else + *r = cast_U16(rgba & 65535) & 255; + *g = cast_U16(rgba & 65535) >> 8; + *b = cast_U16(rgba >> 16) & 255; + *a = cast_U16(rgba >> 16) >> 8; ++#endif + } + + SI void load_8888_(const uint32_t* ptr, size_t tail, U16* r, U16* g, U16* b, U16* a) { +@@ -2904,8 +2939,13 @@ SI void store_8888_(uint32_t* ptr, size_t tail, U16 r, + case 1: vst4_lane_u8((uint8_t*)(ptr+0), rgba, 0); + } + #else ++#ifdef SK_CPU_BENDIAN ++ store(ptr, tail, cast((r<<8) | g) << 16 ++ | cast((b<<8) | a) << 0); ++#else + store(ptr, tail, cast(r | (g<<8)) << 0 + | cast(b | (a<<8)) << 16); ++#endif + #endif + } + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_utils_SkJSON.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_utils_SkJSON.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_utils_SkJSON.h @@ -0,0 +1,51 @@ +--- src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.h +@@ -120,6 +120,7 @@ class alignas(8) Value { (protected) + -- highest 3 bits reserved for type storage + + */ ++#if defined(SK_CPU_LENDIAN) + enum class Tag : uint8_t { + // We picked kShortString == 0 so that tag 0x00 and stored max_size-size (7-7=0) + // conveniently overlap the '\0' terminator, allowing us to store a 7 character +@@ -134,6 +135,22 @@ class alignas(8) Value { (protected) + kObject = 0b11100000, // ptr to external storage + }; + static constexpr uint8_t kTagMask = 0b11100000; ++#else ++ enum class Tag : uint8_t { ++ // We picked kShortString == 0 so that tag 0x00 and stored max_size-size (7-7=0) ++ // conveniently overlap the '\0' terminator, allowing us to store a 7 character ++ // C string inline. ++ kShortString = 0b00000000, // inline payload ++ kNull = 0b00000001, // no payload ++ kBool = 0b00000010, // inline payload ++ kInt = 0b00000011, // inline payload ++ kFloat = 0b00000100, // inline payload ++ kString = 0b00000101, // ptr to external storage ++ kArray = 0b00000110, // ptr to external storage ++ kObject = 0b00000111, // ptr to external storage ++ }; ++ static constexpr uint8_t kTagMask = 0b00000111; ++#endif + + void init_tagged(Tag); + void init_tagged_pointer(Tag, void*); +@@ -192,14 +209,14 @@ class alignas(8) Value { (protected) + + uint8_t fData8[kValueSize]; + +-#if defined(SK_CPU_LENDIAN) + static constexpr size_t kTagOffset = kValueSize - 1; + ++#if defined(SK_CPU_LENDIAN) + static constexpr uintptr_t kTagPointerMask = + ~(static_cast(kTagMask) << ((sizeof(uintptr_t) - 1) * 8)); + #else +- // The current value layout assumes LE and will take some tweaking for BE. +- static_assert(false, "Big-endian builds are not supported at this time."); ++ static constexpr uintptr_t kTagPointerMask = ++ ~static_cast(kTagMask); + #endif + }; + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_utils_SkJSON.cpp =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_utils_SkJSON.cpp +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_src_utils_SkJSON.cpp @@ -0,0 +1,22 @@ +--- src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.cpp.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/skia/src/utils/SkJSON.cpp +@@ -34,6 +34,10 @@ void Value::init_tagged(Tag t) { + + // Pointer values store a type (in the upper kTagBits bits) and a pointer. + void Value::init_tagged_pointer(Tag t, void* p) { ++#if !defined(SK_CPU_LENDIAN) ++ // Check that kRecAlign is large enough to leave room for the tag ++ static_assert(sizeof(Value) > sizeof(uintptr_t) || !(kRecAlign & Value::kTagMask), "kRecAlign is not a multiple of kTagMask+1"); ++#endif + *this->cast() = reinterpret_cast(p); + + if (sizeof(Value) == sizeof(uintptr_t)) { +@@ -169,7 +173,7 @@ class FastString final : public Value { (private) + #if defined(SK_CPU_LENDIAN) + *s64 &= 0x00ffffffffffffffULL >> ((kMaxInlineStringSize - size) * 8); + #else +- static_assert(false, "Big-endian builds are not supported at this time."); ++ *s64 &= 0xffffffffffffff00ULL << ((kMaxInlineStringSize - size) * 8); + #endif + } + }; Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_third__party_skcms_skcms.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_third__party_skcms_skcms.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_third__party_skcms_skcms.cc @@ -0,0 +1,47 @@ +--- src/3rdparty/chromium/third_party/skia/third_party/skcms/skcms.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/skia/third_party/skcms/skcms.cc +@@ -66,10 +66,15 @@ static float eval_curve(const skcms_Curve* curve, floa + uint16_t be_l, be_h; + memcpy(&be_l, curve->table_16 + 2*lo, 2); + memcpy(&be_h, curve->table_16 + 2*hi, 2); ++#if __BIG_ENDIAN__ ++ l = be_l * (1/65535.0f); ++ h = be_h * (1/65535.0f); ++#else + uint16_t le_l = ((be_l << 8) | (be_l >> 8)) & 0xffff; + uint16_t le_h = ((be_h << 8) | (be_h >> 8)) & 0xffff; + l = le_l * (1/65535.0f); + h = le_h * (1/65535.0f); ++#endif + } + return l + (h-l)*t; + } +@@ -124,20 +129,28 @@ enum { + static uint16_t read_big_u16(const uint8_t* ptr) { + uint16_t be; + memcpy(&be, ptr, sizeof(be)); ++#if __BIG_ENDIAN__ ++ return be; ++#else + #if defined(_MSC_VER) + return _byteswap_ushort(be); + #else + return __builtin_bswap16(be); + #endif ++#endif + } + + static uint32_t read_big_u32(const uint8_t* ptr) { + uint32_t be; + memcpy(&be, ptr, sizeof(be)); ++#if __BIG_ENDIAN__ ++ return be; ++#else + #if defined(_MSC_VER) + return _byteswap_ulong(be); + #else + return __builtin_bswap32(be); ++#endif + #endif + } + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_third__party_skcms_src_Transform__inl.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_third__party_skcms_src_Transform__inl.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_skia_third__party_skcms_src_Transform__inl.h @@ -0,0 +1,400 @@ +--- src/3rdparty/chromium/third_party/skia/third_party/skcms/src/Transform_inl.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/skia/third_party/skcms/src/Transform_inl.h +@@ -392,9 +392,11 @@ SI U32 gather_32(const uint8_t* p, I32 ix) { + } + + SI U32 gather_24(const uint8_t* p, I32 ix) { ++#if !__BIG_ENDIAN__ + // First, back up a byte. Any place we're gathering from has a safe junk byte to read + // in front of it, either a previous table value, or some tag metadata. + p -= 1; ++#endif + + // Load the i'th 24-bit value from p, and 1 extra byte. + auto load_24_32 = [p](int i) { +@@ -435,8 +437,10 @@ SI U32 gather_24(const uint8_t* p, I32 ix) { + + #if !defined(__arm__) + SI void gather_48(const uint8_t* p, I32 ix, U64* v) { ++#if !__BIG_ENDIAN__ + // As in gather_24(), with everything doubled. + p -= 2; ++#endif + + // Load the i'th 48-bit value from p, and 2 extra bytes. + auto load_48_64 = [p](int i) { +@@ -499,7 +503,9 @@ SI F F_from_U8(U8 v) { + SI F F_from_U16_BE(U16 v) { + // All 16-bit ICC values are big-endian, so we byte swap before converting to float. + // MSVC catches the "loss" of data here in the portable path, so we also make sure to mask. ++#if !__BIG_ENDIAN__ + v = U16( 0 | ((v & 0x00ff) << 8) | ((v & 0xff00) >> 8) ); ++#endif + return cast(v) * (1/65535.0f); + } + +@@ -534,9 +540,15 @@ SI F table(const skcms_Curve* curve, F v) { + SI void sample_clut_8(const skcms_A2B* a2b, I32 ix, F* r, F* g, F* b) { + U32 rgb = gather_24(a2b->grid_8, ix); + ++#if __BIG_ENDIAN__ ++ *r = cast((rgb >> 16) & 0xff) * (1/255.0f); ++ *g = cast((rgb >> 8) & 0xff) * (1/255.0f); ++ *b = cast((rgb >> 0) & 0xff) * (1/255.0f); ++#else + *r = cast((rgb >> 0) & 0xff) * (1/255.0f); + *g = cast((rgb >> 8) & 0xff) * (1/255.0f); + *b = cast((rgb >> 16) & 0xff) * (1/255.0f); ++#endif + } + + SI void sample_clut_16(const skcms_A2B* a2b, I32 ix, F* r, F* g, F* b) { +@@ -549,12 +561,18 @@ SI void sample_clut_16(const skcms_A2B* a2b, I32 ix, F + // This strategy is much faster for 64-bit builds, and fine for 32-bit x86 too. + U64 rgb; + gather_48(a2b->grid_16, ix, &rgb); ++#if __BIG_ENDIAN__ ++ *r = cast((rgb >> 32) & 0xffff) * (1/65535.0f); ++ *g = cast((rgb >> 16) & 0xffff) * (1/65535.0f); ++ *b = cast((rgb >> 0) & 0xffff) * (1/65535.0f); ++#else + rgb = swap_endian_16x4(rgb); + + *r = cast((rgb >> 0) & 0xffff) * (1/65535.0f); + *g = cast((rgb >> 16) & 0xffff) * (1/65535.0f); + *b = cast((rgb >> 32) & 0xffff) * (1/65535.0f); + #endif ++#endif + } + + // GCC 7.2.0 hits an internal compiler error with -finline-functions (or -O3) +@@ -695,10 +713,17 @@ static void exec_ops(const Op* ops, const void** args, + case Op_load_8888:{ + U32 rgba = load(src + 4*i); + ++#if __BIG_ENDIAN__ ++ r = cast((rgba >> 24) & 0xff) * (1/255.0f); ++ g = cast((rgba >> 16) & 0xff) * (1/255.0f); ++ b = cast((rgba >> 8) & 0xff) * (1/255.0f); ++ a = cast((rgba >> 0) & 0xff) * (1/255.0f); ++#else + r = cast((rgba >> 0) & 0xff) * (1/255.0f); + g = cast((rgba >> 8) & 0xff) * (1/255.0f); + b = cast((rgba >> 16) & 0xff) * (1/255.0f); + a = cast((rgba >> 24) & 0xff) * (1/255.0f); ++#endif + } break; + + case Op_load_8888_palette8:{ +@@ -727,13 +752,29 @@ static void exec_ops(const Op* ops, const void** args, + const uint16_t* rgb = (const uint16_t*)ptr; // cast to const uint16_t* to be safe. + #if defined(USING_NEON) + uint16x4x3_t v = vld3_u16(rgb); ++#if __BIG_ENDIAN__ ++ r = cast(swap_endian_16((U16)v.val[0])) * (1/65535.0f); ++ g = cast(swap_endian_16((U16)v.val[1])) * (1/65535.0f); ++ b = cast(swap_endian_16((U16)v.val[2])) * (1/65535.0f); ++#else + r = cast((U16)v.val[0]) * (1/65535.0f); + g = cast((U16)v.val[1]) * (1/65535.0f); + b = cast((U16)v.val[2]) * (1/65535.0f); ++#endif + #else ++#if __BIG_ENDIAN__ ++ U32 R = load_3(rgb+0), ++ G = load_3(rgb+1), ++ B = load_3(rgb+2); ++ // R,G,B are little-endian 16-bit, so byte swap them before converting to float. ++ r = cast((R & 0x00ff)<<8 | (R & 0xff00)>>8) * (1/65535.0f); ++ g = cast((G & 0x00ff)<<8 | (G & 0xff00)>>8) * (1/65535.0f); ++ b = cast((B & 0x00ff)<<8 | (B & 0xff00)>>8) * (1/65535.0f); ++#else + r = cast(load_3(rgb+0)) * (1/65535.0f); + g = cast(load_3(rgb+1)) * (1/65535.0f); + b = cast(load_3(rgb+2)) * (1/65535.0f); ++#endif + #endif + } break; + +@@ -743,17 +784,33 @@ static void exec_ops(const Op* ops, const void** args, + const uint16_t* rgba = (const uint16_t*)ptr; // cast to const uint16_t* to be safe. + #if defined(USING_NEON) + uint16x4x4_t v = vld4_u16(rgba); ++#if __BIG_ENDIAN__ ++ r = cast(swap_endian_16((U16)v.val[0])) * (1/65535.0f); ++ g = cast(swap_endian_16((U16)v.val[1])) * (1/65535.0f); ++ b = cast(swap_endian_16((U16)v.val[2])) * (1/65535.0f); ++ a = cast(swap_endian_16((U16)v.val[3])) * (1/65535.0f); ++#else + r = cast((U16)v.val[0]) * (1/65535.0f); + g = cast((U16)v.val[1]) * (1/65535.0f); + b = cast((U16)v.val[2]) * (1/65535.0f); + a = cast((U16)v.val[3]) * (1/65535.0f); ++#endif + #else ++#if __BIG_ENDIAN__ ++ U64 px = swap_endian_16x4(load(rgba)); ++ ++ r = cast((px >> 48) & 0xffff) * (1/65535.0f); ++ g = cast((px >> 32) & 0xffff) * (1/65535.0f); ++ b = cast((px >> 16) & 0xffff) * (1/65535.0f); ++ a = cast((px >> 0) & 0xffff) * (1/65535.0f); ++#else + U64 px = load(rgba); + + r = cast((px >> 0) & 0xffff) * (1/65535.0f); + g = cast((px >> 16) & 0xffff) * (1/65535.0f); + b = cast((px >> 32) & 0xffff) * (1/65535.0f); + a = cast((px >> 48) & 0xffff) * (1/65535.0f); ++#endif + #endif + } break; + +@@ -763,10 +820,21 @@ static void exec_ops(const Op* ops, const void** args, + const uint16_t* rgb = (const uint16_t*)ptr; // cast to const uint16_t* to be safe. + #if defined(USING_NEON) + uint16x4x3_t v = vld3_u16(rgb); ++#if __BIG_ENDIAN__ ++ r = cast((U16)v.val[0]) * (1/65535.0f); ++ g = cast((U16)v.val[1]) * (1/65535.0f); ++ b = cast((U16)v.val[2]) * (1/65535.0f); ++#else + r = cast(swap_endian_16((U16)v.val[0])) * (1/65535.0f); + g = cast(swap_endian_16((U16)v.val[1])) * (1/65535.0f); + b = cast(swap_endian_16((U16)v.val[2])) * (1/65535.0f); ++#endif + #else ++#if __BIG_ENDIAN__ ++ r = cast(load_3(rgb+0)) * (1/65535.0f); ++ g = cast(load_3(rgb+1)) * (1/65535.0f); ++ b = cast(load_3(rgb+2)) * (1/65535.0f); ++#else + U32 R = load_3(rgb+0), + G = load_3(rgb+1), + B = load_3(rgb+2); +@@ -774,6 +842,7 @@ static void exec_ops(const Op* ops, const void** args, + r = cast((R & 0x00ff)<<8 | (R & 0xff00)>>8) * (1/65535.0f); + g = cast((G & 0x00ff)<<8 | (G & 0xff00)>>8) * (1/65535.0f); + b = cast((B & 0x00ff)<<8 | (B & 0xff00)>>8) * (1/65535.0f); ++#endif + #endif + } break; + +@@ -783,17 +852,33 @@ static void exec_ops(const Op* ops, const void** args, + const uint16_t* rgba = (const uint16_t*)ptr; // cast to const uint16_t* to be safe. + #if defined(USING_NEON) + uint16x4x4_t v = vld4_u16(rgba); ++#if __BIG_ENDIAN__ ++ r = cast((U16)v.val[0]) * (1/65535.0f); ++ g = cast((U16)v.val[1]) * (1/65535.0f); ++ b = cast((U16)v.val[2]) * (1/65535.0f); ++ a = cast((U16)v.val[3]) * (1/65535.0f); ++#else + r = cast(swap_endian_16((U16)v.val[0])) * (1/65535.0f); + g = cast(swap_endian_16((U16)v.val[1])) * (1/65535.0f); + b = cast(swap_endian_16((U16)v.val[2])) * (1/65535.0f); + a = cast(swap_endian_16((U16)v.val[3])) * (1/65535.0f); ++#endif + #else ++#if __BIG_ENDIAN__ ++ U64 px = load(rgba); ++ ++ r = cast((px >> 48) & 0xffff) * (1/65535.0f); ++ g = cast((px >> 32) & 0xffff) * (1/65535.0f); ++ b = cast((px >> 16) & 0xffff) * (1/65535.0f); ++ a = cast((px >> 0) & 0xffff) * (1/65535.0f); ++#else + U64 px = swap_endian_16x4(load(rgba)); + + r = cast((px >> 0) & 0xffff) * (1/65535.0f); + g = cast((px >> 16) & 0xffff) * (1/65535.0f); + b = cast((px >> 32) & 0xffff) * (1/65535.0f); + a = cast((px >> 48) & 0xffff) * (1/65535.0f); ++#endif + #endif + } break; + +@@ -828,10 +913,17 @@ static void exec_ops(const Op* ops, const void** args, + A = (U16)v.val[3]; + #else + U64 px = load(rgba); ++#if __BIG_ENDIAN__ ++ U16 R = cast((px >> 48) & 0xffff), ++ G = cast((px >> 32) & 0xffff), ++ B = cast((px >> 16) & 0xffff), ++ A = cast((px >> 0) & 0xffff); ++#else + U16 R = cast((px >> 0) & 0xffff), + G = cast((px >> 16) & 0xffff), + B = cast((px >> 32) & 0xffff), + A = cast((px >> 48) & 0xffff); ++#endif + #endif + r = F_from_Half(R); + g = F_from_Half(G); +@@ -1024,10 +1116,17 @@ static void exec_ops(const Op* ops, const void** args, + } return; + + case Op_store_8888: { ++#if __BIG_ENDIAN__ ++ store(dst + 4*i, cast(to_fixed(r * 255) << 24) ++ | cast(to_fixed(g * 255) << 16) ++ | cast(to_fixed(b * 255) << 8) ++ | cast(to_fixed(a * 255) << 0)); ++#else + store(dst + 4*i, cast(to_fixed(r * 255) << 0) + | cast(to_fixed(g * 255) << 8) + | cast(to_fixed(b * 255) << 16) + | cast(to_fixed(a * 255) << 24)); ++#endif + } return; + + case Op_store_1010102: { +@@ -1043,15 +1142,30 @@ static void exec_ops(const Op* ops, const void** args, + uint16_t* rgb = (uint16_t*)ptr; // for this cast to uint16_t* to be safe. + #if defined(USING_NEON) + uint16x4x3_t v = {{ ++#if __BIG_ENDIAN__ ++ (uint16x4_t)swap_endian_16(cast(to_fixed(r * 65535))), ++ (uint16x4_t)swap_endian_16(cast(to_fixed(g * 65535))), ++ (uint16x4_t)swap_endian_16(cast(to_fixed(b * 65535))), ++#else + (uint16x4_t)cast(to_fixed(r * 65535)), + (uint16x4_t)cast(to_fixed(g * 65535)), + (uint16x4_t)cast(to_fixed(b * 65535)), ++#endif + }}; + vst3_u16(rgb, v); + #else ++#if __BIG_ENDIAN__ ++ I32 R = to_fixed(r * 65535), ++ G = to_fixed(g * 65535), ++ B = to_fixed(b * 65535); ++ store_3(rgb+0, cast((R & 0x00ff) << 8 | (R & 0xff00) >> 8) ); ++ store_3(rgb+1, cast((G & 0x00ff) << 8 | (G & 0xff00) >> 8) ); ++ store_3(rgb+2, cast((B & 0x00ff) << 8 | (B & 0xff00) >> 8) ); ++#else + store_3(rgb+0, cast(to_fixed(r * 65535))); + store_3(rgb+1, cast(to_fixed(g * 65535))); + store_3(rgb+2, cast(to_fixed(b * 65535))); ++#endif + #endif + + } return; +@@ -1062,18 +1176,33 @@ static void exec_ops(const Op* ops, const void** args, + uint16_t* rgba = (uint16_t*)ptr; // for this cast to uint16_t* to be safe. + #if defined(USING_NEON) + uint16x4x4_t v = {{ ++#if __BIG_ENDIAN__ ++ (uint16x4_t)swap_endian_16(cast(to_fixed(r * 65535))), ++ (uint16x4_t)swap_endian_16(cast(to_fixed(g * 65535))), ++ (uint16x4_t)swap_endian_16(cast(to_fixed(b * 65535))), ++ (uint16x4_t)swap_endian_16(cast(to_fixed(a * 65535))), ++#else + (uint16x4_t)cast(to_fixed(r * 65535)), + (uint16x4_t)cast(to_fixed(g * 65535)), + (uint16x4_t)cast(to_fixed(b * 65535)), + (uint16x4_t)cast(to_fixed(a * 65535)), ++#endif + }}; + vst4_u16(rgba, v); + #else ++#if __BIG_ENDIAN__ ++ U64 px = cast(to_fixed(r * 65535)) << 48 ++ | cast(to_fixed(g * 65535)) << 32 ++ | cast(to_fixed(b * 65535)) << 16 ++ | cast(to_fixed(a * 65535)) << 0; ++ store(rgba, swap_endian_16x4(px)); ++#else + U64 px = cast(to_fixed(r * 65535)) << 0 + | cast(to_fixed(g * 65535)) << 16 + | cast(to_fixed(b * 65535)) << 32 + | cast(to_fixed(a * 65535)) << 48; + store(rgba, px); ++#endif + #endif + } return; + +@@ -1083,18 +1212,30 @@ static void exec_ops(const Op* ops, const void** args, + uint16_t* rgb = (uint16_t*)ptr; // for this cast to uint16_t* to be safe. + #if defined(USING_NEON) + uint16x4x3_t v = {{ ++#if __BIG_ENDIAN__ ++ (uint16x4_t)cast(to_fixed(r * 65535)), ++ (uint16x4_t)cast(to_fixed(g * 65535)), ++ (uint16x4_t)cast(to_fixed(b * 65535)), ++#else + (uint16x4_t)swap_endian_16(cast(to_fixed(r * 65535))), + (uint16x4_t)swap_endian_16(cast(to_fixed(g * 65535))), + (uint16x4_t)swap_endian_16(cast(to_fixed(b * 65535))), ++#endif + }}; + vst3_u16(rgb, v); + #else ++#if __BIG_ENDIAN__ ++ store_3(rgb+0, cast(to_fixed(r * 65535))); ++ store_3(rgb+1, cast(to_fixed(g * 65535))); ++ store_3(rgb+2, cast(to_fixed(b * 65535))); ++#else + I32 R = to_fixed(r * 65535), + G = to_fixed(g * 65535), + B = to_fixed(b * 65535); + store_3(rgb+0, cast((R & 0x00ff) << 8 | (R & 0xff00) >> 8) ); + store_3(rgb+1, cast((G & 0x00ff) << 8 | (G & 0xff00) >> 8) ); + store_3(rgb+2, cast((B & 0x00ff) << 8 | (B & 0xff00) >> 8) ); ++#endif + #endif + + } return; +@@ -1105,18 +1246,33 @@ static void exec_ops(const Op* ops, const void** args, + uint16_t* rgba = (uint16_t*)ptr; // for this cast to uint16_t* to be safe. + #if defined(USING_NEON) + uint16x4x4_t v = {{ ++#if __BIG_ENDIAN__ ++ (uint16x4_t)cast(to_fixed(r * 65535)), ++ (uint16x4_t)cast(to_fixed(g * 65535)), ++ (uint16x4_t)cast(to_fixed(b * 65535)), ++ (uint16x4_t)cast(to_fixed(a * 65535)), ++#else + (uint16x4_t)swap_endian_16(cast(to_fixed(r * 65535))), + (uint16x4_t)swap_endian_16(cast(to_fixed(g * 65535))), + (uint16x4_t)swap_endian_16(cast(to_fixed(b * 65535))), + (uint16x4_t)swap_endian_16(cast(to_fixed(a * 65535))), ++#endif + }}; + vst4_u16(rgba, v); + #else ++#if __BIG_ENDIAN__ ++ U64 px = cast(to_fixed(r * 65535)) << 48 ++ | cast(to_fixed(g * 65535)) << 32 ++ | cast(to_fixed(b * 65535)) << 16 ++ | cast(to_fixed(a * 65535)) << 0; ++ store(rgba, px); ++#else + U64 px = cast(to_fixed(r * 65535)) << 0 + | cast(to_fixed(g * 65535)) << 16 + | cast(to_fixed(b * 65535)) << 32 + | cast(to_fixed(a * 65535)) << 48; + store(rgba, swap_endian_16x4(px)); ++#endif + #endif + } return; + +@@ -1160,10 +1316,17 @@ static void exec_ops(const Op* ops, const void** args, + }}; + vst4_u16(rgba, v); + #else ++#if __BIG_ENDIAN__ ++ store(rgba, cast(R) << 48 ++ | cast(G) << 32 ++ | cast(B) << 16 ++ | cast(A) << 0); ++#else + store(rgba, cast(R) << 0 + | cast(G) << 16 + | cast(B) << 32 + | cast(A) << 48); ++#endif + #endif + + } return; Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_smhasher_src_City.cpp =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_smhasher_src_City.cpp +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_smhasher_src_City.cpp @@ -0,0 +1,17 @@ +--- src/3rdparty/chromium/third_party/smhasher/src/City.cpp.orig 2019-10-27 22:10:58.672918000 +0100 ++++ src/3rdparty/chromium/third_party/smhasher/src/City.cpp 2019-10-27 22:12:39.653255000 +0100 +@@ -65,11 +65,11 @@ + #define bswap_64(x) OSSwapInt64(x) + + #else +-#include ++#include + #endif + +-#define uint32_in_expected_order(x) (bswap_32(x)) +-#define uint64_in_expected_order(x) (bswap_64(x)) ++#define uint32_in_expected_order(x) (bswap32(x)) ++#define uint64_in_expected_order(x) (bswap64(x)) + + #endif // __BIG_ENDIAN__ + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_common__audio_wav__file.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_common__audio_wav__file.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_common__audio_wav__file.cc @@ -0,0 +1,50 @@ +--- src/3rdparty/chromium/third_party/webrtc/common_audio/wav_file.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/webrtc/common_audio/wav_file.cc +@@ -93,13 +93,15 @@ size_t WavReader::num_samples() const { + } + + size_t WavReader::ReadSamples(size_t num_samples, int16_t* samples) { +-#ifndef WEBRTC_ARCH_LITTLE_ENDIAN +-#error "Need to convert samples to big-endian when reading from WAV file" +-#endif + // There could be metadata after the audio; ensure we don't read it. + num_samples = std::min(num_samples, num_samples_remaining_); + const size_t read = + fread(samples, sizeof(*samples), num_samples, file_handle_); ++#ifndef WEBRTC_ARCH_LITTLE_ENDIAN ++ for (size_t i = 0; i < read; i++) { ++ samples[i] = __builtin_bswap16(samples[i]); ++ } ++#endif + // If we didn't read what was requested, ensure we've reached the EOF. + RTC_CHECK(read == num_samples || feof(file_handle_)); + RTC_CHECK_LE(read, num_samples_remaining_); +@@ -178,13 +180,26 @@ size_t WavWriter::num_samples() const { + + void WavWriter::WriteSamples(const int16_t* samples, size_t num_samples) { + #ifndef WEBRTC_ARCH_LITTLE_ENDIAN +-#error "Need to convert samples to little-endian when writing to WAV file" +-#endif ++ static const size_t kChunksize = 4096 / sizeof(uint16_t); ++ for (size_t i = 0; i < num_samples; i += kChunksize) { ++ int16_t isamples[kChunksize]; ++ const size_t chunk = std::min(kChunksize, num_samples - i); ++ for (size_t j = 0; j < chunk; j++) { ++ isamples[j] = __builtin_bswap16(samples[i + j]); ++ } ++ const size_t written = ++ fwrite(isamples, sizeof(*isamples), chunk, file_handle_); ++ RTC_CHECK_EQ(chunk, written); ++ num_samples_ += written; ++ RTC_CHECK(num_samples_ >= written); // detect size_t overflow ++ } ++#else + const size_t written = + fwrite(samples, sizeof(*samples), num_samples, file_handle_); + RTC_CHECK_EQ(num_samples, written); + num_samples_ += written; + RTC_CHECK(num_samples_ >= written); // detect size_t overflow ++#endif + } + + void WavWriter::WriteSamples(const float* samples, size_t num_samples) { Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_common__audio_wav__header.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_common__audio_wav__header.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_common__audio_wav__header.cc @@ -0,0 +1,30 @@ +--- src/3rdparty/chromium/third_party/webrtc/common_audio/wav_header.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/webrtc/common_audio/wav_header.cc +@@ -86,7 +86,26 @@ static inline std::string ReadFourCC(uint32_t x) { + return std::string(reinterpret_cast(&x), 4); + } + #else +-#error "Write be-to-le conversion functions" ++static inline void WriteLE16(uint16_t* f, uint16_t x) { ++ *f = __builtin_bswap16(x); ++} ++static inline void WriteLE32(uint32_t* f, uint32_t x) { ++ *f = __builtin_bswap32(x); ++} ++static inline void WriteFourCC(uint32_t* f, char a, char b, char c, char d) { ++ *f = static_cast(d) | static_cast(c) << 8 | ++ static_cast(b) << 16 | static_cast(a) << 24; ++} ++ ++static inline uint16_t ReadLE16(uint16_t x) { ++ return __builtin_bswap16(x); ++} ++static inline uint32_t ReadLE32(uint32_t x) { ++ return __builtin_bswap32(x); ++} ++static inline std::string ReadFourCC(uint32_t x) { ++ return std::string(reinterpret_cast(&x), 4); ++} + #endif + + static inline uint32_t RiffChunkSize(size_t bytes_in_payload) { Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_modules_desktop__capture_differ__block.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_modules_desktop__capture_differ__block.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_modules_desktop__capture_differ__block.cc @@ -0,0 +1,26 @@ +--- src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/differ_block.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/webrtc/modules/desktop_capture/differ_block.cc +@@ -30,11 +30,7 @@ bool VectorDifference(const uint8_t* image1, const uin + static bool (*diff_proc)(const uint8_t*, const uint8_t*) = nullptr; + + if (!diff_proc) { +-#if defined(WEBRTC_ARCH_ARM_FAMILY) || defined(WEBRTC_ARCH_MIPS_FAMILY) +- // For ARM and MIPS processors, always use C version. +- // TODO(hclam): Implement a NEON version. +- diff_proc = &VectorDifference_C; +-#else ++#if defined(WEBRTC_ARCH_X86_FAMILY) + bool have_sse2 = WebRtc_GetCPUInfo(kSSE2) != 0; + // For x86 processors, check if SSE2 is supported. + if (have_sse2 && kBlockSize == 32) { +@@ -44,6 +40,10 @@ bool VectorDifference(const uint8_t* image1, const uin + } else { + diff_proc = &VectorDifference_C; + } ++#else ++ // For other processors, always use C version. ++ // TODO(hclam): Implement a NEON version. ++ diff_proc = &VectorDifference_C; + #endif + } + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_rtc__base_system_arch.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_rtc__base_system_arch.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_third__party_webrtc_rtc__base_system_arch.h @@ -0,0 +1,21 @@ +--- src/3rdparty/chromium/third_party/webrtc/rtc_base/system/arch.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/third_party/webrtc/rtc_base/system/arch.h +@@ -47,6 +47,18 @@ + #elif defined(__pnacl__) + #define WEBRTC_ARCH_32_BITS + #define WEBRTC_ARCH_LITTLE_ENDIAN ++#elif defined(__PPC__) ++#define WEBRTC_ARCH_PPC_FAMILY ++#if __BYTE_ORDER__ == __ORDER_LITTLE_ENDIAN__ ++#define WEBRTC_ARCH_LITTLE_ENDIAN ++#else ++#define WEBRTC_ARCH_BIG_ENDIAN ++#endif ++#if defined(__LP64__) ++#define WEBRTC_ARCH_64_BITS ++#else ++#define WEBRTC_ARCH_32_BITS ++#endif + #else + #error Please add support for your architecture in typedefs.h + #endif Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_aura_mus_os__exchange__data__provider__mus.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_aura_mus_os__exchange__data__provider__mus.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_aura_mus_os__exchange__data__provider__mus.cc @@ -0,0 +1,24 @@ +--- src/3rdparty/chromium/ui/aura/mus/os_exchange_data_provider_mus.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/ui/aura/mus/os_exchange_data_provider_mus.cc +@@ -14,6 +14,7 @@ + #include "base/strings/string_split.h" + #include "base/strings/string_util.h" + #include "base/strings/utf_string_conversions.h" ++#include "base/sys_byteorder.h" + #include "net/base/filename_util.h" + #include "ui/base/clipboard/clipboard_constants.h" + #include "ui/base/clipboard/clipboard_format_type.h" +@@ -279,8 +280,13 @@ void OSExchangeDataProviderMus::SetHtml(const base::st + std::vector bytes; + // Manually jam a UTF16 BOM into bytes because otherwise, other programs will + // assume UTF-8. ++#if defined(ARCH_CPU_LITTLE_ENDIAN) + bytes.push_back(0xFF); + bytes.push_back(0xFE); ++#else ++ bytes.push_back(0xFE); ++ bytes.push_back(0xFF); ++#endif + AddString16ToVector(html, &bytes); + mime_data_[ui::kMimeTypeHTML] = bytes; + } Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_base_resource_data__pack.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_base_resource_data__pack.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_base_resource_data__pack.cc @@ -0,0 +1,166 @@ +--- src/3rdparty/chromium/ui/base/resource/data_pack.cc.orig 2019-10-27 17:39:58 UTC ++++ src/3rdparty/chromium/ui/base/resource/data_pack.cc +@@ -154,16 +154,42 @@ class ScopedFileWriter { + DISALLOW_COPY_AND_ASSIGN(ScopedFileWriter); + }; + ++static inline uint16_t byteswap(uint16_t v) { return __builtin_bswap16(v); } ++static inline uint32_t byteswap(uint32_t v) { return __builtin_bswap32(v); } ++ ++template class byteswapped_t { ++private: ++ T value; ++public: ++ inline byteswapped_t(T v) : value(byteswap(v)) { } ++ inline T operator=(T v) { value = byteswap(v); return v; } ++ inline T operator+=(T v) { v += byteswap(value); value = byteswap(v); return v; } ++ inline operator T() const { return byteswap(value); } ++}; ++ ++#if !defined(ARCH_CPU_LITTLE_ENDIAN) ++ ++typedef byteswapped_t uint16le_t; ++typedef byteswapped_t uint32le_t; ++ ++#else ++ ++typedef uint16_t uint16le_t; ++typedef uint32_t uint32le_t; ++ ++#endif ++ + } // namespace + + namespace ui { + + #pragma pack(push, 2) + struct DataPack::Entry { +- uint16_t resource_id; +- uint32_t file_offset; ++ uint16le_t resource_id; ++ uint32le_t file_offset; + + static int CompareById(const void* void_key, const void* void_entry) { ++ // Key is host endian + uint16_t key = *reinterpret_cast(void_key); + const Entry* entry = reinterpret_cast(void_entry); + return key - entry->resource_id; +@@ -171,10 +197,11 @@ struct DataPack::Entry { + }; + + struct DataPack::Alias { +- uint16_t resource_id; +- uint16_t entry_index; ++ uint16le_t resource_id; ++ uint16le_t entry_index; + + static int CompareById(const void* void_key, const void* void_entry) { ++ // Key is host endian + uint16_t key = *reinterpret_cast(void_key); + const Alias* entry = reinterpret_cast(void_entry); + return key - entry->resource_id; +@@ -284,7 +311,7 @@ bool DataPack::LoadImpl(std::unique_ptr sizeof(version)) +- version = reinterpret_cast(data)[0]; ++ version = reinterpret_cast(data)[0]; + size_t header_length = + version == kFileFormatV4 ? kHeaderLengthV4 : kHeaderLengthV5; + if (version == 0 || data_length < header_length) { +@@ -295,14 +322,14 @@ bool DataPack::LoadImpl(std::unique_ptr(data)[1]; ++ resource_count_ = reinterpret_cast(data)[1]; + alias_count_ = 0; + text_encoding_type_ = static_cast(data[8]); + } else if (version == kFileFormatV5) { + // Version 5 added the alias table and changed the header format. + text_encoding_type_ = static_cast(data[4]); +- resource_count_ = reinterpret_cast(data)[4]; +- alias_count_ = reinterpret_cast(data)[5]; ++ resource_count_ = reinterpret_cast(data)[4]; ++ alias_count_ = reinterpret_cast(data)[5]; + } else { + LOG(ERROR) << "Bad data pack version: got " << version << ", expected " + << kFileFormatV4 << " or " << kFileFormatV5; +@@ -382,12 +382,6 @@ bool DataPack::HasResource(uint16_t resource_id) const { + + bool DataPack::GetStringPiece(uint16_t resource_id, + base::StringPiece* data) const { +- // It won't be hard to make this endian-agnostic, but it's not worth +- // bothering to do right now. +-#if !defined(ARCH_CPU_LITTLE_ENDIAN) +-#error "datapack assumes little endian" +-#endif +- + const Entry* target = LookupEntryById(resource_id); + if (!target) + return false; +@@ -447,9 +480,6 @@ void DataPack::CheckForDuplicateResources( + bool DataPack::WritePack(const base::FilePath& path, + const std::map& resources, + TextEncodingType text_encoding_type) { +-#if !defined(ARCH_CPU_LITTLE_ENDIAN) +-#error "datapack assumes little endian" +-#endif + if (text_encoding_type != UTF8 && text_encoding_type != UTF16 && + text_encoding_type != BINARY) { + LOG(ERROR) << "Invalid text encoding type, got " << text_encoding_type +@@ -467,7 +497,7 @@ bool DataPack::WritePack(const base::FilePath& path, + if (!file.valid()) + return false; + +- uint32_t encoding = static_cast(text_encoding_type); ++ uint32le_t encoding = static_cast(text_encoding_type); + + // Build a list of final resource aliases, and an alias map at the same time. + std::vector resource_ids; +@@ -494,13 +524,14 @@ bool DataPack::WritePack(const base::FilePath& path, + + // These values are guaranteed to fit in a uint16_t due to the earlier + // check of |resources_count|. +- const uint16_t alias_count = static_cast(aliases.size()); +- const uint16_t entry_count = static_cast(resource_ids.size()); ++ const uint16le_t alias_count = static_cast(aliases.size()); ++ const uint16le_t entry_count = static_cast(resource_ids.size()); + DCHECK_EQ(static_cast(entry_count) + static_cast(alias_count), + resources_count); + +- file.Write(&kFileFormatV5, sizeof(kFileFormatV5)); +- file.Write(&encoding, sizeof(uint32_t)); ++ uint32le_t version = kFileFormatV5; ++ file.Write(&version, sizeof(version)); ++ file.Write(&encoding, sizeof(uint32le_t)); + file.Write(&entry_count, sizeof(entry_count)); + file.Write(&alias_count, sizeof(alias_count)); + +@@ -508,8 +539,8 @@ bool DataPack::WritePack(const base::FilePath& path, + // last item so we can compute the size of the list item. + const uint32_t index_length = (entry_count + 1) * sizeof(Entry); + const uint32_t alias_table_length = alias_count * sizeof(Alias); +- uint32_t data_offset = kHeaderLengthV5 + index_length + alias_table_length; +- for (const uint16_t resource_id : resource_ids) { ++ uint32le_t data_offset = kHeaderLengthV5 + index_length + alias_table_length; ++ for (const uint16le_t resource_id : resource_ids) { + file.Write(&resource_id, sizeof(resource_id)); + file.Write(&data_offset, sizeof(data_offset)); + data_offset += resources.find(resource_id)->second.length(); +@@ -517,13 +548,13 @@ bool DataPack::WritePack(const base::FilePath& path, + + // We place an extra entry after the last item that allows us to read the + // size of the last item. +- const uint16_t resource_id = 0; ++ const uint16le_t resource_id = 0; + file.Write(&resource_id, sizeof(resource_id)); + file.Write(&data_offset, sizeof(data_offset)); + + // Write the aliases table, if any. Note: |aliases| is an std::map, + // ensuring values are written in increasing order. +- for (const std::pair& alias : aliases) { ++ for (const std::pair alias : aliases) { + file.Write(&alias, sizeof(alias)); + } + Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_jpeg__codec.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_jpeg__codec.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_jpeg__codec.cc @@ -1,6 +1,6 @@ ---- src/3rdparty/chromium/ui/gfx/codec/jpeg_codec.cc.orig 2018-11-13 18:25:11 UTC -+++ src/3rdparty/chromium/ui/gfx/codec/jpeg_codec.cc -@@ -219,6 +219,7 @@ bool JPEGCodec::Decode(const unsigned char* input, siz +--- src/3rdparty/chromium/ui/gfx/codec/jpeg_codec.cc.orig 2019-05-23 14:39:34.000000000 +0200 ++++ src/3rdparty/chromium/ui/gfx/codec/jpeg_codec.cc 2019-10-27 22:18:49.231847000 +0100 +@@ -207,16 +207,17 @@ case JCS_GRAYSCALE: case JCS_RGB: case JCS_YCbCr: @@ -8,13 +8,25 @@ // Choose an output colorspace and return if it is an unsupported one. // Same as JPEGCodec::Encode(), libjpeg-turbo supports all input formats // used by Chromium (i.e. RGBA and BGRA) and we just map the input -@@ -237,6 +238,9 @@ bool JPEGCodec::Decode(const unsigned char* input, siz - NOTREACHED() << "Invalid pixel format"; + // parameters to a colorspace. + if (format == FORMAT_RGBA || +- (format == FORMAT_SkBitmap && SK_R32_SHIFT == 0)) { ++ (format == FORMAT_SkBitmap && SK_PMCOLOR_BYTE_ORDER(R, G, B, A))) { + cinfo->out_color_space = JCS_EXT_RGBX; + cinfo->output_components = 4; + } else if (format == FORMAT_BGRA || +- (format == FORMAT_SkBitmap && SK_B32_SHIFT == 0)) { ++ (format == FORMAT_SkBitmap && SK_PMCOLOR_BYTE_ORDER(B, G, R, A))) { + cinfo->out_color_space = JCS_EXT_BGRX; + cinfo->output_components = 4; + } else { +@@ -224,6 +225,9 @@ return false; } + break; +#else + cinfo.out_color_space = JCS_RGB; +#endif - break; case JCS_CMYK: case JCS_YCCK: + default: Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec.h @@ -0,0 +1,13 @@ +--- src/3rdparty/chromium/ui/gfx/codec/png_codec.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/ui/gfx/codec/png_codec.h +@@ -37,6 +37,10 @@ class CODEC_EXPORT PNGCodec { + // This is the default Windows DIB order. + FORMAT_BGRA, + ++ // 4 bytes per pixel, in ARGB order in memory regardless of endianness. ++ // Only supported for decoding ++ FORMAT_ARGB, ++ + // SkBitmap format. For Encode() kN32_SkColorType (4 bytes per pixel) and + // kAlpha_8_SkColorType (1 byte per pixel) formats are supported. + // kAlpha_8_SkColorType gets encoded into a grayscale PNG treating alpha as Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec.cc @@ -0,0 +1,33 @@ +--- src/3rdparty/chromium/ui/gfx/codec/png_codec.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/ui/gfx/codec/png_codec.cc +@@ -169,6 +169,10 @@ void DecodeInfoCallback(png_struct* png_ptr, png_info* + png_set_bgr(png_ptr); + png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_AFTER); + break; ++ case PNGCodec::FORMAT_ARGB: ++ state->output_channels = 4; ++ png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_BEFORE); ++ break; + case PNGCodec::FORMAT_SkBitmap: + state->output_channels = 4; + png_set_add_alpha(png_ptr, 0xFF, PNG_FILLER_AFTER); +@@ -183,6 +187,10 @@ void DecodeInfoCallback(png_struct* png_ptr, png_info* + state->output_channels = 4; + png_set_bgr(png_ptr); + break; ++ case PNGCodec::FORMAT_ARGB: ++ state->output_channels = 4; ++ png_set_swap_alpha(png_ptr); ++ break; + case PNGCodec::FORMAT_SkBitmap: + state->output_channels = 4; + break; +@@ -475,6 +483,8 @@ bool PNGCodec::Encode(const unsigned char* input, + case FORMAT_BGRA: + colorType = kBGRA_8888_SkColorType; + break; ++ case FORMAT_ARGB: ++ return false; + case FORMAT_SkBitmap: + colorType = kN32_SkColorType; + break; Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec__unittest.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec__unittest.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_codec_png__codec__unittest.cc @@ -0,0 +1,11 @@ +--- src/3rdparty/chromium/ui/gfx/codec/png_codec_unittest.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/ui/gfx/codec/png_codec_unittest.cc +@@ -853,7 +853,7 @@ TEST(PNGCodec, EncodeA8SkBitmap) { + for (int y = 0; y < h; y++) { + uint8_t original_pixel = *original_bitmap.getAddr8(x, y); + uint32_t decoded_pixel = *decoded_bitmap.getAddr32(x, y); +- EXPECT_TRUE(BGRAGrayEqualsA8Gray(decoded_pixel, original_pixel)); ++ EXPECT_TRUE(BGRAGrayEqualsA8Gray(SkUnPreMultiply::PMColorToColor(decoded_pixel), original_pixel)); + } + } + } Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_color__analysis.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_color__analysis.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_color__analysis.cc @@ -0,0 +1,87 @@ +--- src/3rdparty/chromium/ui/gfx/color_analysis.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/ui/gfx/color_analysis.cc +@@ -16,6 +16,7 @@ + #include + + #include "base/logging.h" ++#include "base/sys_byteorder.h" + #include "third_party/skia/include/core/SkBitmap.h" + #include "third_party/skia/include/core/SkUnPreMultiply.h" + #include "ui/gfx/codec/png_codec.h" +@@ -506,10 +507,17 @@ SkColor FindClosestColor(const uint8_t* image, + SkColor best_color = color; + const uint8_t* byte = image; + for (int i = 0; i < width * height; ++i) { ++#if defined(ARCH_CPU_LITTLE_ENDIAN) + uint8_t b = *(byte++); + uint8_t g = *(byte++); + uint8_t r = *(byte++); + uint8_t a = *(byte++); ++#else ++ uint8_t a = *(byte++); ++ uint8_t r = *(byte++); ++ uint8_t g = *(byte++); ++ uint8_t b = *(byte++); ++#endif + // Ignore fully transparent pixels. + if (a == 0) + continue; +@@ -527,7 +535,6 @@ SkColor FindClosestColor(const uint8_t* image, + + // For a 16x16 icon on an Intel Core i5 this function takes approximately + // 0.5 ms to run. +-// TODO(port): This code assumes the CPU architecture is little-endian. + SkColor CalculateKMeanColorOfBuffer(uint8_t* decoded_data, + int img_width, + int img_height, +@@ -550,10 +557,17 @@ SkColor CalculateKMeanColorOfBuffer(uint8_t* decoded_d + int pixel_pos = sampler->GetSample(img_width, img_height) % + (img_width * img_height); + ++#if defined(ARCH_CPU_LITTLE_ENDIAN) + uint8_t b = decoded_data[pixel_pos * 4]; + uint8_t g = decoded_data[pixel_pos * 4 + 1]; + uint8_t r = decoded_data[pixel_pos * 4 + 2]; + uint8_t a = decoded_data[pixel_pos * 4 + 3]; ++#else ++ uint8_t a = decoded_data[pixel_pos * 4]; ++ uint8_t r = decoded_data[pixel_pos * 4 + 1]; ++ uint8_t g = decoded_data[pixel_pos * 4 + 2]; ++ uint8_t b = decoded_data[pixel_pos * 4 + 3]; ++#endif + // Skip fully transparent pixels as they usually contain black in their + // RGB channels but do not contribute to the visual image. + if (a == 0) +@@ -602,10 +616,17 @@ SkColor CalculateKMeanColorOfBuffer(uint8_t* decoded_d + uint8_t* pixel = decoded_data; + uint8_t* decoded_data_end = decoded_data + (img_width * img_height * 4); + while (pixel < decoded_data_end) { ++#if defined(ARCH_CPU_LITTLE_ENDIAN) + uint8_t b = *(pixel++); + uint8_t g = *(pixel++); + uint8_t r = *(pixel++); + uint8_t a = *(pixel++); ++#else ++ uint8_t a = *(pixel++); ++ uint8_t r = *(pixel++); ++ uint8_t g = *(pixel++); ++ uint8_t b = *(pixel++); ++#endif + // Skip transparent pixels, see above. + if (a == 0) + continue; +@@ -683,8 +704,12 @@ SkColor CalculateKMeanColorOfPNG(scoped_refptrsize() && + gfx::PNGCodec::Decode(png->front(), png->size(), +- gfx::PNGCodec::FORMAT_BGRA, &decoded_data, +- &img_width, &img_height)) { ++#if defined(ARCH_CPU_LITTLE_ENDIAN) ++ gfx::PNGCodec::FORMAT_BGRA, ++#else ++ gfx::PNGCodec::FORMAT_ARGB, ++#endif ++ &decoded_data, &img_width, &img_height)) { + return CalculateKMeanColorOfBuffer(&decoded_data[0], img_width, img_height, + lower_bound, upper_bound, sampler, true); + } Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_skbitmap__operations__unittest.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_skbitmap__operations__unittest.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_ui_gfx_skbitmap__operations__unittest.cc @@ -0,0 +1,11 @@ +--- src/3rdparty/chromium/ui/gfx/skbitmap_operations_unittest.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/ui/gfx/skbitmap_operations_unittest.cc +@@ -238,7 +238,7 @@ TEST(SkBitmapOperationsTest, CreateHSLShiftedBitmapHue + + for (int y = 0, i = 0; y < src_h; y++) { + for (int x = 0; x < src_w; x++) { +- *src.getAddr32(x, y) = SkColorSetARGB(255, 0, 0, i % 255); ++ *src.getAddr32(x, y) = SkPackARGB32(255, 0, 0, i % 255); + i++; + } + } Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_url_url__canon__host.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_url_url__canon__host.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_url_url__canon__host.cc @@ -0,0 +1,12 @@ +--- src/3rdparty/chromium/url/url_canon_host.cc.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/url/url_canon_host.cc +@@ -135,8 +135,7 @@ bool DoSimpleHost(const INCHAR* host, + if (source == '%') { + // Unescape first, if possible. + // Source will be used only if decode operation was successful. +- if (!DecodeEscaped(host, &i, host_len, +- reinterpret_cast(&source))) { ++ if (!DecodeEscaped(host, &i, host_len, &source)) { + // Invalid escaped character. There is nothing that can make this + // host valid. We append an escaped percent so the URL looks reasonable + // and mark as failed. Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_url_url__canon__internal.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_url_url__canon__internal.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_url_url__canon__internal.h @@ -0,0 +1,14 @@ +--- src/3rdparty/chromium/url/url_canon_internal.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/url/url_canon_internal.h +@@ -305,9 +305,9 @@ inline bool Is8BitChar(base::char16 c) { + return c <= 255; + } + +-template ++template + inline bool DecodeEscaped(const CHAR* spec, int* begin, int end, +- unsigned char* unescaped_value) { ++ DST* unescaped_value) { + if (*begin + 3 > end || + !Is8BitChar(spec[*begin + 1]) || !Is8BitChar(spec[*begin + 2])) { + // Invalid escape sequence because there's not enough room, or the Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_BUILD.gn =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_BUILD.gn +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_BUILD.gn @@ -1,6 +1,14 @@ ---- src/3rdparty/chromium/v8/BUILD.gn.orig 2019-05-23 12:39:34 UTC -+++ src/3rdparty/chromium/v8/BUILD.gn -@@ -3169,7 +3169,7 @@ v8_component("v8_libbase") { +--- src/3rdparty/chromium/v8/BUILD.gn.orig 2019-05-23 14:39:34.000000000 +0200 ++++ src/3rdparty/chromium/v8/BUILD.gn 2019-10-27 22:44:17.280181000 +0100 +@@ -3006,7 +3006,6 @@ + # to implement atomic memory access + if (v8_current_cpu == "mips" || v8_current_cpu == "mipsel" || + v8_current_cpu == "mips64" || v8_current_cpu == "mips64el" || +- v8_current_cpu == "ppc" || v8_current_cpu == "ppc64" || + v8_current_cpu == "s390" || v8_current_cpu == "s390x") { + libs = [ "atomic" ] + } +@@ -3169,7 +3168,7 @@ } } @@ -9,7 +17,7 @@ sources += [ "src/base/debug/stack_trace_posix.cc", "src/base/platform/platform-linux.cc", -@@ -3189,6 +3189,12 @@ v8_component("v8_libbase") { +@@ -3189,6 +3188,12 @@ "dl", "rt", ] @@ -22,7 +30,7 @@ } else if (is_android) { if (current_toolchain == host_toolchain) { libs = [ -@@ -3393,6 +3399,7 @@ if (v8_use_snapshot && current_toolchain == v8_snapsho +@@ -3393,6 +3398,7 @@ "src/snapshot/embedded-file-writer.h", "src/snapshot/mksnapshot.cc", ] Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_src_ppc_constants-ppc.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_src_ppc_constants-ppc.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_src_ppc_constants-ppc.h @@ -0,0 +1,30 @@ +--- src/3rdparty/chromium/v8/src/ppc/constants-ppc.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/v8/src/ppc/constants-ppc.h +@@ -21,7 +21,8 @@ + #endif + + #if V8_HOST_ARCH_PPC && \ +- (V8_OS_AIX || (V8_TARGET_ARCH_PPC64 && V8_TARGET_BIG_ENDIAN)) ++ (V8_OS_AIX || (V8_TARGET_ARCH_PPC64 && \ ++ (V8_TARGET_BIG_ENDIAN && (!defined(_CALL_ELF) || _CALL_ELF == 1)))) + #define ABI_USES_FUNCTION_DESCRIPTORS 1 + #else + #define ABI_USES_FUNCTION_DESCRIPTORS 0 +@@ -33,13 +34,15 @@ + #define ABI_PASSES_HANDLES_IN_REGS 0 + #endif + +-#if !V8_HOST_ARCH_PPC || !V8_TARGET_ARCH_PPC64 || V8_TARGET_LITTLE_ENDIAN ++#if !V8_HOST_ARCH_PPC || !V8_TARGET_ARCH_PPC64 || \ ++ (V8_TARGET_LITTLE_ENDIAN || (defined(_CALL_ELF) && _CALL_ELF == 2)) + #define ABI_RETURNS_OBJECT_PAIRS_IN_REGS 1 + #else + #define ABI_RETURNS_OBJECT_PAIRS_IN_REGS 0 + #endif + +-#if !V8_HOST_ARCH_PPC || (V8_TARGET_ARCH_PPC64 && V8_TARGET_LITTLE_ENDIAN) ++#if !V8_HOST_ARCH_PPC || (V8_TARGET_ARCH_PPC64 && \ ++ (V8_TARGET_LITTLE_ENDIAN || (defined(_CALL_ELF) && _CALL_ELF == 2))) + #define ABI_CALL_VIA_IP 1 + #else + #define ABI_CALL_VIA_IP 0 Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_src_ppc_register-ppc.h =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_src_ppc_register-ppc.h +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_src_ppc_register-ppc.h @@ -0,0 +1,12 @@ +--- src/3rdparty/chromium/v8/src/ppc/register-ppc.h.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/v8/src/ppc/register-ppc.h +@@ -145,7 +145,8 @@ const int kNumSafepointRegisters = 32; + // The following constants describe the stack frame linkage area as + // defined by the ABI. Note that kNumRequiredStackFrameSlots must + // satisfy alignment requirements (rounding up if required). +-#if V8_TARGET_ARCH_PPC64 && V8_TARGET_LITTLE_ENDIAN // ppc64le linux ++#if V8_TARGET_ARCH_PPC64 && (V8_TARGET_LITTLE_ENDIAN || \ ++ defined(_CALL_ELF) && _CALL_ELF == 2) + // [0] back chain + // [1] condition register save area + // [2] link register save area Index: head/www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_test_BUILD.gn =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_test_BUILD.gn +++ head/www/qt5-webengine/files/patch-src_3rdparty_chromium_v8_test_BUILD.gn @@ -0,0 +1,36 @@ +--- src/3rdparty/chromium/v8/test/BUILD.gn.orig 2019-05-23 12:39:34 UTC ++++ src/3rdparty/chromium/v8/test/BUILD.gn +@@ -31,7 +31,7 @@ group("gn_all") { + deps += [ + "cctest:cctest", + "cctest:generate-bytecode-expectations", +- "unittests:unittests", ++ #"unittests:unittests", + ] + } + } +@@ -80,9 +80,9 @@ group("v8_bot_default") { + "mjsunit:v8_mjsunit", + "mkgrokdump:mkgrokdump", + "preparser:v8_preparser", +- "unittests:unittests", ++ #"unittests:unittests", + "wasm-js:v8_wasm_js", +- "wasm-spec-tests:v8_wasm_spec_tests", ++ #"wasm-spec-tests:v8_wasm_spec_tests", + "webkit:v8_webkit", + ] + } +@@ -100,9 +100,9 @@ group("v8_default") { + "mjsunit:v8_mjsunit", + "mkgrokdump:mkgrokdump", + "preparser:v8_preparser", +- "unittests:unittests", +- "wasm-js:v8_wasm_js", +- "wasm-spec-tests:v8_wasm_spec_tests", ++ #"unittests:unittests", ++ #"wasm-js:v8_wasm_js", ++ #"wasm-spec-tests:v8_wasm_spec_tests", + ] + } + Index: head/www/qt5-webengine/files/patch-src_3rdparty_gn_tools_gn_args.cc =================================================================== --- head/www/qt5-webengine/files/patch-src_3rdparty_gn_tools_gn_args.cc +++ head/www/qt5-webengine/files/patch-src_3rdparty_gn_tools_gn_args.cc @@ -0,0 +1,11 @@ +--- src/3rdparty/gn/tools/gn/args.cc.orig 2019-10-27 19:20:40.465677000 +0100 ++++ src/3rdparty/gn/tools/gn/args.cc 2019-10-27 19:21:07.759511000 +0100 +@@ -332,7 +332,7 @@ + arch = kMips64; + else if (os_arch == "s390x") + arch = kS390X; +- else if (os_arch == "ppc64" || os_arch == "ppc64le") ++ else if (os_arch == "ppc64" || os_arch == "ppc64le" || os_arch == "powerpc") + // We handle the endianness inside //build/config/host_byteorder.gni. + // This allows us to use the same toolchain as ppc64 BE + // and specific flags are included using the host_byteorder logic. Index: head/www/qt5-webengine/pkg-plist =================================================================== --- head/www/qt5-webengine/pkg-plist +++ head/www/qt5-webengine/pkg-plist @@ -172,7 +172,8 @@ libdata/pkgconfig/Qt5WebEngineCore.pc libdata/pkgconfig/Qt5WebEngineWidgets.pc %%QT_LIBEXECDIR%%/QtWebEngineProcess -%%QT_DATADIR%%/resources/icudtl.dat +%%BE%%%%QT_DATADIR%%/resources/icudtb.dat +%%LE%%%%QT_DATADIR%%/resources/icudtl.dat %%QT_DATADIR%%/resources/qtwebengine_devtools_resources.pak %%QT_DATADIR%%/resources/qtwebengine_resources.pak %%QT_DATADIR%%/resources/qtwebengine_resources_100p.pak