Replace Minumum/minumum with Minimum/minimum

Replace Minumum/minumum in comments with Minimum/minimum.

Optimize scripts/merge-test-results.sh

The inner loop is called thousands of times per "make check" even
if there's otherwise nothing to do.  Avoid calling /bin/head all
those times when a builtin will do.

Reviewed-by: Carlos O'Donell <carlos@redhat.com>

Fix GCC 11 -Warray-parameter warning for __sigsetjmp (bug 26647)

This patch fixes part of bug 26647 (-Werror=array-parameter error
building with GCC 11 because of __sigsetjmp being declared using an
array parameter in one header and a pointer parameter in another).

The fix is to split the struct __jmp_buf_tag definition out to a
separate bits/types/ header so it can be included in pthread.h, so
that pthread.h can declare __sigsetjmp with the type contents visible,
so can use an array (as in setjmp.h) rather than a pointer in the
declaration.

Note that several other build failures with GCC 11 remain.  This does
not fix the jmp_buf-related -Wstringop-overflow errors (also discussed
in bug 26647), or -Warray-parameter errors for other functions (bug
26686), or -Warray-bounds errors (bug 26687).

Tested, with older compilers, natively for x86_64 and with
build-many-glibc.py for aarch64-linux-gnu.  Tested with
build-many-glibcs.py with GCC mainline for aarch64-linux-gnu that this
gets past the -Warray-parameter issue for __sigsetjmp (with the next
build failure being the other one discussed in bug 26647).

manual: Fix typo

y2038: nptl: Convert pthread_rwlock_{clock|timed}{rd|wr}lock to support 64 bit time

The pthread_rwlock_clockrdlock, pthread_rwlock_clockwrlock,
pthread_rwlock_timedrdlock and pthread_rwlock_timedwrlock have been converted
to support 64 bit time.

This change uses new futex_abstimed_wait64 function in
./sysdeps/nptl/futex-helpers.c, which uses futex_time64 where possible.

The pthread_rwlock_{clock|timed}{rd|wr}lock only accepts absolute time.
Moreover, there is no need to check for NULL passed as *abstime pointer to the
syscalls as those calls have exported symbols marked with __nonull attribute
for abstime.

For systems with __TIMESIZE != 64 && __WORDSIZE == 32:
- Conversions between 64 bit time to 32 bit are necessary
- Redirection to pthread_rwlock_{clock|timed}{rd|wr}lock will provide support
  for 64 bit time

Build tests:
./src/scripts/build-many-glibcs.py glibcs

Run-time tests:
- Run specific tests on ARM/x86 32bit systems (qemu):
  https://github.com/lmajewski/meta-y2038 and run tests:
  https://github.com/lmajewski/y2038-tests/commits/master

Above tests were performed with Y2038 redirection applied as well as without
to test the proper usage of both __pthread_rwlock_{clock|timed}{rd|wr}lock64
and __pthread_rwlock_{clock|timed}{rd|wr}lock.

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

Y2038: nptl: Provide futex_abstimed_wait64 supporting 64 bit time

This is the helper function, which uses struct __timespec64
to provide 64 bit absolute time to futex syscalls.

The aim of this function is to move convoluted pre-processor
macro code from sysdeps/nptl/lowlevellock-futex.h to C
function in futex-internal.c

The futex_abstimed_wait64 function has been put into a separate
file on the purpose - to avoid issues apparent on the m68k
architecture related to small number of available registers (there
is not enough registers to put all necessary arguments in them if
the above function would be added to futex-internal.h with
__always_inline attribute).

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

sysvipc: Return EINVAL for invalid msgctl commands

It avoids regressions on possible future commands that might require
additional libc support.  The downside is new commands added by newer
kernels will need further glibc support.

Checked on x86_64-linux-gnu and i686-linux-gnu (Linux v4.15 and v5.4).

sysvipc: Fix IPC_INFO and MSG_INFO handling [BZ #26639]

Both commands are Linux extensions where the third argument is a
'struct msginfo' instead of 'struct msqid_ds' and its information
does not contain any time related fields (so there is no need to
extra conversion for __IPC_TIME64.

The regression testcase checks for Linux specifix SysV ipc message
control extension.  For IPC_INFO/MSG_INFO it tries to match the values
against the tunable /proc values and for MSG_STAT/MSG_STAT_ANY it
check if the create message queue is within the global list returned
by the kernel.

Checked on x86_64-linux-gnu and on i686-linux-gnu (Linux v5.4 and on
Linux v4.15).

sysvipc: Return EINVAL for invalid semctl commands

It avoids regressions on possible future commands that might require
additional libc support.  The downside is new commands added by newer
kernels will need further glibc support.

Checked on x86_64-linux-gnu and i686-linux-gnu (Linux v4.15 and v5.4).

sysvipc: Fix SEM_STAT_ANY kernel argument pass [BZ #26637]

Handle SEM_STAT_ANY the same way as SEM_STAT so that the buffer argument
of SEM_STAT_ANY is properly passed to the kernel and back.

The regression testcase checks for Linux specifix SysV ipc message
control extension.  For IPC_INFO/SEM_INFO it tries to match the values
against the tunable /proc values and for SEM_STAT/SEM_STAT_ANY it
check if the create message queue is within the global list returned
by the kernel.

Checked on x86_64-linux-gnu and on i686-linux-gnu (Linux v5.4 and on
Linux v4.15).

Co-authored-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

aarch64: enforce >=64K guard size [BZ #26691]

There are several compiler implementations that allow large stack
allocations to jump over the guard page at the end of the stack and
corrupt memory beyond that. See CVE-2017-1000364.

Compilers can emit code to probe the stack such that the guard page
cannot be skipped, but on aarch64 the probe interval is 64K by default
instead of the minimum supported page size (4K).

This patch enforces at least 64K guard on aarch64 unless the guard
is disabled by setting its size to 0.  For backward compatibility
reasons the increased guard is not reported, so it is only observable
by exhausting the address space or parsing /proc/self/maps on linux.

On other targets the patch has no effect. If the stack probe interval
is larger than a page size on a target then ARCH_MIN_GUARD_SIZE can
be defined to get large enough stack guard on libc allocated stacks.

The patch does not affect threads with user allocated stacks.

Fixes bug 26691.

sysvipc: Fix semtimedop for Linux < 5.1 for 64-bit ABI

Both powerpc64 and s390x provides semtimedop through __NR_ipc for
pre v5.1 kernel.  Neither the y2038 support (7c437d3778) nor the
attempt to fix an issue for !__ASSUME_DIRECT_SYSVIPC_SYSCALLS
(aaa12e9ff0) took this in consideration.

This patch fixes it by issuing __NR_semtimedop_time64 iff it is
defined, otherwise __NR_semtimeop is issued if both
__ASSUME_DIRECT_SYSVIPC_SYSCALLS it set and __NR_semtimedop is
define, other __NR_ipc is used instead.  To summarize:

  1. For 32-bit architetures __NR_semtimedop_time64 is always
     issued.  The fallback is used only for !__ASSUME_TIME64_SYSCALLS
     and it issues either __NR_ipc or __NR_semtimedop.

  2. For 64-bit architecture with wire-up SysV syscall
     (__ASSUME_DIRECT_SYSVIPC_SYSCALLS and __NR_semtimeop defined)
     __NR_semtimeop is issued.

  3. Otherwise __NR_ipc is used instead.

Checked on x86_64-linux-gnu, i686-linux-gnu (kernel 4.15 and 5.4),
powerpc64le (kernel 4.18), and s390x (kernel 4.12).

Reviewed-by: Matheus Castanho <msc@linux.ibm.com>

nptl: futex: Move __NR_futex_time64 alias to beginning of futex-internal.h

This alias macro shall be moved to the beginning of the futex-internal.h
to be easily reused by other functions, which would support 64 bit time.

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>
Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

nptl: Provide proper spelling for 32 bit version of futex_abstimed_wait

This change provides proper spelling of 32 bit __futex_abstimed_wait_cancelable32
function

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

string: Fix strerrorname_np return value [BZ #26555]

It returns the string of the error constant, not its description (as
strerrordesc_np).  To handle the Hurd error mapping, the ERR_MAP was
removed from errlist.h to errlist.c.

Also, the testcase test-strerr (added on 325081b9eb2) was not added
on the check build neither it builds correctly.  This patch also
changed it to decouple from errlist.h, the expected return values
are added explicitly for both both strerrorname_np and strerrordesc_np
directly.

Checked on x86_64-linux-gnu and i686-linux-gnu.  I also run a make
check for i686-gnu.

Set tunable value as well as min/max values

Some tunable values and their minimum/maximum values must be determinted
at run-time.  Add TUNABLE_SET_WITH_BOUNDS and TUNABLE_SET_WITH_BOUNDS_FULL
to update tunable value together with minimum and maximum values.
__tunable_set_val is updated to set tunable value as well as min/max
values.

ld.so: add an --argv0 option [BZ #16124]

Reversing calculation of __x86_shared_non_temporal_threshold

The __x86_shared_non_temporal_threshold determines when memcpy on x86
uses non_temporal stores to avoid pushing other data out of the last
level cache.

This patch proposes to revert the calculation change made by H.J. Lu's
patch of June 2, 2017.

H.J. Lu's patch selected a threshold suitable for a single thread
getting maximum performance. It was tuned using the single threaded
large memcpy micro benchmark on an 8 core processor. The last change
changes the threshold from using 3/4 of one thread's share of the
cache to using 3/4 of the entire cache of a multi-threaded system
before switching to non-temporal stores. Multi-threaded systems with
more than a few threads are server-class and typically have many
active threads. If one thread consumes 3/4 of the available cache for
all threads, it will cause other active threads to have data removed
from the cache. Two examples show the range of the effect. John
McCalpin's widely parallel Stream benchmark, which runs in parallel
and fetches data sequentially, saw a 20% slowdown with this patch on
an internal system test of 128 threads. This regression was discovered
when comparing OL8 performance to OL7.  An example that compares
normal stores to non-temporal stores may be found at
https://vgatherps.github.io/2018-09-02-nontemporal/.  A simple test
shows performance loss of 400 to 500% due to a failure to use
nontemporal stores. These performance losses are most likely to occur
when the system load is heaviest and good performance is critical.

The tunable x86_non_temporal_threshold can be used to override the
default for the knowledgable user who really wants maximum cache
allocation to a single thread in a multi-threaded system.
The manual entry for the tunable has been expanded to provide
more information about its purpose.

modified: sysdeps/x86/cacheinfo.c
modified: manual/tunables.texi

linux: Add time64 recvmmsg support

The wire-up syscall __NR_recvmmsg_time64 (for 32-bit) or
__NR_recvmmsg (for 64-bit) is used as default.  The 32-bit fallback
is used iff __ASSUME_TIME64_SYSCALLS is not defined, which assumes the
kernel ABI provides either __NR_socketcall or __NR_recvmmsg
(32-bit time_t).

It does not handle the timestamps on ancillary data (SCM_TIMESTAMPING
records).

Checked on x86_64-linux-gnu and i686-linux-gnu.

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

linux: Add time64 support for nanosleep

It uses __clock_nanosleep64 and adds the __nanosleep64 symbol.

Checked on x86_64-linux-gnu and i686-linux-gnu (on 5.4 and on 4.15
kernel).

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

linux: Consolidate utimes

The generic version does not have time64 support and Linux default
uses utimensat.  With hppa version gone, __ASSUME_UTIMES is not used
anymore.

Checked on x86_64-linux-gnu and i686-linux-gnu (on 5.4 and on 4.15
kernel).

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

linux: Use 64-bit time_t syscall on clock_getcputclockid

The syscall __NR_clock_getres_time64 (for 32-bit) or __NR_clock_getres
(for 64-bit) is used as default.  The 32-bit fallback is used iff
__ASSUME_TIME64_SYSCALLS is not defined, which assumes the kernel ABI
provides either __NR_rt_sigtimedwait (32-bit time_t).

Since the symbol does not use any type which might be affected by the
time_t, there is no need to add a 64-bit variant.

Checked on x86_64-linux-gnu and i686-linux-gnu (on 5.4 and on 4.15
kernel).

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

linux: Add time64 sigtimedwait support

The syscall __NR_sigtimedwait_time64 (for 32-bit) or __NR_sigtimedwait
(for 64-bit) is used as default.  The 32-bit fallback is used iff
__ASSUME_TIME64_SYSCALLS is not defined, which assumes the kernel ABI
provides either __NR_rt_sigtimedwait (32-bit time_t).

Checked on x86_64-linux-gnu and i686-linux-gnu.

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

linux: Add time64 select support

The syscall __NR_pselect6_time64 (32-bit) or __NR_pselect6 (64-bit)
is used as default.  For architectures with __ASSUME_TIME64_SYSCALLS
the 32-bit fallback uses __NR_select/__NR__newselect or __NR_pselect6
(it should cover the microblaze case where older kernels do not
provide __NR_pselect6).

Checked on x86_64-linux-gnu and i686-linux-gnu (on 5.4 and on 4.15
kernel).

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

nptl: Fix __futex_abstimed_wait_cancellable32

Similar to 64-bit time __futex_abstimed_wait_cancellable64, it should
check for overflow and convert to 32-bit timespec iff timeout is not
NULL.

It fixes some regression on i686-linux-gnu running on a 4.15 kernel.

sysvipc: Fix semtimeop for !__ASSUME_DIRECT_SYSVIPC_SYSCALLS

The __NR_ipc syscall does not support 64-bit time operations.  It
fixes 7c437d3778.

Checked on i686-linux-gnu on a Linux 5.4.

hurd: add ST_RELATIME

sysdeps/mach/hurd/bits/statvfs.h (ST_RELATIME): New macro.

intl: Handle translation output codesets with suffixes [BZ #26383]

Commit 91927b7c7643 (Rewrite iconv option parsing [BZ #19519]) did not
handle cases where the output codeset for translations (via the `gettext'
family of functions) might have a caller specified encoding suffix such as
TRANSLIT or IGNORE.  This led to a regression where translations did not
work when the codeset had a suffix.

This commit fixes the above issue by parsing any suffixes passed to
__dcigettext and adds two new test-cases to intl/tst-codeset.c to
verify correct behaviour.  The iconv-internal function __gconv_create_spec
and the static iconv-internal function gconv_destroy_spec are now visible
internally within glibc and used in intl/dcigettext.c.

bench-strcmp.c: Add workloads on page boundary

Add strcmp workloads on page boundary.

bench-strncmp.c: Add workloads on page boundary

Add strncmp workloads on page boundary.

strcmp: Add a testcase for page boundary

Add a strcmp testcase to cover cases where both strings end on the page
boundary.

strncmp: Add a testcase for page boundary [BZ #25933]

Add a strncmp testcase to cover cases where one of strings ends on the
page boundary with the maximum string length less than the number bytes
of each AVX2 loop iteration and different offsets from page boundary.

The updated string/test-strncmp fails on Intel Core i7-8559U without

ommit 1c6432316bc434a72108d7b0c7cfbfdde64c3124
Author: Sunil K Pandey <skpgkp1@gmail.com>
Date:   Fri Jun 12 08:57:16 2020 -0700

    Fix avx2 strncmp offset compare condition check [BZ #25933]

Set locale related environment variables in debugglibc.sh

Tests and binaries that use locale related functions need to run in the
correct locale environment when being debugged via debugglibc.sh.  This
commit sets up the environment, specifically: GCONV_PATH, LOCPATH, and
LC_ALL for such tests and binaries when they are being debugged outside
of a test container.

Reviewed-by: Carlos O'Donell <carlos@redhat.com>

benchtests: Run _Float128 tests only on architectures that support it

__float128 is a non-standard name and is not available on some architectures
(like aarch64 or s390x) even though they may support the standard _Float128
type.  Other architectures (like armv7) don't support quad-precision
floating-point operations at all.

This commit replaces benchtests references to __float128 with _Float128 and
runs the corresponding tests only on architectures that support it.

powerpc: Protect dl_powerpc_cpu_features on INIT_ARCH() [BZ #26615]

dl_powerpc_cpu_features also needs to be protected by __GLRO to check
for the _rtld_global_ro realocation before accessing it.

Reviewed-by: Tulio Magno Quites Machado Filho <tuliom@linux.ibm.com>

x86: Harden printf against non-normal long double values (bug 26649)

The behavior of isnan/__builtin_isnan on bit patterns that do not
correspond to something that the CPU would produce from valid inputs
is currently under-defined in the toolchain. (The GCC built-in and
glibc disagree.)

The isnan check in PRINTF_FP_FETCH in stdio-common/printf_fp.c
assumes the GCC behavior that returns true for non-normal numbers
which are not specified as NaN. (The glibc implementation returns
false for such numbers.)

At present, passing non-normal numbers to __mpn_extract_long_double
causes this function to produce irregularly shaped multi-precision
integers, triggering undefined behavior in __printf_fp_l.

With GCC 10 and glibc 2.32, this behavior is not visible because
__builtin_isnan is used, which avoids calling
__mpn_extract_long_double in this case.  This commit updates the
implementation of __mpn_extract_long_double so that regularly shaped
multi-precision integers are produced in this case, avoiding
undefined behavior in __printf_fp_l.

x86: Use one ldbl2mpn.c file for both i386 and x86_64

Define __THROW to noexcept for C++11 and later

The __THROW macro and friends expand to "throw ()" for C++ code, but
that syntax is deprecated in C++11 and no longer supported at all since
C++20. In order for glibc headers to be compatible with C++20,
"noexcept" should be used instead.

This patch uses "noexcept (true)" rather than just "noexcept", which is
semantically equivalent, but avoids any possibility of parsing
ambiguities if the next preprocessor token happens to be an opening
parenthesis. This is probably unnecessary, but it seems safer to be
cautious.

Update mallinfo2 ABI, and test

This patch adds the ABI-related bits to reflect the new mallinfo2
function, and adds a test case to verify basic functionality.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

Allow memset local PLT reference for RISC-V.

This is similar to commit a26e2e9feab87d4f745c31411458b048742ac733
"Allow memset local PLT reference for powerpc soft-float.".

GCC 10.1 results in the localplt test failing for RISC-V.

From the original commit for power-pc:
    Since memset is documented as a function GCC may always implicitly
    generate calls to, it seems reasonable to allow that local PLT
    reference (just like those for libgcc functions that GCC implicitly
    generates calls to and that are also exported from libc.so), which
    this patch does.

Acked-by: Palmer Dabbelt <palmerdabbelt@google.com>

powerpc: fix ifunc implementation list for POWER9 strlen and stpcpy

__strlen_power9 and __stpcpy_power9 were added to their ifunc lists
using the wrong function names.

nscd: bump GC cycle during cache pruning (bug 26130)

While nscd prunes a cache it becomes inconsistent temporarily, which is
visible to clients if that cache is shared.  Bump the GC cycle counter so
that the clients notice the modification window.

Uniformly use atomic_fetch_add to modify the GC cycle counter.

x86: Use HAS_CPU_FEATURE with IBT and SHSTK [BZ #26625]

commit 04bba1e5d84b6fd8d3a3b006bc240cd5d241ee30
Author: H.J. Lu <hjl.tools@gmail.com>
Date:   Wed Aug 5 13:51:56 2020 -0700

    x86: Set CPU usable feature bits conservatively [BZ #26552]

    Set CPU usable feature bits only for CPU features which are usable in
    user space and whose usability can be detected from user space, excluding
    features like FSGSBASE whose enable bit can only be checked in the kernel.

no longer turns on the usable bits of IBT and SHSTK since we don't know
if IBT and SHSTK are usable until much later.  Use HAS_CPU_FEATURE to
check if the processor supports IBT and SHSTK.

<sys/platform/x86.h>: Add Intel Key Locker support

Add Intel Key Locker:

https://software.intel.com/content/www/us/en/develop/download/intel-key-locker-specification.html

support to <sys/platform/x86.h>.  Intel Key Locker has

1. KL: AES Key Locker instructions.
2. WIDE_KL: AES wide Key Locker instructions.
3. AESKLE: AES Key Locker instructions are enabled by OS.

Applications should use

if (CPU_FEATURE_USABLE (KL))

and

if (CPU_FEATURE_USABLE (WIDE_KL))

to check if AES Key Locker instructions and AES wide Key Locker
instructions are usable.

Fix handling of collating symbols in fnmatch (bug 26620)

The variable idx contains the index into the extra array, whereas wextra
points into the extra array at this index, containing the length of the
following collating sequence in the wide character representation.

pselect.c: Pass a pointer to SYSCALL_CANCEL [BZ #26606]

commit a92f4e6299fe0e3cb6f77e79de00817aece501ce
Author: Adhemerval Zanella <adhemerval.zanella@linaro.org>
Date:   Mon Jul 6 13:27:12 2020 -0300

    linux: Add time64 pselect support

changed pselect.c to

     r = SYSCALL_CANCEL (pselect6_time64, nfds, readfds, writefds, exceptfds,
  timeout,
  ((__syscall_ulong_t[]){ (uintptr_t) sigmask,
  __NSIG_BYTES }));

which doesn't work with x32's ARGIFY and data passed to syscall isn't
initialized with sigmask and __NSIG_BYTES.  Change to

     __syscall_ulong_t data[2] =
{
  (uintptr_t) sigmask, __NSIG_BYTES
};
      r = SYSCALL_CANCEL (pselect6_time64, nfds, readfds, writefds, exceptfds,
  timeout, data);

fixes [BZ #26606].

y2038: nptl: Convert sem_{clock|timed}wait to support 64 bit time

The sem_clockwait and sem_timedwait have been converted to support 64 bit time.

This change reuses futex_abstimed_wait_cancelable64 function introduced earlier.
The sem_{clock|timed}wait only accepts absolute time. Moreover, there is no
need to check for NULL passed as *abstime pointer to the syscalls as both calls
have exported symbols marked with __nonull attribute for abstime.

For systems with __TIMESIZE != 64 && __WORDSIZE == 32:
- Conversion from 32 bit time to 64 bit struct __timespec64 was necessary
- Redirection to __sem_{clock|timed}wait64 will provide support for 64 bit
  time

Build tests:
./src/scripts/build-many-glibcs.py glibcs

Run-time tests:
- Run specific tests on ARM/x86 32bit systems (qemu):
  https://github.com/lmajewski/meta-y2038 and run tests:
  https://github.com/lmajewski/y2038-tests/commits/master

Above tests were performed with Y2038 redirection applied as well as without
to test the proper usage of both __sem_{clock|timed}wait64 and
__sem_{clock|timed}wait.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

hurd: Add __x86_get_cpu_features to ld.abilist

Add __x86_get_cpu_features to ld.abilist for <sys/platform/x86.h>.

x86: Install <sys/platform/x86.h> [BZ #26124]

Install <sys/platform/x86.h> so that programmers can do

 #if __has_include(<sys/platform/x86.h>)
 #include <sys/platform/x86.h>
 #endif
 ...

   if (CPU_FEATURE_USABLE (SSE2))
 ...
   if (CPU_FEATURE_USABLE (AVX2))
 ...

<sys/platform/x86.h> exports only:

enum
{
  COMMON_CPUID_INDEX_1 = 0,
  COMMON_CPUID_INDEX_7,
  COMMON_CPUID_INDEX_80000001,
  COMMON_CPUID_INDEX_D_ECX_1,
  COMMON_CPUID_INDEX_80000007,
  COMMON_CPUID_INDEX_80000008,
  COMMON_CPUID_INDEX_7_ECX_1,
  /* Keep the following line at the end.  */
  COMMON_CPUID_INDEX_MAX
};

struct cpuid_features
{
  struct cpuid_registers cpuid;
  struct cpuid_registers usable;
};

struct cpu_features
{
  struct cpu_features_basic basic;
  struct cpuid_features features[COMMON_CPUID_INDEX_MAX];
};

/* Get a pointer to the CPU features structure.  */
extern const struct cpu_features *__x86_get_cpu_features
  (unsigned int max) __attribute__ ((const));

Since all feature checks are done through macros, programs compiled with
a newer <sys/platform/x86.h> are compatible with the older glibc binaries
as long as the layout of struct cpu_features is identical.  The features
array can be expanded with backward binary compatibility for both .o and
.so files.  When COMMON_CPUID_INDEX_MAX is increased to support new
processor features, __x86_get_cpu_features in the older glibc binaries
returns NULL and HAS_CPU_FEATURE/CPU_FEATURE_USABLE return false on the
new processor feature.  No new symbol version is neeeded.

Both CPU_FEATURE_USABLE and HAS_CPU_FEATURE are provided.  HAS_CPU_FEATURE
can be used to identify processor features.

Note: Although GCC has __builtin_cpu_supports, it only supports a subset
of <sys/platform/x86.h> and it is equivalent to CPU_FEATURE_USABLE.  It
doesn't support HAS_CPU_FEATURE.

linux: Add time64 pselect support

The syscall __NR_pselect6_time64 (32-bit) or __NR_pselect6 (64-bit)
is used as default.  For architectures with __ASSUME_TIME64_SYSCALLS
the 32-bit fallback uses __NR_pselec6.

To accomodate microblaze missing pselect6 support on kernel older
than 3.15 the fallback is moved to its own function to the microblaze
specific implementation can override it.

Checked on x86_64-linux-gnu and i686-linux-gnu (on 5.4 and on 4.15
kernel).

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

linux: Add time64 semtimedop support

Either the __NR_semtimedop_time64 (for 32-bit) or the __NR_semtimedop
(for 64-bit) syscall is used as default.  The 32-bit fallback is used
iff __ASSUME_TIME64_SYSCALLS is not defined, which assumes the kernel
ABI provides either __NR_ipc or __NR_semtimeop (for 32-bit time_t).

Checked on x86_64-linux-gnu and i686-linux-gnu (on 5.4 and on 4.15
kernel).

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

linux: Add ppoll time64 optimization

It avoid continuing issue the __NR_ppoll_time64 syscall once the kernel
advertise it does not support it.

Checked on x86_64-linux-gnu and i686-linux-gnu (on 5.4 and on 4.15
kernel).

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

linux: Simplify clock_getres

With arch-syscall.h it can now assumes the existance of either
__NR_clock_getres or __NR_clock_getres_time64.  The 32-bit time_t
support is now only build for !__ASSUME_TIME64_SYSCALLS.

It also uses the time64-support functions to simplify it further.

Checked on x86_64-linux-gnu and i686-linux-gnu (on 5.4 and on 4.15
kernel).

Reviewed-by: Alistair Francis <alistair.francis@wdc.com>

Update sparc libm-test-ulps

Remove internal usage of extensible stat functions

It replaces the internal usage of __{f,l}xstat{at}{64} with the
__{f,l}stat{at}{64}.  It should not change the generate code since
sys/stat.h explicit defines redirections to internal calls back to
xstat* symbols.

Checked with a build for all affected ABIs.  I also check on
x86_64-linux-gnu and i686-linux-gnu.

Reviewed-by: Lukasz Majewski <lukma@denx.de>

Linux: Consolidate xmknod

The __NR_mknodat syscall is supported on all kernels, so the generic
implementation is used as default.

Checked on x86_64-linux-gnu and i686-linux-gnu.

Reviewed-by: Lukasz Majewski <lukma@denx.de>

linux: Consolidate fxstatat{64}

The LFS support is implemented on fxstat64.c, instead of fxstat.c for
64-bit architectures.  The fxstatat.c implements the non-LFS and it is
a no-op for !XSTAT_IS_XSTAT64.

The generic non-LFS implementation handles two cases:

  1. New kABIs which uses generic pre 64-bit time Linux ABI (csky and
     nios): it issues __NR_fstatat64 plus handle the overflow on st_ino,
     st_size, or st_blocks.  It only handles _STAT_VER_KERNEL.

  2. Old kABIs with old non-LFS support (arm, i386, hppa, m68k, mips32,
     microblaze, s390, sh, powerpc, and sparc32).  it issues
     __NR_fstatat64 and convert to non-LFS stat struct based on the
     version.

Also non-LFS mips64 is an outlier and it has its own implementation
since _STAT_VER_LINUX requires a different conversion function (it
uses the kernel_stat as the sysissues argument since its exported ABI
is different than the kernel one for both non-LFS and LFS
implementation).

The generic LFS implementation handles multiple cases:

  1. XSTAT_IS_XSTAT64 being 1:

    1.1. 64-bit kABI (aarch64, ia64, powerpc64*, s390x, riscv64, and
         x86_64): it issues __NR_newfstatat for _STAT_VER_KERNEL or
         _STAT_VER_LINUX.

    1.2. 64-bit kABI outlier (sparc64): it issuess fstatat64 with a
         temporary stat64 and convert to output stat64 based on the
         input version (and using a sparc64 specific __xstat32_conv).

    1.3. New 32-bit kABIs with only 64-bit time_t support (arc and
 riscv32): it issues __NR_statx and covert to struct stat64.

  2. Old ABIs with XSTAT_IS_XSTAT64 being 0 (arm, csky, i386, hppa, m68k,
     microblaze, mips32, nios2, sh, powerpc32, and sparc32): it issues
     __NR_fstat64.

Also, two special cases requires specific implementations:

  1. alpha: it uses the __NR_fstatat64 syscall instead.

  2. mips64: as for non-LFS implementation its ABIs differ from
     glibc exported one, which requires an specific conversion
     function to handle the kernel_stat.

Checked with a build for all affected ABIs. I also checked on x86_64,
i686, powerpc, powerpc64le, sparcv9, sparc64, s390, and s390x.

Reviewed-by: Lukasz Majewski <lukma@denx.de>

linux: Consolidate fxstat{64}

The LFS support is implemented on fxstat64.c, instead of fxstat.c for
64-bit architectures.  The fxstat.c implements the non-LFS and it is
a no-op for !XSTAT_IS_XSTAT64.

The generic non-LFS implementation handles two cases:

  1. New kABIs which uses generic pre 64-bit time Linux ABI (csky and
     nios): it issuess __NR_fstat64 plus handle the overflow on st_ino,
     st_size, or st_blocks.  It only handles _STAT_VER_KERNEL.

  2. Old KABIs with old non-LFS support (arm, i386, hppa, m68k,
     microblaze, s390, sh, powerpc, and sparc32).  For _STAT_VER_KERNEL
     it issues __NR_fstat, otherwise it calls __NR_fstat64 and convert
     to non-LFS stat struct and handle possible overflows on st_ino,
     st_size, or st_blocks.

Also non-LFS mips is an outlier and it has its own implementation since
_STAT_VER_LINUX requires a different conversion function (it uses the
kernel_stat as the sysissues argument since its exported ABI is
different than the kernel one for both non-LFS and LFS implementation).

The generic LFS implementation handles multiple cases:

  1. XSTAT_IS_XSTAT64 being 1:

    1.1. 64-bit kABI (aarch64, ia64, powerpc64*, s390x, riscv64, and
 x86_64): it issuess __NR_fstat for _STAT_VER_KERNEL or
 _STAT_VER_LINUX.

    1.2. Old 64-bit kABI with defines __NR_fstat64 instead of __NR_fstat
         (sparc64): it issues __NR_fstat for _STAT_VER_KERNEL or
         __NR_fstat64 and convert to struct stat64.

    1.3. New 32-bit kABIs with only 64-bit time_t support (arc and
 riscv32): it issuess __NR_statx and covert to struct stat64.

  2. Old ABIs with XSTAT_IS_XSTAT64 being 0 (arm, csky, i386, hppa,
     m68k, microblaze, mips32, nios2, sh, powerpc32, and sparc32): it
     issues __NR_fstat64.

Also, two special cases requires specific implementations:

  1. alpha: it requires to handle _STAT_VER_KERNEL64 to issues
     __NR_fstat64 and use the kernel_stat with __NR_fstat otherwise.

  2. mips64: as for non-LFS implementation its ABIs differ from
     glibc exported one, which requires an specific conversion
     function to handle the kernel_stat.

Checked with a build for all affected ABIs. I also checked on x86_64,
i686, powerpc, powerpc64le, sparcv9, sparc64, s390, and s390x.

Reviewed-by: Lukasz Majewski <lukma@denx.de>

linux: Consolidate lxstat{64}

The LFS support is implemented on lxstat64.c, instead of lxstat.c for
64-bit architectures.  The xstat.c implements the non-LFS and it is
a no-op for !XSTAT_IS_XSTAT64.

The generic non-LFS implementation handles two cases:

  1. New kABIs which uses generic pre 64-bit time Linux ABI (csky and
     nios): it issues __NR_fstat64 with AT_SYMLINK_NOFOLLOW plus handles
     the possible overflow off st_ino, st_size, or st_blocks.  It only
     handles _STAT_VER_KERNEL.

  2. Old KABIs with old non-LFS support (arm, i386, hppa, m68k,
     microblaze, s390, sh, powerpc, and sparc32).  For _STAT_VER_KERNEL
     it issues __NR_lstat, otherwise it isseus __NR_lstat64 and convert
     to non-LFS stat struct and handle possible overflows on st_ino,
     st_size, or st_blocks.

Also non-LFS mips is an outlier and it has its own implementation since
_STAT_VER_LINUX requires a different conversion function (it uses the
kernel_stat as the syscall argument since its exported ABI is different
than the kernel one for both non-LFS and LFS implementation).

The generic LFS implementation handles multiple cases:

  1. XSTAT_IS_XSTAT64 being 1:

    1.1. Old 64-bit kABI (ia64, powerpc64*, s390x, sparc64, x86_64): it
         issues __NR_lstat for _STAT_VER_KERNEL or _STAT_VER_LINUX.

    1.2. Old 64-bit kABI with defines __NR_lstat64 instead of __NR_lstat
         (sparc64): it issues __NR_lstat for _STAT_VER_KERNEL or
         __NR_lstat64 and convert to struct stat64.

    1.3. New kABIs which uses generic 64-bit Linux ABI (aarch64 and
         riscv64): it issues __NR_newfstatat with AT_SYMLINK_NOFOLLOW
 and only for _STAT_VER_KERNEL.

    1.4. New 32-bit kABIs with only 64-bit time_t support (arc and
         riscv32): it issues __NR_statx and covert to struct stat64.

  2. Old ABIs with XSTAT_IS_XSTAT64 being 0:

    2.1. New kABIs which uses generic pre 64-bit time Linux ABI (csky
 and nios2): it issues __NR_fstatat64 for _STAT_VER_KERNEL.

    2.2. Old kABIs with old non-LFS support (arm, i386, hppa, m68k,
 microblaze, s390, sh, mips32, powerpc32, and sparc32): it
 issues __NR_lstat64.

Also, two special cases requires specific LFS implementations:

  1. alpha: it requires to handle _STAT_VER_KERNEL64 to issue
     __NR_lstat64 and use the kernel_stat with __NR_lstat otherwise.

  2. mips64: as for non-LFS implementation its ABIs differ from
     glibc exported one, which requires a specific conversion
     function to handle the kernel_stat.

Checked with a build for all affected ABIs. I also checked on x86_64,
i686, powerpc, powerpc64le, sparcv9, sparc64, s390, and s390x.

Reviewed-by: Lukasz Majewski <lukma@denx.de>

linux: Consolidate xstat{64}

The LFS support is implemented on xstat64.c, instead of xstat.c for
64-bit architectures.  The xstat.c implements the non-LFS it is
no-op for !XSTAT_IS_XSTAT64.

The generic non-LFS implementation handle two cases:

  1. New kABIs which uses generic pre 64-bit time Linux ABI (csky and
     nios): it issues __NR_fstat64 plus handle the overflow on st_ino,
     st_size, or st_blocks.  It only handles _STAT_VER_KERNEL.

  2. Old KABIs with old non-LFS support (arm, i386, hppa, m68k,
     microblaze, s390, sh, powerpc, and sparc32).  For _STAT_VER_KERNEL
     it issues __NR_stat, otherwise it issues __NR_stat64 and convert
     to non-LFS stat struct handling possible overflows on st_ino,
     st_size, or st_blocks.

Also the non-LFS mips is an outlier and it has its own implementation
since _STAT_VER_LINUX requires a different conversion function (it uses
the kernel_stat as the syscall argument since its exported ABI is
different than the kernel one for both non-LFS and LFS implementation).

The generic LFS implementation handles multiple cases:

  1. XSTAT_IS_XSTAT64 being 1:

    1.1. Old 64-bit kABI (ia64, powerpc64*, s390x, x86_64): it
         issues __NR_stat for _STAT_VER_KERNEL or _STAT_VER_LINUX.

    1.2. Old 64-bit kABI with defines __NR_stat64 instead of __NR_stat
 (sparc64): it issues __NR_stat for _STAT_VER_KERNEL or
 __NR_stat64 and convert to struct stat64.

    1.3. New kABIs which uses generic 64-bit Linux ABI (aarch64 and
         riscv64): it issues __NR_newfstatat and only for
         _STAT_VER_KERNEL.

    1.4. New 32-bit kABIs with only 64-bit time_t support (arc and
 riscv32): it issues __NR_statx and covert to struct stat64.

  2. Old ABIs with XSTAT_IS_XSTAT64 being 0:

    2.1. New kABIs which uses generic pre 64-bit time Linux ABI (csky
 and nios2): it issues __NR_fstatat64 for _STAT_VER_KERNEL.

    2.2. Old kABIs with old non-LFS support (arm, i386, hppa, m68k,
 microblaze, s390, sh, mips32, powerpc32, and sparc32): it
 issues __NR_stat64.

Also, two special cases requires specific LFS implementations:

  1. alpha: it requires to handle _STAT_VER_KERNEL64 to call __NR_stat64
     or use the kernel_stat with __NR_stat otherwise.

  2. mips64: as for non-LFS implementation its ABIs differ from glibc
     exported one, which requires an specific conversion function to
     handle the kernel_stat.

Checked with a build for all affected ABIs. I also checked on x86_64,
i686, powerpc, powerpc64le, sparcv9, sparc64, s390, and s390x.

Reviewed-by: Lukasz Majewski <lukma@denx.de>

linux: Define STAT64_IS_KERNEL_STAT64

It indicates that the glibc export stat64 is similar in size and
layout of the kernel stat64 used on the syscall.  It is not currently
used on stat implementation, but the idea is to indicate whether
to use the kernel_stat to issue on the syscall on the *stat*64
variant (more specifically on mips which its exported ABI does not
match the kernel).

Reviewed-by: Lukasz Majewski <lukma@denx.de>

linux: Always define STAT_IS_KERNEL_STAT

It allows to check for its value instead of its existence.

Checked with a build for all affected ABIS.

Reviewed-by: Lukasz Majewski <lukma@denx.de>

Update powerpc libm-test-ulps

Before this patch, the following tests were failing:

ppc and ppc64:
    FAIL: math/test-ldouble-j0

ppc64le:
    FAIL: math/test-float128-j0
    FAIL: math/test-float64x-j0
    FAIL: math/test-ibm128-j0
    FAIL: math/test-ldouble-j0

benchtests: Add "workload" traces for sinf128

This patch adds workload traces for sinf128 in binary32.  The trace is
made of 1000 random numbers, generated with SageMath.

benchtests: Add "workload" traces for sinf

This patch adds workload traces for sinf in binary32.  The trace is
made of 1000 random numbers, generated with SageMath.

benchtests: Add "workload" traces for sin

This patch adds workload traces for sin in binary64.  The trace is
made of 1000 random numbers, generated with SageMath.

benchtests: Add "workload" traces for powf128

This patch adds workload traces for pow in binary128.  The trace is
made of 1000 random numbers, generated with SageMath.

benchtests: Add "workload" traces for pow

This patch adds workload traces for pow in binary64.  The trace is
made of 1000 random numbers, generated with SageMath.

benchtests: Add "workload" traces for expf128

This patch adds workload traces for exp in binary128.  The trace is
made of 1000 random numbers, generated with SageMath.

benchtests: Add "workload" traces for exp

This patch adds workload traces for exp in binary64.  The trace is
made of 1000 random numbers, generated with SageMath.

nptl: futex: Provide correct indentation for part of __futex_abstimed_wait_cancelable64

By mistake the if for calling __futex_abstimed_wait_cancellable32 was
misaligned with the rest of the function body.

Disable -Wstringop-overread for some string tests

Similarly to Maciej's changes to fix the build of rawmemchr in the
presence of GCC 11's -Wstringop-overread, also disable that option in
two string function tests that have similar warnings and other string
function warnings already disabled.

Tested with build-many-glibcs.py for aarch64-linux-gnu and
arm-linux-gnueabi that it fixes building the glibc testsuite.

string: Fix GCC 11 `-Werror=stringop-overread' error

Fix a compilation error:

In function '__rawmemchr',
    inlined from '__rawmemchr' at rawmemchr.c:27:1:
rawmemchr.c:36:12: error: 'memchr' specified bound 18446744073709551615 exceeds maximum object size 9223372036854775807 [-Werror=stringop-overread]
   36 |     return memchr (s, c, (size_t)-1);
      |            ^~~~~~~~~~~~~~~~~~~~~~~~~
cc1: all warnings being treated as errors
../o-iterator.mk:9: recipe for target '.../string/rawmemchr.o' failed

introduced with GCC 11 commit d14c547abd48 ("Add -Wstringop-overread
for reading past the end by string functions.").

C11 threads: Fix inaccuracies in testsuite

- tst-mtx-recursive.c: mtx_init fails to use mtx_plain.  Per C11
  specs, using mtx_recursive alone is not supported.  This isn't
  catched because mtx_plain is defined as 0.

- tst-thrd-sleep.c: thrd_sleep returns 0 on success, a negative
  value on failure.  Testing against thrd_success is incorrect.

- tst-tss-basic.c: tss_set is incorrectly checkd for a non-0
  value.  The test should test aginst C11 threads error codes.
  This isn't catched because thrd_success is defined as 0.

Note that all three tests fail on FreeBSD, which defines all mutex type
values, as well as all C11 threads error codes with non-0 values.

elf.h: Add aarch64 bti/pac dynamic tag constants

Constants double checked against binutils and the ELF for the Arm 64-bit
Architecture (AArch64) Release 2020Q2 document.

Only BTI PLT is used in glibc, there's no PAC PLT with glibc, and people
are expected to use BIND_NOW.

x86: Set CPU usable feature bits conservatively [BZ #26552]

Set CPU usable feature bits only for CPU features which are usable in
user space and whose usability can be detected from user space, excluding
features like FSGSBASE whose enable bit can only be checked in the kernel.

Update i686 ulps.

Without this ULP patch these 3 tests fail on i686:
FAIL: math/test-float128-j0
FAIL: math/test-float64x-j0
FAIL: math/test-ldouble-j0

CPU info:
Vendor ID:                       GenuineIntel
CPU family:                      6
Model:                           85
Model name:                      Intel Xeon Processor (Cascadelake)

Use LFS readdir in generic POSIX getcwd [BZ# 22899]

Checked on x86_64-linux-gnu and i686-linux-gnu.

linux: Remove __ASSUME_ATFCTS

The __have_atfcts is not used anywhere.

Checked on x86_64-linux-gnu.

Sync getcwd with gnulib

This is the first of a series of patches to sync with Gnulib commit
615b43e1f9.  This patch adopts most of the changes of Gnulib, except it
retains GETCWD_RETURN_TYPE and does not always use a 64-bit internal
API. These remaining discrepancies will be addressed in later patches
in this series.

Checked on x86_64-linux-gnu and i686-linux-gnu.

x86-64: Fix FMA4 detection in ifunc [BZ #26534]

A typo in commit 107e6a3c2212ba7a3a4ec7cae8d82d73f7c95d0b causes the
FMA4 code path to be taken on systems that support FMA, even if they do
not support FMA4. Fix this to detect FMA4.

y2038: nptl: Convert pthread_cond_{clock|timed}wait to support 64 bit time

The pthread_cond_clockwait and pthread_cond_timedwait have been converted
to support 64 bit time.

This change introduces new futex_abstimed_wait_cancelable64 function in
./sysdeps/nptl/futex-helpers.c, which uses futex_time64 where possible
and tries to replace low-level preprocessor macros from
lowlevellock-futex.h
The pthread_cond_{clock|timed}wait only accepts absolute time. Moreover,
there is no need to check for NULL passed as *abstime pointer as
__pthread_cond_wait_common() always passes non-NULL struct __timespec64
pointer to futex_abstimed_wait_cancellable64().

For systems with __TIMESIZE != 64 && __WORDSIZE == 32:
- Conversions between 64 bit time to 32 bit are necessary
- Redirection to __pthread_cond_{clock|timed}wait64 will provide support
  for 64 bit time

The futex_abstimed_wait_cancelable64 function has been put into a separate
file on the purpose - to avoid issues apparent on the m68k architecture
related to small number of available registers (there is not enough
registers to put all necessary arguments in them if the above function
would be added to futex-internal.h with __always_inline attribute).

In fact - new function - namely __futex_abstimed_wait_cancellable32 is
used to reduce number of needed registers (as some in-register values are
stored on the stack when function call is made).

Build tests:
./src/scripts/build-many-glibcs.py glibcs

Run-time tests:
- Run specific tests on ARM/x86 32bit systems (qemu):
  https://github.com/lmajewski/meta-y2038 and run tests:
  https://github.com/lmajewski/y2038-tests/commits/master

Above tests were performed with Y2038 redirection applied as well as without
to test the proper usage of both __pthread_cond_{clock|timed}wait64 and
__pthread_cond_{clock|timed}wait.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

malloc: Fix mallinfo deprecation declaration

It fixes the build issue below introduced by e3960d1c57e57 (Add
mallinfo2  function that support sizes >= 4GB).  It moves the
__MALLOC_DEPRECATED to the usual place for function attributes:

  In file included from ../include/malloc.h:3,
                   from ../sysdeps/x86_64/multiarch/../../../test-skeleton.c:31,
                   from ../sysdeps/x86_64/multiarch/test-multiarch.c:96:
  ../malloc/malloc.h:118:1: error: empty declaration [-Werror]
    118 | __MALLOC_DEPRECATED;

It also adds the required deprecated warning suppression on the tests.

Checked on x86_64-linux-gnu.

x32: Add <fixup-asm-unistd.h> and regenerate arch-syscall.h

X32 uses the same 64-bit syscall interface for set_thread_area.  But
__NR_set_thread_area is missing from <asm/unistd_x32.h>.  A kernel patch
was submitted:

From 7b05d5b43ae2545e0d4a3edb24205d18bc883626 Mon Sep 17 00:00:00 2001
From: "H.J. Lu" <hjl.tools@gmail.com>
Date: Sat, 15 Aug 2020 10:34:00 -0700
Subject: [PATCH] x86-64: Enable x32 set_thread_area

X32 uses the common 64-bit syscall interface for set_thread_area.  Add
<fixup-asm-unistd.h> to provide __NR_set_thread_area.

Co-authored-by: Florian Weimer <fweimer@redhat.com>

Add mallinfo2 function that support sizes >= 4GB.

The current int type can easily overflow for allocation of more
than 4GB.

Remove obsolete default/nss code

All code reading /etc/default/nss and using the internal
defines got removed, so the config file should be removed, too.

AArch64: Improve backwards memmove performance

On some microarchitectures performance of the backwards memmove improves if
the stores use STR with decreasing addresses.  So change the memmove loop
in memcpy_advsimd.S to use 2x STR rather than STP.

Reviewed-by: Adhemerval Zanella <adhemerval.zanella@linaro.org>

Add RISC-V 32-bit target to build-many-glibcs.py

Support building three variants of 32-bit RISC-V glibc as follows:
- riscv32-linux-gnu-rv32imac-ilp32
- riscv32-linux-gnu-rv32imafdc-ilp32
- riscv32-linux-gnu-rv32imafdc-ilp32d

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>

Documentation for the RISC-V 32-bit port

There is already RISC-V 64-bit port information in the documentation.
Let's add some documentation entries for the RISC-V 32-bit as well.

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>

RISC-V: Build infrastructure for 32-bit port

This patch lays out the top-level organisation of the RISC-V 32-bit port.
It provides all the Implies files as well as various other fragments of
the build infrastructure.

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>

RISC-V: Add rv32 path to RTLDLIST in ldd

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>

riscv32: Specify the arch_minimum_kernel as 5.4

Specify the minimum kernel version for RISC-V 32-bit as the 5.4 kernel.
We require this commit: "waitid: Add support for waiting for the current
process group" for the kernel as it adds support for the P_PGID id for
the waitid syscall.  Without this patch we can't replace the wait4
syscall on 64-bit time_t only systems.

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>

RISC-V: Fix llrint and llround missing exceptions on RV32

Conversions from a float to a long long on 32-bit RISC-V (RV32) may not
raise the correct exceptions on overflow, it also may raise spurious
"inexact" exceptions on non overflow cases.  This patch fixes the
problem, similarly to the fix for MIPS, ARM and S390.

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>

RISC-V: Add the RV32 libm-test-ulps

Add a libm-test-ulps for RV32, this is the same as the RV64 one.

This dosn't match what is generated by running `make regen-ulps` on RV32
QEMU, but the current in tree RV64 doesn't match that either.

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>

RISC-V: Add 32-bit ABI lists

Use the update-abi Make target to generate the abilist for RV32.

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>

RISC-V: Add hard float support for 32-bit CPUs

This patch adds support for hardware floating-point support for the
RV32IF and RV32IFD platforms.

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>

RISC-V: Support the 32-bit ABI implementation

This patch adds the ABI implementation for 32-bit RISC-V.  It contains
the Linux-specific and RISC-V architecture code.

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>

RISC-V: Add arch-syscall.h for RV32

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>

RISC-V: Add path of library directories for the 32-bit

With RV32 support the list of possible RISC-V system directories
increases to:
     - /lib64/lp64d
     - /lib64/lp64
     - /lib32/ilp32d
     - /lib32/ilp32
     - /lib (only ld.so)

This patch changes the add_system_dir () macro to support the new ilp32d
and ilp32 directories for RV32.  While refactoring this code let's split
out the confusing if statements into a loop to make it easier to
understand and extend.

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>

RISC-V: Support dynamic loader for the 32-bit

Add the LD_SO_ABI definition for RISC-V 32-bit.

Reviewed-by: Maciej W. Rozycki <macro@wdc.com>