Adding debian version 13.2.0-10.debian/13.2.0-10debian

Signed-off-by: Daniel Baumann <daniel.baumann@progress-linux.org>

1 files changed, 1307 insertions, 0 deletions

diff --git a/debian/patches/git-doc-updates.diff b/debian/patches/git-doc-updates.diff
new file mode 100644
index 0000000..98e2612
--- /dev/null
+++ b/debian/patches/git-doc-updates.diff
@@ -0,0 +1,1307 @@
+# 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