#
# 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*
}

{
    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*
}

# 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*
}

# 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*
}