fix 32 bit intel/amd compacting garbage collection for arrays with reserved memory to next power of 2, use label names __ARRAYP2__REAL__ and __ARRAYP2__BOOL__ instead of __ARRAY__REAL__ and __ARRAY__BOOL__

for 32 and 64 bit Intel/AMD add code for create_arrayp2 and create_arrayp2_ abc instructions to create arrays with reserved memory for extra elements to the next power of 2

add support for ARRAYP2 descriptors for arrays with reserved memory for elements up to the next power of 2 of the size to the garbage collectors for 32 and 64 bit Intel/AMD processors

for 64 bit intel/amd add missing equ for register d5d, fix cmpb mnemonic and add some ()'s for the microsoft assembler

change representation of arrays on intel/amd processors, remove descriptor from _ARRAY_ nodes, except for unboxed arrays of records, use _ARRAY_R_ descriptor for unboxed arrays of records, use _ARRAY_INT_, _ARRAY_REAL_, _ARRAY_BOOL_, _ARRAY_INT32_ or _ARRAY_REAL32_ descriptor for unboxed arrays of basic types, _ARRAY_ is still used for other arrays

fix assembling the 64 bit copying collector using gas, astartup.sed removed equ's for gas, use EQU instead of equ to convert to .equ using astartup.sed

refactor, in copying collector for 64 bit amd/intel add ws and wl equs, remove old code used before COPY_RECORDS_WITHOUT_POINTERS_TO_END_OF_HEAP

refactor, in copying collector for 32 bit intel add ws and wl equs, remove old code used before COPY_RECORDS_WITHOUT_POINTERS_TO_END_OF_HEAP

in the heap size message on 32 bit intel print compacting for compacting collections (same as on 64 bit amd/intel)

in the compacting garbage collector for 64 bit AMD/Intel mark and copy arrays without reordering records with both pointers and non pointers and swapping the length and element descriptor with the last two elements of arrays with pointers (same as previous commit for the 32 bit version)

the arrays are not reordered anymore

to mark an array using pointer reversal:
  - temporarily replace the _ARRAY_ descriptor with the previous node information, except the
    2 least significant bits. these are cleared because the least significant bit must be zero
    to detect reversed pointers
  - these 2 least significant bits from the previous node information are stored by temporarily
    multiplying the size by 4 and using the least significant 2 bits
  - the address of the array + 3 is stored in the first element of the array, or for unboxed
    arrays of records with both pointers and non pointers, in the first pointer of the current
    record to be marked
    the first argument of an argument part may also contain and address + 3 if the pointer to the
    argument part has been reversed. this pointer always points to a higher address. for arrays the
    address + 3 points to a lower address. so we can use this to distinguish these pointers
    while marking with pointer reversal. after marking this is no longer possible because
    forward pointers to argument parts will also be reversed.
  - the overwritten first element of the array or record in an array is stored in the element that
    is currently being marked, and later restored.
  - elements are marked in reverse order, so starting with the last pointer element
  - while marking we can detect if we have reached the first element because it is an address + 3
    that points backward. because this is the address of the array we can test if this is not
    yet the first record element of an array of records, and using the record descriptor determine
    the beginning and end of the previous (next to be marked) record element

in 32 bit Intel compacting garbage collector remove possible use of bit test, set or reset in memory instructions

the arrays are not reordered anymore

also change the mark bits that are used when marking the first argument of the arguments part of a node:
set the least significant 2 bits to 3 instead of 1

to mark such an array:
- temporarily overwrite the _ARRAY_ descriptor with the address of the pointer (of a previously marked node) to this node
- elements are marked in reverse order, so starting with the last pointer element
- temporarily overwrite the last pointer with a pointer to the beginning of the array
- mark the first pointer of the array, or the first pointer of the last record element if the record also contains non pointers,
  by setting the least significant 2 bits to 1
- continue marking by marking the elements, or the last record element
- after marking these elements, the beginning of the array can be recognized because we have a pointer to the array (in the element)
  and therefore the address of the first element
- if it was not the first element, we have marked a record element that also contains non pointers, we can load the record descriptor
  of the elements using the pointer to the array and compute the first and last pointer addresses of the previous record element,
  then temporarily store the address of the array in the last pointer and mark the least significant 2 bits of the first pointer
  with 1 and continue with marking this record element
- otherwise, the array has been marked, restore the _ARRAY_descriptor and
  continue marking using the address of the pointer that was stored there at the beginning

bug fix for 64 bit linux with stack tracing or time profiling, for the profile stack size use 4096 + the limit from getrlimit (RLIMIT_STACK) instead of the a stack size

Fix x86 repl_r_a_args_n_a; fetch arity without offset from descriptor

See merge request clean-compiler-and-rts/run-time-system!7

add function repl_r_a_args_n_a to push the pointers of a record on the A stack and yield the number of these pointers

bug fix for macosx, fix label in apply entry of build_node_2 that is used if garbage collection is necessary

fix bug in arm64 marking garbage collector, fix marking of strings in mark using pointer reversal (2 constants were incorrect, only one was fixed by the previous commit)