diff options
Diffstat (limited to 'debian/patches/git-doc-updates.diff')
| -rw-r--r-- | debian/patches/git-doc-updates.diff | 1307 |
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 |