commit ff7909eb0eb9c31eb7ebce4d2ef3bdffeef25d1a Author: Richard Biener Date: Fri Aug 7 09:54:35 2026 +0200 Bump BASE-VER * BASE-VER: Set to 16.2.1. diff --git a/gcc/BASE-VER b/gcc/BASE-VER index fd1bd70b7ea..38321081459 100644 --- a/gcc/BASE-VER +++ b/gcc/BASE-VER @@ -1 +1 @@ -16.2.0 +16.2.1 commit 046f8f3134c29cb6c760e69cb2eeb3db8a644a62 Author: Jakub Jelinek Date: Mon Aug 3 11:26:11 2026 +0200 mips: Fix up creation of MD builtins with 0 arguments [PR126484] For MIPS_SI_FTYPE_VOID and MIPS_USI_FTYPE_VOID which are meant for functions which return (SImode) int or unsigned int and have (void) arguments the MIPS backend creates those using case MIPS_SI_FTYPE_VOID: types[(int) type] = build_function_type_list (intSI_type_node, void_type_node, NULL_TREE); break; case MIPS_USI_FTYPE_VOID: types[(int) type] = build_function_type_list (unsigned_intSI_type_node, void_type_node, NULL_TREE); break; That is wrong, because functions which don't take any arguments (i.e. (void) or C23/C++ ()) should be using void_list_node as TYPE_ARG_TYPES, not a TREE_LIST with void_type_node TREE_VALUE and TREE_CHAIN being that void_list_node. Although void_list_node also has TREE_VALUE of void_type_node, various places in the C++ FE as well as in the middle-end rely on void_list_node to be unique, compare it using pointer comparison. The following testcase strangely happens to compile fine when compiled in C, but fails in C++ (which reports wrong number of arguments due to this bug). The following simple patch just arranges those 0 argument functions to have the MIPS_*_FTYPE_VOID enumerators be named as before, but in the build_function_type_list call omit that ", void_type_node" part, so it creates correct 0 arguments FUNCTION_TYPE. 2026-08-03 Jakub Jelinek PR target/126484 * config/mips/mips-ftypes.def (MIPS_SI_FTYPE_VOID, MIPS_USI_FTYPE_VOID): Use DEF_MIPS_FTYPE with 0 as first argument rather than 1 and leave out ", VOID" from second argument. * config/mips/mips.cc (MIPS_FTYPE_NAME0): Define. (MIPS_FTYPE_ATYPES0): Define. * g++.target/mips/pr126484.C: New test. Reviewed-by: Richard Biener (cherry picked from commit e152b584c3df7ce0ef738f3d7c2d852490d59e3d) diff --git a/gcc/config/mips/mips-ftypes.def b/gcc/config/mips/mips-ftypes.def index fb72661c682..94f5c5ddf0e 100644 --- a/gcc/config/mips/mips-ftypes.def +++ b/gcc/config/mips/mips-ftypes.def @@ -75,7 +75,7 @@ DEF_MIPS_FTYPE (1, (SI, V4QI)) DEF_MIPS_FTYPE (2, (SI, V4QI, V4QI)) DEF_MIPS_FTYPE (2, (SI, V4SI, UQI)) DEF_MIPS_FTYPE (2, (SI, V8HI, UQI)) -DEF_MIPS_FTYPE (1, (SI, VOID)) +DEF_MIPS_FTYPE (0, (SI)) DEF_MIPS_FTYPE (2, (UDI, UDI, UDI)) DEF_MIPS_FTYPE (2, (UDI, UV2SI, UV2SI)) @@ -84,7 +84,7 @@ DEF_MIPS_FTYPE (2, (UDI, V2DI, UQI)) DEF_MIPS_FTYPE (2, (USI, V16QI, UQI)) DEF_MIPS_FTYPE (2, (USI, V4SI, UQI)) DEF_MIPS_FTYPE (2, (USI, V8HI, UQI)) -DEF_MIPS_FTYPE (1, (USI, VOID)) +DEF_MIPS_FTYPE (0, (USI)) DEF_MIPS_FTYPE (2, (UV16QI, UV16QI, UQI)) DEF_MIPS_FTYPE (2, (UV16QI, UV16QI, UV16QI)) diff --git a/gcc/config/mips/mips.cc b/gcc/config/mips/mips.cc index cc45a195b89..76543a23248 100644 --- a/gcc/config/mips/mips.cc +++ b/gcc/config/mips/mips.cc @@ -211,6 +211,7 @@ enum mips_ucbranch_type }; /* Macros to create an enumeration identifier for a function prototype. */ +#define MIPS_FTYPE_NAME0(A) MIPS_##A##_FTYPE_VOID #define MIPS_FTYPE_NAME1(A, B) MIPS_##A##_FTYPE_##B #define MIPS_FTYPE_NAME2(A, B, C) MIPS_##A##_FTYPE_##B##_##C #define MIPS_FTYPE_NAME3(A, B, C, D) MIPS_##A##_FTYPE_##B##_##C##_##D @@ -17137,6 +17138,9 @@ mips_build_cvpointer_type (void) /* MIPS_FTYPE_ATYPESN takes N MIPS_FTYPES-like type codes and lists their associated MIPS_ATYPEs. */ +#define MIPS_FTYPE_ATYPES0(A) \ + MIPS_ATYPE_##A + #define MIPS_FTYPE_ATYPES1(A, B) \ MIPS_ATYPE_##A, MIPS_ATYPE_##B diff --git a/gcc/testsuite/g++.target/mips/pr126484.C b/gcc/testsuite/g++.target/mips/pr126484.C new file mode 100644 index 00000000000..2d55cb939c0 --- /dev/null +++ b/gcc/testsuite/g++.target/mips/pr126484.C @@ -0,0 +1,8 @@ +// PR target/126484 +// { dg-do compile } + +int +foo () +{ + return __builtin_mips_get_fcsr (); +} commit ce9e59eb8cfd8740885614e7129970bcb040f7fd Author: Jakub Jelinek Date: Mon Aug 3 11:50:20 2026 +0200 testsuite: Add testcase for already fixed PR [PR126576] This testcase got fixed with r17-2843, but the testcase is sufficiently different from the other one that it is worth having both. 2026-08-03 Jakub Jelinek PR tree-optimization/126576 * gcc.dg/torture/pr126576.c: New test. (cherry picked from commit 04e3459dfc6ecd1138ec6d4f0d1e6b9044576814) diff --git a/gcc/testsuite/gcc.dg/torture/pr126576.c b/gcc/testsuite/gcc.dg/torture/pr126576.c new file mode 100644 index 00000000000..c94c7437035 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr126576.c @@ -0,0 +1,43 @@ +/* PR tree-optimization/126576 */ +/* { dg-do run } */ + +#if __DBL_MANT_DIG__ == 53 && __DBL_MAX_10_EXP__ == 308 \ + && __DBL_HAS_INFINITY__ && __FLT_EVAL_METHOD__ == 0 +int v; + +[[gnu::noipa]] void +bar (int x) +{ + v |= x; +} + +[[gnu::noipa]] double +foo (double x) +{ + double a = x * x; + if (__builtin_isinf (a) && !__builtin_isinf (x)) + bar (1); + double b = a * 3.0; + if (__builtin_isinf (b) && !__builtin_isinf (a)) + bar (2); + return b; +} +#endif + +int +main () +{ +#if __DBL_MANT_DIG__ == 53 && __DBL_MAX_10_EXP__ == 308 \ + && __DBL_HAS_INFINITY__ && __FLT_EVAL_METHOD__ == 0 + foo (1e154); + if (v != 2) + __builtin_abort (); + v = 0; + foo (1e152); + if (v != 0) + __builtin_abort (); + foo (1e155); + if (v != 1) + __builtin_abort (); +#endif +} commit ad7082fb5a1b49d2fd9adc714fab8a3f9a1e19cc Author: Jakub Jelinek Date: Mon Aug 3 13:01:22 2026 +0200 testsuite: Add yet another testcase for float range inverse ops [PR126547] This got also fixed with r17-2843. 2026-08-03 Jakub Jelinek PR tree-optimization/126547 * gcc.dg/torture/pr126547.c: New test. (cherry picked from commit 81763ec0f01664a5dd9fbfc541b1bf22a857f626) diff --git a/gcc/testsuite/gcc.dg/torture/pr126547.c b/gcc/testsuite/gcc.dg/torture/pr126547.c new file mode 100644 index 00000000000..c1066a2cfa9 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr126547.c @@ -0,0 +1,31 @@ +/* PR tree-optimization/126547 */ +/* { dg-do run } */ + +#if __LDBL_HAS_INFINITY__ +[[gnu::noipa]] static int +foo (long double a1, long double a2) +{ + if (a1 >= 1.0 && a1 <= 8.0) + { + long double d = a1 / a2; + int n = 0; + if (d >= __builtin_infl ()) + n += 1; + if (a2 > 0.0L) + n += 2; + return n; + } + else + return -1; +} +#endif + +int +main () +{ +#if __LDBL_HAS_INFINITY__ + if (__builtin_isinf (1.0 / __LDBL_DENORM_MIN__) + && foo (1.0, __LDBL_DENORM_MIN__) != 3) + __builtin_abort (); +#endif +} commit 925574f378c7fb3403b7027f6ac7c783964d5ee4 Author: Jakub Jelinek Date: Tue Aug 4 10:34:01 2026 +0200 range-op-float: Remove inappropriate frange_drop_infs call [PR126549] For integer to floating conversions I've added frange_drop_infs call into the handler. Supposedly I thought that integers converted to floating point are never +-inf, but that is clearly not the case as the testcases show. For _Float16 it can be +-inf very easily, as the finite range is just [-65504.0f16,65504.0f16], for others all one needs is a large enough _BitInt. The following patch just drops that call. In the common cases, +-inf will not appear in the range anyway, lb and ub will be usually finite. 2026-08-04 Jakub Jelinek PR tree-optimization/126549 * range-op-float.cc (operator_cast::fold_range): Don't call frange_drop_infs. * gcc.dg/torture/pr126549.c: New test. * gcc.dg/torture/bitint-107.c: New test. Reviewed-by: Aldy Hernandez (cherry picked from commit 217df27883c450f3f098bd0d1dc1ea7d5dbe8ff8) diff --git a/gcc/range-op-float.cc b/gcc/range-op-float.cc index 821e55b325f..e3633565680 100644 --- a/gcc/range-op-float.cc +++ b/gcc/range-op-float.cc @@ -3139,7 +3139,6 @@ operator_cast::fold_range (frange &r, tree type, const irange &op1, frange_nextafter (mode, ub, dconstinf); } r.set (type, lb, ub, nan_state (false)); - frange_drop_infs (r, type); if (r.undefined_p ()) r.set_varying (type); return true; diff --git a/gcc/testsuite/gcc.dg/torture/bitint-107.c b/gcc/testsuite/gcc.dg/torture/bitint-107.c new file mode 100644 index 00000000000..93a37bafe31 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/bitint-107.c @@ -0,0 +1,18 @@ +/* PR tree-optimization/126549 */ +/* { dg-do run { target { float32 && bitint575 } } } */ +/* { dg-add-options float32 } */ + +[[gnu::noipa]] int +foo (unsigned _BitInt(133) a) +{ + unsigned _BitInt(133) u = a % 5444517870735015415413993718908291383300uwb; + _Float32 h = (_Float32) u; + return h > __FLT32_MAX__; +} + +int +main () +{ + if (foo (5444517870735015415413993718908291383295uwb) != 1) + __builtin_abort (); +} diff --git a/gcc/testsuite/gcc.dg/torture/pr126549.c b/gcc/testsuite/gcc.dg/torture/pr126549.c new file mode 100644 index 00000000000..e87610a1717 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr126549.c @@ -0,0 +1,18 @@ +/* PR tree-optimization/126549 */ +/* { dg-do run { target float16 } } */ +/* { dg-add-options float16 } */ + +[[gnu::noipa]] int +foo (unsigned a) +{ + unsigned u = a % 100001U; + _Float16 h = (_Float16) u; + return h > 65504.0f16; +} + +int +main () +{ + if (foo (70000U) != 1) + __builtin_abort (); +} commit 24699eedf51ad307dd9463fa6c0a10222fdd56a2 Author: Jakub Jelinek Date: Tue Aug 4 10:35:19 2026 +0200 phiopt: Fix up spaceship_replacement [PR126564] spaceship_replacement is for optimization of code like : // cond3_bb if (a_3(D) == b_5(D)) goto ; [50.00%] else goto ; [50.00%] [local count: 536870913]: // cond2_bb if (a_3(D) < b_5(D)) goto ; [50.00%] else goto ; [50.00%] [local count: 268435456]: // cond_bb if (a_3(D) > b_5(D)) goto ; [50.00%] else goto ; [50.00%] [local count: 134217728]: // middle_bb [local count: 1073741824]: // phi_bb # SR.27_4 = PHI <0(2), -1(3), 1(4), -128(5)> _2 = SR.27_4 > 0; to a single comparison (i.e. say (a <=> b) > 0 in C++) (it handles also just 2 comparisons instead of 3, but this bug is about the 3 comparisons). In if (e1->flags & EDGE_TRUE_VALUE) { if (tree_to_shwi (arg0) != -128 || absu_hwi (tree_to_shwi (arg1)) != 1 || wi::to_widest (arg1) == wi::to_widest (arg2)) return false; } else if (tree_to_shwi (arg1) != -128 || absu_hwi (tree_to_shwi (arg0)) != 1 || wi::to_widest (arg0) == wi::to_widest (arg2)) return false; (where e1 is 4->6 edge above, arg0 is -128(5), arg1 is 1(4), arg2 is -1(3), cond2_phi_edge is 3->6 edge above) we deal with the different cases of whether the TRUE edge goes directly to phi_bb or through the empty middle_bb in between. Right above the above checks is if ((cond2_phi_edge->flags & EDGE_FALSE_VALUE) && HONOR_NANS (TREE_TYPE (lhs1))) return false; so for HONOR_NANS, cond2_phi_edge must be TRUE edge, otherwise it can be either. The problematic check that causes the miscompilation of the testcase below wants to verify that the two comparisons (cmp1 being code of a_3(D) > b_5(D) and cmp2 a_3(D) < b_5(D))) are actually different, not just non-removed useless duplications (which is what causes miscompilation of the testcase below). The lhs2 == lhs1 xored case is whether the 2 comparisons are x cmp1 y vs. x cmp2 y or x cmp1 y vs. y cmp2 x (earlier code verifies the operands aren't different in other way with the exception of integral comparisons and < 4 vs. <= 3 etc.). For the HONOR_NANS case where we know cond2_phi_edge is TRUE the other xor operand is whether both cmp2 and cmp1 are />= (note, we can treat LT_EXPR and LE_EXPR the same because the optimization requires an equality comparison first, so LT_EXPR vs. LE_EXPR doesn't matter). But for !HONOR_NANS I wrote a condition checking both the comparison codes and corresponding edge flags. That is wrong because whether e1 is TRUE or FALSE edge has been accounted already in the if (e1->flags & EDGE_TRUE_VALUE) code above, all we care about is whether cond2_phi_edge is EDGE_TRUE_VALUE or EDGE_FALSE_VALUE or the comparison codes of the two comparisons (and order of their arguments). So, instead this xors lhs2 == lhs1 with whether cmp{1,2} are the same with whether cond2_phi_edge is EDGE_FALSE_VALUE. For HONOR_NANS there is no difference because the last term will be false. The pr94589*.c tests already cover quite a lot of different cases that should or shouldn't be matched. For 15 and older the testcase will need to be tweaked slightly (see the PR), so that it tests miscompilation in those releases. 2026-08-04 Jakub Jelinek PR tree-optimization/126564 * tree-ssa-phiopt.cc (spaceship_replacement): Fix up condition when to punt because of redundant cmp1 with cmp2, xor in lhs1 == lhs2 with difference of cmp2 from cmp1 (ignoring LT_EXPR vs. LE_EXPR and GT_EXPR vs. GE_EXPR differences) and 1 if cond2_phi_edge is EDGE_FALSE_VALUE. * gcc.dg/torture/pr126564.c: New test. Reviewed-by: Richard Biener (cherry picked from commit 5e9087929abff340ff8b132da837372875c584aa) diff --git a/gcc/testsuite/gcc.dg/torture/pr126564.c b/gcc/testsuite/gcc.dg/torture/pr126564.c new file mode 100644 index 00000000000..31077dbebe6 --- /dev/null +++ b/gcc/testsuite/gcc.dg/torture/pr126564.c @@ -0,0 +1,25 @@ +/* PR tree-optimization/126564 */ +/* { dg-do run } */ + +[[gnu::noipa]] int +foo (int x, int y) +{ + int c = -128; + if (x == y) + c = 0; + else if (x < y) + c = -1; + else if (x <= y) + c = 1; + return c > 0; +} + +int +main () +{ + int i, j; + for (i = -3; i <= 3; i++) + for (j = -3; j <= 3; j++) + if (foo (i, j) != 0) + __builtin_abort (); +} diff --git a/gcc/tree-ssa-phiopt.cc b/gcc/tree-ssa-phiopt.cc index ebbb5e2f1d8..2a8bb852981 100644 --- a/gcc/tree-ssa-phiopt.cc +++ b/gcc/tree-ssa-phiopt.cc @@ -2159,15 +2159,9 @@ spaceship_replacement (basic_block cond_bb, basic_block middle_bb, must be different for non-swapped operands and same for swapped operands. */ if ((lhs2 == lhs1) - ^ (HONOR_NANS (TREE_TYPE (lhs1)) - ? ((cmp2 == LT_EXPR || cmp2 == LE_EXPR) - != (cmp1 == LT_EXPR || cmp1 == LE_EXPR)) - : (((cond2_phi_edge->flags - & ((cmp2 == LT_EXPR || cmp2 == LE_EXPR) - ? EDGE_TRUE_VALUE : EDGE_FALSE_VALUE)) != 0) - != ((e1->flags - & ((cmp1 == LT_EXPR || cmp1 == LE_EXPR) - ? EDGE_TRUE_VALUE : EDGE_FALSE_VALUE)) != 0)))) + ^ ((cmp2 == LT_EXPR || cmp2 == LE_EXPR) + != (cmp1 == LT_EXPR || cmp1 == LE_EXPR)) + ^ ((cond2_phi_edge->flags & EDGE_FALSE_VALUE) != 0)) return false; if (!single_pred_p (cond2_bb) || !cond_only_block_p (cond2_bb)) return false; commit 13a6f9865aa6d938389a8361159b32a715d072f1 Author: Jakub Jelinek Date: Tue Aug 4 10:37:09 2026 +0200 widening_mul: Fix up ICE in maybe_optimize_guarding_check [PR126601] The following testcase ICEs, because we try to quick_push into an already full vector. The caller (match_arith_overflow) has auto_vec mul_stmts; and 0-6 mul_stmts.quick_push (...); calls (none of that in a loop), and then call to that maybe_optimize_guarding_check function which does one quick_push, but the function is called in a FOR_EACH_IMM_USE_STMT (use_stmt, iter, cast_lhs ? cast_lhs : lhs) loop, so if we are unlucky as on the attached testcase, it is called more than twice and either triggers ICE, or worse with checking disabled buffer overflow. The following patch fixes that by using safe_push in that spot instead. 2026-08-04 Jakub Jelinek PR tree-optimization/126601 * tree-ssa-math-opts.cc (maybe_optimize_guarding_check): Use safe_push on mul_stmts rather than quick_push. * gcc.dg/tree-ssa/pr126601.c: New test. Reviewed-by: Richard Biener (cherry picked from commit a49c114c7b3edd33a6ff2e50e6276ca1fbe8ad83) diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr126601.c b/gcc/testsuite/gcc.dg/tree-ssa/pr126601.c new file mode 100644 index 00000000000..971ccba5e18 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/pr126601.c @@ -0,0 +1,29 @@ +/* PR tree-optimization/126601 */ +/* { dg-do compile } */ +/* { dg-options "-Os" } */ + +volatile int c[16]; + +[[gnu::noipa]] int +foo (unsigned x, unsigned y) +{ + unsigned r = x * y; + int t = 0; + if (c[0]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[1]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[2]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[3]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[4]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[5]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[6]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[7]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[8]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[9]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[10]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[11]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[12]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[13]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[14]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + if (c[15]) { int u = 0; if (x != 0) u = (r / x != y); t += u; } + return t; +} diff --git a/gcc/tree-ssa-math-opts.cc b/gcc/tree-ssa-math-opts.cc index cd3fd2fc8fb..63e7f714f7e 100644 --- a/gcc/tree-ssa-math-opts.cc +++ b/gcc/tree-ssa-math-opts.cc @@ -3762,7 +3762,7 @@ maybe_optimize_guarding_check (vec &mul_stmts, gimple *cond_stmt, return; } gimple_stmt_iterator gsi = gsi_after_labels (bb); - mul_stmts.quick_push (div_stmt); + mul_stmts.safe_push (div_stmt); if (is_gimple_debug (gsi_stmt (gsi))) gsi_next_nondebug (&gsi); unsigned cast_count = 0; commit 53f44e2c5fccf31bd0b4e356d5f09a0e0919579d Author: Jakub Jelinek Date: Tue Aug 4 21:41:16 2026 +0200 testsuite: Fix up gcc.dg/torture/bitint-100.c test [PR124948] On Mon, Aug 03, 2026 at 01:56:35PM +0200, Torbjorn SVENSSON wrote: > On 2026-08-03 13:54, Jakub Jelinek wrote: > > On Mon, Aug 03, 2026 at 01:50:18PM +0200, Torbjorn SVENSSON wrote: > > > This change introduces new failures for arm-none-eabi using thumb/arch=armv6s-m/cpu=cortex-m0/float-abi=soft/fpu=auto. > > > > > > bitint-100.c:(.text+0x5a): undefined reference to `__atomic_compare_exchange_4' > > > /build/install-native/arm-none-eabi/bin/ld: (__atomic_compare_exchange_4): Unknown destination type (ARM/Thumb) in /tmp/ccgSaSgH.o > > > FAIL: gcc.dg/torture/bitint-100.c -O0 (test for excess errors) > > > > > > Same failure exist on both trunk and releases/gcc-16. > > > > I thought gcc has been changed to add -latomic_asneeded by default. > > Or is this because the linker doesn't support it in this configuration? > To my knowledge, there is no atomic support for armv6s-m, but I can be wrong. Most of the tests that are dg-do run and use atomics on int/long use sync_int_long effective target. Atomics on _BitInt(17), i.e. something on all currently supported targets larger than short, probably need to be treated the same. 2026-08-04 Jakub Jelinek PR target/124948 * gcc.dg/torture/bitint-100.c: Require also sync_int_long effective target. Reviewed-by: Andrea Pinski (cherry picked from commit 17d0df5cdb1b2983481612e4e454f659bc5ff738) diff --git a/gcc/testsuite/gcc.dg/torture/bitint-100.c b/gcc/testsuite/gcc.dg/torture/bitint-100.c index 4c6e781777c..b9a75db67aa 100644 --- a/gcc/testsuite/gcc.dg/torture/bitint-100.c +++ b/gcc/testsuite/gcc.dg/torture/bitint-100.c @@ -1,5 +1,5 @@ /* PR target/124948 */ -/* { dg-do run { target bitint } } */ +/* { dg-do run { target { bitint && sync_int_long } } } */ /* { dg-options "-std=c23 -pedantic-errors" } */ /* { dg-skip-if "" { ! run_expensive_tests } { "*" } { "-O0" "-O2" } } */ /* { dg-skip-if "" { ! run_expensive_tests } { "-flto" } { "" } } */ commit 0b0209ca1aff9f7cd28150b5714cb6dd7514b313 Author: Jakub Jelinek Date: Tue Aug 4 21:42:49 2026 +0200 testsuite: Fix up gcc.dg/pr126464.c test [PR126464] On Tue, Aug 04, 2026 at 02:13:19PM +0200, Torbjorn SVENSSON wrote: > This causes regression on most (all?) arm-none-eabi targets. > /build/gcc_src/gcc/testsuite/gcc.dg/pr126464.c:56:3: warning: floating constant exceeds range of 'long double' [-Woverflow] This patch guards it with preprocessor tests whether such floating point constants are representable. 2026-08-04 Jakub Jelinek PR tree-optimization/126464 * gcc.dg/pr126464.c: Guard uses of 1e300 with __DBL_MAX_10_EXP__ >= 301 and uses of 1e4000L with __LDBL_MAX_10_EXP__ >= 4001. Reviewed-by: Andrea Pinski (cherry picked from commit b5b0203b8c3b7cee4e65a09e4443f948dee434b4) diff --git a/gcc/testsuite/gcc.dg/pr126464.c b/gcc/testsuite/gcc.dg/pr126464.c index b6eb1320dec..620b9b42f62 100644 --- a/gcc/testsuite/gcc.dg/pr126464.c +++ b/gcc/testsuite/gcc.dg/pr126464.c @@ -47,15 +47,19 @@ qux (long double x) int main () { +#if __DBL_MAX_10_EXP__ >= 301 if (!__builtin_isinf ((double) 1e300) && __builtin_isinf ((float) 1e300) && (foo (-1e300) != -5e299 || baz (1e300) != 5e299)) __builtin_abort (); +#endif +#if __LDBL_MAX_10_EXP__ >= 4001 if (!__builtin_isinf ((long double) 1e4000L) && __builtin_isinf ((double) 1e4000L) && (bar (1e4000L) != 5e3999L || qux (-1e4000L) != -5e3999L)) __builtin_abort (); +#endif } commit d2abcdc5727d0d4e31d6d9d5809aed25818d16a8 Author: Jakub Jelinek Date: Thu Aug 6 11:01:15 2026 +0200 libcpp: Fix up ICE with __VA_OPT__ [PR125048] The following testcase ICEs, because we call linemap_enter_macro and remember what it returned and then in a loop sometimes call vaopt_state::update (src) which can call expand_arg which under the hood can reallocate the pfile->line_table->info_macro.maps array. As linemap_enter_macro returns a pointer into that array, if the array is reallocated, we then dereference the freed memory. The following patch fixes it by remembering the offset into the pfile->line_table->info_macro.maps array and when we could have called expand_arg, updates the map variable so that it is correct even after possible reallocation. 2026-04-28 Jakub Jelinek PR preprocessor/125048 * macro.cc (replace_args): Remember the position of map in the pfile->line_table->info_macro.maps array and if vostate is DROP, recompute map pointer as expand_arg call could have reallocated the pfile->line_table->info_macro.maps array. * c-c++-common/cpp/va-opt-11.c: New test. Reviewed-by: Jason Merrill (cherry picked from commit 7b87f41690d46b869c21d0d0537b766698da3827) diff --git a/gcc/testsuite/c-c++-common/cpp/va-opt-11.c b/gcc/testsuite/c-c++-common/cpp/va-opt-11.c new file mode 100644 index 00000000000..68cf55817ed --- /dev/null +++ b/gcc/testsuite/c-c++-common/cpp/va-opt-11.c @@ -0,0 +1,13 @@ +/* PR preprocessor/125048 */ +/* { dg-do preprocess } */ +/* { dg-options "-std=c23" { target c } } */ +/* { dg-options "-std=c++20" { target c++ } } */ + +#define A(...)B(B(B(B(__VA_ARGS__##__VA_OPT__())))) +#define B(...)C(C(C(C(__VA_ARGS__##__VA_OPT__())))) +#define C(...)D(D(D(D(__VA_ARGS__##__VA_OPT__())))) +#define D(...)E(E(E(E(__VA_ARGS__##__VA_OPT__())))) +#define E(...)__VA_ARGS__ +#define F +A(F) +/* { dg-final { scan-file va-opt-11.i "D\\\(D\\\(D\\\(C\\\(C\\\(C\\\(B\\\(B\\\(B\\\(\\\)\\\)\\\)\\\)\\\)\\\)\\\)\\\)\\\)" } } */ diff --git a/libcpp/macro.cc b/libcpp/macro.cc index c29a34302b6..15260a21b58 100644 --- a/libcpp/macro.cc +++ b/libcpp/macro.cc @@ -1995,6 +1995,7 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, location_t *virt_locs = NULL; unsigned int exp_count; const line_map_macro *map = NULL; + size_t map_idx = 0; int track_macro_exp; /* First, fully macro-expand arguments, calculating the number of @@ -2105,6 +2106,7 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, map = linemap_enter_macro (pfile->line_table, node, expansion_point_loc, num_macro_tokens); + map_idx = map - pfile->line_table->info_macro.maps; } i = 0; vaopt_state vaopt_tracker (pfile, macro->variadic, &args[macro->paramc - 1]); @@ -2226,6 +2228,11 @@ replace_args (cpp_reader *pfile, cpp_hashnode *node, cpp_macro *macro, NULL, 0); } } + else if (vostate == vaopt_state::DROP && map) + /* For the DROP case vaopt_tracker.update (src) can call + expand_arg and that can reallocate the maps, so need to + update the map pointer. */ + map = pfile->line_table->info_macro.maps + map_idx; continue; } commit 742ca4610d51e156c287daebc8e293f155725c0b Author: Jakub Jelinek Date: Thu Aug 6 11:03:43 2026 +0200 testsuite: Clarify the std module export plugin diagnostics [PR125200] The following patch attempts to clarify the diagnostics, so that one e.g. doesn't look for import std::whatever; in the headers or something similar. 2026-08-06 Jakub Jelinek PR libstdc++/125200 * g++.dg/plugin/std_module_exports_plugin.cc (plugin_dump_decl): Use %< and %>. Clarify the error message and add a note. Reviewed-by: Jason Merrill (cherry picked from commit 19a304d3680a1aeeb8ca412a6fe108a3f3b9d305) diff --git a/gcc/testsuite/g++.dg/plugin/std_module_exports_plugin.cc b/gcc/testsuite/g++.dg/plugin/std_module_exports_plugin.cc index e81eb6d3fb6..21a765041f6 100644 --- a/gcc/testsuite/g++.dg/plugin/std_module_exports_plugin.cc +++ b/gcc/testsuite/g++.dg/plugin/std_module_exports_plugin.cc @@ -106,13 +106,19 @@ plugin_dump_decl (tree decl, char *scope, hash_set **exported_usings) if (((int) whitelist[i].enabled_in & (int) this_std) != 0) { inform (DECL_SOURCE_LOCATION (decl), - "missing using %s%D; whitelisted", scope, name); + "missing % whitelisted", scope, name); return; } break; } - error_at (DECL_SOURCE_LOCATION (decl), "missing using %s%D;", scope, name); + auto_diagnostic_group d; + error_at (DECL_SOURCE_LOCATION (decl), + "missing % in libstdc++-v3/src/c++23/std*.cc.in", + scope, name); + inform (DECL_SOURCE_LOCATION (decl), + "%<%s%D%> found in std namespace but not exported from std module", + scope, name); } void commit c40ebe81cd414dd691a065fb4273d0e3111b5225 Author: Jakub Jelinek Date: Thu Aug 6 11:13:53 2026 +0200 c++: Fix structured binding pack instantiation ICE [PR125591] The following testcase ICEs in tsubst_pack_expansion, we trigger the gcc_assert (DECL_DECOMPOSITION_P (orig_arg)); assertion. But in this case, retrieve_local_specialization doesn't return the expected DECL_DECOMPOSITION_P, but ARGUMENT_PACK_SELECT instead. That is because it has been registered earlier in gen_elem_of_pack_expansion_instantiation in aps = make_argument_pack_select (arg_pack, index); if (!mark_used (parm, complain) && !(complain & tf_error)) return error_mark_node; register_local_specialization (aps, parm); The following patch just stops assuming retrieve_local_specialization has to return DECL_DECOMPOSITION_P, but allows also ARGUMENT_PACK_SELECT. The patch is large due to reindentation, with diff -upb it is just @@ -14309,8 +14309,9 @@ tsubst_pack_expansion (tree t, tree args else if (DECL_DECOMPOSITION_P (parm_pack)) { orig_arg = retrieve_local_specialization (parm_pack); + if (DECL_DECOMPOSITION_P (orig_arg)) + { expand_sb_pack: - gcc_assert (DECL_DECOMPOSITION_P (orig_arg)); if (TREE_TYPE (orig_arg) == error_mark_node) return error_mark_node; gcc_assert (DECL_HAS_VALUE_EXPR_P (orig_arg)); @@ -14339,6 +14340,12 @@ tsubst_pack_expansion (tree t, tree args } } else + { + gcc_assert (TREE_CODE (orig_arg) == ARGUMENT_PACK_SELECT); + arg_pack = orig_arg; + } + } + else { int idx; template_parm_level_and_index (parm_pack, &level, &idx); 2026-08-06 Jakub Jelinek PR c++/125591 * pt.cc (tsubst_pack_expansion): Don't require retrieve_local_specialization on structured binding to always return structured binding, instead handle if it returns ARGUMENT_PACK_SELECT. * g++.dg/cpp26/decomp31.C: New test. Reviewed-by: Jason Merrill (cherry picked from commit 091a150a8a51bc953906d3da2a1a09d83fc36633) diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 4359ae8e556..729c7b19165 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -14254,33 +14254,40 @@ tsubst_pack_expansion (tree t, tree args, tsubst_flags_t complain, else if (DECL_DECOMPOSITION_P (parm_pack)) { orig_arg = retrieve_local_specialization (parm_pack); - expand_sb_pack: - gcc_assert (DECL_DECOMPOSITION_P (orig_arg)); - if (TREE_TYPE (orig_arg) == error_mark_node) - return error_mark_node; - gcc_assert (DECL_HAS_VALUE_EXPR_P (orig_arg)); - arg_pack = DECL_VALUE_EXPR (orig_arg); - if (TREE_CODE (arg_pack) != ARRAY_REF) + if (DECL_DECOMPOSITION_P (orig_arg)) { - /* Structured binding packs when initializer is non-dependent - should have their DECL_VALUE_EXPR set to a TREE_VEC. See - cp_finish_decomp comment above the packv variable for - details. */ - tree vec = make_tree_vec (TREE_VEC_LENGTH (arg_pack) - 2); - if (TREE_VEC_LENGTH (vec)) - memcpy (TREE_VEC_BEGIN (vec), &TREE_VEC_ELT (arg_pack, 2), - TREE_VEC_LENGTH (vec) * sizeof (tree)); - arg_pack = make_node (NONTYPE_ARGUMENT_PACK); - ARGUMENT_PACK_ARGS (arg_pack) = vec; + expand_sb_pack: + if (TREE_TYPE (orig_arg) == error_mark_node) + return error_mark_node; + gcc_assert (DECL_HAS_VALUE_EXPR_P (orig_arg)); + arg_pack = DECL_VALUE_EXPR (orig_arg); + if (TREE_CODE (arg_pack) != ARRAY_REF) + { + /* Structured binding packs when initializer is non-dependent + should have their DECL_VALUE_EXPR set to a TREE_VEC. See + cp_finish_decomp comment above the packv variable for + details. */ + tree vec = make_tree_vec (TREE_VEC_LENGTH (arg_pack) - 2); + if (TREE_VEC_LENGTH (vec)) + memcpy (TREE_VEC_BEGIN (vec), &TREE_VEC_ELT (arg_pack, 2), + TREE_VEC_LENGTH (vec) * sizeof (tree)); + arg_pack = make_node (NONTYPE_ARGUMENT_PACK); + ARGUMENT_PACK_ARGS (arg_pack) = vec; + } + else + { + /* If the structured binding pack has type dependent + base, we can't expand it yet. */ + tree base = TREE_OPERAND (arg_pack, 0); + gcc_assert (VAR_P (base) + && type_dependent_expression_p (base)); + arg_pack = NULL_TREE; + } } else { - /* If the structured binding pack has type dependent - base, we can't expand it yet. */ - tree base = TREE_OPERAND (arg_pack, 0); - gcc_assert (VAR_P (base) - && type_dependent_expression_p (base)); - arg_pack = NULL_TREE; + gcc_assert (TREE_CODE (orig_arg) == ARGUMENT_PACK_SELECT); + arg_pack = orig_arg; } } else diff --git a/gcc/testsuite/g++.dg/cpp26/decomp31.C b/gcc/testsuite/g++.dg/cpp26/decomp31.C new file mode 100644 index 00000000000..f9657a9ca6c --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp26/decomp31.C @@ -0,0 +1,19 @@ +// PR c++/125591 +// { dg-do compile { target c++20 } } +// { dg-options "" } + +template +concept is_same_v = __is_same (T, U); + +struct A { int x, y, z; }; +struct B { int x; long y; }; + +template +consteval bool +foo () +{ + constexpr auto [...Ms] = V {}; // { dg-warning "structured binding packs only available with" "" { target c++23_down } } + // { dg-warning "structured binding declaration can be 'constexpr' only with" "" { target c++23_down } .-1 } + using T = decltype (Ms...[0]); // { dg-warning "pack indexing only available with" "" { target c++23_down } } + return (is_same_v && ...); +} commit 31c151da46e71a35e3ee6e0ad6abd21a45f06022 Author: Jakub Jelinek Date: Thu Aug 6 11:26:42 2026 +0200 c++: Fix up constexpr handling of break in expansion statements [PR125601] As the following testcase shows, we mishandle break statements in expansion statements during constant evaluation. finish_expansion_stmt changes the BREAK_STMT/CONTINUE_STMTs to GOTO_EXPRs to corresponding labels and marks those labels with LABEL_DECL_BREAK/LABEL_DECL_CONTINUE so that constexpr.cc is happy about those. The continue label (if any is needed) is right after each iteration's instantiated body, the break label (if any is needed) is after the last body. Now, continue seems to work properly, when we encounter it, we set *jump_target to it and continues predicate is true on it, but cxx_eval_statement_list has /* We've found a continue, so skip everything until we reach the label its jumping to. */ if (continues (jump_target)) { if (label_matches (ctx, jump_target, stmt)) /* Found it. */ *jump_target = NULL_TREE; else continue; } ... if (returns (jump_target) || breaks (jump_target) || throws (jump_target)) break; and so it properly iterates through statement lists until it finds the label decl. But unfortunately it doesn't work for break, we set *jump_target on the GOTO_EXPR, breaks predicate is true, but then break out of any STATEMENT_LISTs and the only way to resume processing of statements in that case is when cxx_eval_loop_expr does if (breaks (jump_target)) { *jump_target = NULL_TREE; break; } or similarly switch handling. But for expansion stmt there is nothing like that in the IL, so either we break some outer loop (foo in the testcase) instead, or fail because we think there was no return in the function. The following patch fixes this by wrapping the series of instantiated expansion stmt bodies (for all iterations) in an artificial do ... while (0); statement, but does that only if break; was actually needed (i.e. when we are emitting a break_label). 2026-08-06 Jakub Jelinek PR c++/125601 * pt.cc (finish_expansion_stmt): If break; was seen in any of the expansion stmt bodies, wrap all the bodies in an artificial do ... while (0); stmt. * g++.dg/cpp26/expansion-stmt45.C: New test. Reviewed-by: Jason Merrill (cherry picked from commit 94843e8b8a47e9a4972b73637578dac12fe1ade7) diff --git a/gcc/cp/pt.cc b/gcc/cp/pt.cc index 729c7b19165..ab3ae922ac5 100644 --- a/gcc/cp/pt.cc +++ b/gcc/cp/pt.cc @@ -33659,6 +33659,7 @@ finish_expansion_stmt (tree expansion_stmt, tree args, DECL_NAME (decl) = NULL_TREE; } + tree stmt_list = push_stmt_list (); expansion_stmt_bc bc_data = { NULL_TREE, NULL_TREE, NULL, loc, false }; for (unsigned HOST_WIDE_INT i = 0; i < n; ++i) @@ -33858,7 +33859,19 @@ finish_expansion_stmt (tree expansion_stmt, tree args, } } if (bc_data.break_label) - add_stmt (build1 (LABEL_EXPR, void_type_node, bc_data.break_label)); + { + /* If break; is seen, wrap all the expansion stmt bodies in + a single artificial do ... while (0); statement, so that + constant evaluation handles break; correctly. */ + tree do_stmt + = build_stmt (loc, DO_STMT, NULL_TREE, NULL_TREE, NULL_TREE); + DO_COND (do_stmt) = boolean_false_node; + DO_BODY (do_stmt) = pop_stmt_list (stmt_list); + add_stmt (do_stmt); + add_stmt (build1 (LABEL_EXPR, void_type_node, bc_data.break_label)); + } + else + add_stmt (pop_stmt_list (stmt_list)); if (args == NULL_TREE) { TREE_TYPE (range_decl) = error_mark_node; diff --git a/gcc/testsuite/g++.dg/cpp26/expansion-stmt45.C b/gcc/testsuite/g++.dg/cpp26/expansion-stmt45.C new file mode 100644 index 00000000000..eeaf9981455 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp26/expansion-stmt45.C @@ -0,0 +1,64 @@ +// PR c++/125601 +// { dg-do run { target c++14 } } +// { dg-options "-O2" } + +constexpr int +foo (int x) +{ + int a = 0, b = 3; + while (b > 0) + { + ++a; + --b; + template for (constexpr int value : { 10, 20, 30 }) // { dg-warning "'template for' only available with" "" { target c++23_down } } + { + a += value; + if (x == 0) + break; + else if (x == 1) + continue; + a += 42; + } + } + return a; +} + +constexpr int +bar (int x) +{ + int a = 0; + template for (constexpr int value : { 10, 20, 30 }) // { dg-warning "'template for' only available with" "" { target c++23_down } } + { + a += value; + if (x == 0) + break; + else if (x == 1) + continue; + a += 42; + } + return a; +} + +static_assert (foo (0) == 3 * (1 + 10), ""); +static_assert (foo (1) == 3 * (1 + 10 + 20 + 30), ""); +static_assert (foo (2) == 3 * (1 + 10 + 20 + 30 + 3 * 42), ""); +static_assert (bar (0) == 10, ""); +static_assert (bar (1) == 10 + 20 + 30, ""); +static_assert (bar (2) == 10 + 20 + 30 + 3 * 42, ""); + +int +main () +{ + if (foo (0) != 3 * (1 + 10)) + __builtin_abort (); + if (foo (1) != 3 * (1 + 10 + 20 + 30)) + __builtin_abort (); + if (foo (2) != 3 * (1 + 10 + 20 + 30 + 3 * 42)) + __builtin_abort (); + if (bar (0) != 10) + __builtin_abort (); + if (bar (1) != 10 + 20 + 30) + __builtin_abort (); + if (bar (2) != 10 + 20 + 30 + 3 * 42) + __builtin_abort (); +} commit 141139e43d5d2f0e752e95cc32eaf8b39a2b3510 Author: Jakub Jelinek Date: Thu Aug 6 12:24:15 2026 +0200 c++: Mangling fix for type alias reflections [PR125680] The following testcase ICEs, because we use write_unqualified_name to write the type alias name. Unfortunately, it is an alias for an unnamed type and write_unqualified_name in that case uses if (TREE_CODE (decl) == TYPE_DECL && enum_with_enumerator_for_linkage_p (type)) write_unnamed_enum_name (type); else if (TREE_CODE (decl) == TYPE_DECL && TYPE_UNNAMED_P (type)) write_unnamed_type_name (type); else if (TREE_CODE (decl) == TYPE_DECL && LAMBDA_TYPE_P (type)) write_closure_type_name (type); else write_source_name (DECL_NAME (decl)); and write_unnamed_type_node else if (TYPE_CLASS_SCOPE_P (type)) discriminator = nested_anon_class_index (type); and nested_anon_class_index ICEs, because type is the type alias and obviously it can't find a type alias among DECL_IMPLICIT_TYPEDEF_P nembers. In this case, we really want to write the source name of the type alias (which always should have DECL_NAME), regardless of what the dealias of the type alias is (that is emitted later in the mangling). Note, this isn't the only PR against this area, there is another one where write_prefix (decl_mangling_context (arg)); doesn't work properly for local names. 2026-08-06 Jakub Jelinek PR c++/125680 * mangle.cc (write_reflection): For type aliases use maybe_write_module and write_source_name instead of write_unqualified_name. * g++.dg/reflect/mangle8.C: New test. Reviewed-by: Jason Merrill (cherry picked from commit 4f751c0b701296bbeb63ff467c7c7e22a9075d19) diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc index 6ac54c81fc5..d8a70233bea 100644 --- a/gcc/cp/mangle.cc +++ b/gcc/cp/mangle.cc @@ -4240,7 +4240,9 @@ write_reflection (tree refl) write_template_args, it shouldn't be remembered among substitutions. */ write_prefix (decl_mangling_context (arg)); - write_unqualified_name (arg); + if (modules_p ()) + maybe_write_module (arg); + write_source_name (DECL_NAME (arg)); tree template_info = maybe_template_info (arg); if (template_info) write_template_args (TI_ARGS (template_info)); diff --git a/gcc/testsuite/g++.dg/reflect/mangle8.C b/gcc/testsuite/g++.dg/reflect/mangle8.C new file mode 100644 index 00000000000..0266aa2d0da --- /dev/null +++ b/gcc/testsuite/g++.dg/reflect/mangle8.C @@ -0,0 +1,32 @@ +// PR c++/125680 +// { dg-do compile { target c++26 } } +// { dg-additional-options "-freflection" } + +#include + +struct A { struct { int b; } a[4]; }; + +template +struct B +{ + consteval static std::meta::info + foo () + { + if constexpr (is_array_type (I)) + { + using C = typename [: remove_extent (I) :]; + return ^^C; + } + else + { + constexpr auto c = type_of (nonstatic_data_members_of (I, std::meta::access_context::current ())[0]); + using C = typename [: c :]; + return ^^C; + } + } + constexpr static std::meta::info b = foo (); +}; + +constexpr auto a = B <^^A>::b; +constexpr auto b = B ::b; +constexpr auto c = B ::b; commit fac66e827216a5593fdf501929babf01338a4e79 Author: Jakub Jelinek Date: Thu Aug 6 13:24:08 2026 +0200 c++: Fix mangling of empty anon union/struct unnamed NSDMs [PR125541] Non-static data members are currently mangled as dm This works fine for NSDMs with a name, or even the unnamed anon union/struct NSDMs iff they have any named members in them (in that case the is using anon_aggr_naming_decl). As the following testcases show, if the anon union/struct is empty, we ICE, because there is nothing we can print as the name. The following patch mangles it similarly to unnamed bitfields in that case, simply counts the index of such problematic empty unnamed anon union/struct within the class and emits _ for the first one, etc. 2026-06-12 Jakub Jelinek PR c++/125541 * mangle.cc (write_reflection): Mangle empty anonymous union/struct data members as "da" rather than "dm" and use index of such a data member instead of name. * g++.dg/reflect/mangle1.C: Add further 2 tests. * g++.dg/reflect/mangle9.C: New test. Reviewed-by: Jason Merrill (cherry picked from commit 24754ac2629968fba1681ba51a96ed5bfd51546f) diff --git a/gcc/cp/mangle.cc b/gcc/cp/mangle.cc index d8a70233bea..6da1484affa 100644 --- a/gcc/cp/mangle.cc +++ b/gcc/cp/mangle.cc @@ -4186,6 +4186,8 @@ write_expression (tree expr) [ ] _ # type alias ::= ty # type ::= dm # ns data member + ::= da [ ] _ # empty anon union + # data member ::= un [ ] _ # unnamed bitfld ::= ct [ ] # class template ::= ft [ ] # function template @@ -4207,6 +4209,11 @@ write_reflection (tree refl) { char prefix[3]; tree arg = reflection_mangle_prefix (refl, prefix); + if (strcmp (prefix, "dm") == 0 + && DECL_NAME (arg) == NULL_TREE + && ANON_AGGR_TYPE_P (TREE_TYPE (arg)) + && anon_aggr_naming_decl (TREE_TYPE (arg)) == NULL_TREE) + strcpy (prefix, "da"); write_string (prefix); /* If there is no argument, nothing further needs to be mangled. */ if (arg == NULL_TREE) @@ -4259,6 +4266,21 @@ write_reflection (tree refl) write_prefix (ctx); write_unqualified_name (arg); } + else if (strcmp (prefix, "da") == 0) + { + int idx = 0; + tree ctx = decl_mangling_context (arg); + for (tree f = TYPE_FIELDS (ctx); f; f = DECL_CHAIN (f)) + if (f == arg) + break; + else if (TREE_CODE (f) == FIELD_DECL + && DECL_NAME (f) == NULL_TREE + && ANON_AGGR_TYPE_P (TREE_TYPE (f)) + && anon_aggr_naming_decl (TREE_TYPE (f)) == NULL_TREE) + ++idx; + write_prefix (ctx); + write_compact_number (idx); + } else if (strcmp (prefix, "un") == 0) { tree ctx = DECL_CONTEXT (arg); diff --git a/gcc/testsuite/g++.dg/reflect/mangle1.C b/gcc/testsuite/g++.dg/reflect/mangle1.C index e0e60994312..e0232837e66 100644 --- a/gcc/testsuite/g++.dg/reflect/mangle1.C +++ b/gcc/testsuite/g++.dg/reflect/mangle1.C @@ -15,6 +15,7 @@ struct S : B { int : 0; static int var; }; +struct W { union {}; union {}; union {}; union {}; }; template struct TCls {}; template void TFn (); template int TVar; @@ -172,6 +173,8 @@ baz (int x) std::meta::reflect_constant (43L), std::meta::reflect_constant (NS2::AA { 1, 2 }) } })> (); // data member description bar <340, ^^NS2::X::~X> (); // function + bar <350, members_of (^^W, ctx)[1]> (); // empty anon union non-static data member + bar <351, members_of (^^W, ctx)[7]> (); // empty anon union non-static data member } // { dg-final { scan-assembler "_Z3fooILi1EDmEvv" } } @@ -258,3 +261,5 @@ baz (int x) // { dg-final { scan-assembler "_Z3barILi334ELDmdsi___0_EEvv" } } // { dg-final { scan-assembler "_Z3barILi335ELDmdsi_1____Li42ELl43EXtlN3NS22AAELi1ELi2EEEEEvv" } } // { dg-final { scan-assembler "_Z3barILi340ELDmfnN3NS21XD4EvEEvv" } } +// { dg-final { scan-assembler "_Z3barILi350ELDmda1W_EEvv" } } +// { dg-final { scan-assembler "_Z3barILi351ELDmda1W2_EEvv" } } diff --git a/gcc/testsuite/g++.dg/reflect/mangle9.C b/gcc/testsuite/g++.dg/reflect/mangle9.C new file mode 100644 index 00000000000..1f78daa6dd5 --- /dev/null +++ b/gcc/testsuite/g++.dg/reflect/mangle9.C @@ -0,0 +1,31 @@ +// { dg-do compile { target c++26 } } +// { dg-options "-freflection -O0" } + +#include + +struct W { union { union {}; union {}; union {}; union {}; }; + union { union {}; union {}; union {}; union {}; }; }; + +constexpr auto ctx = std::meta::access_context::current (); + +template +void +bar () +{ +} + +void +baz (int x) +{ + constexpr auto a = members_of (^^W, ctx)[0]; + bar <10, members_of (a, ctx)[1]> (); // empty anon union non-static data member + bar <11, members_of (a, ctx)[7]> (); // empty anon union non-static data member + constexpr auto b = members_of (^^W, ctx)[2]; + bar <12, members_of (b, ctx)[1]> (); // empty anon union non-static data member + bar <13, members_of (b, ctx)[7]> (); // empty anon union non-static data member +} + +// { dg-final { scan-assembler "_Z3barILi10ELDmda1WUt__EEvv" } } +// { dg-final { scan-assembler "_Z3barILi11ELDmda1WUt_2_EEvv" } } +// { dg-final { scan-assembler "_Z3barILi12ELDmda1WUt0__EEvv" } } +// { dg-final { scan-assembler "_Z3barILi13ELDmda1WUt0_2_EEvv" } } commit fcfd9dd65b9fd34414b26c160847b134dd317707 Author: Paul Thomas Date: Fri Jul 24 15:05:46 2026 +0100 Fortran: Auto deallocate coarrays, allocated in team blocks [PR126205] Gfortran was not compliant with F2018(11.1.5.2), which requires that coarrays that are allocated within a team block are deallocated immediately before END TEAM. This the fourth variant of the patch; the main differences being whether the code is located on resolve.cc, split between resolve.cc and trans-stmt.cc or, as here, split between parse.cc, match.cc and st.cc. The main attraction of the latter scheme is that coarray.cc and resolve.cc do the main job of preparing the code for translation. The team context is tracked using a vector of team namespaces, which is pushed at CHANGE TEAM and popped at END TEAM. The allocate expressions are stashed in a vector hash_map, keyed on the namespace. The allocate expressions are stored while the ALLOCATE statments are being matched. They are then recovered before end in parse_change_team and sent off for automatic deallocation in st.cc(deallocate_allocated_coarrays. The use of st.cc for functions generating chunks of code is a pointer to something that I have been eyeing for a long time, which is to extract all such functions from class.cc and resolve.cc so that they can be refactored to use common chunks. This, however, is for another time! 2026-07-24 Paul Thomas gcc/fortran PR fortran/126205 * gfortran.h: Add prototype for deallocate_allocated_coarrays. hash_map team_allocated_coarrays, vector team_context_stack and prototype for get_current_team_context. * match.cc (gfc_match_allocate): Capture allocate expressions of allocatable coarrays and stash in team_allocated_coarrays. * parse.cc (parse_change_team): Push team context. When end is seen, create the code to deallocate allocated coarrays in this context, using deallocate_allocated_coarrays. * st.cc (get_guarded_dealloc): Generate code to produce IF (ALLOCATED (expr)) DEALLOCATE (expr). (deallocate_allocated_coarrays): Modify the final array ref of the allocate expressions and call get_guarded_dealloc. gcc/testsuite/ PR fortran/126205 * gfortran.dg/coarray/team_allocated_coarrays.f90: New test. (cherry picked from commit 75be60856749d85ef29358e6ab4f3c48c128589c) diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h index b0ce54e1c21..e4a368bb58f 100644 --- a/gcc/fortran/gfortran.h +++ b/gcc/fortran/gfortran.h @@ -4052,13 +4052,13 @@ bool has_parameterized_comps (gfc_symbol *); /* st.cc */ extern gfc_code new_st; - void gfc_clear_new_st (void); gfc_code *gfc_get_code (gfc_exec_op); gfc_code *gfc_append_code (gfc_code *, gfc_code *); void gfc_free_statement (gfc_code *); void gfc_free_statements (gfc_code *); void gfc_free_association_list (gfc_association_list *); +void deallocate_allocated_coarrays (vec *); /* resolve.cc */ void gfc_resolve_symbol (gfc_symbol *); @@ -4234,6 +4234,9 @@ void gfc_global_used (gfc_gsymbol *, locus *); gfc_namespace* gfc_build_block_ns (gfc_namespace *); gfc_statement match_omp_directive (void); bool is_omp_declarative_stmt (gfc_statement); +extern hash_map> team_allocated_coarrays; +extern vec team_context_stack; +gfc_namespace *get_current_team_context (void); /* dependency.cc */ int gfc_dep_compare_functions (gfc_expr *, gfc_expr *, bool); diff --git a/gcc/fortran/match.cc b/gcc/fortran/match.cc index 07555536051..da7a6e78958 100644 --- a/gcc/fortran/match.cc +++ b/gcc/fortran/match.cc @@ -5433,6 +5433,23 @@ gfc_match_allocate (void) goto cleanup; } + /* F2018(11.1.5.2): Track coarrays allocated in team blocks. */ + gfc_namespace *team_ns = get_current_team_context (); + bool codim = tail->expr->symtree->n.sym->attr.codimension + || (tail->expr->symtree->n.sym->as + && tail->expr->symtree->n.sym->as->corank); + for (gfc_ref *r = tail->expr->ref; r; r = r->next) + if (r->type == REF_COMPONENT && r->u.c.component) + codim = r->u.c.component->attr.codimension + || (r->u.c.component->as && r->u.c.component->as->corank); + + if (flag_coarray == GFC_FCOARRAY_LIB && team_ns && codim) + { + gfc_expr *e = gfc_copy_expr (tail->expr); + vec &allocated = team_allocated_coarrays.get_or_insert (team_ns); + allocated.safe_push (e); + } + if (gfc_match_char (',') != MATCH_YES) break; diff --git a/gcc/fortran/parse.cc b/gcc/fortran/parse.cc index 82cd85851c8..7c0119938fe 100644 --- a/gcc/fortran/parse.cc +++ b/gcc/fortran/parse.cc @@ -5526,12 +5526,28 @@ loop: pop_state (); } + +/* F2018(11.1.5.2): Track coarrays allocated within CHANGE TEAM blocks. + Map from team namespace to vector of allocated coarray symbols. */ +hash_map> team_allocated_coarrays; + +/* Stack to track current CHANGE TEAM context. */ +vec team_context_stack; + +gfc_namespace * +get_current_team_context (void) +{ + return team_context_stack.is_empty () ? NULL : team_context_stack.last (); +} + + static void parse_change_team (void) { gfc_namespace *my_ns; gfc_state_data s; gfc_statement st; + vec *team_allocs; gfc_notify_std (GFC_STD_F2018, "CHANGE TEAM construct at %C"); @@ -5549,6 +5565,9 @@ parse_change_team (void) accept_statement (ST_CHANGE_TEAM); push_state (&s, COMP_CHANGE_TEAM, my_ns->proc_name); + /* Push team context for tracking coarrays allocated in a team block. */ + team_context_stack.safe_push (gfc_current_ns); + loop: st = parse_executable (ST_NONE); switch (st) @@ -5559,6 +5578,13 @@ loop: case_end: accept_statement (st); my_ns->code = gfc_state_stack->head; + /* F2018(11.1.5.2): Deallocate coarray expressions allocated in this + team block, */ + team_allocs = team_allocated_coarrays.get (gfc_current_ns); + if (team_allocs) + deallocate_allocated_coarrays (team_allocs); + /* Pop team context. */ + team_context_stack.pop (); break; default: diff --git a/gcc/fortran/st.cc b/gcc/fortran/st.cc index ce4fcad884f..04c3cdd4f61 100644 --- a/gcc/fortran/st.cc +++ b/gcc/fortran/st.cc @@ -366,3 +366,100 @@ gfc_free_association_list (gfc_association_list* assoc) gfc_free_association_list (assoc->next); free (assoc); } + + +/* Function to generate IF (ALLOCATED(expr)) DEALLOCATE(expr) */ + +static gfc_code * +get_guarded_dealloc (gfc_namespace *ns, gfc_expr *expr) +{ + gfc_code *dealloc = gfc_get_code (EXEC_IF); + dealloc->block = gfc_get_code (EXEC_IF); +#define ALLOCATED dealloc->block->expr1 + ALLOCATED = gfc_get_expr (); + ALLOCATED->expr_type = EXPR_FUNCTION; + ALLOCATED->where = gfc_current_locus; + gfc_find_sym_tree ("allocated", ns, 1, &ALLOCATED->symtree); + if (!ALLOCATED->symtree) + { + gfc_get_sym_tree ("allocated", ns, &ALLOCATED->symtree, false); + gfc_commit_symbol (ALLOCATED->symtree->n.sym); + } + ALLOCATED->symtree->n.sym->attr.flavor = FL_PROCEDURE; + ALLOCATED->symtree->n.sym->attr.intrinsic = 1; + ALLOCATED->symtree->n.sym->result = ALLOCATED->symtree->n.sym; + ALLOCATED->ts.type = BT_LOGICAL; + ALLOCATED->ts.kind = gfc_default_logical_kind; + ALLOCATED->value.function.isym + = gfc_intrinsic_function_by_id (GFC_ISYM_ALLOCATED); + ALLOCATED->value.function.actual = gfc_get_actual_arglist (); + ALLOCATED->value.function.actual->expr = gfc_copy_expr (expr); +#undef ALLOCATED + dealloc->block->next = gfc_get_code (EXEC_DEALLOCATE); + dealloc->block->next->ext.alloc.list = gfc_get_alloc (); + dealloc->block->next->ext.alloc.list->expr = gfc_copy_expr (expr); + return dealloc; +} + + +/* F2018(11.1.5.2): Insert code to deallocate coarrays, allocated within a team + block. This uses the previous function to effect a guarded deallocation of + allocated coarray expressions. These are gathered in gfc_match_allocate and + stashed in team_allocs. */ + +void +deallocate_allocated_coarrays (vec *team_allocs) +{ + gfc_code *dealloc, *last_stmt; + gfc_ref *ref, *aref = NULL; + int i; + + for (gfc_expr *e : *team_allocs) + { + if (!e) + continue; + + /* Get the last array_ref right. */ + for (ref = e->ref; ref; ref = ref->next) + if (ref->type == REF_ARRAY) + aref = ref; + + if (aref->u.ar.as->rank) + { + aref->u.ar.type = AR_FULL; + aref->u.ar.dimen = aref->u.ar.as->rank; + for (i = 0; i < aref->u.ar.dimen; i++) + { + aref->u.ar.dimen_type[i] = DIMEN_RANGE; + + if (aref->u.ar.start[i]) gfc_free_expr (aref->u.ar.start[i]); + if (aref->u.ar.end[i]) gfc_free_expr (aref->u.ar.end[i]); + if (aref->u.ar.stride[i]) gfc_free_expr (aref->u.ar.stride[i]); + aref->u.ar.start[i] = aref->u.ar.end[i] = aref->u.ar.stride[i] = NULL; + } + } + + for (i = aref->u.ar.as->rank; + i < aref->u.ar.as->rank + aref->u.ar.as->corank; i++) + aref->u.ar.dimen_type[i] = DIMEN_THIS_IMAGE; + + /* Insert the deallocation code before the END TEAM statement. */ + last_stmt = gfc_current_ns->code; + while (last_stmt) + { + last_stmt = last_stmt->next; + if (last_stmt->next->op == EXEC_END_TEAM || !last_stmt->next) + { + dealloc = get_guarded_dealloc (gfc_current_ns, e); + if (dealloc) + { + dealloc->next = last_stmt->next; + last_stmt->next = dealloc; + break; + } + } + } + gfc_free_expr (e); + e = NULL; + } +} diff --git a/gcc/testsuite/gfortran.dg/coarray/team_allocated_coarrays.f90 b/gcc/testsuite/gfortran.dg/coarray/team_allocated_coarrays.f90 new file mode 100644 index 00000000000..4ecee7bbff4 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/coarray/team_allocated_coarrays.f90 @@ -0,0 +1,104 @@ +! { dg-do run } +! +! F2018(11.1.5.2): Test auto-deallocation of allocatable coarrays that are +! allocated within a team block. +! +program test_nested_teams + use iso_fortran_env, only: team_type + implicit none + type(team_type) :: team1, team2 + integer, allocatable :: a[:] + integer, allocatable :: b[:] + integer, allocatable :: outer[:] + integer, allocatable :: inner(:)[:] ! Rank and corank + logical :: image1 + integer :: me + + type :: mytype + integer, allocatable :: i[:] + end type + type(mytype) :: dt_a, dt_b, dt_outer, dt_inner + + image1 = this_image () == 1 + me = this_image () + + ! Test 1: Simple allocation in single team block + form team(1, team1) + change team(team1) + allocate(a[*]) + a = 1 + allocate(dt_a%i[*], source = me) + end team + if (image1 .and. allocated(a)) stop 1 + if (image1 .and. allocated(dt_a%i)) stop 2 + + ! Test 2: Multiple allocations in single team block + form team(1, team1) + change team(team1) + allocate(a[*], b[*]) + a = 1 + b = 2 + allocate(dt_a%i[*], dt_b%i[*], source = me) + end team + if (image1 .and. allocated(a)) stop 3 + if (image1 .and. allocated(b)) stop 4 + if (image1 .and. allocated(dt_a%i)) stop 5 + if (image1 .and. allocated(dt_b%i)) stop 6 + + ! Test 3: Nested team blocks - allocation in outer team only + form team(1, team1) + change team(team1) + allocate(outer[*]) + allocate(dt_outer%i[*], source = me) + outer = 10 + + ! Nested team with no allocations + form team(1, team2) + change team(team2) + end team + + ! Make sure that auto-deallocation occurs in right context + if (image1 .and. .not.allocated(outer)) stop 7 + if (image1 .and. .not.allocated(dt_outer%i)) stop 8 + + end team + if (image1 .and. allocated(outer)) stop 9 + if (image1 .and. allocated(dt_outer%i)) stop 10 + + ! Test 4: Nested team blocks - allocation in inner team only + form team(1, team1) + change team(team1) + + form team(1, team2) + change team(team2) + allocate(inner(4)[*]) + inner = 20 + allocate(dt_inner%i[*]) + end team + + if (image1 .and. allocated(inner)) stop 11 + if (image1 .and. allocated(dt_inner%i)) stop 12 + end team + + ! Test 5: Nested team blocks - allocations in both levels + form team(1, team1) + change team(team1) + allocate(outer[*]) + outer = 30 + allocate(dt_outer%i[*], source = me) + + form team(1, team2) + change team(team2) + allocate(inner(2)[*]) + inner = 40 + allocate(dt_inner%i[*], source = me) + end team + + if (image1 .and. allocated(inner)) stop 13 + if (image1 .and. allocated(dt_inner%i)) stop 14 + + end team + if (image1 .and. allocated(outer)) stop 15 + if (image1 .and. allocated(dt_outer%i)) stop 16 + +end program test_nested_teams commit 887a62fd0fd79cea79c5f292764aa79b1b039859 Author: Jakub Jelinek Date: Fri Aug 7 17:33:53 2026 +0200 s390: Fix ICE in usubc5 [PR126667] The following testcase ICEs on s390x-linux I believe since r15-6791 when usubc5 named pattern has been introduced. It intentionally uses general_operand predicate for operands[4], so that it can test it against const0_rtx and handle that differently, but otherwise it uses xor3 insn with operands[4] as first input, which has nonimmediate_operand. So we emit (xor:DI (const1_rtx) (const1_rtx)) and then fail to recognize it. The following patch just forces it into a register in that case, cse or combine can then simplify it. The other option would be to check for CONSTANT_P, force into REG unless it is CONST_INT and if it is CONST_INT, perform the xor at compile time, but then the compare too and unsure what to pass to the subsequent insn. The testcase is simplified from a larger botan real-world testcase (though there isn't usubc with a constant 1 carry in visible in the source). 2026-08-07 Jakub Jelinek PR target/126667 * config/s390/s390.md (usubc5): If operands[4] is an immediate operand other than const0_rtx, force it into reg before using it in xor3 insn. * gcc.dg/pr126667.c: New test. * gcc.target/s390/pr126667.c: New test. Reviewed-by: Andreas Krebbel (cherry picked from commit 8d0676db179aa31207bc4dd29e1c310823988f4b) diff --git a/gcc/config/s390/s390.md b/gcc/config/s390/s390.md index 52e9014e416..0343007d9b1 100644 --- a/gcc/config/s390/s390.md +++ b/gcc/config/s390/s390.md @@ -7329,7 +7329,9 @@ else { rtx tmp = gen_reg_rtx (mode); - emit_insn (gen_xor3 (tmp, operands[4], const1_rtx)); + emit_insn (gen_xor3 (tmp, CONSTANT_P (operands[4]) + ? force_reg (mode, operands[4]) + : operands[4], const1_rtx)); rtx slb_cond = s390_emit_compare (mode, LEU, tmp, const0_rtx); emit_insn (gen_sub3_slb_borrow1_cc (operands[0], operands[2], operands[3], slb_cond)); } diff --git a/gcc/testsuite/gcc.dg/pr126667.c b/gcc/testsuite/gcc.dg/pr126667.c new file mode 100644 index 00000000000..f9e4a2120ad --- /dev/null +++ b/gcc/testsuite/gcc.dg/pr126667.c @@ -0,0 +1,9 @@ +/* PR target/126667 */ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ + +unsigned long +foo (unsigned long x, unsigned long y, unsigned long *p) +{ + return __builtin_subcl (x, y, 1UL, p); +} diff --git a/gcc/testsuite/gcc.target/s390/pr126667.c b/gcc/testsuite/gcc.target/s390/pr126667.c new file mode 100644 index 00000000000..0e6cd1467a2 --- /dev/null +++ b/gcc/testsuite/gcc.target/s390/pr126667.c @@ -0,0 +1,9 @@ +/* PR target/126667 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=z14" } */ + +unsigned long +foo (unsigned long x, unsigned long y, unsigned long *p) +{ + return __builtin_subcl (x, y, 1UL, p); +} commit 8dd8b219eb20519df674b4368260586e71e09be9 Author: GCC Administrator Date: Sat Aug 8 00:22:51 2026 +0000 Daily bump. diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 218a8c65b7b..4a6a61d90e0 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,56 @@ +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-07 Jakub Jelinek + + PR target/126667 + * config/s390/s390.md (usubc5): If operands[4] is + an immediate operand other than const0_rtx, force it into reg + before using it in xor3 insn. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-04 Jakub Jelinek + + PR tree-optimization/126601 + * tree-ssa-math-opts.cc (maybe_optimize_guarding_check): Use safe_push + on mul_stmts rather than quick_push. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-04 Jakub Jelinek + + PR tree-optimization/126564 + * tree-ssa-phiopt.cc (spaceship_replacement): Fix up condition + when to punt because of redundant cmp1 with cmp2, xor in + lhs1 == lhs2 with difference of cmp2 from cmp1 (ignoring + LT_EXPR vs. LE_EXPR and GT_EXPR vs. GE_EXPR differences) and + 1 if cond2_phi_edge is EDGE_FALSE_VALUE. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-04 Jakub Jelinek + + PR tree-optimization/126549 + * range-op-float.cc (operator_cast::fold_range): Don't call + frange_drop_infs. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-03 Jakub Jelinek + + PR target/126484 + * config/mips/mips-ftypes.def (MIPS_SI_FTYPE_VOID, + MIPS_USI_FTYPE_VOID): Use DEF_MIPS_FTYPE with 0 as + first argument rather than 1 and leave out ", VOID" from + second argument. + * config/mips/mips.cc (MIPS_FTYPE_NAME0): Define. + (MIPS_FTYPE_ATYPES0): Define. + 2026-08-07 Release Manager * GCC 16.2.0 released. diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 4d4df8e5573..ac282fe95ef 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260807 +20260808 diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index a4e20508e5d..27dc1111f09 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,43 @@ +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-06 Jakub Jelinek + + PR c++/125541 + * mangle.cc (write_reflection): Mangle empty anonymous union/struct + data members as "da" rather than "dm" and use index of such a data + member instead of name. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-06 Jakub Jelinek + + PR c++/125680 + * mangle.cc (write_reflection): For type aliases use maybe_write_module + and write_source_name instead of write_unqualified_name. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-06 Jakub Jelinek + + PR c++/125601 + * pt.cc (finish_expansion_stmt): If break; was seen in any of the + expansion stmt bodies, wrap all the bodies in an artificial + do ... while (0); stmt. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-06 Jakub Jelinek + + PR c++/125591 + * pt.cc (tsubst_pack_expansion): Don't require + retrieve_local_specialization on structured binding to + always return structured binding, instead handle if it returns + ARGUMENT_PACK_SELECT. + 2026-08-07 Release Manager * GCC 16.2.0 released. diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 28f2102d0a1..7d1f6e14c93 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,22 @@ +2026-08-07 Paul Thomas + + Backported from master: + 2026-07-31 Paul Thomas + + PR fortran/126205 + * gfortran.h: Add prototype for deallocate_allocated_coarrays. + hash_map team_allocated_coarrays, vector team_context_stack and + prototype for get_current_team_context. + * match.cc (gfc_match_allocate): Capture allocate expressions + of allocatable coarrays and stash in team_allocated_coarrays. + * parse.cc (parse_change_team): Push team context. When end is + seen, create the code to deallocate allocated coarrays in this + context, using deallocate_allocated_coarrays. + * st.cc (get_guarded_dealloc): Generate code to produce + IF (ALLOCATED (expr)) DEALLOCATE (expr). + (deallocate_allocated_coarrays): Modify the final array ref of + the allocate expressions and call get_guarded_dealloc. + 2026-08-07 Release Manager * GCC 16.2.0 released. diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index c8897f6d4f6..261a927679d 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,138 @@ +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-07 Jakub Jelinek + + PR target/126667 + * gcc.dg/pr126667.c: New test. + * gcc.target/s390/pr126667.c: New test. + +2026-08-07 Paul Thomas + + Backported from master: + 2026-07-31 Paul Thomas + + PR fortran/126205 + * gfortran.dg/coarray/team_allocated_coarrays.f90: New test. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-06 Jakub Jelinek + + PR c++/125541 + * g++.dg/reflect/mangle1.C: Add further 2 tests. + * g++.dg/reflect/mangle9.C: New test. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-06 Jakub Jelinek + + PR c++/125680 + * g++.dg/reflect/mangle8.C: New test. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-06 Jakub Jelinek + + PR c++/125601 + * g++.dg/cpp26/expansion-stmt45.C: New test. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-06 Jakub Jelinek + + PR c++/125591 + * g++.dg/cpp26/decomp31.C: New test. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-06 Jakub Jelinek + + PR libstdc++/125200 + * g++.dg/plugin/std_module_exports_plugin.cc (plugin_dump_decl): Use + %< and %>. Clarify the error message and add a note. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-06 Jakub Jelinek + + PR preprocessor/125048 + * c-c++-common/cpp/va-opt-11.c: New test. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-04 Jakub Jelinek + + PR tree-optimization/126464 + * gcc.dg/pr126464.c: Guard uses of 1e300 with + __DBL_MAX_10_EXP__ >= 301 and uses of 1e4000L with + __LDBL_MAX_10_EXP__ >= 4001. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-04 Jakub Jelinek + + PR target/124948 + * gcc.dg/torture/bitint-100.c: Require also sync_int_long effective + target. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-04 Jakub Jelinek + + PR tree-optimization/126601 + * gcc.dg/tree-ssa/pr126601.c: New test. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-04 Jakub Jelinek + + PR tree-optimization/126564 + * gcc.dg/torture/pr126564.c: New test. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-04 Jakub Jelinek + + PR tree-optimization/126549 + * gcc.dg/torture/pr126549.c: New test. + * gcc.dg/torture/bitint-107.c: New test. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-03 Jakub Jelinek + + PR tree-optimization/126547 + * gcc.dg/torture/pr126547.c: New test. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-03 Jakub Jelinek + + PR tree-optimization/126576 + * gcc.dg/torture/pr126576.c: New test. + +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-03 Jakub Jelinek + + PR target/126484 + * g++.target/mips/pr126484.C: New test. + 2026-08-07 Release Manager * GCC 16.2.0 released. diff --git a/libcpp/ChangeLog b/libcpp/ChangeLog index 7d1a22193c2..89936bf6e27 100644 --- a/libcpp/ChangeLog +++ b/libcpp/ChangeLog @@ -1,3 +1,14 @@ +2026-08-07 Jakub Jelinek + + Backported from master: + 2026-08-06 Jakub Jelinek + + PR preprocessor/125048 + * macro.cc (replace_args): Remember the position of map + in the pfile->line_table->info_macro.maps array and if vostate + is DROP, recompute map pointer as expand_arg call could have + reallocated the pfile->line_table->info_macro.maps array. + 2026-08-07 Release Manager * GCC 16.2.0 released. commit 7f2626bd531984a2f964d70438cb2b09891b8ae1 Author: Paul Thomas Date: Sat May 23 14:58:36 2026 +0100 Fortran: Fix scalar class to derived select type entities. [PR125263] 2026-05-23 Paul Thomas gcc/fortran PR fortran/125263 * trans-expr.cc (gfc_trans_assignment_1): Pass scalar class to derived type assignment expressions to gfc_trans_scalar_assign. gcc/testsuite/ PR fortran/125263 * gfortran.dg/pr125263.f90: New test. (cherry picked from commit 6e1679ebd5e62dd63ee6c93df2514e0c08a2b674) diff --git a/gcc/fortran/trans-expr.cc b/gcc/fortran/trans-expr.cc index 0dbf0e4be9f..b8c50114396 100644 --- a/gcc/fortran/trans-expr.cc +++ b/gcc/fortran/trans-expr.cc @@ -13305,13 +13305,19 @@ gfc_trans_assignment_1 (gfc_expr * expr1, gfc_expr * expr2, bool init_flag, && !CLASS_DATA (expr2)->attr.class_pointer && !CLASS_DATA (expr2)->attr.allocatable); + /* What can be sent to trans_class_assignment includes all the obvious + candidates but scalar assignment of a class expression to a derived type + must be done using gfc_trans_scalar_assign; partly because it is simpler + and partly because some cases fail, eg. class assignment to derived_type + select type temporaries. */ is_poly_assign = (use_vptr_copy || ((lhs_attr.pointer || lhs_attr.allocatable) && !lhs_attr.dimension)) && (expr1->ts.type == BT_CLASS || gfc_is_class_array_ref (expr1, NULL) || gfc_is_class_scalar_expr (expr1) || gfc_is_class_array_ref (expr2, NULL) - || gfc_is_class_scalar_expr (expr2)) + || (gfc_is_class_scalar_expr (expr2) + && !(expr1->ts.type == BT_DERIVED && !lhs_attr.dimension))) && lhs_attr.flavor != FL_PROCEDURE; assoc_assign = is_assoc_assign (expr1, expr2); diff --git a/gcc/testsuite/gfortran.dg/pr125263.f90 b/gcc/testsuite/gfortran.dg/pr125263.f90 new file mode 100644 index 00000000000..9d8d4d08987 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/pr125263.f90 @@ -0,0 +1,71 @@ +! { dg-do run } +! +! Test the fix for pr125263, in which the selector expressions were not +! correctly set after the first two ASSOCIATE constructs below. +! +! Conributed by Bastiaan Braams +! +program Main + implicit none (type, external) + type :: Foo_Type + integer, allocatable :: x(:) + end type Foo_Type + class (Foo_Type), allocatable :: fv(:), f, g + integer :: nx = 2, nf = 3, i + + ! Create fv(:) with all component vectors initialized to 0. + allocate (Foo_Type::fv(0:nf-1)) + do i = 0, nf-1 + allocate (fv(i)%x(0:nx-1)) + fv(i)%x(:) = 0 + end do + + ! Create f with f%x(:) equal to 1 and g with g%x(:) equal to 2. + allocate (Foo_Type::f, g) + allocate (f%x(0:nx-1),g%x(0:nx-1)) + f%x(:) = 1 + g%x(:) = 2 + + ! Use intrinsic assignment to copy f to fv(0). + associate (ft => fv(0)) + select type (ft => fv(0)) + type is (Foo_Type) + ft = f + ft%x = [2,3,4] + class default + error stop 'select type (ft): type error' + end select + end associate + + ! Verify the copy on the element x(0) and that f is not overwritten. + if (any (fv(0)%x /= [2,3,4])) stop 1 + if (any (f%x /= [1,1])) stop 2 + + ! All scalar selector-exprs have the same problem, not just array elements. + f%x(:) = 1 + associate (ft => g) + select type (ft) + type is (Foo_Type) + ft = f + ft%x = [4,5,6] + class default + error stop 'select type (ft): type error' + end select + end associate + ! Verify the copy on g and that f is not overwritten. + if (any (g%x /= [4,5,6])) stop 3 + if (any (f%x /= [1,1])) stop 4 + + ! Assignment to an element of an array associate name was OK. + fv(0)%x(:) = [0,0,0] + select type (ft => fv) + type is (Foo_Type) + ft = f + ft(0)%x = [2,3,4] + class default + error stop 'select type (ft): type error' + end select + if (any (fv(0)%x /= [2,3,4])) stop 5 + if (any (f%x /= [1,1])) stop 6 + +end program Main commit 643129fbd5a2bd227fa798ee066098cd5fe99290 Author: GCC Administrator Date: Sun Aug 9 00:20:46 2026 +0000 Daily bump. diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index ac282fe95ef..8cb42c2ba5a 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260808 +20260809 diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index 7d1f6e14c93..3503f486c84 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,12 @@ +2026-08-08 Paul Thomas + + Backported from master: + 2026-05-23 Paul Thomas + + PR fortran/125263 + * trans-expr.cc (gfc_trans_assignment_1): Pass scalar class to + derived type assignment expressions to gfc_trans_scalar_assign. + 2026-08-07 Paul Thomas Backported from master: diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index 261a927679d..fe8ea028d1d 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,11 @@ +2026-08-08 Paul Thomas + + Backported from master: + 2026-05-23 Paul Thomas + + PR fortran/125263 + * gfortran.dg/pr125263.f90: New test. + 2026-08-07 Jakub Jelinek Backported from master: commit 1d4809920d33e4dad1ee218e051a5ec8c0f24702 Author: GCC Administrator Date: Mon Aug 10 00:20:41 2026 +0000 Daily bump. diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 8cb42c2ba5a..6c93e5aba5c 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20260809 +20260810 commit 01c7083b70a6bbf620d2cb2ce887baf501fe2f1f Author: H.J. Lu Date: Sat Aug 1 06:07:43 2026 +0800 x86: Check DECL_INCOMING_RTL for argument passing check For argument declaration, its DECL_INCOMING_RTL holds an RTL for the stack slot or register where the data was actually passed. If an argument's DECL_INCOMING_RTL is a memory operand, it is passed on stack by caller. Change ix86_argument_passed_on_stack_p to return true if the argument's DECL_INCOMING_RTL is a memory operand. gcc/ PR target/126320 PR target/126450 PR target/126529 * config/i386/i386.cc (ix86_spill_register_argument_p): Removed. (ix86_argument_passed_on_stack_p): Remove the second argument. Return true if the argument's DECL_INCOMING_RTL is a memory operand. (ix86_update_stack_alignment): Updated. gcc/testsuite/ PR target/126320 PR target/126450 PR target/126529 * gcc.target/i386/pr126529-1.c: New test. * gcc.target/i386/pr126529-2.c: Likewise. * gcc.target/i386/pr126529-3.c: Likewise. * gcc.target/i386/pr126529-4.c: Likewise. Signed-off-by: H.J. Lu (cherry picked from commit b06b1ea150558cfe83111b48b94b4297cb3dec05) diff --git a/gcc/config/i386/i386.cc b/gcc/config/i386/i386.cc index 4dfb90acf3f..bf2a3bdfbea 100644 --- a/gcc/config/i386/i386.cc +++ b/gcc/config/i386/i386.cc @@ -8625,42 +8625,10 @@ struct stack_access_data unsigned int *stack_alignment; }; -/* SET stores into OP, a MEM linked to parameter BASE. Return true if - SET stores BASE's argument register into OP. This is a spill: the - callee saves its own register argument to the stack. It is not a - stack argument set up by the caller: - - (set (mem/c:V2DI (plus:DI (reg/f:DI 7 sp) - (const_int -16 [0xfffffffffffffff0])) [4 a1+0 S16 A128]) - (reg:V2DI 20 xmm0 [ a1 ])) - */ - -static bool -ix86_spill_register_argument_p (const_rtx set, const_rtx op, tree base) -{ - rtx src = SET_SRC (set); - - /* Not a hard register store, so not a spill. */ - if (!REG_P (src) || !HARD_REGISTER_P (src)) - return false; - - rtx dest = SET_DEST (set); - tree reg_expr = REG_EXPR (src); - - /* If spilling an SSA_NAME into OP, the argument-linked memory is - also used to store a local variable. */ - return dest == op && (reg_expr == base - || (reg_expr - && TREE_CODE (reg_expr) == SSA_NAME)); -} - -/* Return true if OP, found in PAT, is a stack argument set up by the - caller. Return false if OP is a register argument that the callee - spilled to its own stack frame. Both cases share the same MEM_EXPR, - so we must check PAT to tell them apart. */ +/* Return true if OP is a stack argument set up by the caller. */ static bool -ix86_argument_passed_on_stack_p (const_rtx op, const_rtx pat) +ix86_argument_passed_on_stack_p (const_rtx op) { tree mem_expr = MEM_EXPR (op); if (!mem_expr) @@ -8670,12 +8638,10 @@ ix86_argument_passed_on_stack_p (const_rtx op, const_rtx pat) if (TREE_CODE (var) != PARM_DECL) return false; - /* PAT is always a single SET here: note_stores splits PARALLEL - patterns into separate SETs before calling this function. */ - if (GET_CODE (pat) == SET) - return !ix86_spill_register_argument_p (pat, op, var); - - return true; + /* For PARM_DECL, DECL_INCOMING_RTL holds an RTL for the stack slot + or register where the data was actually passed. Return true if + OP is passed in memory. */ + return DECL_INCOMING_RTL (var) && MEM_P (DECL_INCOMING_RTL (var)); } /* Update the maximum stack slot alignment from memory alignment in PAT. */ @@ -8697,7 +8663,7 @@ ix86_update_stack_alignment (rtx, const_rtx pat, void *data) responsible to align the outgoing stack for arguments passed on stack. */ if (reg_mentioned_p (p->reg, XEXP (op, 0)) - && !ix86_argument_passed_on_stack_p (op, pat)) + && !ix86_argument_passed_on_stack_p (op)) { unsigned int alignment = MEM_ALIGN (op); diff --git a/gcc/testsuite/gcc.target/i386/pr126529-1.c b/gcc/testsuite/gcc.target/i386/pr126529-1.c new file mode 100644 index 00000000000..aa53283e5e3 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr126529-1.c @@ -0,0 +1,39 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -march=x86-64" } */ + +typedef signed char A[[gnu::vector_size (2)]]; +typedef short B[[gnu::vector_size (16)]]; +int a, b, c, d; +B e; +[[gnu::vector_size(8 * sizeof (int))]] int f; +_Bool g; + +__attribute__((noipa, noinline, target("avx2"))) +void * +foo (long long x, _Bool y, int z, B w) +{ + A h = {}; + short i = h[z]; + f = 0 % f; + w = e; + d = w[g]; + h = ((union { short s; A t; }) { i }).t; + b = 3 / x; + h = __builtin_shufflevector (h, h, 3, 2); +lab: + c = h[0]; + if (y) + return 0; + y = 1; + h = ~h; + goto lab; +} + +int +main (void) +{ + if (__builtin_cpu_supports ("avx2")) + foo (3355934481768670720LL, 0, a, e); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/i386/pr126529-2.c b/gcc/testsuite/gcc.target/i386/pr126529-2.c new file mode 100644 index 00000000000..d37c0bf5997 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr126529-2.c @@ -0,0 +1,40 @@ +/* { dg-do run } */ +/* { dg-options "-O2 -march=x86-64" } */ + +typedef signed char A[[gnu::vector_size (2)]]; +typedef short B[[gnu::vector_size (16)]]; +int a, b, c, d; +B e; +[[gnu::vector_size(8 * sizeof (int))]] int f; +_Bool g; + +__attribute__((noipa, noinline, target("avx2"))) +void * +foo (float f1, float f2, float f3, float f4, float f5, float f6, float f7, + float f8, long long x, _Bool y, int z, B w) +{ + A h = {}; + short i = h[z]; + f = 0 % f; + w = e; + d = w[g]; + h = ((union { short s; A t; }) { i }).t; + b = 3 / x; + h = __builtin_shufflevector (h, h, 3, 2); +lab: + c = h[0]; + if (y) + return 0; + y = 1; + h = ~h; + goto lab; +} + +int +main (void) +{ + if (__builtin_cpu_supports ("avx2")) + foo (1, 2, 3, 4, 5, 6, 7, 8, 3355934481768670720LL, 0, a, e); + + return 0; +} diff --git a/gcc/testsuite/gcc.target/i386/pr126529-3.c b/gcc/testsuite/gcc.target/i386/pr126529-3.c new file mode 100644 index 00000000000..740b21b1b28 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr126529-3.c @@ -0,0 +1,32 @@ +/* { dg-do compile { target *-*-linux* } } */ +/* { dg-options "-O2 -march=x86-64-v3" } */ +/* { dg-final { scan-assembler "and\[lq\]?\[\\t \]+\\$-32,\[\\t \]*%\[re\]?sp" } } */ +/* { dg-final { scan-assembler "vmovdqa\[\\t \]+%ymm" } } */ + +typedef signed char A[[gnu::vector_size (2)]]; +typedef short B[[gnu::vector_size (32)]]; +int a, b, c, d; +B e; +[[gnu::vector_size(8 * sizeof (int))]] int f; +_Bool g; + +[[gnu::noipa]] void * +foo (float f1, float f2, float f3, float f4, float f5, float f6, float f7, + long long x, _Bool y, int z, B w) +{ + A h = {}; + short i = h[z]; + f = 0 % f; + w = e; + d = w[g]; + h = ((union { short s; A t; }) { i }).t; + b = 3 / x; + h = __builtin_shufflevector (h, h, 3, 2); +lab: + c = h[0]; + if (y) + return 0; + y = 1; + h = ~h; + goto lab; +} diff --git a/gcc/testsuite/gcc.target/i386/pr126529-4.c b/gcc/testsuite/gcc.target/i386/pr126529-4.c new file mode 100644 index 00000000000..2c08d56ca23 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr126529-4.c @@ -0,0 +1,33 @@ +/* { dg-do compile { target *-*-linux* } } */ +/* { dg-options "-O2 -march=x86-64-v3" } */ +/* { dg-final { scan-assembler "and\[lq\]?\[\\t \]+\\$-32,\[\\t \]*%\[re\]?sp" { target ia32 } } } */ +/* { dg-final { scan-assembler-not "and\[lq\]?\[\\t \]+\\$-32,\[\\t \]*%\[re\]?sp" { target { ! ia32 } } } } */ +/* { dg-final { scan-assembler "vmovdqa\[\\t \]+%ymm" } } */ + +typedef signed char A[[gnu::vector_size (2)]]; +typedef short B[[gnu::vector_size (32)]]; +int a, b, c, d; +B e; +[[gnu::vector_size(8 * sizeof (int))]] int f; +_Bool g; + +[[gnu::noipa]] void * +foo (float f1, float f2, float f3, float f4, float f5, float f6, float f7, + float f8, long long x, _Bool y, int z, B w) +{ + A h = {}; + short i = h[z]; + f = 0 % f; + w = e; + d = w[g]; + h = ((union { short s; A t; }) { i }).t; + b = 3 / x; + h = __builtin_shufflevector (h, h, 3, 2); +lab: + c = h[0]; + if (y) + return 0; + y = 1; + h = ~h; + goto lab; +} commit d564253eb6c859e266d3cae18e82fb4db9a88316 Author: Torbjörn SVENSSON Date: Sun Jul 26 23:25:50 2026 +0200 c++: ICE on on systems without mmap support [PR124806] On systems without mmap support, cc1plus can crash when finishing module output after earlier errors prevented elf_out::begin from running. In that case elf_out::end attempts to fill in the ELF header even though hdr.buffer was never initialized. gcc/cp/ChangeLog: PR c++/124806 * module.cc (elf_out::began): New data member. (elf_out::begin): Set it after successful initialization. (elf_out::end): Do not finalize output that never began. Signed-off-by: Torbjörn SVENSSON (cherry picked from commit 94556938452d2bde01f5954207294906bbb53d8f) diff --git a/gcc/cp/module.cc b/gcc/cp/module.cc index dcd8e772416..83d3929415c 100644 --- a/gcc/cp/module.cc +++ b/gcc/cp/module.cc @@ -1506,6 +1506,7 @@ class elf_out : public elf, public data::allocator { private: ptr_int_hash_map identtab; /* Map of IDENTIFIERS to strtab offsets. */ unsigned pos; /* Write position in file. */ + bool began; /* True if begin initialized output state. */ #if MAPPED_WRITING unsigned offset; /* Offset of the mapping. */ unsigned extent; /* Length of mapping. */ @@ -1514,7 +1515,7 @@ private: public: elf_out (int fd, int e) - :parent (fd, e), identtab (500), pos (0) + :parent (fd, e), identtab (500), pos (0), began (false) { #if MAPPED_WRITING offset = extent = 0; @@ -2226,7 +2227,10 @@ elf_out::begin () memset (h, 0, sizeof (header)); hdr.pos = hdr.size; write (hdr); - return !get_error (); + if (get_error ()) + return false; + began = true; + return true; } /* Finish writing the file. Write out the string & section tables. @@ -2235,7 +2239,7 @@ elf_out::begin () bool elf_out::end () { - if (fd >= 0) + if (fd >= 0 && began) { /* Write the string table. */ unsigned strnam = name (".strtab"); commit 243d2c691bc17a7b42d67969b0ce510749940559 Author: Joseph Myers Date: Mon Aug 10 19:43:33 2026 +0000 Update gcc .po files * be.po, da.po, de.po, el.po, es.po, fi.po, fr.po, hr.po, id.po, ja.po, ka.po, nl.po, ru.po, sr.po, sv.po, tr.po, uk.po, vi.po, zh_CN.po, zh_TW.po: Update. diff --git a/gcc/po/be.po b/gcc/po/be.po index 377b2d4b98d..b9e44e43157 100644 --- a/gcc/po/be.po +++ b/gcc/po/be.po @@ -6,7 +6,7 @@ msgid "" msgstr "" "Project-Id-Version: gcc 3.1\n" "Report-Msgid-Bugs-To: https://gcc.gnu.org/bugs/\n" -"POT-Creation-Date: 2026-04-22 17:18+0000\n" +"POT-Creation-Date: 2026-07-31 13:40+0000\n" "PO-Revision-Date: 2002-05-17 15:54+0200\n" "Last-Translator: Ales Nyakhaychyk \n" "Language-Team: Belarusian \n" @@ -290,7 +290,7 @@ msgstr "" msgid "may not use both -EB and -EL" msgstr "" -#: config/avr/specs.h:70 config/pru/pru.h:58 +#: config/avr/specs.h:71 config/pru/pru.h:58 #, fuzzy #| msgid "-pipe is not supported" msgid "shared is not supported" @@ -374,7 +374,7 @@ msgstr "" msgid "consider using `-pg' instead of `-p' with gprof(1)" msgstr "" -#: config/rs6000/rs6000.h:164 +#: config/rs6000/rs6000.h:165 msgid "Missing -mcpu option in ASM_CPU_SPEC?" msgstr "" @@ -891,14 +891,14 @@ msgstr "" #: config/arc/arc.opt:311 config/arc/arc.opt:315 config/arc/arc.opt:320 #: config/arc/arc.opt:329 config/arc/arc.opt:409 config/pa/pa.opt:46 #: config/pa/pa.opt:78 config/xtensa/xtensa.opt:42 fortran/lang.opt:879 -#: common.opt:658 common.opt:1236 common.opt:1240 common.opt:1244 -#: common.opt:1339 common.opt:1716 common.opt:1798 common.opt:1901 -#: common.opt:2173 common.opt:2320 common.opt:2378 common.opt:2852 -#: common.opt:2888 common.opt:2982 common.opt:2986 common.opt:3096 -#: common.opt:3231 common.opt:3239 common.opt:3247 common.opt:3255 -#: common.opt:3360 common.opt:3380 common.opt:3420 common.opt:3516 -#: common.opt:3696 common.opt:3700 common.opt:3704 common.opt:3708 -#: common.opt:3782 common.opt:3786 common.opt:3817 common.opt:3821 +#: common.opt:657 common.opt:1235 common.opt:1239 common.opt:1243 +#: common.opt:1338 common.opt:1715 common.opt:1797 common.opt:1900 +#: common.opt:2172 common.opt:2319 common.opt:2377 common.opt:2851 +#: common.opt:2887 common.opt:2981 common.opt:2985 common.opt:3095 +#: common.opt:3230 common.opt:3238 common.opt:3246 common.opt:3254 +#: common.opt:3359 common.opt:3379 common.opt:3419 common.opt:3515 +#: common.opt:3695 common.opt:3699 common.opt:3703 common.opt:3707 +#: common.opt:3781 common.opt:3785 common.opt:3816 common.opt:3820 #: c-family/c.opt:1877 c-family/c.opt:1980 c-family/c.opt:1988 #: c-family/c.opt:2319 #, no-c-format @@ -2159,91 +2159,97 @@ msgstr "" msgid "Use the given offset for addressing the stack-protector guard." msgstr "" -#: config/rs6000/rs6000.opt:600 +#: config/rs6000/rs6000.opt:604 +#, fuzzy, no-c-format +#| msgid "Do not generate char instructions" +msgid "Generate (do not generate) DMF (Dense Math Facility) instructions." +msgstr "Не генерыраваць сімвальныя інструкцыі" + +#: config/rs6000/rs6000.opt:608 #, fuzzy, no-c-format #| msgid "Do not generate char instructions" msgid "Generate (do not generate) prefixed memory instructions." msgstr "Не генерыраваць сімвальныя інструкцыі" -#: config/rs6000/rs6000.opt:604 +#: config/rs6000/rs6000.opt:612 #, no-c-format msgid "Generate (do not generate) pc-relative memory addressing." msgstr "" -#: config/rs6000/rs6000.opt:608 +#: config/rs6000/rs6000.opt:616 #, no-c-format msgid "Generate (do not generate) pc-relative memory optimizations for externals." msgstr "" -#: config/rs6000/rs6000.opt:612 +#: config/rs6000/rs6000.opt:620 #, fuzzy, no-c-format #| msgid "Do not generate char instructions" msgid "Generate (do not generate) MMA instructions." msgstr "Не генерыраваць сімвальныя інструкцыі" -#: config/rs6000/rs6000.opt:619 +#: config/rs6000/rs6000.opt:627 #, no-c-format msgid "Enable instructions that guard against return-oriented programming attacks." msgstr "" -#: config/rs6000/rs6000.opt:623 +#: config/rs6000/rs6000.opt:631 #, no-c-format msgid "Generate code that will run in privileged state." msgstr "" -#: config/rs6000/rs6000.opt:627 +#: config/rs6000/rs6000.opt:635 #, fuzzy, no-c-format #| msgid "Do not generate char instructions" msgid "Generate (do not generate) code that uses the XXSPLTIW instruction." msgstr "Не генерыраваць сімвальныя інструкцыі" -#: config/rs6000/rs6000.opt:631 +#: config/rs6000/rs6000.opt:639 #, no-c-format msgid "Generate (do not generate) code that uses the XXSPLTIDP instruction." msgstr "" -#: config/rs6000/rs6000.opt:635 +#: config/rs6000/rs6000.opt:643 #, fuzzy, no-c-format #| msgid "Do not generate char instructions" msgid "Generate (do not generate) code that uses the LXVKQ instruction." msgstr "Не генерыраваць сімвальныя інструкцыі" -#: config/rs6000/rs6000.opt:641 +#: config/rs6000/rs6000.opt:649 #, no-c-format msgid "Used to limit unroll factor which indicates how much the autovectorizer may unroll a loop. The default value is 4." msgstr "" -#: config/rs6000/rs6000.opt:647 +#: config/rs6000/rs6000.opt:655 #, no-c-format msgid "When costing for loop vectorization, we probably need to penalize the loop body cost if the existing cost model may not adequately reflect delays from unavailable vector resources. We collect the cost for vectorized statements and non-vectorized statements separately, check the proportion of vec_cost to total cost of vec_cost and non vec_cost, and penalize only if the proportion exceeds the threshold specified by this parameter. The default value is 85." msgstr "" -#: config/rs6000/rs6000.opt:656 +#: config/rs6000/rs6000.opt:664 #, no-c-format msgid "Like parameter rs6000-density-pct-threshold, we also check the total sum of vec_cost and non vec_cost, and penalize only if the sum exceeds the threshold specified by this parameter. The default value is 70." msgstr "" -#: config/rs6000/rs6000.opt:662 +#: config/rs6000/rs6000.opt:670 #, no-c-format msgid "When both heuristics with rs6000-density-pct-threshold and rs6000-density-size-threshold are satisfied, we decide to penalize the loop body cost by the value which is specified by this parameter. The default value is 10." msgstr "" -#: config/rs6000/rs6000.opt:669 +#: config/rs6000/rs6000.opt:677 #, no-c-format msgid "When costing for loop vectorization, we probably need to penalize the loop body cost by accounting for excess strided or elementwise loads. We collect the numbers for general statements and load statements according to the information for statements to be vectorized, check the proportion of load statements, and penalize only if the proportion exceeds the threshold specified by this parameter. The default value is 45." msgstr "" -#: config/rs6000/rs6000.opt:678 +#: config/rs6000/rs6000.opt:686 #, no-c-format msgid "Like parameter rs6000-density-load-pct-threshold, we also check if the total number of load statements exceeds the threshold specified by this parameter, and penalize only if it's satisfied. The default value is 20." msgstr "" -#: config/rs6000/rs6000.opt:684 config/loongarch/loongarch.opt:334 +#: config/rs6000/rs6000.opt:692 config/loongarch/loongarch.opt:334 #, no-c-format msgid "Indicate how many non memory access vector instructions can be issued per cycle, it's used in unroll factor determination for autovectorizer. The default value is 4." msgstr "" -#: config/rs6000/rs6000.opt:690 +#: config/rs6000/rs6000.opt:698 #, no-c-format msgid "When reduction factor computed for a loop exceeds the threshold specified by this parameter, prefer to unroll this loop. The default value is 1." msgstr "" @@ -3115,10 +3121,10 @@ msgid "Use fp registers." msgstr "Выкарыстоўваць 64-бітныя FP-рэгістры" #: config/alpha/alpha.opt:31 fortran/lang.opt:214 fortran/lang.opt:551 -#: analyzer/analyzer.opt:295 analyzer/analyzer.opt:359 common.opt:700 -#: common.opt:858 common.opt:1134 common.opt:1138 common.opt:1142 -#: common.opt:1146 common.opt:1938 common.opt:2043 common.opt:2225 -#: common.opt:2229 common.opt:2548 common.opt:2774 common.opt:3555 +#: analyzer/analyzer.opt:295 analyzer/analyzer.opt:359 common.opt:699 +#: common.opt:857 common.opt:1133 common.opt:1137 common.opt:1141 +#: common.opt:1145 common.opt:1937 common.opt:2042 common.opt:2224 +#: common.opt:2228 common.opt:2547 common.opt:2773 common.opt:3554 #: c-family/c.opt:1517 c-family/c.opt:1738 #, no-c-format msgid "Does nothing. Preserved for backward compatibility." @@ -11972,8 +11978,8 @@ msgid "Display target specific command line options (including assembler and lin msgstr "" #: common.opt:463 common.opt:505 common.opt:509 common.opt:513 common.opt:517 -#: common.opt:521 common.opt:525 common.opt:529 common.opt:946 common.opt:3864 -#: common.opt:3962 common.opt:4076 +#: common.opt:521 common.opt:525 common.opt:529 common.opt:945 common.opt:3863 +#: common.opt:3961 common.opt:4075 #, no-c-format msgid "Passed to the linker." msgstr "" @@ -12039,2917 +12045,2917 @@ msgstr "" msgid "Warn about problems with auto-profile data." msgstr "" -#: common.opt:565 common.opt:569 +#: common.opt:568 #, no-c-format msgid "Warn for uses of pointers to deallocated storage." msgstr "" -#: common.opt:573 +#: common.opt:572 #, no-c-format msgid "Warn about inappropriate attribute usage." msgstr "" -#: common.opt:577 +#: common.opt:576 #, fuzzy, no-c-format #| msgid "wrong number of arguments specified for `%s' attribute" msgid "Do not warn about specified attributes." msgstr "памылковая колькасьць аргументаў, зададзеных для атрыбута `%s'" -#: common.opt:581 common.opt:585 +#: common.opt:580 common.opt:584 #, no-c-format msgid "Warn about type safety and similar errors and mismatches in declarations with alias attributes." msgstr "" -#: common.opt:589 +#: common.opt:588 #, no-c-format msgid "Warn when profiling instrumentation was requested, but could not be applied to a certain function." msgstr "" -#: common.opt:594 common.opt:598 +#: common.opt:593 common.opt:597 #, no-c-format msgid "Warn about pointer casts which increase alignment." msgstr "" -#: common.opt:602 +#: common.opt:601 #, no-c-format msgid "Complain when a command-line option is valid, but not applicable to the current front end." msgstr "" -#: common.opt:606 +#: common.opt:605 #, no-c-format msgid "Warn when a #warning directive is encountered." msgstr "" -#: common.opt:610 +#: common.opt:609 #, no-c-format msgid "Warn about uses of __attribute__((warning)) declarations." msgstr "" -#: common.opt:614 +#: common.opt:613 #, no-c-format msgid "Warn if a deprecated compiler feature, class, method, or field is used." msgstr "" -#: common.opt:618 +#: common.opt:617 #, no-c-format msgid "Warn about uses of __attribute__((deprecated)) declarations." msgstr "" -#: common.opt:622 +#: common.opt:621 #, no-c-format msgid "Warn when an optimization pass is disabled." msgstr "" -#: common.opt:626 +#: common.opt:625 #, no-c-format msgid "Turn all warnings into errors." msgstr "" -#: common.opt:630 +#: common.opt:629 #, no-c-format msgid "Turn the specified warning into an error." msgstr "" -#: common.opt:634 +#: common.opt:633 #, no-c-format msgid "Print extra (possibly unwanted) warnings." msgstr "" -#: common.opt:638 +#: common.opt:637 #, no-c-format msgid "Exit on the first error occurred." msgstr "" -#: common.opt:642 +#: common.opt:641 #, no-c-format msgid "-Wframe-larger-than=\tWarn if a function's stack frame requires in excess of ." msgstr "" -#: common.opt:646 +#: common.opt:645 #, no-c-format msgid "Disable -Wframe-larger-than= warning. Equivalent to -Wframe-larger-than= or larger." msgstr "" -#: common.opt:650 +#: common.opt:649 #, no-c-format msgid "Warn when attempting to free a non-heap object." msgstr "" -#: common.opt:654 +#: common.opt:653 #, no-c-format msgid "Warn when -fhardened did not enable an option from its set." msgstr "" -#: common.opt:665 +#: common.opt:664 #, no-c-format msgid "Warn when a switch case falls through." msgstr "" -#: common.opt:669 rust/lang.opt:59 c-family/c.opt:919 +#: common.opt:668 rust/lang.opt:59 c-family/c.opt:919 #, no-c-format msgid "Warn for infinitely recursive calls." msgstr "" -#: common.opt:673 +#: common.opt:672 #, fuzzy, no-c-format #| msgid "virtual functions cannot be friends" msgid "Warn when an inlined function cannot be inlined." msgstr "віртуальныя функцыі не могуць быць сяброўскімі" -#: common.opt:677 +#: common.opt:676 #, no-c-format msgid "Warn when an atomic memory model parameter is known to be outside the valid range." msgstr "" -#: common.opt:684 +#: common.opt:683 #, no-c-format msgid "-Wlarger-than=\tWarn if an object's size exceeds ." msgstr "" -#: common.opt:688 +#: common.opt:687 #, no-c-format msgid "Disable -Wlarger-than= warning. Equivalent to -Wlarger-than= or larger." msgstr "" -#: common.opt:692 +#: common.opt:691 #, no-c-format msgid "Warn if comparing pointer parameter with nonnull attribute with NULL." msgstr "" -#: common.opt:696 +#: common.opt:695 #, no-c-format msgid "Warn if dereferencing a NULL pointer may lead to erroneous or undefined behavior." msgstr "" -#: common.opt:707 +#: common.opt:706 #, no-c-format msgid "Warn about passing a pointer/reference to a local or temporary variable to a musttail call argument." msgstr "" -#: common.opt:711 +#: common.opt:710 #, no-c-format msgid "Warn about pointer/reference to a local or temporary variable possibly escaping to a musttail call." msgstr "" -#: common.opt:715 +#: common.opt:714 #, no-c-format msgid "Warn about some C++ One Definition Rule violations during link time optimization." msgstr "" -#: common.opt:719 +#: common.opt:718 #, no-c-format msgid "Warn about overflow in arithmetic expressions." msgstr "" -#: common.opt:723 +#: common.opt:722 #, no-c-format msgid "During link time optimization warn about mismatched types of global declarations." msgstr "" -#: common.opt:727 +#: common.opt:726 #, no-c-format msgid "Warn when the packed attribute has no effect on struct layout." msgstr "" -#: common.opt:731 +#: common.opt:730 #, no-c-format msgid "Warn when padding is required to align structure members." msgstr "" -#: common.opt:735 +#: common.opt:734 #, no-c-format msgid "Issue warnings needed for strict compliance to the standard." msgstr "" -#: common.opt:739 +#: common.opt:738 #, no-c-format msgid "Warn about returning a pointer/reference to a local or temporary variable." msgstr "" -#: common.opt:743 +#: common.opt:742 #, no-c-format msgid "Warn when one variable shadows another. Same as -Wshadow=global." msgstr "" -#: common.opt:747 +#: common.opt:746 #, no-c-format msgid "Warn when one variable shadows another (globally)." msgstr "" -#: common.opt:751 +#: common.opt:750 #, no-c-format msgid "Warn when one local variable shadows another local variable or parameter." msgstr "" -#: common.opt:758 +#: common.opt:757 #, no-c-format msgid "Warn when one local variable shadows another local variable or parameter of compatible type." msgstr "" -#: common.opt:765 +#: common.opt:764 #, no-c-format msgid "Warn when not issuing stack smashing protection for some reason." msgstr "" -#: common.opt:769 +#: common.opt:768 #, no-c-format msgid "-Wstack-usage=\tWarn if stack usage might exceed ." msgstr "" -#: common.opt:773 +#: common.opt:772 #, no-c-format msgid "Disable Wstack-usage= warning. Equivalent to Wstack-usage= or larger." msgstr "" -#: common.opt:777 common.opt:781 +#: common.opt:776 common.opt:780 #, no-c-format msgid "Warn about code which might break strict aliasing rules." msgstr "" -#: common.opt:785 common.opt:789 +#: common.opt:784 common.opt:788 #, no-c-format msgid "Warn about optimizations that assume that signed overflow is undefined." msgstr "" -#: common.opt:793 +#: common.opt:792 #, no-c-format msgid "Warn about functions which might be candidates for __attribute__((cold))." msgstr "" -#: common.opt:797 +#: common.opt:796 #, no-c-format msgid "Warn about functions which might be candidates for __attribute__((const))." msgstr "" -#: common.opt:801 +#: common.opt:800 #, no-c-format msgid "Warn about functions which might be candidates for __attribute__((pure))." msgstr "" -#: common.opt:805 +#: common.opt:804 #, no-c-format msgid "Warn about functions which might be candidates for __attribute__((noreturn))." msgstr "" -#: common.opt:809 +#: common.opt:808 #, no-c-format msgid "Warn about functions which might be candidates for __attribute__((malloc))." msgstr "" -#: common.opt:813 +#: common.opt:812 #, no-c-format msgid "Warn about functions which might be candidates for __attribute__((returns_nonnull))." msgstr "" -#: common.opt:817 +#: common.opt:816 #, no-c-format msgid "Warn about C++ polymorphic types where adding final keyword would improve code quality." msgstr "" -#: common.opt:821 +#: common.opt:820 #, no-c-format msgid "Warn about C++ virtual methods where adding final keyword would improve code quality." msgstr "" -#: common.opt:825 +#: common.opt:824 #, no-c-format msgid "Warn about statements between switch's controlling expression and the first case." msgstr "" -#: common.opt:830 +#: common.opt:829 #, no-c-format msgid "Do not suppress warnings from system headers." msgstr "" -#: common.opt:834 +#: common.opt:833 #, no-c-format msgid "Warn if a comparison always evaluates to true or false." msgstr "" -#: common.opt:838 +#: common.opt:837 #, no-c-format msgid "Warn whenever a trampoline is generated." msgstr "" -#: common.opt:842 +#: common.opt:841 #, no-c-format msgid "Warn about cases where -ftrivial-auto-var-init cannot initialize an auto variable." msgstr "" -#: common.opt:846 +#: common.opt:845 #, no-c-format msgid "Warn if a comparison is always true or always false due to the limited range of the data type." msgstr "" -#: common.opt:850 +#: common.opt:849 #, no-c-format msgid "Warn about uninitialized automatic variables." msgstr "" -#: common.opt:854 +#: common.opt:853 #, no-c-format msgid "Warn about maybe uninitialized automatic variables." msgstr "" -#: common.opt:862 +#: common.opt:861 #, no-c-format msgid "Enable all -Wunused- warnings." msgstr "" -#: common.opt:869 +#: common.opt:868 #, no-c-format msgid "Warn when a function parameter is only set, otherwise unused." msgstr "" -#: common.opt:876 +#: common.opt:875 #, no-c-format msgid "Warn when a variable is only set, otherwise unused." msgstr "" -#: common.opt:880 +#: common.opt:879 #, no-c-format msgid "Warn when a function is unused." msgstr "" -#: common.opt:884 +#: common.opt:883 #, no-c-format msgid "Warn when a label is unused." msgstr "" -#: common.opt:888 +#: common.opt:887 #, no-c-format msgid "Warn when a function parameter is unused." msgstr "" -#: common.opt:892 +#: common.opt:891 #, no-c-format msgid "Warn when an expression value is unused." msgstr "" -#: common.opt:896 +#: common.opt:895 #, no-c-format msgid "Warn when a variable is unused." msgstr "" -#: common.opt:900 +#: common.opt:899 #, no-c-format msgid "Warn in case profiles in -fprofile-use do not match." msgstr "" -#: common.opt:904 +#: common.opt:903 #, no-c-format msgid "Warn in case a function ends earlier than it begins due to an invalid linenum macros." msgstr "" -#: common.opt:908 +#: common.opt:907 #, no-c-format msgid "Warn when a conditional has too many terms and condition coverage profiling gives up instrumenting the expression." msgstr "" -#: common.opt:913 +#: common.opt:912 #, no-c-format msgid "-fpath-coverage-limit= Don't instrument functions path count exceeding ." msgstr "" -#: common.opt:918 +#: common.opt:917 #, no-c-format msgid "Warn if a function exceeds the number of paths (controlled by -fpath-coverage-limit) and path coverage give up instrumenting the function. The limit is approximate and conservative and coverage might give up even if the actual number is slightly below the limit." msgstr "" -#: common.opt:925 +#: common.opt:924 #, no-c-format msgid "Warn in case profiles in -fprofile-use do not exist." msgstr "" -#: common.opt:929 +#: common.opt:928 #, no-c-format msgid "Warn when a vector operation is compiled outside the SIMD." msgstr "" -#: common.opt:933 +#: common.opt:932 #, no-c-format msgid "Warn about unsupported features in ThreadSanitizer." msgstr "" -#: common.opt:950 +#: common.opt:949 #, no-c-format msgid "-aux-info \tEmit declaration information into ." msgstr "" -#: common.opt:963 +#: common.opt:962 #, no-c-format msgid "-d\tEnable dumps from specific passes of the compiler." msgstr "" -#: common.opt:967 +#: common.opt:966 #, no-c-format msgid "-dumpbase \tSet the file basename to be used for dumps." msgstr "" -#: common.opt:971 +#: common.opt:970 #, no-c-format msgid "-dumpbase-ext . Drop a trailing . from the dump basename to name auxiliary output files." msgstr "" -#: common.opt:975 +#: common.opt:974 #, no-c-format msgid "-dumpdir \tSet the directory name to be used for dumps." msgstr "" -#: common.opt:1090 +#: common.opt:1089 #, no-c-format msgid "The version of the C++ ABI in use." msgstr "" -#: common.opt:1094 +#: common.opt:1093 #, no-c-format msgid "Aggressively optimize loops using language constraints." msgstr "" -#: common.opt:1098 +#: common.opt:1097 #, fuzzy, no-c-format msgid "Align the start of functions." msgstr "вельмі шмат аргументаў у функцыі" -#: common.opt:1105 +#: common.opt:1104 #, no-c-format msgid "Align labels which are only reached by jumping." msgstr "" -#: common.opt:1112 +#: common.opt:1111 #, no-c-format msgid "Align all labels." msgstr "" -#: common.opt:1119 +#: common.opt:1118 #, no-c-format msgid "Align the start of loops." msgstr "" -#: common.opt:1126 +#: common.opt:1125 #, no-c-format msgid "Allow the compiler to introduce new data races on stores." msgstr "" -#: common.opt:1130 +#: common.opt:1129 #, no-c-format msgid "Enable static analysis pass." msgstr "" -#: common.opt:1150 +#: common.opt:1149 #, no-c-format msgid "Select what to sanitize." msgstr "" -#: common.opt:1154 +#: common.opt:1153 #, no-c-format msgid "Select type of coverage sanitization." msgstr "" -#: common.opt:1167 +#: common.opt:1166 #, no-c-format msgid "-fasan-shadow-offset=\tUse custom shadow memory offset." msgstr "" -#: common.opt:1171 +#: common.opt:1170 #, no-c-format msgid "-fsanitize-sections=\tSanitize global variables in user-defined sections." msgstr "" -#: common.opt:1176 +#: common.opt:1175 #, no-c-format msgid "After diagnosing undefined behavior attempt to continue execution." msgstr "" -#: common.opt:1180 +#: common.opt:1179 #, no-c-format msgid "This switch is deprecated; use -fsanitize-recover= instead." msgstr "" -#: common.opt:1184 +#: common.opt:1183 #, no-c-format msgid "Use traps instead of diagnostics of undefined behavior sanitizers." msgstr "" -#: common.opt:1194 +#: common.opt:1193 #, no-c-format msgid "This switch is deprecated; use -fsanitize-trap= instead." msgstr "" -#: common.opt:1198 +#: common.opt:1197 #, no-c-format msgid "Generate unwind tables that are exact at each instruction boundary." msgstr "" -#: common.opt:1202 +#: common.opt:1201 #, fuzzy, no-c-format #| msgid "Do not generate char instructions" msgid "Generate auto-inc/dec instructions." msgstr "Не генерыраваць сімвальныя інструкцыі" -#: common.opt:1206 +#: common.opt:1205 #, no-c-format msgid "Use sample profile information for call graph node weights. The default profile file is fbdata.afdo in 'pwd'." msgstr "" -#: common.opt:1211 +#: common.opt:1210 #, no-c-format msgid "Use sample profile information for call graph node weights. The profile file is specified in the argument." msgstr "" -#: common.opt:1216 +#: common.opt:1215 #, no-c-format msgid "Perform inlining using auto-profile." msgstr "" -#: common.opt:1224 +#: common.opt:1223 #, no-c-format msgid "Generate code to check bounds before indexing arrays." msgstr "" -#: common.opt:1228 +#: common.opt:1227 #, no-c-format msgid "Replace add, compare, branch with branch on count register." msgstr "" -#: common.opt:1232 +#: common.opt:1231 #, no-c-format msgid "Use profiling information for branch probabilities." msgstr "" -#: common.opt:1248 +#: common.opt:1247 #, no-c-format msgid "Output callgraph information on a per-file basis." msgstr "" -#: common.opt:1252 +#: common.opt:1251 #, no-c-format msgid "Output callgraph information on a per-file basis with decorations." msgstr "" -#: common.opt:1256 +#: common.opt:1255 #, no-c-format msgid "-fcall-saved-\tMark as being preserved across functions." msgstr "" -#: common.opt:1260 +#: common.opt:1259 #, no-c-format msgid "-fcall-used-\tMark as being corrupted by function calls." msgstr "" -#: common.opt:1267 +#: common.opt:1266 #, no-c-format msgid "Save registers around function calls." msgstr "" -#: common.opt:1271 +#: common.opt:1270 #, no-c-format msgid "This switch is deprecated; do not use." msgstr "" -#: common.opt:1275 +#: common.opt:1274 #, no-c-format msgid "Check the return value of new in C++." msgstr "" -#: common.opt:1279 common.opt:1283 +#: common.opt:1278 common.opt:1282 #, no-c-format msgid "Perform internal consistency checkings." msgstr "" -#: common.opt:1287 +#: common.opt:1286 #, no-c-format msgid "For -f*-prefix-map= options compare canonicalized pathnames rather than just strings." msgstr "" -#: common.opt:1291 +#: common.opt:1290 #, fuzzy, no-c-format #| msgid "Enable exception handling" msgid "Enable code hoisting." msgstr "Уключыць апрацоўку выключэньняў" -#: common.opt:1295 +#: common.opt:1294 #, no-c-format msgid "Looks for opportunities to reduce stack adjustments and stack references." msgstr "" -#: common.opt:1299 +#: common.opt:1298 #, no-c-format msgid "Put uninitialized globals in the common section." msgstr "" -#: common.opt:1307 +#: common.opt:1306 #, no-c-format msgid "-fcompare-debug[=]\tCompile with and without e.g. -gtoggle, and compare the final-insns dump." msgstr "" -#: common.opt:1311 +#: common.opt:1310 #, no-c-format msgid "Run only the second compilation of -fcompare-debug." msgstr "" -#: common.opt:1315 +#: common.opt:1314 #, no-c-format msgid "Perform comparison elimination after register allocation has finished." msgstr "" -#: common.opt:1319 +#: common.opt:1318 #, no-c-format msgid "Do not perform optimizations increasing noticeably stack usage." msgstr "" -#: common.opt:1323 +#: common.opt:1322 #, no-c-format msgid "Perform a register copy-propagation optimization pass." msgstr "" -#: common.opt:1327 +#: common.opt:1326 #, no-c-format msgid "Fold instructions calculating memory offsets to the memory access instruction if possible." msgstr "" -#: common.opt:1331 +#: common.opt:1330 #, no-c-format msgid "Perform cross-jumping optimization." msgstr "" -#: common.opt:1335 +#: common.opt:1334 #, no-c-format msgid "When running CSE, follow jumps to their targets." msgstr "" -#: common.opt:1361 +#: common.opt:1360 #, no-c-format msgid "Omit range reduction step when performing complex division." msgstr "" -#: common.opt:1365 +#: common.opt:1364 #, no-c-format msgid "Complex multiplication and division follow Fortran rules." msgstr "" -#: common.opt:1369 +#: common.opt:1368 #, no-c-format msgid "Place data items into their own section." msgstr "" -#: common.opt:1373 +#: common.opt:1372 #, no-c-format msgid "List all available debugging counters with their limits and counts." msgstr "" -#: common.opt:1377 +#: common.opt:1376 #, no-c-format msgid "-fdbg-cnt=[:-][:-:...][,:...]\tSet the debug counter limit." msgstr "" -#: common.opt:1381 +#: common.opt:1380 #, no-c-format msgid "-fdebug-prefix-map==\tMap one directory name to another in debug information." msgstr "" -#: common.opt:1385 +#: common.opt:1384 #, no-c-format msgid "-ffile-prefix-map==\tMap one directory name to another in compilation result." msgstr "" -#: common.opt:1389 +#: common.opt:1388 #, no-c-format msgid "Output .debug_types section when using DWARF v4 debuginfo." msgstr "" -#: common.opt:1395 +#: common.opt:1394 #, no-c-format msgid "Defer popping functions args from stack until later." msgstr "" -#: common.opt:1399 +#: common.opt:1398 #, no-c-format msgid "Attempt to fill delay slots of branch instructions." msgstr "" -#: common.opt:1403 +#: common.opt:1402 #, no-c-format msgid "Delete dead instructions that may throw exceptions." msgstr "" -#: common.opt:1407 +#: common.opt:1406 #, no-c-format msgid "Delete useless null pointer checks." msgstr "" -#: common.opt:1411 +#: common.opt:1410 #, no-c-format msgid "Issue defining instructions back to back with their single uses, provided they are macro-fusible in the target microarchitecture." msgstr "" -#: common.opt:1415 +#: common.opt:1414 #, no-c-format msgid "Stream extra data to support more aggressive devirtualization in LTO local transformation mode." msgstr "" -#: common.opt:1419 +#: common.opt:1418 #, no-c-format msgid "Perform speculative devirtualization." msgstr "" -#: common.opt:1423 +#: common.opt:1422 #, no-c-format msgid "Try to convert virtual calls to direct ones." msgstr "" -#: common.opt:1427 +#: common.opt:1426 #, no-c-format msgid "-fdiagnostics-show-location=[once|every-line]\tHow often to emit source location at the beginning of line-wrapped diagnostics." msgstr "" -#: common.opt:1444 +#: common.opt:1443 #, no-c-format msgid "Show the source line with a caret indicating the column." msgstr "" -#: common.opt:1448 +#: common.opt:1447 #, no-c-format msgid "Show lines linking related events in diagnostic paths." msgstr "" -#: common.opt:1452 +#: common.opt:1451 #, no-c-format msgid "Show labels annotating ranges of source code when showing source." msgstr "" -#: common.opt:1456 +#: common.opt:1455 #, no-c-format msgid "Show line numbers in the left margin when showing source." msgstr "" -#: common.opt:1464 +#: common.opt:1463 #, no-c-format msgid "-fdiagnostics-color=[never|always|auto]\tColorize diagnostics." msgstr "" -#: common.opt:1484 +#: common.opt:1483 #, no-c-format msgid "Enable formatting of JSON output." msgstr "" -#: common.opt:1488 +#: common.opt:1487 #, no-c-format msgid "-fdiagnostics-urls=[never|always|auto]\tEmbed URLs in diagnostics." msgstr "" -#: common.opt:1508 +#: common.opt:1507 #, no-c-format msgid "-fdiagnostics-column-unit=[display|byte]\tSelect whether column numbers are output as display columns (default) or raw bytes." msgstr "" -#: common.opt:1512 +#: common.opt:1511 #, no-c-format msgid "-fdiagnostics-column-origin=\tSet the number of the first column. The default is 1-based as per GNU style, but some utilities may expect 0-based, for example." msgstr "" -#: common.opt:1516 +#: common.opt:1515 #, no-c-format msgid "-fdiagnostics-format=[text|sarif-stderr|sarif-file]\tSelect output format." msgstr "" -#: common.opt:1520 +#: common.opt:1519 #, no-c-format msgid "Add output format." msgstr "" -#: common.opt:1524 +#: common.opt:1523 #, no-c-format msgid "Set output format." msgstr "" -#: common.opt:1528 +#: common.opt:1527 #, no-c-format msgid "-fdiagnostics-escape-format=[unicode|bytes]\tSelect how to escape non-printable-ASCII bytes in the source for diagnostics that suggest it." msgstr "" -#: common.opt:1566 +#: common.opt:1565 #, no-c-format msgid "Print fix-it hints in machine-readable form." msgstr "" -#: common.opt:1570 +#: common.opt:1569 #, no-c-format msgid "Print fix-it hints to stderr in unified diff format." msgstr "" -#: common.opt:1574 +#: common.opt:1573 #, no-c-format msgid "Amend appropriate diagnostic messages with the command line option that controls them." msgstr "" -#: common.opt:1578 +#: common.opt:1577 #, no-c-format msgid "Print CWE identifiers for diagnostic messages, where available." msgstr "" -#: common.opt:1582 +#: common.opt:1581 #, no-c-format msgid "Print any rules associated with diagnostic messages." msgstr "" -#: common.opt:1586 +#: common.opt:1585 #, no-c-format msgid "Use color within diagnostic messages to highlight pertinent information." msgstr "" -#: common.opt:1590 +#: common.opt:1589 #, no-c-format msgid "Specify how to print any control-flow path associated with a diagnostic." msgstr "" -#: common.opt:1594 +#: common.opt:1593 #, no-c-format msgid "Turn off any diagnostics features that complicate the output, such as line numbers, color, and warning URLs." msgstr "" -#: common.opt:1598 +#: common.opt:1597 #, no-c-format msgid "-ftabstop= Distance between tab stops for column reporting." msgstr "" -#: common.opt:1614 +#: common.opt:1613 #, no-c-format msgid "Show stack depths of events in paths." msgstr "" -#: common.opt:1618 +#: common.opt:1617 #, no-c-format msgid "-fdiagnostics-text-art-charset=[none|ascii|unicode|emoji]\tDetermine which characters to use in text arg diagrams." msgstr "" -#: common.opt:1637 +#: common.opt:1636 #, no-c-format msgid "Set minimum width of left margin of source code when showing source." msgstr "" -#: common.opt:1641 +#: common.opt:1640 #, no-c-format msgid "Use indentation to show nesting of diagnostics in text output." msgstr "" -#: common.opt:1645 +#: common.opt:1644 #, no-c-format msgid "Show location information when showing nested diagnostics." msgstr "" -#: common.opt:1649 +#: common.opt:1648 #, no-c-format msgid "Show nesting levels as numbers when showing nested diagnostics." msgstr "" -#: common.opt:1656 +#: common.opt:1655 #, no-c-format msgid "Collect and print more context information for diagnostics." msgstr "" -#: common.opt:1660 +#: common.opt:1659 #, no-c-format msgid "-fdisable-[tree|rtl|ipa]-=range1+range2\tDisable an optimization pass." msgstr "" -#: common.opt:1664 +#: common.opt:1663 #, no-c-format msgid "-fenable-[tree|rtl|ipa]-=range1+range2\tEnable an optimization pass." msgstr "" -#: common.opt:1668 +#: common.opt:1667 #, no-c-format msgid "-fdump-\tDump various compiler internals to a file." msgstr "" -#: common.opt:1675 +#: common.opt:1674 #, no-c-format msgid "-fdump-final-insns=filename\tDump to filename the insns at the end of translation." msgstr "" -#: common.opt:1679 +#: common.opt:1678 #, no-c-format msgid "-fdump-go-spec=filename\tWrite all declarations to file as Go code." msgstr "" -#: common.opt:1683 +#: common.opt:1682 #, no-c-format msgid "Suppress output of addresses in debugging dumps." msgstr "" -#: common.opt:1687 +#: common.opt:1686 #, no-c-format msgid "Collect and dump debug information into temporary file if ICE in C/C++ compiler occurred." msgstr "" -#: common.opt:1692 +#: common.opt:1691 #, no-c-format msgid "Dump detailed information on GCC's internal representation of source code locations." msgstr "" -#: common.opt:1696 +#: common.opt:1695 #, no-c-format msgid "Dump optimization passes." msgstr "" -#: common.opt:1700 +#: common.opt:1699 #, no-c-format msgid "Suppress output of instruction numbers, line number notes and addresses in debugging dumps." msgstr "" -#: common.opt:1704 +#: common.opt:1703 #, no-c-format msgid "Suppress output of previous and next insn numbers in debugging dumps." msgstr "" -#: common.opt:1708 +#: common.opt:1707 #, no-c-format msgid "Enable CFI tables via GAS assembler directives." msgstr "" -#: common.opt:1712 +#: common.opt:1711 #, no-c-format msgid "Perform early inlining." msgstr "" -#: common.opt:1720 +#: common.opt:1719 #, no-c-format msgid "Perform interprocedural reduction of aggregates." msgstr "" -#: common.opt:1724 +#: common.opt:1723 #, no-c-format msgid "Perform unused symbol elimination in debug info." msgstr "" -#: common.opt:1728 +#: common.opt:1727 #, no-c-format msgid "Perform unused type elimination in debug info." msgstr "" -#: common.opt:1732 +#: common.opt:1731 #, no-c-format msgid "Do not suppress C++ class debug information." msgstr "" -#: common.opt:1736 +#: common.opt:1735 #, fuzzy, no-c-format #| msgid "Enable exception handling" msgid "Enable exception handling." msgstr "Уключыць апрацоўку выключэньняў" -#: common.opt:1740 +#: common.opt:1739 #, no-c-format msgid "Perform a number of minor, expensive optimizations." msgstr "" -#: common.opt:1744 +#: common.opt:1743 #, no-c-format msgid "-fexcess-precision=[fast|standard|16]\tSpecify handling of excess floating-point precision." msgstr "" -#: common.opt:1762 +#: common.opt:1761 #, no-c-format msgid "-fpermitted-flt-eval-methods=[c11|ts-18661]\tSpecify which values of FLT_EVAL_METHOD are permitted." msgstr "" -#: common.opt:1778 +#: common.opt:1777 #, no-c-format msgid "Output lto objects containing both the intermediate language and binary output." msgstr "" -#: common.opt:1782 +#: common.opt:1781 #, no-c-format msgid "Assume no NaNs or infinities are generated." msgstr "" -#: common.opt:1786 +#: common.opt:1785 #, no-c-format msgid "Assume that loops with an exit will terminate and not loop indefinitely." msgstr "" -#: common.opt:1790 +#: common.opt:1789 #, no-c-format msgid "-ffixed-\tMark as being unavailable to the compiler." msgstr "" -#: common.opt:1794 +#: common.opt:1793 #, no-c-format msgid "Don't allocate floats and doubles in extended-precision registers." msgstr "" -#: common.opt:1802 +#: common.opt:1801 #, no-c-format msgid "Perform a forward propagation pass on RTL." msgstr "" -#: common.opt:1806 +#: common.opt:1805 #, no-c-format msgid "-ffp-contract=[off|on|fast]\tPerform floating-point expression contraction." msgstr "" -#: common.opt:1822 +#: common.opt:1821 #, no-c-format msgid "Allow built-in functions ceil, floor, round, trunc to raise \"inexact\" exceptions." msgstr "" -#: common.opt:1829 +#: common.opt:1828 #, no-c-format msgid "Allow function addresses to be held in registers." msgstr "" -#: common.opt:1833 +#: common.opt:1832 #, fuzzy, no-c-format #| msgid "for each function it appears in.)" msgid "Place each function into its own section." msgstr "адзін раз для кожнай функцыі, дзе ён з'яўляецца.)" -#: common.opt:1837 +#: common.opt:1836 #, no-c-format msgid "Allow limited optimization of operations with volatile memory access." msgstr "" -#: common.opt:1841 +#: common.opt:1840 #, no-c-format msgid "Perform global common subexpression elimination." msgstr "" -#: common.opt:1845 +#: common.opt:1844 #, no-c-format msgid "Perform enhanced load motion during global common subexpression elimination." msgstr "" -#: common.opt:1849 +#: common.opt:1848 #, no-c-format msgid "Perform store motion after global common subexpression elimination." msgstr "" -#: common.opt:1853 +#: common.opt:1852 #, no-c-format msgid "Try to avoid store forwarding." msgstr "" -#: common.opt:1857 +#: common.opt:1856 #, no-c-format msgid "Perform redundant load after store elimination in global common subexpression elimination." msgstr "" -#: common.opt:1862 +#: common.opt:1861 #, no-c-format msgid "Perform global common subexpression elimination after register allocation has finished." msgstr "" -#: common.opt:1879 +#: common.opt:1878 #, no-c-format msgid "-fgnat-encodings=[all|gdb|minimal]\tSelect the balance between GNAT encodings and standard DWARF emitted in the debug information." msgstr "" -#: common.opt:1884 +#: common.opt:1883 #, no-c-format msgid "Enable in and out of Graphite representation." msgstr "" -#: common.opt:1888 +#: common.opt:1887 #, no-c-format msgid "Enable Graphite Identity transformation." msgstr "" -#: common.opt:1892 +#: common.opt:1891 #, no-c-format msgid "Enable hoisting adjacent loads to encourage generating conditional move instructions." msgstr "" -#: common.opt:1905 +#: common.opt:1904 #, no-c-format msgid "Run two instruction combination passes late in the pass pipeline; one before register allocation and one after." msgstr "" -#: common.opt:1910 +#: common.opt:1909 #, no-c-format msgid "Mark all loops as parallel." msgstr "" -#: common.opt:1914 common.opt:1922 common.opt:3320 +#: common.opt:1913 common.opt:1921 common.opt:3319 #, no-c-format msgid "Enable loop nest transforms. Same as -floop-nest-optimize." msgstr "" -#: common.opt:1918 +#: common.opt:1917 #, no-c-format msgid "Enable loop interchange on trees." msgstr "" -#: common.opt:1926 +#: common.opt:1925 #, no-c-format msgid "Perform unroll-and-jam on loops." msgstr "" -#: common.opt:1930 +#: common.opt:1929 #, no-c-format msgid "Enable support for GNU transactional memory." msgstr "" -#: common.opt:1934 +#: common.opt:1933 #, no-c-format msgid "Use STB_GNU_UNIQUE if supported by the assembler." msgstr "" -#: common.opt:1942 +#: common.opt:1941 #, no-c-format msgid "Enable the loop nest optimizer." msgstr "" -#: common.opt:1946 +#: common.opt:1945 #, no-c-format msgid "Turn indirect calls of pointers loaded from structures to speculative calls if there is one known candidate." msgstr "" -#: common.opt:1950 +#: common.opt:1949 #, no-c-format msgid "Force bitfield accesses to match their type width." msgstr "" -#: common.opt:1954 +#: common.opt:1953 #, no-c-format msgid "Merge adjacent stores." msgstr "" -#: common.opt:1958 +#: common.opt:1957 #, no-c-format msgid "Enable guessing of branch probabilities." msgstr "" -#: common.opt:1962 +#: common.opt:1961 #, no-c-format msgid "Enable various security-relevant flags." msgstr "" -#: common.opt:1966 +#: common.opt:1965 #, no-c-format msgid "Harden conditionals not used in branches, checking reversed conditions." msgstr "" -#: common.opt:1970 +#: common.opt:1969 #, no-c-format msgid "Harden conditional branches by checking reversed conditions." msgstr "" -#: common.opt:1974 +#: common.opt:1973 #, no-c-format msgid "Harden control flow by recording and checking execution paths." msgstr "" -#: common.opt:1978 +#: common.opt:1977 #, fuzzy, no-c-format #| msgid "`%D' is not a function," msgid "Disable CFR in leaf functions." msgstr "`%D' - гэта ня функцыя," -#: common.opt:1982 +#: common.opt:1981 #, no-c-format msgid "Check CFR execution paths also before calls followed by returns of their results." msgstr "" -#: common.opt:1986 +#: common.opt:1985 #, no-c-format msgid "Check CFR execution paths also when exiting a function through an exception." msgstr "" -#: common.opt:1990 +#: common.opt:1989 #, no-c-format msgid "-fhardcfr-check-noreturn-calls=[always|no-xthrow|nothrow|never]\tCheck CFR execution paths also before calling noreturn functions." msgstr "" -#: common.opt:2011 +#: common.opt:2010 #, fuzzy, no-c-format #| msgid "Use given assembler dialect" msgid "Emit .ident assembler directives." msgstr "Выкарыстоўвываць зададзены дыялект асэмблера" -#: common.opt:2015 +#: common.opt:2014 #, no-c-format msgid "Perform conversion of conditional jumps to branchless equivalents." msgstr "" -#: common.opt:2019 +#: common.opt:2018 #, no-c-format msgid "Perform conversion of conditional jumps to conditional execution." msgstr "" -#: common.opt:2023 +#: common.opt:2022 #, no-c-format msgid "-fstack-reuse=[all|named_vars|none]\tSet stack reuse level for local variables." msgstr "" -#: common.opt:2039 +#: common.opt:2038 #, no-c-format msgid "Convert conditional jumps in innermost loops to branchless equivalents." msgstr "" -#: common.opt:2051 +#: common.opt:2050 #, fuzzy, no-c-format #| msgid "Do not generate char instructions" msgid "Do not generate .size directives." msgstr "Не генерыраваць сімвальныя інструкцыі" -#: common.opt:2055 +#: common.opt:2054 #, no-c-format msgid "Perform indirect inlining." msgstr "" -#: common.opt:2061 +#: common.opt:2060 #, no-c-format msgid "Enable inlining of function declared \"inline\", disabling disables all inlining." msgstr "" -#: common.opt:2065 +#: common.opt:2064 #, no-c-format msgid "Integrate functions into their callers when code size is known not to grow." msgstr "" -#: common.opt:2069 +#: common.opt:2068 #, no-c-format msgid "Integrate functions not declared \"inline\" into their callers when profitable." msgstr "" -#: common.opt:2073 +#: common.opt:2072 #, no-c-format msgid "Integrate functions only required by their single caller." msgstr "" -#: common.opt:2080 +#: common.opt:2079 #, no-c-format msgid "-finline-limit=\tLimit the size of inlined functions to ." msgstr "" -#: common.opt:2084 +#: common.opt:2083 #, no-c-format msgid "Inline __atomic operations when a lock free instruction sequence is available." msgstr "" -#: common.opt:2094 +#: common.opt:2093 #, no-c-format msgid "-finline-stringops[=memcmp|memcpy|memmove|memset] Expand supported mem/str operations inline, even if against optimization." msgstr "" -#: common.opt:2122 +#: common.opt:2121 #, no-c-format msgid "Equivalent to -fcf-protection=full." msgstr "" -#: common.opt:2126 +#: common.opt:2125 #, no-c-format msgid "-fcf-protection=[full|branch|return|none|check]\tInstrument functions with checks to verify jump/call/return control-flow transfer instructions have valid targets." msgstr "" -#: common.opt:2149 +#: common.opt:2148 #, no-c-format msgid "Instrument function entry and exit with profiling calls." msgstr "" -#: common.opt:2153 +#: common.opt:2152 #, no-c-format msgid "Instrument function entry and exit with profiling calls invoked once." msgstr "" -#: common.opt:2157 +#: common.opt:2156 #, no-c-format msgid "-finstrument-functions-exclude-function-list=name,...\tDo not instrument listed functions." msgstr "" -#: common.opt:2161 +#: common.opt:2160 #, no-c-format msgid "-finstrument-functions-exclude-file-list=filename,...\tDo not instrument functions listed in files." msgstr "" -#: common.opt:2165 +#: common.opt:2164 #, no-c-format msgid "Perform interprocedural constant propagation." msgstr "" -#: common.opt:2169 +#: common.opt:2168 #, no-c-format msgid "Perform cloning to make Interprocedural constant propagation stronger." msgstr "" -#: common.opt:2177 +#: common.opt:2176 #, no-c-format msgid "Perform interprocedural bitwise constant propagation." msgstr "" -#: common.opt:2181 +#: common.opt:2180 #, no-c-format msgid "Perform interprocedural modref analysis." msgstr "" -#: common.opt:2185 +#: common.opt:2184 #, no-c-format msgid "Perform reordering and cloning of functions to maximize locality." msgstr "" -#: common.opt:2189 +#: common.opt:2188 #, no-c-format msgid "Perform interprocedural profile propagation." msgstr "" -#: common.opt:2193 +#: common.opt:2192 #, no-c-format msgid "Perform interprocedural points-to analysis." msgstr "" -#: common.opt:2197 +#: common.opt:2196 #, no-c-format msgid "Discover pure and const functions." msgstr "" -#: common.opt:2201 +#: common.opt:2200 #, no-c-format msgid "Perform Identical Code Folding for functions and read-only variables." msgstr "" -#: common.opt:2205 +#: common.opt:2204 #, no-c-format msgid "Perform Identical Code Folding for functions." msgstr "" -#: common.opt:2209 +#: common.opt:2208 #, no-c-format msgid "Perform Identical Code Folding for variables." msgstr "" -#: common.opt:2213 +#: common.opt:2212 #, no-c-format msgid "Discover read-only and non addressable static variables." msgstr "" -#: common.opt:2217 +#: common.opt:2216 #, no-c-format msgid "Discover read-only, write-only and non-addressable static variables." msgstr "" -#: common.opt:2221 +#: common.opt:2220 #, no-c-format msgid "Reduce stack alignment on call sites if possible." msgstr "" -#: common.opt:2233 +#: common.opt:2232 #, no-c-format msgid "Perform IPA Value Range Propagation." msgstr "" -#: common.opt:2237 +#: common.opt:2236 #, no-c-format msgid "-fira-algorithm=[CB|priority]\tSet the used IRA algorithm." msgstr "" -#: common.opt:2241 +#: common.opt:2240 #, no-c-format msgid "Assume strict aliasing rules apply across (uninlined) function boundaries." msgstr "" -#: common.opt:2254 +#: common.opt:2253 #, no-c-format msgid "-fira-region=[one|all|mixed]\tSet regions for IRA." msgstr "" -#: common.opt:2270 +#: common.opt:2269 #, no-c-format msgid "Use IRA based register pressure calculation in RTL hoist optimizations." msgstr "" -#: common.opt:2275 +#: common.opt:2274 #, no-c-format msgid "Use IRA based register pressure calculation in RTL loop optimizations." msgstr "" -#: common.opt:2280 +#: common.opt:2279 #, no-c-format msgid "Share slots for saving different hard registers." msgstr "" -#: common.opt:2284 +#: common.opt:2283 #, no-c-format msgid "Share stack slots for spilled pseudo-registers." msgstr "" -#: common.opt:2288 +#: common.opt:2287 #, no-c-format msgid "-fira-verbose=\tControl IRA's level of diagnostic messages." msgstr "" -#: common.opt:2292 +#: common.opt:2291 #, no-c-format msgid "Optimize induction variables on trees." msgstr "" -#: common.opt:2296 +#: common.opt:2295 #, no-c-format msgid "Use jump tables for sufficiently large switch statements." msgstr "" -#: common.opt:2300 +#: common.opt:2299 #, no-c-format msgid "Use bit tests for sufficiently large switch statements." msgstr "" -#: common.opt:2304 +#: common.opt:2303 #, no-c-format msgid "Generate code for functions even if they are fully inlined." msgstr "" -#: common.opt:2308 +#: common.opt:2307 #, no-c-format msgid "Generate code for static functions even if they are never called." msgstr "" -#: common.opt:2312 +#: common.opt:2311 #, no-c-format msgid "Emit static const variables even if they are not used." msgstr "" -#: common.opt:2316 +#: common.opt:2315 #, no-c-format msgid "Give external symbols a leading underscore." msgstr "" -#: common.opt:2324 +#: common.opt:2323 #, no-c-format msgid "Do CFG-sensitive rematerialization in LRA." msgstr "" -#: common.opt:2328 +#: common.opt:2327 #, fuzzy, no-c-format #| msgid "Enable SSA optimizations" msgid "Enable link-time optimization." msgstr "Уключаць SSA аптымізацыю" -#: common.opt:2332 +#: common.opt:2331 #, no-c-format msgid "Link-time optimization with number of parallel jobs or jobserver." msgstr "" -#: common.opt:2336 +#: common.opt:2335 #, no-c-format msgid "Enable incremental LTO, with its cache in given directory." msgstr "" -#: common.opt:2340 +#: common.opt:2339 #, no-c-format msgid "Number of cache entries in incremental LTO after which to prune old entries." msgstr "" -#: common.opt:2365 +#: common.opt:2364 #, no-c-format msgid "Specify the algorithm to partition symbols and vars at linktime." msgstr "" -#: common.opt:2369 +#: common.opt:2368 #, no-c-format msgid "Enable heuristics to recognize symbol identifiers in toplevel (not extended) assembly and prevent their mangling/deletion." msgstr "" -#: common.opt:2374 +#: common.opt:2373 #, no-c-format msgid "Use zlib/zstd compression level for IL." msgstr "" -#: common.opt:2382 +#: common.opt:2381 #, no-c-format msgid "Report various link-time optimization statistics." msgstr "" -#: common.opt:2386 +#: common.opt:2385 #, no-c-format msgid "Report various link-time optimization statistics for WPA only." msgstr "" -#: common.opt:2390 +#: common.opt:2389 #, fuzzy, no-c-format msgid "Set errno after built-in math functions." msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" -#: common.opt:2394 +#: common.opt:2393 #, no-c-format msgid "-fmax-errors=\tMaximum number of errors to report." msgstr "" -#: common.opt:2398 +#: common.opt:2397 #, no-c-format msgid "Allow removal of malloc and free pairs when allocated block is unused." msgstr "" -#: common.opt:2405 +#: common.opt:2404 #, no-c-format msgid "Report on permanent memory allocation." msgstr "" -#: common.opt:2409 +#: common.opt:2408 #, no-c-format msgid "Report on permanent memory allocation in WPA only." msgstr "" -#: common.opt:2416 +#: common.opt:2415 #, no-c-format msgid "Attempt to merge identical constants and constant variables." msgstr "" -#: common.opt:2420 +#: common.opt:2419 #, no-c-format msgid "Attempt to merge identical constants across compilation units." msgstr "" -#: common.opt:2424 +#: common.opt:2423 #, no-c-format msgid "Attempt to merge identical debug strings across compilation units." msgstr "" -#: common.opt:2428 +#: common.opt:2427 #, no-c-format msgid "-fmessage-length=\tLimit diagnostics to characters per line. 0 suppresses line-wrapping." msgstr "" -#: common.opt:2432 +#: common.opt:2431 #, fuzzy, no-c-format msgid "Align the start of every function." msgstr "вельмі шмат аргументаў у функцыі" -#: common.opt:2436 +#: common.opt:2435 #, no-c-format msgid "Perform SMS based modulo scheduling before the first scheduling pass." msgstr "" -#: common.opt:2440 +#: common.opt:2439 #, no-c-format msgid "Perform SMS based modulo scheduling with register moves allowed." msgstr "" -#: common.opt:2444 +#: common.opt:2443 #, no-c-format msgid "Move loop invariant computations out of loops." msgstr "" -#: common.opt:2448 +#: common.opt:2447 #, no-c-format msgid "Move stores out of loops." msgstr "" -#: common.opt:2452 +#: common.opt:2451 #, no-c-format msgid "Building block for specs-based multilib-aware TFLAGS." msgstr "" -#: common.opt:2456 +#: common.opt:2455 #, no-c-format msgid "Use the RTL dead code elimination pass." msgstr "" -#: common.opt:2460 +#: common.opt:2459 #, no-c-format msgid "Use the RTL dead store elimination pass." msgstr "" -#: common.opt:2464 +#: common.opt:2463 #, no-c-format msgid "Enable/Disable the traditional scheduling in loops that already passed modulo scheduling." msgstr "" -#: common.opt:2468 +#: common.opt:2467 #, no-c-format msgid "Support synchronous non-call exceptions." msgstr "" -#: common.opt:2475 +#: common.opt:2474 #, no-c-format msgid "-foffload-options==\tSpecify options for the offloading targets." msgstr "" -#: common.opt:2481 +#: common.opt:2480 #, no-c-format msgid "-foffload-abi=[lp64|ilp32]\tSet the ABI to use in an offload compiler." msgstr "" -#: common.opt:2496 +#: common.opt:2495 #, no-c-format msgid "-foffload-abi-host-opts=\tSpecify host ABI options." msgstr "" -#: common.opt:2500 +#: common.opt:2499 #, no-c-format msgid "When possible do not generate stack frames." msgstr "" -#: common.opt:2507 +#: common.opt:2506 #, no-c-format msgid "Generate SIMD clones for functions with the OpenMP declare target directive." msgstr "" -#: common.opt:2526 +#: common.opt:2525 #, fuzzy, no-c-format #| msgid "Enable SSA optimizations" msgid "Enable all optimization info dumps on stderr." msgstr "Уключаць SSA аптымізацыю" -#: common.opt:2530 +#: common.opt:2529 #, no-c-format msgid "-fopt-info[-=filename]\tDump compiler optimization details." msgstr "" -#: common.opt:2534 +#: common.opt:2533 #, no-c-format msgid "Write a SRCFILE.opt-record.json file detailing what optimizations were performed." msgstr "" -#: common.opt:2538 +#: common.opt:2537 #, no-c-format msgid "Detect loops calculating CRC and replace with faster implementation. If the target supports CRC instruction and the CRC loop uses the same polynomial as the one used in the CRC instruction, directly replace with the corresponding CRC instruction. Otherwise, if the target supports carry-less-multiplication instruction, generate CRC using it. If neither case applies, generate table-based CRC." msgstr "" -#: common.opt:2552 +#: common.opt:2551 #, no-c-format msgid "Optimize sibling and tail recursive calls." msgstr "" -#: common.opt:2556 +#: common.opt:2555 #, no-c-format msgid "Insert path profiling code." msgstr "" -#: common.opt:2560 +#: common.opt:2559 #, no-c-format msgid "Perform partial inlining." msgstr "" -#: common.opt:2564 +#: common.opt:2563 #, no-c-format msgid "Report on memory allocation before interprocedural optimization." msgstr "" -#: common.opt:2568 +#: common.opt:2567 #, no-c-format msgid "Report on memory allocation after interprocedural optimization." msgstr "" -#: common.opt:2572 +#: common.opt:2571 #, no-c-format msgid "Pack structure members together without holes." msgstr "" -#: common.opt:2576 +#: common.opt:2575 #, no-c-format msgid "-fpack-struct=\tSet initial maximum structure member alignment." msgstr "" -#: common.opt:2580 +#: common.opt:2579 #, no-c-format msgid "Return small aggregates in memory, not registers." msgstr "" -#: common.opt:2584 +#: common.opt:2583 #, no-c-format msgid "Perform loop peeling." msgstr "" -#: common.opt:2588 +#: common.opt:2587 #, no-c-format msgid "Enable machine specific peephole optimizations." msgstr "" -#: common.opt:2592 +#: common.opt:2591 #, no-c-format msgid "Enable an RTL peephole pass before sched2." msgstr "" -#: common.opt:2596 +#: common.opt:2595 #, no-c-format msgid "Generate position-independent code if possible (large mode)." msgstr "" -#: common.opt:2600 +#: common.opt:2599 #, no-c-format msgid "Generate position-independent code for executables if possible (large mode)." msgstr "" -#: common.opt:2604 +#: common.opt:2603 #, no-c-format msgid "Generate position-independent code if possible (small mode)." msgstr "" -#: common.opt:2608 +#: common.opt:2607 #, no-c-format msgid "Generate position-independent code for executables if possible (small mode)." msgstr "" -#: common.opt:2612 +#: common.opt:2611 #, no-c-format msgid "Use PLT for PIC calls (-fno-plt: load the address from GOT at call site)." msgstr "" -#: common.opt:2616 +#: common.opt:2615 #, no-c-format msgid "Specify a plugin to load." msgstr "" -#: common.opt:2620 +#: common.opt:2619 #, no-c-format msgid "-fplugin-arg--[=]\tSpecify argument = for plugin ." msgstr "" -#: common.opt:2624 +#: common.opt:2623 #, no-c-format msgid "Run predictive commoning optimization." msgstr "" -#: common.opt:2628 +#: common.opt:2627 #, no-c-format msgid "Generate prefetch instructions, if available, for arrays in loops." msgstr "" -#: common.opt:2632 +#: common.opt:2631 #, no-c-format msgid "Enable basic program profiling code." msgstr "" -#: common.opt:2636 +#: common.opt:2635 #, no-c-format msgid "Generate absolute source path names for gcov." msgstr "" -#: common.opt:2640 +#: common.opt:2639 #, no-c-format msgid "Insert arc-based program profiling code." msgstr "" -#: common.opt:2644 +#: common.opt:2643 #, no-c-format msgid "Insert condition coverage profiling code." msgstr "" -#: common.opt:2648 +#: common.opt:2647 #, no-c-format msgid "Set the top-level directory for storing the profile data. The default is 'pwd'." msgstr "" -#: common.opt:2653 +#: common.opt:2652 #, no-c-format msgid "Select the name for storing the profile note file." msgstr "" -#: common.opt:2657 +#: common.opt:2656 #, no-c-format msgid "Enable correction of flow inconsistent profile data input." msgstr "" -#: common.opt:2661 +#: common.opt:2660 #, no-c-format msgid "-fprofile-update=[single|atomic|prefer-atomic]\tSet the profile update method." msgstr "" -#: common.opt:2665 +#: common.opt:2664 #, no-c-format msgid "Instrument only functions from files whose name matches any of the regular expressions (separated by semi-colons)." msgstr "" -#: common.opt:2669 +#: common.opt:2668 #, no-c-format msgid "Instrument only functions from files whose name does not match any of the regular expressions (separated by semi-colons)." msgstr "" -#: common.opt:2685 +#: common.opt:2684 #, no-c-format msgid "-fprofile-reproducible=[serial|parallel-runs|multithreaded]\tControl level of reproducibility of profile gathered by -fprofile-generate." msgstr "" -#: common.opt:2701 +#: common.opt:2700 #, no-c-format msgid "Remove prefix from absolute path before mangling name for -fprofile-generate= and -fprofile-use=." msgstr "" -#: common.opt:2705 +#: common.opt:2704 #, no-c-format msgid "-fprofile-prefix-map==\tMap one directory name to another in GCOV coverage result." msgstr "" -#: common.opt:2709 +#: common.opt:2708 #, no-c-format msgid "Enable common options for generating profile info for profile feedback directed optimizations." msgstr "" -#: common.opt:2713 +#: common.opt:2712 #, no-c-format msgid "Enable common options for generating profile info for profile feedback directed optimizations, and set -fprofile-dir=." msgstr "" -#: common.opt:2717 +#: common.opt:2716 #, no-c-format msgid "Register the profile information in the .gcov_info section instead of using a constructor/destructor." msgstr "" -#: common.opt:2721 +#: common.opt:2720 #, no-c-format msgid "Register the profile information in the specified section instead of using a constructor/destructor." msgstr "" -#: common.opt:2725 +#: common.opt:2724 #, no-c-format msgid "Do not assume that functions never executed during the train run are cold." msgstr "" -#: common.opt:2729 +#: common.opt:2728 #, no-c-format msgid "Enable common options for performing profile feedback directed optimizations." msgstr "" -#: common.opt:2733 +#: common.opt:2732 #, no-c-format msgid "Enable common options for performing profile feedback directed optimizations, and set -fprofile-dir=." msgstr "" -#: common.opt:2737 +#: common.opt:2736 #, no-c-format msgid "Insert code to profile values of expressions." msgstr "" -#: common.opt:2741 +#: common.opt:2740 #, no-c-format msgid "Report on consistency of profile." msgstr "" -#: common.opt:2745 +#: common.opt:2744 #, no-c-format msgid "Enable function reordering that improves code placement." msgstr "" -#: common.opt:2749 +#: common.opt:2748 #, no-c-format msgid "Insert NOP instructions at each function entry." msgstr "" -#: common.opt:2756 +#: common.opt:2755 #, no-c-format msgid "-frandom-seed=\tMake compile reproducible using ." msgstr "" -#: common.opt:2766 +#: common.opt:2765 #, no-c-format msgid "Record gcc command line switches in the object file." msgstr "" -#: common.opt:2770 +#: common.opt:2769 #, fuzzy, no-c-format msgid "Return small aggregates in registers." msgstr "Не выкарыстоўваць рэгістра sb" -#: common.opt:2778 +#: common.opt:2777 #, no-c-format msgid "Tell DSE that the storage for a C++ object is dead when the constructor starts and when the destructor finishes." msgstr "" -#: common.opt:2792 +#: common.opt:2791 #, no-c-format msgid "-flive-patching=[inline-only-static|inline-clone]\tControl IPA optimizations to provide a safe compilation for live-patching. At the same time, provides multiple-level control on the enabled IPA optimizations." msgstr "" -#: common.opt:2807 +#: common.opt:2806 #, no-c-format msgid "Tell DCE to remove unused C++ allocations." msgstr "" -#: common.opt:2811 +#: common.opt:2810 #, no-c-format msgid "Relief of register pressure through live range shrinkage." msgstr "" -#: common.opt:2815 +#: common.opt:2814 #, no-c-format msgid "Perform a register renaming optimization pass." msgstr "" -#: common.opt:2819 +#: common.opt:2818 #, no-c-format msgid "Perform a target dependent instruction fusion optimization pass." msgstr "" -#: common.opt:2823 +#: common.opt:2822 #, no-c-format msgid "Reorder basic blocks to improve code placement." msgstr "" -#: common.opt:2827 +#: common.opt:2826 #, no-c-format msgid "-freorder-blocks-algorithm=[simple|stc]\tSet the used basic block reordering algorithm." msgstr "" -#: common.opt:2840 +#: common.opt:2839 #, no-c-format msgid "Reorder basic blocks and partition into hot and cold sections." msgstr "" -#: common.opt:2844 +#: common.opt:2843 #, no-c-format msgid "Reorder functions to improve code placement." msgstr "" -#: common.opt:2848 +#: common.opt:2847 #, no-c-format msgid "Add a common subexpression elimination pass after loop optimizations." msgstr "" -#: common.opt:2856 +#: common.opt:2855 #, no-c-format msgid "Disable optimizations that assume default FP rounding behavior." msgstr "" -#: common.opt:2860 +#: common.opt:2859 #, no-c-format msgid "Enable scheduling across basic blocks." msgstr "" -#: common.opt:2864 +#: common.opt:2863 #, no-c-format msgid "Enable register pressure sensitive insn scheduling." msgstr "" -#: common.opt:2868 +#: common.opt:2867 #, no-c-format msgid "Allow speculative motion of non-loads." msgstr "" -#: common.opt:2872 +#: common.opt:2871 #, no-c-format msgid "Allow speculative motion of some loads." msgstr "" -#: common.opt:2876 +#: common.opt:2875 #, no-c-format msgid "Allow speculative motion of more loads." msgstr "" -#: common.opt:2880 +#: common.opt:2879 #, no-c-format msgid "-fsched-verbose=\tSet the verbosity level of the scheduler." msgstr "" -#: common.opt:2884 +#: common.opt:2883 #, no-c-format msgid "If scheduling post reload, do superblock scheduling." msgstr "" -#: common.opt:2892 +#: common.opt:2891 #, no-c-format msgid "Reschedule instructions before register allocation." msgstr "" -#: common.opt:2896 +#: common.opt:2895 #, no-c-format msgid "Reschedule instructions after register allocation." msgstr "" -#: common.opt:2903 +#: common.opt:2902 #, no-c-format msgid "Schedule instructions using selective scheduling algorithm." msgstr "" -#: common.opt:2907 +#: common.opt:2906 #, no-c-format msgid "Run selective scheduling after reload." msgstr "" -#: common.opt:2911 +#: common.opt:2910 #, no-c-format msgid "Run self-tests, using the given path to locate test files." msgstr "" -#: common.opt:2915 +#: common.opt:2914 #, no-c-format msgid "Perform software pipelining of inner loops during selective scheduling." msgstr "" -#: common.opt:2919 +#: common.opt:2918 #, no-c-format msgid "Perform software pipelining of outer loops during selective scheduling." msgstr "" -#: common.opt:2924 +#: common.opt:2923 #, no-c-format msgid "Reschedule pipelined regions without pipelining." msgstr "" -#: common.opt:2928 +#: common.opt:2927 #, no-c-format msgid "Allow interposing function (or variables) by ones with different semantics (or initializer) respectively by dynamic linker." msgstr "" -#: common.opt:2934 +#: common.opt:2933 #, no-c-format msgid "Allow premature scheduling of queued insns." msgstr "" -#: common.opt:2938 +#: common.opt:2937 #, no-c-format msgid "-fsched-stalled-insns=\tSet number of queued insns that can be prematurely scheduled." msgstr "" -#: common.opt:2946 +#: common.opt:2945 #, no-c-format msgid "Set dependence distance checking in premature scheduling of queued insns." msgstr "" -#: common.opt:2950 +#: common.opt:2949 #, no-c-format msgid "-fsched-stalled-insns-dep=\tSet dependence distance checking in premature scheduling of queued insns." msgstr "" -#: common.opt:2954 +#: common.opt:2953 #, no-c-format msgid "Enable the group heuristic in the scheduler." msgstr "" -#: common.opt:2958 +#: common.opt:2957 #, no-c-format msgid "Enable the critical path heuristic in the scheduler." msgstr "" -#: common.opt:2962 +#: common.opt:2961 #, no-c-format msgid "Enable the speculative instruction heuristic in the scheduler." msgstr "" -#: common.opt:2966 +#: common.opt:2965 #, no-c-format msgid "Enable the rank heuristic in the scheduler." msgstr "" -#: common.opt:2970 +#: common.opt:2969 #, no-c-format msgid "Enable the last instruction heuristic in the scheduler." msgstr "" -#: common.opt:2974 +#: common.opt:2973 #, no-c-format msgid "Enable the dependent count heuristic in the scheduler." msgstr "" -#: common.opt:2978 +#: common.opt:2977 #, no-c-format msgid "Access data in the same section from shared anchor points." msgstr "" -#: common.opt:2990 +#: common.opt:2989 #, no-c-format msgid "Turn on Redundant Extensions Elimination pass." msgstr "" -#: common.opt:2994 +#: common.opt:2993 #, no-c-format msgid "Show column numbers in diagnostics, when available. Default on." msgstr "" -#: common.opt:2998 +#: common.opt:2997 #, no-c-format msgid "Emit function prologues only before parts of the function that need it, rather than at the top of the function." msgstr "" -#: common.opt:3003 +#: common.opt:3002 #, no-c-format msgid "Shrink-wrap parts of the prologue and epilogue separately." msgstr "" -#: common.opt:3007 +#: common.opt:3006 #, no-c-format msgid "Disable optimizations observable by IEEE signaling NaNs." msgstr "" -#: common.opt:3011 +#: common.opt:3010 #, no-c-format msgid "Disable floating point optimizations that ignore the IEEE signedness of zero." msgstr "" -#: common.opt:3015 +#: common.opt:3014 #, no-c-format msgid "Convert floating point constants to single precision constants." msgstr "" -#: common.opt:3019 +#: common.opt:3018 #, no-c-format msgid "Split lifetimes of induction variables when loops are unrolled." msgstr "" -#: common.opt:3023 +#: common.opt:3022 #, no-c-format msgid "Generate discontiguous stack frames." msgstr "" -#: common.opt:3027 +#: common.opt:3026 #, no-c-format msgid "Split wide types into independent registers." msgstr "" -#: common.opt:3031 +#: common.opt:3030 #, no-c-format msgid "Split wide types into independent registers earlier." msgstr "" -#: common.opt:3035 +#: common.opt:3034 #, no-c-format msgid "Enable backward propagation of use properties at the SSA level." msgstr "" -#: common.opt:3039 +#: common.opt:3038 #, no-c-format msgid "Optimize conditional patterns using SSA PHI nodes." msgstr "" -#: common.opt:3043 +#: common.opt:3042 #, no-c-format msgid "Optimize amount of stdarg registers saved to stack at start of function." msgstr "" -#: common.opt:3047 +#: common.opt:3046 #, no-c-format msgid "Apply variable expansion when loops are unrolled." msgstr "" -#: common.opt:3051 +#: common.opt:3050 #, fuzzy, no-c-format #| msgid "Insert stack checking code into the program" msgid "-fstack-check=[no|generic|specific]\tInsert stack checking code into the program." msgstr "Уключаць код правэркі стэку ў праграму" -#: common.opt:3055 +#: common.opt:3054 #, fuzzy, no-c-format #| msgid "Insert stack checking code into the program" msgid "Insert stack checking code into the program. Same as -fstack-check=specific." msgstr "Уключаць код правэркі стэку ў праграму" -#: common.opt:3059 +#: common.opt:3058 #, no-c-format msgid "Insert code to probe each page of stack space as it is allocated to protect from stack-clash style attacks." msgstr "" -#: common.opt:3068 +#: common.opt:3067 #, no-c-format msgid "-fstack-limit-register=\tTrap if the stack goes past ." msgstr "" -#: common.opt:3072 +#: common.opt:3071 #, no-c-format msgid "-fstack-limit-symbol=\tTrap if the stack goes past symbol ." msgstr "" -#: common.opt:3076 +#: common.opt:3075 #, no-c-format msgid "Use propolice as a stack protection method." msgstr "" -#: common.opt:3080 +#: common.opt:3079 #, no-c-format msgid "Use a stack protection method for every function." msgstr "" -#: common.opt:3084 +#: common.opt:3083 #, no-c-format msgid "Use a smart stack protection method for certain functions." msgstr "" -#: common.opt:3088 +#: common.opt:3087 #, no-c-format msgid "Use stack protection method only for functions with the stack_protect attribute." msgstr "" -#: common.opt:3092 +#: common.opt:3091 #, no-c-format msgid "Output stack usage information on a per-function basis." msgstr "" -#: common.opt:3104 +#: common.opt:3103 #, no-c-format msgid "Assume strict aliasing rules apply." msgstr "" -#: common.opt:3108 +#: common.opt:3107 #, no-c-format msgid "Treat signed overflow as undefined. Negated as -fwrapv -fwrapv-pointer." msgstr "" -#: common.opt:3112 +#: common.opt:3111 #, no-c-format msgid "Disable stack scrub entirely, disregarding strub attributes." msgstr "" -#: common.opt:3116 +#: common.opt:3115 #, no-c-format msgid "Enable stack scrub as per attributes, with strict call checking." msgstr "" -#: common.opt:3125 +#: common.opt:3124 #, no-c-format msgid "Restore default strub mode: as per attributes, with relaxed checking." msgstr "" -#: common.opt:3129 +#: common.opt:3128 #, no-c-format msgid "Enable stack scrubbing for all viable functions." msgstr "" -#: common.opt:3133 +#: common.opt:3132 #, no-c-format msgid "Enable at-calls stack scrubbing for all viable functions." msgstr "" -#: common.opt:3137 +#: common.opt:3136 #, no-c-format msgid "Enable internal stack scrubbing for all viable functions." msgstr "" -#: common.opt:3141 +#: common.opt:3140 #, no-c-format msgid "Implement __atomic operations via libcalls to legacy __sync functions." msgstr "" -#: common.opt:3145 +#: common.opt:3144 #, no-c-format msgid "Check for syntax errors, then stop." msgstr "" -#: common.opt:3149 +#: common.opt:3148 #, no-c-format msgid "Create data files needed by \"gcov\"." msgstr "" -#: common.opt:3153 +#: common.opt:3152 #, no-c-format msgid "Perform jump threading optimizations." msgstr "" -#: common.opt:3157 +#: common.opt:3156 #, no-c-format msgid "Report the time taken by each compiler pass." msgstr "" -#: common.opt:3161 +#: common.opt:3160 #, no-c-format msgid "Record times taken by sub-phases separately." msgstr "" -#: common.opt:3165 +#: common.opt:3164 #, no-c-format msgid "-ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]\tSet the default thread-local storage code generation model." msgstr "" -#: common.opt:3184 +#: common.opt:3183 #, no-c-format msgid "Reorder top level functions, variables, and asms." msgstr "" -#: common.opt:3188 +#: common.opt:3187 #, no-c-format msgid "Perform superblock formation via tail duplication." msgstr "" -#: common.opt:3192 +#: common.opt:3191 #, no-c-format msgid "For targets that normally need trampolines for nested functions, always generate them instead of using descriptors." msgstr "" -#: common.opt:3197 +#: common.opt:3196 #, no-c-format msgid "Whether trampolines are generated in executable memory rather than executable stack." msgstr "" -#: common.opt:3215 +#: common.opt:3214 #, no-c-format msgid "Assume floating-point operations can trap." msgstr "" -#: common.opt:3219 +#: common.opt:3218 #, no-c-format msgid "Trap for signed overflow in addition, subtraction and multiplication." msgstr "" -#: common.opt:3223 +#: common.opt:3222 #, fuzzy, no-c-format #| msgid "Enable SSA optimizations" msgid "Enable SSA-CCP optimization on trees." msgstr "Уключаць SSA аптымізацыю" -#: common.opt:3227 +#: common.opt:3226 #, fuzzy, no-c-format #| msgid "Enable SSA optimizations" msgid "Enable SSA-BIT-CCP optimization on trees." msgstr "Уключаць SSA аптымізацыю" -#: common.opt:3235 +#: common.opt:3234 #, no-c-format msgid "Enable loop header copying on trees." msgstr "" -#: common.opt:3243 +#: common.opt:3242 #, no-c-format msgid "Enable SSA coalescing of user variables." msgstr "" -#: common.opt:3251 +#: common.opt:3250 #, no-c-format msgid "Enable copy propagation on trees." msgstr "" -#: common.opt:3259 +#: common.opt:3258 #, no-c-format msgid "Transform condition stores into unconditional ones." msgstr "" -#: common.opt:3263 +#: common.opt:3262 #, no-c-format msgid "Perform conversions of switch initializations." msgstr "" -#: common.opt:3267 +#: common.opt:3266 #, fuzzy, no-c-format #| msgid "Enable SSA optimizations" msgid "Enable SSA dead code elimination optimization on trees." msgstr "Уключаць SSA аптымізацыю" -#: common.opt:3271 +#: common.opt:3270 #, fuzzy, no-c-format #| msgid "Enable SSA optimizations" msgid "Enable dominator optimizations." msgstr "Уключаць SSA аптымізацыю" -#: common.opt:3275 +#: common.opt:3274 #, no-c-format msgid "Enable tail merging on trees." msgstr "" -#: common.opt:3279 +#: common.opt:3278 #, fuzzy, no-c-format #| msgid "Enable SSA optimizations" msgid "Enable dead store elimination." msgstr "Уключаць SSA аптымізацыю" -#: common.opt:3283 +#: common.opt:3282 #, no-c-format msgid "Enable forward propagation on trees." msgstr "" -#: common.opt:3287 +#: common.opt:3286 #, no-c-format msgid "Enable Full Redundancy Elimination (FRE) on trees." msgstr "" -#: common.opt:3291 +#: common.opt:3290 #, fuzzy, no-c-format #| msgid "Enable SSA optimizations" msgid "Enable string length optimizations on trees." msgstr "Уключаць SSA аптымізацыю" -#: common.opt:3295 +#: common.opt:3294 #, no-c-format msgid "Detect paths that trigger erroneous or undefined behavior due to dereferencing a null pointer. Isolate those paths from the main control flow and turn the statement with erroneous or undefined behavior into a trap." msgstr "" -#: common.opt:3301 +#: common.opt:3300 #, no-c-format msgid "Detect paths that trigger erroneous or undefined behavior due to a null value being used in a way forbidden by a returns_nonnull or nonnull attribute. Isolate those paths from the main control flow and turn the statement with erroneous or undefined behavior into a trap." msgstr "" -#: common.opt:3308 +#: common.opt:3307 #, no-c-format msgid "Enable loop distribution on trees." msgstr "" -#: common.opt:3312 +#: common.opt:3311 #, no-c-format msgid "Enable loop distribution for patterns transformed into a library call." msgstr "" -#: common.opt:3316 +#: common.opt:3315 #, no-c-format msgid "Enable loop invariant motion on trees." msgstr "" -#: common.opt:3324 +#: common.opt:3323 #, no-c-format msgid "Create canonical induction variables in loops." msgstr "" -#: common.opt:3328 +#: common.opt:3327 #, fuzzy, no-c-format #| msgid "Enable SSA optimizations" msgid "Enable loop optimizations on tree level." msgstr "Уключаць SSA аптымізацыю" -#: common.opt:3332 +#: common.opt:3331 #, no-c-format msgid "-ftree-parallelize-loops=\tEnable automatic parallelization of loops." msgstr "" -#: common.opt:3336 +#: common.opt:3335 #, no-c-format msgid "Enable automatic parallelization of loops." msgstr "" -#: common.opt:3340 +#: common.opt:3339 #, no-c-format msgid "Enable hoisting loads from conditional pointers." msgstr "" -#: common.opt:3344 +#: common.opt:3343 #, fuzzy, no-c-format #| msgid "Enable SSA optimizations" msgid "Enable SSA-PRE optimization on trees." msgstr "Уключаць SSA аптымізацыю" -#: common.opt:3348 +#: common.opt:3347 #, no-c-format msgid "In SSA-PRE optimization on trees, enable partial-partial redundancy elimination." msgstr "" -#: common.opt:3352 +#: common.opt:3351 #, no-c-format msgid "Perform function-local points-to analysis on trees." msgstr "" -#: common.opt:3356 +#: common.opt:3355 #, no-c-format msgid "Enable reassociation on tree level." msgstr "" -#: common.opt:3364 +#: common.opt:3363 #, no-c-format msgid "Enable SSA code sinking on trees." msgstr "" -#: common.opt:3368 +#: common.opt:3367 #, no-c-format msgid "Perform straight-line strength reduction." msgstr "" -#: common.opt:3372 +#: common.opt:3371 #, no-c-format msgid "Perform scalar replacement of aggregates." msgstr "" -#: common.opt:3376 +#: common.opt:3375 #, no-c-format msgid "Replace temporary expressions in the SSA->normal pass." msgstr "" -#: common.opt:3384 +#: common.opt:3383 #, no-c-format msgid "Perform Value Range Propagation on trees." msgstr "" -#: common.opt:3388 +#: common.opt:3387 #, no-c-format msgid "Split paths leading to loop backedges." msgstr "" -#: common.opt:3392 +#: common.opt:3391 #, no-c-format msgid "Assume common declarations may be overridden with ones with a larger trailing array." msgstr "" -#: common.opt:3397 +#: common.opt:3396 #, no-c-format msgid "Compile whole compilation unit at a time." msgstr "" -#: common.opt:3401 +#: common.opt:3400 #, no-c-format msgid "Trap on __builtin_unreachable instead of using it for optimization." msgstr "" -#: common.opt:3405 +#: common.opt:3404 #, no-c-format msgid "Perform loop unrolling when iteration count is known." msgstr "" -#: common.opt:3409 +#: common.opt:3408 #, no-c-format msgid "Perform loop unrolling for all loops." msgstr "" -#: common.opt:3424 +#: common.opt:3423 #, no-c-format msgid "Allow optimization for floating-point arithmetic which may change the result of the operation due to rounding." msgstr "" -#: common.opt:3429 +#: common.opt:3428 #, no-c-format msgid "Same as -fassociative-math for expressions which include division." msgstr "" -#: common.opt:3437 +#: common.opt:3436 #, no-c-format msgid "Allow math optimizations that may violate IEEE or ISO standards." msgstr "" -#: common.opt:3441 +#: common.opt:3440 #, no-c-format msgid "Perform loop unswitching." msgstr "" -#: common.opt:3445 +#: common.opt:3444 #, no-c-format msgid "Perform loop splitting." msgstr "" -#: common.opt:3449 +#: common.opt:3448 #, no-c-format msgid "Version loops based on whether indices have a stride of one." msgstr "" -#: common.opt:3453 +#: common.opt:3452 #, fuzzy, no-c-format #| msgid "Enable exception handling" msgid "Just generate unwind tables for exception handling." msgstr "Уключыць апрацоўку выключэньняў" -#: common.opt:3457 +#: common.opt:3456 #, no-c-format msgid "Use the bfd linker instead of the default linker." msgstr "" -#: common.opt:3461 +#: common.opt:3460 #, no-c-format msgid "Use the gold linker instead of the default linker." msgstr "" -#: common.opt:3465 +#: common.opt:3464 #, no-c-format msgid "Use the lld LLVM linker instead of the default linker." msgstr "" -#: common.opt:3469 +#: common.opt:3468 #, no-c-format msgid "Use the Modern linker (MOLD) linker instead of the default linker." msgstr "" -#: common.opt:3473 +#: common.opt:3472 #, no-c-format msgid "Use the Wild linker instead of the default linker." msgstr "" -#: common.opt:3480 +#: common.opt:3479 #, no-c-format msgid "Enable linking of libatomic." msgstr "" -#: common.opt:3487 +#: common.opt:3486 #, no-c-format msgid "Perform variable tracking." msgstr "" -#: common.opt:3494 +#: common.opt:3493 #, no-c-format msgid "Perform variable tracking by annotating assignments." msgstr "" -#: common.opt:3500 +#: common.opt:3499 #, no-c-format msgid "Toggle -fvar-tracking-assignments." msgstr "" -#: common.opt:3507 +#: common.opt:3506 #, no-c-format msgid "Perform variable tracking and also tag variables that are uninitialized." msgstr "" -#: common.opt:3512 +#: common.opt:3511 #, no-c-format msgid "Enable vectorization on trees." msgstr "" -#: common.opt:3520 +#: common.opt:3519 #, fuzzy, no-c-format #| msgid "Enable SSA optimizations" msgid "Enable loop vectorization on trees." msgstr "Уключаць SSA аптымізацыю" -#: common.opt:3524 +#: common.opt:3523 #, no-c-format msgid "Enable basic block vectorization (SLP) on trees." msgstr "" -#: common.opt:3528 +#: common.opt:3527 #, no-c-format msgid "-fvect-cost-model=[unlimited|dynamic|cheap|very-cheap]\tSpecifies the cost model for vectorization." msgstr "" -#: common.opt:3532 +#: common.opt:3531 #, no-c-format msgid "-fsimd-cost-model=[unlimited|dynamic|cheap|very-cheap]\tSpecifies the vectorization cost model for code marked with a simd directive." msgstr "" -#: common.opt:3551 +#: common.opt:3550 #, no-c-format msgid "Enables the dynamic vectorizer cost model. Preserved for backward compatibility." msgstr "" -#: common.opt:3559 +#: common.opt:3558 #, no-c-format msgid "Enable copy propagation of scalar-evolution information." msgstr "" -#: common.opt:3563 +#: common.opt:3562 #, no-c-format msgid "-ftrivial-auto-var-init=[uninitialized|pattern|zero]\tAdd initializations to automatic variables." msgstr "" -#: common.opt:3585 +#: common.opt:3584 #, no-c-format msgid "Add extra commentary to assembler output." msgstr "" -#: common.opt:3589 +#: common.opt:3588 #, no-c-format msgid "-fvisibility=[default|internal|hidden|protected]\tSet the default symbol visibility." msgstr "" -#: common.opt:3608 +#: common.opt:3607 #, no-c-format msgid "Validate vtable pointers before using them." msgstr "" -#: common.opt:3624 +#: common.opt:3623 #, no-c-format msgid "Output vtable verification counters." msgstr "" -#: common.opt:3628 +#: common.opt:3627 #, no-c-format msgid "Output vtable verification pointer sets information." msgstr "" -#: common.opt:3632 +#: common.opt:3631 #, no-c-format msgid "Use expression value profiles in optimizations." msgstr "" -#: common.opt:3636 +#: common.opt:3635 #, no-c-format msgid "Construct webs and split unrelated uses of single variable." msgstr "" -#: common.opt:3640 +#: common.opt:3639 #, no-c-format msgid "Enable conditional dead code elimination for builtin calls." msgstr "" -#: common.opt:3644 +#: common.opt:3643 #, no-c-format msgid "Perform whole program optimizations." msgstr "" -#: common.opt:3648 +#: common.opt:3647 #, no-c-format msgid "Assume pointer overflow wraps around." msgstr "" -#: common.opt:3652 +#: common.opt:3651 #, no-c-format msgid "Assume signed arithmetic overflow wraps around." msgstr "" -#: common.opt:3656 +#: common.opt:3655 #, no-c-format msgid "Put zero initialized data in the bss section." msgstr "" -#: common.opt:3660 +#: common.opt:3659 #, no-c-format msgid "Clear call-used registers upon function return." msgstr "" -#: common.opt:3664 +#: common.opt:3663 #, no-c-format msgid "-fzero-init-padding-bits=[standard|unions|all]\tZero padding bits in initializers." msgstr "" -#: common.opt:3680 +#: common.opt:3679 #, no-c-format msgid "Generate debug information in default format." msgstr "" -#: common.opt:3684 +#: common.opt:3683 #, no-c-format msgid "Assume assembler support for (DWARF2+) .loc directives." msgstr "" -#: common.opt:3688 +#: common.opt:3687 #, no-c-format msgid "Assume assembler support for view in (DWARF2+) .loc directives." msgstr "" -#: common.opt:3692 +#: common.opt:3691 #, no-c-format msgid "Generate debug information in CodeView format." msgstr "" -#: common.opt:3712 +#: common.opt:3711 #, no-c-format msgid "Record DW_AT_decl_column and DW_AT_call_column in DWARF." msgstr "" -#: common.opt:3718 +#: common.opt:3717 #, no-c-format msgid "Generate CTF debug information at default level." msgstr "" -#: common.opt:3722 +#: common.opt:3721 #, no-c-format msgid "Generate BTF debug information at default level." msgstr "" -#: common.opt:3726 +#: common.opt:3725 #, no-c-format msgid "Generate pruned BTF when emitting BTF info." msgstr "" -#: common.opt:3730 +#: common.opt:3729 #, no-c-format msgid "Generate debug information in default version of DWARF format." msgstr "" -#: common.opt:3734 +#: common.opt:3733 #, no-c-format msgid "Generate debug information in DWARF v2 (or later) format." msgstr "" -#: common.opt:3738 +#: common.opt:3737 #, no-c-format msgid "Use 32-bit DWARF format when emitting DWARF debug information." msgstr "" -#: common.opt:3742 +#: common.opt:3741 #, no-c-format msgid "Use 64-bit DWARF format when emitting DWARF debug information." msgstr "" -#: common.opt:3746 +#: common.opt:3745 #, no-c-format msgid "Generate debug information in default extended format." msgstr "" -#: common.opt:3750 +#: common.opt:3749 #, no-c-format msgid "Generate extended entry point information for inlined functions." msgstr "" -#: common.opt:3754 +#: common.opt:3753 #, no-c-format msgid "Compute locview reset points based on insn length estimates." msgstr "" -#: common.opt:3762 +#: common.opt:3761 #, no-c-format msgid "Don't generate DWARF pubnames and pubtypes sections." msgstr "" -#: common.opt:3766 +#: common.opt:3765 #, no-c-format msgid "Generate DWARF pubnames and pubtypes sections." msgstr "" -#: common.opt:3770 +#: common.opt:3769 #, no-c-format msgid "Generate DWARF pubnames and pubtypes sections with GNU extensions." msgstr "" -#: common.opt:3774 +#: common.opt:3773 #, no-c-format msgid "Record gcc command line switches in DWARF DW_AT_producer." msgstr "" -#: common.opt:3778 +#: common.opt:3777 #, no-c-format msgid "Generate debug information in separate .dwo files." msgstr "" -#: common.opt:3790 +#: common.opt:3789 #, no-c-format msgid "Emit progressive recommended breakpoint locations." msgstr "" -#: common.opt:3794 +#: common.opt:3793 #, no-c-format msgid "Don't emit DWARF additions beyond selected version." msgstr "" -#: common.opt:3798 +#: common.opt:3797 #, no-c-format msgid "Add description attributes to some DWARF DIEs that have no name attribute." msgstr "" -#: common.opt:3802 +#: common.opt:3801 #, no-c-format msgid "Toggle debug information generation." msgstr "" -#: common.opt:3806 +#: common.opt:3805 #, no-c-format msgid "Augment variable location lists with progressive views." msgstr "" -#: common.opt:3813 +#: common.opt:3812 #, fuzzy, no-c-format msgid "Generate debug information in VMS format." msgstr "Стварыць код для DLL" -#: common.opt:3842 +#: common.opt:3841 #, no-c-format msgid "Generate compressed debug sections." msgstr "" -#: common.opt:3846 +#: common.opt:3845 #, no-c-format msgid "-gz=\tGenerate compressed debug sections in format ." msgstr "" -#: common.opt:3853 +#: common.opt:3852 #, no-c-format msgid "-iplugindir=\tSet to be the default plugin directory." msgstr "" -#: common.opt:3857 +#: common.opt:3856 #, no-c-format msgid "-imultiarch \tSet to be the multiarch include subdirectory." msgstr "" -#: common.opt:3886 +#: common.opt:3885 #, fuzzy, no-c-format #| msgid " -o Place the output into \n" msgid "-o \tPlace output into ." msgstr " -o <файл> Памясціць вывад у <файл>\n" -#: common.opt:3890 +#: common.opt:3889 #, fuzzy, no-c-format #| msgid "Enable exception handling" msgid "Enable function profiling." msgstr "Уключыць апрацоўку выключэньняў" -#: common.opt:3900 +#: common.opt:3899 #, no-c-format msgid "Like -pedantic but issue errors instead of warnings." msgstr "" -#: common.opt:3944 +#: common.opt:3943 #, no-c-format msgid "Do not display functions compiled or elapsed time." msgstr "" -#: common.opt:3948 +#: common.opt:3947 #, no-c-format msgid "Produce a relocatable object as output." msgstr "" -#: common.opt:3952 +#: common.opt:3951 #, no-c-format msgid "Remove all symbol table and relocation information from the executable." msgstr "" -#: common.opt:3979 +#: common.opt:3978 #, no-c-format msgid "Enable verbose output." msgstr "" -#: common.opt:3983 +#: common.opt:3982 #, no-c-format msgid "Display the compiler's version." msgstr "" -#: common.opt:3987 +#: common.opt:3986 #, no-c-format msgid "Suppress warnings." msgstr "" -#: common.opt:3997 +#: common.opt:3996 #, no-c-format msgid "Create a shared library." msgstr "" -#: common.opt:4064 +#: common.opt:4063 #, no-c-format msgid "Don't create a dynamically linked position independent executable." msgstr "" -#: common.opt:4068 +#: common.opt:4067 #, no-c-format msgid "Create a dynamically linked position independent executable." msgstr "" -#: common.opt:4072 +#: common.opt:4071 #, no-c-format msgid "Create a static position independent executable." msgstr "" -#: common.opt:4080 +#: common.opt:4079 #, no-c-format msgid "Use caller save register across calls if possible." msgstr "" -#: common.opt:4084 +#: common.opt:4083 #, no-c-format msgid "Perform dead code elimination on zero and sign extensions with special dataflow analysis." msgstr "" @@ -18418,86 +18424,86 @@ msgstr "" msgid "argument must be passed by copying" msgstr "" -#: calls.cc:2555 +#: calls.cc:2565 msgid "machine description does not have a sibcall_epilogue instruction pattern" msgstr "" -#: calls.cc:2567 +#: calls.cc:2577 msgid "callee returns a structure" msgstr "" -#: calls.cc:2575 +#: calls.cc:2585 msgid "target is not able to optimize the call into a sibling call" msgstr "" -#: calls.cc:2584 +#: calls.cc:2594 msgid "callee returns twice" msgstr "" -#: calls.cc:2589 +#: calls.cc:2599 msgid "callee does not return" msgstr "" -#: calls.cc:2596 +#: calls.cc:2606 #, fuzzy msgid "volatile function type" msgstr "Нерэчаісны выбар \"%s\"" -#: calls.cc:2615 +#: calls.cc:2625 #, fuzzy #| msgid "In function" msgid "nested function" msgstr "У функцыі" -#: calls.cc:2626 +#: calls.cc:2636 msgid "callee required more stack slots than the caller" msgstr "" -#: calls.cc:2640 +#: calls.cc:2650 msgid "inconsistent number of popped arguments" msgstr "" -#: calls.cc:2647 +#: calls.cc:2657 #, fuzzy #| msgid "%s does not support %s" msgid "frontend does not support sibling call" msgstr "%s не падтрымлівае %s" -#: calls.cc:2703 +#: calls.cc:2713 msgid "other reasons" msgstr "" -#: calls.cc:3077 +#: calls.cc:3087 msgid "inside another call" msgstr "" -#: calls.cc:3086 +#: calls.cc:3096 msgid "variable size arguments" msgstr "" -#: calls.cc:3110 +#: calls.cc:3120 msgid "hidden string length argument passed on stack" msgstr "" -#: calls.cc:3159 +#: calls.cc:3169 msgid "caller and callee disagree in promotion of function return value" msgstr "" #. Ideally we'd emit a message for all of the ways that it could #. have failed. -#: calls.cc:4086 +#: calls.cc:4096 msgid "tail call production failed" msgstr "" -#: cfgrtl.cc:2830 +#: cfgrtl.cc:2843 msgid "flow control insn inside a basic block" msgstr "" -#: cfgrtl.cc:3122 +#: cfgrtl.cc:3135 msgid "insn outside basic block" msgstr "" -#: cfgrtl.cc:3130 +#: cfgrtl.cc:3143 msgid "return not followed by barrier" msgstr "" @@ -18606,12 +18612,12 @@ msgstr "" #. PRINT_OPERAND must handle them. #. We can't handle floating point constants; #. TARGET_PRINT_OPERAND must handle them. -#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13370 +#: final.cc:3760 config/arc/arc.cc:6323 config/i386/i386.cc:13416 #, c-format msgid "floating constant misused" msgstr "" -#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13464 +#: final.cc:3818 config/arc/arc.cc:6420 config/i386/i386.cc:13510 #: config/pdp11/pdp11.cc:1872 #, c-format msgid "invalid expression as operand" @@ -19903,11 +19909,11 @@ msgstr "" msgid "this is the insn:" msgstr "" -#: lra-constraints.cc:4198 +#: lra-constraints.cc:4228 msgid "unable to reload address in " msgstr "" -#: lra-constraints.cc:4523 reload.cc:3852 +#: lra-constraints.cc:4553 reload.cc:3852 msgid "unable to generate reloads for:" msgstr "" @@ -20132,8 +20138,8 @@ msgstr "" msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n" msgstr "" -#: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6614 -#: c/c-typeck.cc:9595 cp/error.cc:1379 c-family/c-pretty-print.cc:441 +#: tree-diagnostic.cc:103 tree-logical-location.cc:131 c/c-decl.cc:6616 +#: c/c-typeck.cc:9612 cp/error.cc:1381 c-family/c-pretty-print.cc:441 #, gcc-internal-format msgid "" msgstr "" @@ -20535,18 +20541,18 @@ msgstr "" msgid "" msgstr "" -#: config/aarch64/aarch64.cc:13027 config/loongarch/loongarch.cc:6728 +#: config/aarch64/aarch64.cc:13020 config/loongarch/loongarch.cc:6763 #, fuzzy, c-format msgid "unsupported operand for code '%c'" msgstr "Нерэчаісны выбар \"%s\"" -#: config/aarch64/aarch64.cc:13036 config/aarch64/aarch64.cc:13049 -#: config/aarch64/aarch64.cc:13061 config/aarch64/aarch64.cc:13072 -#: config/aarch64/aarch64.cc:13088 config/aarch64/aarch64.cc:13102 -#: config/aarch64/aarch64.cc:13122 config/aarch64/aarch64.cc:13204 -#: config/aarch64/aarch64.cc:13215 config/aarch64/aarch64.cc:13229 -#: config/aarch64/aarch64.cc:13455 config/aarch64/aarch64.cc:13468 -#: config/aarch64/aarch64.cc:13485 config/pru/pru.cc:1872 +#: config/aarch64/aarch64.cc:13029 config/aarch64/aarch64.cc:13042 +#: config/aarch64/aarch64.cc:13054 config/aarch64/aarch64.cc:13065 +#: config/aarch64/aarch64.cc:13081 config/aarch64/aarch64.cc:13095 +#: config/aarch64/aarch64.cc:13115 config/aarch64/aarch64.cc:13197 +#: config/aarch64/aarch64.cc:13208 config/aarch64/aarch64.cc:13222 +#: config/aarch64/aarch64.cc:13448 config/aarch64/aarch64.cc:13461 +#: config/aarch64/aarch64.cc:13478 config/pru/pru.cc:1872 #: config/pru/pru.cc:1883 config/pru/pru.cc:1965 config/riscv/riscv.cc:8095 #: config/riscv/riscv.cc:8111 config/riscv/riscv.cc:8127 #: config/riscv/riscv.cc:8143 config/riscv/riscv.cc:8176 @@ -20556,8 +20562,8 @@ msgstr "Нерэчаісны выбар \"%s\"" msgid "invalid operand for '%%%c'" msgstr "Нерэчаісны выбар \"%s\"" -#: config/aarch64/aarch64.cc:13140 config/aarch64/aarch64.cc:13151 -#: config/aarch64/aarch64.cc:13315 config/aarch64/aarch64.cc:13326 +#: config/aarch64/aarch64.cc:13133 config/aarch64/aarch64.cc:13144 +#: config/aarch64/aarch64.cc:13308 config/aarch64/aarch64.cc:13319 #: config/riscv/riscv.cc:7991 config/riscv/riscv.cc:7999 #: config/riscv/riscv.cc:8006 config/riscv/riscv.cc:8010 #: config/riscv/riscv.cc:8052 config/riscv/riscv.cc:8070 @@ -20566,116 +20572,116 @@ msgstr "Нерэчаісны выбар \"%s\"" msgid "invalid vector constant" msgstr "`%E' - нерэчаісная нязьменная тыпу string" -#: config/aarch64/aarch64.cc:13165 +#: config/aarch64/aarch64.cc:13158 #, c-format msgid "incompatible floating point / vector register operand for '%%%c'" msgstr "" -#: config/aarch64/aarch64.cc:13177 +#: config/aarch64/aarch64.cc:13170 #, fuzzy, c-format #| msgid "impossible operator '%s'" msgid "incompatible operand for '%%%c'" msgstr "немагчымы апэратар '%s'" -#: config/aarch64/aarch64.cc:13197 +#: config/aarch64/aarch64.cc:13190 #, fuzzy, c-format #| msgid "invalid register name for `%s'" msgid "incompatible register operand for '%%%c'" msgstr "нерэчаісная назва рэгістра `%s'" -#: config/aarch64/aarch64.cc:13262 config/arm/arm.cc:24794 +#: config/aarch64/aarch64.cc:13255 config/arm/arm.cc:24794 #, fuzzy, c-format msgid "missing operand" msgstr "прапушчан ініцыялізатар" -#: config/aarch64/aarch64.cc:13352 +#: config/aarch64/aarch64.cc:13345 #, fuzzy, c-format msgid "invalid constant" msgstr "Нерэчаісны выбар %s" -#: config/aarch64/aarch64.cc:13355 +#: config/aarch64/aarch64.cc:13348 #, fuzzy, c-format #| msgid "invalid %%d operand" msgid "invalid operand" msgstr "нерэчаісны %%d аперанд" -#: config/aarch64/aarch64.cc:13493 config/aarch64/aarch64.cc:13498 +#: config/aarch64/aarch64.cc:13486 config/aarch64/aarch64.cc:13491 #, fuzzy, c-format msgid "invalid operand prefix '%%%c'" msgstr "Нерэчаісны выбар \"%s\"" -#: config/aarch64/aarch64.cc:13518 +#: config/aarch64/aarch64.cc:13511 #, fuzzy, c-format #| msgid "invalid address" msgid "invalid address mode" msgstr "нерэчаісны адрас" -#: config/aarch64/aarch64.cc:23822 +#: config/aarch64/aarch64.cc:23815 msgid "invalid conversion from type %" msgstr "" -#: config/aarch64/aarch64.cc:23824 +#: config/aarch64/aarch64.cc:23817 msgid "invalid conversion to type %" msgstr "" -#: config/aarch64/aarch64.cc:31134 +#: config/aarch64/aarch64.cc:31168 msgid "preincrement operation not permitted on svbool_t" msgstr "" -#: config/aarch64/aarch64.cc:31136 +#: config/aarch64/aarch64.cc:31170 msgid "predecrement operation not permitted on svbool_t" msgstr "" -#: config/aarch64/aarch64.cc:31138 +#: config/aarch64/aarch64.cc:31172 msgid "postincrement operation not permitted on svbool_t" msgstr "" -#: config/aarch64/aarch64.cc:31140 +#: config/aarch64/aarch64.cc:31174 msgid "postdecrement operation not permitted on svbool_t" msgstr "" -#: config/aarch64/aarch64.cc:31142 +#: config/aarch64/aarch64.cc:31176 msgid "negation operation not permitted on svbool_t" msgstr "" -#: config/aarch64/aarch64.cc:31144 +#: config/aarch64/aarch64.cc:31178 msgid "plus operation not permitted on svbool_t" msgstr "" -#: config/aarch64/aarch64.cc:31146 +#: config/aarch64/aarch64.cc:31180 msgid "minus operation not permitted on svbool_t" msgstr "" -#: config/aarch64/aarch64.cc:31148 +#: config/aarch64/aarch64.cc:31182 msgid "multiply operation not permitted on svbool_t" msgstr "" -#: config/aarch64/aarch64.cc:31150 +#: config/aarch64/aarch64.cc:31184 msgid "divide operation not permitted on svbool_t" msgstr "" -#: config/aarch64/aarch64.cc:31153 +#: config/aarch64/aarch64.cc:31187 msgid "shift operation not permitted on svbool_t" msgstr "" -#: config/aarch64/aarch64.cc:31158 +#: config/aarch64/aarch64.cc:31192 msgid "only == and != operations permitted on svbool_t" msgstr "" -#: config/aarch64/aarch64.cc:31160 +#: config/aarch64/aarch64.cc:31194 msgid "subscript operation not supported on svbool_t" msgstr "" -#: config/aarch64/aarch64.cc:31181 config/aarch64/aarch64.cc:31214 +#: config/aarch64/aarch64.cc:31215 config/aarch64/aarch64.cc:31248 msgid "operation not permitted on type %" msgstr "" -#: config/aarch64/aarch64.cc:31202 +#: config/aarch64/aarch64.cc:31236 msgid "cannot combine GNU and SVE vectors in a binary operation" msgstr "" -#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14676 -#: config/rs6000/rs6000.cc:14685 config/sparc/sparc.cc:9386 +#: config/alpha/alpha.cc:5776 config/i386/i386.cc:14722 +#: config/rs6000/rs6000.cc:14852 config/sparc/sparc.cc:9386 #, c-format msgid "'%%&' used without any local dynamic TLS references" msgstr "" @@ -20691,18 +20697,18 @@ msgid "invalid %%r value" msgstr "нерэчаіснае значэньне %%r" #: config/alpha/alpha.cc:5874 config/ia64/ia64.cc:5591 -#: config/rs6000/rs6000.cc:14380 config/xtensa/xtensa.cc:3016 +#: config/rs6000/rs6000.cc:14523 config/xtensa/xtensa.cc:3016 #, c-format msgid "invalid %%R value" msgstr "нерэчаіснае значэньне %%R" -#: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14300 +#: config/alpha/alpha.cc:5880 config/rs6000/rs6000.cc:14443 #: config/xtensa/xtensa.cc:2989 #, c-format msgid "invalid %%N value" msgstr "нерэчаіснае значэньне %%N" -#: config/alpha/alpha.cc:5888 config/rs6000/rs6000.cc:14328 +#: config/alpha/alpha.cc:5888 config/rs6000/rs6000.cc:14471 #, c-format msgid "invalid %%P value" msgstr "нерэчаіснае значэньне %%P" @@ -20732,7 +20738,7 @@ msgstr "нерэчаіснае значэньне %%M" msgid "invalid %%U value" msgstr "нерэчаіснае значэньне %%U" -#: config/alpha/alpha.cc:5974 config/rs6000/rs6000.cc:14388 +#: config/alpha/alpha.cc:5974 config/rs6000/rs6000.cc:14531 #, c-format msgid "invalid %%s value" msgstr "нерэчаіснае значэньне %%v" @@ -20742,7 +20748,7 @@ msgstr "нерэчаіснае значэньне %%v" msgid "invalid %%C value" msgstr "нерэчаіснае значэньне %%C" -#: config/alpha/alpha.cc:6022 config/rs6000/rs6000.cc:14164 +#: config/alpha/alpha.cc:6022 config/rs6000/rs6000.cc:14307 #, c-format msgid "invalid %%E value" msgstr "нерэчаіснае значэньне %%E" @@ -20755,7 +20761,7 @@ msgstr "" #: config/alpha/alpha.cc:6056 config/gcn/gcn.cc:7606 config/gcn/gcn.cc:7615 #: config/gcn/gcn.cc:7673 config/gcn/gcn.cc:7681 config/gcn/gcn.cc:7697 #: config/gcn/gcn.cc:7715 config/gcn/gcn.cc:7766 config/gcn/gcn.cc:7885 -#: config/gcn/gcn.cc:8001 config/rs6000/rs6000.cc:14690 +#: config/gcn/gcn.cc:8001 config/rs6000/rs6000.cc:14857 #, c-format msgid "invalid %%xn code" msgstr "нерэчаіснае значэньне %%xn" @@ -20937,104 +20943,104 @@ msgstr "нераспазнаны выбар \"-%s\"" msgid "incomplete application of insn" msgstr "" -#: config/avr/avr.cc:2504 +#: config/avr/avr.cc:2501 #, c-format msgid "address operand requires constraint for X, Y, or Z register" msgstr "" -#: config/avr/avr.cc:2687 +#: config/avr/avr.cc:2684 msgid "operands to %T/%t must be reg + const_int:" msgstr "" -#: config/avr/avr.cc:2742 +#: config/avr/avr.cc:2739 #, c-format msgid "bad I/O address 0x%s outside of valid range [0x%x, 0x%x] for %%i operand" msgstr "" -#: config/avr/avr.cc:2768 +#: config/avr/avr.cc:2765 #, c-format msgid "%s operand cannot be used as %%i I/O address operand" msgstr "" -#: config/avr/avr.cc:2791 +#: config/avr/avr.cc:2788 msgid "bad address, not a constant:" msgstr "" -#: config/avr/avr.cc:2810 config/avr/avr.cc:2817 +#: config/avr/avr.cc:2807 config/avr/avr.cc:2814 msgid "bad address, not (reg+disp):" msgstr "" -#: config/avr/avr.cc:2824 +#: config/avr/avr.cc:2821 msgid "bad address, not post_inc or pre_dec:" msgstr "" -#: config/avr/avr.cc:2836 +#: config/avr/avr.cc:2833 msgid "internal compiler error. Bad address:" msgstr "" -#: config/avr/avr.cc:2865 +#: config/avr/avr.cc:2862 #, c-format msgid "Unsupported code '%c' for fixed-point:" msgstr "" -#: config/avr/avr.cc:2884 +#: config/avr/avr.cc:2881 msgid "internal compiler error. Unknown mode:" msgstr "" -#: config/avr/avr.cc:4298 config/avr/avr.cc:5284 config/avr/avr.cc:5731 +#: config/avr/avr.cc:4295 config/avr/avr.cc:5281 config/avr/avr.cc:5728 #, fuzzy msgid "invalid insn:" msgstr "Нерэчаісны выбар %s" -#: config/avr/avr.cc:4381 config/avr/avr.cc:4506 config/avr/avr.cc:4564 -#: config/avr/avr.cc:4616 config/avr/avr.cc:4635 config/avr/avr.cc:4827 -#: config/avr/avr.cc:5135 config/avr/avr.cc:5420 config/avr/avr.cc:5624 -#: config/avr/avr.cc:5788 config/avr/avr.cc:5881 config/avr/avr.cc:6079 +#: config/avr/avr.cc:4378 config/avr/avr.cc:4503 config/avr/avr.cc:4561 +#: config/avr/avr.cc:4613 config/avr/avr.cc:4632 config/avr/avr.cc:4824 +#: config/avr/avr.cc:5132 config/avr/avr.cc:5417 config/avr/avr.cc:5621 +#: config/avr/avr.cc:5785 config/avr/avr.cc:5878 config/avr/avr.cc:6076 msgid "incorrect insn:" msgstr "" -#: config/avr/avr.cc:4651 config/avr/avr.cc:4926 config/avr/avr.cc:5206 -#: config/avr/avr.cc:5492 config/avr/avr.cc:5670 config/avr/avr.cc:5937 -#: config/avr/avr.cc:6137 +#: config/avr/avr.cc:4648 config/avr/avr.cc:4923 config/avr/avr.cc:5203 +#: config/avr/avr.cc:5489 config/avr/avr.cc:5667 config/avr/avr.cc:5934 +#: config/avr/avr.cc:6134 msgid "unknown move insn:" msgstr "" -#: config/avr/avr.cc:7082 +#: config/avr/avr.cc:7079 msgid "bad shift insn:" msgstr "" -#: config/avr/avr.cc:7182 config/avr/avr.cc:7708 config/avr/avr.cc:8171 +#: config/avr/avr.cc:7179 config/avr/avr.cc:7705 config/avr/avr.cc:8168 msgid "internal compiler error. Incorrect shift:" msgstr "" -#: config/avr/avr.cc:10463 +#: config/avr/avr.cc:10460 #, fuzzy #| msgid "unsupported version" msgid "unsupported fixed-point conversion" msgstr "непадтрымліваемая версія" -#: config/avr/avr.cc:11747 +#: config/avr/avr.cc:11744 msgid "variable" msgstr "" -#: config/avr/avr.cc:11752 +#: config/avr/avr.cc:11749 #, fuzzy msgid "function parameter" msgstr "невыкарыстаемы параметр \"%s\"" -#: config/avr/avr.cc:11757 +#: config/avr/avr.cc:11754 #, fuzzy #| msgid "structure" msgid "structure field" msgstr "структура" -#: config/avr/avr.cc:11763 +#: config/avr/avr.cc:11760 #, fuzzy #| msgid "return type of `%s' is not `int'" msgid "return type of function" msgstr "вяртаемы тып \"%s\" не \"int\"" -#: config/avr/avr.cc:11768 +#: config/avr/avr.cc:11765 msgid "pointer" msgstr "" @@ -21056,14 +21062,14 @@ msgstr "" msgid "invalid const_double operand" msgstr "нерэчаісны %%c аперанд" -#: config/bpf/bpf.cc:933 +#: config/bpf/bpf.cc:956 #, fuzzy #| msgid "invalid %%d operand" msgid "invalid address in operand" msgstr "нерэчаісны %%d аперанд" #. Fallthrough. -#: config/bpf/bpf.cc:940 +#: config/bpf/bpf.cc:963 #, fuzzy #| msgid "unsupported version" msgid "unsupported operand" @@ -21074,7 +21080,7 @@ msgstr "непадтрымліваемая версія" #: cobol/dts.h:71 final.cc:3204 final.cc:3206 fold-const.cc:347 gcc.cc:6327 #: gcc.cc:6341 rtl-error.cc:101 toplev.cc:325 cobol/gcobolspec.cc:361 #: cobol/gcobolspec.cc:435 cobol/gcobolspec.cc:445 cobol/gcobolspec.cc:529 -#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8101 +#: cobol/genutil.cc:1179 cp/logic.cc:311 cp/logic.cc:313 cp/typeck.cc:8102 #: d/d-convert.cc:237 go/go-gcc-diagnostics.cc:28 go/go-gcc-diagnostics.cc:37 #: go/go-gcc-diagnostics.cc:45 go/go-gcc-diagnostics.cc:53 #: lto/lto-object.cc:178 lto/lto-object.cc:275 lto/lto-object.cc:332 @@ -21322,130 +21328,130 @@ msgstr "`%E' - нерэчаісная нязьменная тыпу string" msgid "Expected register or constant integer." msgstr "" -#: config/i386/i386.cc:13458 +#: config/i386/i386.cc:13504 #, c-format msgid "invalid UNSPEC as operand" msgstr "" -#: config/i386/i386.cc:14001 +#: config/i386/i386.cc:14047 #, fuzzy, c-format #| msgid "invalid use of `restrict'" msgid "invalid use of register '%s'" msgstr "нявернае выкарыстанне \"restict\"" -#: config/i386/i386.cc:14006 +#: config/i386/i386.cc:14052 #, fuzzy, c-format #| msgid "invalid use of `restrict'" msgid "invalid use of asm flag output" msgstr "нявернае выкарыстанне \"restict\"" -#: config/i386/i386.cc:14241 +#: config/i386/i386.cc:14287 #, fuzzy, c-format msgid "invalid operand size for operand code 'O'" msgstr "нерэчаісны %%-код" -#: config/i386/i386.cc:14276 +#: config/i386/i386.cc:14322 #, fuzzy, c-format msgid "invalid operand size for operand code 'z'" msgstr "нерэчаісны %%-код" -#: config/i386/i386.cc:14351 +#: config/i386/i386.cc:14397 #, fuzzy, c-format msgid "invalid operand type used with operand code '%c'" msgstr "Нерэчаісны выбар \"%s\"" -#: config/i386/i386.cc:14356 +#: config/i386/i386.cc:14402 #, fuzzy, c-format msgid "invalid operand size for operand code '%c'" msgstr "Нерэчаісны выбар \"%s\"" -#: config/i386/i386.cc:14434 +#: config/i386/i386.cc:14480 #, c-format msgid "operand is not a condition code, invalid operand code 'Y'" msgstr "" -#: config/i386/i386.cc:14513 +#: config/i386/i386.cc:14559 #, c-format msgid "operand is not a condition code, invalid operand code 'D'" msgstr "" -#: config/i386/i386.cc:14531 +#: config/i386/i386.cc:14577 #, c-format msgid "operand is not a condition code, invalid operand code '%c'" msgstr "" -#: config/i386/i386.cc:14552 +#: config/i386/i386.cc:14598 #, c-format msgid "operand is not an offsettable memory reference, invalid operand code 'H'" msgstr "" -#: config/i386/i386.cc:14567 +#: config/i386/i386.cc:14613 #, c-format msgid "operand is not an integer, invalid operand code 'K'" msgstr "" -#: config/i386/i386.cc:14595 +#: config/i386/i386.cc:14641 #, c-format msgid "operand is not a specific integer, invalid operand code 'r'" msgstr "" -#: config/i386/i386.cc:14613 +#: config/i386/i386.cc:14659 #, c-format msgid "operand is not an integer, invalid operand code 'R'" msgstr "" -#: config/i386/i386.cc:14636 +#: config/i386/i386.cc:14682 #, c-format msgid "operand is not a specific integer, invalid operand code 'R'" msgstr "" -#: config/i386/i386.cc:14663 +#: config/i386/i386.cc:14709 #, c-format msgid "operand is not a memory reference, invalid operand code 'v'" msgstr "" -#: config/i386/i386.cc:14751 +#: config/i386/i386.cc:14797 #, fuzzy, c-format msgid "invalid operand code '%c'" msgstr "Нерэчаісны выбар \"%s\"" -#: config/i386/i386.cc:14813 config/i386/i386.cc:15202 +#: config/i386/i386.cc:14859 config/i386/i386.cc:15248 #, fuzzy, c-format #| msgid "invalid %%c operand" msgid "invalid constraints for operand" msgstr "нерэчаісны %%c аперанд" -#: config/i386/i386.cc:14914 +#: config/i386/i386.cc:14960 #, fuzzy, c-format msgid "invalid vector immediate" msgstr "нерэчаісны ініцыялізатар" -#: config/i386/i386.cc:18092 +#: config/i386/i386.cc:18138 #, fuzzy msgid "unknown insn mode" msgstr "невядомы рэжым машыны \"%s\"" -#: config/i386/i386.cc:24925 +#: config/i386/i386.cc:24971 msgid "invalid conversion from type %<__bf16%> without option %<-msse2%>" msgstr "" -#: config/i386/i386.cc:24928 +#: config/i386/i386.cc:24974 msgid "invalid conversion from type %<_Float16%> without option %<-msse2%>" msgstr "" -#: config/i386/i386.cc:24931 +#: config/i386/i386.cc:24977 msgid "invalid conversion to type %<__bf16%> without option %<-msse2%>" msgstr "" -#: config/i386/i386.cc:24934 +#: config/i386/i386.cc:24980 msgid "invalid conversion to type %<_Float16%> without option %<-msse2%>" msgstr "" -#: config/i386/i386.cc:24972 config/i386/i386.cc:24997 +#: config/i386/i386.cc:25018 config/i386/i386.cc:25043 msgid "operation not permitted on type %<__bf16%> without option %<-msse2%>" msgstr "" -#: config/i386/i386.cc:24975 config/i386/i386.cc:25001 +#: config/i386/i386.cc:25021 config/i386/i386.cc:25047 msgid "operation not permitted on type %<_Float16%> without option %<-msse2%>" msgstr "" @@ -21481,7 +21487,7 @@ msgstr "нерэчаісны %%-код" msgid "invalid %%P operand" msgstr "нерэчаісны %%-код" -#: config/iq2000/iq2000.cc:3131 config/rs6000/rs6000.cc:14318 +#: config/iq2000/iq2000.cc:3131 config/rs6000/rs6000.cc:14461 #, c-format msgid "invalid %%p value" msgstr "" @@ -21510,22 +21516,22 @@ msgstr "" msgid "invalid addressing mode" msgstr "" -#: config/loongarch/loongarch.cc:6467 config/loongarch/loongarch.cc:6489 -#: config/loongarch/loongarch.cc:6900 config/mips/mips.cc:9404 +#: config/loongarch/loongarch.cc:6500 config/loongarch/loongarch.cc:6522 +#: config/loongarch/loongarch.cc:6935 config/mips/mips.cc:9404 #: config/mips/mips.cc:9431 config/mips/mips.cc:9614 #, fuzzy, c-format msgid "'%%%c' is not a valid operand prefix" msgstr "\"%s\" - гэта не пачатак дэкларацыі" -#: config/loongarch/loongarch.cc:6720 config/loongarch/loongarch.cc:6740 -#: config/loongarch/loongarch.cc:6797 config/loongarch/loongarch.cc:6804 -#: config/loongarch/loongarch.cc:6814 config/loongarch/loongarch.cc:6860 -#: config/loongarch/loongarch.cc:6872 config/loongarch/loongarch.cc:6879 -#: config/loongarch/loongarch.cc:6889 config/loongarch/loongarch.cc:6892 -#: config/loongarch/loongarch.cc:6913 config/loongarch/loongarch.cc:6920 -#: config/loongarch/loongarch.cc:6947 config/loongarch/loongarch.cc:6954 -#: config/loongarch/loongarch.cc:6967 config/loongarch/loongarch.cc:6982 -#: config/loongarch/loongarch.cc:6991 config/mips/mips.cc:9503 +#: config/loongarch/loongarch.cc:6753 config/loongarch/loongarch.cc:6775 +#: config/loongarch/loongarch.cc:6832 config/loongarch/loongarch.cc:6839 +#: config/loongarch/loongarch.cc:6849 config/loongarch/loongarch.cc:6895 +#: config/loongarch/loongarch.cc:6907 config/loongarch/loongarch.cc:6914 +#: config/loongarch/loongarch.cc:6924 config/loongarch/loongarch.cc:6927 +#: config/loongarch/loongarch.cc:6948 config/loongarch/loongarch.cc:6955 +#: config/loongarch/loongarch.cc:6984 config/loongarch/loongarch.cc:6991 +#: config/loongarch/loongarch.cc:7004 config/loongarch/loongarch.cc:7019 +#: config/loongarch/loongarch.cc:7028 config/mips/mips.cc:9503 #: config/mips/mips.cc:9510 config/mips/mips.cc:9517 config/mips/mips.cc:9524 #: config/mips/mips.cc:9537 config/mips/mips.cc:9544 config/mips/mips.cc:9554 #: config/mips/mips.cc:9557 config/mips/mips.cc:9569 config/mips/mips.cc:9572 @@ -21566,7 +21572,7 @@ msgid "post-increment address is not a register" msgstr "" #: config/m32r/m32r.cc:2340 config/m32r/m32r.cc:2355 -#: config/rs6000/rs6000.cc:20992 +#: config/rs6000/rs6000.cc:21162 msgid "bad address" msgstr "дрэнны адрас" @@ -21784,278 +21790,292 @@ msgstr "" msgid "Try running '%s' in the shell to raise its limit.\n" msgstr "" -#: config/rs6000/rs6000.cc:3837 +#: config/rs6000/rs6000.cc:3905 #, fuzzy #| msgid "Use hardware floating point" msgid "%<-mvsx%> requires hardware floating-point" msgstr "Выкарыстоўваць апаратную \"плаваючую кропку\"" -#: config/rs6000/rs6000.cc:3848 +#: config/rs6000/rs6000.cc:3916 msgid "%<-mvsx%> needs indexed addressing" msgstr "" -#: config/rs6000/rs6000.cc:3858 +#: config/rs6000/rs6000.cc:3926 msgid "%<-mno-altivec%> disables vsx" msgstr "" -#: config/rs6000/rs6000.cc:3978 +#: config/rs6000/rs6000.cc:4046 msgid "%<-mquad-memory%> requires 64-bit mode" msgstr "" -#: config/rs6000/rs6000.cc:3981 +#: config/rs6000/rs6000.cc:4049 msgid "%<-mquad-memory-atomic%> requires 64-bit mode" msgstr "" -#: config/rs6000/rs6000.cc:3993 +#: config/rs6000/rs6000.cc:4061 msgid "%<-mquad-memory%> is not available in little endian mode" msgstr "" -#: config/rs6000/rs6000.cc:11390 +#: config/rs6000/rs6000.cc:11482 msgid "bad move" msgstr "" -#: config/rs6000/rs6000.cc:13948 +#: config/rs6000/rs6000.cc:14082 msgid "Bad 128-bit move" msgstr "" -#: config/rs6000/rs6000.cc:14128 +#: config/rs6000/rs6000.cc:14264 config/rs6000/rs6000.cc:14271 #, fuzzy, c-format #| msgid "invalid %%Q value" msgid "invalid %%A value" msgstr "дрэннае %%Q значэнне" -#: config/rs6000/rs6000.cc:14137 config/xtensa/xtensa.cc:2955 +#: config/rs6000/rs6000.cc:14280 config/xtensa/xtensa.cc:2955 #, fuzzy, c-format msgid "invalid %%D value" msgstr "дрэннае %%Q значэнне" -#: config/rs6000/rs6000.cc:14152 +#: config/rs6000/rs6000.cc:14295 #, fuzzy, c-format #| msgid "invalid %%Q value" msgid "invalid %%e value" msgstr "дрэннае %%Q значэнне" -#: config/rs6000/rs6000.cc:14173 +#: config/rs6000/rs6000.cc:14316 #, c-format msgid "invalid %%f value" msgstr "" -#: config/rs6000/rs6000.cc:14182 +#: config/rs6000/rs6000.cc:14325 #, c-format msgid "invalid %%F value" msgstr "" -#: config/rs6000/rs6000.cc:14191 +#: config/rs6000/rs6000.cc:14334 #, c-format msgid "invalid %%G value" msgstr "" -#: config/rs6000/rs6000.cc:14226 +#: config/rs6000/rs6000.cc:14369 #, c-format msgid "invalid %%j code" msgstr "" -#: config/rs6000/rs6000.cc:14236 +#: config/rs6000/rs6000.cc:14379 #, c-format msgid "invalid %%J code" msgstr "" -#: config/rs6000/rs6000.cc:14246 +#: config/rs6000/rs6000.cc:14389 #, c-format msgid "invalid %%k value" msgstr "" -#: config/rs6000/rs6000.cc:14261 config/xtensa/xtensa.cc:3002 +#: config/rs6000/rs6000.cc:14404 config/xtensa/xtensa.cc:3002 #, c-format msgid "invalid %%K value" msgstr "" -#: config/rs6000/rs6000.cc:14308 +#: config/rs6000/rs6000.cc:14451 #, c-format msgid "invalid %%O value" msgstr "нерэчаіснае значэньне %%O" -#: config/rs6000/rs6000.cc:14355 +#: config/rs6000/rs6000.cc:14498 #, c-format msgid "invalid %%q value" msgstr "" -#: config/rs6000/rs6000.cc:14397 +#: config/rs6000/rs6000.cc:14540 #, fuzzy, c-format #| msgid "invalid %%Q value" msgid "invalid %%t value" msgstr "дрэннае %%Q значэнне" -#: config/rs6000/rs6000.cc:14414 +#: config/rs6000/rs6000.cc:14557 #, c-format msgid "invalid %%T value" msgstr "" -#: config/rs6000/rs6000.cc:14426 +#: config/rs6000/rs6000.cc:14569 #, c-format msgid "invalid %%u value" msgstr "" -#: config/rs6000/rs6000.cc:14440 config/xtensa/xtensa.cc:2977 +#: config/rs6000/rs6000.cc:14583 config/xtensa/xtensa.cc:2977 #, c-format msgid "invalid %%v value" msgstr "" -#: config/rs6000/rs6000.cc:14490 config/xtensa/xtensa.cc:3030 +#: config/rs6000/rs6000.cc:14633 config/xtensa/xtensa.cc:3030 #, c-format msgid "invalid %%V value" msgstr "нерэчаіснае значэньне %%V" -#: config/rs6000/rs6000.cc:14506 config/xtensa/xtensa.cc:3037 +#: config/rs6000/rs6000.cc:14652 +#, fuzzy, c-format +#| msgid "invalid %%Q value" +msgid "invalid %%W value" +msgstr "дрэннае %%Q значэнне" + +#: config/rs6000/rs6000.cc:14673 config/xtensa/xtensa.cc:3037 #, fuzzy, c-format #| msgid "invalid %%x/X value" msgid "invalid %%x value" msgstr "нерэчаіснае значэньне %%x/X" -#: config/rs6000/rs6000.cc:14563 +#: config/rs6000/rs6000.cc:14730 #, c-format msgid "invalid %%z value" msgstr "" -#: config/rs6000/rs6000.cc:14632 +#: config/rs6000/rs6000.cc:14799 #, fuzzy, c-format msgid "invalid %%y value, try using the 'Z' constraint" msgstr "нявернае выкарыстанне \"restict\"" -#: config/rs6000/rs6000.cc:14740 +#: config/rs6000/rs6000.cc:14907 #, c-format msgid "%%a requires an address of memory" msgstr "" -#: config/rs6000/rs6000.cc:15593 +#: config/rs6000/rs6000.cc:15760 msgid "Invalid mixing of IEEE 128-bit and IBM 128-bit floating point types" msgstr "" -#: config/rs6000/rs6000.cc:24411 +#: config/rs6000/rs6000.cc:24626 #, fuzzy #| msgid "too few arguments to function" msgid "AltiVec argument passed to unprototyped function" msgstr "не хапае аргументаў у функцыі" -#: config/rs6000/rs6000.cc:28012 +#: config/rs6000/rs6000.cc:28237 #, fuzzy msgid "Could not generate addis value for fusion" msgstr "Стварыць код для DLL" -#: config/rs6000/rs6000.cc:28081 +#: config/rs6000/rs6000.cc:28306 msgid "Unable to generate load/store offset for fusion" msgstr "" -#: config/rs6000/rs6000.cc:28157 +#: config/rs6000/rs6000.cc:28382 msgid "Bad GPR fusion" msgstr "" -#: config/rs6000/rs6000.cc:28805 +#: config/rs6000/rs6000.cc:29031 msgid "invalid conversion from type %<__vector_quad%>" msgstr "" -#: config/rs6000/rs6000.cc:28807 +#: config/rs6000/rs6000.cc:29033 msgid "invalid conversion to type %<__vector_quad%>" msgstr "" -#: config/rs6000/rs6000.cc:28809 +#: config/rs6000/rs6000.cc:29035 msgid "invalid conversion from type %<__vector_pair%>" msgstr "" -#: config/rs6000/rs6000.cc:28811 +#: config/rs6000/rs6000.cc:29037 msgid "invalid conversion to type %<__vector_pair%>" msgstr "" -#: config/s390/s390.cc:8894 +#: config/rs6000/rs6000.cc:29039 +msgid "invalid conversion from type %<__dmr1024%>" +msgstr "" + +#: config/rs6000/rs6000.cc:29041 +msgid "invalid conversion to type %<__dmr1024%>" +msgstr "" + +#: config/s390/s390.cc:8910 #, c-format msgid "symbolic memory references are only supported on z10 or later" msgstr "" -#: config/s390/s390.cc:8905 +#: config/s390/s390.cc:8921 #, fuzzy, c-format msgid "cannot decompose address" msgstr "невядомая назва рэгістра: %s" -#: config/s390/s390.cc:8987 +#: config/s390/s390.cc:9003 #, c-format msgid "invalid comparison operator for 'E' output modifier" msgstr "" -#: config/s390/s390.cc:9010 +#: config/s390/s390.cc:9026 #, c-format msgid "invalid reference for 'J' output modifier" msgstr "" -#: config/s390/s390.cc:9028 +#: config/s390/s390.cc:9044 #, c-format msgid "invalid address for 'O' output modifier" msgstr "" -#: config/s390/s390.cc:9045 config/s390/s390.cc:9075 config/s390/s390.cc:9104 -#: config/s390/s390.cc:9280 config/s390/s390.cc:9299 +#: config/s390/s390.cc:9061 config/s390/s390.cc:9091 config/s390/s390.cc:9120 +#: config/s390/s390.cc:9296 config/s390/s390.cc:9315 #, c-format msgid "invalid constant for output modifier '%c'" msgstr "" -#: config/s390/s390.cc:9123 +#: config/s390/s390.cc:9139 #, c-format msgid "invalid address for 'R' output modifier" msgstr "" -#: config/s390/s390.cc:9141 +#: config/s390/s390.cc:9157 #, c-format msgid "memory reference expected for 'S' output modifier" msgstr "" -#: config/s390/s390.cc:9151 +#: config/s390/s390.cc:9167 #, c-format msgid "invalid address for 'S' output modifier" msgstr "" -#: config/s390/s390.cc:9172 +#: config/s390/s390.cc:9188 #, c-format msgid "register or memory expression expected for 'N' output modifier" msgstr "" -#: config/s390/s390.cc:9183 +#: config/s390/s390.cc:9199 #, c-format msgid "register or memory expression expected for 'M' output modifier" msgstr "" -#: config/s390/s390.cc:9312 +#: config/s390/s390.cc:9328 #, c-format msgid "invalid constant vector for output modifier '%c'" msgstr "" -#: config/s390/s390.cc:9319 +#: config/s390/s390.cc:9335 #, c-format msgid "invalid expression - try using an output modifier" msgstr "" -#: config/s390/s390.cc:9322 +#: config/s390/s390.cc:9338 #, c-format msgid "invalid expression for output modifier '%c'" msgstr "" -#: config/s390/s390.cc:13175 +#: config/s390/s390.cc:13191 #, fuzzy #| msgid "too few arguments to function" msgid "vector argument passed to unprototyped function" msgstr "не хапае аргументаў у функцыі" -#: config/s390/s390.cc:17671 +#: config/s390/s390.cc:17687 msgid "types differ in signedness" msgstr "" -#: config/s390/s390.cc:17681 +#: config/s390/s390.cc:17697 msgid "binary operator does not support two vector bool operands" msgstr "" -#: config/s390/s390.cc:17684 +#: config/s390/s390.cc:17700 msgid "binary operator does not support vector bool operand" msgstr "" -#: config/s390/s390.cc:17692 +#: config/s390/s390.cc:17708 msgid "binary operator does not support mixing vector bool with floating point vector operands" msgstr "" @@ -22250,7 +22270,7 @@ msgstr "" msgid "aka" msgstr "" -#: c/c-objc-common.cc:395 c/c-typeck.cc:8303 +#: c/c-objc-common.cc:395 c/c-typeck.cc:8320 msgid "({anonymous})" msgstr "" @@ -22263,39 +22283,39 @@ msgstr "" #. ; #. <~~~~~~~~~ declaration ~~~~~~~~~~> #. Use c_parser_require to get an error with a fix-it hint. -#: c/c-parser.cc:3258 c/c-parser.cc:3467 c/c-parser.cc:3481 c/c-parser.cc:7698 -#: c/c-parser.cc:8552 c/c-parser.cc:9130 c/c-parser.cc:9322 c/c-parser.cc:9355 -#: c/c-parser.cc:9653 c/c-parser.cc:14681 c/c-parser.cc:14716 -#: c/c-parser.cc:14747 c/c-parser.cc:14794 c/c-parser.cc:14975 -#: c/c-parser.cc:15808 c/c-parser.cc:15883 c/c-parser.cc:15926 -#: c/c-parser.cc:24068 c/c-parser.cc:24148 c/c-parser.cc:24477 -#: c/c-parser.cc:24503 c/c-parser.cc:24526 c/c-parser.cc:25212 -#: c/c-parser.cc:25255 c/c-parser.cc:26529 c/gimple-parser.cc:459 +#: c/c-parser.cc:3260 c/c-parser.cc:3469 c/c-parser.cc:3483 c/c-parser.cc:7700 +#: c/c-parser.cc:8559 c/c-parser.cc:9137 c/c-parser.cc:9329 c/c-parser.cc:9362 +#: c/c-parser.cc:9660 c/c-parser.cc:14674 c/c-parser.cc:14709 +#: c/c-parser.cc:14740 c/c-parser.cc:14787 c/c-parser.cc:14968 +#: c/c-parser.cc:15801 c/c-parser.cc:15876 c/c-parser.cc:15919 +#: c/c-parser.cc:24061 c/c-parser.cc:24141 c/c-parser.cc:24470 +#: c/c-parser.cc:24496 c/c-parser.cc:24519 c/c-parser.cc:25205 +#: c/c-parser.cc:25248 c/c-parser.cc:26522 c/gimple-parser.cc:459 #: c/gimple-parser.cc:500 c/gimple-parser.cc:509 c/gimple-parser.cc:729 #: c/gimple-parser.cc:2427 c/gimple-parser.cc:2464 c/gimple-parser.cc:2543 -#: c/gimple-parser.cc:2570 c/c-parser.cc:4329 c/c-parser.cc:4520 -#: c/c-parser.cc:4555 c/c-parser.cc:14968 c/gimple-parser.cc:2234 -#: c/gimple-parser.cc:2246 cp/parser.cc:18046 cp/parser.cc:37137 -#: cp/parser.cc:37776 +#: c/gimple-parser.cc:2570 c/c-parser.cc:4331 c/c-parser.cc:4522 +#: c/c-parser.cc:4557 c/c-parser.cc:14961 c/gimple-parser.cc:2234 +#: c/gimple-parser.cc:2246 cp/parser.cc:18048 cp/parser.cc:37140 +#: cp/parser.cc:37779 #, gcc-internal-format msgid "expected %<;%>" msgstr "" -#: c/c-parser.cc:3439 c/c-parser.cc:9613 +#: c/c-parser.cc:3441 c/c-parser.cc:9620 #, gcc-internal-format msgid "expected %<:%> or %<)%>" msgstr "" -#: c/c-parser.cc:3978 c/c-parser.cc:5131 c/c-parser.cc:5323 c/c-parser.cc:5381 -#: c/c-parser.cc:5439 c/c-parser.cc:5828 c/c-parser.cc:5851 c/c-parser.cc:5860 -#: c/c-parser.cc:5911 c/c-parser.cc:5920 c/c-parser.cc:11209 -#: c/c-parser.cc:11295 c/c-parser.cc:11911 c/c-parser.cc:11937 -#: c/c-parser.cc:11971 c/c-parser.cc:12172 c/c-parser.cc:13053 -#: c/c-parser.cc:15082 c/c-parser.cc:17734 c/c-parser.cc:18469 -#: c/c-parser.cc:18528 c/c-parser.cc:18583 c/c-parser.cc:20655 -#: c/c-parser.cc:20947 c/c-parser.cc:21099 c/c-parser.cc:23160 -#: c/c-parser.cc:24568 c/c-parser.cc:25220 c/c-parser.cc:29190 -#: c/c-parser.cc:29458 c/c-parser.cc:29540 c/gimple-parser.cc:238 +#: c/c-parser.cc:3980 c/c-parser.cc:5133 c/c-parser.cc:5325 c/c-parser.cc:5383 +#: c/c-parser.cc:5441 c/c-parser.cc:5830 c/c-parser.cc:5853 c/c-parser.cc:5862 +#: c/c-parser.cc:5913 c/c-parser.cc:5922 c/c-parser.cc:11220 +#: c/c-parser.cc:11306 c/c-parser.cc:11922 c/c-parser.cc:11948 +#: c/c-parser.cc:11982 c/c-parser.cc:12183 c/c-parser.cc:13064 +#: c/c-parser.cc:15075 c/c-parser.cc:17727 c/c-parser.cc:18462 +#: c/c-parser.cc:18521 c/c-parser.cc:18576 c/c-parser.cc:20648 +#: c/c-parser.cc:20940 c/c-parser.cc:21092 c/c-parser.cc:23153 +#: c/c-parser.cc:24561 c/c-parser.cc:25213 c/c-parser.cc:29183 +#: c/c-parser.cc:29451 c/c-parser.cc:29533 c/gimple-parser.cc:238 #: c/gimple-parser.cc:241 c/gimple-parser.cc:594 c/gimple-parser.cc:628 #: c/gimple-parser.cc:633 c/gimple-parser.cc:814 c/gimple-parser.cc:911 #: c/gimple-parser.cc:1135 c/gimple-parser.cc:1161 c/gimple-parser.cc:1164 @@ -22303,153 +22323,153 @@ msgstr "" #: c/gimple-parser.cc:1571 c/gimple-parser.cc:1648 c/gimple-parser.cc:1681 #: c/gimple-parser.cc:1711 c/gimple-parser.cc:1737 c/gimple-parser.cc:1944 #: c/gimple-parser.cc:2156 c/gimple-parser.cc:2176 c/gimple-parser.cc:2337 -#: c/gimple-parser.cc:2500 c/c-parser.cc:3430 c/c-parser.cc:9605 -#: c/c-parser.cc:21763 cp/parser.cc:37824 cp/parser.cc:46187 +#: c/gimple-parser.cc:2500 c/c-parser.cc:3432 c/c-parser.cc:9612 +#: c/c-parser.cc:21756 cp/parser.cc:37827 cp/parser.cc:46190 #, gcc-internal-format msgid "expected %<)%>" msgstr "" -#: c/c-parser.cc:5217 c/c-parser.cc:5971 c/c-parser.cc:6328 c/c-parser.cc:6346 -#: c/c-parser.cc:6347 c/c-parser.cc:6856 c/c-parser.cc:6900 c/c-parser.cc:9704 -#: c/c-parser.cc:12163 c/c-parser.cc:13626 c/c-parser.cc:13999 -#: c/c-parser.cc:17056 c/gimple-parser.cc:1920 cp/parser.cc:37788 +#: c/c-parser.cc:5219 c/c-parser.cc:5973 c/c-parser.cc:6330 c/c-parser.cc:6348 +#: c/c-parser.cc:6349 c/c-parser.cc:6858 c/c-parser.cc:6902 c/c-parser.cc:9711 +#: c/c-parser.cc:12174 c/c-parser.cc:13637 c/c-parser.cc:14010 +#: c/c-parser.cc:17049 c/gimple-parser.cc:1920 cp/parser.cc:37791 #, gcc-internal-format msgid "expected %<]%>" msgstr "" -#: c/c-parser.cc:5419 +#: c/c-parser.cc:5421 msgid "expected %<;%>, %<,%> or %<)%>" msgstr "" #. Look for the two `(' tokens. -#: c/c-parser.cc:5880 c/c-parser.cc:5885 c/c-parser.cc:17717 -#: c/c-parser.cc:18558 c/c-parser.cc:20637 c/c-parser.cc:21571 -#: c/c-parser.cc:21670 c/c-parser.cc:27888 c/c-parser.cc:28209 -#: c/c-parser.cc:29112 c/c-parser.cc:29266 c/c-parser.cc:29483 +#: c/c-parser.cc:5882 c/c-parser.cc:5887 c/c-parser.cc:17710 +#: c/c-parser.cc:18551 c/c-parser.cc:20630 c/c-parser.cc:21564 +#: c/c-parser.cc:21663 c/c-parser.cc:27881 c/c-parser.cc:28202 +#: c/c-parser.cc:29105 c/c-parser.cc:29259 c/c-parser.cc:29476 #: c/gimple-parser.cc:223 c/gimple-parser.cc:541 c/gimple-parser.cc:580 #: c/gimple-parser.cc:612 c/gimple-parser.cc:881 c/gimple-parser.cc:1129 #: c/gimple-parser.cc:1155 c/gimple-parser.cc:1282 c/gimple-parser.cc:1417 #: c/gimple-parser.cc:1545 c/gimple-parser.cc:1677 c/gimple-parser.cc:1695 #: c/gimple-parser.cc:1730 c/gimple-parser.cc:2125 c/gimple-parser.cc:2136 #: c/gimple-parser.cc:2142 c/gimple-parser.cc:2325 c/gimple-parser.cc:2497 -#: c/c-parser.cc:11068 c/c-parser.cc:17498 cp/parser.cc:37779 +#: c/c-parser.cc:11079 c/c-parser.cc:17491 cp/parser.cc:37782 #, gcc-internal-format msgid "expected %<(%>" msgstr "" -#: c/c-parser.cc:6324 c/c-parser.cc:6326 c/c-parser.cc:16961 cp/parser.cc:37791 -#: cp/parser.cc:41694 go/gofrontend/embed.cc:440 +#: c/c-parser.cc:6326 c/c-parser.cc:6328 c/c-parser.cc:16954 cp/parser.cc:37794 +#: cp/parser.cc:41697 go/gofrontend/embed.cc:440 #, gcc-internal-format msgid "expected %<[%>" msgstr "" -#: c/c-parser.cc:7160 c/c-parser.cc:15311 c/c-parser.cc:21647 -#: c/c-parser.cc:24043 c/c-parser.cc:24129 c/c-parser.cc:24890 -#: c/c-parser.cc:26036 c/c-parser.cc:31332 c/gimple-parser.cc:452 -#: c/gimple-parser.cc:2503 c/c-parser.cc:4316 c/c-parser.cc:4544 -#: c/c-parser.cc:14863 cp/parser.cc:23969 cp/parser.cc:37785 +#: c/c-parser.cc:7162 c/c-parser.cc:15304 c/c-parser.cc:21640 +#: c/c-parser.cc:24036 c/c-parser.cc:24122 c/c-parser.cc:24883 +#: c/c-parser.cc:26029 c/c-parser.cc:31325 c/gimple-parser.cc:452 +#: c/gimple-parser.cc:2503 c/c-parser.cc:4318 c/c-parser.cc:4546 +#: c/c-parser.cc:14856 cp/parser.cc:23971 cp/parser.cc:37788 #: go/gofrontend/embed.cc:371 #, gcc-internal-format msgid "expected %<{%>" msgstr "" -#: c/c-parser.cc:8110 c/c-parser.cc:8119 c/c-parser.cc:10153 -#: c/c-parser.cc:11463 c/c-parser.cc:15075 c/c-parser.cc:15472 -#: c/c-parser.cc:15536 c/c-parser.cc:17038 c/c-parser.cc:18149 -#: c/c-parser.cc:18386 c/c-parser.cc:18948 c/c-parser.cc:19051 -#: c/c-parser.cc:19592 c/c-parser.cc:19760 c/c-parser.cc:20298 -#: c/c-parser.cc:20374 c/c-parser.cc:20505 c/c-parser.cc:20577 -#: c/c-parser.cc:20657 c/c-parser.cc:21330 c/c-parser.cc:21885 -#: c/c-parser.cc:27747 c/c-parser.cc:29139 c/c-parser.cc:29323 -#: c/c-parser.cc:29382 c/c-parser.cc:30618 c/gimple-parser.cc:635 +#: c/c-parser.cc:8117 c/c-parser.cc:8126 c/c-parser.cc:10160 +#: c/c-parser.cc:11474 c/c-parser.cc:15068 c/c-parser.cc:15465 +#: c/c-parser.cc:15529 c/c-parser.cc:17031 c/c-parser.cc:18142 +#: c/c-parser.cc:18379 c/c-parser.cc:18941 c/c-parser.cc:19044 +#: c/c-parser.cc:19585 c/c-parser.cc:19753 c/c-parser.cc:20291 +#: c/c-parser.cc:20367 c/c-parser.cc:20498 c/c-parser.cc:20570 +#: c/c-parser.cc:20650 c/c-parser.cc:21323 c/c-parser.cc:21878 +#: c/c-parser.cc:27740 c/c-parser.cc:29132 c/c-parser.cc:29316 +#: c/c-parser.cc:29375 c/c-parser.cc:30611 c/gimple-parser.cc:635 #: c/gimple-parser.cc:950 c/gimple-parser.cc:1632 c/gimple-parser.cc:2551 -#: c/gimple-parser.cc:2578 c/c-parser.cc:9612 c/c-parser.cc:17642 -#: c/c-parser.cc:19056 cp/parser.cc:37818 cp/parser.cc:39534 cp/parser.cc:42634 -#: cp/parser.cc:43538 go/gofrontend/embed.cc:404 +#: c/gimple-parser.cc:2578 c/c-parser.cc:9619 c/c-parser.cc:17635 +#: c/c-parser.cc:19049 cp/parser.cc:37821 cp/parser.cc:39537 cp/parser.cc:42637 +#: cp/parser.cc:43541 go/gofrontend/embed.cc:404 #, gcc-internal-format msgid "expected %<:%>" msgstr "" -#: c/c-parser.cc:9106 cp/parser.cc:37705 +#: c/c-parser.cc:9113 cp/parser.cc:37708 #, gcc-internal-format msgid "expected %" msgstr "" -#: c/c-parser.cc:11172 c/c-parser.cc:11411 c/c-parser.cc:11961 -#: c/c-parser.cc:12000 c/c-parser.cc:12093 c/c-parser.cc:12234 -#: c/c-parser.cc:13043 c/c-parser.cc:18563 c/c-parser.cc:20443 +#: c/c-parser.cc:11183 c/c-parser.cc:11422 c/c-parser.cc:11972 +#: c/c-parser.cc:12011 c/c-parser.cc:12104 c/c-parser.cc:12245 +#: c/c-parser.cc:13054 c/c-parser.cc:18556 c/c-parser.cc:20436 #: c/gimple-parser.cc:1132 c/gimple-parser.cc:1158 c/gimple-parser.cc:1286 #: c/gimple-parser.cc:1289 c/gimple-parser.cc:1699 c/gimple-parser.cc:1705 -#: cp/parser.cc:37135 cp/parser.cc:37794 +#: cp/parser.cc:37138 cp/parser.cc:37797 #, gcc-internal-format msgid "expected %<,%>" msgstr "" -#: c/c-parser.cc:11855 +#: c/c-parser.cc:11866 msgid "expected %<.%>" msgstr "" -#: c/c-parser.cc:14534 c/c-parser.cc:14566 c/c-parser.cc:14806 -#: cp/parser.cc:40108 cp/parser.cc:40129 +#: c/c-parser.cc:14527 c/c-parser.cc:14559 c/c-parser.cc:14799 +#: cp/parser.cc:40111 cp/parser.cc:40132 #, gcc-internal-format msgid "expected %<@end%>" msgstr "" -#: c/c-parser.cc:15224 c/gimple-parser.cc:1457 cp/parser.cc:37803 +#: c/c-parser.cc:15217 c/gimple-parser.cc:1457 cp/parser.cc:37806 #, gcc-internal-format msgid "expected %<>%>" msgstr "" -#: c/c-parser.cc:19146 c/c-parser.cc:21117 c/c-parser.cc:21634 -#: cp/parser.cc:37827 cp/parser.cc:46038 +#: c/c-parser.cc:19139 c/c-parser.cc:21110 c/c-parser.cc:21627 +#: cp/parser.cc:37830 cp/parser.cc:46041 #, gcc-internal-format msgid "expected %<,%> or %<)%>" msgstr "" #. All following cases are statements with LHS. -#: c/c-parser.cc:20290 c/c-parser.cc:23938 c/c-parser.cc:23983 -#: c/c-parser.cc:24140 c/c-parser.cc:24487 c/c-parser.cc:25199 -#: c/c-parser.cc:26412 c/c-parser.cc:27936 c/c-parser.cc:29524 -#: c/gimple-parser.cc:805 c/c-parser.cc:6923 c/c-parser.cc:24060 -#: c/c-parser.cc:24283 cp/parser.cc:37806 cp/parser.cc:47748 cp/parser.cc:47921 +#: c/c-parser.cc:20283 c/c-parser.cc:23931 c/c-parser.cc:23976 +#: c/c-parser.cc:24133 c/c-parser.cc:24480 c/c-parser.cc:25192 +#: c/c-parser.cc:26405 c/c-parser.cc:27929 c/c-parser.cc:29517 +#: c/gimple-parser.cc:805 c/c-parser.cc:6925 c/c-parser.cc:24053 +#: c/c-parser.cc:24276 cp/parser.cc:37809 cp/parser.cc:47751 cp/parser.cc:47924 #, gcc-internal-format msgid "expected %<=%>" msgstr "" -#: c/c-parser.cc:21784 c/c-parser.cc:28218 c/c-parser.cc:28239 -#: c/c-parser.cc:17096 c/c-parser.cc:17108 c/c-parser.cc:21764 -#: cp/parser.cc:46188 cp/parser.cc:46215 cp/parser.cc:53866 cp/parser.cc:53877 +#: c/c-parser.cc:21777 c/c-parser.cc:28211 c/c-parser.cc:28232 +#: c/c-parser.cc:17089 c/c-parser.cc:17101 c/c-parser.cc:21757 +#: cp/parser.cc:46191 cp/parser.cc:46218 cp/parser.cc:53869 cp/parser.cc:53880 #, gcc-internal-format msgid "expected %<)%> or %<,%>" msgstr "" -#: c/c-parser.cc:24071 c/c-parser.cc:24151 c/c-parser.cc:24504 -#: c/c-parser.cc:24959 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785 -#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37782 -#: cp/parser.cc:40318 +#: c/c-parser.cc:24064 c/c-parser.cc:24144 c/c-parser.cc:24497 +#: c/c-parser.cc:24952 c/gimple-parser.cc:1753 c/gimple-parser.cc:1785 +#: c/gimple-parser.cc:1795 c/gimple-parser.cc:2588 cp/parser.cc:37785 +#: cp/parser.cc:40321 #, gcc-internal-format msgid "expected %<}%>" msgstr "" -#: c/c-parser.cc:24164 cp/parser.cc:47846 +#: c/c-parser.cc:24157 cp/parser.cc:47849 #, gcc-internal-format msgid "expected %" msgstr "" -#: c/c-parser.cc:26083 c/c-parser.cc:26072 cp/parser.cc:50807 +#: c/c-parser.cc:26076 c/c-parser.cc:26065 cp/parser.cc:50810 #, gcc-internal-format msgid "expected %<#pragma omp section%> or %<}%>" msgstr "" -#: c/c-parser.cc:30216 cp/parser.cc:56118 +#: c/c-parser.cc:30209 cp/parser.cc:56121 msgid "" msgstr "" -#: c/c-typeck.cc:10466 +#: c/c-typeck.cc:10483 msgid "(anonymous)" msgstr "" -#: c/gimple-parser.cc:1446 cp/parser.cc:21232 cp/parser.cc:37800 +#: c/gimple-parser.cc:1446 cp/parser.cc:21234 cp/parser.cc:37803 #, gcc-internal-format msgid "expected %<<%>" msgstr "" @@ -22465,26 +22485,26 @@ msgstr "" msgid "Driving: (" msgstr "" -#: cp/call.cc:4281 +#: cp/call.cc:4285 #, c-format msgid "candidate %i:" msgstr "" -#: cp/call.cc:8590 +#: cp/call.cc:8594 msgid " after user-defined conversion:" msgstr "" -#: cp/call.cc:8800 cp/pt.cc:27894 +#: cp/call.cc:8804 cp/pt.cc:27963 msgid "candidate is:" msgid_plural "candidates are:" msgstr[0] "" msgstr[1] "" -#: cp/call.cc:13469 cp/call.cc:13921 +#: cp/call.cc:13481 cp/call.cc:13933 msgid "candidate 1:" msgstr "" -#: cp/call.cc:13471 cp/call.cc:13922 +#: cp/call.cc:13483 cp/call.cc:13934 msgid "candidate 2:" msgstr "" @@ -22500,424 +22520,424 @@ msgstr "" msgid "" msgstr "" -#: cp/error.cc:894 +#: cp/error.cc:896 #, fuzzy #| msgid "parse error" msgid "" msgstr "граматычная памылка" #. A lambda's "type" is essentially its signature. -#: cp/error.cc:1001 +#: cp/error.cc:1003 msgid "" msgstr "" -#: cp/error.cc:1017 +#: cp/error.cc:1019 #, c-format msgid "" msgstr "" -#: cp/error.cc:1158 +#: cp/error.cc:1160 msgid "" msgstr "" -#: cp/error.cc:1302 +#: cp/error.cc:1304 #, fuzzy, c-format msgid "(static initializers for %s)" msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" -#: cp/error.cc:1304 +#: cp/error.cc:1306 #, c-format msgid "(static destructors for %s)" msgstr "" -#: cp/error.cc:1375 +#: cp/error.cc:1377 #, fuzzy #| msgid "structure" msgid "" msgstr "структура" -#: cp/error.cc:1501 +#: cp/error.cc:1503 msgid "vtable for " msgstr "" -#: cp/error.cc:1525 +#: cp/error.cc:1527 msgid " " msgstr "" -#: cp/error.cc:1540 +#: cp/error.cc:1542 msgid "{anonymous}" msgstr "" -#: cp/error.cc:1542 +#: cp/error.cc:1544 #, fuzzy msgid "(anonymous namespace)" msgstr "невядомы рэжым машыны \"%s\"" -#: cp/error.cc:1641 +#: cp/error.cc:1643 #, fuzzy msgid "