path: root/debian/patches/git-doc-updates.diff

# DP: updates from the 13 branch upto 20240119 (documentation).

LANG=C git diff --no-renames --src-prefix=a/src/ --dst-prefix=b/src/ \
	c891d8dc23e1a46ad9f3e757d09e57b500d40044 e3d4ebdc67ccb376916e140322d968571d114d18 \
	| awk '/^diff .*\.texi/ {skip=0; print; next} /^diff / {skip=1; next} skip==0' \
        | grep -v -E '^(diff|index)'

--- a/src/gcc/doc/avr-mmcu.texi
+++ b/src/gcc/doc/avr-mmcu.texi
@@ -50,11 +50,11 @@
 
 @item avrxmega2
 ``XMEGA'' devices with more than 8@tie{}KiB and up to 64@tie{}KiB of program memory.
-@*@var{mcu}@tie{}= @code{atxmega8e5}, @code{atxmega16a4}, @code{atxmega16a4u}, @code{atxmega16c4}, @code{atxmega16d4}, @code{atxmega16e5}, @code{atxmega32a4}, @code{atxmega32a4u}, @code{atxmega32c3}, @code{atxmega32c4}, @code{atxmega32d3}, @code{atxmega32d4}, @code{atxmega32e5}, @code{avr64da28}, @code{avr64da32}, @code{avr64da48}, @code{avr64da64}, @code{avr64db28}, @code{avr64db32}, @code{avr64db48}, @code{avr64db64}.
+@*@var{mcu}@tie{}= @code{atxmega8e5}, @code{atxmega16a4}, @code{atxmega16a4u}, @code{atxmega16c4}, @code{atxmega16d4}, @code{atxmega16e5}, @code{atxmega32a4}, @code{atxmega32a4u}, @code{atxmega32c3}, @code{atxmega32c4}, @code{atxmega32d3}, @code{atxmega32d4}, @code{atxmega32e5}, @code{avr64da28}, @code{avr64da32}, @code{avr64da48}, @code{avr64da64}, @code{avr64db28}, @code{avr64db32}, @code{avr64db48}, @code{avr64db64}, @code{avr64dd14}, @code{avr64dd20}, @code{avr64dd28}, @code{avr64dd32}, @code{avr64ea28}, @code{avr64ea32}, @code{avr64ea48}.
 
 @item avrxmega3
 ``XMEGA'' devices with up to 64@tie{}KiB of combined program memory and RAM, and with program memory visible in the RAM address space.
-@*@var{mcu}@tie{}= @code{attiny202}, @code{attiny204}, @code{attiny212}, @code{attiny214}, @code{attiny402}, @code{attiny404}, @code{attiny406}, @code{attiny412}, @code{attiny414}, @code{attiny416}, @code{attiny417}, @code{attiny804}, @code{attiny806}, @code{attiny807}, @code{attiny814}, @code{attiny816}, @code{attiny817}, @code{attiny1604}, @code{attiny1606}, @code{attiny1607}, @code{attiny1614}, @code{attiny1616}, @code{attiny1617}, @code{attiny3214}, @code{attiny3216}, @code{attiny3217}, @code{atmega808}, @code{atmega809}, @code{atmega1608}, @code{atmega1609}, @code{atmega3208}, @code{atmega3209}, @code{atmega4808}, @code{atmega4809}, @code{avr32da28}, @code{avr32da32}, @code{avr32da48}, @code{avr32db28}, @code{avr32db32}, @code{avr32db48}.
+@*@var{mcu}@tie{}= @code{attiny202}, @code{attiny204}, @code{attiny212}, @code{attiny214}, @code{attiny402}, @code{attiny404}, @code{attiny406}, @code{attiny412}, @code{attiny414}, @code{attiny416}, @code{attiny417}, @code{attiny424}, @code{attiny426}, @code{attiny427}, @code{attiny804}, @code{attiny806}, @code{attiny807}, @code{attiny814}, @code{attiny816}, @code{attiny817}, @code{attiny824}, @code{attiny826}, @code{attiny827}, @code{attiny1604}, @code{attiny1606}, @code{attiny1607}, @code{attiny1614}, @code{attiny1616}, @code{attiny1617}, @code{attiny1624}, @code{attiny1626}, @code{attiny1627}, @code{attiny3214}, @code{attiny3216}, @code{attiny3217}, @code{attiny3224}, @code{attiny3226}, @code{attiny3227}, @code{atmega808}, @code{atmega809}, @code{atmega1608}, @code{atmega1609}, @code{atmega3208}, @code{atmega3209}, @code{atmega4808}, @code{atmega4809}, @code{avr16dd14}, @code{avr16dd20}, @code{avr16dd28}, @code{avr16dd32}, @code{avr32da28}, @code{avr32da32}, @code{avr32da48}, @code{avr32db28}, @code{avr32db32}, @code{avr32db48}, @code{avr32dd14}, @code{avr32dd20}, @code{avr32dd28}, @code{avr32dd32}.
 
 @item avrxmega4
 ``XMEGA'' devices with more than 64@tie{}KiB and up to 128@tie{}KiB of program memory.
@@ -74,7 +74,7 @@
 
 @item avrtiny
 ``TINY'' Tiny core devices with 512@tie{}B up to 4@tie{}KiB of program memory.
-@*@var{mcu}@tie{}= @code{attiny4}, @code{attiny5}, @code{attiny9}, @code{attiny10}, @code{attiny20}, @code{attiny40}.
+@*@var{mcu}@tie{}= @code{attiny4}, @code{attiny5}, @code{attiny9}, @code{attiny10}, @code{attiny102}, @code{attiny104}, @code{attiny20}, @code{attiny40}.
 
 @item avr1
 This ISA is implemented by the minimal AVR core and supported for assembler only.
--- a/src/gcc/doc/extend.texi
+++ b/src/gcc/doc/extend.texi
@@ -1076,7 +1076,7 @@ infinities, NaNs and negative zeros are involved.
 ISO/IEC TS 18661-3:2015 defines C support for additional floating
 types @code{_Float@var{n}} and @code{_Float@var{n}x}, and GCC supports
 these type names; the set of types supported depends on the target
-architecture.  These types are not supported when compiling C++.
+architecture.
 Constants with these types use suffixes @code{f@var{n}} or
 @code{F@var{n}} and @code{f@var{n}x} or @code{F@var{n}x}.  These type
 names can be used together with @code{_Complex} to declare complex
@@ -12308,12 +12308,12 @@ variables to be protected.  The list is ignored by GCC which treats it as
 empty.  GCC interprets an empty list as meaning that all globally
 accessible variables should be protected.
 
-@defbuiltin{@var{type} __sync_fetch_and_add (@var{type} *ptr, @var{type} value, ...)}
-@defbuiltinx{@var{type} __sync_fetch_and_sub (@var{type} *ptr, @var{type} value, ...)}
-@defbuiltinx{@var{type} __sync_fetch_and_or (@var{type} *ptr, @var{type} value, ...)}
-@defbuiltinx{@var{type} __sync_fetch_and_and (@var{type} *ptr, @var{type} value, ...)}
-@defbuiltinx{@var{type} __sync_fetch_and_xor (@var{type} *ptr, @var{type} value, ...)}
-@defbuiltinx{@var{type} __sync_fetch_and_nand (@var{type} *ptr, @var{type} value, ...)}
+@defbuiltin{@var{type} __sync_fetch_and_add (@var{type} *@var{ptr}, @var{type} @var{value}, ...)}
+@defbuiltinx{@var{type} __sync_fetch_and_sub (@var{type} *@var{ptr}, @var{type} @var{value}, ...)}
+@defbuiltinx{@var{type} __sync_fetch_and_or (@var{type} *@var{ptr}, @var{type} @var{value}, ...)}
+@defbuiltinx{@var{type} __sync_fetch_and_and (@var{type} *@var{ptr}, @var{type} @var{value}, ...)}
+@defbuiltinx{@var{type} __sync_fetch_and_xor (@var{type} *@var{ptr}, @var{type} @var{value}, ...)}
+@defbuiltinx{@var{type} __sync_fetch_and_nand (@var{type} *@var{ptr}, @var{type} @var{value}, ...)}
 These built-in functions perform the operation suggested by the name, and
 returns the value that had previously been in memory.  That is, operations
 on integer operands have the following semantics.  Operations on pointer
@@ -12333,13 +12333,13 @@ type.  It must not be a boolean type.
 as @code{*ptr = ~(tmp & value)} instead of @code{*ptr = ~tmp & value}.
 @enddefbuiltin
 
-@defbuiltin{@var{type} __sync_add_and_fetch (@var{type} *ptr, @
-                                             @var{type} value, ...)}
-@defbuiltinx{@var{type} __sync_sub_and_fetch (@var{type} *ptr, @var{type} value, ...)}
-@defbuiltinx{@var{type} __sync_or_and_fetch (@var{type} *ptr, @var{type} value, ...)}
-@defbuiltinx{@var{type} __sync_and_and_fetch (@var{type} *ptr, @var{type} value, ...)}
-@defbuiltinx{@var{type} __sync_xor_and_fetch (@var{type} *ptr, @var{type} value, ...)}
-@defbuiltinx{@var{type} __sync_nand_and_fetch (@var{type} *ptr, @var{type} value, ...)}
+@defbuiltin{@var{type} __sync_add_and_fetch (@var{type} *@var{ptr}, @
+                                             @var{type} @var{value}, ...)}
+@defbuiltinx{@var{type} __sync_sub_and_fetch (@var{type} *@var{ptr}, @var{type} @var{value}, ...)}
+@defbuiltinx{@var{type} __sync_or_and_fetch (@var{type} *@var{ptr}, @var{type} @var{value}, ...)}
+@defbuiltinx{@var{type} __sync_and_and_fetch (@var{type} *@var{ptr}, @var{type} @var{value}, ...)}
+@defbuiltinx{@var{type} __sync_xor_and_fetch (@var{type} *@var{ptr}, @var{type} @var{value}, ...)}
+@defbuiltinx{@var{type} __sync_nand_and_fetch (@var{type} *@var{ptr}, @var{type} @var{value}, ...)}
 These built-in functions perform the operation suggested by the name, and
 return the new value.  That is, operations on integer operands have
 the following semantics.  Operations on pointer operands are performed as
@@ -12358,8 +12358,8 @@ as @code{*ptr = ~(*ptr & value)} instead of
 @code{*ptr = ~*ptr & value}.
 @enddefbuiltin
 
-@defbuiltin{bool __sync_bool_compare_and_swap (@var{type} *ptr, @var{type} oldval, @var{type} newval, ...)}
-@defbuiltinx{@var{type} __sync_val_compare_and_swap (@var{type} *ptr, @var{type} oldval, @var{type} newval, ...)}
+@defbuiltin{bool __sync_bool_compare_and_swap (@var{type} *@var{ptr}, @var{type} @var{oldval}, @var{type} @var{newval}, ...)}
+@defbuiltinx{@var{type} __sync_val_compare_and_swap (@var{type} *@var{ptr}, @var{type} @var{oldval}, @var{type} @var{newval}, ...)}
 These built-in functions perform an atomic compare and swap.
 That is, if the current
 value of @code{*@var{ptr}} is @var{oldval}, then write @var{newval} into
@@ -12374,7 +12374,7 @@ of @code{*@var{ptr}} before the operation.
 This built-in function issues a full memory barrier.
 @enddefbuiltin
 
-@defbuiltin{@var{type} __sync_lock_test_and_set (@var{type} *ptr, @var{type} value, ...)}
+@defbuiltin{@var{type} __sync_lock_test_and_set (@var{type} *@var{ptr}, @var{type} @var{value}, ...)}
 This built-in function, as described by Intel, is not a traditional test-and-set
 operation, but rather an atomic exchange operation.  It writes @var{value}
 into @code{*@var{ptr}}, and returns the previous contents of
@@ -12394,7 +12394,7 @@ be globally visible yet, and previous memory loads may not yet be
 satisfied.
 @enddefbuiltin
 
-@defbuiltin{void __sync_lock_release (@var{type} *ptr, ...)}
+@defbuiltin{void __sync_lock_release (@var{type} *@var{ptr}, ...)}
 This built-in function releases the lock acquired by
 @code{__sync_lock_test_and_set}.
 Normally this means writing the constant 0 to @code{*@var{ptr}}.
@@ -12511,7 +12511,7 @@ reserved for the memory order.  The remainder of the signed int is reserved
 for target use and should be 0.  Use of the predefined atomic values
 ensures proper usage.
 
-@defbuiltin{@var{type} __atomic_load_n (@var{type} *ptr, int memorder)}
+@defbuiltin{@var{type} __atomic_load_n (@var{type} *@var{ptr}, int @var{memorder})}
 This built-in function implements an atomic load operation.  It returns the
 contents of @code{*@var{ptr}}.
 
@@ -12521,13 +12521,13 @@ and @code{__ATOMIC_CONSUME}.
 
 @enddefbuiltin
 
-@defbuiltin{void __atomic_load (@var{type} *ptr, @var{type} *ret, int memorder)}
+@defbuiltin{void __atomic_load (@var{type} *@var{ptr}, @var{type} *@var{ret}, int @var{memorder})}
 This is the generic version of an atomic load.  It returns the
 contents of @code{*@var{ptr}} in @code{*@var{ret}}.
 
 @enddefbuiltin
 
-@defbuiltin{void __atomic_store_n (@var{type} *ptr, @var{type} val, int memorder)}
+@defbuiltin{void __atomic_store_n (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
 This built-in function implements an atomic store operation.  It writes 
 @code{@var{val}} into @code{*@var{ptr}}.  
 
@@ -12536,13 +12536,13 @@ The valid memory order variants are
 
 @enddefbuiltin
 
-@defbuiltin{void __atomic_store (@var{type} *ptr, @var{type} *val, int memorder)}
+@defbuiltin{void __atomic_store (@var{type} *@var{ptr}, @var{type} *@var{val}, int @var{memorder})}
 This is the generic version of an atomic store.  It stores the value
 of @code{*@var{val}} into @code{*@var{ptr}}.
 
 @enddefbuiltin
 
-@defbuiltin{@var{type} __atomic_exchange_n (@var{type} *ptr, @var{type} val, int memorder)}
+@defbuiltin{@var{type} __atomic_exchange_n (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
 This built-in function implements an atomic exchange operation.  It writes
 @var{val} into @code{*@var{ptr}}, and returns the previous contents of
 @code{*@var{ptr}}.
@@ -12551,14 +12551,14 @@ All memory order variants are valid.
 
 @enddefbuiltin
 
-@defbuiltin{void __atomic_exchange (@var{type} *ptr, @var{type} *val, @var{type} *ret, int memorder)}
+@defbuiltin{void __atomic_exchange (@var{type} *@var{ptr}, @var{type} *@var{val}, @var{type} *@var{ret}, int @var{memorder})}
 This is the generic version of an atomic exchange.  It stores the
 contents of @code{*@var{val}} into @code{*@var{ptr}}. The original value
 of @code{*@var{ptr}} is copied into @code{*@var{ret}}.
 
 @enddefbuiltin
 
-@defbuiltin{bool __atomic_compare_exchange_n (@var{type} *ptr, @var{type} *expected, @var{type} desired, bool weak, int success_memorder, int failure_memorder)}
+@defbuiltin{bool __atomic_compare_exchange_n (@var{type} *@var{ptr}, @var{type} *@var{expected}, @var{type} @var{desired}, bool @var{weak}, int @var{success_memorder}, int @var{failure_memorder})}
 This built-in function implements an atomic compare and exchange operation.
 This compares the contents of @code{*@var{ptr}} with the contents of
 @code{*@var{expected}}. If equal, the operation is a @emph{read-modify-write}
@@ -12582,7 +12582,7 @@ stronger order than that specified by @var{success_memorder}.
 
 @enddefbuiltin
 
-@defbuiltin{bool __atomic_compare_exchange (@var{type} *ptr, @var{type} *expected, @var{type} *desired, bool weak, int success_memorder, int failure_memorder)}
+@defbuiltin{bool __atomic_compare_exchange (@var{type} *@var{ptr}, @var{type} *@var{expected}, @var{type} *@var{desired}, bool @var{weak}, int @var{success_memorder}, int @var{failure_memorder})}
 This built-in function implements the generic version of
 @code{__atomic_compare_exchange}.  The function is virtually identical to
 @code{__atomic_compare_exchange_n}, except the desired value is also a
@@ -12590,12 +12590,12 @@ pointer.
 
 @enddefbuiltin
 
-@defbuiltin{@var{type} __atomic_add_fetch (@var{type} *ptr, @var{type} val, int memorder)}
-@defbuiltinx{@var{type} __atomic_sub_fetch (@var{type} *ptr, @var{type} val, int memorder)}
-@defbuiltinx{@var{type} __atomic_and_fetch (@var{type} *ptr, @var{type} val, int memorder)}
-@defbuiltinx{@var{type} __atomic_xor_fetch (@var{type} *ptr, @var{type} val, int memorder)}
-@defbuiltinx{@var{type} __atomic_or_fetch (@var{type} *ptr, @var{type} val, int memorder)}
-@defbuiltinx{@var{type} __atomic_nand_fetch (@var{type} *ptr, @var{type} val, int memorder)}
+@defbuiltin{@var{type} __atomic_add_fetch (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
+@defbuiltinx{@var{type} __atomic_sub_fetch (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
+@defbuiltinx{@var{type} __atomic_and_fetch (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
+@defbuiltinx{@var{type} __atomic_xor_fetch (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
+@defbuiltinx{@var{type} __atomic_or_fetch (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
+@defbuiltinx{@var{type} __atomic_nand_fetch (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
 These built-in functions perform the operation suggested by the name, and
 return the result of the operation.  Operations on pointer arguments are
 performed as if the operands were of the @code{uintptr_t} type.  That is,
@@ -12611,12 +12611,12 @@ type.  It must not be a boolean type.  All memory orders are valid.
 
 @enddefbuiltin
 
-@defbuiltin{@var{type} __atomic_fetch_add (@var{type} *ptr, @var{type} val, int memorder)}
-@defbuiltinx{@var{type} __atomic_fetch_sub (@var{type} *ptr, @var{type} val, int memorder)}
-@defbuiltinx{@var{type} __atomic_fetch_and (@var{type} *ptr, @var{type} val, int memorder)}
-@defbuiltinx{@var{type} __atomic_fetch_xor (@var{type} *ptr, @var{type} val, int memorder)}
-@defbuiltinx{@var{type} __atomic_fetch_or (@var{type} *ptr, @var{type} val, int memorder)}
-@defbuiltinx{@var{type} __atomic_fetch_nand (@var{type} *ptr, @var{type} val, int memorder)}
+@defbuiltin{@var{type} __atomic_fetch_add (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
+@defbuiltinx{@var{type} __atomic_fetch_sub (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
+@defbuiltinx{@var{type} __atomic_fetch_and (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
+@defbuiltinx{@var{type} __atomic_fetch_xor (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
+@defbuiltinx{@var{type} __atomic_fetch_or (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
+@defbuiltinx{@var{type} __atomic_fetch_nand (@var{type} *@var{ptr}, @var{type} @var{val}, int @var{memorder})}
 These built-in functions perform the operation suggested by the name, and
 return the value that had previously been in @code{*@var{ptr}}.  Operations
 on pointer arguments are performed as if the operands were of
@@ -12633,7 +12633,7 @@ The same constraints on arguments apply as for the corresponding
 
 @enddefbuiltin
 
-@defbuiltin{bool __atomic_test_and_set (void *ptr, int memorder)}
+@defbuiltin{bool __atomic_test_and_set (void *@var{ptr}, int @var{memorder})}
 
 This built-in function performs an atomic test-and-set operation on
 the byte at @code{*@var{ptr}}.  The byte is set to some implementation
@@ -12646,7 +12646,7 @@ All memory orders are valid.
 
 @enddefbuiltin
 
-@defbuiltin{void __atomic_clear (bool *ptr, int memorder)}
+@defbuiltin{void __atomic_clear (bool *@var{ptr}, int @var{memorder})}
 
 This built-in function performs an atomic clear operation on
 @code{*@var{ptr}}.  After the operation, @code{*@var{ptr}} contains 0.
@@ -12661,7 +12661,7 @@ The valid memory order variants are
 
 @enddefbuiltin
 
-@defbuiltin{void __atomic_thread_fence (int memorder)}
+@defbuiltin{void __atomic_thread_fence (int @var{memorder})}
 
 This built-in function acts as a synchronization fence between threads
 based on the specified memory order.
@@ -12670,7 +12670,7 @@ All memory orders are valid.
 
 @enddefbuiltin
 
-@defbuiltin{void __atomic_signal_fence (int memorder)}
+@defbuiltin{void __atomic_signal_fence (int @var{memorder})}
 
 This built-in function acts as a synchronization fence between a thread
 and signal handlers based in the same thread.
@@ -12679,7 +12679,7 @@ All memory orders are valid.
 
 @enddefbuiltin
 
-@defbuiltin{bool __atomic_always_lock_free (size_t size,  void *ptr)}
+@defbuiltin{bool __atomic_always_lock_free (size_t @var{size},  void *@var{ptr})}
 
 This built-in function returns @code{true} if objects of @var{size} bytes always
 generate lock-free atomic instructions for the target architecture.
@@ -12696,7 +12696,7 @@ if (__atomic_always_lock_free (sizeof (long long), 0))
 
 @enddefbuiltin
 
-@defbuiltin{bool __atomic_is_lock_free (size_t size, void *ptr)}
+@defbuiltin{bool __atomic_is_lock_free (size_t @var{size}, void *@var{ptr})}
 
 This built-in function returns @code{true} if objects of @var{size} bytes always
 generate lock-free atomic instructions for the target architecture.  If
@@ -12714,13 +12714,13 @@ compiler may also ignore this parameter.
 The following built-in functions allow performing simple arithmetic operations
 together with checking whether the operations overflowed.
 
-@defbuiltin{bool __builtin_add_overflow (@var{type1} a, @var{type2} b, @var{type3} *res)}
-@defbuiltinx{bool __builtin_sadd_overflow (int a, int b, int *res)}
-@defbuiltinx{bool __builtin_saddl_overflow (long int a, long int b, long int *res)}
-@defbuiltinx{bool __builtin_saddll_overflow (long long int a, long long int b, long long int *res)}
-@defbuiltinx{bool __builtin_uadd_overflow (unsigned int a, unsigned int b, unsigned int *res)}
-@defbuiltinx{bool __builtin_uaddl_overflow (unsigned long int a, unsigned long int b, unsigned long int *res)}
-@defbuiltinx{bool __builtin_uaddll_overflow (unsigned long long int a, unsigned long long int b, unsigned long long int *res)}
+@defbuiltin{bool __builtin_add_overflow (@var{type1} @var{a}, @var{type2} @var{b}, @var{type3} *@var{res})}
+@defbuiltinx{bool __builtin_sadd_overflow (int @var{a}, int @var{b}, int *@var{res})}
+@defbuiltinx{bool __builtin_saddl_overflow (long int @var{a}, long int @var{b}, long int *@var{res})}
+@defbuiltinx{bool __builtin_saddll_overflow (long long int @var{a}, long long int @var{b}, long long int *@var{res})}
+@defbuiltinx{bool __builtin_uadd_overflow (unsigned int @var{a}, unsigned int @var{b}, unsigned int *@var{res})}
+@defbuiltinx{bool __builtin_uaddl_overflow (unsigned long int @var{a}, unsigned long int @var{b}, unsigned long int *@var{res})}
+@defbuiltinx{bool __builtin_uaddll_overflow (unsigned long long int @var{a}, unsigned long long int @var{b}, unsigned long long int *@var{res})}
 
 These built-in functions promote the first two operands into infinite precision signed
 type and perform addition on those promoted operands.  The result is then
@@ -12740,13 +12740,13 @@ after addition, conditional jump on carry etc.
 
 @enddefbuiltin
 
-@defbuiltin{bool __builtin_sub_overflow (@var{type1} a, @var{type2} b, @var{type3} *res)}
-@defbuiltinx{bool __builtin_ssub_overflow (int a, int b, int *res)}
-@defbuiltinx{bool __builtin_ssubl_overflow (long int a, long int b, long int *res)}
-@defbuiltinx{bool __builtin_ssubll_overflow (long long int a, long long int b, long long int *res)}
-@defbuiltinx{bool __builtin_usub_overflow (unsigned int a, unsigned int b, unsigned int *res)}
-@defbuiltinx{bool __builtin_usubl_overflow (unsigned long int a, unsigned long int b, unsigned long int *res)}
-@defbuiltinx{bool __builtin_usubll_overflow (unsigned long long int a, unsigned long long int b, unsigned long long int *res)}
+@defbuiltin{bool __builtin_sub_overflow (@var{type1} @var{a}, @var{type2} @var{b}, @var{type3} *@var{res})}
+@defbuiltinx{bool __builtin_ssub_overflow (int @var{a}, int @var{b}, int *@var{res})}
+@defbuiltinx{bool __builtin_ssubl_overflow (long int @var{a}, long int @var{b}, long int *@var{res})}
+@defbuiltinx{bool __builtin_ssubll_overflow (long long int @var{a}, long long int @var{b}, long long int *@var{res})}
+@defbuiltinx{bool __builtin_usub_overflow (unsigned int @var{a}, unsigned int @var{b}, unsigned int *@var{res})}
+@defbuiltinx{bool __builtin_usubl_overflow (unsigned long int @var{a}, unsigned long int @var{b}, unsigned long int *@var{res})}
+@defbuiltinx{bool __builtin_usubll_overflow (unsigned long long int @var{a}, unsigned long long int @var{b}, unsigned long long int *@var{res})}
 
 These built-in functions are similar to the add overflow checking built-in
 functions above, except they perform subtraction, subtract the second argument
@@ -12754,13 +12754,13 @@ from the first one, instead of addition.
 
 @enddefbuiltin
 
-@defbuiltin{bool __builtin_mul_overflow (@var{type1} a, @var{type2} b, @var{type3} *res)}
-@defbuiltinx{bool __builtin_smul_overflow (int a, int b, int *res)}
-@defbuiltinx{bool __builtin_smull_overflow (long int a, long int b, long int *res)}
-@defbuiltinx{bool __builtin_smulll_overflow (long long int a, long long int b, long long int *res)}
-@defbuiltinx{bool __builtin_umul_overflow (unsigned int a, unsigned int b, unsigned int *res)}
-@defbuiltinx{bool __builtin_umull_overflow (unsigned long int a, unsigned long int b, unsigned long int *res)}
-@defbuiltinx{bool __builtin_umulll_overflow (unsigned long long int a, unsigned long long int b, unsigned long long int *res)}
+@defbuiltin{bool __builtin_mul_overflow (@var{type1} @var{a}, @var{type2} @var{b}, @var{type3} *@var{res})}
+@defbuiltinx{bool __builtin_smul_overflow (int @var{a}, int @var{b}, int *@var{res})}
+@defbuiltinx{bool __builtin_smull_overflow (long int @var{a}, long int @var{b}, long int *@var{res})}
+@defbuiltinx{bool __builtin_smulll_overflow (long long int @var{a}, long long int @var{b}, long long int *@var{res})}
+@defbuiltinx{bool __builtin_umul_overflow (unsigned int @var{a}, unsigned int @var{b}, unsigned int *@var{res})}
+@defbuiltinx{bool __builtin_umull_overflow (unsigned long int @var{a}, unsigned long int @var{b}, unsigned long int *@var{res})}
+@defbuiltinx{bool __builtin_umulll_overflow (unsigned long long int @var{a}, unsigned long long int @var{b}, unsigned long long int *@var{res})}
 
 These built-in functions are similar to the add overflow checking built-in
 functions above, except they perform multiplication, instead of addition.
@@ -12770,9 +12770,9 @@ functions above, except they perform multiplication, instead of addition.
 The following built-in functions allow checking if simple arithmetic operation
 would overflow.
 
-@defbuiltin{bool __builtin_add_overflow_p (@var{type1} a, @var{type2} b, @var{type3} c)}
-@defbuiltinx{bool __builtin_sub_overflow_p (@var{type1} a, @var{type2} b, @var{type3} c)}
-@defbuiltinx{bool __builtin_mul_overflow_p (@var{type1} a, @var{type2} b, @var{type3} c)}
+@defbuiltin{bool __builtin_add_overflow_p (@var{type1} @var{a}, @var{type2} @var{b}, @var{type3} @var{c})}
+@defbuiltinx{bool __builtin_sub_overflow_p (@var{type1} @var{a}, @var{type2} @var{b}, @var{type3} @var{c})}
+@defbuiltinx{bool __builtin_mul_overflow_p (@var{type1} @var{a}, @var{type2} @var{b}, @var{type3} @var{c})}
 
 These built-in functions are similar to @code{__builtin_add_overflow},
 @code{__builtin_sub_overflow}, or @code{__builtin_mul_overflow}, except that
@@ -13573,7 +13573,7 @@ for all target libcs, but in all cases they will gracefully fallback to libc
 calls.  These built-in functions appear both with and without the
 @code{__builtin_} prefix.
 
-@defbuiltin{{void *} __builtin_alloca (size_t size)}
+@defbuiltin{{void *} __builtin_alloca (size_t @var{size})}
 The @code{__builtin_alloca} function must be called at block scope.
 The function allocates an object @var{size} bytes large on the stack
 of the calling function.  The object is aligned on the default stack
@@ -13613,7 +13613,7 @@ where GCC provides them as an extension.
 
 @enddefbuiltin
 
-@defbuiltin{{void *} __builtin_alloca_with_align (size_t size, size_t alignment)}
+@defbuiltin{{void *} __builtin_alloca_with_align (size_t @var{size}, size_t @var{alignment})}
 The @code{__builtin_alloca_with_align} function must be called at block
 scope.  The function allocates an object @var{size} bytes large on
 the stack of the calling function.  The allocated object is aligned on
@@ -13660,7 +13660,7 @@ an extension.  @xref{Variable Length}, for details.
 
 @enddefbuiltin
 
-@defbuiltin{{void *} __builtin_alloca_with_align_and_max (size_t size, size_t alignment, size_t max_size)}
+@defbuiltin{{void *} __builtin_alloca_with_align_and_max (size_t @var{size}, size_t @var{alignment}, size_t @var{max_size})}
 Similar to @code{__builtin_alloca_with_align} but takes an extra argument
 specifying an upper bound for @var{size} in case its value cannot be computed
 at compile time, for use by @option{-fstack-usage}, @option{-Wstack-usage}
@@ -13713,7 +13713,7 @@ recognized in such contexts.
 
 @enddefbuiltin
 
-@defbuiltin{@var{type} __builtin_speculation_safe_value (@var{type} val, @var{type} failval)}
+@defbuiltin{@var{type} __builtin_speculation_safe_value (@var{type} @var{val}, @var{type} @var{failval})}
 
 This built-in function can be used to help mitigate against unsafe
 speculative execution.  @var{type} may be any integral type or any
@@ -14419,7 +14419,7 @@ argument.  GCC treats this parameter as type-generic, which means it
 does not do default promotion from float to double.
 @enddefbuiltin
 
-@defbuiltin{double __builtin_nan (const char *str)}
+@defbuiltin{double __builtin_nan (const char *@var{str})}
 This is an implementation of the ISO C99 function @code{nan}.
 
 Since ISO C99 defines this function in terms of @code{strtod}, which we
@@ -14436,68 +14436,68 @@ consumed by @code{strtol}, is evaluated early enough that it is considered a
 compile-time constant.
 @enddefbuiltin
 
-@defbuiltin{_Decimal32 __builtin_nand32 (const char *str)}
+@defbuiltin{_Decimal32 __builtin_nand32 (const char *@var{str})}
 Similar to @code{__builtin_nan}, except the return type is @code{_Decimal32}.
 @enddefbuiltin
 
-@defbuiltin{_Decimal64 __builtin_nand64 (const char *str)}
+@defbuiltin{_Decimal64 __builtin_nand64 (const char *@var{str})}
 Similar to @code{__builtin_nan}, except the return type is @code{_Decimal64}.
 @enddefbuiltin
 
-@defbuiltin{_Decimal128 __builtin_nand128 (const char *str)}
+@defbuiltin{_Decimal128 __builtin_nand128 (const char *@var{str})}
 Similar to @code{__builtin_nan}, except the return type is @code{_Decimal128}.
 @enddefbuiltin
 
-@defbuiltin{float __builtin_nanf (const char *str)}
+@defbuiltin{float __builtin_nanf (const char *@var{str})}
 Similar to @code{__builtin_nan}, except the return type is @code{float}.
 @enddefbuiltin
 
-@defbuiltin{{long double} __builtin_nanl (const char *str)}
+@defbuiltin{{long double} __builtin_nanl (const char *@var{str})}
 Similar to @code{__builtin_nan}, except the return type is @code{long double}.
 @enddefbuiltin
 
-@defbuiltin{_Float@var{n} __builtin_nanf@var{n} (const char *str)}
+@defbuiltin{_Float@var{n} __builtin_nanf@var{n} (const char *@var{str})}
 Similar to @code{__builtin_nan}, except the return type is
 @code{_Float@var{n}}.
 @enddefbuiltin
 
-@defbuiltin{_Float@var{n}x __builtin_nanf@var{n}x (const char *str)}
+@defbuiltin{_Float@var{n}x __builtin_nanf@var{n}x (const char *@var{str})}
 Similar to @code{__builtin_nan}, except the return type is
 @code{_Float@var{n}x}.
 @enddefbuiltin
 
-@defbuiltin{double __builtin_nans (const char *str)}
+@defbuiltin{double __builtin_nans (const char *@var{str})}
 Similar to @code{__builtin_nan}, except the significand is forced
 to be a signaling NaN@.  The @code{nans} function is proposed by
 @uref{https://www.open-std.org/jtc1/sc22/wg14/www/docs/n965.htm,,WG14 N965}.
 @enddefbuiltin
 
-@defbuiltin{_Decimal32 __builtin_nansd32 (const char *str)}
+@defbuiltin{_Decimal32 __builtin_nansd32 (const char *@var{str})}
 Similar to @code{__builtin_nans}, except the return type is @code{_Decimal32}.
 @enddefbuiltin
 
-@defbuiltin{_Decimal64 __builtin_nansd64 (const char *str)}
+@defbuiltin{_Decimal64 __builtin_nansd64 (const char *@var{str})}
 Similar to @code{__builtin_nans}, except the return type is @code{_Decimal64}.
 @enddefbuiltin
 
-@defbuiltin{_Decimal128 __builtin_nansd128 (const char *str)}
+@defbuiltin{_Decimal128 __builtin_nansd128 (const char *@var{str})}
 Similar to @code{__builtin_nans}, except the return type is @code{_Decimal128}.
 @enddefbuiltin
 
-@defbuiltin{float __builtin_nansf (const char *str)}
+@defbuiltin{float __builtin_nansf (const char *@var{str})}
 Similar to @code{__builtin_nans}, except the return type is @code{float}.
 @enddefbuiltin
 
-@defbuiltin{{long double} __builtin_nansl (const char *str)}
+@defbuiltin{{long double} __builtin_nansl (const char *@var{str})}
 Similar to @code{__builtin_nans}, except the return type is @code{long double}.
 @enddefbuiltin
 
-@defbuiltin{_Float@var{n} __builtin_nansf@var{n} (const char *str)}
+@defbuiltin{_Float@var{n} __builtin_nansf@var{n} (const char *@var{str})}
 Similar to @code{__builtin_nans}, except the return type is
 @code{_Float@var{n}}.
 @enddefbuiltin
 
-@defbuiltin{_Float@var{n}x __builtin_nansf@var{n}x (const char *str)}
+@defbuiltin{_Float@var{n}x __builtin_nansf@var{n}x (const char *@var{str})}
 Similar to @code{__builtin_nans}, except the return type is
 @code{_Float@var{n}x}.
 @enddefbuiltin
@@ -14516,32 +14516,32 @@ With @code{-ffinite-math-only} option this built-in function will always
 return 0.
 @enddefbuiltin
 
-@defbuiltin{int __builtin_ffs (int x)}
+@defbuiltin{int __builtin_ffs (int @var{x})}
 Returns one plus the index of the least significant 1-bit of @var{x}, or
 if @var{x} is zero, returns zero.
 @enddefbuiltin
 
-@defbuiltin{int __builtin_clz (unsigned int x)}
+@defbuiltin{int __builtin_clz (unsigned int @var{x})}
 Returns the number of leading 0-bits in @var{x}, starting at the most
 significant bit position.  If @var{x} is 0, the result is undefined.
 @enddefbuiltin
 
-@defbuiltin{int __builtin_ctz (unsigned int x)}
+@defbuiltin{int __builtin_ctz (unsigned int @var{x})}
 Returns the number of trailing 0-bits in @var{x}, starting at the least
 significant bit position.  If @var{x} is 0, the result is undefined.
 @enddefbuiltin
 
-@defbuiltin{int __builtin_clrsb (int x)}
+@defbuiltin{int __builtin_clrsb (int @var{x})}
 Returns the number of leading redundant sign bits in @var{x}, i.e.@: the
 number of bits following the most significant bit that are identical
 to it.  There are no special cases for 0 or other values. 
 @enddefbuiltin
 
-@defbuiltin{int __builtin_popcount (unsigned int x)}
+@defbuiltin{int __builtin_popcount (unsigned int @var{x})}
 Returns the number of 1-bits in @var{x}.
 @enddefbuiltin
 
-@defbuiltin{int __builtin_parity (unsigned int x)}
+@defbuiltin{int __builtin_parity (unsigned int @var{x})}
 Returns the parity of @var{x}, i.e.@: the number of 1-bits in @var{x}
 modulo 2.
 @enddefbuiltin
@@ -14613,29 +14613,29 @@ Returns the first argument raised to the power of the second.  Unlike the
 @code{pow} function no guarantees about precision and rounding are made.
 @enddefbuiltin
 
-@defbuiltin{uint16_t __builtin_bswap16 (uint16_t x)}
+@defbuiltin{uint16_t __builtin_bswap16 (uint16_t @var{x})}
 Returns @var{x} with the order of the bytes reversed; for example,
 @code{0xaabb} becomes @code{0xbbaa}.  Byte here always means
 exactly 8 bits.
 @enddefbuiltin
 
-@defbuiltin{uint32_t __builtin_bswap32 (uint32_t x)}
+@defbuiltin{uint32_t __builtin_bswap32 (uint32_t @var{x})}
 Similar to @code{__builtin_bswap16}, except the argument and return types
 are 32-bit.
 @enddefbuiltin
 
-@defbuiltin{uint64_t __builtin_bswap64 (uint64_t x)}
+@defbuiltin{uint64_t __builtin_bswap64 (uint64_t @var{x})}
 Similar to @code{__builtin_bswap32}, except the argument and return types
 are 64-bit.
 @enddefbuiltin
 
-@defbuiltin{uint128_t __builtin_bswap128 (uint128_t x)}
+@defbuiltin{uint128_t __builtin_bswap128 (uint128_t @var{x})}
 Similar to @code{__builtin_bswap64}, except the argument and return types
 are 128-bit.  Only supported on targets when 128-bit types are supported.
 @enddefbuiltin
 
 
-@defbuiltin{Pmode __builtin_extend_pointer (void * x)}
+@defbuiltin{Pmode __builtin_extend_pointer (void * @var{x})}
 On targets where the user visible pointer size is smaller than the size
 of an actual hardware address this function returns the extended user
 pointer.  Targets where this is true included ILP32 mode on x86_64 or
@@ -14643,12 +14643,12 @@ Aarch64.  This function is mainly useful when writing inline assembly
 code.
 @enddefbuiltin
 
-@defbuiltin{int __builtin_goacc_parlevel_id (int x)}
+@defbuiltin{int __builtin_goacc_parlevel_id (int @var{x})}
 Returns the openacc gang, worker or vector id depending on whether @var{x} is
 0, 1 or 2.
 @enddefbuiltin
 
-@defbuiltin{int __builtin_goacc_parlevel_size (int x)}
+@defbuiltin{int __builtin_goacc_parlevel_size (int @var{x})}
 Returns the openacc gang, worker or vector size depending on whether @var{x} is
 0, 1 or 2.
 @enddefbuiltin
@@ -16332,6 +16332,11 @@ function you need to include @code{larchintrin.h}.
     void __break (imm0_32767)
 @end smallexample
 
+Returns the value that is currently set in the @samp{tp} register.
+@smallexample
+    void * __builtin_thread_pointer (void)
+@end smallexample
+
 @node MIPS DSP Built-in Functions
 @subsection MIPS DSP Built-in Functions
 
@@ -18410,8 +18415,8 @@ round to odd as the rounding mode.
 The following additional built-in functions are also available for the
 PowerPC family of processors, starting with ISA 3.0 or later:
 
-@defbuiltin{long long __builtin_darn (void)}
-@defbuiltinx{long long __builtin_darn_raw (void)}
+@defbuiltin{{long long} __builtin_darn (void)}
+@defbuiltinx{{long long} __builtin_darn_raw (void)}
 @defbuiltinx{int __builtin_darn_32 (void)}
 The @code{__builtin_darn} and @code{__builtin_darn_raw}
 functions require a
@@ -20069,9 +20074,9 @@ implemented by the @code{vctzdm} instruction.
 
 @smallexample
 @exdent vector signed char
-@exdent vec_clrl (vector signed char a, unsigned int n);
+@exdent vec_clrl (vector signed char @var{a}, unsigned int @var{n});
 @exdent vector unsigned char
-@exdent vec_clrl (vector unsigned char a, unsigned int n);
+@exdent vec_clrl (vector unsigned char @var{a}, unsigned int @var{n});
 @end smallexample
 Clear the left-most @code{(16 - n)} bytes of vector argument @code{a}, as if
 implemented by the @code{vclrlb} instruction on a big-endian target
@@ -20081,9 +20086,9 @@ value of @code{n} that is greater than 16 is treated as if it equaled 16.
 
 @smallexample
 @exdent vector signed char
-@exdent vec_clrr (vector signed char a, unsigned int n);
+@exdent vec_clrr (vector signed char @var{a}, unsigned int @var{n});
 @exdent vector unsigned char
-@exdent vec_clrr (vector unsigned char a, unsigned int n);
+@exdent vec_clrr (vector unsigned char @var{a}, unsigned int @var{n});
 @end smallexample
 Clear the right-most @code{(16 - n)} bytes of vector argument @code{a}, as if
 implemented by the @code{vclrrb} instruction on a big-endian target
@@ -20537,9 +20542,9 @@ Vector Integer Multiply/Divide/Modulo
 
 @smallexample
 @exdent vector signed int
-@exdent vec_mulh (vector signed int a, vector signed int b);
+@exdent vec_mulh (vector signed int @var{a}, vector signed int @var{b});
 @exdent vector unsigned int
-@exdent vec_mulh (vector unsigned int a, vector unsigned int b);
+@exdent vec_mulh (vector unsigned int @var{a}, vector unsigned int @var{b});
 @end smallexample
 
 For each integer value @code{i} from 0 to 3, do the following. The integer
@@ -20549,9 +20554,9 @@ into word element @code{i} of the vector returned.
 
 @smallexample
 @exdent vector signed long long
-@exdent vec_mulh (vector signed long long a, vector signed long long b);
+@exdent vec_mulh (vector signed long long @var{a}, vector signed long long @var{b});
 @exdent vector unsigned long long
-@exdent vec_mulh (vector unsigned long long a, vector unsigned long long b);
+@exdent vec_mulh (vector unsigned long long @var{a}, vector unsigned long long @var{b});
 @end smallexample
 
 For each integer value @code{i} from 0 to 1, do the following. The integer
@@ -20561,9 +20566,9 @@ are placed into doubleword element @code{i} of the vector returned.
 
 @smallexample
 @exdent vector unsigned long long
-@exdent vec_mul (vector unsigned long long a, vector unsigned long long b);
+@exdent vec_mul (vector unsigned long long @var{a}, vector unsigned long long @var{b});
 @exdent vector signed long long
-@exdent vec_mul (vector signed long long a, vector signed long long b);
+@exdent vec_mul (vector signed long long @var{a}, vector signed long long @var{b});
 @end smallexample
 
 For each integer value @code{i} from 0 to 1, do the following. The integer
@@ -20573,9 +20578,9 @@ are placed into doubleword element @code{i} of the vector returned.
 
 @smallexample
 @exdent vector signed int
-@exdent vec_div (vector signed int a, vector signed int b);
+@exdent vec_div (vector signed int @var{a}, vector signed int @var{b});
 @exdent vector unsigned int
-@exdent vec_div (vector unsigned int a, vector unsigned int b);
+@exdent vec_div (vector unsigned int @var{a}, vector unsigned int @var{b});
 @end smallexample
 
 For each integer value @code{i} from 0 to 3, do the following. The integer in
@@ -20586,9 +20591,9 @@ the vector returned. If an attempt is made to perform any of the divisions
 
 @smallexample
 @exdent vector signed long long
-@exdent vec_div (vector signed long long a, vector signed long long b);
+@exdent vec_div (vector signed long long @var{a}, vector signed long long @var{b});
 @exdent vector unsigned long long
-@exdent vec_div (vector unsigned long long a, vector unsigned long long b);
+@exdent vec_div (vector unsigned long long @var{a}, vector unsigned long long @var{b});
 @end smallexample
 
 For each integer value @code{i} from 0 to 1, do the following. The integer in
@@ -20600,9 +20605,9 @@ the quotient is undefined.
 
 @smallexample
 @exdent vector signed int
-@exdent vec_dive (vector signed int a, vector signed int b);
+@exdent vec_dive (vector signed int @var{a}, vector signed int @var{b});
 @exdent vector unsigned int
-@exdent vec_dive (vector unsigned int a, vector unsigned int b);
+@exdent vec_dive (vector unsigned int @var{a}, vector unsigned int @var{b});
 @end smallexample
 
 For each integer value @code{i} from 0 to 3, do the following. The integer in
@@ -20614,9 +20619,9 @@ divisions <anything> ÷ 0 then the quotient is undefined.
 
 @smallexample
 @exdent vector signed long long
-@exdent vec_dive (vector signed long long a, vector signed long long b);
+@exdent vec_dive (vector signed long long @var{a}, vector signed long long @var{b});
 @exdent vector unsigned long long
-@exdent vec_dive (vector unsigned long long a, vector unsigned long long b);
+@exdent vec_dive (vector unsigned long long @var{a}, vector unsigned long long @var{b});
 @end smallexample
 
 For each integer value @code{i} from 0 to 1, do the following. The integer in
@@ -20628,9 +20633,9 @@ quotient cannot be represented in 64 bits, or if an attempt is made to perform
 
 @smallexample
 @exdent vector signed int
-@exdent vec_mod (vector signed int a, vector signed int b);
+@exdent vec_mod (vector signed int @var{a}, vector signed int @var{b});
 @exdent vector unsigned int
-@exdent vec_mod (vector unsigned int a, vector unsigned int b);
+@exdent vec_mod (vector unsigned int @var{a}, vector unsigned int @var{b});
 @end smallexample
 
 For each integer value @code{i} from 0 to 3, do the following. The integer in
@@ -20641,9 +20646,9 @@ the vector returned.  If an attempt is made to perform any of the divisions
 
 @smallexample
 @exdent vector signed long long
-@exdent vec_mod (vector signed long long a, vector signed long long b);
+@exdent vec_mod (vector signed long long @var{a}, vector signed long long @var{b});
 @exdent vector unsigned long long
-@exdent vec_mod (vector unsigned long long a, vector unsigned long long b);
+@exdent vec_mod (vector unsigned long long @var{a}, vector unsigned long long @var{b});
 @end smallexample
 
 For each integer value @code{i} from 0 to 1, do the following. The integer in
@@ -20658,14 +20663,14 @@ immediate value is either 0, 1, 2 or 3.
 @findex vec_genpcvm
 
 @smallexample
-@exdent vector unsigned __int128 vec_rl (vector unsigned __int128 A,
-                                         vector unsigned __int128 B);
-@exdent vector signed __int128 vec_rl (vector signed __int128 A,
-                                       vector unsigned __int128 B);
+@exdent vector unsigned __int128 vec_rl (vector unsigned __int128 @var{A},
+                                         vector unsigned __int128 @var{B});
+@exdent vector signed __int128 vec_rl (vector signed __int128 @var{A},
+                                       vector unsigned __int128 @var{B});
 @end smallexample
 
-Result value: Each element of R is obtained by rotating the corresponding element
-of A left by the number of bits specified by the corresponding element of B.
+Result value: Each element of @var{R} is obtained by rotating the corresponding element
+of @var{A} left by the number of bits specified by the corresponding element of @var{B}.
 
 
 @smallexample
@@ -20699,28 +20704,28 @@ input.  The shift is obtained from the third input in the 7-bit field bits
 [125:131] where all bits counted from zero at the left.
 
 @smallexample
-@exdent vector unsigned __int128 vec_sl(vector unsigned __int128 A, vector unsigned __int128 B);
-@exdent vector signed __int128 vec_sl(vector signed __int128 A, vector unsigned __int128 B);
+@exdent vector unsigned __int128 vec_sl(vector unsigned __int128 @var{A}, vector unsigned __int128 @var{B});
+@exdent vector signed __int128 vec_sl(vector signed __int128 @var{A}, vector unsigned __int128 @var{B});
 @end smallexample
 
-Result value: Each element of R is obtained by shifting the corresponding element of
-A left by the number of bits specified by the corresponding element of B.
+Result value: Each element of @var{R} is obtained by shifting the corresponding element of
+@var{A} left by the number of bits specified by the corresponding element of @var{B}.
 
 @smallexample
-@exdent vector unsigned __int128 vec_sr(vector unsigned __int128 A, vector unsigned __int128 B);
-@exdent vector signed __int128 vec_sr(vector signed __int128 A, vector unsigned __int128 B);
+@exdent vector unsigned __int128 vec_sr(vector unsigned __int128 @var{A}, vector unsigned __int128 @var{B});
+@exdent vector signed __int128 vec_sr(vector signed __int128 @var{A}, vector unsigned __int128 @var{B});
 @end smallexample
 
-Result value: Each element of R is obtained by shifting the corresponding element of
-A right by the number of bits specified by the corresponding element of B.
+Result value: Each element of @var{R} is obtained by shifting the corresponding element of
+@var{A} right by the number of bits specified by the corresponding element of @var{B}.
 
 @smallexample
-@exdent vector unsigned __int128 vec_sra(vector unsigned __int128 A, vector unsigned __int128 B);
-@exdent vector signed __int128 vec_sra(vector signed __int128 A, vector unsigned __int128 B);
+@exdent vector unsigned __int128 vec_sra(vector unsigned __int128 @var{A}, vector unsigned __int128 @var{B});
+@exdent vector signed __int128 vec_sra(vector signed __int128 @var{A}, vector unsigned __int128 @var{B});
 @end smallexample
 
-Result value: Each element of R is obtained by arithmetic shifting the corresponding
-element of A right by the number of bits specified by the corresponding element of B.
+Result value: Each element of @var{R} is obtained by arithmetic shifting the corresponding
+element of @var{A} right by the number of bits specified by the corresponding element of @var{B}.
 
 @smallexample
 @exdent vector unsigned __int128 vec_mule (vector unsigned long long,
@@ -21301,12 +21306,12 @@ multiplying the bottom 16 bits of the two arguments into the
 accumulator.
 @enddefbuiltin
 
-@defbuiltin{int  __builtin_rx_mvfachi (void)}
+@defbuiltin{int __builtin_rx_mvfachi (void)}
 Generates the @code{mvfachi} machine instruction to read the top
 32 bits of the accumulator.
 @enddefbuiltin
 
-@defbuiltin{int  __builtin_rx_mvfacmi (void)}
+@defbuiltin{int __builtin_rx_mvfacmi (void)}
 Generates the @code{mvfacmi} machine instruction to read the middle
 32 bits of the accumulator.
 @enddefbuiltin
@@ -21326,7 +21331,7 @@ Generates the @code{mvtaclo} machine instruction to set the bottom
 32 bits of the accumulator.
 @enddefbuiltin
 
-@defbuiltin{void __builtin_rx_mvtc (int reg, int val)}
+@defbuiltin{void __builtin_rx_mvtc (int @var{reg}, int @var{val})}
 Generates the @code{mvtc} machine instruction which sets control
 register number @code{reg} to @code{val}.
 @enddefbuiltin
@@ -22660,7 +22665,7 @@ Generates the @code{extractps} machine instruction.
 Generates the @code{pextrd} machine instruction.
 @enddefbuiltin
 
-@defbuiltin{long long __builtin_ia32_vec_ext_v2di (v2di, const int)}
+@defbuiltin{{long long} __builtin_ia32_vec_ext_v2di (v2di, const int)}
 Generates the @code{pextrq} machine instruction in 64bit mode.
 @enddefbuiltin
 
@@ -22689,19 +22694,19 @@ v2di __builtin_ia32_pcmpgtq (v2di, v2di);
 The following built-in functions are available when @option{-msse4.2} is
 used.
 
-@defbuiltin{unsigned int __builtin_ia32_crc32qi (unsigned int, unsigned char)}
+@defbuiltin{{unsigned int} __builtin_ia32_crc32qi (unsigned int, unsigned char)}
 Generates the @code{crc32b} machine instruction.
 @enddefbuiltin
 
-@defbuiltin{unsigned int __builtin_ia32_crc32hi (unsigned int, unsigned short)}
+@defbuiltin{{unsigned int} __builtin_ia32_crc32hi (unsigned int, unsigned short)}
 Generates the @code{crc32w} machine instruction.
 @enddefbuiltin
 
-@defbuiltin{unsigned int __builtin_ia32_crc32si (unsigned int, unsigned int)}
+@defbuiltin{{unsigned int} __builtin_ia32_crc32si (unsigned int, unsigned int)}
 Generates the @code{crc32l} machine instruction.
 @enddefbuiltin
 
-@defbuiltin{unsigned long long __builtin_ia32_crc32di (unsigned long long, unsigned long long)}
+@defbuiltin{{unsigned long long} __builtin_ia32_crc32di (unsigned long long, unsigned long long)}
 Generates the @code{crc32q} machine instruction.
 @enddefbuiltin
 
--- a/src/gcc/doc/gm2.texi
+++ b/src/gcc/doc/gm2.texi
@@ -227,6 +227,7 @@ such as the AVR and the ARM).
 * Linking::               Linking options in more detail.
 * Elementary data types:: Data types supported by GNU Modula-2.
 * Standard procedures::   Permanently accessible base procedures.
+* High procedure function:: Behavior of the high procedure function.
 * Dialect::               GNU Modula-2 supported dialects.
 * Exceptions::            Exception implementation
 * Semantic checking::     How to detect run time problems at compile time.
@@ -658,6 +659,29 @@ zero.
 @item -fwholevalue
 generate code to detect whole number overflow and underflow.
 
+@item -Wcase-enum
+generate a warning if a @code{CASE} statement selects on an enumerated
+type expression and the statement is missing one or more @code{CASE}
+labels.  No warning is issued if the @code{CASE} statement has a default
+@code{ELSE} clause.
+The option @samp{-Wall} will turn on this flag.
+
+@item -Wuninit-variable-checking
+issue a warning if a variable is used before it is initialized.
+The checking only occurs in the first basic block in each procedure.
+It does not check parameters, array types or set types.
+
+@item -Wuninit-variable-checking=all,known,cond
+issue a warning if a variable is used before it is initialized.
+The checking will only occur in the first basic block in each
+procedure if @samp{known} is specified.  If @samp{cond} or @samp{all}
+is specified then checking continues into conditional branches of the
+flow graph.  All checking will stop when a procedure call is invoked
+or the top of a loop is encountered.
+The option @samp{-Wall} will turn on this flag with
+@samp{-Wuninit-variable-checking=known}.
+The @samp{-Wuninit-variable-checking=all} will increase compile time.
+
 @c the following warning options are complete but need to be
 @c regression tested against all other front ends
 @c to ensure the options do not conflict.
@@ -829,7 +853,7 @@ exported from the @code{SYSTEM} module.
 @xref{The PIM system module, , ,gm2}.
 @xref{The ISO system module, , ,gm2}.
 
-@node Standard procedures, Dialect, Elementary data types, Using
+@node Standard procedures, High procedure function, Elementary data types, Using
 @section Permanently accessible base procedures.
 
 This section describes the procedures and functions which are
@@ -986,7 +1010,7 @@ PROCEDURE HALT ;
              foo('hello')
           END
 
-          will cause the local variable c to contain the value 4
+          will cause the local variable c to contain the value 5
 *)
 
 @findex HIGH
@@ -1228,7 +1252,99 @@ PROCEDURE ODD (v: <any whole number type>) : BOOLEAN ;
 PROCEDURE RE (c: <any complex type>) : <floating point type> ;
 @end example
 
-@node Dialect, Exceptions, Standard procedures, Using
+@node High procedure function, Dialect, Standard procedures, Using
+
+@section Behavior of the high procedure function
+
+This section describes the behavior of the standard procedure function
+@code{HIGH} and it includes a table of parameters with the expected
+return result.  The standard procedure function will return the last
+accessible indice of an @code{ARRAY}.  If the parameter to @code{HIGH}
+is a static array then the result will be a @code{CARDINAL} value
+matching the upper bound in the @code{ARRAY} declaration.
+
+The section also describes the behavior of a string literal actual
+parameter and how it relates to @code{HIGH}.
+The PIM2, PIM3, PIM4 and ISO standard is silent on the issue of
+whether a @code{nul} is present in an @code{ARRAY} @code{OF}
+@code{CHAR} actual parameter.
+
+If the first parameter to @code{HIGH} is an unbounded @code{ARRAY} the
+return value from @code{HIGH} will be the last accessible element in
+the array.  If a constant string literal is passed as an actual
+parameter then it will be @code{nul} terminated.  The table and
+example code below describe the effect of passing an actual parameter
+and the expected @code{HIGH} value.
+
+@example
+MODULE example1 ;
+
+PROCEDURE test (a: ARRAY OF CHAR) ;
+VAR
+   x: CARDINAL ;
+BEGIN
+   x := HIGH (a) ;
+   ...
+END test ;
+
+
+BEGIN
+   test ('') ;
+   test ('1') ;
+   test ('12') ;
+   test ('123') ;
+END example1.
+
+
+Actual parameter | HIGH (a) | a[HIGH (a)] = nul
+===============================================
+ ''              | 0        | TRUE
+ '1'             | 1        | TRUE
+ '12'            | 2        | TRUE
+ '123'           | 3        | TRUE
+@end example
+
+A constant string literal will be passed to an @code{ARRAY} @code{OF}
+@code{CHAR} with an appended @code{nul} @code{CHAR}.  Thus if the
+constant string literal @code{''} is passed as an actual parameter (in
+example1) then the result from @code{HIGH(a)} will be @code{0}.
+
+@example
+MODULE example2 ;
+
+PROCEDURE test (a: ARRAY OF CHAR) ;
+VAR
+   x: CARDINAL ;
+BEGIN
+   x := HIGH (a) ;
+   ...
+END test ;
+
+VAR
+   str0: ARRAY [0..0] OF CHAR ;
+   str1: ARRAY [0..1] OF CHAR ;
+   str2: ARRAY [0..2] OF CHAR ;
+   str3: ARRAY [0..3] OF CHAR ;
+BEGIN
+   str0 := 'a' ;   (* No room for the nul terminator.  *)
+   test (str0) ;
+   str1 := 'ab' ;  (* No room for the nul terminator.  *)
+   test (str1) ;
+   str2 := 'ab' ;  (* Terminated with a nul.  *)
+   test (str2) ;
+   str2 := 'abc' ; (* Terminated with a nul.  *)
+   test (str3) ;
+END example2.
+
+Actual parameter | HIGH (a) | a[HIGH (a)] = nul
+===============================================
+ str0            | 0        | FALSE
+ str1            | 1        | FALSE
+ atr2            | 2        | TRUE
+ str3            | 3        | TRUE
+@end example
+
+@node Dialect, Exceptions, High procedure function, Using
 @section GNU Modula-2 supported dialects
 
 This section describes the dialects understood by GNU Modula-2.
@@ -1359,6 +1475,126 @@ with @samp{-fsoft-check-all} so that the compiler is able to run the
 optimizer and perform variable and flow analysis before the semantic
 plugin is invoked.
 
+The @samp{-Wuninit-variable-checking} can be used to identify
+uninitialized variables within the first basic block in a procedure.
+The checking is limited to variables so long as they are
+not an array or set or a variant record or var parameter.
+
+The following example detects whether a sub component within a record
+is uninitialized.
+
+@example
+MODULE testlarge2 ;
+
+TYPE
+   color = RECORD
+              r, g, b: CARDINAL ;
+           END ;
+
+   pixel = RECORD
+              fg, bg: color ;
+           END ;
+
+PROCEDURE test ;
+VAR
+   p: pixel ;
+BEGIN
+   p.fg.r := 1 ;
+   p.fg.g := 2 ;
+   p.fg.g := 3 ;   (* Deliberate typo should be p.fg.b.  *)
+   p.bg := p.fg ;  (* Accessing an uninitialized field.  *)
+END test ;
+
+BEGIN
+   test
+END testlarge2.
+@end example
+
+@example
+$ gm2 -c -Wuninit-variable-checking testlarge2.mod
+testlarge2.mod:19:13: warning: In procedure ‘test’: attempting to
+access expression before it has been initialized
+   19 |    p.bg := p.fg ;  (* Accessing an uninitialized field.  *)
+      |            ~^~~
+@end example
+
+The following example detects if an individual field is uninitialized.
+
+@example
+MODULE testwithnoptr ;
+
+TYPE
+   Vec =  RECORD
+             x, y: CARDINAL ;
+          END ;
+
+PROCEDURE test ;
+VAR
+   p: Vec ;
+BEGIN
+   WITH p DO
+      x := 1 ;
+      x := 2   (* Deliberate typo, user meant y.  *)
+   END ;
+   IF p.y = 2
+   THEN
+   END
+END test ;
+
+BEGIN
+   test
+END testwithnoptr.
+@end example
+
+The following example detects a record is uninitialized via a
+pointer variable in a @samp{WITH} block.
+
+@example
+$ gm2 -g -c -Wuninit-variable-checking testwithnoptr.mod
+testwithnoptr.mod:21:8: warning: In procedure ‘test’: attempting to
+access expression before it has been initialized
+   21 |    IF p.y = 2
+      |       ~^~
+@end example
+
+@example
+MODULE testnew6 ;
+
+FROM Storage IMPORT ALLOCATE ;
+
+TYPE
+   PtrToVec = POINTER TO RECORD
+                            x, y: INTEGER ;
+                         END ;
+
+PROCEDURE test ;
+VAR
+   p: PtrToVec ;
+BEGIN
+   NEW (p) ;
+   WITH p^ DO
+      x := 1 ;
+      x := 2   (* Deliberate typo, user meant y.  *)
+   END ;
+   IF p^.y = 2
+   THEN
+   END
+END test ;
+
+
+BEGIN
+   test
+END testnew6.
+@end example
+
+@example
+$ gm2 -g -c -Wuninit-variable-checking testnew6.mod
+testnew6.mod:19:9: warning: In procedure ‘test’: attempting to
+access expression before it has been initialized
+   19 |    IF p^.y = 2
+      |       ~~^~
+@end example
+
 @node Extensions, Type compatibility, Semantic checking, Using
 @section GNU Modula-2 language extensions
 
--- a/src/gcc/doc/invoke.texi
+++ b/src/gcc/doc/invoke.texi
@@ -16102,6 +16102,13 @@ crossing a loop backedge when comparing to
 Maximum number of nested calls to search for control dependencies
 during uninitialized variable analysis.
 
+@item uninit-max-chain-len
+Maximum number of predicates anded for each predicate ored in the normalized
+predicate chain.
+
+@item uninit-max-num-chains
+Maximum number of predicates ored in the normalized predicate chain.
+
 @item sched-autopref-queue-depth
 Hardware autoprefetcher scheduler model control flag.
 Number of lookahead cycles the model looks into; at '
@@ -32397,8 +32404,8 @@ SSSE3, SSE4.1, SSE4.2, POPCNT, AES, PREFETCHW, PCLMUL, RDRND, XSAVE, XSAVEC,
 XSAVES, XSAVEOPT, FSGSBASE, PTWRITE, RDPID, SGX, GFNI-SSE, CLWB, MOVDIRI,
 MOVDIR64B, CLDEMOTE, WAITPKG, ADCX, AVX, AVX2, BMI, BMI2, F16C, FMA, LZCNT,
 PCONFIG, PKU, VAES, VPCLMULQDQ, SERIALIZE, HRESET, KL, WIDEKL, AVX-VNNI,
-AVXIFMA, AVXVNNIINT8, AVXNECONVERT, CMPCCXADD, ENQCMD, UINTR and RAOINT
-instruction set support.
+AVXIFMA, AVXVNNIINT8, AVXNECONVERT, CMPCCXADD, ENQCMD and UINTR instruction set
+support.
 
 @item knl
 Intel Knight's Landing CPU with 64-bit extensions, MOVBE, MMX, SSE, SSE2, SSE3,
--- a/src/gcc/fortran/gfortran.texi
+++ b/src/gcc/fortran/gfortran.texi
@@ -3750,7 +3750,8 @@ front ends of GCC, e.g. to GCC's C99 compiler for @code{_Bool}
 or GCC's Ada compiler for @code{Boolean}.)
 
 For arguments of @code{CHARACTER} type, the character length is passed
-as a hidden argument at the end of the argument list.  For
+as a hidden argument at the end of the argument list, except when the
+corresponding dummy argument is declared as @code{TYPE(*)}.  For
 deferred-length strings, the value is passed by reference, otherwise
 by value.  The character length has the C type @code{size_t} (or
 @code{INTEGER(kind=C_SIZE_T)} in Fortran).  Note that this is
--- a/src/gcc/m2/target-independent/m2/gm2-libs.texi
+++ b/src/gcc/m2/target-independent/m2/gm2-libs.texi
@@ -55,7 +55,6 @@ building the GNU Modula-2 compiler.
 * gm2-libs/LegacyReal::LegacyReal.def
 * gm2-libs/M2Dependent::M2Dependent.def
 * gm2-libs/M2EXCEPTION::M2EXCEPTION.def
-* gm2-libs/M2LINK::M2LINK.def
 * gm2-libs/M2RTS::M2RTS.def
 * gm2-libs/MathLib0::MathLib0.def
 * gm2-libs/MemUtils::MemUtils.def
@@ -1944,7 +1943,8 @@ TYPE
 
 
 @findex ConstructModules
-PROCEDURE ConstructModules (applicationmodule, libname: ADDRESS;
+PROCEDURE ConstructModules (applicationmodule, libname,
+                            overrideliborder: ADDRESS;
                             argc: INTEGER; argv, envp: ADDRESS) ;
 
 @findex DeconstructModules
@@ -1979,7 +1979,7 @@ END M2Dependent.
 @end example
 @page
 
-@node gm2-libs/M2EXCEPTION, gm2-libs/M2LINK, gm2-libs/M2Dependent, Base libraries
+@node gm2-libs/M2EXCEPTION, gm2-libs/M2RTS, gm2-libs/M2Dependent, Base libraries
 @subsection gm2-libs/M2EXCEPTION
 
 @example
@@ -2017,33 +2017,7 @@ END M2EXCEPTION.
 @end example
 @page
 
-@node gm2-libs/M2LINK, gm2-libs/M2RTS, gm2-libs/M2EXCEPTION, Base libraries
-@subsection gm2-libs/M2LINK
-
-@example
-DEFINITION MODULE FOR "C" M2LINK ;
-
-
-TYPE
-@findex PtrToChar (type)
-   PtrToChar = POINTER TO CHAR ;
-
-(* These variables are set by the compiler in the program module
-   according to linking command line options.  *)
-
-VAR
-@findex ForcedModuleInitOrder (var)
-   ForcedModuleInitOrder: PtrToChar ;
-@findex StaticInitialization (var)
-   StaticInitialization : BOOLEAN ;
-
-
-@findex END M2LINK. (var)
-END M2LINK.
-@end example
-@page
-
-@node gm2-libs/M2RTS, gm2-libs/MathLib0, gm2-libs/M2LINK, Base libraries
+@node gm2-libs/M2RTS, gm2-libs/MathLib0, gm2-libs/M2EXCEPTION, Base libraries
 @subsection gm2-libs/M2RTS
 
 @example
@@ -2058,7 +2032,8 @@ TYPE
 
 
 @findex ConstructModules
-PROCEDURE ConstructModules (applicationmodule, libname: ADDRESS;
+PROCEDURE ConstructModules (applicationmodule, libname,
+                            overrideliborder: ADDRESS;
                             argc: INTEGER; argv, envp: ADDRESS) ;
 
 @findex DeconstructModules
@@ -8956,6 +8931,7 @@ coexist with their PIM counterparts.
 * gm2-libs-iso/TERMINATION::TERMINATION.def
 * gm2-libs-iso/TermFile::TermFile.def
 * gm2-libs-iso/TextIO::TextIO.def
+* gm2-libs-iso/TextUtil::TextUtil.def
 * gm2-libs-iso/WholeConv::WholeConv.def
 * gm2-libs-iso/WholeIO::WholeIO.def
 * gm2-libs-iso/WholeStr::WholeStr.def
@@ -10830,6 +10806,7 @@ TYPE
 
 @findex ConstructModules
 PROCEDURE ConstructModules (applicationmodule, libname: ADDRESS;
+                            overrideliborder: ADDRESS;
                             argc: INTEGER; argv, envp: ADDRESS) ;
 
 @findex DeconstructModules
@@ -14344,7 +14321,7 @@ END TermFile.
 @end example
 @page
 
-@node gm2-libs-iso/TextIO, gm2-libs-iso/WholeConv, gm2-libs-iso/TermFile, M2 ISO Libraries
+@node gm2-libs-iso/TextIO, gm2-libs-iso/TextUtil, gm2-libs-iso/TermFile, M2 ISO Libraries
 @subsection gm2-libs-iso/TextIO
 
 @example
@@ -14422,7 +14399,42 @@ END TextIO.
 @end example
 @page
 
-@node gm2-libs-iso/WholeConv, gm2-libs-iso/WholeIO, gm2-libs-iso/TextIO, M2 ISO Libraries
+@node gm2-libs-iso/TextUtil, gm2-libs-iso/WholeConv, gm2-libs-iso/TextIO, M2 ISO Libraries
+@subsection gm2-libs-iso/TextUtil
+
+@example
+DEFINITION MODULE TextUtil ;
+
+(*
+    Description: provides text manmipulation routines.
+*)
+
+IMPORT IOChan ;
+
+
+(*
+   SkipSpaces - skips any spaces.
+*)
+
+@findex SkipSpaces
+PROCEDURE SkipSpaces (cid: IOChan.ChanId) ;
+
+
+(* The following procedures do not read past line marks.  *)
+
+@findex CharAvailable
+PROCEDURE CharAvailable (cid: IOChan.ChanId) : BOOLEAN ;
+
+
+@findex EofOrEoln
+PROCEDURE EofOrEoln (cid: IOChan.ChanId) : BOOLEAN ;
+
+
+END TextUtil.
+@end example
+@page
+
+@node gm2-libs-iso/WholeConv, gm2-libs-iso/WholeIO, gm2-libs-iso/TextUtil, M2 ISO Libraries
 @subsection gm2-libs-iso/WholeConv
 
 @example