#include <stdbool.h>
#include <stddef.h>
#include <stdint.h>
#include <valgrind/cachegrind.h>
#include <valgrind/callgrind.h>
#include <valgrind/dhat.h>
#include <valgrind/helgrind.h>
#include <valgrind/memcheck.h>
#include <valgrind/valgrind.h>
size_t running_on_valgrind() { return RUNNING_ON_VALGRIND; }
void vg_discard_translations(void *addr, size_t len) {
VALGRIND_DISCARD_TRANSLATIONS(addr, len);
}
size_t vg_count_errors() { return VALGRIND_COUNT_ERRORS; }
void vg_malloclike_block(void *addr, size_t sizeB, size_t rzB, bool is_zeroed) {
VALGRIND_MALLOCLIKE_BLOCK(addr, sizeB, rzB, is_zeroed);
}
void vg_freelike_block(void *addr, size_t rzB) {
VALGRIND_FREELIKE_BLOCK(addr, rzB);
}
void vg_resizeinplace_block(void *addr, size_t oldSizeB, size_t newSizeB,
size_t rzB) {
VALGRIND_RESIZEINPLACE_BLOCK(addr, oldSizeB, newSizeB, rzB);
}
void vg_create_mempool(void *pool, size_t rzB, bool is_zeroed) {
VALGRIND_CREATE_MEMPOOL(pool, rzB, is_zeroed);
}
void vg_create_mempool_ext(void *pool, size_t rzB, bool is_zeroed, int flags) {
VALGRIND_CREATE_MEMPOOL_EXT(pool, rzB, is_zeroed, flags);
}
void vg_destroy_mempool(void *pool) { VALGRIND_DESTROY_MEMPOOL(pool); }
void vg_mempool_alloc(void *pool, void *addr, size_t size) {
VALGRIND_MEMPOOL_ALLOC(pool, addr, size);
}
void vg_mempool_free(void *pool, void *addr) {
VALGRIND_MEMPOOL_FREE(pool, addr);
}
void vg_mempool_trim(void *pool, void *addr, size_t size) {
VALGRIND_MEMPOOL_TRIM(pool, addr, size);
}
void vg_move_mempool(void *poolA, void *poolB) {
VALGRIND_MOVE_MEMPOOL(poolA, poolB);
}
void vg_mempool_change(void *pool, void *addrA, void *addrB, size_t size) {
VALGRIND_MEMPOOL_CHANGE(pool, addrA, addrB, size);
}
bool vg_mempool_exists(void *pool) {
return (bool)VALGRIND_MEMPOOL_EXISTS(pool);
}
size_t vg_stack_register(void *start, void *end) {
return VALGRIND_STACK_REGISTER(start, end);
}
void vg_stack_deregister(size_t id) { VALGRIND_STACK_DEREGISTER(id); }
void vg_stack_change(size_t id, void *start, void *end) {
VALGRIND_STACK_CHANGE(id, start, end);
}
void vg_load_pdb_debuginfo(int fd, void *ptr, size_t total_size, size_t delta) {
VALGRIND_LOAD_PDB_DEBUGINFO(fd, ptr, total_size, delta);
}
size_t vg_map_ip_to_srcloc(void *addr, void *buf64) {
return VALGRIND_MAP_IP_TO_SRCLOC(addr, buf64);
}
void vg_disable_error_reporting() { VALGRIND_DISABLE_ERROR_REPORTING; }
void vg_enable_error_reporting() { VALGRIND_ENABLE_ERROR_REPORTING; }
void vg_non_simd_call1(size_t (*fn)(size_t, void *), void *arg1) {
VALGRIND_NON_SIMD_CALL1(fn, arg1);
}
size_t vg_print(char *msg) { return VALGRIND_PRINTF("%s", msg); }
size_t vg_print_backtrace(char *msg) {
return VALGRIND_PRINTF_BACKTRACE("%s", msg);
}
bool vg_monitor_command(char *cmd) {
return (bool)VALGRIND_MONITOR_COMMAND(cmd);
}
void vg_clo_change(char *opt) { VALGRIND_CLO_CHANGE(opt); }
void cl_dump_stats() { CALLGRIND_DUMP_STATS; }
void cl_dump_stats_at(char *pos_str) { CALLGRIND_DUMP_STATS_AT(pos_str); }
void cl_zero_stats() { CALLGRIND_ZERO_STATS; }
void cl_toggle_collect() { CALLGRIND_TOGGLE_COLLECT; }
void cl_start_instrumentation() { CALLGRIND_START_INSTRUMENTATION; }
void cl_stop_instrumentation() { CALLGRIND_STOP_INSTRUMENTATION; }
void cg_start_instrumentation() { CACHEGRIND_START_INSTRUMENTATION; }
void cg_stop_instrumentation() { CACHEGRIND_STOP_INSTRUMENTATION; }
int mc_make_mem_noaccess(void *addr, size_t len) {
return VALGRIND_MAKE_MEM_NOACCESS(addr, len);
}
int mc_make_mem_undefined(void *addr, size_t len) {
return VALGRIND_MAKE_MEM_UNDEFINED(addr, len);
}
int mc_make_mem_defined(void *addr, size_t len) {
return VALGRIND_MAKE_MEM_DEFINED(addr, len);
}
int mc_make_mem_defined_if_addressable(void *addr, size_t len) {
return VALGRIND_MAKE_MEM_DEFINED_IF_ADDRESSABLE(addr, len);
}
int mc_create_block(void *addr, size_t len, const char *desc) {
return VALGRIND_CREATE_BLOCK(addr, len, desc);
}
int mc_discard(int blkindex) { return VALGRIND_DISCARD(blkindex); }
size_t mc_check_mem_is_addressable(void *addr, size_t len) {
return VALGRIND_CHECK_MEM_IS_ADDRESSABLE(addr, len);
}
size_t mc_check_mem_is_defined(void *addr, size_t len) {
return VALGRIND_CHECK_MEM_IS_DEFINED(addr, len);
}
void mc_do_leak_check() { VALGRIND_DO_LEAK_CHECK; }
void mc_do_new_leak_check() { VALGRIND_DO_NEW_LEAK_CHECK; }
void mc_do_quick_leak_check() { VALGRIND_DO_QUICK_LEAK_CHECK; }
void mc_do_added_leak_check() { VALGRIND_DO_ADDED_LEAK_CHECK; }
void mc_do_changed_leak_check() { VALGRIND_DO_CHANGED_LEAK_CHECK; }
typedef struct {
size_t leaked, dubious, reachable, suppressed;
} leaks_count;
leaks_count mc_count_leaks() {
leaks_count leaks;
VALGRIND_COUNT_LEAKS(leaks.leaked, leaks.dubious, leaks.reachable,
leaks.suppressed);
return leaks;
}
leaks_count mc_count_leak_blocks() {
leaks_count leaks;
VALGRIND_COUNT_LEAK_BLOCKS(leaks.leaked, leaks.dubious, leaks.reachable,
leaks.suppressed);
return leaks;
}
int mc_get_vbits(void *addr, char *bits, size_t nbytes) {
return VALGRIND_GET_VBITS(addr, bits, nbytes);
}
int mc_set_vbits(void *addr, char *bits, size_t nbytes) {
return VALGRIND_SET_VBITS(addr, bits, nbytes);
}
void mc_disable_addr_error_reporting_in_range(void *addr, size_t len) {
VALGRIND_DISABLE_ADDR_ERROR_REPORTING_IN_RANGE(addr, len);
}
void mc_enable_addr_error_reporting_in_range(void *addr, size_t len) {
VALGRIND_ENABLE_ADDR_ERROR_REPORTING_IN_RANGE(addr, len);
}
void hg_clean_memory(void *addr, size_t len) {
VALGRIND_HG_CLEAN_MEMORY(addr, len);
}
void hg_annotate_happens_before(void *addr) { ANNOTATE_HAPPENS_BEFORE(addr); }
void hg_annotate_happens_after(void *addr) { ANNOTATE_HAPPENS_AFTER(addr); }
void hg_annotate_new_memory(void *addr, size_t size) {
ANNOTATE_NEW_MEMORY(addr, size);
}
void hg_rwlock_create(void *lock) { ANNOTATE_RWLOCK_CREATE(lock); }
void hg_rwlock_destroy(void *lock) { ANNOTATE_RWLOCK_DESTROY(lock); }
void hg_rwlock_acquired(void *lock, bool is_write) {
ANNOTATE_RWLOCK_ACQUIRED(lock, is_write);
}
void hg_rwlock_released(void *lock) { ANNOTATE_RWLOCK_RELEASED(lock, 0); }
void dh_histogram_memory(void *addr) { DHAT_HISTOGRAM_MEMORY(addr); }