aarch64: morello: add lazy binding entry code

cheri: elf: fix SYMBOL_ADDRESS to return RX derived pointer

All symbol addresses can be derived from the RX capability of the
module (l_map_start). For RW object symbols pointer will have to
be rederived from l_rw_start.

cheri: elf: Use RW permissions for l_ld when needed

The dynamic section of an executable needs to be written to set the
DT_DEBUG entry for debuggers (unless the target has some other place
to store r_debug). For this reason we make l_ld writable whenever
the dynamic section is writable.

The ld.so l_ld is kept RX, since it does not have DT_DEBUG.
(Note: relocating the dynamic section is not allowed on cheri and
that's the only other reason glibc would write to it.)

cheri: elf: Use elfptr_t for function symbol fixup

Propagate capabilities during lazy binding and IFUNC fixup in dlsym.

cheri: elf: Prepare support for dynamic relocation processing

Type of relocation addresses must be changed from ElfW(Addr) to
elfptr_t to cover both traditional and CHERI ABIs.

And relative relocation processing must have access to the link_map
to derive pointers from the right per module capability.

TODO(sprof): cheri: disable profiling shared libraries

This is needed now to avoid referencing abort in ld.so.

TODO: Fixing shared library profiling for capabilities requires
type fixes so capabilities are not stored into shared memory
(maybe purecap layout can match the lp64 one and then no file format
and external tooling change is required.)
TODO: Proper fix also depends on _dl_runtime_profile plt entry

TODO(pldd): cheri: elf: fix pldd to compile for purecap abi

Adjust types in the E(*) structs to support capabilities.

TODO: purecap pldd should refuse to deal with lp64 and ELF32 processes.
the code for the 32bit case should be disabled.
TODO: a correct fix requires support for all abis that can run on the
same system (purecap, lp64 and ELF32 too).

aarch64: morello: add dl-r_debug.h

Used internally for r_debug tests, but with the assumption that
the return value can be dereferenced, so change the prototype
and return a valid capability.

Also used in pldd, where we only support purecap abi processes.

aarch64: elf: avoid loading incompatible binaries

Prevent lp64 ld.so loading purecap binaries.

cheri: elf: use RX, RW capabilities to derive pointers

Instead of

  map->l_addr + offset

use

  dl_rx_ptr (map, offset)
  dl_rw_ptr (map, offset)

depending on RX or RW permission requirement.

cheri: elf: Fix segment mapping permissions

Ensure mmap returns pointers with RWX permission covering all segments.
These pointers later get restricted to RX and RW permission.

cheri: elf: Setup per module RX and RW capabilities

_dl_map_segments must use capabilities, this required changes beyond
the obvious elfptr_t changes:

- Ensure map_end is derived from map_start,

- Use strict mmap bounds with MAP_FIXED: c->mapend is aligned up to
  pagesize which may be out of bounds of l_map_start (covering the
  load segments, but bounds are not aligned up), so use c->dataend
  instead.

Propagate l_map_start and l_rw_start capabilities of ld.so and exe that
come from auxv, and ensure they are not recomputed incorrectly by ld.so.

The l_rw_range should exclude the relro region, but in libc.so and
ld.so this does not work: symbols are accessed before relro is applied
and then the permission should be writable.

cheri: elf: change l_entry to be elfptr_t

It is simpler and more consistent to make l_entry a capability
throughout instead of leaving it as an address and converting before
use:

The AT_ENTRY auxv entry is specified to be a capability and a number
if internal l_entry usage is simpler if it is elfptr_t.

Functions returning a pointer to the user entry are also changed to
use elfptr_t.

aarch64: morello: add purecap ld.so _start code

The purecap version of aarch64 dl-start.S. Note: self relocation of
ld.so is handled by the rtld bootstrap code.

The ldso internal _dl_start still expects continuous argc, argv, envp,
auxv, so that's emulated (since the purecap ELF entry passes them in
separate registers).

aarch64: morello: rtld: define DL_RO_DYN_SECTION

The dynamic section cannot be relocated to hold pointers in place.

aarch64: morello: fix ldconfig for purecap abi

Add purecap ld cache flag. Add the purecap ld.so name to known names.
Handle lib64c system library paths. And set the purecap abi flag on
cache entries.

aarch64: morello: disable the vpcs test

The asm code of the test is for lp64 ABI only.

aarch64: morello: add purecap ucontext support

Adjust ucontext layout for purecap ABI and add make/get/set/swapcontext
implementations accordingly.

Note: mcontext layout follows the linux sigcontext struct, in userspace
*context functions rely on the c registers stored in the extension area
and ignore the mcontext fields for x registers.

aarch64: morello: add purecap setjmp/longjmp

Similar to lp64 setjmp/longjmp, but handles capability registers.
Save q regs instead of d regs to simplify the offset computation.

cheri: malloc: Ensure the mappings have RW permission

The arena allocator incrementally applies RW mprotect to a PROT_NONE
mapping.  Use PROT_MAX to ensure the pointers derived from the original
mapping have RW capability permission.

cheri: malloc: avoid switch over uintptr_t

We should use a type that guarantees to represent all address bits.
In CHERI C this would be ptraddr_t, but we use unsigned long for now
not to cause regressions on other targets where this type is missing.

cheri: malloc: align up without breaking capability in memalign

cheri: malloc: Disable pointer protection

Such arithmetic invalidates capabilities so this security measure does
not work for CHERI.

Note: the architecture makes it hard to corrupt pointers in malloc
metadata, but not impossible: current allocation bounds include the
metadata and capabilities are not revoked after free. These issues can
be fixed by a capability aware malloc.

cheri: fix invalid pointer use after realloc in localealias

This code updates pointers to a reallocated buffer to point to the new
buffer.  It is not conforming (does arithmetics with freed pointers),
but it also creates invalid capabilities because the provenance is
derived from the original freed pointers instead of the new buffer.

Change the arithmetics so provenance is derived from the new buffer.
The conformance issue is not fixed.

cheri: fix pointer tagging in tsearch

USE_MALLOC_LOW_BIT should work for capabilities too, but we need to
ensure that pointer provenance is right: the red/black flag is
computed as uintptr_t, but with uintptr_t | uintptr_t it's not clear
which side provides the provenance.

So use unsigned int type for the flag (which is the type used in case
of !USE_MALLOC_LOW_BIT anyway), then unsigned int | uintptr_t works.

The type of RED is corrected too to match unsigned int.

cheri: fix qsort for capabilities

On capability targets avoid copying pointers via unsigned long.

cheri: wctype: turn wctype_t into a pointer

Make wctype_t a pointer so dereferencing it works. wctrans_t is already
a pointer and used the same way.

Existing targets are not affected, only capability targets where this
is necessary.

cheri: rseq: remove const to avoid readonly permission

Using const on the definition does not work for a pure capability ABI:
the capability permissions when accessing the object will be read only.

Use a hack to hide the public declaration in the TU where the const
objects are initialized. (This should work on non-capability targets
too, but to err on the safe side only enable the hack on capability
targets.)

cheri: Fix capability permissions of PROT_NONE maps in test code

cheri: Fix capability permissions of PROT_NONE map in locarchive

cheri: nptl: Fix thread stack capability permissions

aarch64: morello: nptl: fix thread pointer setup

aarch64: morello: nptl: fix pthread types for 128 bit pointers

cheri: nptl: fix pthread_attr_t alignment

Alignment of the public definition did not match the internal layout.
Ensure that the type is at least pointer aligned.

cheri: nptl: fix thread ID types for capabilities

cheri: Implement 128-bit atomics

Arm Morello requires 128-bit atomics.

cheri: elf: Use elfptr_t in _dl_protect_relro

Derive the start of the relro area from the RW capability of the dso.

cheri: fix static linking TLS setup

Use the per module RW capability to access the TLS initimage.
The bounds are not restricted for now.

cheri: elf: elfptr_t fixes for preinit/init/fini array

According to the ELF spec:

 "Each element of this array is a pointer to a function to be executed
  by the dynamic linker."

 "Note that the address of a function need not be the same as a pointer
  to a function as defined by the processor supplement."

so these should be accessed via uintptr_t type instead of ElfW(Addr) and
the pointers are derived from the RX pointer of the elf module.

cheri: Setup RX, RW capabilities for static linking

At least tls image access requires RX capability of the main link_map.

cheri: elf: add dl_{rx,rw}_ptr to derive addresses within a map

To derive pointers within a module from the per module RX and RW caps.

cheri: elf: add an RW capability to link_map

For each module keep an RX and an RW root capability.  Use the existing
l_map_start for RX (covering all load segments) and add l_rw_start for
RW (covering all writable load segments).

For relocation processing, we also need individual RW ranges to decide
which objects need to be derived from RW and RX capabilities.  In
practice most modules have exactly one RW segment and it's unlikely
that any module needs more than four distinct ranges to tightly cover
the RW mappings.

Only added on CHERI targets so always has to be used behind ifdef.

cheri: elf: elfptr_t l_map_start in link_map struct

Use a capability for the load segment start that covers all load
segments so pointers can be derived from it.

It should have RX permission and a separate capability used for
writable pointers.

cheri: Introduce elfptr_t int type that can hold pointers

Use elfptr_t when ElfW(Addr) represents a runtime pointer (may be
dereferenced or pointers may be derived from it).

cheri: fix __minimal_malloc

The linker created _end symbol does not have the right bounds, so
don't try to reuse leftover memory at the end of the .data section.

cheri: fix static linking early allocation

Store mmap result to intptr_t instead of long.

cheri: don't use dl_random for pointer mangling

Pointer mangling cannot be supported on capability architectures.
And there is not enough bytes in dl_random for 128 bit pointers.

Stack guard is still loaded from dl_random: stack protection is
unlikely to be useful on a capability architecture, but it works.

aarch64: morello: add purecap start code

Written in C so the self relocation code in crt1.o is easier to
maintain.

The purecap ELF entry is special: passes separate argc, argv, envp,
auxv in registers instead of on the stack.

For each module there will be separate RW and RX capabilities that
cover the writable and all load segments respectively. The relative
reloc processing code is prepared for such separate capabilities.

The static link detection (for self relocation) is not ideal, it
relies on relocations that don't work in PIC, so it is ifdefed out
for Scrt1.o. (Currently adrp of undefined weak symbol is not fixed
up by the linker to be 0 so we use movz to detect the presence of
__rela_dyn_start.)

cheri: change __libc_start_main prototype

The prototype of __libc_start_main is changed to

  void
  __libc_start_main (int main (int, char **, char **, void *),
                     int argc, char **argv, char **envp, void *auxv,
                     void rtld_fini (void), void *sp);

so envp is passed down separately and the unused init, fini args are
dropped.

aarch64: morello: purecap crti.S and crtn.S

Purecap ABI versions of crti.S and crtn.S.

cheri: aarch64: Add header for CHERI permissions

New file containing the capability permission bits.

The capability permission bits are defined in the Arm Architecture
Reference Manual Suplement- Morello for A-Profile Architecture:

https://developer.arm.com/documentation/ddi0606/latest

cheri: elf: use elfptr_t for auxv parsing

cheri: elf: Adjust Elf64_auxv_t for capabilities

The Elf64_auxv_t needs to be adjusted for the new capability size.

cheri: elf: Add new AT_* auxv type definitions

Follows the morello pure capability user ABI of linux.

elf: add EF_AARCH64_CHERI_PURECAP

elf: add Arm Morello relocations to elf.h

TODO(uapi): narrow capability in mmap and mremap

This is a temporary workaround.

length is rounded up to pagesize and don't use exact bound (bounds
will be larger if exact value is not representable).

capability permissions are roughly emulated too.

TODO: kernel should do this

TODO(uapi): aarch64: morello: add HWCAP2_MORELLO

TODO: this is the value in the 5.18 kernel, will change later.

TODO(uapi): aarch64: morello: use non-ifunc gettimeofday

TODO: Remove this once morello has vdso gettimeofday.

TODO(uapi): aarch64: morello: make brk always fail

TODO: drop this once linux brk always fails.

TODO(uapi): cheri: fix clone_args

Current clone_args does not support 128 bit pointers.

TODO: the fix is incomplete (missing clone3 abi checks) and has to be
aligned with purecap clone3 struct layout.

aarch64: morello: define PROT_MAX

Specifies the prot flags a mapping may gain via mprotect or MAP_FIXED.
On CHERI targets this is used to get capability with more permissions
than the original mmap protection would imply.

aarch64: morello: fix missing variadic argument in fcntl

In fcntl va_arg is currently used even if the caller did not pass
any variadic arguments. This is undefined behaviour and does not
work with the Morello purecap ABI, so use a helper macro.

When the argument is missing, the result of the helper macro is
arbitrary as it will be ignored by the kernel, we just have to
ensure it does not cause a runtime crash.

aarch64: morello: add prctl with correct vararg handling

prctl is a variadic function and on morello args that were not passed
cannot be accessed so the generic code does not work.

aarch64: morello: fix vfork

No need to set the child stack to sp, 0 means the parent stack is used.
This avoids purecap specific ifdefs in vfork.

aarch64: morello: add purecap syscall support

Support the Morello Linux purecap syscall ABI.  The macro definitions
are moved to a morello specific sysdep.h to avoid cluttering the
aarch64 one.

aarch64: fix VDSO setup to only apply to known ABIs

New syscall ABI requires different VDSO support code.

TODO(api): cheri: fix syscall return type

TODO: this affects API (syscall return type is long)
so breaks portability and requires doc updates.

aarch64: morello: string: memcpy

from arm optimized-routines morello branch.

aarch64: morello: string: memset

memset from arm optimized-routines morello branch.

aarch64: morello: string: dummy c memcmp

aarch64: morello: string: dummy c memchr

aarch64: morello: string: dummy c memrchr

aarch64: morello: purecap rawmemchr

Modified rawmemchr to support Arm Morello Capabilities.

aarch64: morello: string: dummy c strchrnul

aarch64: morello: string: dummy c strlen

aarch64: morello: string: dummy c strnlen

aarch64: morello: string: dummy c strcpy and stpcpy

aarch64: morello: string: dummy c strcmp

aarch64: morello: string: dummy c strncmp

aarch64: morello: string: dummy c strchr

aarch64: morello: string: dummy c strrchr

aarch64: morello: string: dummy c strspn

avoids out of bound access of the generic implementation.

aarch64: morello: string: dummy c strcspn

avoids out of bounds access of the generic implementation.

aarch64: morello: update sysdep.h for purecap ABI

Add macro definitions for purecap ABI in sysdep.h.

TODO(gcc): cheri: work around a gcc bug in _dl_setup_stack_chk_guard

morello purecap gcc in some cases inlines 16byte memcpy as a capability
load, which is wrong if the source or dest may be unaligned.

stack guard only needs random for the address portion since only that
part is compared, so 8 byte is enough with 64 bit addresses, but the
current code is only right on little endian systems.

TODO: drop when gcc is fixed

cheri: __LP64__ is not defined for purecap ABI

There is no ideal ABI macro, so we assume __CHERI_PURE_CAPABILITY__
implies 64 bit long, 64 bit address and 128 bit pointer.

cheri: headers: Define {u}intptr_t and {u}intcap_t for CHERI

The CHERI pure capability programming model for C requires special
definition of {u}intptr_t.

Only the pure capability model is supported for hosted compilation,
but for freestanding compilation there is limited support for other
(hybrid capability) programming models too, which require new
{u}intcap_t type definitions.

aarch64: morello: use separate c++-types.data

The c++ mangling ABI for intptr_t and pthread_t are different on
morello.

aarch64: morello: use separate localplt data for morello

There is no longer PLT reference to matherr in libm.

aarch64: morello: Add separate lp64 and morello linux abilists

The base symbol version is 2.36.

aarch64: morello: Add purecap abi-variants on linux

aarch64: morello: configure change for purecap abi

Detect default-abi and add aarch64-purecap make variable.

Purecap abi sets HIDDEN_VAR_NEEDS_DYNAMIC_RELOC and unsets
SUPPORT_STATIC_PIE.

aarch64: morello: Use separate lp64 and morello sysdep directories

Provide separate directories for lp64 and purecap abi related sysdep
functionality.

purecap may be better name than morello, but we started with morello
and that is more future compatible with alternative cheri-like
extensions on top of aarch64.

aarch64: morello: add purecap support to build-many-glibcs.py

aarch64-linux-gnu compiler is a lp64,purecap multilib gcc and
supported glibc variants:

  aarch64-linux-gnu
  aarch64-linux-gnu-purecap
  aarch64-linux-gnu-purecap-nopie

aarch64-linux-gnu_purecap compiler is a default purecap gcc, with
supported glibc variants:

  aarch64-linux-gnu_purecap
  aarch64-linux-gnu_purecap-nopie

purecap libgomp and libitm builds fail so disabled for now.

aarch64: Use fewer ifdefs in bits/fcntl.h

This simplifies adding the Morello purecap abi target.

aarch64: cleanup MOVL definition in sysdep.h

PTR_REG is for ILP32, there is no point using it under __LP64__.

libio: adjust _IO_FILE / _IO_FILE_complete for 128 bit pointers

The size of the reserved space has to be adjusted because it underflows
with 16 byte pointers.  With the new value there should be enough space
for 2 more pointers in the struct on CHERI targets.

static: glibc-bug: NL_CURRENT_INDIRECT is broken so disable it

nl_langinfo_l ignores its locale argument with NL_CURRENT_INDIRECT
which is wrong when that argument does not match the current thread's
locale.

upstream glibc is not tested with static linking so this is not found.

cheri: Fix elf/tst-dlmodcount test

switch statement does not work for intptr_t, use a large int type
that's guaranteed to work.