From 626ed1dcfe5a17c69820346d79999e6a18fd2b7a Mon Sep 17 00:00:00 2001 From: wxiat Date: Mon, 24 Jul 2023 09:44:42 +0800 Subject: [PATCH] add sw Signed-off-by: wxiat --- 0001-qtbase-add-sw.patch | 506 +++++++++++++++++++++++++++++++++++++++ qt5-qtbase.spec | 7 +- 2 files changed, 512 insertions(+), 1 deletion(-) create mode 100644 0001-qtbase-add-sw.patch diff --git a/0001-qtbase-add-sw.patch b/0001-qtbase-add-sw.patch new file mode 100644 index 0000000..a8df93b --- /dev/null +++ b/0001-qtbase-add-sw.patch @@ -0,0 +1,506 @@ +From b9cef2a2bbc93693c8dabf6fd17430b54db84662 Mon Sep 17 00:00:00 2001 +From: wxiat +Date: Wed, 19 Jul 2023 17:04:23 +0800 +Subject: [PATCH] qtbase add sw + +--- + "\\" | 372 ++++++++++++++++++ + .../include/double-conversion/utils.h | 3 +- + src/3rdparty/sha3/brg_endian.h | 1 + + src/corelib/io/qfilesystemwatcher_inotify.cpp | 4 + + src/gui/image/qimage.cpp | 4 + + src/testlib/3rdparty/cycle_p.h | 36 ++ + 6 files changed, 419 insertions(+), 1 deletion(-) + create mode 100644 "\\" + +diff --git "a/\\" "b/\\" +new file mode 100644 +index 00000000..103439a5 +--- /dev/null ++++ "b/\\" +@@ -0,0 +1,372 @@ ++// Copyright 2010 the V8 project authors. All rights reserved. ++// Redistribution and use in source and binary forms, with or without ++// modification, are permitted provided that the following conditions are ++// met: ++// ++// * Redistributions of source code must retain the above copyright ++// notice, this list of conditions and the following disclaimer. ++// * Redistributions in binary form must reproduce the above ++// copyright notice, this list of conditions and the following ++// disclaimer in the documentation and/or other materials provided ++// with the distribution. ++// * Neither the name of Google Inc. nor the names of its ++// contributors may be used to endorse or promote products derived ++// from this software without specific prior written permission. ++// ++// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS ++// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT ++// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR ++// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT ++// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, ++// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT ++// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, ++// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY ++// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT ++// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE ++// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. ++ ++#ifndef DOUBLE_CONVERSION_UTILS_H_ ++#define DOUBLE_CONVERSION_UTILS_H_ ++ ++#include ++#include ++ ++#include ++#ifndef ASSERT ++#define ASSERT(condition) \ ++ assert(condition); ++#endif ++#ifndef UNIMPLEMENTED ++#define UNIMPLEMENTED() (abort()) ++#endif ++#ifndef DOUBLE_CONVERSION_NO_RETURN ++#ifdef _MSC_VER ++#define DOUBLE_CONVERSION_NO_RETURN __declspec(noreturn) ++#else ++#define DOUBLE_CONVERSION_NO_RETURN __attribute__((noreturn)) ++#endif ++#endif ++#ifndef UNREACHABLE ++#ifdef _MSC_VER ++void DOUBLE_CONVERSION_NO_RETURN abort_noreturn(); ++inline void abort_noreturn() { abort(); } ++#define UNREACHABLE() (abort_noreturn()) ++#else ++#define UNREACHABLE() (abort()) ++#endif ++#endif ++ ++#ifndef DOUBLE_CONVERSION_UNUSED ++#ifdef __GNUC__ ++#define DOUBLE_CONVERSION_UNUSED __attribute__((unused)) ++#else ++#define DOUBLE_CONVERSION_UNUSED ++#endif ++#endif ++ ++// Double operations detection based on target architecture. ++// Linux uses a 80bit wide floating point stack on x86. This induces double ++// rounding, which in turn leads to wrong results. ++// An easy way to test if the floating-point operations are correct is to ++// evaluate: 89255.0/1e22. If the floating-point stack is 64 bits wide then ++// the result is equal to 89255e-22. ++// The best way to test this, is to create a division-function and to compare ++// the output of the division with the expected result. (Inlining must be ++// disabled.) ++// On Linux,x86 89255e-22 != Div_double(89255.0/1e22) ++// ++// For example: ++/* ++// -- in div.c ++double Div_double(double x, double y) { return x / y; } ++ ++// -- in main.c ++double Div_double(double x, double y); // Forward declaration. ++ ++int main(int argc, char** argv) { ++ return Div_double(89255.0, 1e22) == 89255e-22; ++} ++*/ ++// Run as follows ./main || echo "correct" ++// ++// If it prints "correct" then the architecture should be here, in the "correct" section. ++#if defined(_M_X64) || defined(__x86_64__) || \ ++ defined(__ARMEL__) || defined(__avr32__) || defined(_M_ARM) || defined(_M_ARM64) || \ ++ defined(__hppa__) || defined(__ia64__) || \ ++ defined(__mips__) || \ ++ defined(__powerpc__) || defined(__ppc__) || defined(__ppc64__) || \ ++ defined(_POWER) || defined(_ARCH_PPC) || defined(_ARCH_PPC64) || \ ++ defined(__sparc__) || defined(__sparc) || defined(__s390__) || \ ++ defined(__SH4__) || defined(__alpha__) || \ ++ defined(_MIPS_ARCH_MIPS32R2) || defined(__ARMEB__) ||\ ++ defined(__AARCH64EL__) || defined(__aarch64__) || defined(__AARCH64EB__) || \ ++ defined(__riscv) || \ ++ defined(__or1k__) || defined(__arc__) || \ ++ defined(__EMSCRIPTEN__) || \ ++ defined(__loongarch__) || defined(__loongarch64__) || \ ++ defined(__sw_64__) ++#define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 ++#elif defined(__mc68000__) || \ ++ defined(__pnacl__) || defined(__native_client__) ++#undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS ++#elif defined(_M_IX86) || defined(__i386__) || defined(__i386) ++#if defined(_WIN32) ++// Windows uses a 64bit wide floating point stack. ++#define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 ++#else ++#undef DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS ++#endif // _WIN32 ++#elif defined(__ghs) ++// Green Hills toolchain uses a 64bit wide floating point stack ++#define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 ++#else ++#error Target architecture was not detected as supported by Double-Conversion. ++#endif ++ ++#if defined(_WIN32) && !defined(__MINGW32__) ++ ++typedef signed char int8_t; ++typedef unsigned char uint8_t; ++typedef short int16_t; // NOLINT ++typedef unsigned short uint16_t; // NOLINT ++typedef int int32_t; ++typedef unsigned int uint32_t; ++typedef __int64 int64_t; ++typedef unsigned __int64 uint64_t; ++// intptr_t and friends are defined in crtdefs.h through stdio.h. ++ ++#else ++ ++#include ++ ++#endif ++ ++typedef uint16_t uc16; ++ ++// The following macro works on both 32 and 64-bit platforms. ++// Usage: instead of writing 0x1234567890123456 ++// write UINT64_2PART_C(0x12345678,90123456); ++#define UINT64_2PART_C(a, b) (((static_cast(a) << 32) + 0x##b##u)) ++ ++ ++// The expression ARRAY_SIZE(a) is a compile-time constant of type ++// size_t which represents the number of elements of the given ++// array. You should only use ARRAY_SIZE on statically allocated ++// arrays. ++#ifndef ARRAY_SIZE ++#define ARRAY_SIZE(a) \ ++ ((sizeof(a) / sizeof(*(a))) / \ ++ static_cast(!(sizeof(a) % sizeof(*(a))))) ++#endif ++ ++// A macro to disallow the evil copy constructor and operator= functions ++// This should be used in the private: declarations for a class ++#ifndef DC_DISALLOW_COPY_AND_ASSIGN ++#define DC_DISALLOW_COPY_AND_ASSIGN(TypeName) \ ++ TypeName(const TypeName&); \ ++ void operator=(const TypeName&) ++#endif ++ ++// A macro to disallow all the implicit constructors, namely the ++// default constructor, copy constructor and operator= functions. ++// ++// This should be used in the private: declarations for a class ++// that wants to prevent anyone from instantiating it. This is ++// especially useful for classes containing only static methods. ++#ifndef DC_DISALLOW_IMPLICIT_CONSTRUCTORS ++#define DC_DISALLOW_IMPLICIT_CONSTRUCTORS(TypeName) \ ++ TypeName(); \ ++ DC_DISALLOW_COPY_AND_ASSIGN(TypeName) ++#endif ++ ++namespace double_conversion { ++ ++static const int kCharSize = sizeof(char); ++ ++// Returns the maximum of the two parameters. ++template ++static T Max(T a, T b) { ++ return a < b ? b : a; ++} ++ ++ ++// Returns the minimum of the two parameters. ++template ++static T Min(T a, T b) { ++ return a < b ? a : b; ++} ++ ++ ++inline int StrLength(const char* string) { ++ size_t length = strlen(string); ++ ASSERT(length == static_cast(static_cast(length))); ++ return static_cast(length); ++} ++ ++// This is a simplified version of V8's Vector class. ++template ++class Vector { ++ public: ++ Vector() : start_(NULL), length_(0) {} ++ Vector(T* data, int len) : start_(data), length_(len) { ++ ASSERT(len == 0 || (len > 0 && data != NULL)); ++ } ++ ++ // Returns a vector using the same backing storage as this one, ++ // spanning from and including 'from', to but not including 'to'. ++ Vector SubVector(int from, int to) { ++ ASSERT(to <= length_); ++ ASSERT(from < to); ++ ASSERT(0 <= from); ++ return Vector(start() + from, to - from); ++ } ++ ++ // Returns the length of the vector. ++ int length() const { return length_; } ++ ++ // Returns whether or not the vector is empty. ++ bool is_empty() const { return length_ == 0; } ++ ++ // Returns the pointer to the start of the data in the vector. ++ T* start() const { return start_; } ++ ++ // Access individual vector elements - checks bounds in debug mode. ++ T& operator[](int index) const { ++ ASSERT(0 <= index && index < length_); ++ return start_[index]; ++ } ++ ++ T& first() { return start_[0]; } ++ ++ T& last() { return start_[length_ - 1]; } ++ ++ private: ++ T* start_; ++ int length_; ++}; ++ ++ ++// Helper class for building result strings in a character buffer. The ++// purpose of the class is to use safe operations that checks the ++// buffer bounds on all operations in debug mode. ++class StringBuilder { ++ public: ++ StringBuilder(char* buffer, int buffer_size) ++ : buffer_(buffer, buffer_size), position_(0) { } ++ ++ ~StringBuilder() { if (!is_finalized()) Finalize(); } ++ ++ int size() const { return buffer_.length(); } ++ ++ // Get the current position in the builder. ++ int position() const { ++ ASSERT(!is_finalized()); ++ return position_; ++ } ++ ++ // Reset the position. ++ void Reset() { position_ = 0; } ++ ++ // Add a single character to the builder. It is not allowed to add ++ // 0-characters; use the Finalize() method to terminate the string ++ // instead. ++ void AddCharacter(char c) { ++ ASSERT(c != '\0'); ++ ASSERT(!is_finalized() && position_ < buffer_.length()); ++ buffer_[position_++] = c; ++ } ++ ++ // Add an entire string to the builder. Uses strlen() internally to ++ // compute the length of the input string. ++ void AddString(const char* s) { ++ AddSubstring(s, StrLength(s)); ++ } ++ ++ // Add the first 'n' characters of the given string 's' to the ++ // builder. The input string must have enough characters. ++ void AddSubstring(const char* s, int n) { ++ ASSERT(!is_finalized() && position_ + n < buffer_.length()); ++ ASSERT(static_cast(n) <= strlen(s)); ++ memmove(&buffer_[position_], s, n * kCharSize); ++ position_ += n; ++ } ++ ++ ++ // Add character padding to the builder. If count is non-positive, ++ // nothing is added to the builder. ++ void AddPadding(char c, int count) { ++ for (int i = 0; i < count; i++) { ++ AddCharacter(c); ++ } ++ } ++ ++ // Finalize the string by 0-terminating it and returning the buffer. ++ char* Finalize() { ++ ASSERT(!is_finalized() && position_ < buffer_.length()); ++ buffer_[position_] = '\0'; ++ // Make sure nobody managed to add a 0-character to the ++ // buffer while building the string. ++ ASSERT(strlen(buffer_.start()) == static_cast(position_)); ++ position_ = -1; ++ ASSERT(is_finalized()); ++ return buffer_.start(); ++ } ++ ++ private: ++ Vector buffer_; ++ int position_; ++ ++ bool is_finalized() const { return position_ < 0; } ++ ++ DC_DISALLOW_IMPLICIT_CONSTRUCTORS(StringBuilder); ++}; ++ ++// The type-based aliasing rule allows the compiler to assume that pointers of ++// different types (for some definition of different) never alias each other. ++// Thus the following code does not work: ++// ++// float f = foo(); ++// int fbits = *(int*)(&f); ++// ++// The compiler 'knows' that the int pointer can't refer to f since the types ++// don't match, so the compiler may cache f in a register, leaving random data ++// in fbits. Using C++ style casts makes no difference, however a pointer to ++// char data is assumed to alias any other pointer. This is the 'memcpy ++// exception'. ++// ++// Bit_cast uses the memcpy exception to move the bits from a variable of one ++// type of a variable of another type. Of course the end result is likely to ++// be implementation dependent. Most compilers (gcc-4.2 and MSVC 2005) ++// will completely optimize BitCast away. ++// ++// There is an additional use for BitCast. ++// Recent gccs will warn when they see casts that may result in breakage due to ++// the type-based aliasing rule. If you have checked that there is no breakage ++// you can use BitCast to cast one pointer type to another. This confuses gcc ++// enough that it can no longer see that you have cast one pointer type to ++// another thus avoiding the warning. ++template ++inline Dest BitCast(const Source& source) { ++ // Compile time assertion: sizeof(Dest) == sizeof(Source) ++ // A compile error here means your Dest and Source have different sizes. ++#if __cplusplus >= 201103L ++ static_assert(sizeof(Dest) == sizeof(Source), ++ "source and destination size mismatch"); ++#else ++ DOUBLE_CONVERSION_UNUSED ++ typedef char VerifySizesAreEqual[sizeof(Dest) == sizeof(Source) ? 1 : -1]; ++#endif ++ ++ Dest dest; ++ memmove(&dest, &source, sizeof(dest)); ++ return dest; ++} ++ ++template ++inline Dest BitCast(Source* source) { ++ return BitCast(reinterpret_cast(source)); ++} ++ ++} // namespace double_conversion ++ ++#endif // DOUBLE_CONVERSION_UTILS_H_ +diff --git a/src/3rdparty/double-conversion/include/double-conversion/utils.h b/src/3rdparty/double-conversion/include/double-conversion/utils.h +index e060299d..103439a5 100644 +--- a/src/3rdparty/double-conversion/include/double-conversion/utils.h ++++ b/src/3rdparty/double-conversion/include/double-conversion/utils.h +@@ -103,7 +103,8 @@ int main(int argc, char** argv) { + defined(__riscv) || \ + defined(__or1k__) || defined(__arc__) || \ + defined(__EMSCRIPTEN__) || \ +- defined(__loongarch__) || defined(__loongarch64__) ++ defined(__loongarch__) || defined(__loongarch64__) || \ ++ defined(__sw_64__) + #define DOUBLE_CONVERSION_CORRECT_DOUBLE_OPERATIONS 1 + #elif defined(__mc68000__) || \ + defined(__pnacl__) || defined(__native_client__) +diff --git a/src/3rdparty/sha3/brg_endian.h b/src/3rdparty/sha3/brg_endian.h +index 9bb306e6..e3907596 100644 +--- a/src/3rdparty/sha3/brg_endian.h ++++ b/src/3rdparty/sha3/brg_endian.h +@@ -105,6 +105,7 @@ Changes for ARM 9/9/2010 [Downstream relative to Gladman's GitHub, upstream to Q + #if !defined(PLATFORM_BYTE_ORDER) + + #if defined( __alpha__ ) || defined( __alpha ) || defined( i386 ) || \ ++#if defined( __sw_64__ ) || defined( __sw_64 ) || \ + defined( __i386__ ) || defined( _M_I86 ) || defined( _M_IX86 ) || \ + defined( __OS2__ ) || defined( sun386 ) || defined( __TURBOC__ ) || \ + defined( vax ) || defined( vms ) || defined( VMS ) || \ +diff --git a/src/corelib/io/qfilesystemwatcher_inotify.cpp b/src/corelib/io/qfilesystemwatcher_inotify.cpp +index 27e0b13b..70d406f4 100644 +--- a/src/corelib/io/qfilesystemwatcher_inotify.cpp ++++ b/src/corelib/io/qfilesystemwatcher_inotify.cpp +@@ -91,6 +91,10 @@ + # define __NR_inotify_add_watch 285 + # define __NR_inotify_rm_watch 286 + # define __NR_inotify_init1 324 ++#elif defined (__sw_64__) ++# define __NR_inotify_init 444 ++# define __NR_inotify_add_watch 445 ++# define __NR_inotify_rm_watch 446 + #elif defined (__alpha__) + # define __NR_inotify_init 444 + # define __NR_inotify_add_watch 445 +diff --git a/src/gui/image/qimage.cpp b/src/gui/image/qimage.cpp +index 1389fcfa..9af539cb 100644 +--- a/src/gui/image/qimage.cpp ++++ b/src/gui/image/qimage.cpp +@@ -83,6 +83,10 @@ static inline bool isLocked(QImageData *data) + return data != nullptr && data->is_locked; + } + ++#if defined(Q_CC_DEC) && defined(__sw_64) && (__DECCXX_VER-0 >= 50190001) ++#pragma message disable narrowptr ++#endif ++ + #if defined(Q_CC_DEC) && defined(__alpha) && (__DECCXX_VER-0 >= 50190001) + #pragma message disable narrowptr + #endif +diff --git a/src/testlib/3rdparty/cycle_p.h b/src/testlib/3rdparty/cycle_p.h +index 95e741a8..5577b873 100644 +--- a/src/testlib/3rdparty/cycle_p.h ++++ b/src/testlib/3rdparty/cycle_p.h +@@ -405,6 +405,26 @@ INLINE_ELAPSED(__inline__) + + #define HAVE_TICK_COUNTER + #endif ++/*----------------------------------------------------------------*/ ++#if defined(__GNUC__) && defined(__sw_64__) && !defined(HAVE_TICK_COUNTER) ++/* ++ * The 32-bit cycle counter on sw_64 overflows pretty quickly, ++ * unfortunately. A 1GHz machine overflows in 4 seconds. ++ */ ++typedef unsigned int CycleCounterTicks; ++ ++static __inline__ CycleCounterTicks getticks(void) ++{ ++ unsigned long cc; ++ __asm__ __volatile__ ("rtc %0" : "=r"(cc)); ++ return (cc & 0xFFFFFFFF); ++} ++ ++INLINE_ELAPSED(__inline__) ++ ++#define HAVE_TICK_COUNTER ++#endif ++ + /*----------------------------------------------------------------*/ + #if defined(__GNUC__) && defined(__alpha__) && !defined(HAVE_TICK_COUNTER) + /* +@@ -441,6 +461,22 @@ INLINE_ELAPSED(__inline__) + #define HAVE_TICK_COUNTER + #endif + ++/*----------------------------------------------------------------*/ ++#if (defined(__DECC) || defined(__DECCXX)) && defined(__sw_64) && defined(HAVE_C_ASM_H) && !defined(HAVE_TICK_COUNTER) ++# include ++typedef unsigned int CycleCounterTicks; ++ ++static __inline CycleCounterTicks getticks(void) ++{ ++ unsigned long cc; ++ cc = asm("rtc %v0"); ++ return (cc & 0xFFFFFFFF); ++} ++ ++INLINE_ELAPSED(__inline) ++ ++#define HAVE_TICK_COUNTER ++#endif + /*----------------------------------------------------------------*/ + #if (defined(__DECC) || defined(__DECCXX)) && defined(__alpha) && defined(HAVE_C_ASM_H) && !defined(HAVE_TICK_COUNTER) + # include +-- +2.31.1 + diff --git a/qt5-qtbase.spec b/qt5-qtbase.spec index 71eacc7..ce26d2b 100644 --- a/qt5-qtbase.spec +++ b/qt5-qtbase.spec @@ -1,4 +1,4 @@ -%define anolis_release .0.1 +%define anolis_release .0.2 # See http://bugzilla.redhat.com/223663 %global multilib_archs x86_64 %{ix86} %{?mips} ppc64 ppc s390x s390 sparc64 sparcv9 %global multilib_basearchs x86_64 %{?mips64} ppc64 s390x sparc64 @@ -178,6 +178,7 @@ Patch1068: QTBUG-95942-Fix-text-ellipsis-not-implemented-in-Tibetan.patch Patch1070: qt5-qtbase-fix-bug108222-linewrap-carriage_return-different_rowspacing.patch Patch1071: remove-the-X11-True-and-False.patch #End +Patch1072: 0001-qtbase-add-sw.patch # Do not check any files in %%{_qt5_plugindir}/platformthemes/ for requires. # Those themes are there for platform integration. If the required libraries are @@ -485,6 +486,7 @@ Qt5 libraries used for drawing widgets and OpenGL items. %patch1070 -p1 %patch1071 -p1 #End +%patch1072 -p1 # move some bundled libs to ensure they're not accidentally used pushd src/3rdparty @@ -1159,6 +1161,9 @@ fi %changelog +* Wed Jul 19 2023 wxiat - 5.15.3-1.0.2 +- add sw arch + * Mon Dec 12 2022 liuzhilin - 5.15.3-1.0.1 - fix:add support loongarch64 - feature: add patchs for DDE (liuxingwei@uniontech.com) -- Gitee