[SCM] qtbase packaging branch, master, updated. debian/5.2.0+dfsg-6-3-gdd85a4c
Lisandro Damián Nicanor Pérez
lisandro at moszumanska.debian.org
Fri Jan 31 15:35:36 UTC 2014
Gitweb-URL: http://git.debian.org/?p=pkg-kde/qt/qtbase.git;a=commitdiff;h=1c98d15
The following commit has been merged in the master branch:
commit 1c98d15bf474b23b03c8f1cee5f26f2ae49a9276
Author: Lisandro Damián Nicanor Pérez Meyer <perezmeyer at gmail.com>
Date: Thu Jan 2 16:40:58 2014 -0300
Workaround sparc's FTBFS due to it's qatomic code.
Please take a look at the patch's description to unsderstand this.
---
debian/changelog | 3 +
debian/patches/change_sparc_qatomic.patch | 510 ++++++++++++++++++++++++++++++
debian/patches/series | 1 +
3 files changed, 514 insertions(+)
diff --git a/debian/changelog b/debian/changelog
index d0890f3..d910ae8 100644
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,5 +1,8 @@
qtbase-opensource-src (5.2.0+dfsg-5) UNRELEASED; urgency=medium
+ [ Lisandro Damián Nicanor Pérez Meyer ]
+ * Workaround sparc's FTBFS due to it's qatomic code.
+
-- Debian Qt/KDE Maintainers <debian-qt-kde at lists.debian.org> Thu, 02 Jan 2014 16:38:35 -0300
qtbase-opensource-src (5.2.0+dfsg-4) experimental; urgency=medium
diff --git a/debian/patches/change_sparc_qatomic.patch b/debian/patches/change_sparc_qatomic.patch
new file mode 100644
index 0000000..28bb326
--- /dev/null
+++ b/debian/patches/change_sparc_qatomic.patch
@@ -0,0 +1,510 @@
+Description: use qatomic_gcc on sparc to avoid a FTBFS.
+ At first sight you would think that qatomic_sparc would need a fix. But
+ it happens that qatomic_sparc.h has not been ported to the new infrastucture
+ of Qt5 and has already been removed in the development branch. Then those
+ arches not ported will need to use qatomic_gcc, qatomic_unix or being ported.
+ .
+ In this way we ensure that we can detect sparc, avoid the FTBFS of the qatomic
+ header and the FTBFS caused by the header's tests (see
+ do_not_pass_wcast-align_on_sparc.patch).
+ .
+ This patch should be kept as Debian-specific and possibly be removed with
+ Qt 5.3.0.
+Author: Lisandro Damián Nicanor Pérez Meyer <lisandro at debian.org>
+Forwarded: not-needed
+
+--- a/src/corelib/arch/qatomic_sparc.h
++++ b/src/corelib/arch/qatomic_sparc.h
+@@ -42,491 +42,6 @@
+ #ifndef QATOMIC_SPARC_H
+ #define QATOMIC_SPARC_H
+
+-#include <QtCore/qoldbasicatomic.h>
+-
+-QT_BEGIN_NAMESPACE
+-
+-#if 0
+-// silence syncqt warnings
+-QT_END_NAMESPACE
+-QT_END_HEADER
+-
+-#pragma qt_sync_skip_header_check
+-#pragma qt_sync_stop_processing
+-#endif
+-
+-#if defined(_LP64)
+-
+-#define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_ALWAYS_NATIVE
+-
+-inline bool QBasicAtomicInt::isReferenceCountingNative()
+-{ return true; }
+-inline bool QBasicAtomicInt::isReferenceCountingWaitFree()
+-{ return false; }
+-
+-#define Q_ATOMIC_INT_TEST_AND_SET_IS_ALWAYS_NATIVE
+-#define Q_ATOMIC_INT_TEST_AND_SET_IS_WAIT_FREE
+-
+-inline bool QBasicAtomicInt::isTestAndSetNative()
+-{ return true; }
+-inline bool QBasicAtomicInt::isTestAndSetWaitFree()
+-{ return true; }
+-
+-#define Q_ATOMIC_INT_FETCH_AND_STORE_IS_ALWAYS_NATIVE
+-#define Q_ATOMIC_INT_FETCH_AND_STORE_IS_WAIT_FREE
+-
+-inline bool QBasicAtomicInt::isFetchAndStoreNative()
+-{ return true; }
+-inline bool QBasicAtomicInt::isFetchAndStoreWaitFree()
+-{ return true; }
+-
+-#define Q_ATOMIC_INT_FETCH_AND_ADD_IS_ALWAYS_NATIVE
+-
+-inline bool QBasicAtomicInt::isFetchAndAddNative()
+-{ return true; }
+-inline bool QBasicAtomicInt::isFetchAndAddWaitFree()
+-{ return false; }
+-
+-#define Q_ATOMIC_POINTER_TEST_AND_SET_IS_ALWAYS_NATIVE
+-#define Q_ATOMIC_POINTER_TEST_AND_SET_IS_WAIT_FREE
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isTestAndSetNative()
+-{ return true; }
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isTestAndSetWaitFree()
+-{ return true; }
+-
+-#define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_ALWAYS_NATIVE
+-#define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_WAIT_FREE
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndStoreNative()
+-{ return true; }
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndStoreWaitFree()
+-{ return true; }
+-
+-#define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_ALWAYS_NATIVE
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddNative()
+-{ return true; }
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree()
+-{ return false; }
+-
+-extern "C" {
+- Q_CORE_EXPORT int q_atomic_increment(volatile int *ptr);
+- Q_CORE_EXPORT int q_atomic_decrement(volatile int *ptr);
+-
+- Q_CORE_EXPORT int q_atomic_test_and_set_int(volatile int *ptr, int expected, int newval);
+- Q_CORE_EXPORT int q_atomic_test_and_set_acquire_int(volatile int *ptr,
+- int expected,
+- int newval);
+- Q_CORE_EXPORT int q_atomic_test_and_set_release_int(volatile int *ptr,
+- int expected,
+- int newval);
+-
+- Q_CORE_EXPORT int q_atomic_set_int(volatile int *ptr, int newval);
+- Q_CORE_EXPORT int q_atomic_fetch_and_store_acquire_int(volatile int *ptr, int newval);
+- Q_CORE_EXPORT int q_atomic_fetch_and_store_release_int(volatile int *ptr, int newval);
+-
+- Q_CORE_EXPORT int q_atomic_fetch_and_add_int(volatile int *ptr, int value);
+- Q_CORE_EXPORT int q_atomic_fetch_and_add_acquire_int(volatile int *ptr, int value);
+- Q_CORE_EXPORT int q_atomic_fetch_and_add_release_int(volatile int *ptr, int value);
+-
+- Q_CORE_EXPORT int q_atomic_test_and_set_ptr(volatile void *ptr, const void *expected, const void *newval);
+- Q_CORE_EXPORT int q_atomic_test_and_set_acquire_ptr(volatile void *ptr,
+- const void *expected,
+- const void *newval);
+- Q_CORE_EXPORT int q_atomic_test_and_set_release_ptr(volatile void *ptr,
+- const void *expected,
+- const void *newval);
+-
+- Q_CORE_EXPORT void *q_atomic_set_ptr(volatile void *ptr, const void *newval);
+- Q_CORE_EXPORT void *q_atomic_fetch_and_store_acquire_ptr(volatile void *ptr, const void *newval);
+- Q_CORE_EXPORT void *q_atomic_fetch_and_store_release_ptr(volatile void *ptr, const void *newval);
+-
+- Q_CORE_EXPORT void *q_atomic_fetch_and_add_ptr(volatile void *ptr, int value);
+- Q_CORE_EXPORT void *q_atomic_fetch_and_add_acquire_ptr(volatile void *ptr, int value);
+- Q_CORE_EXPORT void *q_atomic_fetch_and_add_release_ptr(volatile void *ptr, int value);
+-}
+-
+-inline bool QBasicAtomicInt::ref()
+-{
+- return fetchAndAddRelaxed(1) != -1;
+-}
+-
+-inline bool QBasicAtomicInt::deref()
+-{
+- return fetchAndAddRelaxed(-1) != 1;
+-}
+-
+-inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
+-{
+- return q_atomic_test_and_set_int(&_q_value, expectedValue, newValue) != 0;
+-}
+-
+-inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
+-{
+- return q_atomic_test_and_set_acquire_int(&_q_value, expectedValue, newValue) != 0;
+-}
+-
+-inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
+-{
+- return q_atomic_test_and_set_release_int(&_q_value, expectedValue, newValue) != 0;
+-}
+-
+-inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
+-{
+- return q_atomic_test_and_set_acquire_int(&_q_value, expectedValue, newValue) != 0;
+-}
+-
+-inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
+-{
+- return q_atomic_set_int(&_q_value, newValue);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
+-{
+- return q_atomic_fetch_and_store_acquire_int(&_q_value, newValue);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
+-{
+- return q_atomic_fetch_and_store_release_int(&_q_value, newValue);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
+-{
+- return q_atomic_fetch_and_store_acquire_int(&_q_value, newValue);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndAddRelaxed(int newValue)
+-{
+- return q_atomic_fetch_and_add_int(&_q_value, newValue);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndAddAcquire(int newValue)
+-{
+- return q_atomic_fetch_and_add_acquire_int(&_q_value, newValue);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndAddRelease(int newValue)
+-{
+- return q_atomic_fetch_and_add_release_int(&_q_value, newValue);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndAddOrdered(int newValue)
+-{
+- return q_atomic_fetch_and_add_acquire_int(&_q_value, newValue);
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
+-{
+- return q_atomic_test_and_set_ptr(&_q_value, expectedValue, newValue) != 0;
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
+-{
+- return q_atomic_test_and_set_acquire_ptr(&_q_value, expectedValue, newValue) != 0;
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
+-{
+- return q_atomic_test_and_set_release_ptr(&_q_value, expectedValue, newValue) != 0;
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
+-{
+- return q_atomic_test_and_set_acquire_ptr(&_q_value, expectedValue, newValue) != 0;
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
+-{
+- return reinterpret_cast<T *>(q_atomic_set_ptr(&_q_value, newValue));
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
+-{
+- return reinterpret_cast<T *>(q_atomic_fetch_and_store_acquire_ptr(&_q_value, newValue));
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
+-{
+- return reinterpret_cast<T *>(q_atomic_fetch_and_store_release_ptr(&_q_value, newValue));
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
+-{
+- return reinterpret_cast<T *>(q_atomic_fetch_and_store_acquire_ptr(&_q_value, newValue));
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
+-{
+- return reinterpret_cast<T *>(q_atomic_fetch_and_add_ptr(&_q_value, valueToAdd * sizeof(T)));
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE
+-T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd)
+-{
+- return reinterpret_cast<T *>(q_atomic_fetch_and_add_acquire_ptr(&_q_value, valueToAdd * sizeof(T)));
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd)
+-{
+- return reinterpret_cast<T *>(q_atomic_fetch_and_add_release_ptr(&_q_value, valueToAdd * sizeof(T)));
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
+-{
+- return reinterpret_cast<T *>(q_atomic_fetch_and_add_acquire_ptr(&_q_value, valueToAdd * sizeof(T)));
+-}
+-
+-#else
+-
+-#define Q_ATOMIC_INT_REFERENCE_COUNTING_IS_NOT_NATIVE
+-
+-inline bool QBasicAtomicInt::isReferenceCountingNative()
+-{ return false; }
+-inline bool QBasicAtomicInt::isReferenceCountingWaitFree()
+-{ return false; }
+-
+-#define Q_ATOMIC_INT_TEST_AND_SET_IS_NOT_NATIVE
+-
+-inline bool QBasicAtomicInt::isTestAndSetNative()
+-{ return false; }
+-inline bool QBasicAtomicInt::isTestAndSetWaitFree()
+-{ return false; }
+-
+-#define Q_ATOMIC_INT_FETCH_AND_STORE_IS_ALWAYS_NATIVE
+-#define Q_ATOMIC_INT_FETCH_AND_STORE_IS_WAIT_FREE
+-
+-inline bool QBasicAtomicInt::isFetchAndStoreNative()
+-{ return true; }
+-inline bool QBasicAtomicInt::isFetchAndStoreWaitFree()
+-{ return true; }
+-
+-#define Q_ATOMIC_INT_FETCH_AND_ADD_IS_NOT_NATIVE
+-
+-inline bool QBasicAtomicInt::isFetchAndAddNative()
+-{ return false; }
+-inline bool QBasicAtomicInt::isFetchAndAddWaitFree()
+-{ return false; }
+-
+-#define Q_ATOMIC_POINTER_TEST_AND_SET_IS_NOT_NATIVE
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isTestAndSetNative()
+-{ return false; }
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isTestAndSetWaitFree()
+-{ return false; }
+-
+-#define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_ALWAYS_NATIVE
+-#define Q_ATOMIC_POINTER_FETCH_AND_STORE_IS_WAIT_FREE
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndStoreNative()
+-{ return true; }
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndStoreWaitFree()
+-{ return true; }
+-
+-#define Q_ATOMIC_POINTER_FETCH_AND_ADD_IS_NOT_NATIVE
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddNative()
+-{ return false; }
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::isFetchAndAddWaitFree()
+-{ return false; }
+-
+-extern "C" {
+- Q_CORE_EXPORT int q_atomic_lock_int(volatile int *addr);
+- Q_CORE_EXPORT int q_atomic_lock_ptr(volatile void *addr);
+- Q_CORE_EXPORT void q_atomic_unlock(volatile void *addr, int value);
+- Q_CORE_EXPORT int q_atomic_set_int(volatile int *ptr, int newval);
+- Q_CORE_EXPORT void *q_atomic_set_ptr(volatile void *ptr, void *newval);
+-} // extern "C"
+-
+-inline bool QBasicAtomicInt::ref()
+-{
+- const int val = q_atomic_lock_int(&_q_value);
+- q_atomic_unlock(&_q_value, val + 1);
+- return val != -1;
+-}
+-
+-inline bool QBasicAtomicInt::deref()
+-{
+- const int val = q_atomic_lock_int(&_q_value);
+- q_atomic_unlock(&_q_value, val - 1);
+- return val != 1;
+-}
+-
+-inline bool QBasicAtomicInt::testAndSetOrdered(int expectedValue, int newValue)
+-{
+- int val = q_atomic_lock_int(&_q_value);
+- if (val == expectedValue) {
+- q_atomic_unlock(&_q_value, newValue);
+- return true;
+- }
+- q_atomic_unlock(&_q_value, val);
+- return false;
+-}
+-
+-inline bool QBasicAtomicInt::testAndSetRelaxed(int expectedValue, int newValue)
+-{
+- return testAndSetOrdered(expectedValue, newValue);
+-}
+-
+-inline bool QBasicAtomicInt::testAndSetAcquire(int expectedValue, int newValue)
+-{
+- return testAndSetOrdered(expectedValue, newValue);
+-}
+-
+-inline bool QBasicAtomicInt::testAndSetRelease(int expectedValue, int newValue)
+-{
+- return testAndSetOrdered(expectedValue, newValue);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndStoreOrdered(int newValue)
+-{
+- return q_atomic_set_int(&_q_value, newValue);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndStoreRelaxed(int newValue)
+-{
+- return fetchAndStoreOrdered(newValue);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndStoreAcquire(int newValue)
+-{
+- return fetchAndStoreOrdered(newValue);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndStoreRelease(int newValue)
+-{
+- return fetchAndStoreOrdered(newValue);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndAddOrdered(int valueToAdd)
+-{
+- const int originalValue = q_atomic_lock_int(&_q_value);
+- q_atomic_unlock(&_q_value, originalValue + valueToAdd);
+- return originalValue;
+-}
+-
+-inline int QBasicAtomicInt::fetchAndAddRelaxed(int valueToAdd)
+-{
+- return fetchAndAddOrdered(valueToAdd);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndAddAcquire(int valueToAdd)
+-{
+- return fetchAndAddOrdered(valueToAdd);
+-}
+-
+-inline int QBasicAtomicInt::fetchAndAddRelease(int valueToAdd)
+-{
+- return fetchAndAddOrdered(valueToAdd);
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetOrdered(T *expectedValue, T *newValue)
+-{
+- T *val = reinterpret_cast<T *>(q_atomic_lock_ptr(&_q_value));
+- if (val == expectedValue) {
+- q_atomic_unlock(&_q_value, reinterpret_cast<int>(newValue));
+- return true;
+- }
+- q_atomic_unlock(&_q_value, reinterpret_cast<int>(val));
+- return false;
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelaxed(T *expectedValue, T *newValue)
+-{
+- return testAndSetOrdered(expectedValue, newValue);
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetAcquire(T *expectedValue, T *newValue)
+-{
+- return testAndSetOrdered(expectedValue, newValue);
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE bool QBasicAtomicPointer<T>::testAndSetRelease(T *expectedValue, T *newValue)
+-{
+- return testAndSetOrdered(expectedValue, newValue);
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreOrdered(T *newValue)
+-{
+- return reinterpret_cast<T *>(q_atomic_set_ptr(&_q_value, newValue));
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelaxed(T *newValue)
+-{
+- return fetchAndStoreOrdered(newValue);
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreAcquire(T *newValue)
+-{
+- return fetchAndStoreOrdered(newValue);
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndStoreRelease(T *newValue)
+-{
+- return fetchAndStoreOrdered(newValue);
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddOrdered(qptrdiff valueToAdd)
+-{
+- T *originalValue = reinterpret_cast<T *>(q_atomic_lock_ptr(&_q_value));
+- q_atomic_unlock(&_q_value, int(originalValue + valueToAdd));
+- return originalValue;
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelaxed(qptrdiff valueToAdd)
+-{
+- return fetchAndAddOrdered(valueToAdd);
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddAcquire(qptrdiff valueToAdd)
+-{
+- return fetchAndAddOrdered(valueToAdd);
+-}
+-
+-template <typename T>
+-Q_INLINE_TEMPLATE T *QBasicAtomicPointer<T>::fetchAndAddRelease(qptrdiff valueToAdd)
+-{
+- return fetchAndAddOrdered(valueToAdd);
+-}
+-
+-#endif // _LP64
+-
+-QT_END_NAMESPACE
++#include "qatomic_gcc.h"
+
+ #endif // QATOMIC_SPARC_H
diff --git a/debian/patches/series b/debian/patches/series
index e3c33cb..bd7f15c 100644
--- a/debian/patches/series
+++ b/debian/patches/series
@@ -11,4 +11,5 @@ enable_sparc_detection.patch
do_not_pass_wcast-align_on_sparc.patch
# Debian specific.
+change_sparc_qatomic.patch
remove_google_adsense.patch
--
qtbase packaging
More information about the pkg-kde-commits
mailing list