Home | History | Annotate | Download | only in drd
      1 /*
      2   ----------------------------------------------------------------
      3 
      4   Notice that the following BSD-style license applies to this one
      5   file (drd.h) only.  The rest of Valgrind is licensed under the
      6   terms of the GNU General Public License, version 2, unless
      7   otherwise indicated.  See the COPYING file in the source
      8   distribution for details.
      9 
     10   ----------------------------------------------------------------
     11 
     12   This file is part of DRD, a Valgrind tool for verification of
     13   multithreaded programs.
     14 
     15   Copyright (C) 2006-2015 Bart Van Assche <bvanassche (at) acm.org>.
     16   All rights reserved.
     17 
     18   Redistribution and use in source and binary forms, with or without
     19   modification, are permitted provided that the following conditions
     20   are met:
     21 
     22   1. Redistributions of source code must retain the above copyright
     23   notice, this list of conditions and the following disclaimer.
     24 
     25   2. The origin of this software must not be misrepresented; you must
     26   not claim that you wrote the original software.  If you use this
     27   software in a product, an acknowledgment in the product
     28   documentation would be appreciated but is not required.
     29 
     30   3. Altered source versions must be plainly marked as such, and must
     31   not be misrepresented as being the original software.
     32 
     33   4. The name of the author may not be used to endorse or promote
     34   products derived from this software without specific prior written
     35   permission.
     36 
     37   THIS SOFTWARE IS PROVIDED BY THE AUTHOR ``AS IS'' AND ANY EXPRESS
     38   OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
     39   WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
     40   ARE DISCLAIMED.  IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY
     41   DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
     42   DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE
     43   GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
     44   INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY,
     45   WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
     46   NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
     47   SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
     48 
     49   ----------------------------------------------------------------
     50 
     51   Notice that the above BSD-style license applies to this one file
     52   (drd.h) only.  The entire rest of Valgrind is licensed under
     53   the terms of the GNU General Public License, version 2.  See the
     54   COPYING file in the source distribution for details.
     55 
     56   ----------------------------------------------------------------
     57 */
     58 
     59 #ifndef __VALGRIND_DRD_H
     60 #define __VALGRIND_DRD_H
     61 
     62 
     63 #include "valgrind.h"
     64 
     65 
     66 /** Obtain the thread ID assigned by Valgrind's core. */
     67 #define DRD_GET_VALGRIND_THREADID                                          \
     68     (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0,                           \
     69                                    VG_USERREQ__DRD_GET_VALGRIND_THREAD_ID, \
     70                                    0, 0, 0, 0, 0)
     71 
     72 /** Obtain the thread ID assigned by DRD. */
     73 #define DRD_GET_DRD_THREADID                                            \
     74     (unsigned)VALGRIND_DO_CLIENT_REQUEST_EXPR(0,                        \
     75                                    VG_USERREQ__DRD_GET_DRD_THREAD_ID,   \
     76                                    0, 0, 0, 0, 0)
     77 
     78 
     79 /** Tell DRD not to complain about data races for the specified variable. */
     80 #define DRD_IGNORE_VAR(x) ANNOTATE_BENIGN_RACE_SIZED(&(x), sizeof(x), "")
     81 
     82 /** Tell DRD to no longer ignore data races for the specified variable. */
     83 #define DRD_STOP_IGNORING_VAR(x)                                       \
     84    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_FINISH_SUPPRESSION, \
     85                                    &(x), sizeof(x), 0, 0, 0)
     86 
     87 /**
     88  * Tell DRD to trace all memory accesses for the specified variable
     89  * until the memory that was allocated for the variable is freed.
     90  */
     91 #define DRD_TRACE_VAR(x)                                             \
     92    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_START_TRACE_ADDR, \
     93                                    &(x), sizeof(x), 0, 0, 0)
     94 
     95 /**
     96  * Tell DRD to stop tracing memory accesses for the specified variable.
     97  */
     98 #define DRD_STOP_TRACING_VAR(x)                                       \
     99    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_STOP_TRACE_ADDR, \
    100                                    &(x), sizeof(x), 0, 0, 0)
    101 
    102 /**
    103  * @defgroup RaceDetectionAnnotations Data race detection annotations.
    104  *
    105  * @see See also the source file <a href="http://code.google.com/p/data-race-test/source/browse/trunk/dynamic_annotations/dynamic_annotations.h</a>
    106 
    107  * in the ThreadSanitizer project.
    108  */
    109 /*@{*/
    110 
    111 #ifndef __HELGRIND_H
    112 
    113 /**
    114  * Tell DRD to insert a happens-before mark. addr is the address of an object
    115  * that is not a pthread synchronization object.
    116  */
    117 #define ANNOTATE_HAPPENS_BEFORE(addr)                                       \
    118    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_HAPPENS_BEFORE, \
    119                                    addr, 0, 0, 0, 0)
    120 
    121 /**
    122  * Tell DRD that the memory accesses executed after this annotation will
    123  * happen after all memory accesses performed before all preceding
    124  * ANNOTATE_HAPPENS_BEFORE(addr). addr is the address of an object that is not
    125  * a pthread synchronization object. Inserting a happens-after annotation
    126  * before any other thread has passed by a happens-before annotation for the
    127  * same address is an error.
    128  */
    129 #define ANNOTATE_HAPPENS_AFTER(addr)                                       \
    130    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_HAPPENS_AFTER, \
    131                                    addr, 0, 0, 0, 0)
    132 
    133 #else /* __HELGRIND_H */
    134 
    135 #undef ANNOTATE_CONDVAR_LOCK_WAIT
    136 #undef ANNOTATE_CONDVAR_WAIT
    137 #undef ANNOTATE_CONDVAR_SIGNAL
    138 #undef ANNOTATE_CONDVAR_SIGNAL_ALL
    139 #undef ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX
    140 #undef ANNOTATE_PUBLISH_MEMORY_RANGE
    141 #undef ANNOTATE_BARRIER_INIT
    142 #undef ANNOTATE_BARRIER_WAIT_BEFORE
    143 #undef ANNOTATE_BARRIER_WAIT_AFTER
    144 #undef ANNOTATE_BARRIER_DESTROY
    145 #undef ANNOTATE_PCQ_CREATE
    146 #undef ANNOTATE_PCQ_DESTROY
    147 #undef ANNOTATE_PCQ_PUT
    148 #undef ANNOTATE_PCQ_GET
    149 #undef ANNOTATE_BENIGN_RACE
    150 #undef ANNOTATE_BENIGN_RACE_SIZED
    151 #undef ANNOTATE_IGNORE_READS_BEGIN
    152 #undef ANNOTATE_IGNORE_READS_END
    153 #undef ANNOTATE_IGNORE_WRITES_BEGIN
    154 #undef ANNOTATE_IGNORE_WRITES_END
    155 #undef ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN
    156 #undef ANNOTATE_IGNORE_READS_AND_WRITES_END
    157 #undef ANNOTATE_NEW_MEMORY
    158 #undef ANNOTATE_TRACE_MEMORY
    159 #undef ANNOTATE_THREAD_NAME
    160 
    161 #endif /* __HELGRIND_H */
    162 
    163 /**
    164  * Tell DRD that waiting on the condition variable at address cv has succeeded
    165  * and a lock on the mutex at address mtx is now held. Since DRD always inserts
    166  * a happens before relation between the pthread_cond_signal() or
    167  * pthread_cond_broadcast() call that wakes up a pthread_cond_wait() or
    168  * pthread_cond_timedwait() call and the woken up thread, this macro has been
    169  * defined such that it has no effect.
    170  */
    171 #define ANNOTATE_CONDVAR_LOCK_WAIT(cv, mtx) do { } while(0)
    172 
    173 /**
    174  * Tell DRD that the condition variable at address cv is about to be signaled.
    175  */
    176 #define ANNOTATE_CONDVAR_SIGNAL(cv) do { } while(0)
    177 
    178 /**
    179  * Tell DRD that the condition variable at address cv is about to be signaled.
    180  */
    181 #define ANNOTATE_CONDVAR_SIGNAL_ALL(cv) do { } while(0)
    182 
    183 /**
    184  * Tell DRD that waiting on condition variable at address cv succeeded and that
    185  * the memory operations performed after this annotation should be considered
    186  * to happen after the matching ANNOTATE_CONDVAR_SIGNAL(cv). Since this is the
    187  * default behavior of DRD, this macro and the macro above have been defined
    188  * such that they have no effect.
    189  */
    190 #define ANNOTATE_CONDVAR_WAIT(cv) do { } while(0)
    191 
    192 /**
    193  * Tell DRD to consider the memory operations that happened before a mutex
    194  * unlock event and after the subsequent mutex lock event on the same mutex as
    195  * ordered. This is how DRD always behaves, so this macro has been defined
    196  * such that it has no effect.
    197  */
    198 #define ANNOTATE_PURE_HAPPENS_BEFORE_MUTEX(mtx) do { } while(0)
    199 
    200 /** Deprecated -- don't use this annotation. */
    201 #define ANNOTATE_MUTEX_IS_USED_AS_CONDVAR(mtx) do { } while(0)
    202 
    203 /**
    204  * Tell DRD to handle the specified memory range like a pure happens-before
    205  * detector would do. Since this is how DRD always behaves, this annotation
    206  * has been defined such that it has no effect.
    207  */
    208 #define ANNOTATE_PUBLISH_MEMORY_RANGE(addr, size) do { } while(0)
    209 
    210 /** Deprecated -- don't use this annotation. */
    211 #define ANNOTATE_UNPUBLISH_MEMORY_RANGE(addr, size) do { } while(0)
    212 
    213 /** Deprecated -- don't use this annotation. */
    214 #define ANNOTATE_SWAP_MEMORY_RANGE(addr, size) do { } while(0)
    215 
    216 #ifndef __HELGRIND_H
    217 
    218 /** Tell DRD that a reader-writer lock object has been initialized. */
    219 #define ANNOTATE_RWLOCK_CREATE(rwlock)                                     \
    220    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_RWLOCK_CREATE, \
    221                                    rwlock, 0, 0, 0, 0);
    222 
    223 /** Tell DRD that a reader-writer lock object has been destroyed. */
    224 #define ANNOTATE_RWLOCK_DESTROY(rwlock)                                     \
    225    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_RWLOCK_DESTROY, \
    226                                    rwlock, 0, 0, 0, 0);
    227 
    228 /**
    229  * Tell DRD that a reader-writer lock has been acquired. is_w == 1 means that
    230  * a write lock has been obtained, is_w == 0 means that a read lock has been
    231  * obtained.
    232  */
    233 #define ANNOTATE_RWLOCK_ACQUIRED(rwlock, is_w)                               \
    234    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_RWLOCK_ACQUIRED, \
    235                                    rwlock, is_w, 0, 0, 0)
    236 
    237 #endif /* __HELGRIND_H */
    238 
    239 /**
    240  * Tell DRD that a reader lock has been acquired on a reader-writer
    241  * synchronization object.
    242  */
    243 #define ANNOTATE_READERLOCK_ACQUIRED(rwlock) ANNOTATE_RWLOCK_ACQUIRED(rwlock, 0)
    244 
    245 /**
    246  * Tell DRD that a writer lock has been acquired on a reader-writer
    247  * synchronization object.
    248  */
    249 #define ANNOTATE_WRITERLOCK_ACQUIRED(rwlock) ANNOTATE_RWLOCK_ACQUIRED(rwlock, 1)
    250 
    251 #ifndef __HELGRIND_H
    252 
    253 /**
    254  * Tell DRD that a reader-writer lock is about to be released. is_w == 1 means
    255  * that a write lock is about to be released, is_w == 0 means that a read lock
    256  * is about to be released.
    257  */
    258 #define ANNOTATE_RWLOCK_RELEASED(rwlock, is_w)                               \
    259    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_RWLOCK_RELEASED, \
    260                                    rwlock, is_w, 0, 0, 0);
    261 
    262 #endif /* __HELGRIND_H */
    263 
    264 /**
    265  * Tell DRD that a reader lock is about to be released.
    266  */
    267 #define ANNOTATE_READERLOCK_RELEASED(rwlock) ANNOTATE_RWLOCK_RELEASED(rwlock, 0)
    268 
    269 /**
    270  * Tell DRD that a writer lock is about to be released.
    271  */
    272 #define ANNOTATE_WRITERLOCK_RELEASED(rwlock) ANNOTATE_RWLOCK_RELEASED(rwlock, 1)
    273 
    274 /** Tell DRD that a semaphore object is going to be initialized. */
    275 #define ANNOTATE_SEM_INIT_PRE(sem, value)                                 \
    276    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_SEM_INIT_PRE, \
    277                                    sem, value, 0, 0, 0);
    278 
    279 /** Tell DRD that a semaphore object has been destroyed. */
    280 #define ANNOTATE_SEM_DESTROY_POST(sem)                                        \
    281    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_SEM_DESTROY_POST, \
    282                                    sem, 0, 0, 0, 0);
    283 
    284 /** Tell DRD that a semaphore is going to be acquired. */
    285 #define ANNOTATE_SEM_WAIT_PRE(sem)                                        \
    286    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_SEM_WAIT_PRE, \
    287                                    sem, 0, 0, 0, 0)
    288 
    289 /** Tell DRD that a semaphore has been acquired. */
    290 #define ANNOTATE_SEM_WAIT_POST(sem)                                        \
    291    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_SEM_WAIT_POST, \
    292                                    sem, 0, 0, 0, 0)
    293 
    294 /** Tell DRD that a semaphore is going to be released. */
    295 #define ANNOTATE_SEM_POST_PRE(sem)                                        \
    296    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATE_SEM_POST_PRE, \
    297                                    sem, 0, 0, 0, 0)
    298 
    299 /*
    300  * Report that a barrier has been initialized with a given barrier count.  The
    301  * third argument specifies whether or not reinitialization is allowed, that
    302  * is, whether or not it is allowed to call barrier_init() several times
    303  * without calling barrier_destroy().
    304  */
    305 #define ANNOTATE_BARRIER_INIT(barrier, count, reinitialization_allowed) \
    306    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATION_UNIMP,    \
    307                                    "ANNOTATE_BARRIER_INIT", barrier,    \
    308                                    count, reinitialization_allowed, 0)
    309 
    310 /* Report that a barrier has been destroyed. */
    311 #define ANNOTATE_BARRIER_DESTROY(barrier)                               \
    312    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATION_UNIMP,    \
    313                                    "ANNOTATE_BARRIER_DESTROY",          \
    314                                    barrier, 0, 0, 0)
    315 
    316 /* Report that the calling thread is about to start waiting for a barrier. */
    317 #define ANNOTATE_BARRIER_WAIT_BEFORE(barrier)                           \
    318    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATION_UNIMP,    \
    319                                    "ANNOTATE_BARRIER_WAIT_BEFORE",      \
    320                                    barrier, 0, 0, 0)
    321 
    322 /* Report that the calling thread has just finished waiting for a barrier. */
    323 #define ANNOTATE_BARRIER_WAIT_AFTER(barrier)                            \
    324    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_ANNOTATION_UNIMP,    \
    325                                    "ANNOTATE_BARRIER_WAIT_AFTER",       \
    326                                    barrier, 0, 0, 0)
    327 
    328 /**
    329  * Tell DRD that a FIFO queue has been created. The abbreviation PCQ stands for
    330  * <em>producer-consumer</em>.
    331  */
    332 #define ANNOTATE_PCQ_CREATE(pcq) do { } while(0)
    333 
    334 /** Tell DRD that a FIFO queue has been destroyed. */
    335 #define ANNOTATE_PCQ_DESTROY(pcq) do { } while(0)
    336 
    337 /**
    338  * Tell DRD that an element has been added to the FIFO queue at address pcq.
    339  */
    340 #define ANNOTATE_PCQ_PUT(pcq) do { } while(0)
    341 
    342 /**
    343  * Tell DRD that an element has been removed from the FIFO queue at address pcq,
    344  * and that DRD should insert a happens-before relationship between the memory
    345  * accesses that occurred before the corresponding ANNOTATE_PCQ_PUT(pcq)
    346  * annotation and the memory accesses after this annotation. Correspondence
    347  * between PUT and GET annotations happens in FIFO order. Since locking
    348  * of the queue is needed anyway to add elements to or to remove elements from
    349  * the queue, for DRD all four FIFO annotations are defined as no-ops.
    350  */
    351 #define ANNOTATE_PCQ_GET(pcq) do { } while(0)
    352 
    353 /**
    354  * Tell DRD that data races at the specified address are expected and must not
    355  * be reported.
    356  */
    357 #define ANNOTATE_BENIGN_RACE(addr, descr) \
    358    ANNOTATE_BENIGN_RACE_SIZED(addr, sizeof(*addr), descr)
    359 
    360 /* Same as ANNOTATE_BENIGN_RACE(addr, descr), but applies to
    361    the memory range [addr, addr + size). */
    362 #define ANNOTATE_BENIGN_RACE_SIZED(addr, size, descr)                   \
    363    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_START_SUPPRESSION,   \
    364                                    addr, size, 0, 0, 0)
    365 
    366 /** Tell DRD to ignore all reads performed by the current thread. */
    367 #define ANNOTATE_IGNORE_READS_BEGIN()                                \
    368    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_RECORD_LOADS,     \
    369                                    0, 0, 0, 0, 0);
    370 
    371 
    372 /** Tell DRD to no longer ignore the reads performed by the current thread. */
    373 #define ANNOTATE_IGNORE_READS_END()                                  \
    374    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_RECORD_LOADS,     \
    375                                    1, 0, 0, 0, 0);
    376 
    377 /** Tell DRD to ignore all writes performed by the current thread. */
    378 #define ANNOTATE_IGNORE_WRITES_BEGIN()                                \
    379    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_RECORD_STORES,     \
    380                                    0, 0, 0, 0, 0)
    381 
    382 /** Tell DRD to no longer ignore the writes performed by the current thread. */
    383 #define ANNOTATE_IGNORE_WRITES_END()                                  \
    384    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_RECORD_STORES,     \
    385                                    1, 0, 0, 0, 0)
    386 
    387 /** Tell DRD to ignore all memory accesses performed by the current thread. */
    388 #define ANNOTATE_IGNORE_READS_AND_WRITES_BEGIN() \
    389    do { ANNOTATE_IGNORE_READS_BEGIN(); ANNOTATE_IGNORE_WRITES_BEGIN(); } while(0)
    390 
    391 /**
    392  * Tell DRD to no longer ignore the memory accesses performed by the current
    393  * thread.
    394  */
    395 #define ANNOTATE_IGNORE_READS_AND_WRITES_END() \
    396    do { ANNOTATE_IGNORE_READS_END(); ANNOTATE_IGNORE_WRITES_END(); } while(0)
    397 
    398 /**
    399  * Tell DRD that size bytes starting at addr has been allocated by a custom
    400  * memory allocator.
    401  */
    402 #define ANNOTATE_NEW_MEMORY(addr, size)                           \
    403    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_CLEAN_MEMORY,  \
    404                                    addr, size, 0, 0, 0)
    405 
    406 /** Ask DRD to report every access to the specified address. */
    407 #define ANNOTATE_TRACE_MEMORY(addr) DRD_TRACE_VAR(*(char*)(addr))
    408 
    409 /**
    410  * Tell DRD to assign the specified name to the current thread. This name will
    411  * be used in error messages printed by DRD.
    412  */
    413 #define ANNOTATE_THREAD_NAME(name)                                      \
    414    VALGRIND_DO_CLIENT_REQUEST_STMT(VG_USERREQ__DRD_SET_THREAD_NAME,     \
    415                                    name, 0, 0, 0, 0)
    416 
    417 /*@}*/
    418 
    419 
    420 /* !! ABIWARNING !! ABIWARNING !! ABIWARNING !! ABIWARNING !!
    421    This enum comprises an ABI exported by Valgrind to programs
    422    which use client requests.  DO NOT CHANGE THE ORDER OF THESE
    423    ENTRIES, NOR DELETE ANY -- add new ones at the end.
    424 */
    425 enum {
    426    /* Ask the DRD tool to discard all information about memory accesses   */
    427    /* and client objects for the specified range. This client request is  */
    428    /* binary compatible with the similarly named Helgrind client request. */
    429    VG_USERREQ__DRD_CLEAN_MEMORY = VG_USERREQ_TOOL_BASE('H','G'),
    430    /* args: Addr, SizeT. */
    431 
    432    /* Ask the DRD tool the thread ID assigned by Valgrind. */
    433    VG_USERREQ__DRD_GET_VALGRIND_THREAD_ID = VG_USERREQ_TOOL_BASE('D','R'),
    434    /* args: none. */
    435    /* Ask the DRD tool the thread ID assigned by DRD. */
    436    VG_USERREQ__DRD_GET_DRD_THREAD_ID,
    437    /* args: none. */
    438 
    439    /* To tell the DRD tool to suppress data race detection on the */
    440    /* specified address range. */
    441    VG_USERREQ__DRD_START_SUPPRESSION,
    442    /* args: start address, size in bytes */
    443    /* To tell the DRD tool no longer to suppress data race detection on */
    444    /* the specified address range. */
    445    VG_USERREQ__DRD_FINISH_SUPPRESSION,
    446    /* args: start address, size in bytes */
    447 
    448    /* To ask the DRD tool to trace all accesses to the specified range. */
    449    VG_USERREQ__DRD_START_TRACE_ADDR,
    450    /* args: Addr, SizeT. */
    451    /* To ask the DRD tool to stop tracing accesses to the specified range. */
    452    VG_USERREQ__DRD_STOP_TRACE_ADDR,
    453    /* args: Addr, SizeT. */
    454 
    455    /* Tell DRD whether or not to record memory loads in the calling thread. */
    456    VG_USERREQ__DRD_RECORD_LOADS,
    457    /* args: Bool. */
    458    /* Tell DRD whether or not to record memory stores in the calling thread. */
    459    VG_USERREQ__DRD_RECORD_STORES,
    460    /* args: Bool. */
    461 
    462    /* Set the name of the thread that performs this client request. */
    463    VG_USERREQ__DRD_SET_THREAD_NAME,
    464    /* args: null-terminated character string. */
    465 
    466    /* Tell DRD that a DRD annotation has not yet been implemented. */
    467    VG_USERREQ__DRD_ANNOTATION_UNIMP,
    468    /* args: char*. */
    469 
    470    /* Tell DRD that a user-defined semaphore synchronization object
    471     * is about to be created. */
    472    VG_USERREQ__DRD_ANNOTATE_SEM_INIT_PRE,
    473    /* args: Addr, UInt value. */
    474    /* Tell DRD that a user-defined semaphore synchronization object
    475     * has been destroyed. */
    476    VG_USERREQ__DRD_ANNOTATE_SEM_DESTROY_POST,
    477    /* args: Addr. */
    478    /* Tell DRD that a user-defined semaphore synchronization
    479     * object is going to be acquired (semaphore wait). */
    480    VG_USERREQ__DRD_ANNOTATE_SEM_WAIT_PRE,
    481    /* args: Addr. */
    482    /* Tell DRD that a user-defined semaphore synchronization
    483     * object has been acquired (semaphore wait). */
    484    VG_USERREQ__DRD_ANNOTATE_SEM_WAIT_POST,
    485    /* args: Addr. */
    486    /* Tell DRD that a user-defined semaphore synchronization
    487     * object is about to be released (semaphore post). */
    488    VG_USERREQ__DRD_ANNOTATE_SEM_POST_PRE,
    489    /* args: Addr. */
    490 
    491    /* Tell DRD to ignore the inter-thread ordering introduced by a mutex. */
    492    VG_USERREQ__DRD_IGNORE_MUTEX_ORDERING,
    493    /* args: Addr. */
    494 
    495    /* Tell DRD that a user-defined reader-writer synchronization object
    496     * has been created. */
    497    VG_USERREQ__DRD_ANNOTATE_RWLOCK_CREATE
    498       = VG_USERREQ_TOOL_BASE('H','G') + 256 + 14,
    499    /* args: Addr. */
    500    /* Tell DRD that a user-defined reader-writer synchronization object
    501     * is about to be destroyed. */
    502    VG_USERREQ__DRD_ANNOTATE_RWLOCK_DESTROY
    503       = VG_USERREQ_TOOL_BASE('H','G') + 256 + 15,
    504    /* args: Addr. */
    505    /* Tell DRD that a lock on a user-defined reader-writer synchronization
    506     * object has been acquired. */
    507    VG_USERREQ__DRD_ANNOTATE_RWLOCK_ACQUIRED
    508       = VG_USERREQ_TOOL_BASE('H','G') + 256 + 17,
    509    /* args: Addr, Int is_rw. */
    510    /* Tell DRD that a lock on a user-defined reader-writer synchronization
    511     * object is about to be released. */
    512    VG_USERREQ__DRD_ANNOTATE_RWLOCK_RELEASED
    513       = VG_USERREQ_TOOL_BASE('H','G') + 256 + 18,
    514    /* args: Addr, Int is_rw. */
    515 
    516    /* Tell DRD that a Helgrind annotation has not yet been implemented. */
    517    VG_USERREQ__HELGRIND_ANNOTATION_UNIMP
    518       = VG_USERREQ_TOOL_BASE('H','G') + 256 + 32,
    519    /* args: char*. */
    520 
    521    /* Tell DRD to insert a happens-before annotation. */
    522    VG_USERREQ__DRD_ANNOTATE_HAPPENS_BEFORE
    523       = VG_USERREQ_TOOL_BASE('H','G') + 256 + 33,
    524    /* args: Addr. */
    525    /* Tell DRD to insert a happens-after annotation. */
    526    VG_USERREQ__DRD_ANNOTATE_HAPPENS_AFTER
    527       = VG_USERREQ_TOOL_BASE('H','G') + 256 + 34,
    528    /* args: Addr. */
    529 
    530 };
    531 
    532 
    533 /**
    534  * @addtogroup RaceDetectionAnnotations
    535  */
    536 /*@{*/
    537 
    538 #ifdef __cplusplus
    539 /* ANNOTATE_UNPROTECTED_READ is the preferred way to annotate racy reads.
    540 
    541    Instead of doing
    542    ANNOTATE_IGNORE_READS_BEGIN();
    543    ... = x;
    544    ANNOTATE_IGNORE_READS_END();
    545    one can use
    546    ... = ANNOTATE_UNPROTECTED_READ(x); */
    547 template <typename T>
    548 inline T ANNOTATE_UNPROTECTED_READ(const volatile T& x) {
    549    ANNOTATE_IGNORE_READS_BEGIN();
    550    const T result = x;
    551    ANNOTATE_IGNORE_READS_END();
    552    return result;
    553 }
    554 /* Apply ANNOTATE_BENIGN_RACE_SIZED to a static variable. */
    555 #define ANNOTATE_BENIGN_RACE_STATIC(static_var, description)		\
    556    namespace {								\
    557       static class static_var##_annotator				\
    558       {									\
    559       public:								\
    560 	 static_var##_annotator()					\
    561 	 {								\
    562 	    ANNOTATE_BENIGN_RACE_SIZED(&static_var, sizeof(static_var),	\
    563 				       #static_var ": " description);	\
    564 	 }								\
    565       } the_##static_var##_annotator;					\
    566    }
    567 #endif
    568 
    569 /*@}*/
    570 
    571 #endif /* __VALGRIND_DRD_H */
    572