valgrind-requests 1.1.0

#include <stdbool.h>
#include <stddef.h>

#include "valgrind/valgrind.h"

#include "valgrind/cachegrind.h"
#include "valgrind/callgrind.h"
#include "valgrind/dhat.h"
#include "valgrind/drd.h"
#include "valgrind/helgrind.h"
#include "valgrind/memcheck.h"

#ifdef VALGRIND_DO_CLIENT_REQUEST_EXPR
const bool VR_IS_PLATFORM_SUPPORTED_BY_VALGRIND = true;
#else
const bool VR_IS_PLATFORM_SUPPORTED_BY_VALGRIND = false;
#endif

#ifdef __VALGRIND_MAJOR__
const unsigned int VR_VALGRIND_MAJOR = __VALGRIND_MAJOR__;
#else
const unsigned int VR_VALGRIND_MAJOR = 0;
#endif

#ifdef __VALGRIND_MINOR__
const unsigned int VR_VALGRIND_MINOR = __VALGRIND_MINOR__;
#else
const unsigned int VR_VALGRIND_MINOR = 0;
#endif

/*
 * Instead of taking the original enums, we wrap the enum variants in our own
 * type. So, we stay in control which client requests we offer and can sort out
 * client requests which are not available in a specific valgrind version.
 *
 * If a definition does not exist we still assign a value to the enum variant.
 * Values <= 0x1000 indicate that this enum variant does not exists and we
 * cannot execute the client request.
 *
 * The check usage of the enum variant value is done in the rust source code
 * which uses the bindings to our enums from this header file.
 */

/*
 * VALGRIND
 * */

typedef enum {
#ifdef RUNNING_ON_VALGRIND
  VR_RUNNING_ON_VALGRIND = VG_USERREQ__RUNNING_ON_VALGRIND,
#else
  VR_RUNNING_ON_VALGRIND = 0,
#endif
#ifdef VALGRIND_DISCARD_TRANSLATIONS
  VR_DISCARD_TRANSLATIONS = VG_USERREQ__DISCARD_TRANSLATIONS,
#else
  VR_DISCARD_TRANSLATIONS = 1,
#endif
#ifdef VALGRIND_REPLACES_MALLOC
  VR_VALGRIND_REPLACES_MALLOC = VG_USERREQ__VALGRIND_REPLACES_MALLOC,
#else
  VR_VALGRIND_REPLACES_MALLOC = 2,
#endif
#ifdef VALGRIND_GET_TOOLNAME
  VR_VALGRIND_GET_TOOLNAME = VG_USERREQ__VALGRIND_GET_TOOLNAME,
#else
  VR_VALGRIND_GET_TOOLNAME = 3,
#endif
#ifdef VALGRIND_INNER_THREADS
  VR_INNER_THREADS = VG_USERREQ__INNER_THREADS,
#else
  VR_INNER_THREADS = 4,
#endif
#ifdef VALGRIND_NON_SIMD_CALL0
  VR_CLIENT_CALL0 = VG_USERREQ__CLIENT_CALL0,
#else
  VR_CLIENT_CALL0 = 5,
#endif
#ifdef VALGRIND_NON_SIMD_CALL1
  VR_CLIENT_CALL1 = VG_USERREQ__CLIENT_CALL1,
#else
  VR_CLIENT_CALL1 = 6,
#endif
#ifdef VALGRIND_NON_SIMD_CALL2
  VR_CLIENT_CALL2 = VG_USERREQ__CLIENT_CALL2,
#else
  VR_CLIENT_CALL2 = 7,
#endif
#ifdef VALGRIND_NON_SIMD_CALL3
  VR_CLIENT_CALL3 = VG_USERREQ__CLIENT_CALL3,
#else
  VR_CLIENT_CALL3 = 8,
#endif
#ifdef VALGRIND_COUNT_ERRORS
  VR_COUNT_ERRORS = VG_USERREQ__COUNT_ERRORS,
#else
  VR_COUNT_ERRORS = 9,
#endif
#ifdef VALGRIND_MALLOCLIKE_BLOCK
  VR_MALLOCLIKE_BLOCK = VG_USERREQ__MALLOCLIKE_BLOCK,
#else
  VR_MALLOCLIKE_BLOCK = 10,
#endif
#ifdef VALGRIND_RESIZEINPLACE_BLOCK
  VR_RESIZEINPLACE_BLOCK = VG_USERREQ__RESIZEINPLACE_BLOCK,
#else
  VR_RESIZEINPLACE_BLOCK = 11,
#endif
#ifdef VALGRIND_FREELIKE_BLOCK
  VR_FREELIKE_BLOCK = VG_USERREQ__FREELIKE_BLOCK,
#else
  VR_FREELIKE_BLOCK = 12,
#endif
#if defined(VALGRIND_CREATE_MEMPOOL) || defined(VALGRIND_CREATE_MEMPOOL_EXT)
  VR_CREATE_MEMPOOL = VG_USERREQ__CREATE_MEMPOOL,
#else
  VR_CREATE_MEMPOOL = 13,
#endif
#ifdef VALGRIND_DESTROY_MEMPOOL
  VR_DESTROY_MEMPOOL = VG_USERREQ__DESTROY_MEMPOOL,
#else
  VR_DESTROY_MEMPOOL = 14,
#endif
#ifdef VALGRIND_MEMPOOL_ALLOC
  VR_MEMPOOL_ALLOC = VG_USERREQ__MEMPOOL_ALLOC,
#else
  VR_MEMPOOL_ALLOC = 15,
#endif
#ifdef VALGRIND_MEMPOOL_FREE
  VR_MEMPOOL_FREE = VG_USERREQ__MEMPOOL_FREE,
#else
  VR_MEMPOOL_FREE = 16,
#endif
#ifdef VALGRIND_MEMPOOL_TRIM
  VR_MEMPOOL_TRIM = VG_USERREQ__MEMPOOL_TRIM,
#else
  VR_MEMPOOL_TRIM = 17,
#endif
#ifdef VALGRIND_MOVE_MEMPOOL
  VR_MOVE_MEMPOOL = VG_USERREQ__MOVE_MEMPOOL,
#else
  VR_MOVE_MEMPOOL = 18,
#endif
#ifdef VALGRIND_MEMPOOL_CHANGE
  VR_MEMPOOL_CHANGE = VG_USERREQ__MEMPOOL_CHANGE,
#else
  VR_MEMPOOL_CHANGE = 19,
#endif
#ifdef VALGRIND_MEMPOOL_EXISTS
  VR_MEMPOOL_EXISTS = VG_USERREQ__MEMPOOL_EXISTS,
#else
  VR_MEMPOOL_EXISTS = 20,
#endif
#ifdef VALGRIND_STACK_REGISTER
  VR_STACK_REGISTER = VG_USERREQ__STACK_REGISTER,
#else
  VR_STACK_REGISTER = 21,
#endif
#ifdef VALGRIND_STACK_DEREGISTER
  VR_STACK_DEREGISTER = VG_USERREQ__STACK_DEREGISTER,
#else
  VR_STACK_DEREGISTER = 22,
#endif
#ifdef VALGRIND_STACK_CHANGE
  VR_STACK_CHANGE = VG_USERREQ__STACK_CHANGE,
#else
  VR_STACK_CHANGE = 23,
#endif
#ifdef VALGRIND_LOAD_PDB_DEBUGINFO
  VR_LOAD_PDB_DEBUGINFO = VG_USERREQ__LOAD_PDB_DEBUGINFO,
#else
  VR_LOAD_PDB_DEBUGINFO = 24,
#endif
#ifdef VALGRIND_MAP_IP_TO_SRCLOC
  VR_MAP_IP_TO_SRCLOC = VG_USERREQ__MAP_IP_TO_SRCLOC,
#else
  VR_MAP_IP_TO_SRCLOC = 25,
#endif
#if defined(VALGRIND_DISABLE_ERROR_REPORTING) ||                               \
    defined(VALGRIND_ENABLE_ERROR_REPORTING)
  VR_CHANGE_ERR_DISABLEMENT = VG_USERREQ__CHANGE_ERR_DISABLEMENT,
#else
  VR_CHANGE_ERR_DISABLEMENT = 26,
#endif
#ifdef VALGRIND_MONITOR_COMMAND
  VR_GDB_MONITOR_COMMAND = VG_USERREQ__GDB_MONITOR_COMMAND,
#else
  VR_GDB_MONITOR_COMMAND = 27,
#endif
#ifdef VALGRIND_CLO_CHANGE
  VR_CLO_CHANGE = VG_USERREQ__CLO_CHANGE,
#else
  VR_CLO_CHANGE = 28,
#endif
} VR_ValgrindClientRequest;

/*
 * CALLGRIND
 * */

typedef enum {
#ifdef CALLGRIND_DUMP_STATS
  VR_DUMP_STATS = VG_USERREQ__DUMP_STATS,
#else
  VR_DUMP_STATS = 0,
#endif
#ifdef CALLGRIND_DUMP_STATS_AT
  VR_DUMP_STATS_AT = VG_USERREQ__DUMP_STATS_AT,
#else
  VR_DUMP_STATS_AT = 1,
#endif
#ifdef CALLGRIND_ZERO_STATS
  VR_ZERO_STATS = VG_USERREQ__ZERO_STATS,
#else
  VR_ZERO_STATS = 2,
#endif
#ifdef CALLGRIND_TOGGLE_COLLECT
  VR_TOGGLE_COLLECT = VG_USERREQ__TOGGLE_COLLECT,
#else
  VR_TOGGLE_COLLECT = 3,
#endif
#ifdef CALLGRIND_START_INSTRUMENTATION
  VR_START_INSTRUMENTATION = VG_USERREQ__START_INSTRUMENTATION,
#else
  VR_START_INSTRUMENTATION = 4,
#endif
#ifdef CALLGRIND_STOP_INSTRUMENTATION
  VR_STOP_INSTRUMENTATION = VG_USERREQ__STOP_INSTRUMENTATION,
#else
  VR_STOP_INSTRUMENTATION = 5,
#endif
} VR_CallgrindClientRequest;

/*
 * DHAT
 * */

typedef enum {
#ifdef DHAT_AD_HOC_EVENT
  VR_DHAT_AD_HOC_EVENT = VG_USERREQ__DHAT_AD_HOC_EVENT,
#else
  VR_DHAT_AD_HOC_EVENT = 0,
#endif
#ifdef DHAT_HISTOGRAM_MEMORY
  VR_DHAT_HISTOGRAM_MEMORY = VG_USERREQ__DHAT_HISTOGRAM_MEMORY,
#else
  VR_DHAT_HISTOGRAM_MEMORY = 1,
#endif
} VR_DHATClientRequest;

/*
 * Memcheck
 * */

typedef enum {
#ifdef VALGRIND_MAKE_MEM_NOACCESS
  VR_MAKE_MEM_NOACCESS = VG_USERREQ__MAKE_MEM_NOACCESS,
#else
  VR_MAKE_MEM_NOACCESS = 0,
#endif
#ifdef VALGRIND_MAKE_MEM_UNDEFINED
  VR_MAKE_MEM_UNDEFINED = VG_USERREQ__MAKE_MEM_UNDEFINED,
#else
  VR_MAKE_MEM_UNDEFINED = 1,
#endif
#ifdef VALGRIND_MAKE_MEM_DEFINED
  VR_MAKE_MEM_DEFINED = VG_USERREQ__MAKE_MEM_DEFINED,
#else
  VR_MAKE_MEM_DEFINED = 2,
#endif
#ifdef VALGRIND_DISCARD
  VR_DISCARD = VG_USERREQ__DISCARD,
#else
  VR_DISCARD = 3,
#endif
#ifdef VALGRIND_CHECK_MEM_IS_ADDRESSABLE
  VR_CHECK_MEM_IS_ADDRESSABLE = VG_USERREQ__CHECK_MEM_IS_ADDRESSABLE,
#else
  VR_CHECK_MEM_IS_ADDRESSABLE = 4,
#endif
#if defined(VALGRIND_CHECK_MEM_IS_DEFINED) ||                                  \
    defined(VALGRIND_CHECK_VALUE_IS_DEFINED)
  VR_CHECK_MEM_IS_DEFINED = VG_USERREQ__CHECK_MEM_IS_DEFINED,
#else
  VR_CHECK_MEM_IS_DEFINED = 5,
#endif
#if defined(VALGRIND_DO_LEAK_CHECK) ||                                         \
    defined(VALGRIND_DO_ADDED_LEAK_CHECK) ||                                   \
    defined(VALGRIND_DO_CHANGED_LEAK_CHECK) ||                                 \
    defined(VALGRIND_DO_NEW_LEAK_CHECK) ||                                     \
    defined(VALGRIND_DO_QUICK_LEAK_CHECK)
  VR_DO_LEAK_CHECK = VG_USERREQ__DO_LEAK_CHECK,
#else
  VR_DO_LEAK_CHECK = 6,
#endif
#ifdef VALGRIND_COUNT_LEAKS
  VR_COUNT_LEAKS = VG_USERREQ__COUNT_LEAKS,
#else
  VR_COUNT_LEAKS = 7,
#endif
#ifdef VALGRIND_GET_VBITS
  VR_GET_VBITS = VG_USERREQ__GET_VBITS,
#else
  VR_GET_VBITS = 8,
#endif
#ifdef VALGRIND_SET_VBITS
  VR_SET_VBITS = VG_USERREQ__SET_VBITS,
#else
  VR_SET_VBITS = 9,
#endif
#ifdef VALGRIND_CREATE_BLOCK
  VR_CREATE_BLOCK = VG_USERREQ__CREATE_BLOCK,
#else
  VR_CREATE_BLOCK = 10,
#endif
#ifdef VALGRIND_MAKE_MEM_DEFINED_IF_ADDRESSABLE
  VR_MAKE_MEM_DEFINED_IF_ADDRESSABLE =
      VG_USERREQ__MAKE_MEM_DEFINED_IF_ADDRESSABLE,
#else
  VR_MAKE_MEM_DEFINED_IF_ADDRESSABLE = 11,
#endif
#ifdef VALGRIND_COUNT_LEAK_BLOCKS
  VR_COUNT_LEAK_BLOCKS = VG_USERREQ__COUNT_LEAK_BLOCKS,
#else
  VR_COUNT_LEAK_BLOCKS = 12,
#endif
#ifdef VALGRIND_ENABLE_ADDR_ERROR_REPORTING_IN_RANGE
  VR_ENABLE_ADDR_ERROR_REPORTING_IN_RANGE =
      VG_USERREQ__ENABLE_ADDR_ERROR_REPORTING_IN_RANGE,
#else
  VR_ENABLE_ADDR_ERROR_REPORTING_IN_RANGE = 13,
#endif
#ifdef VALGRIND_DISABLE_ADDR_ERROR_REPORTING_IN_RANGE
  VR_DISABLE_ADDR_ERROR_REPORTING_IN_RANGE =
      VG_USERREQ__DISABLE_ADDR_ERROR_REPORTING_IN_RANGE,
#else
  VR_DISABLE_ADDR_ERROR_REPORTING_IN_RANGE = 14,
#endif
} VR_MemcheckClientRequest;

typedef enum {
#ifdef VALGRIND_HG_MUTEX_INIT_POST
  VR_HG_PTHREAD_MUTEX_INIT_POST = _VG_USERREQ__HG_PTHREAD_MUTEX_INIT_POST,
#else
  VR_HG_PTHREAD_MUTEX_INIT_POST = 1,
#endif
#ifdef VALGRIND_HG_MUTEX_LOCK_PRE
  VR_HG_PTHREAD_MUTEX_LOCK_PRE = _VG_USERREQ__HG_PTHREAD_MUTEX_ACQUIRE_PRE,
#else
  VR_HG_PTHREAD_MUTEX_LOCK_PRE = 2,
#endif
#ifdef VALGRIND_HG_MUTEX_LOCK_POST
  VR_HG_PTHREAD_MUTEX_LOCK_POST = _VG_USERREQ__HG_PTHREAD_MUTEX_ACQUIRE_POST,
#else
  VR_HG_PTHREAD_MUTEX_LOCK_POST = 3,
#endif
#ifdef VALGRIND_HG_MUTEX_UNLOCK_PRE
  VR_HG_PTHREAD_MUTEX_UNLOCK_PRE = _VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_PRE,
#else
  VR_HG_PTHREAD_MUTEX_UNLOCK_PRE = 4,
#endif
#ifdef VALGRIND_HG_MUTEX_UNLOCK_POST
  VR_HG_PTHREAD_MUTEX_UNLOCK_POST = _VG_USERREQ__HG_PTHREAD_MUTEX_UNLOCK_POST,
#else
  VR_HG_PTHREAD_MUTEX_UNLOCK_POST = 5,
#endif
#ifdef VALGRIND_HG_MUTEX_DESTROY_PRE
  VR_HG_PTHREAD_MUTEX_DESTROY_PRE = _VG_USERREQ__HG_PTHREAD_MUTEX_DESTROY_PRE,
#else
  VR_HG_PTHREAD_MUTEX_DESTROY_PRE = 6,
#endif
#ifdef VALGRIND_HG_SEM_INIT_POST
  VR_HG_POSIX_SEM_INIT_POST = _VG_USERREQ__HG_POSIX_SEM_INIT_POST,
#else
  VR_HG_POSIX_SEM_INIT_POST = 7,
#endif
#ifdef VALGRIND_HG_SEM_WAIT_POST
  VR_HG_POSIX_SEM_ACQUIRED = _VG_USERREQ__HG_POSIX_SEM_ACQUIRED,
#else
  VR_HG_POSIX_SEM_ACQUIRED = 8,
#endif
#ifdef VALGRIND_HG_SEM_POST_PRE
  VR_HG_POSIX_SEM_RELEASED = _VG_USERREQ__HG_POSIX_SEM_RELEASED,
#else
  VR_HG_POSIX_SEM_RELEASED = 9,
#endif
#ifdef VALGRIND_HG_SEM_DESTROY_PRE
  VR_HG_POSIX_SEM_DESTROY_PRE = _VG_USERREQ__HG_POSIX_SEM_DESTROY_PRE,
#else
  VR_HG_POSIX_SEM_DESTROY_PRE = 10,
#endif
#ifdef VALGRIND_HG_BARRIER_INIT_PRE
  VR_HG_PTHREAD_BARRIER_INIT_PRE = _VG_USERREQ__HG_PTHREAD_BARRIER_INIT_PRE,
#else
  VR_HG_PTHREAD_BARRIER_INIT_PRE = 11,
#endif
#ifdef VALGRIND_HG_BARRIER_WAIT_PRE
  VR_HG_PTHREAD_BARRIER_WAIT_PRE = _VG_USERREQ__HG_PTHREAD_BARRIER_WAIT_PRE,
#else
  VR_HG_PTHREAD_BARRIER_WAIT_PRE = 12,
#endif
#ifdef VALGRIND_HG_BARRIER_RESIZE_PRE
  VR_HG_PTHREAD_BARRIER_RESIZE_PRE = _VG_USERREQ__HG_PTHREAD_BARRIER_RESIZE_PRE,
#else
  VR_HG_PTHREAD_BARRIER_RESIZE_PRE = 13,
#endif
#ifdef VALGRIND_HG_BARRIER_DESTROY_PRE
  VR_HG_PTHREAD_BARRIER_DESTROY_PRE =
      _VG_USERREQ__HG_PTHREAD_BARRIER_DESTROY_PRE,
#else
  VR_HG_PTHREAD_BARRIER_DESTROY_PRE = 14,
#endif
#ifdef VALGRIND_HG_CLEAN_MEMORY
  VR_HG_CLEAN_MEMORY = VG_USERREQ__HG_CLEAN_MEMORY,
#else
  VR_HG_CLEAN_MEMORY = 15,
#endif
#ifdef VALGRIND_HG_CLEAN_MEMORY_HEAPBLOCK
  VR_HG_CLEAN_MEMORY_HEAPBLOCK = _VG_USERREQ__HG_CLEAN_MEMORY_HEAPBLOCK,
#else
  VR_HG_CLEAN_MEMORY_HEAPBLOCK = 16,
#endif
#ifdef VALGRIND_HG_DISABLE_CHECKING
  VR_HG_ARANGE_MAKE_UNTRACKED = _VG_USERREQ__HG_ARANGE_MAKE_UNTRACKED,
#else
  VR_HG_ARANGE_MAKE_UNTRACKED = 17,
#endif
#ifdef VALGRIND_HG_ENABLE_CHECKING
  VR_HG_ARANGE_MAKE_TRACKED = _VG_USERREQ__HG_ARANGE_MAKE_TRACKED,
#else
  VR_HG_ARANGE_MAKE_TRACKED = 18,
#endif
#ifdef VALGRIND_HG_GET_ABITS
  VR_HG_GET_ABITS = _VG_USERREQ__HG_GET_ABITS,
#else
  VR_HG_GET_ABITS = 19,
#endif
#ifdef VALGRIND_HG_GNAT_DEPENDENT_MASTER_JOIN
  VR_HG_GNAT_DEPENDENT_MASTER_JOIN = _VG_USERREQ__HG_GNAT_DEPENDENT_MASTER_JOIN,
#else
  VR_HG_GNAT_DEPENDENT_MASTER_JOIN = 20,
#endif
#ifdef ANNOTATE_HAPPENS_BEFORE
  VR_HG_USERSO_SEND_PRE = _VG_USERREQ__HG_USERSO_SEND_PRE,
#else
  VR_HG_USERSO_SEND_PRE = 21,
#endif
#ifdef ANNOTATE_HAPPENS_AFTER
  VR_HG_USERSO_RECV_POST = _VG_USERREQ__HG_USERSO_RECV_POST,
#else
  VR_HG_USERSO_RECV_POST = 22,
#endif
#ifdef ANNOTATE_HAPPENS_BEFORE_FORGET_ALL
  VR_HG_USERSO_FORGET_ALL = _VG_USERREQ__HG_USERSO_FORGET_ALL,
#else
  VR_HG_USERSO_FORGET_ALL = 23,
#endif
#ifdef ANNOTATE_RWLOCK_CREATE
  VR_HG_PTHREAD_RWLOCK_INIT_POST = _VG_USERREQ__HG_PTHREAD_RWLOCK_INIT_POST,
#else
  VR_HG_PTHREAD_RWLOCK_INIT_POST = 24,
#endif
#ifdef ANNOTATE_RWLOCK_DESTROY
  VR_HG_PTHREAD_RWLOCK_DESTROY_PRE = _VG_USERREQ__HG_PTHREAD_RWLOCK_DESTROY_PRE,
#else
  VR_HG_PTHREAD_RWLOCK_DESTROY_PRE = 25,
#endif
#ifdef ANNOTATE_RWLOCK_ACQUIRED
  VR_HG_PTHREAD_RWLOCK_ACQUIRED = _VG_USERREQ__HG_PTHREAD_RWLOCK_ACQUIRED,
#else
  VR_HG_PTHREAD_RWLOCK_ACQUIRED = 26,
#endif
#ifdef ANNOTATE_RWLOCK_RELEASED
  VR_HG_PTHREAD_RWLOCK_RELEASED = _VG_USERREQ__HG_PTHREAD_RWLOCK_RELEASED,
#else
  VR_HG_PTHREAD_RWLOCK_RELEASED = 27,
#endif
} VR_HelgrindClientRequest;

typedef enum {
#ifdef DRD_GET_VALGRIND_THREADID
  VR_DRD_GET_VALGRIND_THREAD_ID = VG_USERREQ__DRD_GET_VALGRIND_THREAD_ID,
#else
  VR_DRD_GET_VALGRIND_THREAD_ID = 0,
#endif
#ifdef DRD_GET_DRD_THREADID
  VR_DRD_GET_DRD_THREAD_ID = VG_USERREQ__DRD_GET_DRD_THREAD_ID,
#else
  VR_DRD_GET_DRD_THREAD_ID = 1,
#endif
#if defined(DRD_IGNORE_VAR) || defined(ANNOTATE_BENIGN_RACE) ||                \
    defined(ANNOTATE_BENIGN_RACE_SIZED)
  VR_DRD_START_SUPPRESSION = VG_USERREQ__DRD_START_SUPPRESSION,
#else
  VR_DRD_START_SUPPRESSION = 2,
#endif
#ifdef DRD_STOP_IGNORING_VAR
  VR_DRD_FINISH_SUPPRESSION = VG_USERREQ__DRD_FINISH_SUPPRESSION,
#else
  VR_DRD_FINISH_SUPPRESSION = 3,
#endif
#if defined(DRD_TRACE_VAR) || defined(ANNOTATE_TRACE_MEMORY)
  VR_DRD_START_TRACE_ADDR = VG_USERREQ__DRD_START_TRACE_ADDR,
#else
  VR_DRD_START_TRACE_ADDR = 4,
#endif
#ifdef DRD_STOP_TRACING_VAR
  VR_DRD_STOP_TRACE_ADDR = VG_USERREQ__DRD_STOP_TRACE_ADDR,
#else
  VR_DRD_STOP_TRACE_ADDR = 5,
#endif
#ifdef ANNOTATE_SEM_INIT_PRE
  VR_DRD_ANNOTATE_SEM_INIT_PRE = VG_USERREQ__DRD_ANNOTATE_SEM_INIT_PRE,
#else
  VR_DRD_ANNOTATE_SEM_INIT_PRE = 6,
#endif
#ifdef ANNOTATE_SEM_DESTROY_POST
  VR_DRD_ANNOTATE_SEM_DESTROY_POST = VG_USERREQ__DRD_ANNOTATE_SEM_DESTROY_POST,
#else
  VR_DRD_ANNOTATE_SEM_DESTROY_POST = 7,
#endif
#ifdef ANNOTATE_SEM_WAIT_PRE
  VR_DRD_ANNOTATE_SEM_WAIT_PRE = VG_USERREQ__DRD_ANNOTATE_SEM_WAIT_PRE,
#else
  VR_DRD_ANNOTATE_SEM_WAIT_PRE = 8,
#endif
#ifdef ANNOTATE_SEM_WAIT_POST
  VR_DRD_ANNOTATE_SEM_WAIT_POST = VG_USERREQ__DRD_ANNOTATE_SEM_WAIT_POST,
#else
  VR_DRD_ANNOTATE_SEM_WAIT_POST = 9,
#endif
#ifdef ANNOTATE_SEM_POST_PRE
  VR_DRD_ANNOTATE_SEM_POST_PRE = VG_USERREQ__DRD_ANNOTATE_SEM_POST_PRE,
#else
  VR_DRD_ANNOTATE_SEM_POST_PRE = 10,
#endif
#if defined(ANNOTATE_IGNORE_READS_BEGIN) || defined(ANNOTATE_IGNORE_READS_END)
  VR_DRD_RECORD_LOADS = VG_USERREQ__DRD_RECORD_LOADS,
#else
  VR_DRD_RECORD_LOADS = 11,
#endif
#if defined(ANNOTATE_IGNORE_WRITES_BEGIN) || defined(ANNOTATE_IGNORE_WRITES_END)
  VR_DRD_RECORD_STORES = VG_USERREQ__DRD_RECORD_STORES,
#else
  VR_DRD_RECORD_STORES = 12,
#endif
#ifdef ANNOTATE_NEW_MEMORY
  VR_DRD_CLEAN_MEMORY = VG_USERREQ__DRD_CLEAN_MEMORY,
#else
  VR_DRD_CLEAN_MEMORY = 13,
#endif
#ifdef ANNOTATE_THREAD_NAME
  VR_DRD_SET_THREAD_NAME = VG_USERREQ__DRD_SET_THREAD_NAME,
#else
  VR_DRD_SET_THREAD_NAME = 14,
#endif
} VR_DRDClientRequest;

typedef enum {
#ifdef CACHEGRIND_START_INSTRUMENTATION
  VR_CG_START_INSTRUMENTATION = VG_USERREQ__CG_START_INSTRUMENTATION,
#else
  VR_CG_START_INSTRUMENTATION = 0,
#endif
#ifdef CACHEGRIND_STOP_INSTRUMENTATION
  VR_CG_STOP_INSTRUMENTATION = VG_USERREQ__CG_STOP_INSTRUMENTATION,
#else
  VR_CG_STOP_INSTRUMENTATION = 1,
#endif
} VR_CachegrindClientRequest;