You can subscribe to this list here.
| 2002 |
Jan
|
Feb
|
Mar
|
Apr
|
May
|
Jun
|
Jul
|
Aug
|
Sep
(1) |
Oct
(122) |
Nov
(152) |
Dec
(69) |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 2003 |
Jan
(6) |
Feb
(25) |
Mar
(73) |
Apr
(82) |
May
(24) |
Jun
(25) |
Jul
(10) |
Aug
(11) |
Sep
(10) |
Oct
(54) |
Nov
(203) |
Dec
(182) |
| 2004 |
Jan
(307) |
Feb
(305) |
Mar
(430) |
Apr
(312) |
May
(187) |
Jun
(342) |
Jul
(487) |
Aug
(637) |
Sep
(336) |
Oct
(373) |
Nov
(441) |
Dec
(210) |
| 2005 |
Jan
(385) |
Feb
(480) |
Mar
(636) |
Apr
(544) |
May
(679) |
Jun
(625) |
Jul
(810) |
Aug
(838) |
Sep
(634) |
Oct
(521) |
Nov
(965) |
Dec
(543) |
| 2006 |
Jan
(494) |
Feb
(431) |
Mar
(546) |
Apr
(411) |
May
(406) |
Jun
(322) |
Jul
(256) |
Aug
(401) |
Sep
(345) |
Oct
(542) |
Nov
(308) |
Dec
(481) |
| 2007 |
Jan
(427) |
Feb
(326) |
Mar
(367) |
Apr
(255) |
May
(244) |
Jun
(204) |
Jul
(223) |
Aug
(231) |
Sep
(354) |
Oct
(374) |
Nov
(497) |
Dec
(362) |
| 2008 |
Jan
(322) |
Feb
(482) |
Mar
(658) |
Apr
(422) |
May
(476) |
Jun
(396) |
Jul
(455) |
Aug
(267) |
Sep
(280) |
Oct
(253) |
Nov
(232) |
Dec
(304) |
| 2009 |
Jan
(486) |
Feb
(470) |
Mar
(458) |
Apr
(423) |
May
(696) |
Jun
(461) |
Jul
(551) |
Aug
(575) |
Sep
(134) |
Oct
(110) |
Nov
(157) |
Dec
(102) |
| 2010 |
Jan
(226) |
Feb
(86) |
Mar
(147) |
Apr
(117) |
May
(107) |
Jun
(203) |
Jul
(193) |
Aug
(238) |
Sep
(300) |
Oct
(246) |
Nov
(23) |
Dec
(75) |
| 2011 |
Jan
(133) |
Feb
(195) |
Mar
(315) |
Apr
(200) |
May
(267) |
Jun
(293) |
Jul
(353) |
Aug
(237) |
Sep
(278) |
Oct
(611) |
Nov
(274) |
Dec
(260) |
| 2012 |
Jan
(303) |
Feb
(391) |
Mar
(417) |
Apr
(441) |
May
(488) |
Jun
(655) |
Jul
(590) |
Aug
(610) |
Sep
(526) |
Oct
(478) |
Nov
(359) |
Dec
(372) |
| 2013 |
Jan
(467) |
Feb
(226) |
Mar
(391) |
Apr
(281) |
May
(299) |
Jun
(252) |
Jul
(311) |
Aug
(352) |
Sep
(481) |
Oct
(571) |
Nov
(222) |
Dec
(231) |
| 2014 |
Jan
(185) |
Feb
(329) |
Mar
(245) |
Apr
(238) |
May
(281) |
Jun
(399) |
Jul
(382) |
Aug
(500) |
Sep
(579) |
Oct
(435) |
Nov
(487) |
Dec
(256) |
| 2015 |
Jan
(338) |
Feb
(357) |
Mar
(330) |
Apr
(294) |
May
(191) |
Jun
(108) |
Jul
(142) |
Aug
(261) |
Sep
(190) |
Oct
(54) |
Nov
(83) |
Dec
(22) |
| 2016 |
Jan
(49) |
Feb
(89) |
Mar
(33) |
Apr
(50) |
May
(27) |
Jun
(34) |
Jul
(53) |
Aug
(53) |
Sep
(98) |
Oct
(206) |
Nov
(93) |
Dec
(53) |
| 2017 |
Jan
(65) |
Feb
(82) |
Mar
(102) |
Apr
(86) |
May
(187) |
Jun
(67) |
Jul
(23) |
Aug
(93) |
Sep
(65) |
Oct
(45) |
Nov
(35) |
Dec
(17) |
| 2018 |
Jan
(26) |
Feb
(35) |
Mar
(38) |
Apr
(32) |
May
(8) |
Jun
(43) |
Jul
(27) |
Aug
(30) |
Sep
(43) |
Oct
(42) |
Nov
(38) |
Dec
(67) |
| 2019 |
Jan
(32) |
Feb
(37) |
Mar
(53) |
Apr
(64) |
May
(49) |
Jun
(18) |
Jul
(14) |
Aug
(53) |
Sep
(25) |
Oct
(30) |
Nov
(49) |
Dec
(31) |
| 2020 |
Jan
(87) |
Feb
(45) |
Mar
(37) |
Apr
(51) |
May
(99) |
Jun
(36) |
Jul
(11) |
Aug
(14) |
Sep
(20) |
Oct
(24) |
Nov
(40) |
Dec
(23) |
| 2021 |
Jan
(14) |
Feb
(53) |
Mar
(85) |
Apr
(15) |
May
(19) |
Jun
(3) |
Jul
(14) |
Aug
(1) |
Sep
(57) |
Oct
(73) |
Nov
(56) |
Dec
(22) |
| 2022 |
Jan
(3) |
Feb
(22) |
Mar
(6) |
Apr
(55) |
May
(46) |
Jun
(39) |
Jul
(15) |
Aug
(9) |
Sep
(11) |
Oct
(34) |
Nov
(20) |
Dec
(36) |
| 2023 |
Jan
(79) |
Feb
(41) |
Mar
(99) |
Apr
(169) |
May
(48) |
Jun
(16) |
Jul
(16) |
Aug
(57) |
Sep
(19) |
Oct
|
Nov
|
Dec
|
|
From: Paul F. <pa...@so...> - 2023-09-03 12:23:21
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=c086bbdd66dc8e7cba02f06de74aff37bb79b3ea commit c086bbdd66dc8e7cba02f06de74aff37bb79b3ea Author: Paul Floyd <pj...@wa...> Date: Sun Sep 3 14:20:42 2023 +0200 Solaris regtest: aligned / sized expecteds and an improved filter A couple of testcases fail due to ever changing output for floating point infinity. Add memalign and aligned_alloc expecteds for Solaris 11.3 (which doesn't have aligned_allloc). Diff: --- memcheck/tests/Makefile.am | 1 + memcheck/tests/memalign_args.stderr.exp-solaris | 11 +++++++++++ memcheck/tests/sized_aligned_new_delete_misaligned | Bin 0 -> 42384 bytes memcheck/tests/solaris/Makefile.am | 1 + memcheck/tests/solaris/aligned_alloc.stderr.exp-solaris | 0 none/tests/amd64/filter_inf_nan | 6 +++--- none/tests/x86/filter_inf_nan | 6 +++--- 7 files changed, 19 insertions(+), 6 deletions(-) diff --git a/memcheck/tests/Makefile.am b/memcheck/tests/Makefile.am index e216521b5e..4442d945cc 100644 --- a/memcheck/tests/Makefile.am +++ b/memcheck/tests/Makefile.am @@ -257,6 +257,7 @@ EXTRA_DIST = \ memalign_args.vgtest memalign_args.stderr.exp \ memalign_args.stderr.exp-glibc \ memalign_args.stderr.exp-darwin \ + memalign_args.stderr.exp-solaris \ memcmptest.stderr.exp memcmptest.stderr.exp2 \ memcmptest.stdout.exp memcmptest.vgtest \ memmem.stderr.exp memmem.vgtest \ diff --git a/memcheck/tests/memalign_args.stderr.exp-solaris b/memcheck/tests/memalign_args.stderr.exp-solaris new file mode 100644 index 0000000000..c255e02f1c --- /dev/null +++ b/memcheck/tests/memalign_args.stderr.exp-solaris @@ -0,0 +1,11 @@ +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:...) + by 0x........: main (memalign_args.c:23) + +Conditional jump or move depends on uninitialised value(s) + at 0x........: valloc (vg_replace_malloc.c:...) + by 0x........: main (memalign_args.c:31) diff --git a/memcheck/tests/sized_aligned_new_delete_misaligned b/memcheck/tests/sized_aligned_new_delete_misaligned new file mode 100755 index 0000000000..1c69036c16 Binary files /dev/null and b/memcheck/tests/sized_aligned_new_delete_misaligned differ diff --git a/memcheck/tests/solaris/Makefile.am b/memcheck/tests/solaris/Makefile.am index fe1e2ca3fb..f80a23448d 100644 --- a/memcheck/tests/solaris/Makefile.am +++ b/memcheck/tests/solaris/Makefile.am @@ -13,6 +13,7 @@ noinst_HEADERS = scalar.h EXTRA_DIST = \ aligned_alloc.stderr.exp aligned_alloc.vgtest \ + aligned_alloc.stderr.exp-solaris \ brk.stderr.exp brk.stdout.exp brk.vgtest \ context_stack_die.stderr.exp context_stack_die.stdout.exp context_stack_die.vgtest \ door_data.stderr.exp door_data.stdout.exp door_data.vgtest \ diff --git a/memcheck/tests/solaris/aligned_alloc.stderr.exp-solaris b/memcheck/tests/solaris/aligned_alloc.stderr.exp-solaris new file mode 100644 index 0000000000..e69de29bb2 diff --git a/none/tests/amd64/filter_inf_nan b/none/tests/amd64/filter_inf_nan index ce40f21dc8..1e660e5a7c 100755 --- a/none/tests/amd64/filter_inf_nan +++ b/none/tests/amd64/filter_inf_nan @@ -1,9 +1,9 @@ #! /bin/sh -# Solaris libc prints 'Inf' or 'Infinity' instead of 'inf' +# Solaris libc prints 'Inf' or 'Infinity' or 'infinity' instead of 'inf' # and 'NaN' instead of 'nan'. Filter these differences here. -sed "s/-Infinity/ -inf/g" | -sed "s/Infinity/ inf/g" | +sed "s/-[Ii]nfinity/ -inf/g" | +sed "s/[Ii]nfinity/ inf/g" | sed "s/Inf/inf/g" | sed "s/NaN/nan/g" diff --git a/none/tests/x86/filter_inf_nan b/none/tests/x86/filter_inf_nan index b4ddfc9b1c..f70958cff1 100755 --- a/none/tests/x86/filter_inf_nan +++ b/none/tests/x86/filter_inf_nan @@ -1,9 +1,9 @@ #! /bin/sh -# Solaris libc prints 'Infinity' instead of 'inf' and 'NaN' instead of 'nan'. +# Solaris libc prints 'Infinity' or 'infinity' instead of 'inf' and 'NaN' instead of 'nan'. # Filter these differences here. -sed "s/-Infinity/ -inf/g" | -sed "s/Infinity/ inf/g" | +sed "s/-[Ii]nfinity/ -inf/g" | +sed "s/[Ii]nfinity/ inf/g" | sed "s/NaN/nan/g" exit 0 |
|
From: Paul F. <pa...@so...> - 2023-09-03 06:30:00
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=28621328367f4160d78e8f9f6acf715415853b8c commit 28621328367f4160d78e8f9f6acf715415853b8c Author: Paul Floyd <pj...@wa...> Date: Sun Sep 3 08:28:26 2023 +0200 coverity: various fixes Null check, uninitialized variable and several print format uses of size_t. clang-tidy also complains about most of them. Diff: --- coregrind/m_debuginfo/debuginfo.c | 2 +- coregrind/m_debuginfo/readelf.c | 3 ++- coregrind/vgdb.c | 23 +++++++++++++---------- 3 files changed, 16 insertions(+), 12 deletions(-) diff --git a/coregrind/m_debuginfo/debuginfo.c b/coregrind/m_debuginfo/debuginfo.c index 0c4eb99c0d..4f6ffd48ae 100644 --- a/coregrind/m_debuginfo/debuginfo.c +++ b/coregrind/m_debuginfo/debuginfo.c @@ -2828,7 +2828,7 @@ const HChar* VG_(describe_IP)(DiEpoch ep, Addr eip, const InlIPCursor *iipc) ); know_dirinfo = buf_dirname[0] != '\0'; } else { - const DiInlLoc *cur_inl = iipc && iipc->cur_inltab >= 0 + const DiInlLoc *cur_inl = iipc && iipc->di && iipc->cur_inltab >= 0 ? & iipc->di->inltab[iipc->cur_inltab] : NULL; vg_assert (cur_inl); diff --git a/coregrind/m_debuginfo/readelf.c b/coregrind/m_debuginfo/readelf.c index ef9a722ad9..13efc46b84 100644 --- a/coregrind/m_debuginfo/readelf.c +++ b/coregrind/m_debuginfo/readelf.c @@ -2933,7 +2933,8 @@ Bool ML_(read_elf_object) ( struct _DebugInfo* di ) /* TOPLEVEL */ /* Read .eh_frame and .debug_frame (call-frame-info) if any. Do the .eh_frame section(s) first. */ - vg_assert(di->n_ehframe >= 0 && di->n_ehframe <= N_EHFRAME_SECTS); + /* i->n_ehframe is unsigned and cannot be negative */ + vg_assert(di->n_ehframe <= N_EHFRAME_SECTS); for (i = 0; i < di->n_ehframe; i++) { /* see Comment_on_EH_FRAME_MULTIPLE_INSTANCES above for why this next assertion should hold. */ diff --git a/coregrind/vgdb.c b/coregrind/vgdb.c index 9e21a00d66..8e030e27b1 100644 --- a/coregrind/vgdb.c +++ b/coregrind/vgdb.c @@ -1035,8 +1035,11 @@ send_packet_start: // or -1 if no packet could be read. static int receive_packet(char *buf, int noackmode) { - int bufcnt = 0, ret; - char c, c1, c2; + int bufcnt = 0; + int ret; + char c; + char c1 = '\0'; + char c2; unsigned char csum = 0; // Look for first '$' (start of packet) or error. @@ -1428,12 +1431,12 @@ void do_multi_mode(int check_trials, int in_port) // Count the lenghts of each substring, init to -1 to compensate for // each substring starting with a delim char. - for (int i = 0; i < count; i++) + for (size_t i = 0; i < count; i++) len[i] = -1; count_len(';', buf, len); if (next_str) { DEBUG(1, "vRun: next_str %s\n", next_str); - for (int i = 0; i < count; i++) { + for (size_t i = 0; i < count; i++) { /* Handle the case when the arguments * was specified to gdb's run command * but no remote exec-file was set, @@ -1449,16 +1452,16 @@ void do_multi_mode(int check_trials, int in_port) if (i < count - 1) next_str = next_delim_string(next_str, *delim); } - DEBUG(1, "vRun decoded: %s, next_str %s, len[%d] %d\n", + DEBUG(1, "vRun decoded: %s, next_str %s, len[%zu] %zu\n", decoded_string[i], next_str, i, len[i]); } /* If we didn't get any arguments or the filename is an empty string, valgrind won't know which program to run. */ - DEBUG (1, "count: %d, len[0]: %d\n", count, len[0]); + DEBUG (1, "count: %zu, len[0]: %zu\n", count, len[0]); if (! count || len[0] == 0) { free(len); - for (int i = 0; i < count; i++) + for (size_t i = 0; i < count; i++) free (decoded_string[i]); free (decoded_string); send_packet ("E01", noackmode); @@ -1469,7 +1472,7 @@ void do_multi_mode(int check_trials, int in_port) launch valgrind with the correct arguments... We then use the valgrind pid to start relaying packets. */ pid_t valgrind_pid = -1; - int res = fork_and_exec_valgrind (count, + int res = fork_and_exec_valgrind ((int)count, decoded_string, working_dir, in_port, @@ -1706,7 +1709,7 @@ void gdb_relay(int pid, int send_noack_mode, char *q_buf) buflen = getpkt(buf, from_pid, to_pid); if (buflen != 2 || strcmp(buf, "OK") != 0) { if (buflen != 2) - ERROR(0, "no ack mode: unexpected buflen %d, buf %s\n", + ERROR(0, "no ack mode: unexpected buflen %zu, buf %s\n", buflen, buf); else ERROR(0, "no ack mode: unexpected packet %s\n", buf); @@ -1729,7 +1732,7 @@ void gdb_relay(int pid, int send_noack_mode, char *q_buf) if (buflen > 0) { waiting_for_qsupported = False; } else { - ERROR(0, "Unexpected getpkt for qSupported reply: %d\n", + ERROR(0, "Unexpected getpkt for qSupported reply: %zu\n", buflen); } } else if (!read_from_pid_write_to_gdb(from_pid)) |
|
From: Paul F. <pa...@so...> - 2023-09-03 06:28:15
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=777b0e041a880f6cce5b8e39068aa77ca11ff50d commit 777b0e041a880f6cce5b8e39068aa77ca11ff50d Author: Paul Floyd <pj...@wa...> Date: Sun Sep 3 08:27:19 2023 +0200 FreeBSD: clarify which package GNU cp is in (needed for nightly tests) Diff: --- README.freebsd | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/README.freebsd b/README.freebsd index ce1e435f5d..449796353f 100644 --- a/README.freebsd +++ b/README.freebsd @@ -156,7 +156,7 @@ and "gmake regtest". Again, more details can be seen in README_DEVELOPERS. If you want to run the 'nightly' script (see nightly/README.txt) -you will need to install gcp and coreutils and modify the +you will need to install coreutils (for GNU cp) and modify the nightly/conf/freebsd.* files. The default configuration sends an e-mail to the valgrind-testresults mailing list. |
|
From: Paul F. <pa...@so...> - 2023-09-02 21:46:06
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=1e197de36e1d116294d2f19c4d47fb91a6611208 commit 1e197de36e1d116294d2f19c4d47fb91a6611208 Author: Paul Floyd <pj...@wa...> Date: Sat Sep 2 23:43:31 2023 +0200 coverity: fix a couple of forward nulls In the new sized/aligned memcheck code. Diff: --- memcheck/mc_main.c | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/memcheck/mc_main.c b/memcheck/mc_main.c index 90b89a9115..3f34e3dc19 100644 --- a/memcheck/mc_main.c +++ b/memcheck/mc_main.c @@ -7305,7 +7305,7 @@ static Bool mc_handle_client_request ( ThreadId tid, UWord* arg, UWord* ret ) 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) { + if (mc && 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 || @@ -7318,7 +7318,7 @@ static Bool mc_handle_client_request ( ThreadId tid, UWord* arg, UWord* ret ) 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) { + if (mc && 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 || |
|
From: Paul F. <pa...@so...> - 2023-09-02 21:20:11
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=9ed8f42357f73c290c7bff85246977ff1972fbb8 commit 9ed8f42357f73c290c7bff85246977ff1972fbb8 Author: Paul Floyd <pj...@wa...> Date: Sat Sep 2 23:19:17 2023 +0200 coverity: a few bits of dead code and one vgdb command line leak Diff: --- coregrind/launcher-freebsd.c | 19 +------------------ coregrind/vgdb.c | 5 +++++ include/pub_tool_basics.h | 5 ----- memcheck/mc_translate.c | 9 +-------- 4 files changed, 7 insertions(+), 31 deletions(-) diff --git a/coregrind/launcher-freebsd.c b/coregrind/launcher-freebsd.c index 030b183b57..8687de3f59 100644 --- a/coregrind/launcher-freebsd.c +++ b/coregrind/launcher-freebsd.c @@ -198,7 +198,7 @@ int main(int argc, char** argv, char** envp) const char *toolname = NULL; const char *clientname = NULL; const char *platform; - const char *default_platform; + const char *default_platform = VG_PLATFORM; const char *cp; char *toolfile; char launcher_name[PATH_MAX+1]; @@ -243,23 +243,6 @@ int main(int argc, char** argv, char** envp) toolname = "memcheck"; } - /* Select a platform to use if we can't decide that by looking at - the executable (eg because it's a shell script). Note that the - default_platform is not necessarily either the primary or - secondary build target. Instead it's chosen to maximise the - chances that /bin/sh will work on it. Hence for a primary - target of ppc64-linux we still choose ppc32-linux as the default - target, because on most ppc64-linux setups, the basic /bin, - /usr/bin, etc, stuff is built in 32-bit mode, not 64-bit - mode. */ - if (0==strcmp(VG_PLATFORM,"x86-freebsd")) { - default_platform = "x86-freebsd"; - } else if (0==strcmp(VG_PLATFORM,"amd64-freebsd")) { - default_platform = "amd64-freebsd"; - } else { - barf("Unknown VG_PLATFORM '%s'", VG_PLATFORM); - } - /* Work out what platform to use, or use the default platform if not possible. */ if (clientname == NULL) { diff --git a/coregrind/vgdb.c b/coregrind/vgdb.c index c024ffca6b..9e21a00d66 100644 --- a/coregrind/vgdb.c +++ b/coregrind/vgdb.c @@ -2269,6 +2269,11 @@ void parse_options(int argc, char** argv, arg_errors++; } } else if (is_opt(argv[i], "--vgdb-prefix=")) { + if (vgdb_prefix) { + // was specified more than once on the command line + // ignore earlier uses + free(vgdb_prefix); + } vgdb_prefix = strdup (argv[i] + 14); } else if (is_opt(argv[i], "--valgrind=")) { char *path = argv[i] + 11; diff --git a/include/pub_tool_basics.h b/include/pub_tool_basics.h index d22a425238..bf5a5ba7fa 100644 --- a/include/pub_tool_basics.h +++ b/include/pub_tool_basics.h @@ -233,11 +233,6 @@ typedef UWord _val; UWord _val2; Bool _isError; -#if defined(VGP_amd64_freebsd) - char padding[7]; -#else - char padding[3]; -#endif } SysRes; diff --git a/memcheck/mc_translate.c b/memcheck/mc_translate.c index 72ccb3c8c6..f8aca1641c 100644 --- a/memcheck/mc_translate.c +++ b/memcheck/mc_translate.c @@ -4822,18 +4822,11 @@ IRAtom* expr2vbits_Binop ( MCEnv* mce, and_or_ty = Ity_I1; improve = mkImproveOR1; goto do_And_Or; do_And_Or: - return - assignNew( - 'V', mce, - and_or_ty, - difd(mce, uifu(mce, vatom1, vatom2), - difd(mce, improve(mce, atom1, vatom1), - improve(mce, atom2, vatom2) ) ) ); - return assignNew('V', mce, and_or_ty, difd(mce, uifu(mce, vatom1, vatom2), difd(mce, improve(mce, atom1, vatom1), improve(mce, atom2, vatom2) ) ) ); + case Iop_Xor8: return mkUifU8(mce, vatom1, vatom2); case Iop_Xor16: |
|
From: Paul F. <pa...@so...> - 2023-09-02 15:38:43
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=fa2f351cf8aecfc4fa3377eac5daa565df13d963 commit fa2f351cf8aecfc4fa3377eac5daa565df13d963 Author: Paul Floyd <pj...@wa...> Date: Sat Sep 2 17:33:35 2023 +0200 regtest: silence some more warnings A massif test that checks that --ignore-fn Sadly neither C nor C++ has a standard way of specifying functons to _never_ inline, and GCC and LLVM seem to have different extensions. GCC complains about __attribute__((optnone)). Diff: --- configure.ac | 1 + massif/tests/Makefile.am | 2 +- 2 files changed, 2 insertions(+), 1 deletion(-) diff --git a/configure.ac b/configure.ac index 5ce94c318c..0ce6cccb6d 100755 --- a/configure.ac +++ b/configure.ac @@ -2606,6 +2606,7 @@ AC_GCC_WARNING_SUBST_NO([fortify-source], [FLAG_W_NO_FORTIFY_SOURCE]) AC_GCC_WARNING_SUBST_NO([builtin-memcpy-chk-size], [FLAG_W_NO_BUILTIN_MEMCPY_CHK_SIZE]) AC_GCC_WARNING_SUBST_NO([incompatible-pointer-types-discards-qualifiers], [FLAG_W_NO_INCOMPATIBLE_POINTER_TYPES_DISCARDS_QUALIFIERS]) AC_GCC_WARNING_SUBST_NO([suspicious-bzero], [FLAG_W_NO_SUSPICIOUS_BZERO]) +AC_GCC_WARNING_SUBST_NO([attributes], [FLAG_W_NO_ATTRIBUTES]) AC_GCC_WARNING_SUBST_NO_VAL([alloc-size-larger-than], [1677216], [FLAG_W_NO_ALLOC_SIZE_LARGER_THAN]) diff --git a/massif/tests/Makefile.am b/massif/tests/Makefile.am index f8deeb5766..636bc8f85a 100644 --- a/massif/tests/Makefile.am +++ b/massif/tests/Makefile.am @@ -91,7 +91,7 @@ AM_CXXFLAGS += $(AM_FLAG_M3264_PRI) bug469146_SOURCES = bug469146.cpp # -fno-optimize-sibling-calls because otherwise some platforms will have # tail call optimization which messes up --ignore-fn -bug469146_CXXFLAGS = $(AM_CXXFLAGS) -O2 -fno-optimize-sibling-calls @FLAG_W_NO_USE_AFTER_FREE@ +bug469146_CXXFLAGS = $(AM_CXXFLAGS) -O2 -fno-optimize-sibling-calls @FLAG_W_NO_USE_AFTER_FREE@ @FLAG_W_NO_ATTRIBUTES@ new_cpp_SOURCES = new-cpp.cpp overloaded_new_SOURCES = overloaded-new.cpp # pre C++11 compilers don't have exception specs |
|
From: Paul F. <pa...@so...> - 2023-09-02 15:16:09
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=86a8f04c7f5d31050d841e82397f052fc6a958a6 commit 86a8f04c7f5d31050d841e82397f052fc6a958a6 Author: Paul Floyd <pj...@wa...> Date: Sat Sep 2 17:12:23 2023 +0200 regtest: silence a few warnings A couple of testcases that use 'new' that will throw an uncaught exception. The variable doesn't get used, there is only an assert to check that nothing is reached after the new expressions. Diff: --- configure.ac | 1 + memcheck/tests/Makefile.am | 4 ++-- 2 files changed, 3 insertions(+), 2 deletions(-) diff --git a/configure.ac b/configure.ac index 2aaf3f44bb..5ce94c318c 100755 --- a/configure.ac +++ b/configure.ac @@ -2592,6 +2592,7 @@ AC_GCC_WARNING_SUBST_NO([static-local-in-inline], [FLAG_W_NO_STATIC_LOCAL_IN_INL AC_GCC_WARNING_SUBST_NO([mismatched-new-delete], [FLAG_W_NO_MISMATCHED_NEW_DELETE]) AC_GCC_WARNING_SUBST_NO([infinite-recursion], [FLAG_W_NO_INFINITE_RECURSION]) AC_GCC_WARNING_SUBST_NO([expansion-to-defined], [FLAG_W_NO_EXPANSION_TO_DEFINED]) +AC_GCC_WARNING_SUBST_NO([unused-variable], [FLAG_W_NO_UNUSED_VARIABLE]) AC_GCC_WARNING_SUBST_NO([unused-but-set-variable], [FLAG_W_NO_UNUSED_BUT_SET_VARIABLE]) AC_GCC_WARNING_SUBST_NO([non-power-of-two-alignment], [FLAG_W_NO_NON_POWER_OF_TWO_ALIGNMENT]) AC_GCC_WARNING_SUBST_NO([sign-compare], [FLAG_W_NO_SIGN_COMPARE]) diff --git a/memcheck/tests/Makefile.am b/memcheck/tests/Makefile.am index 24b39099a7..e216521b5e 100644 --- a/memcheck/tests/Makefile.am +++ b/memcheck/tests/Makefile.am @@ -625,9 +625,9 @@ sized_aligned_new_delete_args_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_misaligned2_CXXFLAGS = ${AM_CXXFLAGS} -std=c++17 @FLAG_W_NO_UNUSED_VARIABLE@ sized_aligned_new_delete_misaligned3_SOURCES = sized_aligned_new_delete_misaligned3.cpp -sized_aligned_new_delete_misaligned3_CXXFLAGS = ${AM_CXXFLAGS} -std=c++17 +sized_aligned_new_delete_misaligned3_CXXFLAGS = ${AM_CXXFLAGS} -std=c++17 @FLAG_W_NO_UNUSED_VARIABLE@ if COMPILER_IS_CLANG cxx17_aligned_new_CXXFLAGS += -fsized-deallocation sized_aligned_new_delete_args_CXXFLAGS += -fsized-deallocation |
|
From: Paul F. <pa...@so...> - 2023-09-02 14:26:32
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=a265a206203003cc0433f786478fe81a6cc3298a commit a265a206203003cc0433f786478fe81a6cc3298a Author: Paul Floyd <pj...@wa...> Date: Sun Mar 12 08:26:04 2023 +0100 Add memcheck errors for aligned and sized allocations and deallocations Bug 433857 Add validation to C++17 aligned new/delete alignment size Bug 433859 Add mismatched detection to C++ 17 aligned new/delete Bug 466105 aligned_alloc problems, part 2 Bug 467441 Add mismatched detection to C++ 14 sized delete 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 An example of the new errors is: int *pi = memalign(31, 100); which will generate the following error ==96206== Invalid alignment value: 31 (should be power of 2) ==96206== at 0x485195E: memalign (vg_replace_malloc.c:1886) ==96206== by 0x20200E: main (memalign.c:59) Diff: --- .gitignore | 8 +- NEWS | 19 +- coregrind/m_replacemalloc/vg_replace_malloc.c | 710 +++++++++++---------- coregrind/m_tooliface.c | 6 +- coregrind/pub_core_replacemalloc.h | 6 +- coregrind/pub_core_tooliface.h | 6 +- dhat/dh_main.c | 6 +- drd/drd_malloc_wrappers.c | 6 +- helgrind/hg_main.c | 6 +- include/pub_tool_replacemalloc.h | 31 + include/pub_tool_tooliface.h | 6 +- massif/ms_main.c | 6 +- memcheck/docs/mc-manual.xml | 58 +- memcheck/mc_errors.c | 262 +++++++- memcheck/mc_include.h | 13 +- memcheck/mc_main.c | 123 +++- memcheck/mc_malloc_wrappers.c | 41 +- memcheck/memcheck.h | 3 +- memcheck/tests/Makefile.am | 66 +- memcheck/tests/duplicate_align_size_errors.cpp | 53 ++ memcheck/tests/filter_size_t | 4 +- memcheck/tests/filter_stanza_and_size_t | 6 + memcheck/tests/filter_used_supp | 7 + memcheck/tests/filter_xml | 7 + memcheck/tests/freebsd/Makefile.am | 21 +- memcheck/tests/freebsd/aligned_alloc.c | 38 ++ memcheck/tests/freebsd/aligned_alloc.stderr.exp | 8 + memcheck/tests/freebsd/aligned_alloc.vgtest | 2 + .../tests/freebsd/aligned_alloc_xml.stderr.exp | 101 +++ memcheck/tests/freebsd/aligned_alloc_xml.vgtest | 4 + .../tests/freebsd/aligned_allocs_supp.stderr.exp | 15 + memcheck/tests/freebsd/aligned_allocs_supp.supp | 20 + memcheck/tests/freebsd/aligned_allocs_supp.vgtest | 4 + memcheck/tests/freebsd/bug470713.cpp | 1 + memcheck/tests/freebsd/delete_sized_mismatch.cpp | 22 + .../tests/freebsd/delete_sized_mismatch.stderr.exp | 14 + .../tests/freebsd/delete_sized_mismatch.vgtest | 3 + .../freebsd/delete_sized_mismatch_xml.stderr.exp | 139 ++++ .../tests/freebsd/delete_sized_mismatch_xml.vgtest | 3 + memcheck/tests/freebsd/errno_aligned_allocs.c | 4 + .../tests/freebsd/errno_aligned_allocs.stderr.exp | 28 +- memcheck/tests/freebsd/memalign.stderr.exp | 32 + memcheck/tests/freebsd/memalign_supp.stderr.exp | 13 + memcheck/tests/freebsd/memalign_supp.supp | 6 + memcheck/tests/freebsd/memalign_supp.vgtest | 2 + memcheck/tests/linux/Makefile.am | 4 +- memcheck/tests/linux/aligned_alloc.stderr.exp-musl | 8 + memcheck/tests/linux/memalign.c | 8 + memcheck/tests/linux/memalign.stderr.exp | 40 ++ memcheck/tests/linux/memalign.stderr.exp-musl | 40 ++ memcheck/tests/memalign_args.stderr.exp-darwin | 7 +- memcheck/tests/mismatches.cpp | 4 +- memcheck/tests/mismatches.stderr.exp2 | 56 ++ memcheck/tests/mismatches_xml.stderr.exp | 331 ++++++++++ memcheck/tests/mismatches_xml.stderr.exp2 | 427 +++++++++++++ memcheck/tests/mismatches_xml.vgtest | 3 + memcheck/tests/new_delete_mismatch_size.cpp | 30 + memcheck/tests/new_delete_mismatch_size.stderr.exp | 28 + memcheck/tests/new_delete_mismatch_size.vgtest | 5 + .../tests/new_delete_mismatch_size_supp.stderr.exp | 4 + .../new_delete_mismatch_size_supp.stderr.exp_32 | 4 + memcheck/tests/new_delete_mismatch_size_supp.supp | 57 ++ .../tests/new_delete_mismatch_size_supp.vgtest | 4 + memcheck/tests/posix_memalign.c | 52 +- memcheck/tests/posix_memalign.stderr.exp | 40 ++ memcheck/tests/posix_memalign.stderr.exp-darwin | 50 ++ memcheck/tests/posix_memalign.vgtest | 1 + memcheck/tests/posix_memalign_supp.stderr.exp | 2 + memcheck/tests/posix_memalign_supp.supp | 14 + memcheck/tests/posix_memalign_supp.vgtest | 3 + memcheck/tests/posix_memalign_xml.stderr.exp | 333 ++++++++++ memcheck/tests/posix_memalign_xml.vgtest | 3 + .../tests/sized_aligned_new_delete_args.vgtest | 2 +- .../sized_aligned_new_delete_misaligned.stderr.exp | 10 - .../sized_aligned_new_delete_misaligned.vgtest | 4 - ...pp => sized_aligned_new_delete_misaligned1.cpp} | 40 +- ...sized_aligned_new_delete_misaligned1.stderr.exp | 68 ++ .../sized_aligned_new_delete_misaligned1.vgtest | 4 + ..._aligned_new_delete_misaligned1_supp.stderr.exp | 8 + ...igned_new_delete_misaligned1_supp.stderr.exp_32 | 8 + .../sized_aligned_new_delete_misaligned1_supp.supp | 133 ++++ ...ized_aligned_new_delete_misaligned1_supp.vgtest | 4 + ...d_aligned_new_delete_misaligned1_xml.stderr.exp | 525 +++++++++++++++ ...sized_aligned_new_delete_misaligned1_xml.vgtest | 4 + .../tests/sized_aligned_new_delete_misaligned2.cpp | 10 + ...sized_aligned_new_delete_misaligned2.stderr.exp | 9 + .../sized_aligned_new_delete_misaligned2.vgtest | 4 + ..._aligned_new_delete_misaligned2_supp.stderr.exp | 1 + ...igned_new_delete_misaligned2_supp.stderr.exp_32 | 1 + .../sized_aligned_new_delete_misaligned2_supp.supp | 133 ++++ ...ized_aligned_new_delete_misaligned2_supp.vgtest | 4 + ...d_aligned_new_delete_misaligned2_xml.stderr.exp | 108 ++++ ...sized_aligned_new_delete_misaligned2_xml.vgtest | 4 + .../tests/sized_aligned_new_delete_misaligned3.cpp | 11 + ...sized_aligned_new_delete_misaligned3.stderr.exp | 9 + .../sized_aligned_new_delete_misaligned3.vgtest | 4 + ..._aligned_new_delete_misaligned3_supp.stderr.exp | 1 + ...igned_new_delete_misaligned3_supp.stderr.exp_32 | 1 + .../sized_aligned_new_delete_misaligned3_supp.supp | 133 ++++ ...ized_aligned_new_delete_misaligned3_supp.vgtest | 4 + ...d_aligned_new_delete_misaligned3_xml.stderr.exp | 108 ++++ ...sized_aligned_new_delete_misaligned3_xml.vgtest | 4 + memcheck/tests/solaris/aligned_alloc.stderr.exp | 8 + memcheck/tests/solaris/memalign.stderr.exp | 44 ++ 104 files changed, 4425 insertions(+), 483 deletions(-) diff --git a/.gitignore b/.gitignore index 6538eb718b..6aeb41df94 100644 --- a/.gitignore +++ b/.gitignore @@ -866,6 +866,7 @@ /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 @@ -932,6 +933,7 @@ /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 @@ -971,7 +973,9 @@ /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 @@ -1341,11 +1345,13 @@ /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 diff --git a/NEWS b/NEWS index 41f6d8699a..7c5247f071 100644 --- a/NEWS +++ b/NEWS @@ -22,9 +22,20 @@ AMD64/macOS 10.13 and nanoMIPS/Linux. * 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 ==================== @@ -35,8 +46,12 @@ bugzilla (https://bugs.kde.org/enter_bug.cgi?product=valgrind) rather 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 diff --git a/coregrind/m_replacemalloc/vg_replace_malloc.c b/coregrind/m_replacemalloc/vg_replace_malloc.c index a71aa4b5b2..6c6f0d60f7 100644 --- a/coregrind/m_replacemalloc/vg_replace_malloc.c +++ b/coregrind/m_replacemalloc/vg_replace_malloc.c @@ -67,9 +67,14 @@ #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: @@ -307,15 +312,18 @@ extern int * __error(void) __attribute__((weak)); /* 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) \ @@ -327,7 +335,7 @@ extern int * __error(void) __attribute__((weak)); 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; \ @@ -382,15 +390,18 @@ extern int * __error(void) __attribute__((weak)); '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) \ @@ -406,7 +417,7 @@ extern int * __error(void) __attribute__((weak)); 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( \ @@ -519,55 +530,55 @@ extern int * __error(void) __attribute__((weak)); #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 @@ -639,55 +650,55 @@ extern int * __error(void) __attribute__((weak)); #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 @@ -761,57 +772,57 @@ extern int * __error(void) __attribute__((weak)); #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 @@ -882,57 +893,57 @@ extern int * __error(void) __attribute__((weak)); #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 @@ -1044,13 +1055,16 @@ extern int * __error(void) __attribute__((weak)); /*------------------- 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; \ @@ -1060,79 +1074,89 @@ extern int * __error(void) __attribute__((weak)); #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; \ @@ -1141,76 +1165,76 @@ extern int * __error(void) __attribute__((weak)); #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 @@ -1247,29 +1271,29 @@ extern int * __error(void) __attribute__((weak)); #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 @@ -1311,51 +1335,51 @@ extern int * __error(void) __attribute__((weak)); #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, ... [truncated message content] |
|
From: Paul F. <pa...@so...> - 2023-09-02 12:10:13
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=6489bc63a13fcf614cdb1cb318ea9a1f898a39cd commit 6489bc63a13fcf614cdb1cb318ea9a1f898a39cd Author: Paul Floyd <pj...@wa...> Date: Sat Sep 2 14:08:07 2023 +0200 regtest: make memcheck sem test quiet On Solaris the summary shows 7 allocations causing a diff. Diff: --- memcheck/tests/sem.stderr.exp | 10 ---------- memcheck/tests/sem.vgtest | 1 + 2 files changed, 1 insertion(+), 10 deletions(-) diff --git a/memcheck/tests/sem.stderr.exp b/memcheck/tests/sem.stderr.exp index eb42921c60..e69de29bb2 100644 --- a/memcheck/tests/sem.stderr.exp +++ b/memcheck/tests/sem.stderr.exp @@ -1,10 +0,0 @@ - - -HEAP SUMMARY: - in use at exit: 0 bytes in 0 blocks - total heap usage: 0 allocs, 0 frees, 0 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) diff --git a/memcheck/tests/sem.vgtest b/memcheck/tests/sem.vgtest index 876f002110..a95230830b 100644 --- a/memcheck/tests/sem.vgtest +++ b/memcheck/tests/sem.vgtest @@ -1 +1,2 @@ prog: ../../none/tests/sem +vgopts: -q |
|
From: Paul F. <pa...@so...> - 2023-09-02 11:52:52
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=b93ae9a9c8c071fcbf2d0ece052d084b63f6c39c commit b93ae9a9c8c071fcbf2d0ece052d084b63f6c39c Author: Paul Floyd <pj...@wa...> Date: Sat Sep 2 13:52:12 2023 +0200 Solaris: fix a few compiler warnings Diff: --- coregrind/m_coredump/coredump-solaris.c | 2 +- coregrind/m_debuginfo/readelf.c | 2 +- coregrind/m_initimg/initimg-solaris.c | 2 +- coregrind/m_syswrap/syswrap-solaris.c | 3 ++- 4 files changed, 5 insertions(+), 4 deletions(-) diff --git a/coregrind/m_coredump/coredump-solaris.c b/coregrind/m_coredump/coredump-solaris.c index 8e84dba51f..00d131b370 100644 --- a/coregrind/m_coredump/coredump-solaris.c +++ b/coregrind/m_coredump/coredump-solaris.c @@ -886,7 +886,7 @@ void VG_(make_coredump)(ThreadId tid, const vki_siginfo_t *si, VG_(snprintf)(filename, filename_size, "%s%s.%d", basename, coreext, VG_(getpid)()); else - VG_(snprintf)(filename, filename_size, "%s%s.%d.%d", + VG_(snprintf)(filename, filename_size, "%s%s.%d.%u", basename, coreext, VG_(getpid)(), seq); seq++; diff --git a/coregrind/m_debuginfo/readelf.c b/coregrind/m_debuginfo/readelf.c index a4c79efd0f..ef9a722ad9 100644 --- a/coregrind/m_debuginfo/readelf.c +++ b/coregrind/m_debuginfo/readelf.c @@ -1343,7 +1343,7 @@ DiImage* open_debug_file( const HChar* name, const HChar* buildid, UInt crc, if (VG_(clo_verbosity) > 1) VG_(message)(Vg_DebugMsg, " .. build-id mismatch (found %s wanted %s)\n", - debug_buildid, buildid); + (debug_buildid ? debug_buildid : "(null)"), buildid); ML_(dinfo_free)(debug_buildid); return NULL; } diff --git a/coregrind/m_initimg/initimg-solaris.c b/coregrind/m_initimg/initimg-solaris.c index 3e473c8803..1e9e3fd061 100644 --- a/coregrind/m_initimg/initimg-solaris.c +++ b/coregrind/m_initimg/initimg-solaris.c @@ -920,7 +920,7 @@ IIFinaliseImageInfo VG_(ii_create_image)(IICreateImageInfo iicii, szB = VG_PGROUNDUP(szB); VG_(debugLog)(1, "initimg", - "Setup client stack: size will be %ld\n", szB); + "Setup client stack: size will be %lu\n", szB); iifii.clstack_max_size = szB; iifii.initial_client_SP = setup_client_stack(init_sp, env, &info, diff --git a/coregrind/m_syswrap/syswrap-solaris.c b/coregrind/m_syswrap/syswrap-solaris.c index ed3cb4a551..b5489644c1 100644 --- a/coregrind/m_syswrap/syswrap-solaris.c +++ b/coregrind/m_syswrap/syswrap-solaris.c @@ -639,10 +639,11 @@ void VG_(restore_context)(ThreadId tid, vki_ucontext_t *uc, CorePart part, if (tst->os_state.ustack && VG_(am_is_valid_for_client)((Addr)tst->os_state.ustack, sizeof(*tst->os_state.ustack), - VKI_PROT_WRITE)) + VKI_PROT_WRITE)) { *tst->os_state.ustack = uc->uc_stack; VG_TRACK(post_mem_write, part, tid, (Addr)&tst->os_state.ustack, sizeof(tst->os_state.ustack)); + } } /* Restore the architecture-specific part of the context. */ |
|
From: Paul F. <pa...@so...> - 2023-09-02 11:21:48
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=ae4e70d97d46c58a99782ff007df1cdc34ac1219 commit ae4e70d97d46c58a99782ff007df1cdc34ac1219 Author: Paul Floyd <pj...@wa...> Date: Sat Sep 2 15:20:36 2023 +0200 FreeBSD: Add support for building on FreeBSD 15.0 Diff: --- NEWS | 2 ++ configure.ac | 11 +++++++++-- 2 files changed, 11 insertions(+), 2 deletions(-) diff --git a/NEWS b/NEWS index 832d24e45a..41f6d8699a 100644 --- a/NEWS +++ b/NEWS @@ -20,6 +20,8 @@ AMD64/macOS 10.13 and nanoMIPS/Linux. * ================== PLATFORM CHANGES ================= +* support has been added for FreeBSD 14 and FreeBSD 15. + * ==================== TOOL CHANGES =================== diff --git a/configure.ac b/configure.ac index e9592f47ec..2aaf3f44bb 100755 --- a/configure.ac +++ b/configure.ac @@ -398,6 +398,8 @@ case "${host_os}" in freebsd_13_2=1320 AC_DEFINE([FREEBSD_14], 1400, [FREEBSD_VERS value for FreeBSD 14.x]) freebsd_14=1400 + AC_DEFINE([FREEBSD_15], 1500, [FREEBSD_VERS value for FreeBSD 15.x]) + freebsd_15=1500 AC_MSG_CHECKING([for the kernel version]) kernel=`uname -r` @@ -446,7 +448,7 @@ case "${host_os}" in ;; *) AC_MSG_RESULT([unsupported (${kernel})]) - AC_MSG_ERROR([Valgrind works on FreeBSD 10.x to 14.x]) + AC_MSG_ERROR([Valgrind works on FreeBSD 10.x to 15.x]) ;; esac ;; @@ -455,9 +457,14 @@ case "${host_os}" in AC_DEFINE([FREEBSD_VERS], FREEBSD_14, [FreeBSD version]) freebsd_vers=$freebsd_14 ;; + 15.*) + AC_MSG_RESULT([FreeBSD 15.x (${kernel})]) + AC_DEFINE([FREEBSD_VERS], FREEBSD_15, [FreeBSD version]) + freebsd_vers=$freebsd_15 + ;; *) AC_MSG_RESULT([unsupported (${kernel})]) - AC_MSG_ERROR([Valgrind works on FreeBSD 10.x to 14.x]) + AC_MSG_ERROR([Valgrind works on FreeBSD 10.x to 15.x]) ;; esac |
|
From: Mark W. <ma...@kl...> - 2023-09-02 00:08:12
|
Hi Carl, On Fri, Sep 01, 2023 at 11:59:39AM -0700, Carl Love via Valgrind-developers wrote: > The test results are: > > machine pre-lazy-load current mainline with ppc debuginfo fix with Explicitly-load- > (as of 8/31/2023) libc-and-any-sonames > > Power 8 LE Red Hat Enterprise Linux Server 7.9 (Maipo) > 707 tests, 708 tests, 708 tests 708 tests, > 4 stderr failures, 280 stderr failures, 247 stderr failures, 4 stderr failures, > 0 stdout failures, 54 stdout failures, 54 stdout failures, 0 stdout failures, > 13 stderrB failures, 16 stderrB failures, 16 stderrB failures, 13 stderrB failures, > 0 stdoutB failures, 11 stdoutB failures, 12 stdoutB failures 0 stdoutB failures > 9 post failures 13 post failures 9 post failures 9 post failures > > Power 8 BE Ubuntu 20.04.5 LTS (Focal Fossa) > 742 tests, 743 tests, 743 tests, 743 tests, > 2 stderr failures, 671 stderr failures, 671 stderr failures, 671 stderr failures > 0 stdout failures, 152 stdout failures, 152 stdout failures, 152 stdout failures, > 0 stderrB failures, 14 stderrB failures, 14 stderrB failures, 14 stderrB failures, > 2 stdoutB failures, 20 stdoutB failures, 20 stdoutB failures, 20 stdoutB failures, > 9 post failures 43 post failures 43 post failures 43 post failures > > Power 9 LE Ubuntu 20.04.5 LTS (Focal Fossa) > 711 tests, 712 tests, 712 tests, 712 tests, > 4 stderr failures, 280 stderr failures, 247 stderr failures, 4 stderr failures, > 0 stdout failures, 54 stdout failures, 54 stdout failures, 0 stdout failures, > 13 stderrB failures, 16 stderrB failures, 16 stderrB failures, 13 stderrB failures, > 0 stdoutB failures, 12 stdoutB failures, 12 stdoutB failures 0 stdoutB failures, > 9 post failures 13 post failures 9 post failures 9 post failures > > Power 10 LE Red Hat Enterprise Linux 9.0 (Plow) > 719 tests 720 tests, 720 tests, 720 tests, > 2 stderr failures, 42 stderr failures, 2 stderr failures, 2 stderr failures, > 0 stdout failures, 0 stdout failures, 0 stdout failures, 0 stdout failures, > 2 stderrB failures, 2 stderrB failures, 2 stderrB failures, 2 stderrB failures, > 10 stdoutB failures, 10 stdoutB failures, 10 stdoutB failures, 10 stdoutB failures > 0 post failures 3 post failures 0 post failures 0 post failures > > The Explicitly-load-libc-and-any-sonames-that-contain-ma.patch seems > to fix the issues across the various OS distributions for the LE > machines. It does appear that there is a separate issue with the > original patch to lazily load the debug info on PowerPC BE. > Hopefully we can sort that issue out when Aaron gets back from > vacation. The little endian results look really good. Thanks for all the testing. I pushed both Aaron's and my commit. I don't yet fully understand what is going on with big endian. Cheers, Mark |
|
From: Mark W. <ma...@so...> - 2023-09-02 00:03:57
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=8228fe7f696b30c7b6b6daf576fc189bf8d6f8c2 commit 8228fe7f696b30c7b6b6daf576fc189bf8d6f8c2 Author: Mark Wielaard <ma...@kl...> Date: Fri Sep 1 19:10:17 2023 +0200 Explicitly load libc and any sonames that contain mandatory specs We really need symtab for glibc and ld.so libraries early for redir. Some distros move these into separate debuginfo files, which means we need to fully load them early. https://bugs.kde.org/show_bug.cgi?id=473745 Diff: --- NEWS | 1 + coregrind/m_debuginfo/debuginfo.c | 41 ++++++++++++++++++--------------------- coregrind/m_redir.c | 23 ++++++++++++++++------ coregrind/pub_core_debuginfo.h | 2 ++ coregrind/pub_core_redir.h | 2 +- 5 files changed, 40 insertions(+), 29 deletions(-) diff --git a/NEWS b/NEWS index 6f13d53569..832d24e45a 100644 --- a/NEWS +++ b/NEWS @@ -52,6 +52,7 @@ are not entered into bugzilla tend to get forgotten about or ignored. 472963 Broken regular expression in configure.ac 473604 Fix bug472219.c compile failure with Clang 16 473677 make check compile failure with Clang 16 based on GCC 13.x +473745 must-be-redirected function - strlen 473870 FreeBSD 14 applications fail early at startup 473944 Handle mold linker split RW PT_LOAD segments correctly n-i-bz Allow arguments with spaces in .valgrindrc files diff --git a/coregrind/m_debuginfo/debuginfo.c b/coregrind/m_debuginfo/debuginfo.c index c37e50b9d3..0c4eb99c0d 100644 --- a/coregrind/m_debuginfo/debuginfo.c +++ b/coregrind/m_debuginfo/debuginfo.c @@ -1445,27 +1445,34 @@ ULong VG_(di_notify_mmap)( Addr a, Bool allow_SkFileV, Int use_fd ) } } +/* Load DI if it hasn't already been been loaded. */ +void VG_(di_load_di)( DebugInfo *di ) +{ + if (di->deferred) { + di->deferred = False; + ML_(read_elf_debug) (di); + ML_(canonicaliseTables)( di ); + + /* Check invariants listed in + Comment_on_IMPORTANT_REPRESENTATIONAL_INVARIANTS in + priv_storage.h. */ + check_CFSI_related_invariants(di); + ML_(finish_CFSI_arrays)(di); + } +} + /* Load DI if it has a text segment containing A and DI hasn't already been loaded. */ void VG_(load_di)( DebugInfo *di, Addr a) { - if (!di->deferred - || !di->text_present + if (!di->text_present || di->text_size <= 0 || di->text_avma > a || a >= di->text_avma + di->text_size) return; - di->deferred = False; - ML_(read_elf_debug) (di); - ML_(canonicaliseTables)( di ); - - /* Check invariants listed in - Comment_on_IMPORTANT_REPRESENTATIONAL_INVARIANTS in - priv_storage.h. */ - check_CFSI_related_invariants(di); - ML_(finish_CFSI_arrays)(di); + VG_(di_load_di)(di); } /* Attempt to load DebugInfo with a text segment containing A, @@ -1477,17 +1484,7 @@ void VG_(addr_load_di)( Addr a ) di = VG_(find_DebugInfo)(VG_(current_DiEpoch)(), a); if (di != NULL) - if (di->deferred) { - di->deferred = False; - ML_(read_elf_debug) (di); - ML_(canonicaliseTables)( di ); - - /* Check invariants listed in - Comment_on_IMPORTANT_REPRESENTATIONAL_INVARIANTS in - priv_storage.h. */ - check_CFSI_related_invariants(di); - ML_(finish_CFSI_arrays)(di); - } + VG_(di_load_di)(di); } /* Unmap is simpler - throw away any SegInfos intersecting diff --git a/coregrind/m_redir.c b/coregrind/m_redir.c index 37c67f4c13..cef241b4f8 100644 --- a/coregrind/m_redir.c +++ b/coregrind/m_redir.c @@ -255,7 +255,7 @@ typedef typedef struct _TopSpec { struct _TopSpec* next; /* linked list */ - const DebugInfo* seginfo; /* symbols etc */ + DebugInfo* seginfo; /* symbols etc */ Spec* specs; /* specs pulled out of seginfo */ Bool mark; /* transient temporary used during deletion */ } @@ -312,7 +312,7 @@ static void show_active ( const HChar* left, const Active* act ); static void handle_maybe_load_notifier( const HChar* soname, const HChar* symbol, Addr addr ); -static void handle_require_text_symbols ( const DebugInfo* ); +static void handle_require_text_symbols ( DebugInfo* ); /*------------------------------------------------------------*/ /*--- NOTIFICATIONS ---*/ @@ -324,7 +324,7 @@ void generate_and_add_actives ( Spec* specs, TopSpec* parent_spec, /* debuginfo and the owning TopSpec */ - const DebugInfo* di, + DebugInfo* di, TopSpec* parent_sym ); @@ -385,7 +385,7 @@ static HChar const* advance_to_comma ( HChar const* c ) { topspecs list, and (2) figure out what new binding are now active, and, as a result, add them to the actives mapping. */ -void VG_(redir_notify_new_DebugInfo)( const DebugInfo* newdi ) +void VG_(redir_notify_new_DebugInfo)( DebugInfo* newdi ) { Bool ok, isWrap, isGlobal; Int i, nsyms, becTag, becPrio; @@ -421,6 +421,12 @@ void VG_(redir_notify_new_DebugInfo)( const DebugInfo* newdi ) newdi_soname = VG_(DebugInfo_get_soname)(newdi); vg_assert(newdi_soname != NULL); + /* libc is special, because it contains some of the core redirects. + Make sure it is fully loaded. */ + if (0 == VG_(strcmp)(newdi_soname, libc_soname) || + 0 == VG_(strcmp)(newdi_soname, pthread_soname)) + VG_(di_load_di)(newdi); + #ifdef ENABLE_INNER { /* When an outer Valgrind is executing an inner Valgrind, the @@ -814,7 +820,7 @@ void generate_and_add_actives ( Spec* specs, TopSpec* parent_spec, /* seginfo and the owning TopSpec */ - const DebugInfo* di, + DebugInfo* di, TopSpec* parent_sym ) { @@ -846,6 +852,11 @@ void generate_and_add_actives ( sp->mark = VG_(string_match)( sp->from_sopatt, soname ); anyMark = anyMark || sp->mark; + + /* The symtab might be in a separate debuginfo file. Make sure the + debuginfo is fully loaded. */ + if (sp->mark && sp->mandatory) + VG_(di_load_di)(di); } /* shortcut: if none of the sonames match, there will be no bindings. */ @@ -1792,7 +1803,7 @@ void handle_maybe_load_notifier( const HChar* soname, symbols that satisfy any --require-text-symbol= specifications that apply to it, and abort the run with an error message if not. */ -static void handle_require_text_symbols ( const DebugInfo* di ) +static void handle_require_text_symbols ( DebugInfo* di ) { /* First thing to do is figure out which, if any, --require-text-symbol specification strings apply to this diff --git a/coregrind/pub_core_debuginfo.h b/coregrind/pub_core_debuginfo.h index 6e93bb93c5..4d6ebda816 100644 --- a/coregrind/pub_core_debuginfo.h +++ b/coregrind/pub_core_debuginfo.h @@ -78,6 +78,8 @@ extern void VG_(di_notify_vm_protect)( Addr a, SizeT len, UInt prot ); extern void VG_(addr_load_di)( Addr a ); +extern void VG_(di_load_di)( DebugInfo *di ); + extern void VG_(load_di)( DebugInfo *di, Addr a ); extern void VG_(di_discard_ALL_debuginfo)( void ); diff --git a/coregrind/pub_core_redir.h b/coregrind/pub_core_redir.h index b88ca98f92..0cf0b009ea 100644 --- a/coregrind/pub_core_redir.h +++ b/coregrind/pub_core_redir.h @@ -61,7 +61,7 @@ //-------------------------------------------------------------------- /* Notify the module of a new DebugInfo (called from m_debuginfo). */ -extern void VG_(redir_notify_new_DebugInfo)( const DebugInfo* ); +extern void VG_(redir_notify_new_DebugInfo)( DebugInfo* ); /* Notify the module of the disappearance of a DebugInfo (also called from m_debuginfo). */ |
|
From: Mark W. <ma...@so...> - 2023-09-02 00:03:46
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=a01d8e01fceb9e8e1c5fba67d9322fb2c45e9c83 commit a01d8e01fceb9e8e1c5fba67d9322fb2c45e9c83 Author: Aaron Merey <am...@re...> Date: Wed Aug 30 14:49:09 2023 -0400 Fix lazy debuginfo loading on ppc64le Lazy debuginfo loading introduced in commit 60f7e89ba32 assumed that either describe_IP or find_DiCfSI will be called before stacktrace printing. describe_IP and find_DiCfSI cause debuginfo to be lazily loaded before symtab lookup occurs during stacktraces. However this assumption does not hold true on ppc64le, resulting in debuginfo failing to load in time for stacktraces. Fix this by loading debuginfo during get_StackTrace_wrk on ppc arches. Diff: --- coregrind/m_stacktrace.c | 3 +++ 1 file changed, 3 insertions(+) diff --git a/coregrind/m_stacktrace.c b/coregrind/m_stacktrace.c index 308bebdd86..0ec6f5993a 100644 --- a/coregrind/m_stacktrace.c +++ b/coregrind/m_stacktrace.c @@ -772,6 +772,8 @@ UInt VG_(get_StackTrace_wrk) ( ThreadId tid_if_known, # endif Addr fp_min = sp - VG_STACK_REDZONE_SZB; + VG_(addr_load_di)(ip); + /* Snaffle IPs from the client's stack into ips[0 .. max_n_ips-1], stopping when the trail goes cold, which we guess to be when FP is not a reasonable stack location. */ @@ -913,6 +915,7 @@ UInt VG_(get_StackTrace_wrk) ( ThreadId tid_if_known, play safe, a la x86/amd64 above. See extensive comments above. */ RECURSIVE_MERGE(cmrf,ips,i); + VG_(addr_load_di)(ip); continue; } |
|
From: Philippe W. <phi...@so...> - 2023-09-01 19:05:46
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=c0b2c786d38002a20f845a9fb739b8659fa87bcc commit c0b2c786d38002a20f845a9fb739b8659fa87bcc Author: Philippe Waroquiers <phi...@sk...> Date: Fri Sep 1 20:23:46 2023 +0200 Fix 473944 Handle mold linker split RW PT_LOAD segments correctly Condition to consider segments will be merged has to be more specific than just having a page rounded file offset p_offset. Regtested on debian, somewhat poorly due to the amount of tests failing due to: 473745 must-be-redirected function - strlen - for valgrind 3.22 but not 3.21 Diff: --- NEWS | 3 +- coregrind/m_debuginfo/readelf.c | 72 ++++++++++++++++++++++++++++++++--------- 2 files changed, 59 insertions(+), 16 deletions(-) diff --git a/NEWS b/NEWS index 519ed664c1..6f13d53569 100644 --- a/NEWS +++ b/NEWS @@ -12,7 +12,7 @@ AMD64/macOS 10.13 and nanoMIPS/Linux. * A new configure option --with-gdbscripts-dir lets you install the gdb valgrind python monitor scripts in a specific location. - For example an distro could use it to install the scripts in a + For example a distro could use it to install the scripts in a safe load location --with-gdbscripts-dir=%{_datadir}/gdb/auto-load It is also possible to configure --without-gdb-scripts-dir so no .debug_gdb_scripts section is added to the vgpreload library and @@ -53,6 +53,7 @@ are not entered into bugzilla tend to get forgotten about or ignored. 473604 Fix bug472219.c compile failure with Clang 16 473677 make check compile failure with Clang 16 based on GCC 13.x 473870 FreeBSD 14 applications fail early at startup +473944 Handle mold linker split RW PT_LOAD segments correctly n-i-bz Allow arguments with spaces in .valgrindrc files To see details of a given bug, visit diff --git a/coregrind/m_debuginfo/readelf.c b/coregrind/m_debuginfo/readelf.c index ac72f98fb5..a4c79efd0f 100644 --- a/coregrind/m_debuginfo/readelf.c +++ b/coregrind/m_debuginfo/readelf.c @@ -32,6 +32,7 @@ #include "pub_core_basics.h" #include "pub_core_vki.h" #include "pub_core_vkiscnums.h" +#include "pub_core_debuglog.h" #include "pub_core_debuginfo.h" #include "pub_core_libcbase.h" #include "pub_core_libcprint.h" @@ -3793,6 +3794,7 @@ Bool ML_(check_elf_and_get_rw_loads) ( Int fd, const HChar* filename, Int * rw_l DiOffT phdr_mioff = 0; UWord phdr_mnent = 0U; UWord phdr_ment_szB = 0U; + ElfXX_Phdr previous_rw_a_phdr; res = False; @@ -3830,6 +3832,9 @@ Bool ML_(check_elf_and_get_rw_loads) ( Int fd, const HChar* filename, Int * rw_l phdr_mnent = ehdr_m.e_phnum; phdr_ment_szB = ehdr_m.e_phentsize; + /* Sets p_memsz to 0 to indicate we have not yet a previous a_phdr. */ + previous_rw_a_phdr.p_memsz = 0; + for (i = 0U; i < phdr_mnent; i++) { ElfXX_Phdr a_phdr; ML_(img_get)(&a_phdr, mimg, @@ -3841,22 +3846,59 @@ Bool ML_(check_elf_and_get_rw_loads) ( Int fd, const HChar* filename, Int * rw_l if (((a_phdr.p_flags & (PF_R | PF_W)) == (PF_R | PF_W)) && ((a_phdr.p_flags & flag_x) == 0)) { ++*rw_load_count; - } + if (VG_(debugLog_getLevel)() > 1) + VG_(message)(Vg_DebugMsg, "check_elf_and_get_rw_loads: " + "++*rw_load_count to %d for %s " + "p_vaddr %#lx p_offset %lu, p_filesz %lu\n", + *rw_load_count, filename, + (UWord)a_phdr.p_vaddr, (UWord)a_phdr.p_offset, + (UWord)a_phdr.p_filesz); + /* + * Hold your horses + * Just because The ELF file contains 2 RW PT_LOAD segments + * doesn't mean that Valgrind will also make 2 calls to + * VG_(di_notify_mmap): in some cases, the 2 NSegments will get + * merged and VG_(di_notify_mmap) only gets called once. + * How to detect that the segments will be merged ? + * Logically, they will be merged if the first segment ends + * at the beginning of the second segment: + * Seg1 virtual address + Seg1 segment_size + * == Seg2 virtual address. + * However, it is not very clear how the file section will be + * loaded: the PT_LOAD specifies a file size and a memory size. + * Logically, the memory size should be used in the above + * condition, but strangely enough, in some cases the file size + * can be smaller than the memory size. And that then result in + * an "anonymous" mapping done between the 2 segments that + * otherwise would be consecutive. + * This has been seen in an executable linked by the mold linker + * (see bug 473944). In this case, the file segments were loaded + * with a "page rounded up" file size (observed on RHEL 8.6, + * ld-2.28.so, mold 1.5.1). + * However, in FreeBSD with lld (see 452802 and 473944), rounding + * up p_filesz in the below condition makes at least one test + * fail. + * As on the mold case, the below condition correctly ensures + * the 2 different segments loaded separately are both counted + * here, we use the non rounded up p_filesz. + * This is all a nightmare/hack. Something cleaner should be + * done than trying to guess here if segments will or will not + * be merged later depending on how the loader will load + * with or without rounding up. + * */ + if (previous_rw_a_phdr.p_memsz > 0 && + ehdr_m.e_type == ET_EXEC && + previous_rw_a_phdr.p_vaddr + previous_rw_a_phdr.p_filesz + == a_phdr.p_vaddr) + { + --*rw_load_count; + if (VG_(debugLog_getLevel)() > 1) + VG_(message)(Vg_DebugMsg, "check_elf_and_get_rw_loads: " + " --*rw_load_count to %d for %s\n", + *rw_load_count, filename); + } - /* - * Hold your horses - * Just because The ELF file contains 2 RW PT_LOAD segments it - * doesn't mean that Valgrind will also make 2 calls to - * VG_(di_notify_mmap). If the stars are all aligned - * (which usually means that the ELF file is the client - * executable with the segment offset for the - * second PT_LOAD falls exactly on 0x1000) then the NSegements - * will get merged and VG_(di_notify_mmap) only gets called once. */ - if (*rw_load_count == 2 && - ehdr_m.e_type == ET_EXEC && - a_phdr.p_offset == VG_PGROUNDDN(a_phdr.p_offset) ) - { - *rw_load_count = 1; + previous_rw_a_phdr = a_phdr; } } } |
|
From: Carl L. <ce...@us...> - 2023-09-01 18:59:57
|
Mark: On Fri, 2023-09-01 at 16:21 +0200, Mark Wielaard wrote: > Hi Carl, > > On Thu, 2023-08-31 at 15:38 -0700, Carl Love wrote: > > So, I then tried to run the same test on a Power 8LE system Ubuntu > > 20.04.5 LTS (Focal Fossa). I get: > > > > valgrind --tool=memcheck -q ./memcheck/tests/doublefree > out- > > current > > > > valgrind: Fatal error at startup: a function redirection > > valgrind: which is mandatory for this platform-tool combination > > valgrind: cannot be set up. Details of the redirection are: > > valgrind: > > valgrind: A must-be-redirected function > > valgrind: whose name matches the pattern: strlen > > valgrind: in an object with soname matching: ld64.so.2 > > valgrind: was not found whilst processing > > valgrind: symbols from the object with soname: ld64.so.2 > > valgrind: > > valgrind: Possible fixes: (1, short term): install glibc's > > debuginfo > > valgrind: package on this machine. (2, longer term): ask the > > packagers > > valgrind: for your Linux distribution to please in future ship a > > non- > > valgrind: stripped ld.so (or whatever the dynamic linker .so is > > called) > > valgrind: that exports the above-named function using the standard > > valgrind: calling conventions for this platform. The package you > > need > > valgrind: to install for fix (1) is called > > valgrind: > > valgrind: On Debian, Ubuntu: libc6-dbg > > valgrind: On SuSE, openSuSE, Fedora, RHEL: glibc-debuginfo > > valgrind: > > valgrind: Note that if you are debugging a 32 bit process on a > > valgrind: 64 bit system, you will need a corresponding 32 bit > > debuginfo > > valgrind: package (e.g. libc6-dbg:i386). > > valgrind: > > valgrind: Cannot continue -- exiting now. Sorry. > > > > > > When I put in my print statements, I see the call to > > read_elf_symtab__normal instead of read_elf_symtab__ppc64be_linux > > as > > expected. It appears that some of the image file is read as I see a > > second call to di_notify_ACHIEVE_ACCEPT_STATE, read_elf_object > > which I > > don't see on the BE system before the run fails. > > So the above is indeed not architecture, but Debian/Ubuntu specific. > It is tracked as > https://bugs.kde.org/show_bug.cgi?id=473745 > > > It is because the ld.so symtab is in a separate dbg package, which > (now) isn't loaded early anymore when resolving the hardwired > redirects. It doesn't happen on other distros because they keep > symtab > in ld.so. I added the attached patch and tested on the four different platforms. The git tree for all four systems was: commit 053cf5ff31e4a2d65726af431824bf30172d21ed (HEAD -> master) Author: Mark Wielaard <ma...@kl...> Date: Fri Sep 1 19:10:17 2023 +0200 Explicitly load libc and any sonames that contain mandatory specs https://bugs.kde.org/show_bug.cgi?id=473745 commit d76ddc0981862bde160a92baf362d3baf2633368 Author: Aaron Merey <am...@re...> Date: Wed Aug 30 14:49:09 2023 -0400 Fix lazy debuginfo loading on ppc64le Lazy debuginfo loading introduced in commit 60f7e89ba32 assumed that either describe_IP or find_DiCfSI will be called before stacktrace printing. describe_IP and find_DiCfSI cause debuginfo to be lazily loaded before symtab lookup occurs during stacktraces. However this assumption does not hold true on ppc64le, resulting in debuginfo failing to load in time for stacktraces. Fix this by loading debuginfo during get_StackTrace_wrk on ppc arches. commit c934430d56c2add25002ea8e321bd8bdab80fc99 (origin/master, origin/HEAD) Author: Paul Floyd <pj...@wa...> Date: Thu Aug 31 15:32:21 2023 +0200 Bug 473870 - FreeBSD 14 applications fail early at startup FreeBSD recently started adding some functions using @gnu_indirect_function, specifically strpcmp which was causing this crash. When running and encountering this ifunc Valgrind looked for the ifunc_handler. But there wasn't one for FreeBSD so Valgrind asserted. The test results are: machine pre-lazy-load current mainline with ppc debuginfo fix with Explicitly-load- (as of 8/31/2023) libc-and-any-sonames Power 8 LE Red Hat Enterprise Linux Server 7.9 (Maipo) 707 tests, 708 tests, 708 tests 708 tests, 4 stderr failures, 280 stderr failures, 247 stderr failures, 4 stderr failures, 0 stdout failures, 54 stdout failures, 54 stdout failures, 0 stdout failures, 13 stderrB failures, 16 stderrB failures, 16 stderrB failures, 13 stderrB failures, 0 stdoutB failures, 11 stdoutB failures, 12 stdoutB failures 0 stdoutB failures 9 post failures 13 post failures 9 post failures 9 post failures Power 8 BE Ubuntu 20.04.5 LTS (Focal Fossa) 742 tests, 743 tests, 743 tests, 743 tests, 2 stderr failures, 671 stderr failures, 671 stderr failures, 671 stderr failures 0 stdout failures, 152 stdout failures, 152 stdout failures, 152 stdout failures, 0 stderrB failures, 14 stderrB failures, 14 stderrB failures, 14 stderrB failures, 2 stdoutB failures, 20 stdoutB failures, 20 stdoutB failures, 20 stdoutB failures, 9 post failures 43 post failures 43 post failures 43 post failures Power 9 LE Ubuntu 20.04.5 LTS (Focal Fossa) 711 tests, 712 tests, 712 tests, 712 tests, 4 stderr failures, 280 stderr failures, 247 stderr failures, 4 stderr failures, 0 stdout failures, 54 stdout failures, 54 stdout failures, 0 stdout failures, 13 stderrB failures, 16 stderrB failures, 16 stderrB failures, 13 stderrB failures, 0 stdoutB failures, 12 stdoutB failures, 12 stdoutB failures 0 stdoutB failures, 9 post failures 13 post failures 9 post failures 9 post failures Power 10 LE Red Hat Enterprise Linux 9.0 (Plow) 719 tests 720 tests, 720 tests, 720 tests, 2 stderr failures, 42 stderr failures, 2 stderr failures, 2 stderr failures, 0 stdout failures, 0 stdout failures, 0 stdout failures, 0 stdout failures, 2 stderrB failures, 2 stderrB failures, 2 stderrB failures, 2 stderrB failures, 10 stdoutB failures, 10 stdoutB failures, 10 stdoutB failures, 10 stdoutB failures 0 post failures 3 post failures 0 post failures 0 post failures The Explicitly-load-libc-and-any-sonames-that-contain-ma.patch seems to fix the issues across the various OS distributions for the LE machines. It does appear that there is a separate issue with the original patch to lazily load the debug info on PowerPC BE. Hopefully we can sort that issue out when Aaron gets back from vacation. Thanks for your help with the latest patch. Carl |
|
From: Mark W. <ma...@kl...> - 2023-09-01 17:47:42
|
On Fri, 2023-09-01 at 16:21 +0200, Mark Wielaard wrote: > So the above is indeed not architecture, but Debian/Ubuntu specific. > It is tracked as https://bugs.kde.org/show_bug.cgi?id=473745 > > It is because the ld.so symtab is in a separate dbg package, which > (now) isn't loaded early anymore when resolving the hardwired > redirects. It doesn't happen on other distros because they keep symtab > in ld.so. I have attached a patch that seems to work for me. |
|
From: Mark W. <ma...@kl...> - 2023-09-01 14:21:34
|
Hi Carl, On Thu, 2023-08-31 at 15:38 -0700, Carl Love wrote: > So, I then tried to run the same test on a Power 8LE system Ubuntu > 20.04.5 LTS (Focal Fossa). I get: > > valgrind --tool=memcheck -q ./memcheck/tests/doublefree > out- > current > > valgrind: Fatal error at startup: a function redirection > valgrind: which is mandatory for this platform-tool combination > valgrind: cannot be set up. Details of the redirection are: > valgrind: > valgrind: A must-be-redirected function > valgrind: whose name matches the pattern: strlen > valgrind: in an object with soname matching: ld64.so.2 > valgrind: was not found whilst processing > valgrind: symbols from the object with soname: ld64.so.2 > valgrind: > valgrind: Possible fixes: (1, short term): install glibc's debuginfo > valgrind: package on this machine. (2, longer term): ask the > packagers > valgrind: for your Linux distribution to please in future ship a non- > valgrind: stripped ld.so (or whatever the dynamic linker .so is > called) > valgrind: that exports the above-named function using the standard > valgrind: calling conventions for this platform. The package you need > valgrind: to install for fix (1) is called > valgrind: > valgrind: On Debian, Ubuntu: libc6-dbg > valgrind: On SuSE, openSuSE, Fedora, RHEL: glibc-debuginfo > valgrind: > valgrind: Note that if you are debugging a 32 bit process on a > valgrind: 64 bit system, you will need a corresponding 32 bit > debuginfo > valgrind: package (e.g. libc6-dbg:i386). > valgrind: > valgrind: Cannot continue -- exiting now. Sorry. > > > When I put in my print statements, I see the call to > read_elf_symtab__normal instead of read_elf_symtab__ppc64be_linux as > expected. It appears that some of the image file is read as I see a > second call to di_notify_ACHIEVE_ACCEPT_STATE, read_elf_object which I > don't see on the BE system before the run fails. So the above is indeed not architecture, but Debian/Ubuntu specific. It is tracked as https://bugs.kde.org/show_bug.cgi?id=473745 It is because the ld.so symtab is in a separate dbg package, which (now) isn't loaded early anymore when resolving the hardwired redirects. It doesn't happen on other distros because they keep symtab in ld.so. Cheers, Mark |
|
From: Paul F. <pa...@so...> - 2023-09-01 06:26:48
|
https://sourceware.org/git/gitweb.cgi?p=valgrind.git;h=8a545a3684024f4a54bb20b7ad1d0fe9949bbede commit 8a545a3684024f4a54bb20b7ad1d0fe9949bbede Author: Paul Floyd <pj...@wa...> Date: Fri Sep 1 08:26:24 2023 +0200 FreeBSD: add common failure causes to README.freebsd Also fix the name of one of the fields of vki_kinfo_vmentry. Diff: --- README.freebsd | 15 ++++++++++++++- coregrind/m_aspacemgr/aspacemgr-linux.c | 2 +- include/vki/vki-freebsd.h | 2 +- 3 files changed, 16 insertions(+), 3 deletions(-) diff --git a/README.freebsd b/README.freebsd index eb6a510ada..ce1e435f5d 100644 --- a/README.freebsd +++ b/README.freebsd @@ -130,7 +130,20 @@ These are much easier. They just contain a POST_MEM_WRITE macro for each output argument. -1. Running regression tests +1. Frequent causes of problems + +- New _umtx_op codes. Valgrind will print "WARNING: _umtx_op unsupported value". + See syswrap-freebsd.c and add new cases for the new codes. +- Additions to auxv. Depending on the entry it may need to be simply copied + from the host to the guest, it may need to be modified for the guest or + it may need to be ignored. See initimg-freebsd.c. +- ELF PT_LOAD mappings. Either Valgrind will assert or there will be no source + information in error reports. See VG_(di_notify_mmap) in debuginfo.c +- Because they contain many deliberate errors the regression tests are prone + to change with changes of compiler. Liberal use of 'volatile' and + '-Wno-warning-flag' can help - see configure.ac + +2. Running regression tests In order to run all of the regression tests you will need to install the following packages diff --git a/coregrind/m_aspacemgr/aspacemgr-linux.c b/coregrind/m_aspacemgr/aspacemgr-linux.c index ae38d8bd05..ba8964928e 100644 --- a/coregrind/m_aspacemgr/aspacemgr-linux.c +++ b/coregrind/m_aspacemgr/aspacemgr-linux.c @@ -3943,7 +3943,7 @@ static void parse_procselfmaps ( endPlusOne = (UWord)kve->kve_end; foffset = kve->kve_offset; filename = kve->kve_path; - dev = kve->kve_fsid_freebsd11; + dev = kve->kve_vn_fsid_freebsd11; ino = kve->kve_fileid; if (filename[0] != '/') { filename = NULL; diff --git a/include/vki/vki-freebsd.h b/include/vki/vki-freebsd.h index 92ca8a6878..b30b2933ec 100644 --- a/include/vki/vki-freebsd.h +++ b/include/vki/vki-freebsd.h @@ -2170,7 +2170,7 @@ struct vki_kinfo_vmentry { ULong kve_end; ULong kve_offset; ULong kve_fileid; - UInt kve_fsid_freebsd11; + UInt kve_vn_fsid_freebsd11; int kve_flags; int kve_resident; int kve_private_resident; |
|
From: Carl L. <ce...@us...> - 2023-08-31 22:38:32
|
On Thu, 2023-08-31 at 10:31 -0700, Carl Love wrote:
> Mark, Aaron:
>
> So, I tried running the doublefree test by hand with the intention of
> then adding some debug prints to see which routines were being
> called.
> I am seeing the following:
>
> valgrind --tool=memcheck -q ./memcheck/tests/doublefree > out-
> current
>
> valgrind: m_debuginfo/image.c:1106 (vgModuleLocal_img_valid):
> Assertion 'img != NULL' failed.
> Segmentation fault
>
> I rolled back the git tree to the commit prior to the initial patch
> to
> do the lazy load,
>
> commit 6ce0979884a8f246c80a098333ceef1a7b7f694d
> Author: Paul Floyd <pj...@wa...>
> Date: Mon Jul 24 22:06:00 2023 +0200
>
> Bug 472219 - Syscall param ppoll(ufds.events) points to
> uninitialised byte(s
>
> Add checks that (p)poll fd is not negative. If it is negative,
> don't check
> the events field.
>
> I re-compliled, re-installed and tested again and get:
>
> valgrind --tool=memcheck -q ./memcheck/tests/doublefree > out-
> current
> ==124807== Invalid free() / delete / delete[] / realloc()
> ==124807== at 0x409B680: free (vg_replace_malloc.c:974)
> ==124807== by 0x1000063B: main (doublefree.c:10)
> ==124807== Address 0x42f0040 is 0 bytes inside a block of size 177
> free'd
> ==124807== at 0x409B680: free (vg_replace_malloc.c:974)
> ==124807== by 0x1000063B: main (doublefree.c:10)
> ==124807== Block was alloc'd at
> ==124807== at 0x409858C: malloc (vg_replace_malloc.c:431)
> ==124807== by 0x1000061B: main (doublefree.c:8)
> ==124807==
>
> So it seems with the initial patch and the PPC patch we are hitting
> an
> assertion issue. I will try and pursue a bit more.
The system I was testing on is Power 8 BE
system is Red Hat Enterprise Linux Server 7.9 (Maipo)
The assertion is in function ML_(img_valid), file
coregrind/m_debuginfo/image.c. I put a print statement in before each
of the 18 calls to determine which of the calls fails. The failure is
in readelf.c, line ~ 609
Bool get_elf_symbol_info (... )
{
...
/* Now we want to know what's at that offset in the .opd
section. We can't look in the running image since it won't
necessarily have been mapped. But we can consult the oimage.
opd_img is the start address of the .opd in the oimage.
Hence: */
ULong fn_descr[2]; /* is actually 3 words, but we need only 2 */
VG_(printf)("CARLL, img_valid 2\n");
if (!ML_(img_valid)(escn_opd->img, escn_opd->ioff + offset_in_opd,
sizeof(fn_descr))) {
if (TRACE_SYMTAB_ENABLED) {
HChar* sym_name = ML_(img_strdup)(escn_strtab->img,
"di.gesi.6b", sym_name_ioff);
TRACE_SYMTAB(" ignore -- invalid OPD fn_descr offset: %s\n",
sym_name);
if (sym_name) ML_(dinfo_free)(sym_name);
}
return False;
}
...
The function is called from
static
__attribute__((unused)) /* not referred to on all targets */
void read_elf_symtab__ppc64be_linux(
struct _DebugInfo* di, const HChar* tab_name,
DiSlice* escn_symtab,
DiSlice* escn_strtab,
DiSlice* escn_opd, /* ppc64be-linux only */
Bool symtab_in_debug
)
{
...
}
in the same file. There is an #if def to select which of the two calls
to make
# if defined(VGP_ppc64be_linux)
read_elf_symtab = read_elf_symtab__ppc64be_linux;
# else
read_elf_symtab = read_elf_symtab__normal;
# endif
in function read_elf_object. Which is called from
di_notify_ACHIEVE_ACCEPT_STATE in debuginfo.c.
I believe we need to call read_elf_debug to actually load the image. I
am not seeing any calls to read_elf_debug. It is called in load_di,
addr_load_di and load_all_debuginfo. I don't see any of these
functions getting called. describe_IP calls load_di or addr_load_di;
find_DiCfSI will call load_di. Again, I don't see describe_IP or
find_DiCfSI being called.
----------------------------------------
So, I then tried to run the same test on a Power 8LE system Ubuntu
20.04.5 LTS (Focal Fossa). I get:
valgrind --tool=memcheck -q ./memcheck/tests/doublefree > out-
current
valgrind: Fatal error at startup: a function redirection
valgrind: which is mandatory for this platform-tool combination
valgrind: cannot be set up. Details of the redirection are:
valgrind:
valgrind: A must-be-redirected function
valgrind: whose name matches the pattern: strlen
valgrind: in an object with soname matching: ld64.so.2
valgrind: was not found whilst processing
valgrind: symbols from the object with soname: ld64.so.2
valgrind:
valgrind: Possible fixes: (1, short term): install glibc's debuginfo
valgrind: package on this machine. (2, longer term): ask the
packagers
valgrind: for your Linux distribution to please in future ship a non-
valgrind: stripped ld.so (or whatever the dynamic linker .so is
called)
valgrind: that exports the above-named function using the standard
valgrind: calling conventions for this platform. The package you need
valgrind: to install for fix (1) is called
valgrind:
valgrind: On Debian, Ubuntu: libc6-dbg
valgrind: On SuSE, openSuSE, Fedora, RHEL: glibc-debuginfo
valgrind:
valgrind: Note that if you are debugging a 32 bit process on a
valgrind: 64 bit system, you will need a corresponding 32 bit
debuginfo
valgrind: package (e.g. libc6-dbg:i386).
valgrind:
valgrind: Cannot continue -- exiting now. Sorry.
When I put in my print statements, I see the call to
read_elf_symtab__normal instead of read_elf_symtab__ppc64be_linux as
expected. It appears that some of the image file is read as I see a
second call to di_notify_ACHIEVE_ACCEPT_STATE, read_elf_object which I
don't see on the BE system before the run fails.
Carl
|
|
From: Carl L. <ce...@us...> - 2023-08-31 22:38:31
|
Aaron, Mark:
On Wed, 2023-08-30 at 15:48 -0700, Carl Love wrote:
> Thanks for taking a look at the issue. I tested the patch an a variety
> of machines and get mixed results. Here is what I am seeing before the
> commit to add the lazy loading, with the current Valgrind mainline
> (includes the lazy commit) and with the patch to fix the lazy load on
> Power:
>
> machine pre-lazy-load current mainline with ppc debuginfo fix
> Power 8 LE 707 tests, 708 tests, 708 tests
> 4 stderr failures, 280 stderr failures, 247 stderr failures,
> 0 stdout failures, 54 stdout failures, 54 stdout failures,
> 13 stderrB failures, 16 stderrB failures, 16 stderrB failures,
> 0 stdoutB failures, 11 stdoutB failures, 12 stdoutB failures
> 9 post failures 13 post failures 9 post failures
>
> Power 8 BE 742 tests, 743 tests, 743 tests,
> 2 stderr failures, 671 stderr failures, 671 stderr failures,
> 0 stdout failures, 152 stdout failures, 152 stdout failures,
> 0 stderrB failures, 14 stderrB failures, 14 stderrB failures,
> 2 stdoutB failures, 20 stdoutB failures, 20 stdoutB failures,
> 9 post failures 43 post failures 43 post failures
>
> Power 9 LE 711 tests, 712 tests, 712 tests,
> 4 stderr failures, 280 stderr failures, 247 stderr failures,
> 0 stdout failures, 54 stdout failures, 54 stdout failures,
> 13 stderrB failures, 16 stderrB failures, 16 stderrB failures,
> 0 stdoutB failures, 12 stdoutB failures, 12 stdoutB failures
> 9 post failures 13 post failures 9 post failures
>
> Power 10 LE 719 tests 720 tests, 720 tests,
> 2 stderr failures, 42 stderr failures, 2 stderr failures,
> 0 stdout failures, 0 stdout failures, 0 stdout failures,
> 2 stderrB failures, 2 stderrB failures, 2 stderrB failures,
> 10 stdoutB failures, 10 stdoutB failures, 10 stdoutB failures,
> 0 post failures 3 post failures 0 post failures
I was thinking about what else could cause the differences in the test
results. I was wondering if the OS distribution might be an issue.
So, I tried some different OS distributions on the same hardware.
First here is the OS distribution for the above testing.
The Power 8 BE system is Red Hat Enterprise Linux Server 7.9 (Maipo)
The Power 8 LE system is Ubuntu 20.04.5 LTS (Focal Fossa)
The Power 9 LE system is Ubuntu 20.04.5 LTS (Focal Fossa)
The Power 10 LE system Red Hat Enterprise Linux 9.0 (Plow)
I did some additional testing on Power 9 LE and Power 10 LE with
different OS distributions with the PPC fix patch applied.
Power 9 LE Red Hat Enterprise Linux 8.7 (Ootpa)
== 714 tests, 4 stderr failures, 0 stdout failures, 0 stderrB failures,
0 stdoutB failures, 9 post failures ==
Power 10 LE Ubuntu 22.04.2 LTS
== 721 tests, 303 stderr failures, 62 stdout failures, 11 stderrB
failures, 14 stdoutB failures, 0 post failures ==
So, it seems that RHAT works well on Power 9 and Power 10. Ubuntu
doesn't work well on Power 10, Power 9 or Power 8. There seems to be
an OS issue, not a timing issue that is causing the differences on the
various platforms that I tested.
Carl
|
|
From: Carl L. <ce...@us...> - 2023-08-31 17:40:26
|
Mark, Aaron:
So, I tried running the doublefree test by hand with the intention of
then adding some debug prints to see which routines were being called.
I am seeing the following:
valgrind --tool=memcheck -q ./memcheck/tests/doublefree > out-
current
valgrind: m_debuginfo/image.c:1106 (vgModuleLocal_img_valid):
Assertion 'img != NULL' failed.
Segmentation fault
I rolled back the git tree to the commit prior to the initial patch to
do the lazy load,
commit 6ce0979884a8f246c80a098333ceef1a7b7f694d
Author: Paul Floyd <pj...@wa...>
Date: Mon Jul 24 22:06:00 2023 +0200
Bug 472219 - Syscall param ppoll(ufds.events) points to
uninitialised byte(s
Add checks that (p)poll fd is not negative. If it is negative,
don't check
the events field.
I re-compliled, re-installed and tested again and get:
valgrind --tool=memcheck -q ./memcheck/tests/doublefree > out-current
==124807== Invalid free() / delete / delete[] / realloc()
==124807== at 0x409B680: free (vg_replace_malloc.c:974)
==124807== by 0x1000063B: main (doublefree.c:10)
==124807== Address 0x42f0040 is 0 bytes inside a block of size 177
free'd
==124807== at 0x409B680: free (vg_replace_malloc.c:974)
==124807== by 0x1000063B: main (doublefree.c:10)
==124807== Block was alloc'd at
==124807== at 0x409858C: malloc (vg_replace_malloc.c:431)
==124807== by 0x1000061B: main (doublefree.c:8)
==124807==
So it seems with the initial patch and the PPC patch we are hitting an
assertion issue. I will try and pursue a bit more.
Carl
|
|
From: Carl L. <ce...@us...> - 2023-08-31 17:07:44
|
Mark:
On Thu, 2023-08-31 at 17:43 +0200, Mark Wielaard wrote:
> Hi,
>
> On Thu, Aug 31, 2023 at 04:14:53PM +0200, Mark Wielaard wrote:
> > It also doesn't seem to work for me on a power9 f38 system. Which
> > is
> > surprising, since theoretically I think it should work. The
> > difference between ppc64le and other architectures is that all
> > other
> > architectures use VG_(use_CF_info) for unwinding, which will
> > indirectly load the debuginfo for the pc. So explicitly loading it
> > for
> > the pc in the ppc case should have worked, but it doesn't... :{
> >
> > I'll keep poking if there is some other difference with the other
> > architectures.
>
> I take that back. I didn't apply Aaron's patch correctly (I had some
> local hacks that conflicted with the second part). With a clean
> current trunk and Aaron's patch applied the results look pretty good:
>
> == 712 tests, 4 stderr failures, 0 stdout failures, 0 stderrB
> failures, 0 stdoutB failures, 0 post failures ==
> memcheck/tests/bug340392 (stderr)
> memcheck/tests/linux/debuginfod-check (stderr)
> helgrind/tests/pth_mempcpy_false_races (stderr)
> drd/tests/std_thread2 (stderr)
>
> ...checking makefile consistency
> ...checking header files and include directives
> make: *** [Makefile:1438: regtest] Error 1
>
> I think memcheck/tests/bug340392,
> helgrind/tests/pth_mempcpy_false_races and drd/tests/std_thread2 are
> known failures.
>
> memcheck/tests/linux/debuginfod-check.stderr.diff:
>
> --- debuginfod-check.stderr.exp 2023-04-27 15:25:16.209181780 +0000
> +++ debuginfod-check.stderr.out 2023-08-31 14:21:46.438006283 +0000
> @@ -2,5 +2,5 @@
> at 0x........: main (debuginfod-check.c:5)
> Address 0x........ is 1 bytes before a block of size 1 alloc'd
> at 0x........: malloc (vg_replace_malloc.c:...)
> - by 0x........: main (debuginfod-check.c:4)
> + ...
>
> so that is interesting, have to figure out why the explicit
> debuginfod
> testcase fails. But the rest does look good with Aaron's patch
> applied.
>
> Carl, can you look if the patch applied cleanly for you?
I have test directories on each machine. I did a git pull, compiled,
ran the test, then applied the fix patch, compiled, ran tests, then I
rolled back the git repository to the commit prior to the initial
commit complied and ran the test.
I didn't see any issues when I applied the PPC fix patch.
So today, I cloned the current valgrind tree into an empty directory,
applied the PPC fix patch. The patch applied without any issues. Then
configure, compiled and installed valgrind. I reran the tests on each
platform and got identical results as I posted yesterday. Looking at
the variability in the results before and after the PPC fix patch just
makes me wonder if there is a timing issue given what the patch did??
Valgrind is a single threaded program as far as I know so I am puzzled
how it could be a timing issue. I have tried running the tests
multiple times on the various platforms and always get consistent
results.
I will see if I can play around with the patch some today to see if I
can find anything.
Carl
|
|
From: Mark W. <ma...@kl...> - 2023-08-31 15:43:37
|
Hi,
On Thu, Aug 31, 2023 at 04:14:53PM +0200, Mark Wielaard wrote:
> It also doesn't seem to work for me on a power9 f38 system. Which is
> surprising, since theoretically I think it should work. The
> difference between ppc64le and other architectures is that all other
> architectures use VG_(use_CF_info) for unwinding, which will
> indirectly load the debuginfo for the pc. So explicitly loading it for
> the pc in the ppc case should have worked, but it doesn't... :{
>
> I'll keep poking if there is some other difference with the other
> architectures.
I take that back. I didn't apply Aaron's patch correctly (I had some
local hacks that conflicted with the second part). With a clean
current trunk and Aaron's patch applied the results look pretty good:
== 712 tests, 4 stderr failures, 0 stdout failures, 0 stderrB failures, 0 stdoutB failures, 0 post failures ==
memcheck/tests/bug340392 (stderr)
memcheck/tests/linux/debuginfod-check (stderr)
helgrind/tests/pth_mempcpy_false_races (stderr)
drd/tests/std_thread2 (stderr)
...checking makefile consistency
...checking header files and include directives
make: *** [Makefile:1438: regtest] Error 1
I think memcheck/tests/bug340392,
helgrind/tests/pth_mempcpy_false_races and drd/tests/std_thread2 are
known failures.
memcheck/tests/linux/debuginfod-check.stderr.diff:
--- debuginfod-check.stderr.exp 2023-04-27 15:25:16.209181780 +0000
+++ debuginfod-check.stderr.out 2023-08-31 14:21:46.438006283 +0000
@@ -2,5 +2,5 @@
at 0x........: main (debuginfod-check.c:5)
Address 0x........ is 1 bytes before a block of size 1 alloc'd
at 0x........: malloc (vg_replace_malloc.c:...)
- by 0x........: main (debuginfod-check.c:4)
+ ...
so that is interesting, have to figure out why the explicit debuginfod
testcase fails. But the rest does look good with Aaron's patch
applied.
Carl, can you look if the patch applied cleanly for you?
Cheers,
Mark
|
|
From: Floyd, P. <pj...@wa...> - 2023-08-31 14:50:32
|
Hi Mark On 27/08/2023 17:46, Mark Wielaard wrote: > And hopefully nightly test results and/or buildbot builders. > >> * the long running question of what to do with macOS > Any testers/developers/volunteers? One main developer but intermittent progress. Occasional other contributors After being just about totally broken on macOS versions from 10.15 onwards memcheck is now just about usable for small non-GUI applications on Intel hardware. Ongoing work on Apple's ARM architecture but I don't have an ARM mac so I can't test that. >> * memcheck aligned and sized checks plus maybe c23 free_sized and >> free_sized_aligned plus Linux aligned_alloc >> >> * detect whether a debug version of libstdc++ is being used and then >> use that to automatically turn on or off mismatch detection > That is an interesting idea. I need to do more testing to see if detecting debuginfo would be enough, or whether we also need to know if the compiler used optimization. >> And I expect the usual steady stream of smaller fixes. > On irc we also discussed having a "rolling release branch" where we > put small/essential bug fixes (some of which some distros now backport > themselves). I'd be interested in that. On FreeBSD I maintain two ports, one that is mostly stable and based on official Valgrind releases and a second one that is a bit more "rolling" (actually it doesn't roll as fast as it should lack of time etc.). That second one is based on a GH repo that shadows the sourceware repo. I'm planning to switch over to use sourceware snapshots the next time I bump that port (RSN after de-borking FreeBSD 14/15 Valgrind amd64 today). The big advantage for me is that I don't have to maintain any icky patchsets for the port. I can just fix things and push to sourceware and then base off that. Also I don't have any constraints like LTS and paying customers. Do you think it will be feasible for such release branch to satisfy most distro packagers needs? I do occasionally look to see what distros have in their patchsets - I merged one from Debian a dew days ago. A+ Paul |