Darwin: add support for setting errno from alloc wrappers

Regtest: fixes for callgrind tests referring to cachegrind reference files

cachegrind/tests/cgout-test was renamed to ann1.cgout but the
two tests in callgrind that use it weren't updated.

Commit access and try branches

Darwin: try to improve posix_memalign / zone_memalign wrapper

It still doesn't set errno though.

Darwin regtest: another test using aligned_alloc

I added this test because I wanted to check the behaviour of
aligned_alloc on current macOS, but Valgrind doesn't support it
yet.

Darwin regtest: fix building on older OS versions

aligned_alloc was added to macOS 10.15 and 10.13 is the latest
that we support.

MUSL regtest: fix a comple of build problems building regression tests on Alpine

Regtest: fix a couple of unused variable warnings

Copy & paste leftovers

Remove source file added to EXTRA_DIST in error

Add missing entries to cachegrind EXTRA_DIST

Propagate memory allocation failure to out_of_memory_NORETURN

Provide the user with a hint of what caused an out of memory error.
And explain that some memory policies, like selinux deny_execmem
might cause Permission denied errors.

Add an err argument to out_of_memory_NORETURN. And change
am_shadow_alloc to return a SysRes (all three callers were already
checking for errors and calling out_of_memory_NORETURN).

cg_annotate: use `<unspecified>` for an unspecified filename.

Users shouldn't ever see this, but it's useful to distinguish this
malformed data file case from the missing symbol case (which is still
shown as `???`).

cg_annotate.in: fix a small bug in the printing of past-the-end lines.

Fix some problems in `cachegrind/tests/Makefile.am`.

Simpler and more consistent `cachegrind/tests/*.vgtest` files.

- Always use `python3`, never `python`.
- Avoid unnecessary `../cachegrind/` in paths.

Rewrite `cg_merge` in Python.

It's currently written in C, but `cg_annotate` and `cg_diff` are written in
Python. It's better to have them all in the same language.

The good news is that the Python code is 4.5x shorter than the C code.
The bad news is that the Python code is roughly 3x slower than the C
code. But `cg_merge` isn't used that often, so I think it's a reasonable
trade-off.

Rewrite `cg_diff` in Python.

For all the same reasons I rewrote `cg_annotate` in Python.

The commit also moves the Python "build" steps into
`auxprogs/pybuild.sh`, for easy sharing.

Finally, it very slightly tweaks the whitespace in the output of
`cg_annotate`.

Rename `ann-diff` test as `ann-diff1`.

To make room for another test.

Make section formatting more consistent.

- Every section now has a heading with the long `----` lines above and
  below.
- Event names are always shown below that heading, rather than within
  it.
- Each Unreadable file now gets its own section, much like files that
  lack any data.

Rename a bunch of `cg_annotate` test files.

For more consistency.

Solaris: improve syscall trace for sysfs

More than just fix the format warning

Regtest: put back a glibc version ofr memalign_args test

I forgot that glibc aligned_alloc really is memalign, which
changes the callstack.

Regtest: add a filter for aligned alloc uninit args tests

These tests generate a varying number of errors per argument
depending on the platform and compiler.

The filter just prints the first unique error stanza which
allows 8 expecteds to be removed.

Solaris: format warnings in syswrap functions

Regtest: clean aligned alloc tests on FreeBSD x86

Add a filter for size_t (unsigned long on 64bit platforms and unsigned
int on 32bit ones).

Add another expected for x86.

Add more annotated/unannotated lines at the end.

This way, all CCs are categorised, which is useful for understanding
why thing were/weren't annotated.

Change `Threshold:` to `Thresholds:`.

Because all the thresholds other than the first one were always 100, due
to historical reasons.

Just use one decimal place for all percentages.

Simpler, shorter, and good enough in practice.

Improve formatting of percentage columns.

Currently their width is mostly hard-wired in a quick and dirty fashion.
This commit does them properly, so:
- all columns are always the right width, even ones with really large
  percentages
- things like `( 1.00%)` are now `(1.00%)`
- any percentages that would involve a division by zero now show as
  `(n/a)` rather than `( 0.00%)`

Make `cg_annotate` work with Python 3.9, by avoiding `TypeAlias`.

Make cg_annotate independent of python3 install location

cachegrind/tests/Makefile.am EXTRA_DIST add ann3.{{post,stderr}.exp,vgtest}

Rewrite `cg_annotate` in Python.

Perl was a reasonable choice for `cg_annotate` in 2002, but not in 2023.
Also, the existing structure of the code is not good. These two things
make it hard to modify `cg_annotate` in any significant way.

Benefits of the change:
- Now written in a language that is (a) nice, and (b) not moribund.
- Easier to maintain, due to (a) abovementioned better language, (b)
  better code structure, and (c) better language tooling, such as
  formatters, type checkers, and linters.
- The new version is a little shorter.
- It runs about 2x faster.
- Argument handling is more standard. E.g. things like `--context 2`,
  `--auto`, `--no-auto` are supported. (The old forms that require `=`
  are still supported, though the `=yes`/`=no` forms are deprecated.)

The behaviour and output of the new version is identical for typical
uses, but there are some very minor changes for edge cases, which nobody
is likely to notice. For example:
- The file format is slightly changed: I removed support for '.'
  counts, which had the same meaning as '0'. This was a feature that
  Cachegrind never used, and the old script handled it inconsistently.
- The new version will abort on a malformed data line. The old version
  would just print a warning and continue.

The commit also adds a new test `ann3` that tests many parts of
`cg_annotate` that weren't tested previously, and tweaks the existing
`ann2` test.

Solaris: fix build, another aligned alloc typo

Bug 467482 - Build failure on aarch64 Alpine

Patch submitted by
fanquake@gmail.com

coverity: a couple of potential buffer overruns

coverity: printf args format mismatch

coverity: copy paste error

FreeBSD: fix a syswrap compiler warning

regtest: add an s390 expected for sized_aligned_new_delete_args

doc: Add asan equivalent to --realloc-zero-bytes-frees to manual-core

Refactor: reorder a few structs to make them more compact

Used pahole to find candidates. Don't have any performance
measurements, but it won't do any harm.

regtest: update one expected after fixing realloc_size_zero_mismatch.cpp

regtest: build failure on Linux ppc64le, missing header

Bug 436413 - Warn about realloc of size zero

Adds a new warning to memcheck when realloc is used with a size of 0.
For a long time this has been "implementation defined" and so
non-portable. With C23 it will become UB.

Also adds a switch to turn off the error generation and a
second switch to select between the most common
"implementation" behaviours. The defaults for this second
switch are baked in at build time.

Rename memcheck/tests/sized_aligned_new_delete_args.stderr.exp-glibc

It's for GCC / libstdc++ really

darwin regtest: fix unused variable warning

Copied and paster from old posix_memalign test

Mised one aligned alloc wrapper on Linux

Need different expected for GCC / libstdc++

And I think that the 32bit expected will also need updating.

Malloc replacements: add some C++14/17 comments

Rearrange the code to group C++ 14 operator deeltes together.

regtest: try to fix bad merge of memalign_args expected on ppc64

regtest: update sized_aligned_new_delete_args expected

Don't quite understand how I managed to generate the original
expected.

Make operator new aligned more like the standalone versions

If the alignment is not a power of two return nullptr for the
nothrow overload and bomb for the throwing overload.

regtest: add an arm expected for memalign_args

regtest: fix warning in memalign_args and add debug info to sized_aligned_new_delete_args

auxchecks: fix building on FreeBSD

FreeBSD has a sha256sum that doesn't take long args (--check)
GNU sha256sum exists as gsha256sum so add a check for that to
configure.ac

Fix compile failure on Linux

Use SizeT rather than size_t
Also make tests quieter with -q

Add 32bit version of sized_aligned_new_delete_args expected

Asl add some parens to shut up clangd

Add checks to all new / delete overload arguments

auxchecks: use outer configure make and compilers

On FreeBSD the hard coded 'make' will switch to BSD make rather
than the outer configure make - GNU make.

Similarly for systems with gcc and clang installed then an outer
'configure CC=clang' and then make auxchecks doesn't propagate
the CC to the inner gsl configure, which will use gcc.

Still need some work on the tarball checksum calculation.

Bug 466104 - aligned_alloc problems, part 1

I think that these are all now done.
This commit refactors memalign and updates manual-core.xml
to say some behaviour of Valgrind depends on the build time
OS and libraries.

Linux musl: fix code refactor that missed one usage

Darwin regtest: again, forgot to delete errno

Setting errno on Darwin not supported on Valgrind.

Darwin regtest: remove test that aligned_alloc fails with huge alignment

Needs more debugging.

Linux musl: one more iteration for aligned_alloc, assert in wrong place

Linux musl: corrections for aligned_alloc test

Fix a compiler warning

Linux musl: alligned_alloc accepts alignment of zero

Solaris regtest: final iteration for aligned_alloc

Solaris: bump alignment to next power of two for aligned_alloc

I'm not changing the Valgrind allocator to fit Solaris, too bad.

Solaris: copy paste error in alignment check for aligned_alloc

Solaris: adapt to aligned_alloc only enforcing a multiple of 4

Make aligned_alloc behave more like the underlying platform aligned_alloc

This is the third part of
Bug 466104 aligned_alloc problems, part 1

Shouldn't affect Linux glibc.

Bug 449309 -  Missing loopback device ioctl(s)

Patch provided by:
    Faheem Sheikh <faheem.sheikh@bmw.de>

Note that the testcase provided with this report hasn't
been added as it requires privileges.

Linux PPC regtest: forgot to add the new expected

Linux PPC regtest: add a specific expected for memalign_args

The number of errors for arguments that gets triggered depends
on how GCC optimzes and generates code for the vg_replace_malloc.c
wrappers. PPC seems to trigger more than amd64.

Darwin regtest: no malloc.h header on Darwin

Typo in comment

Fix Darwin compilation

Removed memalign wrapper on Darwin, so valloc can't use it any more.

Bug 445743 - "The impossible happened: mutex is locked simultaneously by two threads" while using mutexes with priority inheritance and signals

Been using the same fix in FreeBSD for quite a while, so I think
it's safe to apply to Linux and close the bugzi item.

Remove unused helgrind expected

I don't think that this can match any more.

Change behaviour of posix_memalign for Solaris

It returns NULL and 0 status whilst most other platforms
allocatae some undefined amount of memory (which is allowed
by posix).

Update the posix_memalign test as well.

Finally remove some clang warnings about alignment.

Put back Darwin zone memalign

I had another look at the XNU source and this does seem to exist.
The manpage says that it is the zone version of posix_memalign,
though that's probably more because Darwin has no memalign.

Make memalign behave more like the underlying platform memalign

This is the first part of
Bug 466104 aligned_alloc problems, part 1

The bulk of this change is try try to get memalign to be more
platform aware. Previously the Valgrind implementation only
reflected the glibc implementation. That meant non-power of
two alignment values would silently get bumped up to the
next largest power of two. Most other platforms return NULL
and set errno to EINVAL.

There are a few other changes. A couple of the other aligned alloc
functions like valloc were caling the Valgrind memalign. This meant
that there weould be an extra Valgrind memalign in any error
callstacks. Now these functions call the allocator directly.

The memcheck memalign2 testcase has been redone. The memalign
parts moved out to per-platform versions and the tescase
itdelf renamed to posix_memalign, since that is all that is left.
I also modified the testcase so that it checks that the
memalign calls check for non-NULL returns, and on platforms
that set errno that it is correctly set. Previously the
test only worked on non-glibc because NULL & alignment is
zero.  The platform versions have been tested on glibc,
MUSL, FreeBSD and OpenIndiana and should hopefully run OK
both under memcheck and standalone.

There is stil quite a lot that is NOT done

1. I'm not certain that implementations allocate more memory
   and/or use a wider alignment. It doesn't help that almost
   universally the memalign implementations are badly
   documented, undocumented or buggy.
2. We don't handle very large alignment requests well.
   Most implementations will fail and set EINVAL if the
   alignment is over half the memory space. Valgrind will
   core panic if an aligmnt of over 16Mbytes is requested.
3. We don't generate any memcheck errors for invalid values
   of alignment. That's planned in Part 2.
4. The code is static and fixed at compile time. That means that
   if you are using MUSL with a glibc-built Valgrind you
   will still get glibc memalign behaviour.
   I'll wait to see if there are any requests before trying
   to make the behaviour selectable at runtime.

And here is the updated expected for FreeBSD scalar x86 mknodat

FreeBSD mknodat syscall dev arg is 64bits so the syscall needs splitting into amd64 and x86 versions

Small update to FreeBSD x86 scalar expected

FreeBSD: make rfork() fail more gracefully

rfork() is barely used in base FreeBSD. The main use
is in posix_spawn(). If rfork() fails with EINVAL
then it falls back to using vfork(). This is preferable
to Valgrind bombing.

ksh93 uses posix_spawn. I tested bash and csh and they had
no problems.

Also add 'hello world" smoke tests for bash csh and ksh

bug465435 - m_libcfile.c:66 (vgPlain_safe_fd): Assertion 'newfd >= VG_(fd_hard_limit)' failed.

One small typo

musl regtest : fix warnings and badly initialized struct msghdr

Try to correct configure script for warning flags with values

Some -W flags come with and without an =
(usually for warning levels)
But some only have the form -Wfoo=42 and -Wno-foo

musl: fix a couple of warnings

musl doesn't have sys/poll.h

GCC moans and then uses poll.h

On glibc linux and FreeBSD poll.h is a symlink to sys/poll.h
Illumos poll.h includes sys/poll.h

regtest: remove compiler warnings with clang

DRD aarch64: Add some suppressions for DRD libstdc++

Also fix building drd/tests/std_mutex, needs -pthread.

README_DEVELOPERS: Explain how to set VALGRIND_LIB to gdb valgrind

Darwin: try to fix assert in DRD

The hard coded memory mapping trigger drd_start_using_mem_w_perms
which will lead to tl_assert(vg_tid != VG_INVALID_THREADID);

But vg_tid was just set to VG_INVALID_THREADID before the
hard coded memory map.

Regtest: rationalize filters for new/delete

Darwin regtest: add filtering for zone functions and realloc

For test of C++17 new/delete variations

DRD regtest: try to make timed_mutex more reliable

On RHEL 7.6 ARM I see this with the lock returning false
but without the 11 second timeout. Try adding some sleeps.

DRD regtest: try to make timed_mutex more reliable

On RHEL 7.6 ARM I see this with the lock returning false
but without the 11 second timeout. Try adding some sleeps.