Warning, /sdk/kde-dev-scripts/kde.supp is written in an unsupported language. File is not indexed.

 #
 # Some valgrind suppressions handy for ignoring stuff we don't care
 # about when valgrinding kde applications
 #
 # Library paths and versions from debian unstable, YMMV
 #
 
 #
 # ld.so errors
 #
 
 {
     strchr/decompose_rpath/_dl_map_object
     MemCheck:Cond
     fun:strchr
     fun:decompose_rpath
     fun:_dl_map_object
 }
 
 {
     strlen/libc/_dl_catch_error
     MemCheck:Cond
     fun:strlen
     fun:_dl_open
     obj:*libdl-2*.so
     fun:_dl_catch_error*
 }
 
 {
     addr8/dl_catch_error
     MemCheck:Addr8
     ...
     fun:_dl_catch_error*
 }
 
 {
     strchr/libc/_dl_catch_error
     MemCheck:Cond
     fun:strchr
     obj:*libc-2.2.?.so
     fun:_dl_catch_error
 }
 
 {
     strrchr/_dl_map_object_from_fd/_dl_map_object
     MemCheck:Cond
     fun:strrchr
     fun:_dl_map_object_from_fd
     fun:_dl_map_object
 }
 
 # Needed with /lib/ld-2.12.1.so
 {
    index/expand_dynamic_string_token/_dl_map_object
    Memcheck:Cond
    fun:index
    fun:expand_dynamic_string_token
    fun:_dl_map_object
 }
 
 {
    strlen/_dl_signal_cerror/_dl_lookup_symbol_internal
    Memcheck:Cond
    fun:strlen
    fun:_dl_signal_cerror
    fun:_dl_lookup_symbol_internal
    fun:*dlsym
 }
 
 #
 # X library errors
 #
 
 {
     libXft(Cond)
     MemCheck:Cond
     obj:/usr/X11R6/lib/libXft.so.1.1
     obj:/usr/X11R6/lib/libXft.so.1.1
 }
 
 {
    write(buf)/libc/libICE
    Memcheck:Param
    write(buf)
    fun:__GI___libc_write
    fun:_IceTransWrite
    fun:_IceWrite
    fun:IceFlush
 }
 
 {
    write(buf)/libc/libICE(nosymbols)
    Memcheck:Param
    write(buf)
    fun:__write_nocancel
    obj:/usr/lib*/libICE.so.*
    obj:/usr/lib*/libICE.so.*
 }
 
 {
    write(buf)/libc/libICE(variant)
    Memcheck:Param
    write(buf)
    obj:/lib/libpthread-*.so
    obj:/usr/lib/libICE.so.*
    fun:_IceWrite
    fun:IceFlush
 }
 
 {
    write(buf)/libc/libX11
    Memcheck:Param
    write(buf)
    fun:__GI___libc_write
    fun:_X11TransWrite
    fun:_XFlushInt
    fun:_XFlush
 }
 
 {
    write(buf)/libc/libX11
    Memcheck:Param
    write(buf)
    fun:__GI___libc_write
    fun:_X11TransWrite
    fun:_XFlushInt
    fun:_XReply
 }
 
 {
    writev(vector[...])
    Memcheck:Param
    writev(vector[...])
    fun:*writev
    obj:libX11.so.*
    fun:_X11TransWritev
    fun:_XSend
 }
 
 #
 # SSL errors
 #
 
 {
     various1/libcrypto
     Memcheck:Value4
     obj:*libcrypto.so.0.9.7
 }
 
 {
     various2/libcrypto
     Memcheck:Cond
     obj:*libcrypto.so.0.9.7
 }
 
 {
     ssl3_read_bytes1/libssl
     Memcheck:Cond
     fun:memcpy
     fun:ssl3_read_bytes
 }
 
 {
     ssl3_read_bytes2/libssl
     Memcheck:Cond
     fun:ssl3_read_bytes
 }
 
 {
     ssl3_get_message/libssl
     Memcheck:Cond
     fun:ssl3_get_message
 }
 
 # zlib-1.2.x uses uninitialised memory in some tricky way which
 # apparently is harmless (it must amount to a vectorised while-loop,
 # nothing else makes sense).  Fools Memcheck though.  See the mentioned
 # URL for details.
 
 # Valgrind has this in default.supp but only for deflate, not for uncompress/inflateInit2
 {
    zlib-1.2.x trickyness (1): See http://www.zlib.net/zlib_faq.html#faq36
    Memcheck:Cond
    obj:/*lib*/libz.so.1.2.*
    ...
    fun:inflateInit2*
 }
 
 # Qt uses the waitid syscall in strange ways, to detect forkfd support
 {
    sys_waitid from qtbase/src/3rdparty/forkfd/forkfd_linux.c
    Memcheck:Param
    waitid(infop)
    fun:syscall
    fun:_ZL10sys_waitidiiP9siginfo_tiP6rusage
 }
 
 # Leakcheck suppressions
 {
    dlopen_worker_malloc
    Memcheck:Leak
    fun:malloc
    ...
    fun:dl_open_worker
 }
 
 {
    dlopen_worker_calloc
    Memcheck:Leak
    fun:calloc
    ...
    fun:dl_open_worker
 }
 
 {
    fontconfig_init
    Memcheck:Leak
    ...
    fun:FcInit
 }
 
 # Helgrind suppressions
 # Most of them (apart from the first one) are probably real,
 # but they're deep inside Qt, and usually not what we want to see
 # when debugging a threading issue in a KDE application.
 {
    QMutex_qt4_unlock_false_race
    Helgrind:Race
    fun:_ZN6QMutex6unlockEv
 }
 {
    QMutex_qt4_lock_false_race
    Helgrind:Race
    fun:_ZN6QMutex4lockEv
 }
 {
    # Qt4 qmutex_p.h, see maximumSpinTime declared as "volatile qint64"...
    QMutex_lockInternal_real_race
    Helgrind:Race
    fun:_ZN6QMutex12lockInternalEv
 }
 {
    # (Qt5) QMutex::lock checks a bool that is set by the QMutex constructor.
    # To use a mutex from another thread, some synchronization must have happened
    # already, which propagated this non-atomic write. Helgrind doesn't catch that.
    QMutex_isRecursive_false_race
    Helgrind:Race
    fun:_ZL11isRecursiveP10QMutexData
    fun:_ZN6QMutex4lockEv
 }
 {
    # Qt5: helgrind doesn't understand the atomic-operation calls inside QMutex
    Qt5_lockInternal
    Helgrind:Race
    ...
    fun:_ZN11QBasicMutex12lockInternalEv
 }
 {
    # Qt5: helgrind doesn't understand the atomic-operation calls inside QMutex
    Qt5_unlockInternal
    Helgrind:Race
    ...
    fun:_ZN11QBasicMutex14unlockInternalEv
 }
 {
    # Qt5: helgrind doesn't understand the atomic-operation calls inside QMutex
    Qt5_QMutex_unlock
    Helgrind:Race
    ...
    fun:_ZN6QMutex6unlockEv
 }
 {
    # Qt5: helgrind doesn't understand the atomic-operation calls inside QMutex
    Qt5_QMutex_lock
    Helgrind:Race
    ...
    fun:_ZN6QMutex4lockEv
 }
 {
    # Qt5: helgrind doesn't understand the atomic-operation calls
    Qt5_release_refcount
    Helgrind:Race
    ...
    fun:_ZN9QtPrivate8RefCount3refEv
 }
 {
    # Qt5 in release mode
    Qt5_release_basicmutex_isrecursive
    Helgrind:Race
    fun:_ZN11QBasicMutex11isRecursiveEv
 }
 
 {
    # I don't really see a problem with fork+exit "exiting while still holding one mutex".
    # I think helgrind just doesn't notice that we forked before calling exit -> TODO: report hg bug
    Helgrind_Exit
    Helgrind:Misc
    fun:_Exit
 }
 {
    deallocate_stack
    Helgrind:Race
    fun:__deallocate_stack
    fun:start_thread
    fun:clone
 }
 {
    qt_thread_data_race
    Helgrind:Race
    fun:_ZL15set_thread_dataP11QThreadData
    fun:_ZN14QThreadPrivate5startEPv
 }
 {
    timerId_race_in_qt4
    Helgrind:Race
    fun:_ZN31QAbstractEventDispatcherPrivate14releaseTimerIdEi
 }
 {
    timerId_second_race_in_qt4
    Helgrind:Race
    fun:_ZN31QAbstractEventDispatcherPrivate15allocateTimerIdEv
 }
 {
    QPointer_race_in_qt4
    Helgrind:Race
    fun:_ZNK5QHashIP7QObjectPS1_E7isEmptyEv
    fun:_ZN11QMetaObject11removeGuardEPP7QObject
 }
 
 # Helgrind suppressions for atomic operations.
 # This is because helgrind/drd cannot tell that they are atomic operations, on x86. The machine code is exactly the same.
 {
    QBasicAtomicPointer
    Helgrind:Race
    # catch load*, store*, and the qt4 operators
    ...
    fun:_*QBasicAtomicPointer*
 }
 {
    QBasicAtomicInt
    Helgrind:Race
    # catch Int and Integer, load, loadAcquire, store, storeRelease, testAndSet*, etc.
    ...
    fun:_*QBasicAtomicInt*
 }
 {
    Qt_5_9_atomic_ops
    Helgrind:Race
    ...
    fun:loadAcquire
 }
 
 # Additional helgrind suppressions: these are actual atomic operations,
 # but if they conflict with a suppressed store(), helgrind will warn anyway -- https://bugs.kde.org/show_bug.cgi?id=317381
 {
    QBasicAtomicOps_fetchAndStore
    Helgrind:Race
    fun:_ZN15QBasicAtomicOps*fetchAndStore*
 }
 {
    QBasicAtomicOps_testAndSet
    Helgrind:Race
    fun:_ZN15QBasicAtomicOps*testAndSet*
 }
 {
    QBasicAtomicOps_ref
    Helgrind:Race
    fun:_ZN15QBasicAtomicOps*ref*
 }
 
 ## Same for DRD (tested with Qt5 only)
 {
    QBasicAtomic_load_drd
    drd:ConflictingAccess
    # catch load and loadAcquire
    fun:_ZNK19QBasicAtomic*load*
 }
 {
    QBasicAtomic_store_drd
    drd:ConflictingAccess
    # catch store and storeRelease
    fun:_ZN19QBasicAtomic*store*
 }
 {
    QBasicAtomicOps_fetchAndStore_drd
    drd:ConflictingAccess
    fun:_ZN15QBasicAtomicOps*fetchAndStore*
 }
 {
    QBasicAtomicOps_testAndSet_drd
    drd:ConflictingAccess
    fun:_ZN15QBasicAtomicOps*testAndSet*
 }
 
 # fixup QOrderedMutexLocker, see https://bugs.kde.org/show_bug.cgi?id=243232
 {
    QOrderedMutexLocker_relock_tryLock
    Helgrind:LockOrder
    fun:QMutex_tryLock_int_WRK
    fun:_ZN19QOrderedMutexLocker6relockEP6QMutexS1_
 }
 
 {
    QOrderedMutexLocker_relock_lock
    Helgrind:LockOrder
    fun:QMutex_lock_WRK
    fun:_ZN19QOrderedMutexLocker6relockEP6QMutexS1_
 }
 
 {
    QOrderedMutexLocker_relock2_tryLock
    Helgrind:LockOrder
    fun:QMutex_tryLock_int_WRK
    fun:_ZN19QOrderedMutexLocker6relockEv
 }
 {
    QOrderedMutexLocker_relock2_lock
    Helgrind:LockOrder
    fun:QMutex_lock_WRK
    fun:_ZN19QOrderedMutexLocker6relockEv
 }
 
 # glib event loop integration, alternatively use QT_NO_GLIB=1
 
 {
    glib_event_loop
    Helgrind:Race
    fun:g_private_get
    obj:/usr/lib/libglib-*
    fun:g_main_context_dispatch
    obj:/usr/lib/libglib-*
    fun:g_main_context_iteration
 }
 
 # C atomic operations
 
 {
    AO_store
    Helgrind:Race
    fun:AO_store
 }
 {
    AO_load
    Helgrind:Race
    fun:AO_load
 }
 {
    AO_compare_and_swap
    Helgrind:Race
    fun:AO_compare_and_swap
 }
 
 # C++ atomic operations
 
 {
    atomic_store
    Helgrind:Race
    fun:store
    fun:_ZN*St*atomic*
 }
 {
    atomic_load
    Helgrind:Race
    fun:load
    fun:_ZN*St*atomic*
 }