/memcheck/tests/descr_belowsp
/memcheck/tests/dir
/memcheck/tests/doublefree
+/memcheck/tests/duplicate_align_size_errors
/memcheck/tests/dw4
/memcheck/tests/erringfds
/memcheck/tests/error_counts
/memcheck/tests/nanoleak
/memcheck/tests/nanoleak2
/memcheck/tests/nanoleak_supp
+/memcheck/tests/new_delete_mismatch_size
/memcheck/tests/new_nothrow
/memcheck/tests/new_override
/memcheck/tests/noisy_child
/memcheck/tests/sh-mem
/memcheck/tests/sh-mem-random
/memcheck/tests/sized_aligned_new_delete_args
-/memcheck/tests/sized_aligned_new_delete_misaligned
+/memcheck/tests/sized_aligned_new_delete_misaligned1
+/memcheck/tests/sized_aligned_new_delete_misaligned2
+/memcheck/tests/sized_aligned_new_delete_misaligned3
/memcheck/tests/sigaltstack
/memcheck/tests/sigkill
/memcheck/tests/signal2
/memcheck/tests/freebsd/Makefile.in
/memcheck/tests/freebsd/452275
/memcheck/tests/freebsd/access
+/memcheck/tests/freebsd/aligned_alloc
/memcheck/tests/freebsd/bug464476
/memcheck/tests/freebsd/bug470713
/memcheck/tests/freebsd/capsicum
/memcheck/tests/freebsd/chflags
/memcheck/tests/freebsd/chmod_chown
+/memcheck/tests/freebsd/delete_sized_mismatch
/memcheck/tests/freebsd/errno_aligned_allocs
/memcheck/tests/freebsd/eventfd1
/memcheck/tests/freebsd/eventfd2
* support has been added for FreeBSD 14 and FreeBSD 15.
-
* ==================== TOOL CHANGES ===================
+* Memcheck now tests and warns about the values used for
+ alignment and size. These apply to various functions: memalign,
+ posix_memalign and aligned_alloc in C and various overloads
+ of operators new and delete in C++. The kinds of error that can
+ be detected are
+ - invalid alignment, for instance the alignment is usually required
+ to be a power of 2
+ - mismatched alignment between aligned allocation and aligned
+ deallocation
+ - mismatched size when sized delete is used
+ - bad size for functions that have implementation defined behaviour
+ when the requested size is zero
* ==================== FIXED BUGS ====================
than mailing the developers (or mailing lists) directly -- bugs that
are not entered into bugzilla tend to get forgotten about or ignored.
-426751 Valgrind reports «still reachable» memory using musl (alpine running inside docker)
+426751 Valgrind reports "still reachable" memory using musl (alpine running inside docker)
+433857 Add validation to C++17 aligned new/delete alignment size
+433859 Add mismatched detection to C++ 17 aligned new/delete
460192 Add epoll_pwait2
+466105 aligned_alloc problems, part 2
+467441 Add mismatched detection to C++ 14 sized delete
469049 link failure on ppc64 (big endian) valgrind 3.20
469146 massif --ignore-fn does not ignore inlined functions
469768 Make it possible to install gdb scripts in a different location
#include "pub_core_mallocfree.h" // for VG_MIN_MALLOC_SZB, VG_AR_CLIENT
#include "pub_core_redir.h" // for VG_REPLACE_FUNCTION_*
#include "pub_core_replacemalloc.h"
+#include "../../memcheck/memcheck.h"
#define VG_ALIGN_ROUNDUP(size, alignment) (((size) + (alignment) - 1) & ~((alignment) - 1))
+#define VERIFY_ALIGNMENT(aligned_alloc_info) \
+ VALGRIND_DO_CLIENT_REQUEST_STMT(_VG_USERREQ__MEMCHECK_VERIFY_ALIGNMENT, \
+ aligned_alloc_info, 0, 0, 0, 0)
+
/* Assignment of behavioural equivalence class tags: 1NNNP is intended
to be reserved for the Valgrind core. Current usage:
/* Generate a replacement for 'fnname' in object 'soname', which calls
'vg_replacement' to allocate aligned memory. If that fails, return NULL.
*/
-#define ALLOC_or_NULL_ALIGNED(soname, fnname, vg_replacement) \
+#define ALLOC_or_NULL_ALIGNED(soname, fnname, vg_replacement, tag) \
\
void* VG_REPLACE_FUNCTION_EZU(10010,soname,fnname) (SizeT n, SizeT alignment); \
void* VG_REPLACE_FUNCTION_EZU(10010,soname,fnname) (SizeT n, SizeT alignment) \
{ \
void* v; \
+ SizeT orig_alignment = alignment; \
\
DO_INIT; \
TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED(n); \
+ struct AlignedAllocInfo aligned_alloc_info = { .orig_alignment=alignment, .size=n, .alloc_kind=AllocKind##tag}; \
+ VERIFY_ALIGNMENT(&aligned_alloc_info); \
MALLOC_TRACE(#fnname "(size %llu, al %llu)", (ULong)n, (ULong)alignment ); \
\
if ((alignment == 0) \
if (alignment < VG_MIN_MALLOC_SZB) \
alignment = VG_MIN_MALLOC_SZB; \
\
- v = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_##vg_replacement, n, alignment ); \
+ v = (void*)VALGRIND_NON_SIMD_CALL3( info.tl_##vg_replacement, n, alignment, orig_alignment ); \
MALLOC_TRACE(" = %p\n", v ); \
if (!v) SET_ERRNO_ENOMEM; \
return v; \
'vg_replacement' to allocate aligned memory. If that fails, it bombs the
system.
*/
-#define ALLOC_or_BOMB_ALIGNED(soname, fnname, vg_replacement) \
+#define ALLOC_or_BOMB_ALIGNED(soname, fnname, vg_replacement, tag) \
\
void* VG_REPLACE_FUNCTION_EZU(10030,soname,fnname) (SizeT n, SizeT alignment); \
void* VG_REPLACE_FUNCTION_EZU(10030,soname,fnname) (SizeT n, SizeT alignment) \
{ \
void* v; \
+ SizeT orig_alignment = alignment; \
\
DO_INIT; \
TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED(n); \
+ struct AlignedAllocInfo aligned_alloc_info = { .orig_alignment=alignment, .size=n, .alloc_kind=AllocKind##tag }; \
+ VERIFY_ALIGNMENT(&aligned_alloc_info); \
MALLOC_TRACE(#fnname "(size %llu, al %llu)", (ULong)n, (ULong)alignment ); \
\
if ((alignment == 0) \
if (alignment < VG_MIN_MALLOC_SZB) \
alignment = VG_MIN_MALLOC_SZB; \
\
- v = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_##vg_replacement, n, alignment ); \
+ v = (void*)VALGRIND_NON_SIMD_CALL3( info.tl_##vg_replacement, n, alignment, orig_alignment ); \
MALLOC_TRACE(" = %p\n", v ); \
if (NULL == v) { \
VALGRIND_PRINTF( \
#if defined(VGO_linux)
// operator new(unsigned int, std::align_val_t)
#if VG_WORDSIZE == 4
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBC_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_t, __builtin_new_aligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBC_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_t, __builtin_new_aligned, NewAligned);
#endif
// operator new(unsigned long, std::align_val_t)
#if VG_WORDSIZE == 8
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBC_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_t, __builtin_new_aligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBC_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_t, __builtin_new_aligned, NewAligned);
#endif
#elif defined(VGO_freebsd)
- // operator new(unsigned int)
+ // operator new(unsigned int, std::align_val_t)
#if VG_WORDSIZE == 4
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_t, __builtin_new_aligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_t, __builtin_new_aligned, NewAligned);
#endif
- // operator new(unsigned long)
+ // operator new(unsigned long, std::align_val_t)
#if VG_WORDSIZE == 8
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_t, __builtin_new_aligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_t, __builtin_new_aligned, NewAligned);
#endif
#elif defined(VGO_darwin)
#if VG_WORDSIZE == 4
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_t, __builtin_new_aligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_t, __builtin_new_aligned, NewAligned);
#endif
#if VG_WORDSIZE == 8
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_t, __builtin_new_aligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_t, __builtin_new_aligned, NewAligned);
#endif
#elif defined(VGO_solaris)
// operator new(unsigned int, std::align_val_t)
#if VG_WORDSIZE == 4
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_t, __builtin_new_aligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_t, __builtin_new_aligned, NewAligned);
#endif
// operator new(unsigned long, std::align_val_t)
#if VG_WORDSIZE == 8
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned);
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_t, __builtin_new_aligned);
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_t, __builtin_new_aligned, NewAligned);
#endif
#if defined(VGO_linux)
// operator new(unsigned int, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 4
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBC_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBC_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
#endif
// operator new(unsigned long, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 8
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBC_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBC_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
#endif
#elif defined(VGO_freebsd)
// operator new(unsigned int, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 4
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
#endif
// operator new(unsigned long, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 8
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
#endif
#elif defined(VGO_darwin)
#if VG_WORDSIZE == 4
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
#endif
#if VG_WORDSIZE == 8
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
#endif
#elif defined(VGO_solaris)
// operator new(unsigned, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 4
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, __ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, __ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, __ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, __ZnwjSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
#endif
// operator new(unsigned long, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 8
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned);
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnwmSt11align_val_tRKSt9nothrow_t, __builtin_new_aligned, NewAligned);
#endif
#endif
#if defined(VGO_linux)
// operator new[](unsigned int, std::align_val_t)
#if VG_WORDSIZE == 4
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBC_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_t, __builtin_vec_new_aligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBC_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
// operator new[](unsigned long, std::align_val_t)
#if VG_WORDSIZE == 8
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBC_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_t, __builtin_vec_new_aligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBC_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
#elif defined(VGO_freebsd)
// operator new[](unsigned int, std::align_val_t)
#if VG_WORDSIZE == 4
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_t, __builtin_vec_new_aligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
// operator new[](unsigned long, std::align_val_t)
#if VG_WORDSIZE == 8
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_t, __builtin_vec_new_aligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
#elif defined(VGO_darwin)
#if VG_WORDSIZE == 4
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_t, __builtin_vec_new_aligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
// operator new[](unsigned long, std::align_val_t)
#if VG_WORDSIZE == 8
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_t, __builtin_vec_new_aligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
#elif defined(VGO_solaris)
// operator new[](unsigned int, std::align_val_t)
#if VG_WORDSIZE == 4
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_t, __builtin_vec_new_aligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
// operator new[](unsigned long, std::align_val_t)
#if VG_WORDSIZE == 8
- ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned );
- ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_t, __builtin_vec_new_aligned );
+ ALLOC_or_BOMB_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_BOMB_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
#endif
#if defined(VGO_linux)
// operator new[](unsigned int, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 4
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBC_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBC_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
// operator new[](unsigned long, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 8
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBC_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBC_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
#elif defined(VGO_freebsd)
// operator new[](unsigned int, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 4
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
// operator new[](unsigned long, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 8
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
#elif defined(VGO_darwin)
#if VG_WORDSIZE == 4
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
// operator new[](unsigned long, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 8
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
#elif defined(VGO_solaris)
// operator new[](unsigned int, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 4
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnajSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
// operator new[](unsigned long, std::align_val_t, std::nothrow_t const&)
#if VG_WORDSIZE == 8
- ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
- ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned );
+ ALLOC_or_NULL_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
+ ALLOC_or_NULL_ALIGNED(SO_SYN_MALLOC, _ZnamSt11align_val_tRKSt9nothrow_t, __builtin_vec_new_aligned, VecNewAligned );
#endif
#endif
/*------------------- C++14 delete sized -------------------*/
-#define DELETE_SIZED(soname, fnname, vg_replacement) \
+#define DELETE_SIZED(soname, fnname, vg_replacement, tag) \
\
void VG_REPLACE_FUNCTION_EZU(10050,soname,fnname) (void *p, SizeT size); \
void VG_REPLACE_FUNCTION_EZU(10050,soname,fnname) (void *p, SizeT size) \
{ \
+ struct AlignedAllocInfo aligned_alloc_info = { .size=size, .mem=p, .alloc_kind=AllocKind##tag }; \
+ \
DO_INIT; \
TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED((UWord)size); \
+ VERIFY_ALIGNMENT(&aligned_alloc_info); \
MALLOC_TRACE(#fnname "(%p)\n", p ); \
if (p == NULL) \
return; \
#if defined(VGO_linux)
// operator delete(void*, unsigned int)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvj, __builtin_delete );
- DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdlPvj, __builtin_delete );
- DELETE_SIZED(VG_Z_LIBC_SONAME, _ZdlPvj, __builtin_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvj, __builtin_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvj, __builtin_delete, DeleteSized );
+ DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdlPvj, __builtin_delete, DeleteSized );
+ DELETE_SIZED(VG_Z_LIBC_SONAME, _ZdlPvj, __builtin_delete, DeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvj, __builtin_delete, DeleteSized );
// operator delete(void*, unsigned long)
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvm, __builtin_delete );
- DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdlPvm, __builtin_delete );
- DELETE_SIZED(VG_Z_LIBC_SONAME, _ZdlPvm, __builtin_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvm, __builtin_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvm, __builtin_delete, DeleteSized );
+ DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdlPvm, __builtin_delete, DeleteSized );
+ DELETE_SIZED(VG_Z_LIBC_SONAME, _ZdlPvm, __builtin_delete, DeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvm, __builtin_delete, DeleteSized );
#endif
#elif defined(VGO_freebsd)
// operator delete(void*, unsigned int)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvj, __builtin_delete );
- DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdlPvj, __builtin_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvj, __builtin_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvj, __builtin_delete, DeleteSized );
+ DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdlPvj, __builtin_delete, DeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvj, __builtin_delete, DeleteSized );
#elif __SIZEOF_SIZE_T__ == 8
// operator delete(void*, unsigned long)
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvm, __builtin_delete );
- DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdlPvm, __builtin_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvm, __builtin_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvm, __builtin_delete, DeleteSized );
+ DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdlPvm, __builtin_delete, DeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvm, __builtin_delete, DeleteSized );
#endif
#elif defined(VGO_darwin)
// operator delete(void*, unsigned int)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvj, __builtin_delete );
- DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdlPvj, __builtin_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvj, __builtin_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvj, __builtin_delete, DeleteSized );
+ DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdlPvj, __builtin_delete, DeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvj, __builtin_delete, DeleteSized );
#elif __SIZEOF_SIZE_T__ == 8
// operator delete(void*, unsigned long)
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvm, __builtin_delete );
- DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdlPvm, __builtin_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvm, __builtin_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvm, __builtin_delete, DeleteSized );
+ DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdlPvm, __builtin_delete, DeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvm, __builtin_delete, DeleteSized );
#endif
#elif defined(VGO_solaris)
// operator delete(void*, unsigned long)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvj, __builtin_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvj, __builtin_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvj, __builtin_delete, DeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvj, __builtin_delete, DeleteSized );
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvm, __builtin_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvm, __builtin_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvm, __builtin_delete, DeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdlPvm, __builtin_delete, DeleteSized );
#endif
#endif
/*------------------- C++17 delete aligned -------------------*/
-#define DELETE_ALIGNED(soname, fnname, vg_replacement) \
+/* No need to check the alignment
+ * either the alignment matches the alloc
+ * or the alloc would have failed */
+
+#define DELETE_ALIGNED(soname, fnname, vg_replacement, tag ) \
\
void VG_REPLACE_FUNCTION_EZU(10050,soname,fnname) (void *p, SizeT alignment); \
void VG_REPLACE_FUNCTION_EZU(10050,soname,fnname) (void *p, SizeT alignment) \
{ \
+ struct AlignedAllocInfo aligned_alloc_info = { .orig_alignment=alignment, .mem=p, .alloc_kind=AllocKind##tag }; \
+ \
DO_INIT; \
TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED((UWord)alignment); \
+ VERIFY_ALIGNMENT(&aligned_alloc_info); \
MALLOC_TRACE(#fnname "(%p)\n", p ); \
if (p == NULL) \
return; \
(void)VALGRIND_NON_SIMD_CALL1( info.tl_##vg_replacement, p ); \
}
-#define DELETE_SIZED_ALIGNED(soname, fnname, vg_replacement) \
+#define DELETE_SIZED_ALIGNED(soname, fnname, vg_replacement, tag ) \
\
void VG_REPLACE_FUNCTION_EZU(10050,soname,fnname) (void *p, SizeT size, SizeT alignment); \
void VG_REPLACE_FUNCTION_EZU(10050,soname,fnname) (void *p, SizeT size, SizeT alignment) \
{ \
+ struct AlignedAllocInfo aligned_alloc_info = { .orig_alignment=alignment, .size=size, .mem=p, .alloc_kind=AllocKind##tag }; \
+ \
DO_INIT; \
TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED((UWord)size); \
TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED((UWord)alignment); \
+ VERIFY_ALIGNMENT(&aligned_alloc_info); \
MALLOC_TRACE(#fnname "(%p)\n", p ); \
if (p == NULL) \
return; \
#if defined(VGO_linux)
// operator delete(void*, std::align_val_t)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBC_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_t, __builtin_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBC_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_t, __builtin_delete_aligned, DeleteAligned );
// operator delete(void*, unsigned int, std::align_val_t)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBC_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvjSt11align_val_t, __builtin_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBC_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvjSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
// operator delete(void*, unsigned long, std::align_val_t)
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBC_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvmSt11align_val_t, __builtin_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBC_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvmSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
#endif
#elif defined(VGO_freebsd)
// operator delete(void*, std::align_val_t)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_t, __builtin_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_t, __builtin_delete_aligned, DeleteAligned );
// operator delete(void*, unsigned int, std::align_val_t)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvjSt11align_val_t, __builtin_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvjSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
// operator delete(void*, unsigned long, std::align_val_t)
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvmSt11align_val_t, __builtin_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvmSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
#endif
#elif defined(VGO_darwin)
// operator delete(void*, std::align_val_t)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_t, __builtin_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_t, __builtin_delete_aligned, DeleteAligned );
// operator delete(void*, unsigned int, std::align_val_t)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvjSt11align_val_t, __builtin_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvjSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
// operator delete(void*, unsigned long, std::align_val_t)
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvmSt11align_val_t, __builtin_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvmSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
#endif
#elif defined(VGO_solaris)
// operator delete(void*, std::align_val_t)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_t, __builtin_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_t, __builtin_delete_aligned, DeleteAligned );
// operator delete(void*, unsigned int, std::align_val_t)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvjSt11align_val_t, __builtin_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvjSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvjSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
// operator delete(void*, unsigned long, std::align_val_t)
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvmSt11align_val_t, __builtin_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvmSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdlPvmSt11align_val_t, __builtin_delete_aligned, DeleteSizedAligned );
#endif
#endif
#if defined(VGO_linux)
// operator delete(void*, std::align_val_t, std::nothrow_t const&)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBC_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBC_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned, DeleteAligned );
// no sized version of this operator
#elif defined(VGO_freebsd)
// operator delete(void*, std::align_val_t, std::nothrow_t const&)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned, DeleteAligned );
#elif defined(VGO_darwin)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned, DeleteAligned );
#elif defined(VGO_solaris)
// operator delete(void*, std::align_val_t, std::nothrow_t const&)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned, DeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdlPvSt11align_val_tRKSt9nothrow_t, __builtin_delete_aligned, DeleteAligned );
// no sized version of this operator
#if defined(VGO_linux)
// operator delete[](void*, unsigned int)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvj, __builtin_vec_delete );
- DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdaPvj, __builtin_vec_delete );
- DELETE_SIZED(VG_Z_LIBC_SONAME, _ZdaPvj, __builtin_vec_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvj, __builtin_vec_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvj, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdaPvj, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(VG_Z_LIBC_SONAME, _ZdaPvj, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvj, __builtin_vec_delete, VecDeleteSized );
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvm, __builtin_vec_delete );
- DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdaPvm, __builtin_vec_delete );
- DELETE_SIZED(VG_Z_LIBC_SONAME, _ZdaPvm, __builtin_vec_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvm, __builtin_vec_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvm, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdaPvm, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(VG_Z_LIBC_SONAME, _ZdaPvm, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvm, __builtin_vec_delete, VecDeleteSized );
#endif
#elif defined(VGO_freebsd)
// operator delete[](void*, unsigned int)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvj, __builtin_vec_delete );
- DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdaPvj, __builtin_vec_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvj, __builtin_vec_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvj, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdaPvj, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvj, __builtin_vec_delete, VecDeleteSized );
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvm, __builtin_vec_delete );
- DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdaPvm, __builtin_vec_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvm, __builtin_vec_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvm, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdaPvm, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvm, __builtin_vec_delete, VecDeleteSized );
#endif
#elif defined(VGO_darwin)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvj, __builtin_vec_delete );
- DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdaPvj, __builtin_vec_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvj, __builtin_vec_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvj, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdaPvj, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvj, __builtin_vec_delete, VecDeleteSized );
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvm, __builtin_vec_delete );
- DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdaPvm, __builtin_vec_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvm, __builtin_vec_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvm, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(VG_Z_LIBCXX_SONAME, _ZdaPvm, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvm, __builtin_vec_delete, VecDeleteSized );
#endif
#elif defined(VGO_solaris)
// operator delete[](void*, unsigned int)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvj, __builtin_vec_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvj, __builtin_vec_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvj, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvj, __builtin_vec_delete, VecDeleteSized );
// operator delete[](void*, unsigned long)
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvm, __builtin_vec_delete );
- DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvm, __builtin_vec_delete );
+ DELETE_SIZED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvm, __builtin_vec_delete, VecDeleteSized );
+ DELETE_SIZED(SO_SYN_MALLOC, _ZdaPvm, __builtin_vec_delete, VecDeleteSized );
#endif
#endif
#if defined(VGO_linux)
// operator delete[](void*, std::align_val_t)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBC_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBC_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteAligned );
// operator delete[](void*, unsigned int, std::align_val_t)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBC_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBC_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
// operator delete[](void*, unsigned long, std::align_val_t)
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBC_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBC_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
#endif
#elif defined(VGO_freebsd)
// operator delete[](void*, std::align_val_t)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteAligned );
// operator delete[](void*, unsigned int, std::align_val_t)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
// operator delete[](void*, unsigned long, std::align_val_t)
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
#endif
#elif defined(VGO_darwin)
// operator delete[](void*, std::align_val_t)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteAligned );
// operator delete[](void*, unsigned int, std::align_val_t)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
// operator delete[](void*, unsigned long, std::align_val_t)
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
#endif
#elif defined(VGO_solaris)
- // operator delete[](void*, std::align_val_t)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned );
+ // operator delete[](void*, std::align_val_t), GNU mangling
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteAligned );
// operator delete[](void*, unsigned int, std::align_val_t)
#if __SIZEOF_SIZE_T__ == 4
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvjSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
// operator delete[](void*, unsigned long)
#elif __SIZEOF_SIZE_T__ == 8
- DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned );
- DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned );
+ DELETE_SIZED_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
+ DELETE_SIZED_ALIGNED(SO_SYN_MALLOC, _ZdaPvmSt11align_val_t, __builtin_vec_delete_aligned, VecDeleteSizedAligned );
#endif
#endif
#if defined(VGO_linux)
// operator delete[](void*, std::align_val_t, std::nothrow_t const&)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBC_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBC_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned, VecDeleteAligned );
// no sized version of this operator
#elif defined(VGO_freebsd)
// operator delete[](void*, std::align_val_t, std::nothrow_t const&)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned, VecDeleteAligned );
#elif defined(VGO_darwin)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(VG_Z_LIBCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned, VecDeleteAligned );
#elif defined(VGO_solaris)
// operator delete[](void*, std::align_val_t, std::nothrow_t const&)
- DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned );
- DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned );
+ DELETE_ALIGNED(VG_Z_LIBSTDCXX_SONAME, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned, VecDeleteAligned );
+ DELETE_ALIGNED(SO_SYN_MALLOC, _ZdaPvSt11align_val_tRKSt9nothrow_t, __builtin_vec_delete_aligned, VecDeleteAligned );
// no sized version of this operator
/* Probably in the wrong place, this is the function
called by posix_memalign, at least on macOS 10.13 */
-#define ZONEMEMALIGN(soname, fnname) \
- \
- void* VG_REPLACE_FUNCTION_EZU(10100,soname,fnname) \
- ( void *zone, SizeT alignment, SizeT n ); \
- void* VG_REPLACE_FUNCTION_EZU(10100,soname,fnname) \
- ( void *zone, SizeT alignment, SizeT n ) \
- { \
- void* v; \
- \
- DO_INIT; \
- TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED((UWord) zone); \
- TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED(n); \
- MALLOC_TRACE("zone_memalign(%p, al %llu, size %llu)", \
- zone, (ULong)alignment, (ULong)n ); \
- \
- if (alignment == 0 \
- || alignment % sizeof (void *) != 0 \
- || (alignment & (alignment - 1)) != 0) { \
- SET_ERRNO_EINVAL; \
- return NULL; \
- } \
- /* Round up to minimum alignment if necessary. */ \
- if (alignment < VG_MIN_MALLOC_SZB) \
- alignment = VG_MIN_MALLOC_SZB; \
- \
- /* Round up to nearest power-of-two if necessary (like glibc). */ \
- while (0 != (alignment & (alignment - 1))) alignment++; \
- \
- v = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_memalign, alignment, n ); \
- MALLOC_TRACE(" = %p\n", v ); \
- if (!v) SET_ERRNO_ENOMEM; \
- return v; \
+#define ZONEMEMALIGN(soname, fnname) \
+ \
+ void* VG_REPLACE_FUNCTION_EZU(10100, soname, fnname)( \
+ void* zone, SizeT alignment, SizeT n); \
+ void* VG_REPLACE_FUNCTION_EZU(10100, soname, \
+ fnname)(void* zone, SizeT alignment, SizeT n) \
+ { \
+ void* v; \
+ SizeT orig_alignment = alignment; \
+ struct AlignedAllocInfo aligned_alloc_info = { \
+ .orig_alignment = alignment, \
+ .size = n, \
+ .alloc_kind = AllocKindPosixMemalign}; \
+ \
+ DO_INIT; \
+ VERIFY_ALIGNMENT(&aligned_alloc_info); \
+ TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED((UWord)zone); \
+ TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED(n); \
+ MALLOC_TRACE("zone_memalign(%p, al %llu, size %llu)", zone, \
+ (ULong)alignment, (ULong)n); \
+ \
+ if (alignment == 0 || alignment % sizeof(void*) != 0 || \
+ (alignment & (alignment - 1)) != 0) { \
+ SET_ERRNO_EINVAL; \
+ return NULL; \
+ } \
+ /* Round up to minimum alignment if necessary. */ \
+ if (alignment < VG_MIN_MALLOC_SZB) \
+ alignment = VG_MIN_MALLOC_SZB; \
+ \
+ /* Round up to nearest power-of-two if necessary (like glibc). */ \
+ while (0 != (alignment & (alignment - 1))) \
+ alignment++; \
+ \
+ v = (void*)VALGRIND_NON_SIMD_CALL3(info.tl_memalign, alignment, \
+ orig_alignment, n); \
+ MALLOC_TRACE(" = %p\n", v); \
+ if (!v) \
+ SET_ERRNO_ENOMEM; \
+ return v; \
}
#if defined(VGO_freebsd)
#if defined(VGO_solaris)
#define VG_MEMALIGN_ALIGN_FACTOR_FOUR 1
+#define VG_MEMALIGN_NO_ALIGN_ZERO 1
#else
#define VG_MEMALIGN_ALIGN_FACTOR_FOUR 0
+#define VG_MEMALIGN_NO_ALIGN_ZERO 0
#endif
#if defined(MUSL_LIBC)
( SizeT alignment, SizeT n ) \
{ \
void* v; \
+ SizeT orig_alignment = alignment; \
+ struct AlignedAllocInfo aligned_alloc_info = { .orig_alignment=alignment, .size=n, .alloc_kind=AllocKindMemalign}; \
\
DO_INIT; \
TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED(n); \
+ VERIFY_ALIGNMENT(&aligned_alloc_info); \
MALLOC_TRACE("memalign(al %llu, size %llu)", \
(ULong)alignment, (ULong)n ); \
\
/* Round up to nearest power-of-two if necessary (like glibc). */ \
while (0 != (alignment & (alignment - 1))) alignment++; \
\
- v = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_memalign, alignment, n ); \
+ v = (void*)VALGRIND_NON_SIMD_CALL3( info.tl_memalign, alignment, orig_alignment, n ); \
MALLOC_TRACE(" = %p\n", v ); \
if (!v) SET_ERRNO_ENOMEM; \
return v; \
#else
-#define MEMALIGN(soname, fnname) \
- \
- void* VG_REPLACE_FUNCTION_EZU(10110,soname,fnname) \
- ( SizeT alignment, SizeT size ); \
- void* VG_REPLACE_FUNCTION_EZU(10110,soname,fnname) \
- ( SizeT alignment, SizeT size ) \
- { \
- void *mem; \
- \
- DO_INIT; \
- MALLOC_TRACE("memalign(alignment %llu, size %llu)", \
- (ULong)alignment, (ULong)size ); \
- if ((VG_MEMALIGN_NO_SIZE_ZERO && (size == 0)) \
- || (VG_MEMALIGN_NO_ALIGN_ZERO && (alignment == 0)) \
- || (VG_MEMALIGN_ALIGN_POWER_TWO && (alignment & (alignment - 1)) != 0) \
- || (VG_MEMALIGN_ALIGN_FACTOR_FOUR && (alignment % 4 != 0))) { \
- SET_ERRNO_EINVAL; \
- return 0; \
- } \
- /* Round up to minimum alignment if necessary. */ \
- if (alignment < VG_MIN_MALLOC_SZB) \
- alignment = VG_MIN_MALLOC_SZB; \
- /* Solaris allows non-power of 2 alignment but not Valgrind. */ \
- while (0 != (alignment & (alignment - 1))) alignment++; \
- \
- if (VG_MEMALIGN_MAKE_SIZE_MULTIPLE_ALIGN) { \
- size = ((size + alignment - 1)/alignment)*alignment; \
- } \
- \
- mem = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_memalign, alignment, size ); \
- \
- if (!mem) SET_ERRNO_ENOMEM; \
- \
- return mem; \
+#define MEMALIGN(soname, fnname) \
+ \
+ void* VG_REPLACE_FUNCTION_EZU(10110, soname, fnname)(SizeT alignment, \
+ SizeT size); \
+ void* VG_REPLACE_FUNCTION_EZU(10110, soname, fnname)(SizeT alignment, \
+ SizeT size) \
+ { \
+ void* mem; \
+ SizeT orig_alignment = alignment; \
+ struct AlignedAllocInfo aligned_alloc_info = { \
+ .orig_alignment = alignment, \
+ .size = size, \
+ .alloc_kind = AllocKindMemalign}; \
+ \
+ DO_INIT; \
+ VERIFY_ALIGNMENT(&aligned_alloc_info); \
+ MALLOC_TRACE("memalign(alignment %llu, size %llu)", (ULong)alignment, \
+ (ULong)size); \
+ if ((VG_MEMALIGN_NO_SIZE_ZERO && (size == 0)) || \
+ (VG_MEMALIGN_NO_ALIGN_ZERO && (alignment == 0)) || \
+ (VG_MEMALIGN_ALIGN_POWER_TWO && \
+ (alignment & (alignment - 1)) != 0) || \
+ (VG_MEMALIGN_ALIGN_FACTOR_FOUR && (alignment % 4 != 0))) { \
+ SET_ERRNO_EINVAL; \
+ return 0; \
+ } \
+ /* Round up to minimum alignment if necessary. */ \
+ if (alignment < VG_MIN_MALLOC_SZB) \
+ alignment = VG_MIN_MALLOC_SZB; \
+ /* Solaris allows non-power of 2 alignment but not Valgrind. */ \
+ while (0 != (alignment & (alignment - 1))) \
+ alignment++; \
+ \
+ if (VG_MEMALIGN_MAKE_SIZE_MULTIPLE_ALIGN) { \
+ size = ((size + alignment - 1) / alignment) * alignment; \
+ } \
+ \
+ mem = (void*)VALGRIND_NON_SIMD_CALL3(info.tl_memalign, alignment, \
+ orig_alignment, size); \
+ \
+ if (!mem) \
+ SET_ERRNO_ENOMEM; \
+ \
+ return mem; \
}
#endif
pszB = my_getpagesize(); \
DO_INIT; \
TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED(size); \
- mem = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_memalign, \
- pszB, size ); \
+ mem = (void*)VALGRIND_NON_SIMD_CALL3( info.tl_memalign, \
+ pszB, pszB, size ); \
\
if (!mem) SET_ERRNO_ENOMEM; \
\
if (pszB == 0) \
pszB = my_getpagesize(); \
TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED((UWord) zone); \
- return (void*)VALGRIND_NON_SIMD_CALL2( info.tl_memalign, \
- pszB, size ); \
+ return (void*)VALGRIND_NON_SIMD_CALL3( info.tl_memalign, \
+ pszB, pszB, size); \
}
#if defined(VGO_linux)
( void **memptr, SizeT alignment, SizeT size ) \
{ \
void *mem; \
+ SizeT orig_alignment = alignment; \
+ struct AlignedAllocInfo aligned_alloc_info = { .orig_alignment=alignment, .size=size, .alloc_kind=AllocKindPosixMemalign}; \
\
DO_INIT; \
TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED(size); \
+ VERIFY_ALIGNMENT(&aligned_alloc_info); \
MALLOC_TRACE("posix_memalign(al %llu, size %llu)\n", \
(ULong)alignment, (ULong)size ); \
/* Test whether the alignment argument is valid. It must be \
if (alignment < VG_MIN_MALLOC_SZB) \
alignment = VG_MIN_MALLOC_SZB; \
\
- mem = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_memalign, \
- alignment, size ); \
+ mem = (void*)VALGRIND_NON_SIMD_CALL3( info.tl_memalign, \
+ alignment, orig_alignment, size ); \
\
if (mem != NULL) { \
*memptr = mem; \
( SizeT alignment, SizeT size ) \
{ \
void *mem; \
+ SizeT orig_alignment = alignment; \
+ struct AlignedAllocInfo aligned_alloc_info = { .orig_alignment=alignment, .size=size, .alloc_kind=AllocKindAlignedAlloc}; \
\
DO_INIT; \
TRIGGER_MEMCHECK_ERROR_IF_UNDEFINED(size); \
+ VERIFY_ALIGNMENT(&aligned_alloc_info); \
MALLOC_TRACE("aligned_alloc(al %llu, size %llu)", \
(ULong)alignment, (ULong)size ); \
/* Test whether the alignment argument is valid. It must be \
|| (alignment & (alignment - 1)) != 0) \
return 0; \
\
- mem = VG_REPLACE_FUNCTION_EZU(10110,VG_Z_LIBC_SONAME,memalign) \
- (alignment, size); \
+ mem = (void*)VALGRIND_NON_SIMD_CALL3( info.tl_memalign, \
+ alignment, orig_alignment, size ); \
\
return mem; \
}
( SizeT alignment, SizeT size ) \
{ \
void *mem; \
+ SizeT orig_alignment = alignment; \
+ struct AlignedAllocInfo aligned_alloc_info = { .orig_alignment=alignment, .size=size, .alloc_kind=AllocKindAlignedAlloc}; \
\
DO_INIT; \
+ VERIFY_ALIGNMENT(&aligned_alloc_info); \
MALLOC_TRACE("aligned_alloc(al %llu, size %llu)", \
(ULong)alignment, (ULong)size ); \
if ((VG_ALIGNED_ALLOC_NO_SIZE_ZERO && (alignment == 0)) \
/* Solaris allows non-power of 2 alignment but not Valgrind. */ \
while (0 != (alignment & (alignment - 1))) alignment++; \
\
- mem = (void*)VALGRIND_NON_SIMD_CALL2( info.tl_memalign, \
- alignment, size ); \
+ mem = (void*)VALGRIND_NON_SIMD_CALL3( info.tl_memalign, \
+ alignment, orig_alignment, size ); \
\
if (!mem) SET_ERRNO_ENOMEM; \
\
void VG_(needs_malloc_replacement)(
void* (*malloc) ( ThreadId, SizeT ),
void* (*__builtin_new) ( ThreadId, SizeT ),
- void* (*__builtin_new_aligned)( ThreadId, SizeT, SizeT ),
+ void* (*__builtin_new_aligned)( ThreadId, SizeT, SizeT, SizeT ),
void* (*__builtin_vec_new) ( ThreadId, SizeT ),
- void* (*__builtin_vec_new_aligned)( ThreadId, SizeT, SizeT ),
- void* (*memalign) ( ThreadId, SizeT, SizeT ),
+ void* (*__builtin_vec_new_aligned)( ThreadId, SizeT, SizeT, SizeT ),
+ void* (*memalign) ( ThreadId, SizeT, SizeT, SizeT ),
void* (*calloc) ( ThreadId, SizeT, SizeT ),
void (*free) ( ThreadId, void* ),
void (*__builtin_delete) ( ThreadId, void* ),
struct vg_mallocfunc_info {
void* (*tl_malloc) (ThreadId tid, SizeT n);
void* (*tl___builtin_new) (ThreadId tid, SizeT n);
- void* (*tl___builtin_new_aligned) (ThreadId tid, SizeT n, SizeT align);
+ void* (*tl___builtin_new_aligned) (ThreadId tid, SizeT n, SizeT align, SizeT orig_align);
void* (*tl___builtin_vec_new) (ThreadId tid, SizeT n);
- void* (*tl___builtin_vec_new_aligned) (ThreadId tid, SizeT n, SizeT align);
- void* (*tl_memalign) (ThreadId tid, SizeT align, SizeT n);
+ void* (*tl___builtin_vec_new_aligned) (ThreadId tid, SizeT n, SizeT align, SizeT orig_align);
+ void* (*tl_memalign) (ThreadId tid, SizeT align, SizeT orig_align, SizeT n);
void* (*tl_calloc) (ThreadId tid, SizeT nmemb, SizeT n);
void (*tl_free) (ThreadId tid, void* p);
void (*tl___builtin_delete) (ThreadId tid, void* p);
// VG_(needs).malloc_replacement
void* (*tool_malloc) (ThreadId, SizeT);
void* (*tool___builtin_new) (ThreadId, SizeT);
- void* (*tool___builtin_new_aligned) (ThreadId, SizeT, SizeT);
+ void* (*tool___builtin_new_aligned) (ThreadId, SizeT, SizeT, SizeT);
void* (*tool___builtin_vec_new) (ThreadId, SizeT);
- void* (*tool___builtin_vec_new_aligned) (ThreadId, SizeT, SizeT);
- void* (*tool_memalign) (ThreadId, SizeT, SizeT);
+ void* (*tool___builtin_vec_new_aligned) (ThreadId, SizeT, SizeT, SizeT);
+ void* (*tool_memalign) (ThreadId, SizeT, SizeT, SizeT);
void* (*tool_calloc) (ThreadId, SizeT, SizeT);
void (*tool_free) (ThreadId, void*);
void (*tool___builtin_delete) (ThreadId, void*);
return new_block( tid, NULL, szB, VG_(clo_alignment), /*is_zeroed*/False );
}
-static void* dh___builtin_new_aligned ( ThreadId tid, SizeT szB, SizeT alignB )
+static void* dh___builtin_new_aligned ( ThreadId tid, SizeT szB, SizeT alignB, SizeT orig_alignB )
{
return new_block( tid, NULL, szB, alignB, /*is_zeroed*/False );
}
return new_block( tid, NULL, szB, VG_(clo_alignment), /*is_zeroed*/False );
}
-static void* dh___builtin_vec_new_aligned ( ThreadId tid, SizeT szB, SizeT alignB )
+static void* dh___builtin_vec_new_aligned ( ThreadId tid, SizeT szB, SizeT alignB, SizeT orig_alignB )
{
return new_block( tid, NULL, szB, alignB, /*is_zeroed*/False );
}
return new_block( tid, NULL, m*szB, VG_(clo_alignment), /*is_zeroed*/True );
}
-static void *dh_memalign ( ThreadId tid, SizeT alignB, SizeT szB )
+static void *dh_memalign ( ThreadId tid, SizeT alignB, SizeT orig_alignB, SizeT szB)
{
return new_block( tid, NULL, szB, alignB, False );
}
}
/** Wrapper for memalign(). */
-static void* drd_memalign(ThreadId tid, SizeT align, SizeT n)
+static void* drd_memalign(ThreadId tid, SizeT align, SizeT orig_alignT, SizeT n)
{
return new_block(tid, n, align, /*is_zeroed*/False);
}
}
/** Wrapper for __builtin_new_aligned(). */
-static void* drd___builtin_new_aligned(ThreadId tid, SizeT n, SizeT align)
+static void* drd___builtin_new_aligned(ThreadId tid, SizeT n, SizeT align, SizeT orig_align)
{
return new_block(tid, n, align, /*is_zeroed*/False);
}
}
/** Wrapper for __builtin_vec_new_aligned(). */
-static void* drd___builtin_vec_new_aligned(ThreadId tid, SizeT n, SizeT align)
+static void* drd___builtin_vec_new_aligned(ThreadId tid, SizeT n, SizeT align, SizeT orig_align)
{
return new_block(tid, n, align, /*is_zeroed*/False);
}
return handle_alloc ( tid, n, VG_(clo_alignment),
/*is_zeroed*/False );
}
-static void* hg_cli____builtin_new_aligned ( ThreadId tid, SizeT n, SizeT align ) {
+static void* hg_cli____builtin_new_aligned ( ThreadId tid, SizeT n, SizeT align, SizeT orig_align ) {
if (((SSizeT)n) < 0) return NULL;
return handle_alloc ( tid, n, align,
/*is_zeroed*/False );
return handle_alloc ( tid, n, VG_(clo_alignment),
/*is_zeroed*/False );
}
-static void* hg_cli____builtin_vec_new_aligned ( ThreadId tid, SizeT n, SizeT align ) {
+static void* hg_cli____builtin_vec_new_aligned ( ThreadId tid, SizeT n, SizeT align, SizeT orig_align ) {
if (((SSizeT)n) < 0) return NULL;
return handle_alloc ( tid, n, align,
/*is_zeroed*/False );
}
-static void* hg_cli__memalign ( ThreadId tid, SizeT align, SizeT n ) {
+static void* hg_cli__memalign ( ThreadId tid, SizeT align, SizeT orig_alignT, SizeT n ) {
if (((SSizeT)n) < 0) return NULL;
return handle_alloc ( tid, n, align,
/*is_zeroed*/False );
// been called.
extern SizeT VG_(malloc_effective_client_redzone_size)(void);
+/* We have 4 different C functions that perform aligned allocation
+ * They all have slightly different error conditions. But we only have
+ * one wrapper - tl_memalign. Rather than split that into four
+ * nearly identical functions (or resort to a lot of client
+ * requests), the following enum and struct add context so that
+ * memcheck can figure out whether to emit an error.
+ * This isn't a problem for the C++ allocators. Even though
+ * there are many of them they all have the same alignment
+ * behaviour. */
+
+typedef enum {
+ AllocKindMemalign,
+ AllocKindPosixMemalign,
+ AllocKindAlignedAlloc,
+ AllocKindDeleteSized,
+ AllocKindVecDeleteSized,
+ AllocKindNewAligned,
+ AllocKindVecNewAligned,
+ AllocKindDeleteAligned,
+ AllocKindVecDeleteAligned,
+ AllocKindDeleteSizedAligned,
+ AllocKindVecDeleteSizedAligned
+} AlignedAllocKind;
+
+struct AlignedAllocInfo {
+ SizeT orig_alignment;
+ SizeT size;
+ void *mem;
+ AlignedAllocKind alloc_kind;
+};
+
#endif // __PUB_TOOL_REPLACEMALLOC_H
/*--------------------------------------------------------------------*/
extern void VG_(needs_malloc_replacement)(
void* (*pmalloc) ( ThreadId tid, SizeT n ),
void* (*p__builtin_new) ( ThreadId tid, SizeT n ),
- void* (*p__builtin_new_aligned)( ThreadId tid, SizeT n, SizeT align ),
+ void* (*p__builtin_new_aligned)( ThreadId tid, SizeT n, SizeT align, SizeT orig_align ),
void* (*p__builtin_vec_new) ( ThreadId tid, SizeT n ),
- void* (*p__builtin_vec_new_aligned)( ThreadId tid, SizeT n, SizeT align ),
- void* (*pmemalign) ( ThreadId tid, SizeT align, SizeT n ),
+ void* (*p__builtin_vec_new_aligned)( ThreadId tid, SizeT n, SizeT align, SizeT orig_align ),
+ void* (*pmemalign) ( ThreadId tid, SizeT align, SizeT orig_align, SizeT n),
void* (*pcalloc) ( ThreadId tid, SizeT nmemb, SizeT size1 ),
void (*pfree) ( ThreadId tid, void* p ),
void (*p__builtin_delete) ( ThreadId tid, void* p ),
return alloc_and_record_block( tid, szB, VG_(clo_alignment), /*is_zeroed*/False );
}
-static void* ms___builtin_new_aligned ( ThreadId tid, SizeT szB, SizeT alignB )
+static void* ms___builtin_new_aligned ( ThreadId tid, SizeT szB, SizeT alignB , SizeT orig_alignB )
{
return alloc_and_record_block( tid, szB, alignB, /*is_zeroed*/False );
}
return alloc_and_record_block( tid, szB, VG_(clo_alignment), /*is_zeroed*/False );
}
-static void* ms___builtin_vec_new_aligned ( ThreadId tid, SizeT szB, SizeT alignB )
+static void* ms___builtin_vec_new_aligned ( ThreadId tid, SizeT szB, SizeT alignB, SizeT orig_alignB )
{
return alloc_and_record_block( tid, szB, alignB, /*is_zeroed*/False );
}
return alloc_and_record_block( tid, m*szB, VG_(clo_alignment), /*is_zeroed*/True );
}
-static void *ms_memalign ( ThreadId tid, SizeT alignB, SizeT szB )
+static void *ms_memalign ( ThreadId tid, SizeT alignB, SizeT orig_alignB, SizeT szB)
{
return alloc_and_record_block( tid, szB, alignB, False );
}
<function>malloc</function>/<computeroutput>new</computeroutput>/<computeroutput>new[]</computeroutput>
versus
<function>free</function>/<computeroutput>delete</computeroutput>/<computeroutput>delete[]</computeroutput></para>
+ <para>Mismatches will also be reported for <computeroutput>sized</computeroutput> and <computeroutput>aligned</computeroutput>
+ allocation and deallocation functions if the deallocation value
+ does not match the allocation value.</para>
</listitem>
<listitem>
with realloc.</para>
</listitem>
+ <listitem>
+ <para>Using an <computeroutput>alignment</computeroutput> value that
+ is not a power of two.</para>
+ </listitem>
+
<listitem>
<para>Memory leaks.</para>
</listitem>
<function>calloc</function>,
<function>realloc</function>,
<function>memalign</function>,
+<function>posix_memalign</function>,
+<function>aligned_alloc</function>,
<function>new</function>,
<function>new []</function>.
<function>__builtin_new</function>,
<function>__builtin_vec_new</function>,
-For <function>calloc</function> both arguments are being checked.
+For <function>calloc</function> both arguments are checked.
</para>
<para>For example:</para>
</sect2>
+<sect2 id="mc-manual.alignment"
+ xreflabel="Alignment (and Size) Errors">
+<title>Alignment Errors</title>
+
+<para>C and C++ have several functions that allow the user to obtain aligned memory.
+Typically this is done for performance reasons so that the memory will be cache line
+or memory page aligned. C has the functions <computeroutput>memalign</computeroutput>,
+<computeroutput>posix_memalign</computeroutput> and <computeroutput>aligned_alloc</computeroutput>.
+C++ has numerous overloads of <computeroutput>operator new</computeroutput> and <computeroutput>
+operator delete</computeroutput>. Of these, posix_memalign is quite clearly
+specified, the others vary quite widely between implementations. Valgrind will generate
+errors for values of alignment that are invalid on any platform.</para>
+
+<!-- would like to have a table here -->
+<para><computeroutput>memalign</computeroutput> will produce errors if the alignment
+is zero or not a multiple of two.</para>
+
+<para><computeroutput>posix_memalign</computeroutput> will produce errors if the alignment
+is less than sizeof(size_t), not a multiple of two or if the size is zero.</para>
+
+<para><computeroutput>aligned_alloc</computeroutput> will produce errors if the alignment
+is not a multiple of two , if the size is zero or if the size is not an integral
+multiple of the alignment.</para>
+
+<para><computeroutput>aligned new</computeroutput> will produce errors if the alignment
+is zero or not a multiple of two. The <computeroutput>nothrow</computeroutput> overloads
+will return a NULL pointer. The non-nothrow overloads will abort Valgrind.</para>
+
+<para><computeroutput>aligned delete</computeroutput> will produce errors if the alignment
+is zero or not a multiple of two or if the alignment is not the same as that used by
+<computeroutput>aligned new</computeroutput>.</para>
+
+<para><computeroutput>sized delete</computeroutput> will produce errors if the size
+is not the same as that used by <computeroutput>new</computeroutput>.</para>
+
+<para><computeroutput>sized aligned delete</computeroutput> combines the error conditions
+of the individual sized and aligned delete operators.</para>
+
+<para>Example output:</para>
+<programlisting><![CDATA[
+==65825== Invalid alignment value: 3 (should be power of 2)
+==65825== at 0x485197E: memalign (vg_replace_malloc.c:1740)
+==65825== by 0x201CD2: main (memalign.c:39)
+]]></programlisting>
+
+</sect2>
<sect2 id="mc-manual.leaks" xreflabel="Memory leak detection">
<title>Memory leak detection</title>
Err_IllegalMempool,
Err_FishyValue,
Err_ReallocSizeZero,
+ Err_BadAlign,
+ Err_BadSize,
+ Err_SizeMismatch,
+ Err_AlignMismatch,
}
MC_ErrorTag;
AddrInfo ai;
} ReallocSizeZero;
+ struct {
+ AddrInfo ai;
+ SizeT dealloc_align;
+ SizeT size;
+ const HChar *msg;
+ } BadAlign;
+
+ struct {
+ AddrInfo ai;
+ SizeT size;
+ const HChar *func;
+ } BadSize;
+
// Call to strcpy, memcpy, etc, with overlapping blocks.
struct {
Addr src; // Source block
const HChar *argument_name;
SizeT value;
} FishyValue;
+
+ // Program allocates heap block with new but
+ // deallocates with a matching delete
+ // but with a different size
+ struct {
+ AddrInfo ai;
+ const HChar *function_names;
+ SizeT size;
+ } SizeMismatch;
+
+ // Program allocates heap block with one function
+ // (malloc/new/new[]/custom) and deallocates with
+ // a matching one but different alignment
+ struct {
+ AddrInfo ai;
+ const HChar *function_names;
+ SizeT alloc_align;
+ SizeT dealloc_align;
+ } AlignMismatch;
} Err;
};
}
break;
- case Err_ReallocSizeZero:
+ case Err_ReallocSizeZero:
+ if (xml) {
+ emit( " <kind>ReallocSizeZero</kind>\n" );
+ emit( " <what>realloc() with size 0</what>\n" );
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ VG_(pp_addrinfo_mc)(VG_(get_error_address)(err),
+ &extra->Err.ReallocSizeZero.ai, False);
+ } else {
+ emit( "realloc() with size 0\n" );
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ VG_(pp_addrinfo_mc)(VG_(get_error_address)(err),
+ &extra->Err.ReallocSizeZero.ai, False);
+ }
+ break;
+
+ case Err_BadAlign:
+ if (extra->Err.BadAlign.size) {
+ if (xml) {
+ emit( " <kind>InvalidSizeAndAlignment</kind>\n" );
+ emit( " <what>Invalid size value: %lu alignment value: %lu%s</what>\n",
+ extra->Err.BadAlign.size,
+ extra->Err.BadAlign.dealloc_align, extra->Err.BadAlign.msg );
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ } else {
+ emit( "Invalid size value: %lu alignment value: %lu%s\n",
+ extra->Err.BadAlign.size,
+ extra->Err.BadAlign.dealloc_align, extra->Err.BadAlign.msg );
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ }
+ } else {
+ if (xml) {
+ emit( " <kind>InvalidAlignment</kind>\n" );
+ emit( " <what>Invalid alignment value: %lu%s</what>\n",
+ extra->Err.BadAlign.dealloc_align, extra->Err.BadAlign.msg );
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ } else {
+ emit( "Invalid alignment value: %lu%s\n",
+ extra->Err.BadAlign.dealloc_align, extra->Err.BadAlign.msg );
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ }
+ }
+ break;
+
+ case Err_BadSize:
if (xml) {
- emit( " <kind>ReallocSizeZero</kind>\n" );
- emit( " <what>realloc() with size 0</what>\n" );
+ emit( " <kind>InvalidSize</kind>\n" );
+ emit( " <what>%s invalid size value: %lu</what>\n",
+ extra->Err.BadSize.func, extra->Err.BadSize.size );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
- VG_(pp_addrinfo_mc)(VG_(get_error_address)(err),
- &extra->Err.ReallocSizeZero.ai, False);
} else {
- emit( "realloc() with size 0\n" );
+ emit( "%s invalid size value: %lu\n",
+ extra->Err.BadSize.func, extra->Err.BadSize.size );
VG_(pp_ExeContext)( VG_(get_error_where)(err) );
- VG_(pp_addrinfo_mc)(VG_(get_error_address)(err),
- &extra->Err.ReallocSizeZero.ai, False);
}
break;
+ case Err_SizeMismatch:
+ if (xml) {
+ emit( " <kind>MismatchedAllocateDeallocateSize</kind>\n" );
+ emit( " <what>Mismatched %s size value: %lu</what>\n",
+ extra->Err.SizeMismatch.function_names, extra->Err.SizeMismatch.size );
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ VG_(pp_addrinfo_mc)(VG_(get_error_address)(err),
+ &extra->Err.SizeMismatch.ai, False);
+ } else {
+ emit( "Mismatched %s size value: %lu\n",
+ extra->Err.SizeMismatch.function_names, extra->Err.SizeMismatch.size );
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ VG_(pp_addrinfo_mc)(VG_(get_error_address)(err),
+ &extra->Err.SizeMismatch.ai, False);
+ }
+ break;
+
+ case Err_AlignMismatch:
+ if (xml) {
+ emit( " <kind>MismatchedAllocateDeallocateAlignment</kind>\n" );
+ emit( " <what>Mismatched %s size alloc value: %lu dealloc value %lu</what>\n",
+ extra->Err.SizeMismatch.function_names, extra->Err.AlignMismatch.alloc_align, extra->Err.AlignMismatch.dealloc_align );
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ VG_(pp_addrinfo_mc)(VG_(get_error_address)(err),
+ &extra->Err.AlignMismatch.ai, False);
+ } else {
+ emit( "Mismatched %s alignment alloc value: %lu dealloc value: %lu\n",
+ extra->Err.AlignMismatch.function_names, extra->Err.AlignMismatch.alloc_align, extra->Err.AlignMismatch.dealloc_align );
+ VG_(pp_ExeContext)( VG_(get_error_where)(err) );
+ VG_(pp_addrinfo_mc)(VG_(get_error_address)(err),
+ &extra->Err.AlignMismatch.ai, False);
+ }
+ break;
+
default:
VG_(printf)("Error:\n unknown Memcheck error code %d\n",
VG_(get_error_kind)(err));
VG_(maybe_record_error)( tid, Err_ReallocSizeZero, a, /*s*/NULL, &extra );
}
+void MC_(record_bad_alignment) ( ThreadId tid, SizeT align, SizeT size, const HChar *msg )
+{
+ MC_Error extra;
+ tl_assert(VG_INVALID_THREADID != tid);
+ extra.Err.BadAlign.dealloc_align = align;
+ extra.Err.BadAlign.size= size;
+ extra.Err.BadAlign.msg = msg;
+ VG_(maybe_record_error)( tid, Err_BadAlign, /*addr*/0, /*s*/NULL, &extra );
+}
+
+void MC_(record_bad_size) ( ThreadId tid, SizeT size, const HChar *function )
+{
+ MC_Error extra;
+ tl_assert(VG_INVALID_THREADID != tid);
+ extra.Err.BadSize.size= size;
+ extra.Err.BadSize.func = function;
+ VG_(maybe_record_error)( tid, Err_BadSize, /*addr*/0, /*s*/NULL, &extra );
+}
void MC_(record_illegal_mempool_error) ( ThreadId tid, Addr a )
{
return True;
}
+void MC_(record_size_mismatch_error) ( ThreadId tid, MC_Chunk* mc, SizeT size, const HChar *function_names)
+{
+ MC_Error extra;
+ AddrInfo* ai = &extra.Err.SizeMismatch.ai;
+ tl_assert(VG_INVALID_THREADID != tid);
+ ai->tag = Addr_Block;
+ ai->Addr.Block.block_kind = Block_Mallocd; // Nb: Not 'Block_Freed'
+ ai->Addr.Block.block_desc = "block";
+ ai->Addr.Block.block_szB = mc->szB;
+ ai->Addr.Block.rwoffset = 0;
+ ai->Addr.Block.allocated_at = MC_(allocated_at) (mc);
+ VG_(initThreadInfo) (&ai->Addr.Block.alloc_tinfo);
+ ai->Addr.Block.freed_at = MC_(freed_at) (mc);
+ extra.Err.SizeMismatch.size = size;
+ extra.Err.SizeMismatch.function_names = function_names;
+ VG_(maybe_record_error)( tid, Err_SizeMismatch, mc->data, /*s*/NULL,
+ &extra );
+}
+
+void MC_(record_align_mismatch_error) ( ThreadId tid, MC_Chunk* mc, SizeT align, const HChar *function_names )
+{
+ MC_Error extra;
+ AddrInfo* ai = &extra.Err.AlignMismatch.ai;
+ tl_assert(VG_INVALID_THREADID != tid);
+ ai->tag = Addr_Block;
+ ai->Addr.Block.block_kind = Block_Mallocd; // Nb: Not 'Block_Freed'
+ ai->Addr.Block.block_desc = "block";
+ ai->Addr.Block.block_szB = mc->szB;
+ ai->Addr.Block.rwoffset = 0;
+ ai->Addr.Block.allocated_at = MC_(allocated_at) (mc);
+ VG_(initThreadInfo) (&ai->Addr.Block.alloc_tinfo);
+ ai->Addr.Block.freed_at = MC_(freed_at) (mc);
+ extra.Err.AlignMismatch.alloc_align = mc->alignB;
+ extra.Err.AlignMismatch.dealloc_align = align;
+ extra.Err.AlignMismatch.function_names = function_names;
+ VG_(maybe_record_error)( tid, Err_AlignMismatch, mc->data, /*s*/NULL,
+ &extra );
+}
+
void MC_(record_user_error) ( ThreadId tid, Addr a,
Bool isAddrErr, UInt otag )
{
return ( extra1->Err.Value.szB == extra2->Err.Value.szB
? True : False );
+ case Err_BadAlign:
+ if (extra1->Err.BadAlign.size &&
+ extra2->Err.BadAlign.size) {
+ // cases where size should be non-zero or a multiple of alignment
+ return extra1->Err.BadAlign.size ==
+ extra2->Err.BadAlign.size
+ &&
+ extra1->Err.BadAlign.dealloc_align ==
+ extra2->Err.BadAlign.dealloc_align;
+ } else {
+ // non multiple of 2 alignment
+ return extra1->Err.BadAlign.dealloc_align ==
+ extra2->Err.BadAlign.dealloc_align;
+ }
+
+ case Err_BadSize:
+ // sized delete mismatch
+ return extra1->Err.BadSize.size ==
+ extra2->Err.BadSize.size;
+
+ case Err_SizeMismatch:
+ return extra1->Err.SizeMismatch.size ==
+ extra2->Err.SizeMismatch.size;
+
+ case Err_AlignMismatch:
+ // alignments both powers of 2 but different
+ return extra1->Err.AlignMismatch.alloc_align ==
+ extra2->Err.AlignMismatch.alloc_align
+ &&
+ extra1->Err.AlignMismatch.dealloc_align ==
+ extra2->Err.AlignMismatch.dealloc_align;
+
case Err_Leak:
VG_(tool_panic)("Shouldn't get Err_Leak in mc_eq_Error,\n"
"since it's handled with VG_(unique_error)()!");
// shown with VG_(unique_error)() so they 'extra' not copied. But
// we make it consistent with the others.
case Err_Leak:
+ case Err_BadAlign:
+ case Err_BadSize:
+ case Err_SizeMismatch:
+ case Err_AlignMismatch:
return sizeof(MC_Error);
// For value errors, get the ExeContext corresponding to the
// Unaddressable read/write attempt at given size
Addr1Supp, Addr2Supp, Addr4Supp, Addr8Supp, Addr16Supp, Addr32Supp,
- JumpSupp, // Jump to unaddressable target
- FreeSupp, // Invalid or mismatching free
- OverlapSupp, // Overlapping blocks in memcpy(), strcpy(), etc
- LeakSupp, // Something to be suppressed in a leak check.
- MempoolSupp, // Memory pool suppression.
- FishyValueSupp,// Fishy value suppression.
- ReallocSizeZeroSupp, // realloc size 0 suppression
+ JumpSupp, // Jump to unaddressable target
+ FreeSupp, // Invalid or mismatching free
+ OverlapSupp, // Overlapping blocks in memcpy(), strcpy(), etc
+ LeakSupp, // Something to be suppressed in a leak check.
+ MempoolSupp, // Memory pool suppression.
+ FishyValueSupp, // Fishy value suppression.
+ ReallocSizeZeroSupp, // realloc size 0 suppression
+ BadAlignSupp, // Alignment not 2
+ BadSizeSupp, // aligned alloc with size 0
+ SizeMismatch, // Sized deallocation did not match allocation size
+ AlignMismatch, // Aligned deallocation did not match aligned allocation
}
MC_SuppKind;
else if (VG_STREQ(name, "Value32")) skind = Value32Supp;
else if (VG_STREQ(name, "FishyValue")) skind = FishyValueSupp;
else if (VG_STREQ(name, "ReallocZero")) skind = ReallocSizeZeroSupp;
+ else if (VG_STREQ(name, "BadAlign")) skind = BadAlignSupp;
+ else if (VG_STREQ(name, "BadSize")) skind = BadSizeSupp;
+ else if (VG_STREQ(name, "SizeMismatch")) skind = SizeMismatch;
+ else if (VG_STREQ(name, "AlignMismatch")) skind = AlignMismatch;
else
return False;
supp_extra->argument_name);
}
- case ReallocSizeZeroSupp: {
-
+ case ReallocSizeZeroSupp:
return (ekind == Err_ReallocSizeZero);
- }
+
+ case BadAlignSupp:
+ return (ekind == Err_BadAlign);
+
+ case BadSizeSupp:
+ return (ekind == Err_BadSize);
+
+ case SizeMismatch:
+ return (ekind == Err_SizeMismatch);
+
+ case AlignMismatch:
+ return (ekind = Err_AlignMismatch);
default:
VG_(printf)("Error:\n"
case Err_Cond: return "Cond";
case Err_FishyValue: return "FishyValue";
case Err_ReallocSizeZero: return "ReallocZero";
+ case Err_BadAlign: return "BadAlign";
+ case Err_BadSize: return "BadSize";
+ case Err_SizeMismatch: return "SizeMismatch";
+ case Err_AlignMismatch: return "AlignMismatch";
case Err_Addr: {
MC_Error* extra = VG_(get_error_extra)(err);
switch ( extra->Err.Addr.szB ) {
Addr data; // Address of the actual block.
SizeT szB : (sizeof(SizeT)*8)-2; // Size requested; 30 or 62 bits.
MC_AllocKind allockind : 2; // Which operation did the allocation.
+ SizeT alignB; // Alignment (if requested) of the allocation
ExeContext* where[0];
/* Variable-length array. The size depends on MC_(clo_keep_stacktraces).
This array optionally stores the alloc and/or free stack trace. */
void* MC_(new_block) ( ThreadId tid,
Addr p, SizeT size, SizeT align,
+ SizeT orig_align,
Bool is_zeroed, MC_AllocKind kind,
VgHashTable *table);
void MC_(handle_free) ( ThreadId tid,
void* MC_(malloc) ( ThreadId tid, SizeT n );
void* MC_(__builtin_new) ( ThreadId tid, SizeT n );
-void* MC_(__builtin_new_aligned)( ThreadId tid, SizeT n, SizeT alignB );
+void* MC_(__builtin_new_aligned)( ThreadId tid, SizeT n, SizeT alignB, SizeT orig_alignB );
void* MC_(__builtin_vec_new) ( ThreadId tid, SizeT n );
-void* MC_(__builtin_vec_new_aligned) ( ThreadId tid, SizeT n, SizeT alignB );
-void* MC_(memalign) ( ThreadId tid, SizeT align, SizeT n );
+void* MC_(__builtin_vec_new_aligned) ( ThreadId tid, SizeT n, SizeT alignB, SizeT orig_alignB );
+void* MC_(memalign) ( ThreadId tid, SizeT align, SizeT orig_alignB, SizeT n);
void* MC_(calloc) ( ThreadId tid, SizeT nmemb, SizeT size1 );
void MC_(free) ( ThreadId tid, void* p );
void MC_(__builtin_delete) ( ThreadId tid, void* p );
void MC_(record_illegal_mempool_error) ( ThreadId tid, Addr a );
void MC_(record_freemismatch_error) ( ThreadId tid, MC_Chunk* mc );
void MC_(record_realloc_size_zero) ( ThreadId tid, Addr a );
+void MC_(record_bad_alignment) ( ThreadId tid, SizeT align, SizeT size, const HChar *msg);
+void MC_(record_bad_size) ( ThreadId tid, SizeT align, const HChar *function);
void MC_(record_overlap_error) ( ThreadId tid, const HChar* function,
Addr src, Addr dst, SizeT szB );
Bool MC_(record_fishy_value_error) ( ThreadId tid, const HChar* function,
const HChar *argument_name, SizeT value );
+void MC_(record_size_mismatch_error) ( ThreadId tid, MC_Chunk* mc, SizeT size, const HChar *function_names );
+void MC_(record_align_mismatch_error) ( ThreadId tid, MC_Chunk* mc, SizeT align, const HChar *function_names );
+
/* Leak kinds tokens to call VG_(parse_enum_set). */
extern const HChar* MC_(parse_leak_kinds_tokens);
{
Int i;
Addr bad_addr;
+ MC_Chunk* mc = NULL;
if (!VG_IS_TOOL_USERREQ('M','C',arg[0])
&& VG_USERREQ__MALLOCLIKE_BLOCK != arg[0]
UInt rzB = arg[3];
Bool is_zeroed = (Bool)arg[4];
- MC_(new_block) ( tid, p, sizeB, /*ignored*/0, is_zeroed,
+ MC_(new_block) ( tid, p, sizeB, /*ignored*/0U, 0U, is_zeroed,
MC_AllocCustom, MC_(malloc_list) );
if (rzB > 0) {
MC_(make_mem_noaccess) ( p - rzB, rzB);
return True;
}
+ case _VG_USERREQ__MEMCHECK_VERIFY_ALIGNMENT: {
+ struct AlignedAllocInfo *aligned_alloc_info = (struct AlignedAllocInfo *)arg[1];
+ tl_assert(aligned_alloc_info);
+
+ switch (aligned_alloc_info->alloc_kind) {
+ case AllocKindMemalign:
+ // other platforms just ensure it is a power of 2
+ // ignore Illumos only enforcing multiple of 4 (probably a bug)
+ if (aligned_alloc_info->orig_alignment == 0U ||
+ (aligned_alloc_info->orig_alignment & (aligned_alloc_info->orig_alignment - 1)) != 0) {
+ MC_(record_bad_alignment) ( tid, aligned_alloc_info->orig_alignment , 0U, " (should be power of 2)" );
+ }
+ // size zero not allowed on all platforms (e.g. Illumos)
+ if (aligned_alloc_info->size == 0) {
+ MC_(record_bad_size) ( tid, aligned_alloc_info->size, "memalign()" );
+ }
+ break;
+ case AllocKindPosixMemalign:
+ // must be power of 2
+ // alignment at least sizeof(size_t)
+ // size of 0 implementation defined
+ if (aligned_alloc_info->orig_alignment < sizeof(SizeT) ||
+ (aligned_alloc_info->orig_alignment & (aligned_alloc_info->orig_alignment - 1)) != 0) {
+ MC_(record_bad_alignment) ( tid, aligned_alloc_info->orig_alignment , 0U, " (should be non-zero, a power of 2 and a multiple of sizeof(void*))" );
+ }
+ if (aligned_alloc_info->size == 0) {
+ MC_(record_bad_size) ( tid, aligned_alloc_info->size, "posix_memalign()" );
+ }
+ break;
+ case AllocKindAlignedAlloc:
+ // must be power of 2
+ if ((aligned_alloc_info->orig_alignment & (aligned_alloc_info->orig_alignment - 1)) != 0) {
+ MC_(record_bad_alignment) ( tid, aligned_alloc_info->orig_alignment , 0U, " (should be a power of 2)" );
+ }
+ // size should be integral multiple of alignment
+ if (aligned_alloc_info->orig_alignment &&
+ aligned_alloc_info->size % aligned_alloc_info->orig_alignment != 0U) {
+ MC_(record_bad_alignment) ( tid, aligned_alloc_info->orig_alignment , aligned_alloc_info->size, " (size should be a multiple of alignment)" );
+ }
+ if (aligned_alloc_info->size == 0) {
+ MC_(record_bad_size) ( tid, aligned_alloc_info->size, "aligned_alloc()" );
+ }
+ break;
+ case AllocKindDeleteSized:
+ mc = VG_(HT_lookup) ( MC_(malloc_list), (UWord)aligned_alloc_info->mem );
+ if (mc && mc->szB != aligned_alloc_info->size) {
+ MC_(record_size_mismatch_error) ( tid, mc, aligned_alloc_info->size, "new/delete" );
+ }
+ break;
+ case AllocKindVecDeleteSized:
+ mc = VG_(HT_lookup) ( MC_(malloc_list), (UWord)aligned_alloc_info->mem );
+ if (mc && mc->szB != aligned_alloc_info->size) {
+ MC_(record_size_mismatch_error) ( tid, mc, aligned_alloc_info->size, "new[][/delete[]" );
+ }
+ break;
+ case AllocKindNewAligned:
+ if (aligned_alloc_info->orig_alignment == 0 ||
+ (aligned_alloc_info->orig_alignment & (aligned_alloc_info->orig_alignment - 1)) != 0) {
+ MC_(record_bad_alignment) ( tid, aligned_alloc_info->orig_alignment , 0U, " (should be non-zero and a power of 2)" );
+ }
+ break;
+ case AllocKindVecNewAligned:
+ if (aligned_alloc_info->orig_alignment == 0 ||
+ (aligned_alloc_info->orig_alignment & (aligned_alloc_info->orig_alignment - 1)) != 0) {
+ MC_(record_bad_alignment) ( tid, aligned_alloc_info->orig_alignment , 0U, " (should be non-zero and a power of 2)" );
+ }
+ break;
+ case AllocKindDeleteAligned:
+ if (aligned_alloc_info->orig_alignment == 0 ||
+ (aligned_alloc_info->orig_alignment & (aligned_alloc_info->orig_alignment - 1)) != 0) {
+ MC_(record_bad_alignment) ( tid, aligned_alloc_info->orig_alignment , 0U, " (should be non-zero and a power of 2)" );
+ }
+ mc = VG_(HT_lookup) ( MC_(malloc_list), (UWord)aligned_alloc_info->mem );
+ if (mc && aligned_alloc_info->orig_alignment != mc->alignB) {
+ MC_(record_align_mismatch_error) ( tid, mc, aligned_alloc_info->orig_alignment, "new/delete");
+ }
+ break;
+ case AllocKindVecDeleteAligned:
+ if (aligned_alloc_info->orig_alignment == 0 ||
+ (aligned_alloc_info->orig_alignment & (aligned_alloc_info->orig_alignment - 1)) != 0) {
+ MC_(record_bad_alignment) ( tid, aligned_alloc_info->orig_alignment , 0U, " (should be non-zero and a power of 2)" );
+ }
+ mc = VG_(HT_lookup) ( MC_(malloc_list), (UWord)aligned_alloc_info->mem );
+ if (mc && aligned_alloc_info->orig_alignment != mc->alignB) {
+ MC_(record_align_mismatch_error) ( tid, mc, aligned_alloc_info->orig_alignment, "new[]/delete[]");
+ }
+ break;
+ case AllocKindDeleteSizedAligned:
+ mc = VG_(HT_lookup) ( MC_(malloc_list), (UWord)aligned_alloc_info->mem );
+ if (mc && mc->szB != aligned_alloc_info->size) {
+ MC_(record_size_mismatch_error) ( tid, mc, aligned_alloc_info->size, "new/delete");
+ }
+ if (aligned_alloc_info->orig_alignment != mc->alignB) {
+ MC_(record_align_mismatch_error) ( tid, mc, aligned_alloc_info->orig_alignment, "new/delete");
+ }
+ if (aligned_alloc_info->orig_alignment == 0 ||
+ (aligned_alloc_info->orig_alignment & (aligned_alloc_info->orig_alignment - 1)) != 0) {
+ MC_(record_bad_alignment) ( tid, aligned_alloc_info->orig_alignment , 0U, " (should be non-zero and a power of 2)" );
+ }
+ break;
+ case AllocKindVecDeleteSizedAligned:
+ mc = VG_(HT_lookup) ( MC_(malloc_list), (UWord)aligned_alloc_info->mem );
+ if (mc && mc->szB != aligned_alloc_info->size) {
+ MC_(record_size_mismatch_error) ( tid, mc, aligned_alloc_info->size, "new[]/delete[]" );
+ }
+ if (aligned_alloc_info->orig_alignment != mc->alignB) {
+ MC_(record_align_mismatch_error) ( tid, mc, aligned_alloc_info->orig_alignment, "new[]/delete[]");
+ }
+ if (aligned_alloc_info->orig_alignment == 0 ||
+ (aligned_alloc_info->orig_alignment & (aligned_alloc_info->orig_alignment - 1)) != 0) {
+ MC_(record_bad_alignment) ( tid, aligned_alloc_info->orig_alignment , 0U, " (should be non-zero and a power of 2)" );
+ }
+ break;
+ default:
+ tl_assert (False);
+ }
+
+ return True;
+ }
+
case VG_USERREQ__CREATE_MEMPOOL: {
Addr pool = (Addr)arg[1];
UInt rzB = arg[2];
PoolAlloc *MC_(chunk_poolalloc) = NULL;
static
MC_Chunk* create_MC_Chunk ( ThreadId tid, Addr p, SizeT szB,
+ SizeT alignB,
MC_AllocKind kind);
static inline
void delete_MC_Chunk (MC_Chunk* mc);
return NULL;
}
+// @todo PJF !!!!!!!!!!
+// below alignB is the cleanup up value
+// would prefer the original value !!!!!!!!!
+
/* Allocate a shadow chunk, put it on the appropriate list.
If needed, release oldest blocks from freed list. */
static
MC_Chunk* create_MC_Chunk ( ThreadId tid, Addr p, SizeT szB,
+ SizeT alignB,
MC_AllocKind kind)
{
MC_Chunk* mc = VG_(allocEltPA)(MC_(chunk_poolalloc));
mc->data = p;
mc->szB = szB;
+ mc->alignB = alignB;
mc->allockind = kind;
switch ( MC_(n_where_pointers)() ) {
case 2: mc->where[1] = 0; // fallthrough to 1
/* Allocate memory and note change in memory available */
void* MC_(new_block) ( ThreadId tid,
Addr p, SizeT szB, SizeT alignB,
+ SizeT orig_alignB,
Bool is_zeroed, MC_AllocKind kind,
VgHashTable *table)
{
// Only update stats if allocation succeeded.
cmalloc_n_mallocs ++;
cmalloc_bs_mallocd += (ULong)szB;
- mc = create_MC_Chunk (tid, p, szB, kind);
+ mc = create_MC_Chunk (tid, p, szB, orig_alignB, kind);
VG_(HT_add_node)( table, mc );
if (is_zeroed)
if (MC_(record_fishy_value_error)(tid, "malloc", "size", n)) {
return NULL;
} else {
- return MC_(new_block) ( tid, 0, n, VG_(clo_alignment),
+ return MC_(new_block) ( tid, 0, n, VG_(clo_alignment), 0U,
/*is_zeroed*/False, MC_AllocMalloc, MC_(malloc_list));
}
}
if (MC_(record_fishy_value_error)(tid, "__builtin_new", "size", n)) {
return NULL;
} else {
- return MC_(new_block) ( tid, 0, n, VG_(clo_alignment),
+ return MC_(new_block) ( tid, 0, n, VG_(clo_alignment), 0U,
/*is_zeroed*/False, MC_AllocNew, MC_(malloc_list));
}
}
-void* MC_(__builtin_new_aligned) ( ThreadId tid, SizeT n, SizeT alignB )
+void* MC_(__builtin_new_aligned) ( ThreadId tid, SizeT n, SizeT alignB, SizeT orig_alignB )
{
if (MC_(record_fishy_value_error)(tid, "__builtin_new_aligned", "size", n)) {
return NULL;
} else {
- return MC_(new_block) ( tid, 0, n, alignB,
+ return MC_(new_block) ( tid, 0, n, alignB, orig_alignB,
/*is_zeroed*/False, MC_AllocNew, MC_(malloc_list));
}
}
if (MC_(record_fishy_value_error)(tid, "__builtin_vec_new", "size", n)) {
return NULL;
} else {
- return MC_(new_block) ( tid, 0, n, VG_(clo_alignment),
+ return MC_(new_block) ( tid, 0, n, VG_(clo_alignment), 0U,
/*is_zeroed*/False, MC_AllocNewVec, MC_(malloc_list));
}
}
-void* MC_(__builtin_vec_new_aligned) ( ThreadId tid, SizeT n, SizeT alignB )
+void* MC_(__builtin_vec_new_aligned) ( ThreadId tid, SizeT n, SizeT alignB, SizeT orig_alignB )
{
if (MC_(record_fishy_value_error)(tid, "__builtin_vec_new_aligned", "size", n)) {
return NULL;
} else {
- return MC_(new_block) ( tid, 0, n, alignB,
+ return MC_(new_block) ( tid, 0, n, alignB, orig_alignB,
/*is_zeroed*/False, MC_AllocNewVec, MC_(malloc_list));
}
}
-void* MC_(memalign) ( ThreadId tid, SizeT alignB, SizeT n )
+void* MC_(memalign) ( ThreadId tid, SizeT alignB, SizeT orig_alignB, SizeT n)
{
if (MC_(record_fishy_value_error)(tid, "memalign", "size", n)) {
return NULL;
- } else {
- return MC_(new_block) ( tid, 0, n, alignB,
- /*is_zeroed*/False, MC_AllocMalloc, MC_(malloc_list));
}
+
+ return MC_(new_block) ( tid, 0, n, alignB, orig_alignB,
+ /*is_zeroed*/False, MC_AllocMalloc, MC_(malloc_list));
}
void* MC_(calloc) ( ThreadId tid, SizeT nmemb, SizeT size1 )
MC_(record_fishy_value_error)(tid, "calloc", "size", size1)) {
return NULL;
} else {
- return MC_(new_block) ( tid, 0, nmemb*size1, VG_(clo_alignment),
+ return MC_(new_block) ( tid, 0, nmemb*size1, VG_(clo_alignment), 0U,
/*is_zeroed*/True, MC_AllocMalloc, MC_(malloc_list));
}
}
return NULL;
if (p_old == NULL) {
- return MC_(new_block) ( tid, 0, new_szB, VG_(clo_alignment),
+ return MC_(new_block) ( tid, 0, new_szB, VG_(clo_alignment), 0U,
/*is_zeroed*/False, MC_AllocMalloc, MC_(malloc_list));
}
queue). */
// Allocate a new chunk.
- new_mc = create_MC_Chunk( tid, a_new, new_szB, MC_AllocMalloc );
+ // Re-allocation does not conserve alignment.
+ new_mc = create_MC_Chunk( tid, a_new, new_szB, 0U, MC_AllocMalloc );
// Now insert the new mc (with a new 'data' field) into malloc_list.
VG_(HT_add_node)( MC_(malloc_list), new_mc );
MC_(record_illegal_mempool_error) ( tid, pool );
} else {
if (MP_DETAILED_SANITY_CHECKS) check_mempool_sane(mp);
- MC_(new_block)(tid, addr, szB, /*ignored*/0, mp->is_zeroed,
+ MC_(new_block)(tid, addr, szB, /*ignored*/0U, 0U, mp->is_zeroed,
MC_AllocCustom, mp->chunks);
if (mp->rzB > 0) {
// This is not needed if the user application has properly
/* This is just for memcheck's internal use - don't use it */
_VG_USERREQ__MEMCHECK_RECORD_OVERLAP_ERROR
- = VG_USERREQ_TOOL_BASE('M','C') + 256
+ = VG_USERREQ_TOOL_BASE('M','C') + 256,
+ _VG_USERREQ__MEMCHECK_VERIFY_ALIGNMENT
} Vg_MemCheckClientRequest;
filter_malloc_free \
filter_size_t \
filter_stanza \
- filter_stanza.awk
+ filter_stanza.awk \
+ filter_used_supp \
+ filter_stanza_and_size_t
noinst_HEADERS = leak.h
cxx17_aligned_new.stdout.exp \
sized_aligned_new_delete_args.stderr.exp \
sized_aligned_new_delete_args.vgtest \
- sized_aligned_new_delete_misaligned.stderr.exp \
- sized_aligned_new_delete_misaligned.vgtest \
+ sized_aligned_new_delete_misaligned1.stderr.exp \
+ sized_aligned_new_delete_misaligned1.vgtest \
+ sized_aligned_new_delete_misaligned2.stderr.exp \
+ sized_aligned_new_delete_misaligned2.vgtest \
+ sized_aligned_new_delete_misaligned3.stderr.exp \
+ sized_aligned_new_delete_misaligned3.vgtest \
+ sized_aligned_new_delete_misaligned1_xml.stderr.exp \
+ sized_aligned_new_delete_misaligned1_xml.vgtest \
+ sized_aligned_new_delete_misaligned2_xml.stderr.exp \
+ sized_aligned_new_delete_misaligned2_xml.vgtest \
+ sized_aligned_new_delete_misaligned3_xml.stderr.exp \
+ sized_aligned_new_delete_misaligned3_xml.vgtest \
+ sized_aligned_new_delete_misaligned1_supp.vgtest \
+ sized_aligned_new_delete_misaligned1_supp.supp \
+ sized_aligned_new_delete_misaligned1_supp.stderr.exp \
+ sized_aligned_new_delete_misaligned1_supp.stderr.exp_32 \
+ sized_aligned_new_delete_misaligned2_supp.vgtest \
+ sized_aligned_new_delete_misaligned2_supp.supp \
+ sized_aligned_new_delete_misaligned2_supp.stderr.exp \
+ sized_aligned_new_delete_misaligned2_supp.stderr.exp_32 \
+ sized_aligned_new_delete_misaligned3_supp.vgtest \
+ sized_aligned_new_delete_misaligned3_supp.supp \
+ sized_aligned_new_delete_misaligned3_supp.stderr.exp \
+ sized_aligned_new_delete_misaligned3_supp.stderr.exp_32 \
+ new_delete_mismatch_size.stderr.exp \
+ new_delete_mismatch_size.vgtest \
+ new_delete_mismatch_size_supp.stderr.exp \
+ new_delete_mismatch_size_supp.stderr.exp_32 \
+ new_delete_mismatch_size_supp.vgtest \
+ new_delete_mismatch_size_supp.supp \
deep-backtrace.vgtest deep-backtrace.stderr.exp \
demangle.stderr.exp demangle.vgtest \
big_debuginfo_symbol.stderr.exp big_debuginfo_symbol.vgtest \
mempool2.stderr.exp mempool2.vgtest \
metadata.stderr.exp metadata.stdout.exp metadata.vgtest \
mismatches.stderr.exp mismatches.vgtest \
+ mismatches.stderr.exp2 \
+ mismatches_xml.stderr.exp mismatches_xml.vgtest \
+ mismatches_xml.stderr.exp2 \
mmaptest.stderr.exp mmaptest.vgtest \
nanoleak_supp.stderr.exp nanoleak_supp.vgtest nanoleak.supp \
nanoleak_dynsupp.stderr.exp nanoleak_dynsupp.vgtest \
pointer-trace.vgtest \
pointer-trace.stderr.exp \
posix_memalign.stderr.exp posix_memalign.vgtest \
+ posix_memalign.stderr.exp-darwin \
+ posix_memalign_supp.stderr.exp posix_memalign_supp.vgtest \
+ posix_memalign_supp.supp \
+ posix_memalign_xml.stderr.exp posix_memalign_xml.vgtest \
post-syscall.stderr.exp post-syscall.vgtest \
reach_thread_register.stderr.exp reach_thread_register.vgtest \
reach_thread_register.stderr.exp-mips32 \
if HAVE_ALIGNED_CXX_ALLOC
check_PROGRAMS += cxx17_aligned_new sized_aligned_new_delete_args \
- sized_aligned_new_delete_misaligned
+ sized_aligned_new_delete_misaligned1 \
+ sized_aligned_new_delete_misaligned2 \
+ sized_aligned_new_delete_misaligned3
endif
if HAVE_PTHREAD_BARRIER
endif
if HAVE_FSIZED_DEALLOCATION
-check_PROGRAMS += sized_delete
+check_PROGRAMS += sized_delete new_delete_mismatch_size
endif
if HAVE_GNU_STPNCPY
cxx17_aligned_new_CXXFLAGS = -std=c++17 @FLAG_W_NO_MISMATCHED_NEW_DELETE@
sized_aligned_new_delete_args_SOURCES = sized_aligned_new_delete_args.cpp
sized_aligned_new_delete_args_CXXFLAGS = ${AM_CXXFLAGS} -std=c++17
-sized_aligned_new_delete_misaligned_SOURCES = sized_aligned_new_delete_misaligned.cpp
-sized_aligned_new_delete_misaligned_CXXFLAGS = ${AM_CXXFLAGS} -std=c++17
+sized_aligned_new_delete_misaligned1_SOURCES = sized_aligned_new_delete_misaligned1.cpp
+sized_aligned_new_delete_misaligned1_CXXFLAGS = ${AM_CXXFLAGS} -std=c++17
+sized_aligned_new_delete_misaligned2_SOURCES = sized_aligned_new_delete_misaligned2.cpp
+sized_aligned_new_delete_misaligned2_CXXFLAGS = ${AM_CXXFLAGS} -std=c++17
+sized_aligned_new_delete_misaligned3_SOURCES = sized_aligned_new_delete_misaligned3.cpp
+sized_aligned_new_delete_misaligned3_CXXFLAGS = ${AM_CXXFLAGS} -std=c++17
if COMPILER_IS_CLANG
cxx17_aligned_new_CXXFLAGS += -fsized-deallocation
sized_aligned_new_delete_args_CXXFLAGS += -fsized-deallocation
-sized_aligned_new_delete_misaligned_CXXFLAGS += -fsized-deallocation
+sized_aligned_new_delete_misaligned1_CXXFLAGS += -fsized-deallocation
+sized_aligned_new_delete_misaligned2_CXXFLAGS += -fsized-deallocation
+sized_aligned_new_delete_misaligned3_CXXFLAGS += -fsized-deallocation
endif
endif
mismatches_SOURCES = mismatches.cpp
mismatches_CXXFLAGS = $(AM_CXXFLAGS) @FLAG_W_NO_MISMATCHED_NEW_DELETE@
+if HAVE_FSIZED_DEALLOCATION
+new_delete_mismatch_size_SOURCES = new_delete_mismatch_size.cpp
+new_delete_mismatch_size_CXXFLAGS = $(AM_CXXFLAGS) @FLAG_FSIZED_DEALLOCATION@ -std=c++17
+endif
+
new_nothrow_SOURCES = new_nothrow.cpp
new_override_SOURCES = new_override.cpp
--- /dev/null
+#include <new>
+#include <cassert>
+#include <cstdlib>
+#include "tests/malloc.h"
+#include "../../config.h"
+
+int main()
+{
+ std::align_val_t misalign(static_cast<std::align_val_t>(63U));
+ std::align_val_t zeroalign(static_cast<std::align_val_t>(0U));
+ std::align_val_t onealign(static_cast<std::align_val_t>(1U));
+ std::align_val_t align(static_cast<std::align_val_t>(64U));
+ std::align_val_t alignx2(static_cast<std::align_val_t>(128U));
+ std::size_t size(32);
+ std::nothrow_t tag;
+ void *mem = nullptr;
+
+ for (int i = 0 ; i < 2 ; ++i)
+ {
+ // Err_BadAlign alignment only
+ mem = operator new(size, zeroalign, tag);
+ operator delete(mem, zeroalign, tag);
+ mem = nullptr;
+
+#if defined(HAVE_ALIGNED_ALLOC)
+ // Err_BadAlign size and alignment
+ mem = aligned_alloc(64U, 100U);
+ if (mem)
+ {
+ free(mem);
+ mem = nullptr;
+ }
+
+ // Err.BadSize
+ mem = aligned_alloc(64U, 0U);
+ if (mem)
+ {
+ free(mem);
+ mem = nullptr;
+ }
+#endif
+
+ // Err_SizeMismatch
+ mem = operator new(size, align);
+ operator delete(mem, size+1, align);
+ mem = nullptr;
+
+ // Err_AlignMismatch
+ mem = operator new[](size, align);
+ operator delete[](mem, size, alignx2);
+ mem = nullptr;
+ }
+}
#! /bin/sh
+# change 32 bit size_t (unsigned int) to 64 bit (unsigned long)
+# also change 32 bit -1 size_t to 64 bit
./filter_stderr "$@" |
-sed "s/unsigned int/unsigned long/"
+sed "s/unsigned int/unsigned long/;s/4294967295/18446744073709551615/"
--- /dev/null
+#! /bin/sh
+
+
+./filter_stanza "$@" |
+sed "s/unsigned int/unsigned long/;s/4294967295/18446744073709551615/"
+
--- /dev/null
+#! /bin/sh
+
+./filter_stderr "$@" |
+
+grep -v default\.supp |
+
+grep used_suppression
# Filter out @* version symbol function names
sed "s/<fn>\(.*\)\@\*<\/fn>/<fn>\1<\/fn>/" |
sed "s/of size [48]</of size N</" |
+sed "s/unsigned int, std::align_val_t/unsigned long, std::align_val_t/" |
+sed "s/operator new(unsigned int/operator new(unsigned long/" |
+sed "s/operator new\[\](unsigned int/operator new[](unsigned long/" |
+sed "s/operator delete(void\*, unsigned int/operator delete(void*, unsigned long/" |
+sed "s/operator delete\[\](void\*, unsigned int/operator delete[](void*, unsigned long/" |
+sed "s/4294967295/18446744073709551615/" |
+sed "s/malloc_zone_memalign/posix_memalign/" |
perl -p -e "s/(m_replacemalloc\/)?vg_replace_malloc.c/vg_replace_malloc.c/" |
perl -0 -p -e "s/<suppcounts>.*<\/suppcounts>/<suppcounts>...<\/suppcounts>/s" |
perl -p -e "s/<time>.*<\/time>/<time>...<\/time>/s" |
bug464476_rel_symlink.stdout.exp \
memalign.vgtest memalign.stderr.exp \
bug470713.vgtest bug470713.stderr.exp \
- bug470713.stdout.exp
+ bug470713.stdout.exp \
+ aligned_allocs_supp.vgtest \
+ aligned_allocs_supp.stderr.exp \
+ aligned_allocs_supp.supp \
+ memalign_supp.vgtest memalign_supp.stderr.exp \
+ memalign_supp.supp \
+ aligned_alloc.vgtest aligned_alloc.stderr.exp \
+ aligned_alloc_xml.vgtest aligned_alloc_xml.stderr.exp \
+ delete_sized_mismatch.vgtest \
+ delete_sized_mismatch.stderr.exp \
+ delete_sized_mismatch_xml.vgtest \
+ delete_sized_mismatch_xml.stderr.exp
check_PROGRAMS = \
statfs pdfork_pdkill getfsstat inlinfo inlinfo_nested.so extattr \
linkat scalar_fork scalar_thr_exit scalar_abort2 scalar_pdfork \
scalar_vfork stat file_locking_wait6 utimens access chmod_chown \
misc get_set_context utimes static_allocs fexecve errno_aligned_allocs \
- setproctitle sctp sctp2 bug464476 memalign bug470713
+ setproctitle sctp sctp2 bug464476 memalign bug470713 \
+ aligned_alloc delete_sized_mismatch
AM_CFLAGS += $(AM_FLAG_M3264_PRI)
AM_CXXFLAGS += $(AM_FLAG_M3264_PRI)
scalar_CFLAGS = ${AM_CFLAGS} -g
+aligned_alloc_CFLAGS = ${AM_CFLAGS} @FLAG_W_NO_NON_POWER_OF_TWO_ALIGNMENT@
+
+delete_sized_mismatch_CXXFLAGS = ${AM_CXXFLAGS} --std=c++14
+delete_sized_mismatch_SOURCES = delete_sized_mismatch.cpp
+
errno_aligned_allocs_CFLAGS = ${AM_CFLAGS} @FLAG_W_NO_NON_POWER_OF_TWO_ALIGNMENT@
extattr_CFLAGS = ${AM_CFLAGS} @FLAG_W_NO_UNUSED_BUT_SET_VARIABLE@
--- /dev/null
+#include <stdlib.h>
+#include <assert.h>
+#include <errno.h>
+
+int main(void)
+{
+ char* p = NULL;
+
+
+ // zero size
+ p = aligned_alloc(0, 8);
+ assert(p == NULL && errno == EINVAL);
+ errno = 0;
+ // non multiple of alignment passes on FreeBSD
+ p = aligned_alloc(8, 25);
+ assert(p && ((size_t)p % 8U == 0U));
+ free(p);
+ errno = 0;
+ // align not power of 2
+ p = aligned_alloc(40, 160);
+ assert(p == NULL && errno == EINVAL);
+ errno = 0;
+
+ // too big aligment
+ if (sizeof(size_t) == 8)
+ {
+ p = aligned_alloc(16, 1UL<<48);
+ }
+ else
+ {
+ p = NULL;
+ errno = ENOMEM;
+ }
+
+ assert(p == NULL && errno == ENOMEM);
+
+}
+
--- /dev/null
+Invalid size value: 25 alignment value: 8 (size should be a multiple of alignment)
+ at 0x........: aligned_alloc (vg_replace_malloc.c:...)
+ by 0x........: main (aligned_alloc.c:15)
+
+Invalid alignment value: 40 (should be a power of 2)
+ at 0x........: aligned_alloc (vg_replace_malloc.c:...)
+ by 0x........: main (aligned_alloc.c:20)
+
--- /dev/null
+prog: aligned_alloc
+vgopts: -q
--- /dev/null
+<?xml version="1.0"?>
+
+<valgrindoutput>
+
+<protocolversion>4</protocolversion>
+<protocoltool>memcheck</protocoltool>
+
+<preamble>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+</preamble>
+
+<pid>...</pid>
+<ppid>...</ppid>
+<tool>memcheck</tool>
+
+<args>
+ <vargv>...</vargv>
+ <argv>
+ <exe>./aligned_alloc</exe>
+ </argv>
+</args>
+
+<status>
+ <state>RUNNING</state>
+ <time>...</time>
+</status>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidSizeAndAlignment</kind>
+ <what>Invalid size value: 25 alignment value: 8 (size should be a multiple of alignment)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>aligned_alloc</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>aligned_alloc.c</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 40 (should be a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>aligned_alloc</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>aligned_alloc.c</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+
+<status>
+ <state>FINISHED</state>
+ <time>...</time>
+</status>
+
+<errorcounts>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+</errorcounts>
+
+<suppcounts>...</suppcounts>
+
+</valgrindoutput>
+
--- /dev/null
+prog: aligned_alloc
+vgopts: --xml=yes --xml-fd=2 --log-file=/dev/null
+stderr_filter: ../filter_xml
+
--- /dev/null
+
+
+HEAP SUMMARY:
+ in use at exit: 0 bytes in 0 blocks
+ total heap usage: 2 allocs, 2 frees, 25 bytes allocated
+
+For a detailed leak analysis, rerun with: --leak-check=full
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
+
+used_suppression: 2 aligned_alloc bad alignment aligned_allocs_supp.supp:9
+used_suppression: 1 aligned_alloc bad size aligned_allocs_supp.supp:16
+used_suppression: 3 posix_memalign bad alignment aligned_allocs_supp.supp:2
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
--- /dev/null
+{
+ posix_memalign bad alignment
+ Memcheck:BadAlign
+ fun:posix_memalign
+ fun:main
+}
+
+{
+ aligned_alloc bad alignment
+ Memcheck:BadAlign
+ fun:aligned_alloc
+ fun:main
+}
+
+{
+ aligned_alloc bad size
+ Memcheck:BadSize
+ fun:aligned_alloc
+ fun:main
+}
--- /dev/null
+prog: errno_aligned_allocs
+vgopts: --suppressions=aligned_allocs_supp.supp -s
+
+
cout << "sysctl succeeded when it should have failed\n";
}
}
+
--- /dev/null
+// mismatches in the parent directory has a size
+// mismatch, but only with GCC, hence a testcase that
+// explicitly has delete size mismatches
+
+#include <new>
+#include <cassert>
+#include "valgrind.h"
+
+int main()
+{
+ size_t size(32);
+ size_t badsize(33);
+
+ void *mem = nullptr;
+
+ mem = operator new(size);
+ operator delete(mem, badsize);
+
+ mem = operator new[](size);
+ operator delete[](mem, badsize);
+
+}
--- /dev/null
+Mismatched new/delete size value: 33
+ at 0x........: ...operator delete... (vg_replace_malloc.c:...)
+ by 0x........: main (delete_sized_mismatch.cpp:17)
+ Address 0x........ is 0 bytes inside a block of size 32 alloc'd
+ at 0x........: ...operator new... (vg_replace_malloc.c:...)
+ by 0x........: main (delete_sized_mismatch.cpp:16)
+
+Mismatched new[][/delete[] size value: 33
+ at 0x........: operator delete[](void*, unsigned long) (vg_replace_malloc.c:...)
+ by 0x........: main (delete_sized_mismatch.cpp:20)
+ Address 0x........ is 0 bytes inside a block of size 32 alloc'd
+ at 0x........: ...operator new[]... (vg_replace_malloc.c:...)
+ by 0x........: main (delete_sized_mismatch.cpp:19)
+
--- /dev/null
+prog: delete_sized_mismatch
+vgopts: -q
+stderr_filter: ../filter_size_t
--- /dev/null
+<?xml version="1.0"?>
+
+<valgrindoutput>
+
+<protocolversion>4</protocolversion>
+<protocoltool>memcheck</protocoltool>
+
+<preamble>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+</preamble>
+
+<pid>...</pid>
+<ppid>...</ppid>
+<tool>memcheck</tool>
+
+<args>
+ <vargv>...</vargv>
+ <argv>
+ <exe>./delete_sized_mismatch</exe>
+ </argv>
+</args>
+
+<status>
+ <state>RUNNING</state>
+ <time>...</time>
+</status>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedAllocateDeallocateSize</kind>
+ <what>Mismatched new/delete size value: 33</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*, unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>delete_sized_mismatch.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 32 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new(unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>delete_sized_mismatch.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedAllocateDeallocateSize</kind>
+ <what>Mismatched new[][/delete[] size value: 33</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete[](void*, unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>delete_sized_mismatch.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 32 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new[](unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>delete_sized_mismatch.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+
+<status>
+ <state>FINISHED</state>
+ <time>...</time>
+</status>
+
+<errorcounts>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+</errorcounts>
+
+<suppcounts>...</suppcounts>
+
+</valgrindoutput>
+
--- /dev/null
+prog: delete_sized_mismatch
+vgopts: --xml=yes --xml-fd=2 --log-file=/dev/null
+stderr_filter: ../filter_xml
// if ever we make this multi-platform, Solaris doesn't support this
// zero size
+ p = aligned_alloc(32, 0);
+ assert(p && ((size_t)p % 32U == 0U));
+ free(p);
+ // zero alignment
p = aligned_alloc(0, 8);
assert(p == NULL && errno == EINVAL);
errno = 0;
+Invalid alignment value: 0 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (errno_aligned_allocs.c:14)
+
+Invalid alignment value: 2 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (errno_aligned_allocs.c:17)
+
+Invalid alignment value: 40 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (errno_aligned_allocs.c:20)
+
+aligned_alloc() invalid size value: 0
+ at 0x........: aligned_alloc (vg_replace_malloc.c:...)
+ by 0x........: main (errno_aligned_allocs.c:60)
+
+Invalid size value: 25 alignment value: 8 (size should be a multiple of alignment)
+ at 0x........: aligned_alloc (vg_replace_malloc.c:...)
+ by 0x........: main (errno_aligned_allocs.c:68)
+
+Invalid alignment value: 40 (should be a power of 2)
+ at 0x........: aligned_alloc (vg_replace_malloc.c:...)
+ by 0x........: main (errno_aligned_allocs.c:73)
+
HEAP SUMMARY:
in use at exit: 0 bytes in 0 blocks
- total heap usage: 1 allocs, 1 frees, 25 bytes allocated
+ total heap usage: 2 allocs, 2 frees, 25 bytes allocated
For a detailed leak analysis, rerun with: --leak-check=full
For lists of detected and suppressed errors, rerun with: -s
-ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
+ERROR SUMMARY: 6 errors from 6 contexts (suppressed: 0 from 0)
+Invalid alignment value: 3 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:39)
+
+Invalid alignment value: 5 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:45)
+
+Invalid alignment value: 7 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:49)
+
+Invalid alignment value: 9 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:55)
+
+Invalid alignment value: 31 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:59)
+
+Invalid alignment value: 33 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:65)
+
+Invalid alignment value: 4095 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:69)
+
+Invalid alignment value: 4097 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:75)
+
--- /dev/null
+
+
+HEAP SUMMARY:
+ in use at exit: 20,976,192 bytes in 8 blocks
+ total heap usage: 12 allocs, 4 frees, 32,588,352 bytes allocated
+
+For a detailed leak analysis, rerun with: --leak-check=full
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
+
+used_suppression: 8 memalign bad alignment memalign_supp.supp:2
+
+ERROR SUMMARY: 0 errors from 0 contexts (suppressed: 0 from 0)
--- /dev/null
+{
+ memalign bad alignment
+ Memcheck:BadAlign
+ fun:memalign
+ fun:main
+}
--- /dev/null
+prog: memalign
+vgopts: -s --suppressions=memalign_supp.supp
EXTRA_DIST = \
aligned_alloc.vgtest aligned_alloc.stderr.exp \
+ aligned_alloc.stderr.exp-musl \
brk.stderr.exp brk.vgtest \
capget.vgtest capget.stderr.exp capget.stderr.exp2 capget.stderr.exp3 \
debuginfod-check.stderr.exp debuginfod-check.vgtest.in \
sys-preadv2_pwritev2.vgtest sys-preadv2_pwritev2.stderr.exp \
sys-execveat.vgtest sys-execveat.stderr.exp sys-execveat.stdout.exp \
enomem.vgtest enomem.stderr.exp enomem.stdout.exp \
- memalign.vgtest memalign.stderr.exp
+ memalign.vgtest memalign.stderr.exp \
+ memalign.stderr.exp-musl
check_PROGRAMS = \
aligned_alloc \
--- /dev/null
+Invalid size value: 25 alignment value: 8 (size should be a multiple of alignment)
+ at 0x........: aligned_alloc (vg_replace_malloc.c:...)
+ by 0x........: main (aligned_alloc.c:17)
+
+Invalid alignment value: 40 (should be a power of 2)
+ at 0x........: aligned_alloc (vg_replace_malloc.c:...)
+ by 0x........: main (aligned_alloc.c:22)
+
assert(p && (0 == (long)p % (4 * 1024 * 1024)));
p = memalign(16 * 1024 * 1024, 100);
assert(p && (0 == (long)p % (16 * 1024 * 1024)));
+
+ // size 0
+ p = memalign(256, 0);
+ assert(p && (0 == (long)p % 256));
#else
p = memalign(1024 * 1024, 4 * 1024 * 1024 + 1);
assert(p && (0 == (long)p % (1024 * 1024)));
assert(p && (0 == (long)p % (4 * 1024 * 1024)));
p = memalign(16 * 1024 * 1024, 100);
assert(p && (0 == (long)p % (16 * 1024 * 1024)));
+
+ // size 0
+ p = memalign(256, 0);
+ assert(p && (0 == (long)p % 256));
#endif
}
+Invalid alignment value: 0 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:47)
+
+Invalid alignment value: 3 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:53)
+
+Invalid alignment value: 5 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:57)
+
+Invalid alignment value: 7 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:60)
+
+Invalid alignment value: 9 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:64)
+
+Invalid alignment value: 31 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:67)
+
+Invalid alignment value: 33 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:71)
+
+Invalid alignment value: 4095 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:74)
+
+Invalid alignment value: 4097 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:78)
+
+memalign() invalid size value: 0
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:87)
+
--- /dev/null
+Invalid alignment value: 0 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:103)
+
+Invalid alignment value: 3 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:109)
+
+Invalid alignment value: 5 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:115)
+
+Invalid alignment value: 7 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:119)
+
+Invalid alignment value: 9 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:125)
+
+Invalid alignment value: 31 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:129)
+
+Invalid alignment value: 33 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:135)
+
+Invalid alignment value: 4095 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:139)
+
+Invalid alignment value: 4097 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:145)
+
+memalign() invalid size value: 0
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:155)
+
Conditional jump or move depends on uninitialised value(s)
- at 0x........: memalign (vg_replace_malloc.c:...)
- by 0x........: main (memalign_args.c:19)
-
-Conditional jump or move depends on uninitialised value(s)
- at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ at 0x........: malloc_zone_memalign (vg_replace_malloc.c:...)
+ ...
by 0x........: main (memalign_args.c:23)
Conditional jump or move depends on uninitialised value(s)
int main()
{
int* fpointer = (int*)malloc(10);
- delete fpointer; // should give warning
+ delete fpointer; // should give warning (or two if sized delete is used)
fpointer = (int*)malloc(10);
delete [] fpointer; // should give warning
fpointer = (int*)malloc(10);
free (fpointer); // should work!
int* nvec = new int[10];
- delete nvec; // should give a warning
+ delete nvec; // should give a warning (or two if sized delete is used)
nvec = new int[10];
free (nvec); // should give a warning
nvec = new int[10];
--- /dev/null
+Mismatched new/delete size value: 4
+ at 0x........: ...operator delete... (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:6)
+ Address 0x........ is 0 bytes inside a block of size 10 alloc'd
+ at 0x........: malloc (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:5)
+
+Mismatched free() / delete / delete []
+ at 0x........: ...operator delete... (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:6)
+ Address 0x........ is 0 bytes inside a block of size 10 alloc'd
+ at 0x........: malloc (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:5)
+
+Mismatched free() / delete / delete []
+ at 0x........: ...operator delete[]... (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:8)
+ Address 0x........ is 0 bytes inside a block of size 10 alloc'd
+ at 0x........: malloc (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:7)
+
+Mismatched new/delete size value: 4
+ at 0x........: ...operator delete... (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:13)
+ Address 0x........ is 0 bytes inside a block of size 40 alloc'd
+ at 0x........: ...operator new[]... (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:12)
+
+Mismatched free() / delete / delete []
+ at 0x........: ...operator delete... (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:13)
+ Address 0x........ is 0 bytes inside a block of size 40 alloc'd
+ at 0x........: ...operator new[]... (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:12)
+
+Mismatched free() / delete / delete []
+ at 0x........: free (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:15)
+ Address 0x........ is 0 bytes inside a block of size 40 alloc'd
+ at 0x........: ...operator new[]... (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:14)
+
+Mismatched free() / delete / delete []
+ at 0x........: ...operator delete[]... (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:20)
+ Address 0x........ is 0 bytes inside a block of size 4 alloc'd
+ at 0x........: ...operator new... (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:19)
+
+Mismatched free() / delete / delete []
+ at 0x........: free (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:22)
+ Address 0x........ is 0 bytes inside a block of size 4 alloc'd
+ at 0x........: ...operator new... (vg_replace_malloc.c:...)
+ by 0x........: main (mismatches.cpp:21)
+
--- /dev/null
+<?xml version="1.0"?>
+
+<valgrindoutput>
+
+<protocolversion>4</protocolversion>
+<protocoltool>memcheck</protocoltool>
+
+<preamble>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+</preamble>
+
+<pid>...</pid>
+<ppid>...</ppid>
+<tool>memcheck</tool>
+
+<args>
+ <vargv>...</vargv>
+ <argv>
+ <exe>./mismatches</exe>
+ </argv>
+</args>
+
+<status>
+ <state>RUNNING</state>
+ <time>...</time>
+</status>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedFree</kind>
+ <what>Mismatched free() / delete / delete []</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 10 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>malloc</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedFree</kind>
+ <what>Mismatched free() / delete / delete []</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete[](void*)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 10 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>malloc</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedFree</kind>
+ <what>Mismatched free() / delete / delete []</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 40 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new[](unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedFree</kind>
+ <what>Mismatched free() / delete / delete []</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>free</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 40 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new[](unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedFree</kind>
+ <what>Mismatched free() / delete / delete []</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete[](void*)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 4 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new(unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedFree</kind>
+ <what>Mismatched free() / delete / delete []</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>free</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 4 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new(unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+
+<status>
+ <state>FINISHED</state>
+ <time>...</time>
+</status>
+
+<errorcounts>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+</errorcounts>
+
+<suppcounts>...</suppcounts>
+
+</valgrindoutput>
+
--- /dev/null
+<?xml version="1.0"?>
+
+<valgrindoutput>
+
+<protocolversion>4</protocolversion>
+<protocoltool>memcheck</protocoltool>
+
+<preamble>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+</preamble>
+
+<pid>...</pid>
+<ppid>...</ppid>
+<tool>memcheck</tool>
+
+<args>
+ <vargv>...</vargv>
+ <argv>
+ <exe>./mismatches</exe>
+ </argv>
+</args>
+
+<status>
+ <state>RUNNING</state>
+ <time>...</time>
+</status>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedAllocateDeallocateSize</kind>
+ <what>Mismatched new/delete size value: 4</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*, unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 10 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>malloc</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedFree</kind>
+ <what>Mismatched free() / delete / delete []</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*, unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 10 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>malloc</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedFree</kind>
+ <what>Mismatched free() / delete / delete []</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete[](void*)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 10 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>malloc</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedAllocateDeallocateSize</kind>
+ <what>Mismatched new/delete size value: 4</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*, unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 40 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new[](unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedFree</kind>
+ <what>Mismatched free() / delete / delete []</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*, unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 40 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new[](unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedFree</kind>
+ <what>Mismatched free() / delete / delete []</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>free</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 40 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new[](unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedFree</kind>
+ <what>Mismatched free() / delete / delete []</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete[](void*)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 4 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new(unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedFree</kind>
+ <what>Mismatched free() / delete / delete []</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>free</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 4 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new(unsigned long)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>mismatches.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+
+<status>
+ <state>FINISHED</state>
+ <time>...</time>
+</status>
+
+<errorcounts>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+</errorcounts>
+
+<suppcounts>...</suppcounts>
+
+</valgrindoutput>
+
--- /dev/null
+prog: mismatches
+vgopts: --xml=yes --xml-fd=2 --log-file=/dev/null
+stderr_filter: filter_xml
--- /dev/null
+#include <cstdlib>
+#include <new>
+#include <iostream>
+#include <cassert>
+#include <cstdio>
+#include <unistd.h>
+#include <sys/types.h>
+#include <sys/wait.h>
+#include "valgrind.h"
+
+int main() {
+ std::align_val_t align(static_cast<std::align_val_t>(64U));
+ size_t size(32);
+ size_t badsize(33);
+ void *mem = nullptr;
+
+ mem = operator new(size);
+ operator delete(mem, badsize);
+ mem = nullptr;
+
+ mem = operator new[](size);
+ operator delete[](mem, badsize);
+
+ mem = operator new(size, align);
+ operator delete(mem, badsize, align);
+ mem = nullptr;
+
+ mem = operator new[](size, align);
+ operator delete[](mem, badsize, align);
+}
--- /dev/null
+Mismatched new/delete size value: 33
+ at 0x........: ...operator delete... (vg_replace_malloc.c:...)
+ by 0x........: main (new_delete_mismatch_size.cpp:18)
+ Address 0x........ is 0 bytes inside a block of size 32 alloc'd
+ at 0x........: ...operator new... (vg_replace_malloc.c:...)
+ by 0x........: main (new_delete_mismatch_size.cpp:17)
+
+Mismatched new[][/delete[] size value: 33
+ at 0x........: operator delete[](void*, unsigned long) (vg_replace_malloc.c:...)
+ by 0x........: main (new_delete_mismatch_size.cpp:22)
+ Address 0x........ is 0 bytes inside a block of size 32 alloc'd
+ at 0x........: ...operator new[]... (vg_replace_malloc.c:...)
+ by 0x........: main (new_delete_mismatch_size.cpp:21)
+
+Mismatched new/delete size value: 33
+ at 0x........: operator delete(void*, unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (new_delete_mismatch_size.cpp:25)
+ Address 0x........ is 0 bytes inside a block of size 32 alloc'd
+ at 0x........: operator new(unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (new_delete_mismatch_size.cpp:24)
+
+Mismatched new[]/delete[] size value: 33
+ at 0x........: operator delete[](void*, unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (new_delete_mismatch_size.cpp:29)
+ Address 0x........ is 0 bytes inside a block of size 32 alloc'd
+ at 0x........: operator new[](unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (new_delete_mismatch_size.cpp:28)
+
--- /dev/null
+prog: new_delete_mismatch_size
+prereq: test -e ./new_delete_mismatch_size.vgtest
+vgopts: --show-mismatched-frees=yes -q
+stderr_filter: filter_size_t
+
--- /dev/null
+used_suppression: 1 array aligned new sized aligned delete with size mismatch new_delete_mismatch_size_supp.supp:45
+used_suppression: 1 scalar aligned new sized aligned delete with size mismatch new_delete_mismatch_size_supp.supp:31
+used_suppression: 1 array new sized delete with size mismatch new_delete_mismatch_size_supp.supp:17
+used_suppression: 1 scalar new sized delete with size mismatch new_delete_mismatch_size_supp.supp:3
--- /dev/null
+used_suppression: 1 array aligned new sized aligned delete with size mismatch, 32 bit new_delete_mismatch_size_supp.supp:52
+used_suppression: 1 scalar aligned new sized aligned delete with size mismatch, 32 bit new_delete_mismatch_size_supp.supp:38
+used_suppression: 1 array new sized delete with size mismatch, 32 bit new_delete_mismatch_size_supp.supp:24
+used_suppression: 1 scalar new sized delete with size mismatch, 32 bit new_delete_mismatch_size_supp.supp:10
--- /dev/null
+
+{
+ scalar new sized delete with size mismatch
+ Memcheck:SizeMismatch
+ fun:_ZdlPvm
+ fun:main
+}
+
+{
+ scalar new sized delete with size mismatch, 32 bit
+ Memcheck:SizeMismatch
+ fun:_ZdlPvj
+ fun:main
+}
+
+{
+ array new sized delete with size mismatch
+ Memcheck:SizeMismatch
+ fun:_ZdaPvm
+ fun:main
+}
+
+{
+ array new sized delete with size mismatch, 32 bit
+ Memcheck:SizeMismatch
+ fun:_ZdaPvj
+ fun:main
+}
+
+{
+ scalar aligned new sized aligned delete with size mismatch
+ Memcheck:SizeMismatch
+ fun:_ZdlPvmSt11align_val_t
+ fun:main
+}
+
+{
+ scalar aligned new sized aligned delete with size mismatch, 32 bit
+ Memcheck:SizeMismatch
+ fun:_ZdlPvjSt11align_val_t
+ fun:main
+}
+
+{
+ array aligned new sized aligned delete with size mismatch
+ Memcheck:SizeMismatch
+ fun:_ZdaPvmSt11align_val_t
+ fun:main
+}
+
+{
+ array aligned new sized aligned delete with size mismatch, 32 bit
+ Memcheck:SizeMismatch
+ fun:_ZdaPvjSt11align_val_t
+ fun:main
+}
+
--- /dev/null
+prog: new_delete_mismatch_size
+prereq: test -e ./new_delete_mismatch_size.vgtest
+vgopts: --show-mismatched-frees=yes --suppressions=new_delete_mismatch_size_supp.supp -s
+stderr_filter: filter_used_supp
assert(NULL == p);
#else
assert(0 == res && p && 0 == (long)p % 64);
+ free(p);
#endif
- res = PM(&p, -1,100); assert(EINVAL == res);
- res = PM(&p, 0, 100); assert(EINVAL == res);
- res = PM(&p, 1, 100); assert(EINVAL == res);
- res = PM(&p, 2, 100); assert(EINVAL == res);
- res = PM(&p, 3, 100); assert(EINVAL == res);
+ res = PM(&p, -1,100);
+ assert(EINVAL == res);
+ res = PM(&p, 0, 100);
+ assert(EINVAL == res);
+ res = PM(&p, 1, 100);
+ assert(EINVAL == res);
+ res = PM(&p, 2, 100);
+ assert(EINVAL == res);
+ res = PM(&p, 3, 100);
+ assert(EINVAL == res);
res = PM(&p, sizeof(void*), 100);
- assert(0 == res && p && 0 == (long)p % sizeof(void*));
-
- res = PM(&p, 31, 100); assert(EINVAL == res);
- res = PM(&p, 32, 100); assert(0 == res && p && 0 == (long)p % 32);
- res = PM(&p, 33, 100); assert(EINVAL == res);
-
- res = PM(&p, 4095, 100); assert(EINVAL == res);
- res = PM(&p, 4096, 100); assert(0 == res && p && 0 == (long)p % 4096);
- res = PM(&p, 4097, 100); assert(EINVAL == res);
-
- res = PM(&p, 4 * 1024 * 1024, 100); assert(0 == res && p
- && 0 == (long)p % (4 * 1024 * 1024));
- res = PM(&p, 16 * 1024 * 1024, 100); assert(0 == res &&p
- && 0 == (long)p % (16 * 1024 * 1024));
+ assert(0 == res && p && 0 == (long)p % sizeof(void*));
+ free(p);
+ res = PM(&p, 31, 100);
+ assert(EINVAL == res);
+ res = PM(&p, 32, 100);
+ assert(0 == res && p && 0 == (long)p % 32);
+ free(p);
+ res = PM(&p, 33, 100);
+ assert(EINVAL == res);
+ res = PM(&p, 4095, 100);
+ assert(EINVAL == res);
+ res = PM(&p, 4096, 100);
+ assert(0 == res && p && 0 == (long)p % 4096);
+ free(p);
+ res = PM(&p, 4097, 100);
+ assert(EINVAL == res);
+ res = PM(&p, 4 * 1024 * 1024, 100);
+ assert(0 == res && p && 0 == (long)p % (4 * 1024 * 1024));
+ free(p);
+ res = PM(&p, 16 * 1024 * 1024, 100);
+ assert(0 == res && p && 0 == (long)p % (16 * 1024 * 1024));
+ free(p);
#endif
}
+posix_memalign() invalid size value: 0
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (posix_memalign.c:32)
+
+Invalid alignment value: 18446744073709551615 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (posix_memalign.c:40)
+
+Invalid alignment value: 0 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (posix_memalign.c:42)
+
+Invalid alignment value: 1 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (posix_memalign.c:44)
+
+Invalid alignment value: 2 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (posix_memalign.c:46)
+
+Invalid alignment value: 3 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (posix_memalign.c:48)
+
+Invalid alignment value: 31 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (posix_memalign.c:53)
+
+Invalid alignment value: 33 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (posix_memalign.c:58)
+
+Invalid alignment value: 4095 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (posix_memalign.c:60)
+
+Invalid alignment value: 4097 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: posix_memalign (vg_replace_malloc.c:...)
+ by 0x........: main (posix_memalign.c:65)
+
--- /dev/null
+posix_memalign() invalid size value: 0
+ at 0x........: malloc_zone_memalign (vg_replace_malloc.c:...)
+ by 0x........: posix_memalign (in /...libc...)
+ by 0x........: main (posix_memalign.c:32)
+
+Invalid alignment value: 18446744073709551615 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: malloc_zone_memalign (vg_replace_malloc.c:...)
+ by 0x........: posix_memalign (in /...libc...)
+ by 0x........: main (posix_memalign.c:40)
+
+Invalid alignment value: 0 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: malloc_zone_memalign (vg_replace_malloc.c:...)
+ by 0x........: posix_memalign (in /...libc...)
+ by 0x........: main (posix_memalign.c:42)
+
+Invalid alignment value: 1 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: malloc_zone_memalign (vg_replace_malloc.c:...)
+ by 0x........: posix_memalign (in /...libc...)
+ by 0x........: main (posix_memalign.c:44)
+
+Invalid alignment value: 2 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: malloc_zone_memalign (vg_replace_malloc.c:...)
+ by 0x........: posix_memalign (in /...libc...)
+ by 0x........: main (posix_memalign.c:46)
+
+Invalid alignment value: 3 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: malloc_zone_memalign (vg_replace_malloc.c:...)
+ by 0x........: posix_memalign (in /...libc...)
+ by 0x........: main (posix_memalign.c:48)
+
+Invalid alignment value: 31 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: malloc_zone_memalign (vg_replace_malloc.c:...)
+ by 0x........: posix_memalign (in /...libc...)
+ by 0x........: main (posix_memalign.c:53)
+
+Invalid alignment value: 33 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: malloc_zone_memalign (vg_replace_malloc.c:...)
+ by 0x........: posix_memalign (in /...libc...)
+ by 0x........: main (posix_memalign.c:58)
+
+Invalid alignment value: 4095 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: malloc_zone_memalign (vg_replace_malloc.c:...)
+ by 0x........: posix_memalign (in /...libc...)
+ by 0x........: main (posix_memalign.c:60)
+
+Invalid alignment value: 4097 (should be non-zero, a power of 2 and a multiple of sizeof(void*))
+ at 0x........: malloc_zone_memalign (vg_replace_malloc.c:...)
+ by 0x........: posix_memalign (in /...libc...)
+ by 0x........: main (posix_memalign.c:65)
+
prog: posix_memalign
vgopts: -q --freelist-vol=100000 --freelist-big-blocks=0
+stderr_filter: filter_size_t
--- /dev/null
+used_suppression: 9 posix_memalign align ./posix_memalign_supp.supp:10
+used_suppression: 1 posix_memalign size ./posix_memalign_supp.supp:3
--- /dev/null
+
+{
+ posix_memalign size
+ Memcheck:BadSize
+ fun:posix_memalign
+ fun:main
+}
+
+{
+ posix_memalign align
+ Memcheck:BadAlign
+ fun:posix_memalign
+ fun:main
+}
--- /dev/null
+prog: posix_memalign
+vgopts: -s --freelist-vol=100000 --freelist-big-blocks=0 --suppressions=./posix_memalign_supp.supp
+stderr_filter: filter_used_supp
--- /dev/null
+<?xml version="1.0"?>
+
+<valgrindoutput>
+
+<protocolversion>4</protocolversion>
+<protocoltool>memcheck</protocoltool>
+
+<preamble>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+</preamble>
+
+<pid>...</pid>
+<ppid>...</ppid>
+<tool>memcheck</tool>
+
+<args>
+ <vargv>...</vargv>
+ <argv>
+ <exe>./posix_memalign</exe>
+ </argv>
+</args>
+
+<status>
+ <state>RUNNING</state>
+ <time>...</time>
+</status>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidSize</kind>
+ <what>posix_memalign() invalid size value: 0</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>posix_memalign</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>posix_memalign.c</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 18446744073709551615 (should be non-zero, a power of 2 and a multiple of sizeof(void*))</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>posix_memalign</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>posix_memalign.c</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 0 (should be non-zero, a power of 2 and a multiple of sizeof(void*))</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>posix_memalign</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>posix_memalign.c</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 1 (should be non-zero, a power of 2 and a multiple of sizeof(void*))</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>posix_memalign</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>posix_memalign.c</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 2 (should be non-zero, a power of 2 and a multiple of sizeof(void*))</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>posix_memalign</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>posix_memalign.c</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 3 (should be non-zero, a power of 2 and a multiple of sizeof(void*))</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>posix_memalign</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>posix_memalign.c</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 31 (should be non-zero, a power of 2 and a multiple of sizeof(void*))</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>posix_memalign</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>posix_memalign.c</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 33 (should be non-zero, a power of 2 and a multiple of sizeof(void*))</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>posix_memalign</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>posix_memalign.c</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 4095 (should be non-zero, a power of 2 and a multiple of sizeof(void*))</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>posix_memalign</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>posix_memalign.c</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 4097 (should be non-zero, a power of 2 and a multiple of sizeof(void*))</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>posix_memalign</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>posix_memalign.c</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+
+<status>
+ <state>FINISHED</state>
+ <time>...</time>
+</status>
+
+<errorcounts>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+</errorcounts>
+
+<suppcounts>...</suppcounts>
+
+</valgrindoutput>
+
--- /dev/null
+prog: posix_memalign
+vgopts: --freelist-vol=100000 --freelist-big-blocks=0 --xml=yes --xml-fd=2 --log-file=/dev/null
+stderr_filter: filter_xml
prog: sized_aligned_new_delete_args
prereq: test -e ./sized_aligned_new_delete_args
vgopts: -q
-stderr_filter: filter_stanza
+stderr_filter: filter_stanza_and_size_t
+++ /dev/null
-new/new[] aligned failed and should throw an exception, but Valgrind
- cannot throw exceptions and so is aborting instead. Sorry.
- ...
- by 0x........: operator new(unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
- by 0x........: main (sized_aligned_new_delete_misaligned.cpp:69)
-new/new[] aligned failed and should throw an exception, but Valgrind
- cannot throw exceptions and so is aborting instead. Sorry.
- ...
- by 0x........: operator new[](unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
- by 0x........: main (sized_aligned_new_delete_misaligned.cpp:81)
+++ /dev/null
-prog: sized_aligned_new_delete_misaligned
-prereq: test -e ./sized_aligned_new_delete_misaligned
-vgopts: -q
-stderr_filter: filter_size_t
-#include <cstdlib>
#include <new>
-#include <iostream>
#include <cassert>
-#include <cstdio>
-#include <unistd.h>
-#include <sys/types.h>
-#include <sys/wait.h>
+#include <cstdlib>
#include "valgrind.h"
int main() {
std::align_val_t zeroalign(static_cast<std::align_val_t>(0U));
std::align_val_t onealign(static_cast<std::align_val_t>(1U));
std::align_val_t align(static_cast<std::align_val_t>(64U));
- size_t size(32);
+ std::size_t size(32);
std::nothrow_t tag;
void *mem = nullptr;
mem = operator new[](size, align);
operator delete[](mem, size, misalign);
- // the last two throw exceptions in C++
- int pid;
- int status;
- pid = fork();
- if (pid == -1) {
- perror("fork");
- exit(1);
- }
- if (pid == 0) {
- // child
- mem = operator new(size, misalign);
- // should throw
- assert(false);
- }
- waitpid(pid, &status, 0);
- pid = fork();
- if (pid == -1) {
- perror("fork");
- exit(1);
- }
- if (pid == 0) {
- // child
- mem = operator new[](size, misalign);
- // should throw
- assert(false);
- }
- waitpid(pid, &status, 0);
+ // initially this test had two throwing
+ // versions called from fork()s
+ // but that doesn't mix well with xml
+ // so they have split out int vrsions 2 and 3
}
--- /dev/null
+Invalid alignment value: 0 (should be non-zero and a power of 2)
+ at 0x........: operator new(unsigned long, std::align_val_t, std::nothrow_t const&) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:17)
+
+Invalid alignment value: 0 (should be non-zero and a power of 2)
+ at 0x........: operator delete(void*, std::align_val_t, std::nothrow_t const&) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:21)
+
+Invalid alignment value: 63 (should be non-zero and a power of 2)
+ at 0x........: operator delete(void*, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:30)
+
+Mismatched new/delete alignment alloc value: 64 dealloc value: 63
+ at 0x........: operator delete(void*, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:30)
+ Address 0x........ is 0 bytes inside a block of size 32 alloc'd
+ at 0x........: operator new(unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:29)
+
+Invalid alignment value: 63 (should be non-zero and a power of 2)
+ at 0x........: operator delete[](void*, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:34)
+
+Mismatched new[]/delete[] alignment alloc value: 64 dealloc value: 63
+ at 0x........: operator delete[](void*, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:34)
+ Address 0x........ is 0 bytes inside a block of size 32 alloc'd
+ at 0x........: operator new[](unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:33)
+
+Invalid alignment value: 63 (should be non-zero and a power of 2)
+ at 0x........: operator new(unsigned long, std::align_val_t, std::nothrow_t const&) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:39)
+
+Invalid alignment value: 63 (should be non-zero and a power of 2)
+ at 0x........: operator delete(void*, std::align_val_t, std::nothrow_t const&) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:40)
+
+Invalid alignment value: 63 (should be non-zero and a power of 2)
+ at 0x........: operator new[](unsigned long, std::align_val_t, std::nothrow_t const&) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:43)
+
+Invalid alignment value: 63 (should be non-zero and a power of 2)
+ at 0x........: operator delete[](void*, std::align_val_t, std::nothrow_t const&) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:44)
+
+Mismatched new/delete alignment alloc value: 64 dealloc value: 63
+ at 0x........: operator delete(void*, unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:48)
+ Address 0x........ is 0 bytes inside a block of size 32 alloc'd
+ at 0x........: operator new(unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:47)
+
+Invalid alignment value: 63 (should be non-zero and a power of 2)
+ at 0x........: operator delete(void*, unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:48)
+
+Mismatched new[]/delete[] alignment alloc value: 64 dealloc value: 63
+ at 0x........: operator delete[](void*, unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:52)
+ Address 0x........ is 0 bytes inside a block of size 32 alloc'd
+ at 0x........: operator new[](unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:51)
+
+Invalid alignment value: 63 (should be non-zero and a power of 2)
+ at 0x........: operator delete[](void*, unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned1.cpp:52)
+
--- /dev/null
+prog: sized_aligned_new_delete_misaligned1
+prereq: test -e ./sized_aligned_new_delete_misaligned1
+vgopts: -q
+stderr_filter: filter_size_t
--- /dev/null
+used_suppression: 2 array new/delete aligned alignment mismatch sized_aligned_new_delete_misaligned1_supp.supp:93
+used_suppression: 2 scalar new/delete aligned alignment mismatch sized_aligned_new_delete_misaligned1_supp.supp:79
+used_suppression: 1 array delete nothrow aligned bad alignment sized_aligned_new_delete_misaligned1_supp.supp:72
+used_suppression: 1 array new nothrow aligned bad alignment sized_aligned_new_delete_misaligned1_supp.supp:58
+used_suppression: 2 scalar delete nothow bad alignment sized_aligned_new_delete_misaligned1_supp.supp:51
+used_suppression: 2 scalar new nothrow aligned nothrow bad alignment sized_aligned_new_delete_misaligned1_supp.supp:2
+used_suppression: 2 array new/delete aligned alignment mismatch sized_aligned_new_delete_misaligned1_supp.supp:44
+used_suppression: 2 scalar new/delete aligned alignment mismatch sized_aligned_new_delete_misaligned1_supp.supp:23
--- /dev/null
+used_suppression: 2 array new/delete aligned alignment mismatch, 32 bit sized_aligned_new_delete_misaligned1_supp.supp:100
+used_suppression: 2 scalar new/delete aligned alignment mismatch, 32 bit sized_aligned_new_delete_misaligned1_supp.supp:86
+used_suppression: 1 array delete nothrow aligned bad alignment sized_aligned_new_delete_misaligned1_supp.supp:72
+used_suppression: 1 array new nothrow aligned bad alignment, 32 bit sized_aligned_new_delete_misaligned1_supp.supp:65
+used_suppression: 2 scalar delete nothow bad alignment sized_aligned_new_delete_misaligned1_supp.supp:51
+used_suppression: 2 scalar new nothrow aligned nothrow bad alignment, 32 bit sized_aligned_new_delete_misaligned1_supp.supp:9
+used_suppression: 2 array new/delete aligned alignment mismatch sized_aligned_new_delete_misaligned1_supp.supp:44
+used_suppression: 2 scalar new/delete aligned alignment mismatch sized_aligned_new_delete_misaligned1_supp.supp:23
--- /dev/null
+{
+ scalar new nothrow aligned nothrow bad alignment
+ Memcheck:BadAlign
+ fun:_ZnwmSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ scalar new nothrow aligned nothrow bad alignment, 32 bit
+ Memcheck:BadAlign
+ fun:_ZnwjSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ scalar delete aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZdlPvSt11align_val_t
+ fun:main
+}
+
+{
+ scalar new/delete aligned alignment mismatch
+ Memcheck:AlignMismatch
+ fun:_ZdlPvSt11align_val_t
+ fun:main
+}
+
+{
+ array delete bad alignment
+ Memcheck:BadAlign
+ fun:_ZdaPvSt11align_val_t
+ fun:main
+}
+
+{
+ array delete bad alignment, 32 bit
+ Memcheck:BadAlign
+ fun:_ZdaPvjSt11align_val_t
+ fun:main
+}
+
+{
+ array new/delete aligned alignment mismatch
+ Memcheck:AlignMismatch
+ fun:_ZdaPvSt11align_val_t
+ fun:main
+}
+
+{
+ scalar delete nothow bad alignment
+ Memcheck:BadAlign
+ fun:_ZdlPvSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ array new nothrow aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZnamSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ array new nothrow aligned bad alignment, 32 bit
+ Memcheck:BadAlign
+ fun:_ZnajSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ array delete nothrow aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZdaPvSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ scalar new/delete aligned alignment mismatch
+ Memcheck:AlignMismatch
+ fun:_ZdlPvmSt11align_val_t
+ fun:main
+}
+
+{
+ scalar new/delete aligned alignment mismatch, 32 bit
+ Memcheck:AlignMismatch
+ fun:_ZdlPvjSt11align_val_t
+ fun:main
+}
+
+{
+ array new/delete aligned alignment mismatch
+ Memcheck:AlignMismatch
+ fun:_ZdaPvmSt11align_val_t
+ fun:main
+}
+
+{
+ array new/delete aligned alignment mismatch, 32 bit
+ Memcheck:AlignMismatch
+ fun:_ZdaPvjSt11align_val_t
+ fun:main
+}
+
+{
+ scalar new aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZnwmSt11align_val_t
+ fun:main
+}
+
+{
+ scalar new aligned bad alignment, 32 bit
+ Memcheck:BadAlign
+ fun:_ZnwjSt11align_val_t
+ fun:main
+}
+
+{
+ array new aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZnamSt11align_val_t
+ fun:main
+}
+
+{
+ array new aligned bad alignment, 32bit
+ Memcheck:BadAlign
+ fun:_ZnajSt11align_val_t
+ fun:main
+}
+
--- /dev/null
+prog: sized_aligned_new_delete_misaligned1
+prereq: test -e ./sized_aligned_new_delete_misaligned1
+vgopts: -s --suppressions=sized_aligned_new_delete_misaligned1_supp.supp
+stderr_filter: filter_used_supp
--- /dev/null
+<?xml version="1.0"?>
+
+<valgrindoutput>
+
+<protocolversion>4</protocolversion>
+<protocoltool>memcheck</protocoltool>
+
+<preamble>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+</preamble>
+
+<pid>...</pid>
+<ppid>...</ppid>
+<tool>memcheck</tool>
+
+<args>
+ <vargv>...</vargv>
+ <argv>
+ <exe>./sized_aligned_new_delete_misaligned1</exe>
+ </argv>
+</args>
+
+<status>
+ <state>RUNNING</state>
+ <time>...</time>
+</status>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 0 (should be non-zero and a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new(unsigned long, std::align_val_t, std::nothrow_t const&)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 0 (should be non-zero and a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*, std::align_val_t, std::nothrow_t const&)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 63 (should be non-zero and a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedAllocateDeallocateAlignment</kind>
+ <what>Mismatched new/delete size alloc value: 64 dealloc value 63</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 32 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new(unsigned long, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 63 (should be non-zero and a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete[](void*, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedAllocateDeallocateAlignment</kind>
+ <what>Mismatched new[]/delete[] size alloc value: 64 dealloc value 63</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete[](void*, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 32 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new[](unsigned long, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 63 (should be non-zero and a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new(unsigned long, std::align_val_t, std::nothrow_t const&)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 63 (should be non-zero and a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*, std::align_val_t, std::nothrow_t const&)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 63 (should be non-zero and a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new[](unsigned long, std::align_val_t, std::nothrow_t const&)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 63 (should be non-zero and a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete[](void*, std::align_val_t, std::nothrow_t const&)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedAllocateDeallocateAlignment</kind>
+ <what>Mismatched new/delete size alloc value: 64 dealloc value 63</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*, unsigned long, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 32 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new(unsigned long, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 63 (should be non-zero and a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete(void*, unsigned long, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>MismatchedAllocateDeallocateAlignment</kind>
+ <what>Mismatched new[]/delete[] size alloc value: 64 dealloc value 63</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete[](void*, unsigned long, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+ <auxwhat>Address 0x........ is 0 bytes inside a block of size 32 alloc'd</auxwhat>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new[](unsigned long, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 63 (should be non-zero and a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator delete[](void*, unsigned long, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned1.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+
+<status>
+ <state>FINISHED</state>
+ <time>...</time>
+</status>
+
+<errorcounts>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+</errorcounts>
+
+<suppcounts>...</suppcounts>
+
+</valgrindoutput>
+
--- /dev/null
+prog: sized_aligned_new_delete_misaligned1
+prereq: test -e ./sized_aligned_new_delete_misaligned1
+vgopts: --xml=yes --xml-fd=2 --log-file=/dev/null
+stderr_filter: filter_xml
--- /dev/null
+#include <new>
+#include <cassert>
+
+int main() {
+ std::align_val_t misalign(static_cast<std::align_val_t>(63U));
+ std::size_t size(32);
+ void *mem = operator new(size, misalign);
+ // should throw
+ assert(false);
+}
--- /dev/null
+Invalid alignment value: 63 (should be non-zero and a power of 2)
+ at 0x........: operator new(unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned2.cpp:7)
+
+new/new[] aligned failed and should throw an exception, but Valgrind
+ cannot throw exceptions and so is aborting instead. Sorry.
+ ...
+ by 0x........: operator new(unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned2.cpp:7)
--- /dev/null
+prog: sized_aligned_new_delete_misaligned2
+prereq: test -e ./sized_aligned_new_delete_misaligned2
+vgopts: -q
+stderr_filter: filter_size_t
--- /dev/null
+used_suppression: 1 scalar new aligned bad alignment sized_aligned_new_delete_misaligned2_supp.supp:107
--- /dev/null
+used_suppression: 1 scalar new aligned bad alignment, 32 bit sized_aligned_new_delete_misaligned2_supp.supp:114
--- /dev/null
+{
+ scalar new nothrow aligned nothrow bad alignment
+ Memcheck:BadAlign
+ fun:_ZnwmSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ scalar new nothrow aligned nothrow bad alignment, 32 bit
+ Memcheck:BadAlign
+ fun:_ZnwjSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ scalar delete aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZdlPvSt11align_val_t
+ fun:main
+}
+
+{
+ scalar new/delete aligned alignment mismatch
+ Memcheck:AlignMismatch
+ fun:_ZdlPvSt11align_val_t
+ fun:main
+}
+
+{
+ array delete bad alignment
+ Memcheck:BadAlign
+ fun:_ZdaPvSt11align_val_t
+ fun:main
+}
+
+{
+ array delete bad alignment, 32 bit
+ Memcheck:BadAlign
+ fun:_ZdaPvjSt11align_val_t
+ fun:main
+}
+
+{
+ array new/delete aligned alignment mismatch
+ Memcheck:AlignMismatch
+ fun:_ZdaPvSt11align_val_t
+ fun:main
+}
+
+{
+ scalar delete nothow bad alignment
+ Memcheck:BadAlign
+ fun:_ZdlPvSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ array new nothrow aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZnamSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ array new nothrow aligned bad alignment, 32 bit
+ Memcheck:BadAlign
+ fun:_ZnajSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ array delete nothrow aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZdaPvSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ scalar new/delete aligned alignment mismatch
+ Memcheck:AlignMismatch
+ fun:_ZdlPvmSt11align_val_t
+ fun:main
+}
+
+{
+ scalar new/delete aligned alignment mismatch, 32 bit
+ Memcheck:AlignMismatch
+ fun:_ZdlPvjSt11align_val_t
+ fun:main
+}
+
+{
+ array new/delete aligned alignment mismatch
+ Memcheck:AlignMismatch
+ fun:_ZdaPvmSt11align_val_t
+ fun:main
+}
+
+{
+ array new/delete aligned alignment mismatch, 32 bit
+ Memcheck:AlignMismatch
+ fun:_ZdaPvjSt11align_val_t
+ fun:main
+}
+
+{
+ scalar new aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZnwmSt11align_val_t
+ fun:main
+}
+
+{
+ scalar new aligned bad alignment, 32 bit
+ Memcheck:BadAlign
+ fun:_ZnwjSt11align_val_t
+ fun:main
+}
+
+{
+ array new aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZnamSt11align_val_t
+ fun:main
+}
+
+{
+ array new aligned bad alignment, 32bit
+ Memcheck:BadAlign
+ fun:_ZnajSt11align_val_t
+ fun:main
+}
+
--- /dev/null
+prog: sized_aligned_new_delete_misaligned2
+prereq: test -e ./sized_aligned_new_delete_misaligned2
+vgopts: -s --suppressions=sized_aligned_new_delete_misaligned2_supp.supp
+stderr_filter: filter_used_supp
--- /dev/null
+<?xml version="1.0"?>
+
+<valgrindoutput>
+
+<protocolversion>4</protocolversion>
+<protocoltool>memcheck</protocoltool>
+
+<preamble>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+</preamble>
+
+<pid>...</pid>
+<ppid>...</ppid>
+<tool>memcheck</tool>
+
+<args>
+ <vargv>...</vargv>
+ <argv>
+ <exe>./sized_aligned_new_delete_misaligned2</exe>
+ </argv>
+</args>
+
+<status>
+ <state>RUNNING</state>
+ <time>...</time>
+</status>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 63 (should be non-zero and a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new(unsigned long, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned2.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<clientmsg>
+ <tid>...</tid>
+ <text>new/new[] aligned failed and should throw an exception, but Valgrind
+ </text>
+</clientmsg>
+<clientmsg>
+ <tid>...</tid>
+ <text> cannot throw exceptions and so is aborting instead. Sorry.
+ </text>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>VALGRIND_PRINTF_BACKTRACE</fn>
+ <dir>...</dir>
+ <file>valgrind.h</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new(unsigned long, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned2.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</clientmsg>
+
+<status>
+ <state>FINISHED</state>
+ <time>...</time>
+</status>
+
+<errorcounts>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+</errorcounts>
+
+<suppcounts>...</suppcounts>
+
+</valgrindoutput>
+
--- /dev/null
+prog: sized_aligned_new_delete_misaligned2
+prereq: test -e ./sized_aligned_new_delete_misaligned2
+vgopts: --xml=yes --xml-fd=2 --log-file=/dev/null
+stderr_filter: filter_xml
--- /dev/null
+
+#include <new>
+#include <cassert>
+
+int main() {
+ std::align_val_t misalign(static_cast<std::align_val_t>(63U));
+ std::size_t size(32);
+ void *mem = operator new[](size, misalign);
+ // should throw
+ assert(false);
+}
--- /dev/null
+Invalid alignment value: 63 (should be non-zero and a power of 2)
+ at 0x........: operator new[](unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned3.cpp:8)
+
+new/new[] aligned failed and should throw an exception, but Valgrind
+ cannot throw exceptions and so is aborting instead. Sorry.
+ ...
+ by 0x........: operator new[](unsigned long, std::align_val_t) (vg_replace_malloc.c:...)
+ by 0x........: main (sized_aligned_new_delete_misaligned3.cpp:8)
--- /dev/null
+prog: sized_aligned_new_delete_misaligned3
+prereq: test -e ./sized_aligned_new_delete_misaligned3
+vgopts: -q
+stderr_filter: filter_size_t
--- /dev/null
+used_suppression: 1 array new aligned bad alignment sized_aligned_new_delete_misaligned3_supp.supp:121
--- /dev/null
+used_suppression: 1 array new aligned bad alignment, 32bit sized_aligned_new_delete_misaligned3_supp.supp:128
--- /dev/null
+{
+ scalar new nothrow aligned nothrow bad alignment
+ Memcheck:BadAlign
+ fun:_ZnwmSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ scalar new nothrow aligned nothrow bad alignment, 32 bit
+ Memcheck:BadAlign
+ fun:_ZnwjSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ scalar delete aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZdlPvSt11align_val_t
+ fun:main
+}
+
+{
+ scalar new/delete aligned alignment mismatch
+ Memcheck:AlignMismatch
+ fun:_ZdlPvSt11align_val_t
+ fun:main
+}
+
+{
+ array delete bad alignment
+ Memcheck:BadAlign
+ fun:_ZdaPvSt11align_val_t
+ fun:main
+}
+
+{
+ array delete bad alignment, 32 bit
+ Memcheck:BadAlign
+ fun:_ZdaPvjSt11align_val_t
+ fun:main
+}
+
+{
+ array new/delete aligned alignment mismatch
+ Memcheck:AlignMismatch
+ fun:_ZdaPvSt11align_val_t
+ fun:main
+}
+
+{
+ scalar delete nothow bad alignment
+ Memcheck:BadAlign
+ fun:_ZdlPvSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ array new nothrow aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZnamSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ array new nothrow aligned bad alignment, 32 bit
+ Memcheck:BadAlign
+ fun:_ZnajSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ array delete nothrow aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZdaPvSt11align_val_tRKSt9nothrow_t
+ fun:main
+}
+
+{
+ scalar new/delete aligned alignment mismatch
+ Memcheck:AlignMismatch
+ fun:_ZdlPvmSt11align_val_t
+ fun:main
+}
+
+{
+ scalar new/delete aligned alignment mismatch, 32 bit
+ Memcheck:AlignMismatch
+ fun:_ZdlPvjSt11align_val_t
+ fun:main
+}
+
+{
+ array new/delete aligned alignment mismatch
+ Memcheck:AlignMismatch
+ fun:_ZdaPvmSt11align_val_t
+ fun:main
+}
+
+{
+ array new/delete aligned alignment mismatch, 32 bit
+ Memcheck:AlignMismatch
+ fun:_ZdaPvjSt11align_val_t
+ fun:main
+}
+
+{
+ scalar new aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZnwmSt11align_val_t
+ fun:main
+}
+
+{
+ scalar new aligned bad alignment, 32 bit
+ Memcheck:BadAlign
+ fun:_ZnwjSt11align_val_t
+ fun:main
+}
+
+{
+ array new aligned bad alignment
+ Memcheck:BadAlign
+ fun:_ZnamSt11align_val_t
+ fun:main
+}
+
+{
+ array new aligned bad alignment, 32bit
+ Memcheck:BadAlign
+ fun:_ZnajSt11align_val_t
+ fun:main
+}
+
--- /dev/null
+prog: sized_aligned_new_delete_misaligned3
+prereq: test -e ./sized_aligned_new_delete_misaligned3
+vgopts: -s --suppressions=sized_aligned_new_delete_misaligned3_supp.supp
+stderr_filter: filter_used_supp
--- /dev/null
+<?xml version="1.0"?>
+
+<valgrindoutput>
+
+<protocolversion>4</protocolversion>
+<protocoltool>memcheck</protocoltool>
+
+<preamble>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+ <line>...</line>
+</preamble>
+
+<pid>...</pid>
+<ppid>...</ppid>
+<tool>memcheck</tool>
+
+<args>
+ <vargv>...</vargv>
+ <argv>
+ <exe>./sized_aligned_new_delete_misaligned3</exe>
+ </argv>
+</args>
+
+<status>
+ <state>RUNNING</state>
+ <time>...</time>
+</status>
+
+<error>
+ <unique>0x........</unique>
+ <tid>...</tid>
+ <kind>InvalidAlignment</kind>
+ <what>Invalid alignment value: 63 (should be non-zero and a power of 2)</what>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new[](unsigned long, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned3.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</error>
+
+<clientmsg>
+ <tid>...</tid>
+ <text>new/new[] aligned failed and should throw an exception, but Valgrind
+ </text>
+</clientmsg>
+<clientmsg>
+ <tid>...</tid>
+ <text> cannot throw exceptions and so is aborting instead. Sorry.
+ </text>
+ <stack>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>VALGRIND_PRINTF_BACKTRACE</fn>
+ <dir>...</dir>
+ <file>valgrind.h</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>operator new[](unsigned long, std::align_val_t)</fn>
+ <dir>...</dir>
+ <file>vg_replace_malloc.c</file>
+ <line>...</line>
+ </frame>
+ <frame>
+ <ip>0x........</ip>
+ <obj>...</obj>
+ <fn>main</fn>
+ <dir>...</dir>
+ <file>sized_aligned_new_delete_misaligned3.cpp</file>
+ <line>...</line>
+ </frame>
+ </stack>
+</clientmsg>
+
+<status>
+ <state>FINISHED</state>
+ <time>...</time>
+</status>
+
+<errorcounts>
+ <pair>
+ <count>...</count>
+ <unique>0x........</unique>
+ </pair>
+</errorcounts>
+
+<suppcounts>...</suppcounts>
+
+</valgrindoutput>
+
--- /dev/null
+prog: sized_aligned_new_delete_misaligned3
+prereq: test -e ./sized_aligned_new_delete_misaligned3
+vgopts: --xml=yes --xml-fd=2 --log-file=/dev/null
+stderr_filter: filter_xml
+Invalid size value: 25 alignment value: 8 (size should be a multiple of alignment)
+ at 0x........: aligned_alloc (vg_replace_malloc.c:...)
+ by 0x........: main (aligned_alloc.c:15)
+
+Invalid alignment value: 40 (should be a power of 2)
+ at 0x........: aligned_alloc (vg_replace_malloc.c:...)
+ by 0x........: main (aligned_alloc.c:20)
+
+memalign() invalid size value: 0
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:29)
+
+Invalid alignment value: 0 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:34)
+
+Invalid alignment value: 3 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:49)
+
+Invalid alignment value: 5 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:54)
+
+Invalid alignment value: 7 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:58)
+
+Invalid alignment value: 9 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:64)
+
+Invalid alignment value: 12 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:67)
+
+Invalid alignment value: 31 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:70)
+
+Invalid alignment value: 33 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:76)
+
+Invalid alignment value: 4095 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:80)
+
+Invalid alignment value: 4097 (should be power of 2)
+ at 0x........: memalign (vg_replace_malloc.c:...)
+ by 0x........: main (memalign.c:86)
+
projects / thirdparty / valgrind.git / commitdiff
