diff -Nru gcc-10-10.2.0/debian/changelog gcc-10-10.2.0/debian/changelog --- gcc-10-10.2.0/debian/changelog 2020-07-25 15:57:15.000000000 +0000 +++ gcc-10-10.2.0/debian/changelog 2020-08-08 12:12:50.000000000 +0000 @@ -1,8 +1,27 @@ -gcc-10 (10.2.0-3ubuntu1~20.04) focal-proposed; urgency=medium +gcc-10 (10.2.0-5ubuntu1~20.04) focal-proposed; urgency=medium * SRU: LP: #1879481. Update to the GCC 10.2.0 release. - -- Matthias Klose Sat, 25 Jul 2020 17:57:15 +0200 + -- Matthias Klose Sat, 08 Aug 2020 14:12:50 +0200 + +gcc-10 (10.2.0-5ubuntu1) groovy; urgency=medium + + * Merge with Debian; remaining changes: + - Build from upstream sources. + + -- Matthias Klose Sat, 08 Aug 2020 13:42:26 +0200 + +gcc-10 (10.2.0-5) unstable; urgency=medium + + * Update to git 20200808 from the gcc-10 branch. + - Fix PR target/96191 (ARM), PR target/96191 (AArch64), + PR tree-optimization/96483, PR middle-end/96426, PR debug/96354, + PR target/95435 (x86), PR tree-optimization/96058, PR middle-end/96335, + PR lto/45375, PR c/96377, PR c++/96082, PR c++/95591, PR c++/95599, + PR c++/95823, PR c++/95824, PR c++/95895, PR d/96140, + PR fortran/96319, PR fortran/95612, PR fortran/95585. + + -- Matthias Klose Sat, 08 Aug 2020 13:31:03 +0200 gcc-10 (10.2.0-3ubuntu1) groovy; urgency=medium diff -Nru gcc-10-10.2.0/debian/patches/git-doc-updates.diff gcc-10-10.2.0/debian/patches/git-doc-updates.diff --- gcc-10-10.2.0/debian/patches/git-doc-updates.diff 2020-07-23 08:31:58.000000000 +0000 +++ gcc-10-10.2.0/debian/patches/git-doc-updates.diff 2020-08-08 11:41:43.000000000 +0000 @@ -1,7 +1,147 @@ -# DP: updates from the 10 branch upto 20200525 (documentation). +# DP: updates from the 10 branch upto 20200808 (documentation). LANG=C git diff --no-renames --src-prefix=a/src/ --dst-prefix=b/src/ \ - 6e6e3f144a33ae504149dc992453b4f6dea12fdb ca502d7b3c16ef9fa007263aee078b1e451c1eb4 \ + ee5c3db6c5b2c3332912fb4c9cfa2864569ebd9a 931fe8394c6d6bdb6aa957b760767d7928ffaa15 \ | awk '/^diff .*\.texi/ {skip=0; print; next} /^diff / {skip=1; next} skip==0' \ | grep -v -E '^(diff|index)' +--- a/src/gcc/doc/cpp.texi ++++ b/src/gcc/doc/cpp.texi +@@ -1631,7 +1631,7 @@ a function can. The syntax for defining the macro is similar to that of + a function. Here is an example: + + @smallexample +-#define eprintf(@dots{}) fprintf (stderr, __VA_ARGS__) ++#define eprintf(...) fprintf (stderr, __VA_ARGS__) + @end smallexample + + This kind of macro is called @dfn{variadic}. When the macro is invoked, +@@ -1655,11 +1655,11 @@ below for an important special case for @samp{##}.) + If your macro is complicated, you may want a more descriptive name for + the variable argument than @code{@w{__VA_ARGS__}}. CPP permits + this, as an extension. You may write an argument name immediately +-before the @samp{@dots{}}; that name is used for the variable argument. ++before the @samp{...}; that name is used for the variable argument. + The @code{eprintf} macro above could be written + + @smallexample +-#define eprintf(args@dots{}) fprintf (stderr, args) ++#define eprintf(args...) fprintf (stderr, args) + @end smallexample + + @noindent +@@ -1670,7 +1670,7 @@ You can have named arguments as well as variable arguments in a variadic + macro. We could define @code{eprintf} like this, instead: + + @smallexample +-#define eprintf(format, @dots{}) fprintf (stderr, format, __VA_ARGS__) ++#define eprintf(format, ...) fprintf (stderr, format, __VA_ARGS__) + @end smallexample + + @noindent +@@ -1709,7 +1709,7 @@ invocation expands to its argument; but if the variable argument does + not have any tokens, the @code{@w{__VA_OPT__}} expands to nothing: + + @smallexample +-#define eprintf(format, @dots{}) \ ++#define eprintf(format, ...) \ + fprintf (stderr, format __VA_OPT__(,) __VA_ARGS__) + @end smallexample + +@@ -1722,7 +1722,7 @@ the introduction of @code{@w{__VA_OPT__}}, this extension remains + supported in GNU CPP, for backward compatibility. If you write + + @smallexample +-#define eprintf(format, @dots{}) fprintf (stderr, format, ##__VA_ARGS__) ++#define eprintf(format, ...) fprintf (stderr, format, ##__VA_ARGS__) + @end smallexample + + @noindent +@@ -1758,7 +1758,7 @@ replacement list of a variadic macro. + Variadic macros became a standard part of the C language with C99. + GNU CPP previously supported them + with a named variable argument +-(@samp{args@dots{}}, not @samp{@dots{}} and @code{@w{__VA_ARGS__}}), which ++(@samp{args...}, not @samp{...} and @code{@w{__VA_ARGS__}}), which + is still supported for backward compatibility. + + @node Predefined Macros +--- a/src/gcc/doc/extend.texi ++++ b/src/gcc/doc/extend.texi +@@ -3715,6 +3715,7 @@ Function Attributes}, @ref{PowerPC Function Attributes}, + for details. + + @item symver ("@var{name2}@@@var{nodename}") ++@cindex @code{symver} function attribute + On ELF targets this attribute creates a symbol version. The @var{name2} part + of the parameter is the actual name of the symbol by which it will be + externally referenced. The @code{nodename} portion should be the name of a +--- a/src/gcc/doc/invoke.texi ++++ b/src/gcc/doc/invoke.texi +@@ -696,6 +696,7 @@ Objective-C and Objective-C++ Dialects}. + -msign-return-address=@var{scope} @gol + -mbranch-protection=@var{none}|@var{standard}|@var{pac-ret}[+@var{leaf} + +@var{b-key}]|@var{bti} @gol ++-mharden-sls=@var{opts} @gol + -march=@var{name} -mcpu=@var{name} -mtune=@var{name} @gol + -moverride=@var{string} -mverbose-cost-dump @gol + -mstack-protector-guard=@var{guard} -mstack-protector-guard-reg=@var{sysreg} @gol +@@ -16975,7 +16976,8 @@ performance of the code. Permissible values for this option are: + @samp{octeontx81}, @samp{octeontx83}, + @samp{octeontx2}, @samp{octeontx2t98}, @samp{octeontx2t96} + @samp{octeontx2t93}, @samp{octeontx2f95}, @samp{octeontx2f95n}, +-@samp{octeontx2f95mm} ++@samp{octeontx2f95mm}, ++@samp{a64fx}, + @samp{thunderx}, @samp{thunderxt88}, + @samp{thunderxt88p1}, @samp{thunderxt81}, @samp{tsv110}, + @samp{thunderxt83}, @samp{thunderx2t99}, @samp{thunderx3t110}, @samp{zeus}, +@@ -17065,6 +17067,17 @@ functions. The optional argument @samp{b-key} can be used to sign the functions + with the B-key instead of the A-key. + @samp{bti} turns on branch target identification mechanism. + ++@item -mharden-sls=@var{opts} ++@opindex mharden-sls ++Enable compiler hardening against straight line speculation (SLS). ++@var{opts} is a comma-separated list of the following options: ++@table @samp ++@item retbr ++@item blr ++@end table ++In addition, @samp{-mharden-sls=all} enables all SLS hardening while ++@samp{-mharden-sls=none} disables all SLS hardening. ++ + @item -msve-vector-bits=@var{bits} + @opindex msve-vector-bits + Specify the number of bits in an SVE vector register. This option only has +--- a/src/gcc/doc/sourcebuild.texi ++++ b/src/gcc/doc/sourcebuild.texi +@@ -1244,6 +1244,18 @@ This DejaGnu directive compares @var{regexp} to the combined output + that the test executable writes to @file{stdout} and @file{stderr}. + @end table + ++@subsubsection Specify environment variables for a test ++ ++@table @code ++@item @{ dg-set-compiler-env-var @var{var_name} "@var{var_value}" @} ++Specify that the environment variable @var{var_name} needs to be set ++to @var{var_value} before invoking the compiler on the test file. ++ ++@item @{ dg-set-target-env-var @var{var_name} "@var{var_value}" @} ++Specify that the environment variable @var{var_name} needs to be set ++to @var{var_value} before execution of the program created by the test. ++@end table ++ + @subsubsection Specify additional files for a test + + @table @code +@@ -2030,6 +2042,9 @@ whether it does so by default). + @itemx aarch64_sve2048_hw + Like @code{aarch64_sve_hw}, but also test for an exact hardware vector length. + ++@item aarch64_fjcvtzs_hw ++AArch64 target that is able to generate and execute armv8.3-a FJCVTZS ++instruction. + @end table + + @subsubsection MIPS-specific attributes diff -Nru gcc-10-10.2.0/debian/patches/git-updates.diff gcc-10-10.2.0/debian/patches/git-updates.diff --- gcc-10-10.2.0/debian/patches/git-updates.diff 2020-07-25 11:35:23.000000000 +0000 +++ gcc-10-10.2.0/debian/patches/git-updates.diff 2020-08-08 11:41:43.000000000 +0000 @@ -1,13 +1,17 @@ -# DP: updates from the 10 branch upto 20200725 (8dafc134683). +# DP: updates from the 10 branch upto 20200808 (931fe8394c6). LANG=C git diff --no-renames --src-prefix=a/src/ --dst-prefix=b/src/ \ - ee5c3db6c5b2c3332912fb4c9cfa2864569ebd9a 8dafc134683a1aa5538b99d1677dec72779cd45c \ + ee5c3db6c5b2c3332912fb4c9cfa2864569ebd9a 931fe8394c6d6bdb6aa957b760767d7928ffaa15 \ | awk '/^diff .*\.texi/ {skip=1; next} /^diff / { skip=0 } skip==0' \ | grep -v -E '^(diff|index)' --- a/src/contrib/ChangeLog +++ b/src/contrib/ChangeLog -@@ -1,3 +1,18 @@ +@@ -1,3 +1,22 @@ ++2020-07-29 Martin Liska ++ ++ * git-backport.py: fix how are ChangeLog paths combined. ++ +2020-07-23 Martin Liska + + Backported from master: @@ -81,9 +85,287 @@ if os.path.exists(full_path): with open(full_path) as f: content = f.read() +--- a/src/contrib/git-backport.py ++++ b/src/contrib/git-backport.py +@@ -46,7 +46,7 @@ if __name__ == '__main__': + conflicts = out.strip().split('\n') + changelogs = [c for c in conflicts if c.endswith('ChangeLog')] + if changelogs: +- cmd = 'git checkout --theirs %s' % '\n'.join(changelogs) ++ cmd = 'git checkout --theirs %s' % ' '.join(changelogs) + subprocess.check_output(cmd, shell=True) + # 2) remove all ChangeLog files from index + cmd = 'git diff --name-only --diff-filter=M HEAD' --- a/src/gcc/ChangeLog +++ b/src/gcc/ChangeLog -@@ -1,3 +1,34 @@ +@@ -1,3 +1,301 @@ ++2020-08-07 Tamar Christina ++ ++ Backported from master: ++ 2020-08-03 Tamar Christina ++ ++ * config/aarch64/driver-aarch64.c (readline): Check return value fgets. ++ ++2020-08-07 Tamar Christina ++ ++ Backported from master: ++ 2020-07-17 Tamar Christina ++ ++ * doc/sourcebuild.texi (dg-set-compiler-env-var, ++ dg-set-target-env-var): Document. ++ ++2020-08-07 Tamar Christina ++ ++ Backported from master: ++ 2020-07-17 Tamar Christina ++ ++ * config/arm/driver-arm.c (host_detect_local_cpu): Add GCC_CPUINFO. ++ ++2020-08-07 Tamar Christina ++ ++ Backported from master: ++ 2020-07-17 Tamar Christina ++ ++ * config/aarch64/driver-aarch64.c (host_detect_local_cpu): ++ Add GCC_CPUINFO. ++ ++2020-08-07 Tamar Christina ++ ++ Backported from master: ++ 2020-07-17 Tamar Christina ++ ++ * config/aarch64/driver-aarch64.c (INCLUDE_SET): New. ++ (parse_field): Use std::string. ++ (split_words, readline, find_field): New. ++ (host_detect_local_cpu): Fix truncation issues. ++ ++2020-08-07 Richard Sandiford ++ ++ Backported from master: ++ 2020-08-06 Richard Sandiford ++ ++ PR target/96191 ++ * config/arm/arm.md (arm_stack_protect_test_insn): Zero out ++ operand 2 after use. ++ * config/arm/thumb1.md (thumb1_stack_protect_test_insn): Likewise. ++ ++2020-08-07 Richard Sandiford ++ ++ Backported from master: ++ 2020-08-05 Richard Sandiford ++ ++ PR target/96191 ++ * config/aarch64/aarch64.md (stack_protect_test_): Set the ++ CC register directly, instead of a GPR. Replace the original GPR ++ destination with an extra scratch register. Zero out operand 3 ++ after use. ++ (stack_protect_test): Update accordingly. ++ ++2020-08-06 Richard Biener ++ ++ Backported from master: ++ 2020-08-06 Richard Biener ++ ++ PR tree-optimization/96483 ++ * tree-ssa-pre.c (create_component_ref_by_pieces_1): Handle ++ POLY_INT_CST. ++ ++2020-08-04 Jakub Jelinek ++ ++ Backported from master: ++ 2020-08-04 Jakub Jelinek ++ ++ * doc/extend.texi (symver): Add @cindex for symver function attribute. ++ ++2020-08-04 Matthew Malcomson ++ ++ * config/aarch64/aarch64-protos.h (aarch64_indirect_call_asm): ++ New declaration. ++ * config/aarch64/aarch64.c (aarch64_regno_regclass): Handle new ++ stub registers class. ++ (aarch64_class_max_nregs): Likewise. ++ (aarch64_register_move_cost): Likewise. ++ (aarch64_sls_shared_thunks): Global array to store stub labels. ++ (aarch64_sls_emit_function_stub): New. ++ (aarch64_create_blr_label): New. ++ (aarch64_sls_emit_blr_function_thunks): New. ++ (aarch64_sls_emit_shared_blr_thunks): New. ++ (aarch64_asm_file_end): New. ++ (aarch64_indirect_call_asm): New. ++ (TARGET_ASM_FILE_END): Use aarch64_asm_file_end. ++ (TARGET_ASM_FUNCTION_EPILOGUE): Use ++ aarch64_sls_emit_blr_function_thunks. ++ * config/aarch64/aarch64.h (STB_REGNUM_P): New. ++ (enum reg_class): Add STUB_REGS class. ++ (machine_function): Introduce `call_via` array for ++ function-local stub labels. ++ * config/aarch64/aarch64.md (*call_insn, *call_value_insn): Use ++ aarch64_indirect_call_asm to emit code when hardening BLR ++ instructions. ++ * config/aarch64/constraints.md (Ucr): New constraint ++ representing registers for indirect calls. Is GENERAL_REGS ++ usually, and STUB_REGS when hardening BLR instruction against ++ SLS. ++ * config/aarch64/predicates.md (aarch64_general_reg): STUB_REGS class ++ is also a general register. ++ ++2020-08-04 Matthew Malcomson ++ ++ * config/aarch64/aarch64-protos.h (aarch64_sls_barrier): New. ++ * config/aarch64/aarch64.c (aarch64_output_casesi): Emit ++ speculation barrier after BR instruction if needs be. ++ (aarch64_trampoline_init): Handle ptr_mode value & adjust size ++ of code copied. ++ (aarch64_sls_barrier): New. ++ (aarch64_asm_trampoline_template): Add needed barriers. ++ * config/aarch64/aarch64.h (AARCH64_ISA_SB): New. ++ (TARGET_SB): New. ++ (TRAMPOLINE_SIZE): Account for barrier. ++ * config/aarch64/aarch64.md (indirect_jump, *casesi_dispatch, ++ simple_return, *do_return, *sibcall_insn, *sibcall_value_insn): ++ Emit barrier if needs be, also account for possible barrier using ++ "sls_length" attribute. ++ (sls_length): New attribute. ++ (length): Determine default using any non-default sls_length ++ value. ++ ++2020-08-04 Matthew Malcomson ++ ++ * config/aarch64/aarch64-protos.h (aarch64_harden_sls_retbr_p): ++ New. ++ (aarch64_harden_sls_blr_p): New. ++ * config/aarch64/aarch64.c (enum aarch64_sls_hardening_type): ++ New. ++ (aarch64_harden_sls_retbr_p): New. ++ (aarch64_harden_sls_blr_p): New. ++ (aarch64_validate_sls_mitigation): New. ++ (aarch64_override_options): Parse options for SLS mitigation. ++ * config/aarch64/aarch64.opt (-mharden-sls): New option. ++ * doc/invoke.texi: Document new option. ++ ++2020-08-04 Andrea Corallo ++ ++ Backported from master: ++ 2020-08-04 Andrea Corallo ++ ++ * config/aarch64/aarch64.md (aarch64_fjcvtzs): Add missing ++ clobber. ++ * doc/sourcebuild.texi (aarch64_fjcvtzs_hw) Document new ++ target supports option. ++ ++2020-08-04 Jakub Jelinek ++ ++ Backported from master: ++ 2020-08-04 Jakub Jelinek ++ ++ PR middle-end/96426 ++ * tree-vect-generic.c (expand_vector_conversion): Replace .VEC_CONVERT ++ call with GIMPLE_NOP if there is no lhs. ++ ++2020-08-04 Jakub Jelinek ++ ++ Backported from master: ++ 2020-08-04 Jakub Jelinek ++ ++ PR debug/96354 ++ * gimple-fold.c (maybe_canonicalize_mem_ref_addr): Add IS_DEBUG ++ argument. Return false instead of gcc_unreachable if it is true and ++ get_addr_base_and_unit_offset returns NULL. ++ (fold_stmt_1) : Adjust caller. ++ ++2020-08-03 Jonathan Wakely ++ ++ Backported from master: ++ 2020-08-03 Jonathan Wakely ++ ++ * doc/cpp.texi (Variadic Macros): Use the exact ... token in ++ code examples. ++ ++2020-08-03 Richard Sandiford ++ ++ Backported from master: ++ 2020-08-03 Richard Sandiford ++ ++ * doc/invoke.texi: Add missing comma after octeontx2f95mm entry. ++ ++2020-08-03 Qian Jianhua ++ ++ Backported from master: ++ 2020-08-03 Qian jianhua ++ ++ * config/aarch64/aarch64-cores.def (a64fx): New core. ++ * config/aarch64/aarch64-tune.md: Regenerated. ++ * config/aarch64/aarch64.c (a64fx_prefetch_tune, a64fx_tunings): New. ++ * doc/invoke.texi: Add a64fx to the list. ++ ++2020-07-31 Martin Liska ++ ++ Backported from master: ++ 2020-07-31 Martin Liska ++ ++ * cgraph.h: Remove leading empty lines. ++ * cgraphunit.c (enum cgraph_order_sort_kind): Remove ++ ORDER_UNDEFINED. ++ (struct cgraph_order_sort): Add constructors. ++ (cgraph_order_sort::process): New. ++ (cgraph_order_cmp): New. ++ (output_in_order): Simplify and push nodes to vector. ++ ++2020-07-30 Martin Liska ++ ++ Backported from master: ++ 2020-07-30 Martin Liska ++ ++ PR target/95435 ++ * config/i386/x86-tune-costs.h: Use libcall for large sizes for ++ -m32. Start using libcall from 128+ bytes. ++ ++2020-07-30 Martin Liska ++ ++ Backported from master: ++ 2020-07-30 Martin Liska ++ ++ * config/i386/x86-tune-costs.h: Change code formatting. ++ ++2020-07-28 Martin Liska ++ ++ Backported from master: ++ 2020-07-27 Martin Liska ++ ++ PR tree-optimization/96058 ++ * expr.c (string_constant): Build string_constant only ++ for a type that has same precision as char_type_node ++ and is an integral type. ++ ++2020-07-28 Jakub Jelinek ++ ++ Backported from master: ++ 2020-07-28 Jakub Jelinek ++ ++ PR middle-end/96335 ++ * calls.c (maybe_warn_rdwr_sizes): Add FNDECL and FNTYPE arguments, ++ instead of trying to rediscover them in the body. ++ (initialize_argument_information): Adjust caller. ++ ++2020-07-27 Aaron Sawdey ++ ++ Backported from master: ++ 2020-06-23 Aaron Sawdey ++ ++ * config.gcc: Identify power10 as a 64-bit processor and as valid ++ for --with-cpu and --with-tune. ++ ++2020-07-27 Martin Liska ++ ++ Backported from master: ++ 2020-07-27 Martin Liska ++ ++ PR lto/45375 ++ * symbol-summary.h: Call vec_safe_reserve before grow is called ++ in order to grow to a reasonable size. ++ * vec.h (vec_safe_reserve): Add missing function for vl_ptr ++ type. ++ +2020-07-23 Sergei Trofimovich + + Backported from master: @@ -118,7 +400,7 @@ 2020-07-23 Release Manager * GCC 10.2.0 released. -@@ -71,9 +102,9 @@ +@@ -71,9 +369,9 @@ _mm512_mask_cmpord_ps_mask): Move outside of __OPTIMIZE__ guarded section. @@ -134,7 +416,7 @@ +++ b/src/gcc/DATESTAMP @@ -1 +1 @@ -20200723 -+20200725 ++20200808 --- a/src/gcc/asan.c +++ b/src/gcc/asan.c @@ -344,6 +344,13 @@ asan_shadow_offset () @@ -162,6 +444,1619 @@ extern void set_sanitized_sections (const char *); extern bool asan_sanitize_stack_p (void); +--- a/src/gcc/c/ChangeLog ++++ b/src/gcc/c/ChangeLog +@@ -1,3 +1,14 @@ ++2020-08-03 Richard Sandiford ++ ++ Backported from master: ++ 2020-08-01 Richard Sandiford ++ ++ PR c/96377 ++ * c-typeck.c (process_init_element): Split test for whether to ++ recurse into a record, union or array into... ++ (initialize_elementwise_p): ...this new function. Don't recurse ++ into a vector type if the initialization value is also a vector. ++ + 2020-07-23 Release Manager + + * GCC 10.2.0 released. +--- a/src/gcc/c/c-typeck.c ++++ b/src/gcc/c/c-typeck.c +@@ -9910,6 +9910,47 @@ output_pending_init_elements (int all, struct obstack * braced_init_obstack) + goto retry; + } + ++/* Expression VALUE coincides with the start of type TYPE in a braced ++ initializer. Return true if we should treat VALUE as initializing ++ the first element of TYPE, false if we should treat it as initializing ++ TYPE as a whole. ++ ++ If the initializer is clearly invalid, the question becomes: ++ which choice gives the best error message? */ ++ ++static bool ++initialize_elementwise_p (tree type, tree value) ++{ ++ if (type == error_mark_node || value == error_mark_node) ++ return false; ++ ++ gcc_checking_assert (TYPE_MAIN_VARIANT (type) == type); ++ ++ tree value_type = TREE_TYPE (value); ++ if (value_type == error_mark_node) ++ return false; ++ ++ /* GNU vectors can be initialized elementwise. However, treat any ++ kind of vector value as initializing the vector type as a whole, ++ regardless of whether the value is a GNU vector. Such initializers ++ are valid if and only if they would have been valid in a non-braced ++ initializer like: ++ ++ TYPE foo = VALUE; ++ ++ so recursing into the vector type would be at best confusing or at ++ worst wrong. For example, when -flax-vector-conversions is in effect, ++ it's possible to initialize a V8HI from a V4SI, even though the vectors ++ have different element types and different numbers of elements. */ ++ if (gnu_vector_type_p (type)) ++ return !VECTOR_TYPE_P (value_type); ++ ++ if (AGGREGATE_TYPE_P (type)) ++ return type != TYPE_MAIN_VARIANT (value_type); ++ ++ return false; ++} ++ + /* Add one non-braced element to the current constructor level. + This adjusts the current position within the constructor's type. + This may also start or terminate implicit levels +@@ -10089,11 +10130,7 @@ process_init_element (location_t loc, struct c_expr value, bool implicit, + /* Otherwise, if we have come to a subaggregate, + and we don't have an element of its type, push into it. */ + else if (value.value != NULL_TREE +- && value.value != error_mark_node +- && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype +- && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE +- || fieldcode == UNION_TYPE +- || gnu_vector_type_p (fieldtype))) ++ && initialize_elementwise_p (fieldtype, value.value)) + { + push_init_level (loc, 1, braced_init_obstack); + continue; +@@ -10181,11 +10218,7 @@ process_init_element (location_t loc, struct c_expr value, bool implicit, + /* Otherwise, if we have come to a subaggregate, + and we don't have an element of its type, push into it. */ + else if (value.value != NULL_TREE +- && value.value != error_mark_node +- && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != fieldtype +- && (fieldcode == RECORD_TYPE || fieldcode == ARRAY_TYPE +- || fieldcode == UNION_TYPE +- || gnu_vector_type_p (fieldtype))) ++ && initialize_elementwise_p (fieldtype, value.value)) + { + push_init_level (loc, 1, braced_init_obstack); + continue; +@@ -10224,11 +10257,7 @@ process_init_element (location_t loc, struct c_expr value, bool implicit, + /* Otherwise, if we have come to a subaggregate, + and we don't have an element of its type, push into it. */ + else if (value.value != NULL_TREE +- && value.value != error_mark_node +- && TYPE_MAIN_VARIANT (TREE_TYPE (value.value)) != elttype +- && (eltcode == RECORD_TYPE || eltcode == ARRAY_TYPE +- || eltcode == UNION_TYPE +- || gnu_vector_type_p (elttype))) ++ && initialize_elementwise_p (elttype, value.value)) + { + push_init_level (loc, 1, braced_init_obstack); + continue; +--- a/src/gcc/calls.c ++++ b/src/gcc/calls.c +@@ -1982,24 +1982,8 @@ append_attrname (const std::pair &access, + in the function call EXP. */ + + static void +-maybe_warn_rdwr_sizes (rdwr_map *rwm, tree exp) ++maybe_warn_rdwr_sizes (rdwr_map *rwm, tree fndecl, tree fntype, tree exp) + { +- tree fndecl = NULL_TREE; +- tree fntype = NULL_TREE; +- if (tree fnaddr = CALL_EXPR_FN (exp)) +- { +- if (TREE_CODE (fnaddr) == ADDR_EXPR) +- { +- fndecl = TREE_OPERAND (fnaddr, 0); +- fntype = TREE_TYPE (fndecl); +- } +- else +- fntype = TREE_TYPE (TREE_TYPE (fnaddr)); +- } +- +- if (!fntype) +- return; +- + /* A string describing the attributes that the warnings issued by this + function apply to. Used to print one informational note per function + call, rather than one per warning. That reduces clutter. */ +@@ -2560,7 +2544,7 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED, + maybe_warn_nonstring_arg (fndecl, exp); + + /* Check read_only, write_only, and read_write arguments. */ +- maybe_warn_rdwr_sizes (&rdwr_idx, exp); ++ maybe_warn_rdwr_sizes (&rdwr_idx, fndecl, fntype, exp); + } + + /* Update ARGS_SIZE to contain the total size for the argument block. +--- a/src/gcc/cgraph.h ++++ b/src/gcc/cgraph.h +@@ -2165,8 +2165,6 @@ private: + /* Every top level asm statement is put into a asm_node. */ + + struct GTY(()) asm_node { +- +- + /* Next asm node. */ + asm_node *next; + /* String for this asm node. */ +--- a/src/gcc/cgraphunit.c ++++ b/src/gcc/cgraphunit.c +@@ -2491,7 +2491,6 @@ expand_all_functions (void) + + enum cgraph_order_sort_kind + { +- ORDER_UNDEFINED = 0, + ORDER_FUNCTION, + ORDER_VAR, + ORDER_VAR_UNDEF, +@@ -2500,6 +2499,30 @@ enum cgraph_order_sort_kind + + struct cgraph_order_sort + { ++ /* Construct from a cgraph_node. */ ++ cgraph_order_sort (cgraph_node *node) ++ : kind (ORDER_FUNCTION), order (node->order) ++ { ++ u.f = node; ++ } ++ ++ /* Construct from a varpool_node. */ ++ cgraph_order_sort (varpool_node *node) ++ : kind (node->definition ? ORDER_VAR : ORDER_VAR_UNDEF), order (node->order) ++ { ++ u.v = node; ++ } ++ ++ /* Construct from a asm_node. */ ++ cgraph_order_sort (asm_node *node) ++ : kind (ORDER_ASM), order (node->order) ++ { ++ u.a = node; ++ } ++ ++ /* Assembly cgraph_order_sort based on its type. */ ++ void process (); ++ + enum cgraph_order_sort_kind kind; + union + { +@@ -2507,8 +2530,45 @@ struct cgraph_order_sort + varpool_node *v; + asm_node *a; + } u; ++ int order; + }; + ++/* Assembly cgraph_order_sort based on its type. */ ++ ++void ++cgraph_order_sort::process () ++{ ++ switch (kind) ++ { ++ case ORDER_FUNCTION: ++ u.f->process = 0; ++ u.f->expand (); ++ break; ++ case ORDER_VAR: ++ u.v->assemble_decl (); ++ break; ++ case ORDER_VAR_UNDEF: ++ assemble_undefined_decl (u.v->decl); ++ break; ++ case ORDER_ASM: ++ assemble_asm (u.a->asm_str); ++ break; ++ default: ++ gcc_unreachable (); ++ } ++} ++ ++/* Compare cgraph_order_sort by order. */ ++ ++static int ++cgraph_order_cmp (const void *a_p, const void *b_p) ++{ ++ const cgraph_order_sort *nodea = (const cgraph_order_sort *)a_p; ++ const cgraph_order_sort *nodeb = (const cgraph_order_sort *)b_p; ++ ++ return nodea->order - nodeb->order; ++} ++ + /* Output all functions, variables, and asm statements in the order + according to their order fields, which is the order in which they + appeared in the file. This implements -fno-toplevel-reorder. In +@@ -2518,89 +2578,41 @@ struct cgraph_order_sort + static void + output_in_order (void) + { +- int max; +- cgraph_order_sort *nodes; + int i; +- cgraph_node *pf; +- varpool_node *pv; +- asm_node *pa; +- max = symtab->order; +- nodes = XCNEWVEC (cgraph_order_sort, max); ++ cgraph_node *cnode; ++ varpool_node *vnode; ++ asm_node *anode; ++ auto_vec nodes; ++ cgraph_order_sort *node; + +- FOR_EACH_DEFINED_FUNCTION (pf) +- { +- if (pf->process && !pf->thunk.thunk_p && !pf->alias) +- { +- if (!pf->no_reorder) +- continue; +- i = pf->order; +- gcc_assert (nodes[i].kind == ORDER_UNDEFINED); +- nodes[i].kind = ORDER_FUNCTION; +- nodes[i].u.f = pf; +- } +- } ++ FOR_EACH_DEFINED_FUNCTION (cnode) ++ if (cnode->process && !cnode->thunk.thunk_p ++ && !cnode->alias && cnode->no_reorder) ++ nodes.safe_push (cgraph_order_sort (cnode)); + + /* There is a similar loop in symbol_table::output_variables. + Please keep them in sync. */ +- FOR_EACH_VARIABLE (pv) +- { +- if (!pv->no_reorder) +- continue; +- if (DECL_HARD_REGISTER (pv->decl) +- || DECL_HAS_VALUE_EXPR_P (pv->decl)) +- continue; +- i = pv->order; +- gcc_assert (nodes[i].kind == ORDER_UNDEFINED); +- nodes[i].kind = pv->definition ? ORDER_VAR : ORDER_VAR_UNDEF; +- nodes[i].u.v = pv; +- } +- +- for (pa = symtab->first_asm_symbol (); pa; pa = pa->next) +- { +- i = pa->order; +- gcc_assert (nodes[i].kind == ORDER_UNDEFINED); +- nodes[i].kind = ORDER_ASM; +- nodes[i].u.a = pa; +- } +- +- /* In toplevel reorder mode we output all statics; mark them as needed. */ +- +- for (i = 0; i < max; ++i) +- if (nodes[i].kind == ORDER_VAR) +- nodes[i].u.v->finalize_named_section_flags (); +- +- for (i = 0; i < max; ++i) +- { +- switch (nodes[i].kind) +- { +- case ORDER_FUNCTION: +- nodes[i].u.f->process = 0; +- nodes[i].u.f->expand (); +- break; ++ FOR_EACH_VARIABLE (vnode) ++ if (vnode->no_reorder ++ && !DECL_HARD_REGISTER (vnode->decl) ++ && !DECL_HAS_VALUE_EXPR_P (vnode->decl)) ++ nodes.safe_push (cgraph_order_sort (vnode)); + +- case ORDER_VAR: +- nodes[i].u.v->assemble_decl (); +- break; ++ for (anode = symtab->first_asm_symbol (); anode; anode = anode->next) ++ nodes.safe_push (cgraph_order_sort (anode)); + +- case ORDER_VAR_UNDEF: +- assemble_undefined_decl (nodes[i].u.v->decl); +- break; ++ /* Sort nodes by order. */ ++ nodes.qsort (cgraph_order_cmp); + +- case ORDER_ASM: +- assemble_asm (nodes[i].u.a->asm_str); +- break; +- +- case ORDER_UNDEFINED: +- break; ++ /* In toplevel reorder mode we output all statics; mark them as needed. */ ++ FOR_EACH_VEC_ELT (nodes, i, node) ++ if (node->kind == ORDER_VAR) ++ node->u.v->finalize_named_section_flags (); + +- default: +- gcc_unreachable (); +- } +- } ++ FOR_EACH_VEC_ELT (nodes, i, node) ++ node->process (); + + symtab->clear_asm_symbols (); +- +- free (nodes); + } + + static void +--- a/src/gcc/config.gcc ++++ b/src/gcc/config.gcc +@@ -513,7 +513,7 @@ powerpc*-*-*) + extra_headers="${extra_headers} ppu_intrinsics.h spu2vmx.h vec_types.h si2vmx.h" + extra_headers="${extra_headers} amo.h" + case x$with_cpu in +- xpowerpc64|xdefault64|x6[23]0|x970|xG5|xpower[3456789]|xpower6x|xrs64a|xcell|xa2|xe500mc64|xe5500|xe6500|xfuture) ++ xpowerpc64|xdefault64|x6[23]0|x970|xG5|xpower[3456789]|xpower10|xpower6x|xrs64a|xcell|xa2|xe500mc64|xe5500|xe6500) + cpu_is_64bit=yes + ;; + esac +@@ -4928,7 +4928,7 @@ case "${target}" in + eval "with_$which=405" + ;; + "" | common | native \ +- | power[3456789] | power5+ | power6x \ ++ | power[3456789] | power10 | power5+ | power6x \ + | powerpc | powerpc64 | powerpc64le \ + | rs64 \ + | 401 | 403 | 405 | 405fp | 440 | 440fp | 464 | 464fp \ +--- a/src/gcc/config/aarch64/aarch64-cores.def ++++ b/src/gcc/config/aarch64/aarch64-cores.def +@@ -119,6 +119,9 @@ AARCH64_CORE("octeontx2f95", octeontx2f95, cortexa57, 8_2A, AARCH64_FL_FOR_ + AARCH64_CORE("octeontx2f95n", octeontx2f95n, cortexa57, 8_2A, AARCH64_FL_FOR_ARCH8_2 | AARCH64_FL_CRYPTO | AARCH64_FL_PROFILE, cortexa57, 0x43, 0x0b4, -1) + AARCH64_CORE("octeontx2f95mm", octeontx2f95mm, cortexa57, 8_2A, AARCH64_FL_FOR_ARCH8_2 | AARCH64_FL_CRYPTO | AARCH64_FL_PROFILE, cortexa57, 0x43, 0x0b5, -1) + ++/* Fujitsu ('F') cores. */ ++AARCH64_CORE("a64fx", a64fx, a64fx, 8_2A, AARCH64_FL_FOR_ARCH8_2 | AARCH64_FL_F16 | AARCH64_FL_SVE, a64fx, 0x46, 0x001, -1) ++ + /* HiSilicon ('H') cores. */ + AARCH64_CORE("tsv110", tsv110, tsv110, 8_2A, AARCH64_FL_FOR_ARCH8_2 | AARCH64_FL_CRYPTO | AARCH64_FL_F16 | AARCH64_FL_AES | AARCH64_FL_SHA2, tsv110, 0x48, 0xd01, -1) + +--- a/src/gcc/config/aarch64/aarch64-protos.h ++++ b/src/gcc/config/aarch64/aarch64-protos.h +@@ -781,4 +781,9 @@ extern const atomic_ool_names aarch64_ool_ldeor_names; + + tree aarch64_resolve_overloaded_builtin_general (location_t, tree, void *); + ++const char *aarch64_sls_barrier (int); ++const char *aarch64_indirect_call_asm (rtx); ++extern bool aarch64_harden_sls_retbr_p (void); ++extern bool aarch64_harden_sls_blr_p (void); ++ + #endif /* GCC_AARCH64_PROTOS_H */ +--- a/src/gcc/config/aarch64/aarch64-tune.md ++++ b/src/gcc/config/aarch64/aarch64-tune.md +@@ -1,5 +1,5 @@ + ;; -*- buffer-read-only: t -*- + ;; Generated automatically by gentune.sh from aarch64-cores.def + (define_attr "tune" +- "cortexa34,cortexa35,cortexa53,cortexa57,cortexa72,cortexa73,thunderx,thunderxt88p1,thunderxt88,octeontx,octeontxt81,octeontxt83,thunderxt81,thunderxt83,emag,xgene1,falkor,qdf24xx,exynosm1,phecda,thunderx2t99p1,vulcan,thunderx2t99,cortexa55,cortexa75,cortexa76,cortexa76ae,cortexa77,cortexa65,cortexa65ae,ares,neoversen1,neoversee1,octeontx2,octeontx2t98,octeontx2t96,octeontx2t93,octeontx2f95,octeontx2f95n,octeontx2f95mm,tsv110,thunderx3t110,zeus,saphira,cortexa57cortexa53,cortexa72cortexa53,cortexa73cortexa35,cortexa73cortexa53,cortexa75cortexa55,cortexa76cortexa55" ++ "cortexa34,cortexa35,cortexa53,cortexa57,cortexa72,cortexa73,thunderx,thunderxt88p1,thunderxt88,octeontx,octeontxt81,octeontxt83,thunderxt81,thunderxt83,emag,xgene1,falkor,qdf24xx,exynosm1,phecda,thunderx2t99p1,vulcan,thunderx2t99,cortexa55,cortexa75,cortexa76,cortexa76ae,cortexa77,cortexa65,cortexa65ae,ares,neoversen1,neoversee1,octeontx2,octeontx2t98,octeontx2t96,octeontx2t93,octeontx2f95,octeontx2f95n,octeontx2f95mm,a64fx,tsv110,thunderx3t110,zeus,saphira,cortexa57cortexa53,cortexa72cortexa53,cortexa73cortexa35,cortexa73cortexa53,cortexa75cortexa55,cortexa76cortexa55" + (const (symbol_ref "((enum attr_tune) aarch64_tune)"))) +--- a/src/gcc/config/aarch64/aarch64.c ++++ b/src/gcc/config/aarch64/aarch64.c +@@ -868,6 +868,17 @@ static const cpu_prefetch_tune xgene1_prefetch_tune = + -1 /* default_opt_level */ + }; + ++static const cpu_prefetch_tune a64fx_prefetch_tune = ++{ ++ 8, /* num_slots */ ++ 64, /* l1_cache_size */ ++ 256, /* l1_cache_line_size */ ++ 32768, /* l2_cache_size */ ++ true, /* prefetch_dynamic_strides */ ++ -1, /* minimum_stride */ ++ -1 /* default_opt_level */ ++}; ++ + static const struct tune_params generic_tunings = + { + &cortexa57_extra_costs, +@@ -1325,6 +1336,32 @@ static const struct tune_params neoversen1_tunings = + &generic_prefetch_tune + }; + ++static const struct tune_params a64fx_tunings = ++{ ++ &generic_extra_costs, ++ &generic_addrcost_table, ++ &generic_regmove_cost, ++ &generic_vector_cost, ++ &generic_branch_cost, ++ &generic_approx_modes, ++ SVE_512, /* sve_width */ ++ 4, /* memmov_cost */ ++ 7, /* issue_rate */ ++ (AARCH64_FUSE_AES_AESMC | AARCH64_FUSE_CMP_BRANCH), /* fusible_ops */ ++ "32", /* function_align. */ ++ "16", /* jump_align. */ ++ "32", /* loop_align. */ ++ 4, /* int_reassoc_width. */ ++ 2, /* fp_reassoc_width. */ ++ 2, /* vec_reassoc_width. */ ++ 2, /* min_div_recip_mul_sf. */ ++ 2, /* min_div_recip_mul_df. */ ++ 0, /* max_case_values. */ ++ tune_params::AUTOPREFETCHER_WEAK, /* autoprefetcher_model. */ ++ (AARCH64_EXTRA_TUNE_NONE), /* tune_flags. */ ++ &a64fx_prefetch_tune ++}; ++ + /* Support for fine-grained override of the tuning structures. */ + struct aarch64_tuning_override_function + { +@@ -10605,6 +10642,9 @@ aarch64_label_mentioned_p (rtx x) + enum reg_class + aarch64_regno_regclass (unsigned regno) + { ++ if (STUB_REGNUM_P (regno)) ++ return STUB_REGS; ++ + if (GP_REGNUM_P (regno)) + return GENERAL_REGS; + +@@ -10852,8 +10892,8 @@ aarch64_return_addr (int count, rtx frame ATTRIBUTE_UNUSED) + static void + aarch64_asm_trampoline_template (FILE *f) + { +- int offset1 = 16; +- int offset2 = 20; ++ int offset1 = 24; ++ int offset2 = 28; + + if (aarch64_bti_enabled ()) + { +@@ -10876,6 +10916,17 @@ aarch64_asm_trampoline_template (FILE *f) + } + asm_fprintf (f, "\tbr\t%s\n", reg_names [IP1_REGNUM]); + ++ /* We always emit a speculation barrier. ++ This is because the same trampoline template is used for every nested ++ function. Since nested functions are not particularly common or ++ performant we don't worry too much about the extra instructions to copy ++ around. ++ This is not yet a problem, since we have not yet implemented function ++ specific attributes to choose between hardening against straight line ++ speculation or not, but such function specific attributes are likely to ++ happen in the future. */ ++ asm_fprintf (f, "\tdsb\tsy\n\tisb\n"); ++ + /* The trampoline needs an extra padding instruction. In case if BTI is + enabled the padding instruction is replaced by the BTI instruction at + the beginning. */ +@@ -10890,10 +10941,14 @@ static void + aarch64_trampoline_init (rtx m_tramp, tree fndecl, rtx chain_value) + { + rtx fnaddr, mem, a_tramp; +- const int tramp_code_sz = 16; ++ const int tramp_code_sz = 24; + + /* Don't need to copy the trailing D-words, we fill those in below. */ +- emit_block_move (m_tramp, assemble_trampoline_template (), ++ /* We create our own memory address in Pmode so that `emit_block_move` can ++ use parts of the backend which expect Pmode addresses. */ ++ rtx temp = convert_memory_address (Pmode, XEXP (m_tramp, 0)); ++ emit_block_move (gen_rtx_MEM (BLKmode, temp), ++ assemble_trampoline_template (), + GEN_INT (tramp_code_sz), BLOCK_OP_NORMAL); + mem = adjust_address (m_tramp, ptr_mode, tramp_code_sz); + fnaddr = XEXP (DECL_RTL (fndecl), 0); +@@ -10924,6 +10979,7 @@ aarch64_class_max_nregs (reg_class_t regclass, machine_mode mode) + unsigned int nregs, vec_flags; + switch (regclass) + { ++ case STUB_REGS: + case TAILCALL_ADDR_REGS: + case POINTER_REGS: + case GENERAL_REGS: +@@ -11084,6 +11140,8 @@ aarch64_output_casesi (rtx *operands) + output_asm_insn (buf, operands); + output_asm_insn (patterns[index][1], operands); + output_asm_insn ("br\t%3", operands); ++ output_asm_insn (aarch64_sls_barrier (aarch64_harden_sls_retbr_p ()), ++ operands); + assemble_label (asm_out_file, label); + return ""; + } +@@ -13138,10 +13196,12 @@ aarch64_register_move_cost (machine_mode mode, + = aarch64_tune_params.regmove_cost; + + /* Caller save and pointer regs are equivalent to GENERAL_REGS. */ +- if (to == TAILCALL_ADDR_REGS || to == POINTER_REGS) ++ if (to == TAILCALL_ADDR_REGS || to == POINTER_REGS ++ || to == STUB_REGS) + to = GENERAL_REGS; + +- if (from == TAILCALL_ADDR_REGS || from == POINTER_REGS) ++ if (from == TAILCALL_ADDR_REGS || from == POINTER_REGS ++ || from == STUB_REGS) + from = GENERAL_REGS; + + /* Make RDFFR very expensive. In particular, if we know that the FFR +@@ -14494,6 +14554,79 @@ aarch64_validate_mcpu (const char *str, const struct processor **res, + return false; + } + ++/* Straight line speculation indicators. */ ++enum aarch64_sls_hardening_type ++{ ++ SLS_NONE = 0, ++ SLS_RETBR = 1, ++ SLS_BLR = 2, ++ SLS_ALL = 3, ++}; ++static enum aarch64_sls_hardening_type aarch64_sls_hardening; ++ ++/* Return whether we should mitigatate Straight Line Speculation for the RET ++ and BR instructions. */ ++bool ++aarch64_harden_sls_retbr_p (void) ++{ ++ return aarch64_sls_hardening & SLS_RETBR; ++} ++ ++/* Return whether we should mitigatate Straight Line Speculation for the BLR ++ instruction. */ ++bool ++aarch64_harden_sls_blr_p (void) ++{ ++ return aarch64_sls_hardening & SLS_BLR; ++} ++ ++/* As of yet we only allow setting these options globally, in the future we may ++ allow setting them per function. */ ++static void ++aarch64_validate_sls_mitigation (const char *const_str) ++{ ++ char *token_save = NULL; ++ char *str = NULL; ++ ++ if (strcmp (const_str, "none") == 0) ++ { ++ aarch64_sls_hardening = SLS_NONE; ++ return; ++ } ++ if (strcmp (const_str, "all") == 0) ++ { ++ aarch64_sls_hardening = SLS_ALL; ++ return; ++ } ++ ++ char *str_root = xstrdup (const_str); ++ str = strtok_r (str_root, ",", &token_save); ++ if (!str) ++ error ("invalid argument given to %<-mharden-sls=%>"); ++ ++ int temp = SLS_NONE; ++ while (str) ++ { ++ if (strcmp (str, "blr") == 0) ++ temp |= SLS_BLR; ++ else if (strcmp (str, "retbr") == 0) ++ temp |= SLS_RETBR; ++ else if (strcmp (str, "none") == 0 || strcmp (str, "all") == 0) ++ { ++ error ("%<%s%> must be by itself for %<-mharden-sls=%>", str); ++ break; ++ } ++ else ++ { ++ error ("invalid argument %<%s%> for %<-mharden-sls=%>", str); ++ break; ++ } ++ str = strtok_r (NULL, ",", &token_save); ++ } ++ aarch64_sls_hardening = (aarch64_sls_hardening_type) temp; ++ free (str_root); ++} ++ + /* Parses CONST_STR for branch protection features specified in + aarch64_branch_protect_types, and set any global variables required. Returns + the parsing result and assigns LAST_STR to the last processed token from +@@ -14738,6 +14871,9 @@ aarch64_override_options (void) + selected_arch = NULL; + selected_tune = NULL; + ++ if (aarch64_harden_sls_string) ++ aarch64_validate_sls_mitigation (aarch64_harden_sls_string); ++ + if (aarch64_branch_protection_string) + aarch64_validate_mbranch_protection (aarch64_branch_protection_string); + +@@ -22848,6 +22984,231 @@ aarch64_file_end_indicate_exec_stack () + #undef GNU_PROPERTY_AARCH64_FEATURE_1_BTI + #undef GNU_PROPERTY_AARCH64_FEATURE_1_AND + ++/* Helper function for straight line speculation. ++ Return what barrier should be emitted for straight line speculation ++ mitigation. ++ When not mitigating against straight line speculation this function returns ++ an empty string. ++ When mitigating against straight line speculation, use: ++ * SB when the v8.5-A SB extension is enabled. ++ * DSB+ISB otherwise. */ ++const char * ++aarch64_sls_barrier (int mitigation_required) ++{ ++ return mitigation_required ++ ? (TARGET_SB ? "sb" : "dsb\tsy\n\tisb") ++ : ""; ++} ++ ++static GTY (()) tree aarch64_sls_shared_thunks[30]; ++static GTY (()) bool aarch64_sls_shared_thunks_needed = false; ++const char *indirect_symbol_names[30] = { ++ "__call_indirect_x0", ++ "__call_indirect_x1", ++ "__call_indirect_x2", ++ "__call_indirect_x3", ++ "__call_indirect_x4", ++ "__call_indirect_x5", ++ "__call_indirect_x6", ++ "__call_indirect_x7", ++ "__call_indirect_x8", ++ "__call_indirect_x9", ++ "__call_indirect_x10", ++ "__call_indirect_x11", ++ "__call_indirect_x12", ++ "__call_indirect_x13", ++ "__call_indirect_x14", ++ "__call_indirect_x15", ++ "", /* "__call_indirect_x16", */ ++ "", /* "__call_indirect_x17", */ ++ "__call_indirect_x18", ++ "__call_indirect_x19", ++ "__call_indirect_x20", ++ "__call_indirect_x21", ++ "__call_indirect_x22", ++ "__call_indirect_x23", ++ "__call_indirect_x24", ++ "__call_indirect_x25", ++ "__call_indirect_x26", ++ "__call_indirect_x27", ++ "__call_indirect_x28", ++ "__call_indirect_x29", ++}; ++ ++/* Function to create a BLR thunk. This thunk is used to mitigate straight ++ line speculation. Instead of a simple BLR that can be speculated past, ++ we emit a BL to this thunk, and this thunk contains a BR to the relevant ++ register. These thunks have the relevant speculation barries put after ++ their indirect branch so that speculation is blocked. ++ ++ We use such a thunk so the speculation barriers are kept off the ++ architecturally executed path in order to reduce the performance overhead. ++ ++ When optimizing for size we use stubs shared by the linked object. ++ When optimizing for performance we emit stubs for each function in the hope ++ that the branch predictor can better train on jumps specific for a given ++ function. */ ++rtx ++aarch64_sls_create_blr_label (int regnum) ++{ ++ gcc_assert (STUB_REGNUM_P (regnum)); ++ if (optimize_function_for_size_p (cfun)) ++ { ++ /* For the thunks shared between different functions in this compilation ++ unit we use a named symbol -- this is just for users to more easily ++ understand the generated assembly. */ ++ aarch64_sls_shared_thunks_needed = true; ++ const char *thunk_name = indirect_symbol_names[regnum]; ++ if (aarch64_sls_shared_thunks[regnum] == NULL) ++ { ++ /* Build a decl representing this function stub and record it for ++ later. We build a decl here so we can use the GCC machinery for ++ handling sections automatically (through `get_named_section` and ++ `make_decl_one_only`). That saves us a lot of trouble handling ++ the specifics of different output file formats. */ ++ tree decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL, ++ get_identifier (thunk_name), ++ build_function_type_list (void_type_node, ++ NULL_TREE)); ++ DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL, ++ NULL_TREE, void_type_node); ++ TREE_PUBLIC (decl) = 1; ++ TREE_STATIC (decl) = 1; ++ DECL_IGNORED_P (decl) = 1; ++ DECL_ARTIFICIAL (decl) = 1; ++ make_decl_one_only (decl, DECL_ASSEMBLER_NAME (decl)); ++ resolve_unique_section (decl, 0, false); ++ aarch64_sls_shared_thunks[regnum] = decl; ++ } ++ ++ return gen_rtx_SYMBOL_REF (Pmode, thunk_name); ++ } ++ ++ if (cfun->machine->call_via[regnum] == NULL) ++ cfun->machine->call_via[regnum] ++ = gen_rtx_LABEL_REF (Pmode, gen_label_rtx ()); ++ return cfun->machine->call_via[regnum]; ++} ++ ++/* Helper function for aarch64_sls_emit_blr_function_thunks and ++ aarch64_sls_emit_shared_blr_thunks below. */ ++static void ++aarch64_sls_emit_function_stub (FILE *out_file, int regnum) ++{ ++ /* Save in x16 and branch to that function so this transformation does ++ not prevent jumping to `BTI c` instructions. */ ++ asm_fprintf (out_file, "\tmov\tx16, x%d\n", regnum); ++ asm_fprintf (out_file, "\tbr\tx16\n"); ++} ++ ++/* Emit all BLR stubs for this particular function. ++ Here we emit all the BLR stubs needed for the current function. Since we ++ emit these stubs in a consecutive block we know there will be no speculation ++ gadgets between each stub, and hence we only emit a speculation barrier at ++ the end of the stub sequences. ++ ++ This is called in the TARGET_ASM_FUNCTION_EPILOGUE hook. */ ++void ++aarch64_sls_emit_blr_function_thunks (FILE *out_file) ++{ ++ if (! aarch64_harden_sls_blr_p ()) ++ return; ++ ++ bool any_functions_emitted = false; ++ /* We must save and restore the current function section since this assembly ++ is emitted at the end of the function. This means it can be emitted *just ++ after* the cold section of a function. That cold part would be emitted in ++ a different section. That switch would trigger a `.cfi_endproc` directive ++ to be emitted in the original section and a `.cfi_startproc` directive to ++ be emitted in the new section. Switching to the original section without ++ restoring would mean that the `.cfi_endproc` emitted as a function ends ++ would happen in a different section -- leaving an unmatched ++ `.cfi_startproc` in the cold text section and an unmatched `.cfi_endproc` ++ in the standard text section. */ ++ section *save_text_section = in_section; ++ switch_to_section (function_section (current_function_decl)); ++ for (int regnum = 0; regnum < 30; ++regnum) ++ { ++ rtx specu_label = cfun->machine->call_via[regnum]; ++ if (specu_label == NULL) ++ continue; ++ ++ targetm.asm_out.print_operand (out_file, specu_label, 0); ++ asm_fprintf (out_file, ":\n"); ++ aarch64_sls_emit_function_stub (out_file, regnum); ++ any_functions_emitted = true; ++ } ++ if (any_functions_emitted) ++ /* Can use the SB if needs be here, since this stub will only be used ++ by the current function, and hence for the current target. */ ++ asm_fprintf (out_file, "\t%s\n", aarch64_sls_barrier (true)); ++ switch_to_section (save_text_section); ++} ++ ++/* Emit shared BLR stubs for the current compilation unit. ++ Over the course of compiling this unit we may have converted some BLR ++ instructions to a BL to a shared stub function. This is where we emit those ++ stub functions. ++ This function is for the stubs shared between different functions in this ++ compilation unit. We share when optimizing for size instead of speed. ++ ++ This function is called through the TARGET_ASM_FILE_END hook. */ ++void ++aarch64_sls_emit_shared_blr_thunks (FILE *out_file) ++{ ++ if (! aarch64_sls_shared_thunks_needed) ++ return; ++ ++ for (int regnum = 0; regnum < 30; ++regnum) ++ { ++ tree decl = aarch64_sls_shared_thunks[regnum]; ++ if (!decl) ++ continue; ++ ++ const char *name = indirect_symbol_names[regnum]; ++ switch_to_section (get_named_section (decl, NULL, 0)); ++ ASM_OUTPUT_ALIGN (out_file, 2); ++ targetm.asm_out.globalize_label (out_file, name); ++ /* Only emits if the compiler is configured for an assembler that can ++ handle visibility directives. */ ++ targetm.asm_out.assemble_visibility (decl, VISIBILITY_HIDDEN); ++ ASM_OUTPUT_TYPE_DIRECTIVE (out_file, name, "function"); ++ ASM_OUTPUT_LABEL (out_file, name); ++ aarch64_sls_emit_function_stub (out_file, regnum); ++ /* Use the most conservative target to ensure it can always be used by any ++ function in the translation unit. */ ++ asm_fprintf (out_file, "\tdsb\tsy\n\tisb\n"); ++ ASM_DECLARE_FUNCTION_SIZE (out_file, name, decl); ++ } ++} ++ ++/* Implement TARGET_ASM_FILE_END. */ ++void ++aarch64_asm_file_end () ++{ ++ aarch64_sls_emit_shared_blr_thunks (asm_out_file); ++ /* Since this function will be called for the ASM_FILE_END hook, we ensure ++ that what would be called otherwise (e.g. `file_end_indicate_exec_stack` ++ for FreeBSD) still gets called. */ ++#ifdef TARGET_ASM_FILE_END ++ TARGET_ASM_FILE_END (); ++#endif ++} ++ ++const char * ++aarch64_indirect_call_asm (rtx addr) ++{ ++ gcc_assert (REG_P (addr)); ++ if (aarch64_harden_sls_blr_p ()) ++ { ++ rtx stub_label = aarch64_sls_create_blr_label (REGNO (addr)); ++ output_asm_insn ("bl\t%0", &stub_label); ++ } ++ else ++ output_asm_insn ("blr\t%0", &addr); ++ return ""; ++} ++ + /* Target-specific selftests. */ + + #if CHECKING_P +@@ -23398,6 +23759,12 @@ aarch64_libgcc_floating_mode_supported_p + #undef TARGET_MD_ASM_ADJUST + #define TARGET_MD_ASM_ADJUST arm_md_asm_adjust + ++#undef TARGET_ASM_FILE_END ++#define TARGET_ASM_FILE_END aarch64_asm_file_end ++ ++#undef TARGET_ASM_FUNCTION_EPILOGUE ++#define TARGET_ASM_FUNCTION_EPILOGUE aarch64_sls_emit_blr_function_thunks ++ + struct gcc_target targetm = TARGET_INITIALIZER; + + #include "gt-aarch64.h" +--- a/src/gcc/config/aarch64/aarch64.h ++++ b/src/gcc/config/aarch64/aarch64.h +@@ -281,6 +281,7 @@ extern unsigned aarch64_architecture_version; + #define AARCH64_ISA_F32MM (aarch64_isa_flags & AARCH64_FL_F32MM) + #define AARCH64_ISA_F64MM (aarch64_isa_flags & AARCH64_FL_F64MM) + #define AARCH64_ISA_BF16 (aarch64_isa_flags & AARCH64_FL_BF16) ++#define AARCH64_ISA_SB (aarch64_isa_flags & AARCH64_FL_SB) + + /* Crypto is an optional extension to AdvSIMD. */ + #define TARGET_CRYPTO (TARGET_SIMD && AARCH64_ISA_CRYPTO) +@@ -378,6 +379,9 @@ extern unsigned aarch64_architecture_version; + #define TARGET_FIX_ERR_A53_835769_DEFAULT 1 + #endif + ++/* SB instruction is enabled through +sb. */ ++#define TARGET_SB (AARCH64_ISA_SB) ++ + /* Apply the workaround for Cortex-A53 erratum 835769. */ + #define TARGET_FIX_ERR_A53_835769 \ + ((aarch64_fix_a53_err835769 == 2) \ +@@ -639,6 +643,16 @@ extern unsigned aarch64_architecture_version; + #define GP_REGNUM_P(REGNO) \ + (((unsigned) (REGNO - R0_REGNUM)) <= (R30_REGNUM - R0_REGNUM)) + ++/* Registers known to be preserved over a BL instruction. This consists of the ++ GENERAL_REGS without x16, x17, and x30. The x30 register is changed by the ++ BL instruction itself, while the x16 and x17 registers may be used by ++ veneers which can be inserted by the linker. */ ++#define STUB_REGNUM_P(REGNO) \ ++ (GP_REGNUM_P (REGNO) \ ++ && (REGNO) != R16_REGNUM \ ++ && (REGNO) != R17_REGNUM \ ++ && (REGNO) != R30_REGNUM) \ ++ + #define FP_REGNUM_P(REGNO) \ + (((unsigned) (REGNO - V0_REGNUM)) <= (V31_REGNUM - V0_REGNUM)) + +@@ -663,6 +677,7 @@ enum reg_class + { + NO_REGS, + TAILCALL_ADDR_REGS, ++ STUB_REGS, + GENERAL_REGS, + STACK_REG, + POINTER_REGS, +@@ -685,6 +700,7 @@ enum reg_class + { \ + "NO_REGS", \ + "TAILCALL_ADDR_REGS", \ ++ "STUB_REGS", \ + "GENERAL_REGS", \ + "STACK_REG", \ + "POINTER_REGS", \ +@@ -704,6 +720,7 @@ enum reg_class + { \ + { 0x00000000, 0x00000000, 0x00000000 }, /* NO_REGS */ \ + { 0x00030000, 0x00000000, 0x00000000 }, /* TAILCALL_ADDR_REGS */\ ++ { 0x3ffcffff, 0x00000000, 0x00000000 }, /* STUB_REGS */ \ + { 0x7fffffff, 0x00000000, 0x00000003 }, /* GENERAL_REGS */ \ + { 0x80000000, 0x00000000, 0x00000000 }, /* STACK_REG */ \ + { 0xffffffff, 0x00000000, 0x00000003 }, /* POINTER_REGS */ \ +@@ -858,6 +875,8 @@ typedef struct GTY (()) machine_function + struct aarch64_frame frame; + /* One entry for each hard register. */ + bool reg_is_wrapped_separately[LAST_SAVED_REGNUM]; ++ /* One entry for each general purpose register. */ ++ rtx call_via[SP_REGNUM]; + bool label_is_assembled; + } machine_function; + #endif +@@ -1058,8 +1077,10 @@ typedef struct + + #define RETURN_ADDR_RTX aarch64_return_addr + +-/* BTI c + 3 insns + 2 pointer-sized entries. */ +-#define TRAMPOLINE_SIZE (TARGET_ILP32 ? 24 : 32) ++/* BTI c + 3 insns ++ + sls barrier of DSB + ISB. ++ + 2 pointer-sized entries. */ ++#define TRAMPOLINE_SIZE (24 + (TARGET_ILP32 ? 8 : 16)) + + /* Trampolines contain dwords, so must be dword aligned. */ + #define TRAMPOLINE_ALIGNMENT 64 +--- a/src/gcc/config/aarch64/aarch64.md ++++ b/src/gcc/config/aarch64/aarch64.md +@@ -407,10 +407,25 @@ + ;; Attribute that specifies whether the alternative uses MOVPRFX. + (define_attr "movprfx" "no,yes" (const_string "no")) + ++;; Attribute to specify that an alternative has the length of a single ++;; instruction plus a speculation barrier. ++(define_attr "sls_length" "none,retbr,casesi" (const_string "none")) ++ + (define_attr "length" "" + (cond [(eq_attr "movprfx" "yes") + (const_int 8) +- ] (const_int 4))) ++ ++ (eq_attr "sls_length" "retbr") ++ (cond [(match_test "!aarch64_harden_sls_retbr_p ()") (const_int 4) ++ (match_test "TARGET_SB") (const_int 8)] ++ (const_int 12)) ++ ++ (eq_attr "sls_length" "casesi") ++ (cond [(match_test "!aarch64_harden_sls_retbr_p ()") (const_int 16) ++ (match_test "TARGET_SB") (const_int 20)] ++ (const_int 24)) ++ ] ++ (const_int 4))) + + ;; Strictly for compatibility with AArch32 in pipeline models, since AArch64 has + ;; no predicated insns. +@@ -447,8 +462,12 @@ + (define_insn "indirect_jump" + [(set (pc) (match_operand:DI 0 "register_operand" "r"))] + "" +- "br\\t%0" +- [(set_attr "type" "branch")] ++ { ++ output_asm_insn ("br\\t%0", operands); ++ return aarch64_sls_barrier (aarch64_harden_sls_retbr_p ()); ++ } ++ [(set_attr "type" "branch") ++ (set_attr "sls_length" "retbr")] + ) + + (define_insn "jump" +@@ -765,7 +784,7 @@ + "* + return aarch64_output_casesi (operands); + " +- [(set_attr "length" "16") ++ [(set_attr "sls_length" "casesi") + (set_attr "type" "branch")] + ) + +@@ -844,18 +863,23 @@ + [(return)] + "" + { ++ const char *ret = NULL; + if (aarch64_return_address_signing_enabled () + && TARGET_ARMV8_3 + && !crtl->calls_eh_return) + { + if (aarch64_ra_sign_key == AARCH64_KEY_B) +- return "retab"; ++ ret = "retab"; + else +- return "retaa"; ++ ret = "retaa"; + } +- return "ret"; ++ else ++ ret = "ret"; ++ output_asm_insn (ret, operands); ++ return aarch64_sls_barrier (aarch64_harden_sls_retbr_p ()); + } +- [(set_attr "type" "branch")] ++ [(set_attr "type" "branch") ++ (set_attr "sls_length" "retbr")] + ) + + (define_expand "return" +@@ -867,8 +891,12 @@ + (define_insn "simple_return" + [(simple_return)] + "" +- "ret" +- [(set_attr "type" "branch")] ++ { ++ output_asm_insn ("ret", operands); ++ return aarch64_sls_barrier (aarch64_harden_sls_retbr_p ()); ++ } ++ [(set_attr "type" "branch") ++ (set_attr "sls_length" "retbr")] + ) + + (define_insn "*cb1" +@@ -994,16 +1022,15 @@ + ) + + (define_insn "*call_insn" +- [(call (mem:DI (match_operand:DI 0 "aarch64_call_insn_operand" "r, Usf")) ++ [(call (mem:DI (match_operand:DI 0 "aarch64_call_insn_operand" "Ucr, Usf")) + (match_operand 1 "" "")) + (unspec:DI [(match_operand:DI 2 "const_int_operand")] UNSPEC_CALLEE_ABI) + (clobber (reg:DI LR_REGNUM))] + "" + "@ +- blr\\t%0 ++ * return aarch64_indirect_call_asm (operands[0]); + bl\\t%c0" +- [(set_attr "type" "call, call")] +-) ++ [(set_attr "type" "call, call")]) + + (define_expand "call_value" + [(parallel +@@ -1022,13 +1049,13 @@ + + (define_insn "*call_value_insn" + [(set (match_operand 0 "" "") +- (call (mem:DI (match_operand:DI 1 "aarch64_call_insn_operand" "r, Usf")) ++ (call (mem:DI (match_operand:DI 1 "aarch64_call_insn_operand" "Ucr, Usf")) + (match_operand 2 "" ""))) + (unspec:DI [(match_operand:DI 3 "const_int_operand")] UNSPEC_CALLEE_ABI) + (clobber (reg:DI LR_REGNUM))] + "" + "@ +- blr\\t%1 ++ * return aarch64_indirect_call_asm (operands[1]); + bl\\t%c1" + [(set_attr "type" "call, call")] + ) +@@ -1066,10 +1093,16 @@ + (unspec:DI [(match_operand:DI 2 "const_int_operand")] UNSPEC_CALLEE_ABI) + (return)] + "SIBLING_CALL_P (insn)" +- "@ +- br\\t%0 +- b\\t%c0" +- [(set_attr "type" "branch, branch")] ++ { ++ if (which_alternative == 0) ++ { ++ output_asm_insn ("br\\t%0", operands); ++ return aarch64_sls_barrier (aarch64_harden_sls_retbr_p ()); ++ } ++ return "b\\t%c0"; ++ } ++ [(set_attr "type" "branch, branch") ++ (set_attr "sls_length" "retbr,none")] + ) + + (define_insn "*sibcall_value_insn" +@@ -1080,10 +1113,16 @@ + (unspec:DI [(match_operand:DI 3 "const_int_operand")] UNSPEC_CALLEE_ABI) + (return)] + "SIBLING_CALL_P (insn)" +- "@ +- br\\t%1 +- b\\t%c1" +- [(set_attr "type" "branch, branch")] ++ { ++ if (which_alternative == 0) ++ { ++ output_asm_insn ("br\\t%1", operands); ++ return aarch64_sls_barrier (aarch64_harden_sls_retbr_p ()); ++ } ++ return "b\\t%c1"; ++ } ++ [(set_attr "type" "branch, branch") ++ (set_attr "sls_length" "retbr,none")] + ) + + ;; Call subroutine returning any type. +@@ -6969,7 +7008,8 @@ + (define_insn "aarch64_fjcvtzs" + [(set (match_operand:SI 0 "register_operand" "=r") + (unspec:SI [(match_operand:DF 1 "register_operand" "w")] +- UNSPEC_FJCVTZS))] ++ UNSPEC_FJCVTZS)) ++ (clobber (reg:CC CC_REGNUM))] + "TARGET_JSCVT" + "fjcvtzs\\t%w0, %d1" + [(set_attr "type" "f_cvtf2i")] +@@ -7126,10 +7166,8 @@ + (match_operand 2)] + "" + { +- rtx result; + machine_mode mode = GET_MODE (operands[0]); + +- result = gen_reg_rtx(mode); + if (aarch64_stack_protector_guard != SSP_GLOBAL) + { + /* Generate access through the system register. The +@@ -7154,29 +7192,27 @@ + operands[1] = gen_rtx_MEM (mode, tmp_reg); + } + emit_insn ((mode == DImode +- ? gen_stack_protect_test_di +- : gen_stack_protect_test_si) (result, +- operands[0], +- operands[1])); +- +- if (mode == DImode) +- emit_jump_insn (gen_cbranchdi4 (gen_rtx_EQ (VOIDmode, result, const0_rtx), +- result, const0_rtx, operands[2])); +- else +- emit_jump_insn (gen_cbranchsi4 (gen_rtx_EQ (VOIDmode, result, const0_rtx), +- result, const0_rtx, operands[2])); ++ ? gen_stack_protect_test_di ++ : gen_stack_protect_test_si) (operands[0], operands[1])); ++ ++ rtx cc_reg = gen_rtx_REG (CCmode, CC_REGNUM); ++ emit_jump_insn (gen_condjump (gen_rtx_EQ (VOIDmode, cc_reg, const0_rtx), ++ cc_reg, operands[2])); + DONE; + }) + ++;; DO NOT SPLIT THIS PATTERN. It is important for security reasons that the ++;; canary value does not live beyond the end of this sequence. + (define_insn "stack_protect_test_" +- [(set (match_operand:PTR 0 "register_operand" "=r") +- (unspec:PTR [(match_operand:PTR 1 "memory_operand" "m") +- (match_operand:PTR 2 "memory_operand" "m")] +- UNSPEC_SP_TEST)) ++ [(set (reg:CC CC_REGNUM) ++ (unspec:CC [(match_operand:PTR 0 "memory_operand" "m") ++ (match_operand:PTR 1 "memory_operand" "m")] ++ UNSPEC_SP_TEST)) ++ (clobber (match_scratch:PTR 2 "=&r")) + (clobber (match_scratch:PTR 3 "=&r"))] + "" +- "ldr\t%3, %1\;ldr\t%0, %2\;eor\t%0, %3, %0" +- [(set_attr "length" "12") ++ "ldr\t%2, %0\;ldr\t%3, %1\;subs\t%2, %2, %3\;mov\t%3, 0" ++ [(set_attr "length" "16") + (set_attr "type" "multiple")]) + + ;; Write Floating-point Control Register. +--- a/src/gcc/config/aarch64/aarch64.opt ++++ b/src/gcc/config/aarch64/aarch64.opt +@@ -71,6 +71,10 @@ mgeneral-regs-only + Target Report RejectNegative Mask(GENERAL_REGS_ONLY) Save + Generate code which uses only the general registers. + ++mharden-sls= ++Target RejectNegative Joined Var(aarch64_harden_sls_string) ++Generate code to mitigate against straight line speculation. ++ + mfix-cortex-a53-835769 + Target Report Var(aarch64_fix_a53_err835769) Init(2) Save + Workaround for ARM Cortex-A53 Erratum number 835769. +--- a/src/gcc/config/aarch64/constraints.md ++++ b/src/gcc/config/aarch64/constraints.md +@@ -24,6 +24,15 @@ + (define_register_constraint "Ucs" "TAILCALL_ADDR_REGS" + "@internal Registers suitable for an indirect tail call") + ++(define_register_constraint "Ucr" ++ "aarch64_harden_sls_blr_p () ? STUB_REGS : GENERAL_REGS" ++ "@internal Registers to be used for an indirect call. ++ This is usually the general registers, but when we are hardening against ++ Straight Line Speculation we disallow x16, x17, and x30 so we can use ++ indirection stubs. These indirection stubs cannot use the above registers ++ since they will be reached by a BL that may have to go through a linker ++ veneer.") ++ + (define_register_constraint "w" "FP_REGS" + "Floating point and SIMD vector registers.") + +--- a/src/gcc/config/aarch64/driver-aarch64.c ++++ b/src/gcc/config/aarch64/driver-aarch64.c +@@ -21,6 +21,7 @@ + + #include "config.h" + #define INCLUDE_STRING ++#define INCLUDE_SET + #include "system.h" + #include "coretypes.h" + #include "tm.h" +@@ -119,9 +120,15 @@ valid_bL_core_p (unsigned int *core, unsigned int bL_core) + /* Returns the hex integer that is after ':' for the FIELD. + Returns -1 is returned if there was problem parsing the integer. */ + static unsigned +-parse_field (const char *field) ++parse_field (const std::string &field) + { +- const char *rest = strchr (field, ':'); ++ const char *rest = strchr (field.c_str (), ':'); ++ ++ /* The line must be in the format of :, if it's not ++ then we have a weird format. */ ++ if (rest == NULL) ++ return -1; ++ + char *after; + unsigned fint = strtol (rest + 1, &after, 16); + if (after == rest + 1) +@@ -129,6 +136,82 @@ parse_field (const char *field) + return fint; + } + ++/* Returns the index of the ':' inside the FIELD which must be found ++ after the value of KEY. Returns string::npos if line does not contain ++ a field. */ ++ ++static size_t ++find_field (const std::string &field, const std::string &key) ++{ ++ size_t key_pos, sep_pos; ++ key_pos = field.find (key); ++ if (key_pos == std::string::npos) ++ return std::string::npos; ++ ++ sep_pos = field.find (":", key_pos + 1); ++ if (sep_pos == std::string::npos) ++ return std::string::npos; ++ ++ return sep_pos; ++} ++ ++/* Splits and returns a string based on whitespace and return it as ++ part of a set. Empty strings are ignored. */ ++ ++static void ++split_words (const std::string &val, std::set &result) ++{ ++ size_t cur, prev = 0; ++ std::string word; ++ while ((cur = val.find_first_of (" \n", prev)) != std::string::npos) ++ { ++ word = val.substr (prev, cur - prev); ++ /* Skip adding empty words. */ ++ if (!word.empty ()) ++ result.insert (word); ++ prev = cur + 1; ++ } ++ ++ if (prev != cur) ++ result.insert (val.substr (prev)); ++} ++ ++/* Read an entire line from F until '\n' or EOF. */ ++ ++static std::string ++readline (FILE *f) ++{ ++ char *buf = NULL; ++ int size = 0; ++ int last = 0; ++ const int buf_size = 128; ++ ++ if (feof (f)) ++ return std::string (); ++ ++ do ++ { ++ size += buf_size; ++ buf = (char*) xrealloc (buf, size); ++ gcc_assert (buf); ++ /* If fgets fails it returns NULL, but if it reaches EOF ++ with 0 characters read it also returns EOF. However ++ the condition on the loop would have broken out of the ++ loop in that case, and if we are in the first iteration ++ then the empty string is the correct thing to return. */ ++ if (!fgets (buf + last, buf_size, f)) ++ return std::string (); ++ /* If we're not at the end of the line then override the ++ \0 added by fgets. */ ++ last = strnlen (buf, size) - 1; ++ } ++ while (!feof (f) && buf[last] != '\n'); ++ ++ std::string result (buf); ++ free (buf); ++ return result; ++} ++ + /* Return true iff ARR contains CORE, in either of the two elements. */ + + static bool +@@ -167,7 +250,6 @@ host_detect_local_cpu (int argc, const char **argv) + { + const char *res = NULL; + static const int num_exts = ARRAY_SIZE (aarch64_extensions); +- char buf[128]; + FILE *f = NULL; + bool arch = false; + bool tune = false; +@@ -181,6 +263,9 @@ host_detect_local_cpu (int argc, const char **argv) + bool processed_exts = false; + uint64_t extension_flags = 0; + uint64_t default_flags = 0; ++ std::string buf; ++ size_t sep_pos = -1; ++ char *fcpu_info; + + gcc_assert (argc); + +@@ -198,16 +283,20 @@ host_detect_local_cpu (int argc, const char **argv) + if (!arch && !tune && !cpu) + goto not_found; + +- f = fopen ("/proc/cpuinfo", "r"); ++ fcpu_info = getenv ("GCC_CPUINFO"); ++ if (fcpu_info) ++ f = fopen (fcpu_info, "r"); ++ else ++ f = fopen ("/proc/cpuinfo", "r"); + + if (f == NULL) + goto not_found; + + /* Look through /proc/cpuinfo to determine the implementer + and then the part number that identifies a particular core. */ +- while (fgets (buf, sizeof (buf), f) != NULL) ++ while (!(buf = readline (f)).empty ()) + { +- if (strstr (buf, "implementer") != NULL) ++ if (find_field (buf, "implementer") != std::string::npos) + { + unsigned cimp = parse_field (buf); + if (cimp == INVALID_IMP) +@@ -219,8 +308,7 @@ host_detect_local_cpu (int argc, const char **argv) + else if (imp != cimp) + goto not_found; + } +- +- if (strstr (buf, "variant") != NULL) ++ else if (find_field (buf, "variant") != std::string::npos) + { + unsigned cvariant = parse_field (buf); + if (!contains_core_p (variants, cvariant)) +@@ -232,8 +320,7 @@ host_detect_local_cpu (int argc, const char **argv) + } + continue; + } +- +- if (strstr (buf, "part") != NULL) ++ else if (find_field (buf, "part") != std::string::npos) + { + unsigned ccore = parse_field (buf); + if (!contains_core_p (cores, ccore)) +@@ -245,39 +332,36 @@ host_detect_local_cpu (int argc, const char **argv) + } + continue; + } +- if (!tune && !processed_exts && strstr (buf, "Features") != NULL) ++ else if (!tune && !processed_exts ++ && (sep_pos = find_field (buf, "Features")) != std::string::npos) + { ++ /* First create the list of features in the buffer. */ ++ std::set features; ++ /* Drop everything till the :. */ ++ buf = buf.substr (sep_pos + 1); ++ split_words (buf, features); ++ + for (i = 0; i < num_exts; i++) + { +- const char *p = aarch64_extensions[i].feat_string; ++ const std::string val (aarch64_extensions[i].feat_string); + + /* If the feature contains no HWCAPS string then ignore it for the + auto detection. */ +- if (*p == '\0') ++ if (val.empty ()) + continue; + + bool enabled = true; + + /* This may be a multi-token feature string. We need + to match all parts, which could be in any order. */ +- size_t len = strlen (buf); +- do +- { +- const char *end = strchr (p, ' '); +- if (end == NULL) +- end = strchr (p, '\0'); +- if (memmem (buf, len, p, end - p) == NULL) +- { +- /* Failed to match this token. Turn off the +- features we'd otherwise enable. */ +- enabled = false; +- break; +- } +- if (*end == '\0') +- break; +- p = end + 1; +- } +- while (1); ++ std::set tokens; ++ split_words (val, tokens); ++ std::set::iterator it; ++ ++ /* Iterate till the first feature isn't found or all of them ++ are found. */ ++ for (it = tokens.begin (); enabled && it != tokens.end (); ++it) ++ enabled = enabled && features.count (*it); + + if (enabled) + extension_flags |= aarch64_extensions[i].flag; +--- a/src/gcc/config/aarch64/predicates.md ++++ b/src/gcc/config/aarch64/predicates.md +@@ -32,7 +32,8 @@ + + (define_predicate "aarch64_general_reg" + (and (match_operand 0 "register_operand") +- (match_test "REGNO_REG_CLASS (REGNO (op)) == GENERAL_REGS"))) ++ (match_test "REGNO_REG_CLASS (REGNO (op)) == STUB_REGS ++ || REGNO_REG_CLASS (REGNO (op)) == GENERAL_REGS"))) + + ;; Return true if OP a (const_int 0) operand. + (define_predicate "const0_operand" +--- a/src/gcc/config/arm/arm.md ++++ b/src/gcc/config/arm/arm.md +@@ -9320,6 +9320,8 @@ + [(set_attr "arch" "t1,32")] + ) + ++;; DO NOT SPLIT THIS PATTERN. It is important for security reasons that the ++;; canary value does not live beyond the end of this sequence. + (define_insn "arm_stack_protect_test_insn" + [(set (reg:CC_Z CC_REGNUM) + (compare:CC_Z (unspec:SI [(match_operand:SI 1 "memory_operand" "m,m") +@@ -9329,8 +9331,8 @@ + (clobber (match_operand:SI 0 "register_operand" "=&l,&r")) + (clobber (match_dup 2))] + "TARGET_32BIT" +- "ldr\t%0, [%2]\;ldr\t%2, %1\;eors\t%0, %2, %0" +- [(set_attr "length" "8,12") ++ "ldr\t%0, [%2]\;ldr\t%2, %1\;eors\t%0, %2, %0\;mov\t%2, #0" ++ [(set_attr "length" "12,16") + (set_attr "conds" "set") + (set_attr "type" "multiple") + (set_attr "arch" "t,32")] +--- a/src/gcc/config/arm/driver-arm.c ++++ b/src/gcc/config/arm/driver-arm.c +@@ -61,6 +61,7 @@ host_detect_local_cpu (int argc, const char **argv) + FILE *f = NULL; + bool arch; + const struct vendor_cpu *cpu_table = NULL; ++ char *fcpu_info = NULL; + + if (argc < 1) + goto not_found; +@@ -69,7 +70,12 @@ host_detect_local_cpu (int argc, const char **argv) + if (!arch && strcmp (argv[0], "cpu") != 0 && strcmp (argv[0], "tune")) + goto not_found; + +- f = fopen ("/proc/cpuinfo", "r"); ++ fcpu_info = getenv ("GCC_CPUINFO"); ++ if (fcpu_info) ++ f = fopen (fcpu_info, "r"); ++ else ++ f = fopen ("/proc/cpuinfo", "r"); ++ + if (f == NULL) + goto not_found; + +--- a/src/gcc/config/arm/thumb1.md ++++ b/src/gcc/config/arm/thumb1.md +@@ -2020,6 +2020,8 @@ + [(set_attr "type" "mov_reg")] + ) + ++;; DO NOT SPLIT THIS PATTERN. It is important for security reasons that the ++;; canary value does not live beyond the end of this sequence. + (define_insn "thumb1_stack_protect_test_insn" + [(set (match_operand:SI 0 "register_operand" "=&l") + (unspec:SI [(match_operand:SI 1 "memory_operand" "m") +@@ -2027,9 +2029,9 @@ + UNSPEC_SP_TEST)) + (clobber (match_dup 2))] + "TARGET_THUMB1" +- "ldr\t%0, [%2]\;ldr\t%2, %1\;eors\t%0, %2, %0" +- [(set_attr "length" "8") +- (set_attr "conds" "set") ++ "ldr\t%0, [%2]\;ldr\t%2, %1\;eors\t%0, %2, %0\;movs\t%2, #0" ++ [(set_attr "length" "10") ++ (set_attr "conds" "clob") + (set_attr "type" "multiple")] + ) + +--- a/src/gcc/config/i386/x86-tune-costs.h ++++ b/src/gcc/config/i386/x86-tune-costs.h +@@ -1311,14 +1311,23 @@ const struct processor_costs bdver_cost = { + very small blocks it is better to use loop. For large blocks, libcall + can do nontemporary accesses and beat inline considerably. */ + static stringop_algs znver1_memcpy[2] = { +- {libcall, {{6, loop, false}, {14, unrolled_loop, false}, +- {-1, rep_prefix_4_byte, false}}}, +- {libcall, {{16, loop, false}, {8192, rep_prefix_8_byte, false}, ++ /* 32-bit tuning. */ ++ {libcall, {{6, loop, false}, ++ {14, unrolled_loop, false}, ++ {-1, libcall, false}}}, ++ /* 64-bit tuning. */ ++ {libcall, {{16, loop, false}, ++ {128, rep_prefix_8_byte, false}, + {-1, libcall, false}}}}; + static stringop_algs znver1_memset[2] = { +- {libcall, {{8, loop, false}, {24, unrolled_loop, false}, +- {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}}, +- {libcall, {{48, unrolled_loop, false}, {8192, rep_prefix_8_byte, false}, ++ /* 32-bit tuning. */ ++ {libcall, {{8, loop, false}, ++ {24, unrolled_loop, false}, ++ {128, rep_prefix_4_byte, false}, ++ {-1, libcall, false}}}, ++ /* 64-bit tuning. */ ++ {libcall, {{48, unrolled_loop, false}, ++ {128, rep_prefix_8_byte, false}, + {-1, libcall, false}}}}; + struct processor_costs znver1_cost = { + { +@@ -1448,14 +1457,23 @@ struct processor_costs znver1_cost = { + very small blocks it is better to use loop. For large blocks, libcall + can do nontemporary accesses and beat inline considerably. */ + static stringop_algs znver2_memcpy[2] = { +- {libcall, {{6, loop, false}, {14, unrolled_loop, false}, +- {-1, rep_prefix_4_byte, false}}}, +- {libcall, {{16, loop, false}, {64, rep_prefix_4_byte, false}, ++ /* 32-bit tuning. */ ++ {libcall, {{6, loop, false}, ++ {14, unrolled_loop, false}, ++ {-1, libcall, false}}}, ++ /* 64-bit tuning. */ ++ {libcall, {{16, loop, false}, ++ {64, rep_prefix_4_byte, false}, + {-1, libcall, false}}}}; + static stringop_algs znver2_memset[2] = { +- {libcall, {{8, loop, false}, {24, unrolled_loop, false}, +- {2048, rep_prefix_4_byte, false}, {-1, libcall, false}}}, +- {libcall, {{24, rep_prefix_4_byte, false}, {128, rep_prefix_8_byte, false}, ++ /* 32-bit tuning. */ ++ {libcall, {{8, loop, false}, ++ {24, unrolled_loop, false}, ++ {128, rep_prefix_4_byte, false}, ++ {-1, libcall, false}}}, ++ /* 64-bit tuning. */ ++ {libcall, {{24, rep_prefix_4_byte, false}, ++ {128, rep_prefix_8_byte, false}, + {-1, libcall, false}}}}; + + struct processor_costs znver2_cost = { --- a/src/gcc/config/rs6000/rs6000-call.c +++ b/src/gcc/config/rs6000/rs6000-call.c @@ -10834,11 +10834,12 @@ rs6000_gimple_fold_mma_builtin (gimple_stmt_iterator *gsi) @@ -220,92 +2115,1714 @@ /* The default code model. */ #undef SPARC_DEFAULT_CMODEL ---- a/src/gcc/fortran/ChangeLog -+++ b/src/gcc/fortran/ChangeLog -@@ -1,3 +1,68 @@ -+2020-07-23 Harald Anlauf +--- a/src/gcc/cp/ChangeLog ++++ b/src/gcc/cp/ChangeLog +@@ -1,3 +1,66 @@ ++2020-08-04 Marek Polacek + + Backported from master: -+ 2020-07-10 Harald Anlauf ++ 2020-08-04 Marek Polacek + -+ PR fortran/95980 -+ * class.c (gfc_add_component_ref, gfc_build_class_symbol): -+ Add checks for NULL pointer dereference. -+ * primary.c (gfc_variable_attr): Likewise. -+ * resolve.c (resolve_variable, resolve_assoc_var) -+ (resolve_fl_var_and_proc, resolve_fl_variable_derived) -+ (resolve_symbol): Likewise. ++ PR c++/96082 ++ * parser.c (cp_parser_elaborated_type_specifier): Allow ++ 'template' following ::. + -+2020-07-23 Harald Anlauf ++2020-07-29 Iain Sandoe + + Backported from master: -+ 2020-07-06 Harald Anlauf ++ 2020-07-16 Iain Sandoe + -+ PR fortran/95980 -+ * match.c (copy_ts_from_selector_to_associate, build_class_sym): -+ Distinguish between unlimited polymorphic and ordinary variables -+ to avoid NULL pointer dereference. -+ * resolve.c (resolve_select_type): -+ Distinguish between unlimited polymorphic and ordinary variables -+ to avoid NULL pointer dereference. ++ PR c++/95591 ++ PR c++/95599 ++ PR c++/95823 ++ PR c++/95824 ++ PR c++/95895 ++ * coroutines.cc (struct coro_ret_data): Delete. ++ (coro_maybe_expand_co_return): Delete. ++ (co_return_expander): Delete. ++ (expand_co_returns): Delete. ++ (co_await_find_in_subtree): Remove unused name. ++ (build_actor_fn): Remove unused parm, remove handling ++ for co_return expansion. ++ (register_await_info): Demote duplicate info message to a ++ warning. ++ (coro_make_frame_entry): Move closer to use site. ++ (struct susp_frame_data): Add fields for final suspend label ++ and a flag to indicate await expressions with initializers. ++ (captures_temporary): Delete. ++ (register_awaits): Remove unused code, update comments. ++ (find_any_await): New. ++ (tmp_target_expr_p): New. ++ (struct interesting): New. ++ (find_interesting_subtree): New. ++ (struct var_nest_node): New. ++ (flatten_await_stmt): New. ++ (handle_nested_conditionals): New. ++ (process_conditional): New. ++ (replace_statement_captures): Rename to... ++ (maybe_promote_temps): ... this. ++ (maybe_promote_captured_temps): Delete. ++ (analyze_expression_awaits): Check for await expressions with ++ initializers. Simplify handling for truth-and/or-if. ++ (expand_one_truth_if): Simplify (map cases that need expansion ++ to COND_EXPR). ++ (await_statement_walker): Handle CO_RETURN_EXPR. Simplify the ++ handling for truth-and/or-if expressions. ++ (register_local_var_uses): Ensure that we create names in the ++ implementation namespace. ++ (morph_fn_to_coro): Add final suspend label to suspend frame ++ callback data and remove it from the build_actor_fn call. + -+2020-07-23 Harald Anlauf ++2020-07-29 Iain Sandoe + + Backported from master: -+ 2020-07-10 Harald Anlauf ++ 2020-06-05 Iain Sandoe + -+ PR fortran/96086 -+ * match.c (gfc_match_select_rank): Catch NULL pointer -+ dereference. -+ * resolve.c (resolve_assoc_var): Catch NULL pointer dereference -+ that may occur after an illegal declaration. ++ * cp-tree.def (CO_RETURN_EXPR): Correct the class ++ to use tcc_statement. + -+2020-07-23 Harald Anlauf + 2020-07-23 Release Manager + + * GCC 10.2.0 released. +--- a/src/gcc/cp/coroutines.cc ++++ b/src/gcc/cp/coroutines.cc +@@ -1393,119 +1393,6 @@ replace_proxy (tree *here, int *do_subtree, void *d) + return NULL_TREE; + } + +-/* Support for expansion of co_return statements. */ +- +-struct coro_ret_data +-{ +- tree promise_proxy; +- tree real_promise; +- tree fs_label; +-}; +- +-/* If this is a coreturn statement (or one wrapped in a cleanup) then +- return the list of statements to replace it. */ +- +-static tree +-coro_maybe_expand_co_return (tree co_ret_expr, coro_ret_data *data) +-{ +- /* Look inside <(void) (expr)> cleanup */ +- if (TREE_CODE (co_ret_expr) == CLEANUP_POINT_EXPR) +- co_ret_expr = TREE_OPERAND (co_ret_expr, 0); +- +- if (TREE_CODE (co_ret_expr) != CO_RETURN_EXPR) +- return NULL_TREE; +- +- location_t loc = EXPR_LOCATION (co_ret_expr); +- tree expr = TREE_OPERAND (co_ret_expr, 0); +- tree call = TREE_OPERAND (co_ret_expr, 1); +- tree stmt_list = NULL; +- if (expr && VOID_TYPE_P (TREE_TYPE (expr))) +- { +- /* [stmt.return.coroutine], 2.2 +- If expr is present and void, it is placed immediately before +- the call for return_void; */ +- expr = maybe_cleanup_point_expr_void (expr); +- append_to_statement_list (expr, &stmt_list); +- } +- +- /* Now replace the promise proxy with its real value. */ +- proxy_replace p_data; +- p_data.from = data->promise_proxy; +- p_data.to = data->real_promise; +- cp_walk_tree (&call, replace_proxy, &p_data, NULL); +- +- /* The types of p.return_void and p.return_value are not explicitly stated +- at least in n4835, it is expected that they will return void. */ +- call = maybe_cleanup_point_expr_void (call); +- append_to_statement_list (call, &stmt_list); +- tree r = build1_loc (loc, GOTO_EXPR, void_type_node, data->fs_label); +- append_to_statement_list (r, &stmt_list); +- return stmt_list; +-} +- +-/* Callback that rewrites co_return as per [stmt.return.coroutine] +- - for co_return; +- { p.return_void (); goto final_suspend; } +- - for co_return [void expr]; +- { expr; p.return_void(); goto final_suspend;} +- - for co_return [non void expr]; +- { p.return_value(expr); goto final_suspend; } */ +- +-static tree +-co_return_expander (tree *stmt, int *do_subtree, void *d) +-{ +- coro_ret_data *data = (coro_ret_data *) d; +- +- /* To avoid nesting statement lists, walk them and insert as needed. */ +- if (TREE_CODE (*stmt) == STATEMENT_LIST) +- { +- tree_stmt_iterator i; +- for (i = tsi_start (*stmt); !tsi_end_p (i); tsi_next (&i)) +- { +- tree *new_stmt = tsi_stmt_ptr (i); +- tree replace = coro_maybe_expand_co_return (*new_stmt, data); +- /* If we got something, it will be list and we want to splice +- it in. */ +- if (replace != NULL_TREE) +- { +- /* Splice it in ... */ +- tsi_link_before (&i, replace, TSI_SAME_STMT); +- /* ... and delete what we expanded. */ +- tsi_delink (&i); +- /* Maybe, even likely, we replaced the last in the list. */ +- if (tsi_end_p (i)) +- break; +- } +- else /* Continue the walk. */ +- cp_walk_tree (new_stmt, co_return_expander, d, NULL); +- } +- *do_subtree = 0; /* Done subtrees. */ +- } +- else +- { +- /* We might have a single co_return statement, in which case, we do +- have to replace it with a list. */ +- tree replace = coro_maybe_expand_co_return (*stmt, data); +- if (replace != NULL_TREE) +- { +- *stmt = replace; +- *do_subtree = 0; /* Done here. */ +- } +- } +- return NULL_TREE; +-} +- +-/* Walk the original function body, rewriting co_returns. */ +- +-static tree +-expand_co_returns (tree *fnbody, tree promise_proxy, tree promise, +- tree fs_label) +-{ +- coro_ret_data data = {promise_proxy, promise, fs_label}; +- cp_walk_tree (fnbody, co_return_expander, &data, NULL); +- return *fnbody; +-} +- + /* Support for expansion of co_await statements. */ + + struct coro_aw_data +@@ -1530,7 +1417,7 @@ struct coro_aw_data + awaits. */ + + static tree +-co_await_find_in_subtree (tree *stmt, int *do_subtree ATTRIBUTE_UNUSED, void *d) ++co_await_find_in_subtree (tree *stmt, int *, void *d) + { + tree **p = (tree **) d; + if (TREE_CODE (*stmt) == CO_AWAIT_EXPR) +@@ -1895,7 +1782,9 @@ transform_await_wrapper (tree *stmt, int *do_subtree, void *d) + && DECL_CONTEXT (*stmt) != xform->actor_fn) + DECL_CONTEXT (*stmt) = xform->actor_fn; + +- if (TREE_CODE (*stmt) != CO_AWAIT_EXPR && TREE_CODE (*stmt) != CO_YIELD_EXPR) ++ /* We should have already lowered co_yields to their co_await. */ ++ gcc_checking_assert (TREE_CODE (*stmt) != CO_YIELD_EXPR); ++ if (TREE_CODE (*stmt) != CO_AWAIT_EXPR) + return NULL_TREE; + + tree await_expr = *stmt; +@@ -2091,8 +1980,7 @@ static void + build_actor_fn (location_t loc, tree coro_frame_type, tree actor, tree fnbody, + tree orig, hash_map *param_uses, + hash_map *local_var_uses, +- vec *param_dtor_list, +- tree fs_label, tree resume_fn_field, ++ vec *param_dtor_list, tree resume_fn_field, + unsigned body_count, tree frame_size) + { + verify_stmt_tree (fnbody); +@@ -2308,9 +2196,6 @@ build_actor_fn (location_t loc, tree coro_frame_type, tree actor, tree fnbody, + await_xform_data xform + = {actor, actor_frame, promise_proxy, ap, self_h_proxy, ash}; + +- /* Expand co_returns in the saved function body */ +- fnbody = expand_co_returns (&fnbody, promise_proxy, ap, fs_label); +- + /* Transform the await expressions in the function body. Only do each + await tree once! */ + hash_set pset; +@@ -2646,7 +2531,7 @@ register_await_info (tree await_expr, tree aw_type, tree aw_nam) + = suspend_points->get_or_insert (await_expr, &seen); + if (seen) + { +- error_at (EXPR_LOCATION (await_expr), "duplicate info for %qE", ++ warning_at (EXPR_LOCATION (await_expr), 0, "duplicate info for %qE", + await_expr); + return false; + } +@@ -2655,26 +2540,14 @@ register_await_info (tree await_expr, tree aw_type, tree aw_nam) + return true; + } + +-/* Small helper for the repetitive task of adding a new field to the coro +- frame type. */ +- +-static tree +-coro_make_frame_entry (tree *field_list, const char *name, tree fld_type, +- location_t loc) +-{ +- tree id = get_identifier (name); +- tree decl = build_decl (loc, FIELD_DECL, id, fld_type); +- DECL_CHAIN (decl) = *field_list; +- *field_list = decl; +- return id; +-} +- + /* This data set is used when analyzing statements for await expressions. */ + -+ Backported from master: -+ 2020-07-21 Harald Anlauf + struct susp_frame_data + { + /* Function-wide. */ + tree *field_list; /* The current coroutine frame field list. */ + tree handle_type; /* The self-handle type for this coroutine. */ ++ tree fs_label; /* The destination for co_returns. */ + vec *block_stack; /* Track block scopes. */ + vec *bind_stack; /* Track current bind expr. */ + unsigned await_number; /* Which await in the function. */ +@@ -2686,275 +2559,575 @@ struct susp_frame_data + unsigned saw_awaits; /* Count of awaits in this statement */ + bool captures_temporary; /* This expr captures temps by ref. */ + bool needs_truth_if_exp; /* We must expand a truth_if expression. */ ++ bool has_awaiter_init; /* We must handle initializing an awaiter. */ + }; + +-/* Walk the sub-tree looking for call expressions that both capture +- references and have compiler-temporaries as parms. */ ++/* If this is an await expression, then count it (both uniquely within the ++ function and locally within a single statement). */ + -+ PR fortran/89574 -+ * trans-decl.c (gfc_get_extern_function_decl): Check whether a -+ symbol belongs to a different module. ++static tree ++register_awaits (tree *stmt, int *, void *d) ++{ ++ tree aw_expr = *stmt; + -+2020-07-23 Thomas Koenig ++ /* We should have already lowered co_yields to their co_await. */ ++ gcc_checking_assert (TREE_CODE (aw_expr) != CO_YIELD_EXPR); + -+ Backported from master: -+ 2020-07-19 Thomas Koenig ++ if (TREE_CODE (aw_expr) != CO_AWAIT_EXPR) ++ return NULL_TREE; + -+ PR fortran/96220 -+ * dump-parse-tree.c (get_c_type_name): Always use the entries from -+ c_interop_kinds_table to find the correct C type. ++ /* Count how many awaits the current expression contains. */ ++ susp_frame_data *data = (susp_frame_data *) d; ++ data->saw_awaits++; ++ /* Each await suspend context is unique, this is a function-wide value. */ ++ data->await_number++; + -+2020-07-23 Thomas Koenig ++ /* Awaitables should either be user-locals or promoted to coroutine frame ++ entries at this point, and their initializers should have been broken ++ out. */ ++ tree aw = TREE_OPERAND (aw_expr, 1); ++ gcc_checking_assert (!TREE_OPERAND (aw_expr, 2)); + ++ tree aw_field_type = TREE_TYPE (aw); ++ tree aw_field_nam = NULL_TREE; ++ register_await_info (aw_expr, aw_field_type, aw_field_nam); + -+ PR fortran/96018 -+ * frontend-passes.c (gfc_check_externals): Adjust formatting. -+ (implicit_pure_call): New function. -+ (implicit_pure_expr): New function. -+ (gfc_fix_implicit_pure): New function. -+ * gfortran.h (gfc_fix_implicit_pure): New prototype. -+ * parse.c (translate_all_program_units): Call gfc_fix_implicit_pure. ++ /* Rewrite target expressions on the await_suspend () to remove extraneous ++ cleanups for the awaitables, which are now promoted to frame vars and ++ managed via that. */ ++ tree v = TREE_OPERAND (aw_expr, 3); ++ tree o = TREE_VEC_ELT (v, 1); ++ if (TREE_CODE (o) == TARGET_EXPR) ++ TREE_VEC_ELT (v, 1) = get_target_expr (TREE_OPERAND (o, 1)); ++ return NULL_TREE; ++} + - 2020-07-23 Release Manager - - * GCC 10.2.0 released. ---- a/src/gcc/fortran/class.c -+++ b/src/gcc/fortran/class.c -@@ -228,7 +228,7 @@ gfc_add_component_ref (gfc_expr *e, const char *name) - break; - tail = &((*tail)->next); - } -- if (derived->components && derived->components->next && -+ if (derived && derived->components && derived->components->next && - derived->components->next->ts.type == BT_DERIVED && - derived->components->next->ts.u.derived == NULL) ++/* There are cases where any await expression is relevant. */ + static tree +-captures_temporary (tree *stmt, int *do_subtree, void *d) ++find_any_await (tree *stmt, int *dosub, void *d) + { +- /* Stop recursing if we see an await expression, the subtrees +- of that will be handled when it is processed. */ +- if (TREE_CODE (*stmt) == CO_AWAIT_EXPR || TREE_CODE (*stmt) == CO_YIELD_EXPR) ++ if (TREE_CODE (*stmt) == CO_AWAIT_EXPR) { -@@ -663,6 +663,10 @@ gfc_build_class_symbol (gfc_typespec *ts, symbol_attribute *attr, +- *do_subtree = 0; +- return NULL_TREE; ++ *dosub = 0; /* We don't need to consider this any further. */ ++ tree **p = (tree **) d; ++ *p = stmt; ++ return *stmt; + } ++ return NULL_TREE; ++} - /* Determine the name of the encapsulating type. */ - rank = !(*as) || (*as)->rank == -1 ? GFC_MAX_DIMENSIONS : (*as)->rank; +- /* We're only interested in calls. */ +- if (TREE_CODE (*stmt) != CALL_EXPR) +- return NULL_TREE; ++static bool ++tmp_target_expr_p (tree t) ++{ ++ if (TREE_CODE (t) != TARGET_EXPR) ++ return false; ++ tree v = TREE_OPERAND (t, 0); ++ if (!DECL_ARTIFICIAL (v)) ++ return false; ++ if (DECL_NAME (v)) ++ return false; ++ return true; ++} ++ ++/* Structure to record sub-expressions that need to be handled by the ++ statement flattener. */ ++ ++struct coro_interesting_subtree ++{ ++ tree* entry; ++ hash_set *temps_used; ++}; + +- /* Does this call capture references? +- Strip the ADDRESS_EXPR to get the fn decl and inspect it. */ +- tree fn = TREE_OPERAND (CALL_EXPR_FN (*stmt), 0); +- bool is_meth = TREE_CODE (TREE_TYPE (fn)) == METHOD_TYPE; +- tree arg = TYPE_ARG_TYPES (TREE_TYPE (fn)); +- unsigned offset = 3; +- for (unsigned anum = 0; arg != NULL; arg = TREE_CHAIN (arg), anum++) ++/* tree-walk callback that returns the first encountered sub-expression of ++ a kind that needs to be handled specifically by the statement flattener. */ ++ ++static tree ++find_interesting_subtree (tree *expr_p, int *dosub, void *d) ++{ ++ tree expr = *expr_p; ++ coro_interesting_subtree *p = (coro_interesting_subtree *)d; ++ if (TREE_CODE (expr) == CO_AWAIT_EXPR) + { +- tree parm_type = TREE_VALUE (arg); +- if (anum == 0 && is_meth && INDIRECT_TYPE_P (parm_type)) ++ *dosub = 0; /* We don't need to consider this any further. */ ++ if (TREE_OPERAND (expr, 2)) + { +- /* Account for 'this' when the fn is a method. Unless it +- belongs to a CTOR or DTOR. */ +- if (DECL_CONSTRUCTOR_P (fn) || DECL_DESTRUCTOR_P (fn)) +- continue; ++ p->entry = expr_p; ++ return expr; + } +- else if (!TYPE_REF_P (parm_type)) +- /* If it's not a reference, we don't care. */ +- continue; ++ } ++ else if (tmp_target_expr_p (expr) ++ && !p->temps_used->contains (expr)) ++ { ++ p->entry = expr_p; ++ return expr; ++ } + +- /* Fetch the value presented to the fn. */ +- tree parm = TREE_OPERAND (*stmt, anum + offset); ++ return NULL_TREE; ++} + +- while (TREE_CODE (parm) == NOP_EXPR) +- parm = TREE_OPERAND (parm, 0); ++/* Node for a doubly-linked list of promoted variables and their ++ initializers. When the initializer is a conditional expression ++ the 'then' and 'else' clauses are represented by a linked list ++ attached to then_cl and else_cl respectively. */ + +- /* We only care if we're taking the addr of a temporary. */ +- if (TREE_CODE (parm) != ADDR_EXPR) +- continue; ++struct var_nest_node ++{ ++ var_nest_node () = default; ++ var_nest_node (tree v, tree i, var_nest_node *p, var_nest_node *n) ++ : var(v), init(i), prev(p), next(n) ++ { ++ if (p) ++ p->next = this; ++ if (n) ++ n->prev = this; ++ } ++ tree var; ++ tree init; ++ var_nest_node *prev; ++ var_nest_node *next; ++ var_nest_node *then_cl; ++ var_nest_node *else_cl; ++}; + +- parm = TREE_OPERAND (parm, 0); ++/* This is called for single statements from the co-await statement walker. ++ It checks to see if the statement contains any initializers for awaitables ++ and if any of these capture items by reference. */ + +- /* In case of component_ref, we need to capture the object of base +- class as if it is temporary object. There are two possibilities: +- (*base).field and base->field. */ +- while (TREE_CODE (parm) == COMPONENT_REF) ++static void ++flatten_await_stmt (var_nest_node *n, hash_set *promoted, ++ hash_set *temps_used, tree *replace_in) ++{ ++ bool init_expr = false; ++ switch (TREE_CODE (n->init)) ++ { ++ default: break; ++ /* Compound expressions must be flattened specifically. */ ++ case COMPOUND_EXPR: + { +- parm = TREE_OPERAND (parm, 0); +- if (TREE_CODE (parm) == INDIRECT_REF) +- parm = TREE_OPERAND (parm, 0); +- STRIP_NOPS (parm); ++ tree first = TREE_OPERAND (n->init, 0); ++ n->init = TREE_OPERAND (n->init, 1); ++ var_nest_node *ins ++ = new var_nest_node(NULL_TREE, first, n->prev, n); ++ /* The compiler (but not the user) can generate temporaries with ++ uses in the second arm of a compound expr. */ ++ flatten_await_stmt (ins, promoted, temps_used, &n->init); ++ flatten_await_stmt (n, promoted, temps_used, NULL); ++ /* The two arms have been processed separately. */ ++ return; + } ++ break; ++ /* Handle conditional expressions. */ ++ case INIT_EXPR: ++ init_expr = true; ++ /* FALLTHROUGH */ ++ case MODIFY_EXPR: ++ { ++ tree old_expr = TREE_OPERAND (n->init, 1); ++ if (TREE_CODE (old_expr) == COMPOUND_EXPR) ++ { ++ tree first = TREE_OPERAND (old_expr, 0); ++ TREE_OPERAND (n->init, 1) = TREE_OPERAND (old_expr, 1); ++ var_nest_node *ins ++ = new var_nest_node(NULL_TREE, first, n->prev, n); ++ flatten_await_stmt (ins, promoted, temps_used, ++ &TREE_OPERAND (n->init, 1)); ++ flatten_await_stmt (n, promoted, temps_used, NULL); ++ return; ++ } ++ if (TREE_CODE (old_expr) != COND_EXPR) ++ break; ++ /* Reconstruct x = t ? y : z; ++ as (void) t ? x = y : x = z; */ ++ tree var = TREE_OPERAND (n->init, 0); ++ tree var_type = TREE_TYPE (var); ++ tree cond = COND_EXPR_COND (old_expr); ++ /* We are allowed a void type throw in one or both of the cond ++ expr arms. */ ++ tree then_cl = COND_EXPR_THEN (old_expr); ++ if (!VOID_TYPE_P (TREE_TYPE (then_cl))) ++ { ++ gcc_checking_assert (TREE_CODE (then_cl) != STATEMENT_LIST); ++ then_cl ++ = build2 (init_expr ? INIT_EXPR : MODIFY_EXPR, var_type, ++ var, then_cl); ++ } ++ tree else_cl = COND_EXPR_ELSE (old_expr); ++ if (!VOID_TYPE_P (TREE_TYPE (else_cl))) ++ { ++ gcc_checking_assert (TREE_CODE (then_cl) != STATEMENT_LIST); ++ else_cl ++ = build2 (init_expr ? INIT_EXPR : MODIFY_EXPR, var_type, ++ var, else_cl); ++ } ++ n->init = build3 (COND_EXPR, var_type, cond, then_cl, else_cl); ++ } ++ /* FALLTHROUGH */ ++ case COND_EXPR: ++ { ++ tree *found; ++ tree cond = COND_EXPR_COND (n->init); ++ /* If the condition contains an await expression, then we need to ++ set that first and use a separate var. */ ++ if (cp_walk_tree (&cond, find_any_await, &found, NULL)) ++ { ++ tree cond_type = TREE_TYPE (cond); ++ tree cond_var = build_lang_decl (VAR_DECL, NULL_TREE, cond_type); ++ DECL_ARTIFICIAL (cond_var) = true; ++ layout_decl (cond_var, 0); ++ gcc_checking_assert (!TYPE_NEEDS_CONSTRUCTING (cond_type)); ++ cond = build2 (INIT_EXPR, cond_type, cond_var, cond); ++ var_nest_node *ins ++ = new var_nest_node (cond_var, cond, n->prev, n); ++ COND_EXPR_COND (n->init) = cond_var; ++ flatten_await_stmt (ins, promoted, temps_used, NULL); ++ } + +- /* This isn't a temporary. */ +- if ((VAR_P (parm) +- && (!DECL_ARTIFICIAL (parm) || DECL_HAS_VALUE_EXPR_P (parm))) +- || TREE_CODE (parm) == PARM_DECL +- || TREE_CODE (parm) == NON_LVALUE_EXPR) +- continue; +- +- if (TREE_CODE (parm) == TARGET_EXPR) ++ n->then_cl ++ = new var_nest_node (n->var, COND_EXPR_THEN (n->init), NULL, NULL); ++ n->else_cl ++ = new var_nest_node (n->var, COND_EXPR_ELSE (n->init), NULL, NULL); ++ flatten_await_stmt (n->then_cl, promoted, temps_used, NULL); ++ /* Point to the start of the flattened code. */ ++ while (n->then_cl->prev) ++ n->then_cl = n->then_cl->prev; ++ flatten_await_stmt (n->else_cl, promoted, temps_used, NULL); ++ while (n->else_cl->prev) ++ n->else_cl = n->else_cl->prev; ++ return; ++ } ++ break; ++ } ++ coro_interesting_subtree v = { NULL, temps_used }; ++ tree t = cp_walk_tree (&n->init, find_interesting_subtree, (void *)&v, NULL); ++ if (!t) ++ return; ++ switch (TREE_CODE (t)) ++ { ++ default: break; ++ case CO_AWAIT_EXPR: + { +- /* We're taking the address of a temporary and using it as a ref. */ +- tree tvar = TREE_OPERAND (parm, 0); +- gcc_checking_assert (DECL_ARTIFICIAL (tvar)); +- +- susp_frame_data *data = (susp_frame_data *) d; +- data->captures_temporary = true; +- /* Record this one so we don't duplicate, and on the first +- occurrence note the target expr to be replaced. */ +- if (!data->captured_temps.add (tvar)) +- vec_safe_push (data->to_replace, parm); +- /* Now see if the initializer contains any more cases. */ +- hash_set visited; +- tree res = cp_walk_tree (&TREE_OPERAND (parm, 1), +- captures_temporary, d, &visited); +- if (res) +- return res; +- /* Otherwise, we're done with sub-trees for this. */ ++ /* Await expressions with initializers have a compiler-temporary ++ as the awaitable. 'promote' this. */ ++ tree var = TREE_OPERAND (t, 1); ++ bool already_present = promoted->add (var); ++ gcc_checking_assert (!already_present); ++ tree init = TREE_OPERAND (t, 2); ++ switch (TREE_CODE (init)) ++ { ++ default: break; ++ case INIT_EXPR: ++ case MODIFY_EXPR: ++ { ++ tree inner = TREE_OPERAND (init, 1); ++ /* We can have non-lvalue-expressions here, but when we see ++ a target expression, mark it as already used. */ ++ if (TREE_CODE (inner) == TARGET_EXPR) ++ { ++ temps_used->add (inner); ++ gcc_checking_assert ++ (TREE_CODE (TREE_OPERAND (inner, 1)) != COND_EXPR); ++ } ++ } ++ break; ++ case CALL_EXPR: ++ /* If this is a call and not a CTOR, then we didn't expect it. */ ++ gcc_checking_assert ++ (DECL_CONSTRUCTOR_P (TREE_OPERAND (CALL_EXPR_FN (init), 0))); ++ break; ++ } ++ var_nest_node *ins = new var_nest_node (var, init, n->prev, n); ++ TREE_OPERAND (t, 2) = NULL_TREE; ++ flatten_await_stmt (ins, promoted, temps_used, NULL); ++ flatten_await_stmt (n, promoted, temps_used, NULL); ++ return; + } +- else if (TREE_CODE (parm) == CO_AWAIT_EXPR) ++ break; ++ case TARGET_EXPR: + { +- /* CO_AWAIT expressions behave in a similar manner to target +- expressions when the await_resume call is contained in one. */ +- tree awr = TREE_OPERAND (parm, 3); /* call vector. */ +- awr = TREE_VEC_ELT (awr, 2); /* resume call. */ +- if (TREE_CODE (awr) == TARGET_EXPR) ++ /* We have a temporary; promote it. */ ++ tree init = t; ++ temps_used->add (init); ++ tree var_type = TREE_TYPE (init); ++ char *buf = xasprintf ("D.%d", DECL_UID (TREE_OPERAND (init, 0))); ++ tree var = build_lang_decl (VAR_DECL, get_identifier (buf), var_type); ++ DECL_ARTIFICIAL (var) = true; ++ free (buf); ++ bool already_present = promoted->add (var); ++ gcc_checking_assert (!already_present); ++ tree inner = TREE_OPERAND (init, 1); ++ gcc_checking_assert (TREE_CODE (inner) != COND_EXPR); ++ if (TYPE_NEEDS_CONSTRUCTING (var_type)) + { +- tree tvar = TREE_OPERAND (awr, 0); +- gcc_checking_assert (DECL_ARTIFICIAL (tvar)); +- +- susp_frame_data *data = (susp_frame_data *) d; +- data->captures_temporary = true; +- /* Use this as a place-holder. */ +- if (!data->captured_temps.add (tvar)) +- vec_safe_push (data->to_replace, parm); ++ releasing_vec p_in (make_tree_vector_single (init)); ++ init = build_special_member_call (var, complete_ctor_identifier, ++ &p_in, var_type, LOOKUP_NORMAL, ++ tf_warning_or_error); + } +- /* We will walk the sub-trees of this co_await separately. */ ++ else ++ init = build2 (INIT_EXPR, var_type, var, init); ++ var_nest_node *ins ++ = new var_nest_node (var, init, n->prev, n); ++ /* We have to replace the target expr... */ ++ proxy_replace pr = {TREE_OPERAND (t, 0), var}; ++ *v.entry = var; ++ /* ... and any uses of its var. */ ++ cp_walk_tree (&n->init, replace_proxy, &pr, NULL); ++ /* Compiler-generated temporaries can also have uses in following ++ arms of compound expressions, which will be listed in 'replace_in' ++ if present. */ ++ if (replace_in) ++ cp_walk_tree (replace_in, replace_proxy, &pr, NULL); ++ flatten_await_stmt (ins, promoted, temps_used, NULL); ++ flatten_await_stmt (n, promoted, temps_used, NULL); ++ return; + } +- else +- gcc_unreachable (); ++ break; + } +- /* As far as it's necessary, we've walked the subtrees of the call +- expr. */ +- *do_subtree = 0; +- return NULL_TREE; + } + +-/* If this is an await, then register it and decide on what coro +- frame storage is needed. +- If this is a co_yield (which embeds an await), drop the yield +- and record the await (the yield was kept for diagnostics only). */ ++/* Helper for 'process_conditional' that handles recursion into nested ++ conditionals. */ + +-static tree +-register_awaits (tree *stmt, int *do_subtree ATTRIBUTE_UNUSED, void *d) ++static void ++handle_nested_conditionals (var_nest_node *n, vec& list, ++ hash_map& map) + { +- susp_frame_data *data = (susp_frame_data *) d; ++ do ++ { ++ if (n->var && DECL_NAME (n->var)) ++ { ++ list.safe_push (n->var); ++ if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (TREE_TYPE (n->var))) ++ { ++ bool existed; ++ tree& flag = map.get_or_insert (n->var, &existed); ++ if (!existed) ++ { ++ /* We didn't see this var before and it needs a DTOR, so ++ build a guard variable for it. */ ++ char *nam ++ = xasprintf ("%s_guard", ++ IDENTIFIER_POINTER (DECL_NAME (n->var))); ++ flag = build_lang_decl (VAR_DECL, get_identifier (nam), ++ boolean_type_node); ++ free (nam); ++ DECL_ARTIFICIAL (flag) = true; ++ } ++ ++ /* The initializer for this variable is replaced by a compound ++ expression that performs the init and then records that the ++ variable is live (and the DTOR should be run at the scope ++ exit. */ ++ tree set_flag = build2 (INIT_EXPR, boolean_type_node, ++ flag, boolean_true_node); ++ n->init ++ = build2 (COMPOUND_EXPR, boolean_type_node, n->init, set_flag); ++ } ++ } ++ if (TREE_CODE (n->init) == COND_EXPR) ++ { ++ tree new_then = push_stmt_list (); ++ handle_nested_conditionals (n->then_cl, list, map); ++ new_then = pop_stmt_list (new_then); ++ tree new_else = push_stmt_list (); ++ handle_nested_conditionals (n->else_cl, list, map); ++ new_else = pop_stmt_list (new_else); ++ tree new_if ++ = build4 (IF_STMT, void_type_node, COND_EXPR_COND (n->init), ++ new_then, new_else, NULL_TREE); ++ add_stmt (new_if); ++ } ++ else ++ finish_expr_stmt (n->init); ++ n = n->next; ++ } while (n); ++} + +- if (TREE_CODE (*stmt) != CO_AWAIT_EXPR && TREE_CODE (*stmt) != CO_YIELD_EXPR) +- return NULL_TREE; ++/* helper for 'maybe_promote_temps'. + +- tree aw_expr = *stmt; +- location_t aw_loc = EXPR_LOCATION (aw_expr); /* location of the co_xxxx. */ +- /* co_yield is syntactic sugar, re-write it to co_await. */ +- if (TREE_CODE (aw_expr) == CO_YIELD_EXPR) ++ When we have a conditional expression which might embed await expressions ++ and/or promoted variables, we need to handle it appropriately. ++ ++ The linked lists for the 'then' and 'else' clauses in a conditional node ++ identify the promoted variables (but these cannot be wrapped in a regular ++ cleanup). ++ ++ So recurse through the lists and build up a composite list of captured vars. ++ Declare these and any guard variables needed to decide if a DTOR should be ++ run. Then embed the conditional into a try-finally expression that handles ++ running each DTOR conditionally on its guard variable. */ ++ ++static void ++process_conditional (var_nest_node *n, tree& vlist) ++{ ++ tree init = n->init; ++ hash_map var_flags; ++ vec var_list = vNULL; ++ tree new_then = push_stmt_list (); ++ handle_nested_conditionals (n->then_cl, var_list, var_flags); ++ new_then = pop_stmt_list (new_then); ++ tree new_else = push_stmt_list (); ++ handle_nested_conditionals (n->else_cl, var_list, var_flags); ++ new_else = pop_stmt_list (new_else); ++ /* Declare the vars. There are two loops so that the boolean flags are ++ grouped in the frame. */ ++ for (unsigned i = 0; i < var_list.length(); i++) + { +- aw_expr = TREE_OPERAND (aw_expr, 1); +- *stmt = aw_expr; ++ tree var = var_list[i]; ++ DECL_CHAIN (var) = vlist; ++ vlist = var; ++ add_decl_expr (var); + } +- +- /* If the awaitable is a parm or a local variable, then we already have +- a frame copy, so don't make a new one. */ +- tree aw = TREE_OPERAND (aw_expr, 1); +- tree o = TREE_OPERAND (aw_expr, 2); /* Initializer for the frame var. */ +- /* If we have an initializer, then the var is a temp and we need to make +- it in the frame. */ +- tree aw_field_type = TREE_TYPE (aw); +- tree aw_field_nam = NULL_TREE; +- if (o) ++ /* Define the guard flags for variables that need a DTOR. */ ++ for (unsigned i = 0; i < var_list.length(); i++) ++ { ++ tree *flag = var_flags.get (var_list[i]); ++ if (flag) ++ { ++ DECL_INITIAL (*flag) = boolean_false_node; ++ DECL_CHAIN (*flag) = vlist; ++ vlist = *flag; ++ add_decl_expr (*flag); ++ } ++ } ++ tree new_if ++ = build4 (IF_STMT, void_type_node, COND_EXPR_COND (init), ++ new_then, new_else, NULL_TREE); ++ /* Build a set of conditional DTORs. */ ++ tree final_actions = push_stmt_list (); ++ while (!var_list.is_empty()) + { +- /* The required field has the same type as the proxy stored in the +- await expr. */ +- char *nam = xasprintf ("__aw_s.%d", data->await_number); +- aw_field_nam = coro_make_frame_entry (data->field_list, nam, +- aw_field_type, aw_loc); +- free (nam); +- +- /* If the init is a target expression, then we need to remake it to +- strip off any extra cleanups added. */ +- if (o && TREE_CODE (o) == TARGET_EXPR) +- TREE_OPERAND (aw_expr, 2) = get_target_expr (TREE_OPERAND (o, 1)); ++ tree var = var_list.pop (); ++ tree *flag = var_flags.get (var); ++ if (!flag) ++ continue; ++ tree var_type = TREE_TYPE (var); ++ tree cleanup ++ = build_special_member_call (var, complete_dtor_identifier, ++ NULL, var_type, LOOKUP_NORMAL, ++ tf_warning_or_error); ++ tree cond_cleanup = begin_if_stmt (); ++ finish_if_stmt_cond (*flag, cond_cleanup); ++ finish_expr_stmt (cleanup); ++ finish_then_clause (cond_cleanup); ++ finish_if_stmt (cond_cleanup); + } ++ final_actions = pop_stmt_list (final_actions); ++ tree try_finally ++ = build2 (TRY_FINALLY_EXPR, void_type_node, new_if, final_actions); ++ add_stmt (try_finally); ++} + +- tree v = TREE_OPERAND (aw_expr, 3); +- o = TREE_VEC_ELT (v, 1); +- if (TREE_CODE (o) == TARGET_EXPR) +- TREE_VEC_ELT (v, 1) = get_target_expr (TREE_OPERAND (o, 1)); ++/* Given *STMT, that contains at least one await expression. + +- register_await_info (aw_expr, aw_field_type, aw_field_nam); ++ The full expression represented in the original source code will contain ++ suspension points, but it is still required that the lifetime of temporary ++ values extends to the end of the expression. + +- /* Count how many awaits the current expression contains. */ +- data->saw_awaits++; +- /* Each await suspend context is unique, this is a function-wide value. */ +- data->await_number++; +- +- /* We now need to know if to take special action on lifetime extension +- of temporaries captured by reference. This can only happen if such +- a case appears in the initializer for the awaitable. The callback +- records captured temporaries including subtrees of initializers. */ +- hash_set visited; +- tree res = cp_walk_tree (&TREE_OPERAND (aw_expr, 2), captures_temporary, d, +- &visited); +- return res; +-} ++ We already have a mechanism to 'promote' user-authored local variables ++ to a coroutine frame counterpart (which allows explicit management of the ++ lifetime across suspensions). The transform here re-writes STMT into ++ a bind expression, promotes temporary values into local variables in that ++ and flattens the statement into a series of cleanups. + +-/* The gimplifier correctly extends the lifetime of temporaries captured +- by reference (per. [class.temporary] (6.9) "A temporary object bound +- to a reference parameter in a function call persists until the completion +- of the full-expression containing the call"). However, that is not +- sufficient to work across a suspension - and we need to promote such +- temporaries to be regular vars that will then get a coro frame slot. +- We don't want to incur the effort of checking for this unless we have +- an await expression in the current full expression. */ +- +-/* This takes the statement which contains one or more temporaries that have +- been 'captured' by reference in the initializer(s) of co_await(s). +- The statement is replaced by a bind expression that has actual variables +- to replace the temporaries. These variables will be added to the coro- +- frame in the same manner as user-authored ones. */ ++ Conditional expressions are re-written to regular 'if' statements. ++ The cleanups for variables initialized inside a conditional (including ++ nested cases) are wrapped in a try-finally clause, with guard variables ++ to determine which DTORs need to be run. */ + +-static void +-replace_statement_captures (tree *stmt, void *d) ++static tree ++maybe_promote_temps (tree *stmt, void *d) + { + susp_frame_data *awpts = (susp_frame_data *) d; ++ + location_t sloc = EXPR_LOCATION (*stmt); +- tree aw_bind +- = build3_loc (sloc, BIND_EXPR, void_type_node, NULL, NULL, NULL); +- +- /* Any cleanup point expression might no longer be necessary, since we +- are removing one or more temporaries. */ +- tree aw_statement_current = *stmt; +- if (TREE_CODE (aw_statement_current) == CLEANUP_POINT_EXPR) +- aw_statement_current = TREE_OPERAND (aw_statement_current, 0); +- +- /* Collected the scope vars we need move the temps to regular. */ +- tree aw_bind_body = push_stmt_list (); +- tree varlist = NULL_TREE; +- int vnum = -1; +- while (!awpts->to_replace->is_empty ()) ++ tree expr = *stmt; ++ /* Strip off uninteresting wrappers. */ ++ if (TREE_CODE (expr) == CLEANUP_POINT_EXPR) ++ expr = TREE_OPERAND (expr, 0); ++ if (TREE_CODE (expr) == EXPR_STMT) ++ expr = EXPR_STMT_EXPR (expr); ++ if (TREE_CODE (expr) == CONVERT_EXPR ++ && VOID_TYPE_P (TREE_TYPE (expr))) ++ expr = TREE_OPERAND (expr, 0); ++ STRIP_NOPS (expr); ++ ++ /* We walk the statement trees, flattening it into an ordered list of ++ variables with initializers and fragments corresponding to compound ++ expressions, truth or/and if and ternary conditionals. Conditional ++ expressions carry a nested list of fragments for the then and else ++ clauses. We anchor to the 'bottom' of the fragment list; we will write ++ a cleanup nest with one shell for each variable initialized. */ ++ var_nest_node *root = new var_nest_node (NULL_TREE, expr, NULL, NULL); ++ /* Check to see we didn't promote one twice. */ ++ hash_set promoted_vars; ++ hash_set used_temps; ++ flatten_await_stmt (root, &promoted_vars, &used_temps, NULL); ++ ++ gcc_checking_assert (root->next == NULL); ++ tree vlist = NULL_TREE; ++ var_nest_node *t = root; ++ gcc_checking_assert (!t->var); ++ /* We build the bind scope expression from the bottom-up. ++ EXPR_LIST holds the inner expression nest at the current cleanup ++ level (becoming the final expression list when we've exhausted the ++ number of sub-expression fragments). */ ++ tree expr_list = NULL_TREE; ++ do + { +- tree to_replace = awpts->to_replace->pop (); +- tree orig_temp; +- if (TREE_CODE (to_replace) == CO_AWAIT_EXPR) ++ tree new_list = push_stmt_list (); ++ /* When we have a promoted variable, then add that to the bind scope ++ and initialize it. When there's no promoted variable, we just need ++ to run the initializer. ++ If the initializer is a conditional expression, we need to collect ++ and declare any promoted variables nested within it. DTORs for such ++ variables must be run conditionally too. */ ++ if (t->var && DECL_NAME (t->var)) + { +- orig_temp = TREE_OPERAND (to_replace, 3); +- orig_temp = TREE_VEC_ELT (orig_temp, 2); +- orig_temp = TREE_OPERAND (orig_temp, 0); ++ tree var = t->var; ++ DECL_CHAIN (var) = vlist; ++ vlist = var; ++ add_decl_expr (var); ++ if (TREE_CODE (t->init) == COND_EXPR) ++ process_conditional (t, vlist); ++ else ++ finish_expr_stmt (t->init); ++ tree var_type = TREE_TYPE (var); ++ if (TYPE_HAS_NONTRIVIAL_DESTRUCTOR (var_type)) ++ { ++ tree cleanup ++ = build_special_member_call (var, complete_dtor_identifier, ++ NULL, var_type, LOOKUP_NORMAL, ++ tf_warning_or_error); ++ tree cl = build_stmt (sloc, CLEANUP_STMT, expr_list, cleanup, var); ++ add_stmt (cl); /* push this onto the level above. */ ++ } ++ else if (expr_list) ++ add_stmt (expr_list); ++ else ++ gcc_unreachable (); + } + else +- orig_temp = TREE_OPERAND (to_replace, 0); +- +- tree var_type = TREE_TYPE (orig_temp); +- gcc_checking_assert (same_type_p (TREE_TYPE (to_replace), var_type)); +- /* Build a variable to hold the captured value, this will be included +- in the frame along with any user-authored locals. */ +- char *nam = xasprintf ("aw_%d.tmp.%d", awpts->await_number, ++vnum); +- tree newvar = build_lang_decl (VAR_DECL, get_identifier (nam), var_type); +- free (nam); +- /* If we have better location than the whole expression use that, else +- fall back to the expression loc. */ +- DECL_CONTEXT (newvar) = DECL_CONTEXT (orig_temp); +- if (DECL_SOURCE_LOCATION (orig_temp)) +- sloc = DECL_SOURCE_LOCATION (orig_temp); +- else +- sloc = EXPR_LOCATION (*stmt); +- DECL_SOURCE_LOCATION (newvar) = sloc; +- DECL_CHAIN (newvar) = varlist; +- varlist = newvar; /* Chain it onto the list for the bind expr. */ +- /* Declare and initialize it in the new bind scope. */ +- add_decl_expr (newvar); +- tree new_s = build2_loc (sloc, INIT_EXPR, var_type, newvar, to_replace); +- new_s = coro_build_cvt_void_expr_stmt (new_s, sloc); +- add_stmt (new_s); +- +- /* Replace all instances of that temp in the original expr. */ +- proxy_replace pr = {to_replace, newvar}; +- cp_walk_tree (&aw_statement_current, replace_proxy, &pr, NULL); +- } +- +- /* What's left should be the original statement with any co_await captured +- temporaries broken out. Other temporaries might remain so see if we +- need to wrap the revised statement in a cleanup. */ +- aw_statement_current = maybe_cleanup_point_expr_void (aw_statement_current); +- add_stmt (aw_statement_current); +- +- BIND_EXPR_BODY (aw_bind) = pop_stmt_list (aw_bind_body); +- awpts->captured_temps.empty (); +- +- BIND_EXPR_VARS (aw_bind) = nreverse (varlist); ++ { ++ if (TREE_CODE (t->init) == COND_EXPR) ++ process_conditional (t, vlist); ++ else ++ finish_expr_stmt (t->init); ++ if (expr_list) ++ add_stmt (expr_list); ++ } ++ expr_list = pop_stmt_list (new_list); ++ var_nest_node *old = t; ++ t = t->prev; ++ delete old; ++ } while (t); ++ ++ /* Now produce the bind expression containing the 'promoted' temporaries ++ as its variable list, and the cleanup nest as the statement. */ ++ tree await_bind = build3_loc (sloc, BIND_EXPR, void_type_node, ++ NULL, NULL, NULL); ++ BIND_EXPR_BODY (await_bind) = expr_list; ++ BIND_EXPR_VARS (await_bind) = nreverse (vlist); + tree b_block = make_node (BLOCK); + if (!awpts->block_stack->is_empty ()) + { +@@ -2966,37 +3139,12 @@ replace_statement_captures (tree *stmt, void *d) + BLOCK_SUBBLOCKS (s_block) = b_block; + } + } +- BIND_EXPR_BLOCK (aw_bind) = b_block; +- TREE_SIDE_EFFECTS (aw_bind) = TREE_SIDE_EFFECTS (BIND_EXPR_BODY (aw_bind)); +- *stmt = aw_bind; +-} +- +-/* This is called for single statements from the co-await statement walker. +- It checks to see if the statement contains any co-awaits and, if so, +- whether any of these 'capture' a temporary by reference. */ +- +-static tree +-maybe_promote_captured_temps (tree *stmt, void *d) +-{ +- susp_frame_data *awpts = (susp_frame_data *) d; ++ BLOCK_VARS (b_block) = BIND_EXPR_VARS (await_bind) ; ++ BIND_EXPR_BLOCK (await_bind) = b_block; ++ TREE_SIDE_EFFECTS (await_bind) = TREE_SIDE_EFFECTS (BIND_EXPR_BODY (await_bind)); ++ *stmt = await_bind; + hash_set visited; +- awpts->saw_awaits = 0; +- +- /* When register_awaits sees an await, it walks the initializer for +- that await looking for temporaries captured by reference and notes +- them in awpts->captured_temps. */ +- +- if (tree res = cp_walk_tree (stmt, register_awaits, d, &visited)) +- return res; /* We saw some reason to abort the tree walk. */ +- +- /* We only need to take any action here if the statement contained any +- awaits and any of those had temporaries captured by reference in their +- initializers. */ +- +- if (awpts->saw_awaits > 0 && !awpts->captured_temps.is_empty ()) +- replace_statement_captures (stmt, d); +- +- return NULL_TREE; ++ return cp_walk_tree (stmt, register_awaits, d, &visited); + } + + /* Lightweight callback to determine two key factors: +@@ -3005,6 +3153,7 @@ maybe_promote_captured_temps (tree *stmt, void *d) + TRUTH_{AND,OR}IF_EXPRs since, in most cases, they will need expansion + so that the await expressions are not processed in the case of the + short-circuit arm. ++ + CO_YIELD expressions are re-written to their underlying co_await. */ + + static tree +@@ -3021,6 +3170,9 @@ analyze_expression_awaits (tree *stmt, int *do_subtree, void *d) + /* FALLTHROUGH */ + case CO_AWAIT_EXPR: + awpts->saw_awaits++; ++ /* A non-null initializer for the awaiter means we need to expand. */ ++ if (TREE_OPERAND (*stmt, 2)) ++ awpts->has_awaiter_init = true; + break; + case TRUTH_ANDIF_EXPR: + case TRUTH_ORIF_EXPR: +@@ -3054,15 +3206,13 @@ analyze_expression_awaits (tree *stmt, int *do_subtree, void *d) + + /* Given *EXPR + If EXPR contains a TRUTH_{AND,OR}IF_EXPR, TAOIE with an await expr on +- the conditional branch expand this to: ++ the conditionally executed branch, change this in a ternary operator. + + bool not_expr = TAOIE == TRUTH_ORIF_EXPR ? NOT : NOP; +- A) bool t = always exec expr +- if (not_expr (t)) +- B) t = conditionally exec expr +- c) EXPR' = EXPR with TAOIE replaced by t. ++ not_expr (always-exec expr) ? conditionally-exec expr : not_expr; + +- Then repeat this for A, B and C. */ ++ Apply this recursively to the condition and the conditionally-exec ++ branch. */ + + struct truth_if_transform { + tree *orig_stmt; +@@ -3088,47 +3238,26 @@ expand_one_truth_if (tree *expr, int *do_subtree, void *d) + break; + + location_t sloc = EXPR_LOCATION (*expr); +- tree type = TREE_TYPE (xform->scratch_var); +- gcc_checking_assert (TREE_CODE (type) == BOOLEAN_TYPE); +- tree new_list = push_stmt_list (); +- /* Init our scratch with the unconditionally-evaluated expr. */ +- tree new_s = build2_loc (sloc, INIT_EXPR, boolean_type_node, +- xform->scratch_var, +- TREE_OPERAND (*expr, 0)); +- finish_expr_stmt (new_s); +- tree *pre = tsi_stmt_ptr (tsi_last (new_list)); +- tree if_cond = xform->scratch_var; ++ /* Transform truth expression into a cond expression with ++ * the always-executed arm as the condition. ++ * the conditionally-executed arm as the then clause. ++ * the 'else' clause is fixed: 'true' for ||,'false' for &&. */ ++ tree cond = TREE_OPERAND (*expr, 0); ++ tree test1 = TREE_OPERAND (*expr, 1); ++ tree fixed = needs_not ? boolean_true_node : boolean_false_node; + if (needs_not) +- if_cond = build1 (TRUTH_NOT_EXPR, boolean_type_node, if_cond); +- tree if_stmt = begin_if_stmt (); +- finish_if_stmt_cond (if_cond, if_stmt); +- /* If we take the if branch, then overwrite scratch with the cond +- executed branch. */ +- new_s = build2 (INIT_EXPR, boolean_type_node, +- xform->scratch_var, TREE_OPERAND (*expr, 1)); +- finish_expr_stmt (new_s); +- finish_then_clause (if_stmt); +- finish_if_stmt (if_stmt); +- *expr = xform->scratch_var; /* now contains the result. */ +- /* So now we've got a statement list expanding one TAOIe. */ +- add_stmt (*xform->orig_stmt); +- tree *post = tsi_stmt_ptr (tsi_last (new_list)); +- *xform->orig_stmt = pop_stmt_list (new_list); +- /* Now recurse into the pre, if and post parts. */ +- truth_if_transform sub_data = {pre, xform->scratch_var, +- xform->truth_aoif_to_expand}; +- if (tree res = cp_walk_tree (pre, expand_one_truth_if, &sub_data, +- NULL)) +- return res; +- sub_data.orig_stmt = &THEN_CLAUSE (if_stmt); +- if (tree res = cp_walk_tree (&THEN_CLAUSE (if_stmt), +- expand_one_truth_if, &sub_data, NULL)) ++ cond = build1 (TRUTH_NOT_EXPR, boolean_type_node, cond); ++ tree cond_expr ++ = build3_loc (sloc, COND_EXPR, boolean_type_node, ++ cond, test1, fixed); ++ *expr = cond_expr; ++ if (tree res = cp_walk_tree (&COND_EXPR_COND (*expr), ++ expand_one_truth_if, d, NULL)) + return res; +- sub_data.orig_stmt = post; +- if (tree res = cp_walk_tree (post, expand_one_truth_if, &sub_data, +- NULL)) ++ if (tree res = cp_walk_tree (&COND_EXPR_THEN (*expr), ++ expand_one_truth_if, d, NULL)) + return res; +- /* We've done the sub-trees here. */ ++ /* We've manually processed necessary sub-trees here. */ + *do_subtree = 0; + } + break; +@@ -3143,7 +3272,6 @@ static tree + add_var_to_bind (tree& bind, tree var_type, + const char *nam_root, unsigned nam_vers) + { +- + tree b_vars = BIND_EXPR_VARS (bind); + /* Build a variable to hold the condition, this will be included in the + frame as a local var. */ +@@ -3209,14 +3337,20 @@ await_statement_walker (tree *stmt, int *do_subtree, void *d) + } + + /* We have something to be handled as a single statement. */ ++ bool has_cleanup_wrapper = TREE_CODE (*stmt) == CLEANUP_POINT_EXPR; + hash_set visited; + awpts->saw_awaits = 0; + hash_set truth_aoif_to_expand; + awpts->truth_aoif_to_expand = &truth_aoif_to_expand; + awpts->needs_truth_if_exp = false; +- +- if (STATEMENT_CLASS_P (*stmt)) +- switch (TREE_CODE (*stmt)) ++ awpts->has_awaiter_init = false; ++ tree expr = *stmt; ++ if (has_cleanup_wrapper) ++ expr = TREE_OPERAND (expr, 0); ++ STRIP_NOPS (expr); ++ ++ if (STATEMENT_CLASS_P (expr)) ++ switch (TREE_CODE (expr)) + { + /* Unless it's a special case, just walk the subtrees as usual. */ + default: return NULL_TREE; +@@ -3256,13 +3390,6 @@ await_statement_walker (tree *stmt, int *do_subtree, void *d) + tree new_s = build2_loc (sloc, MODIFY_EXPR, boolean_type_node, + newvar, cond_inner); + finish_expr_stmt (new_s); +- if (awpts->needs_truth_if_exp) +- { +- tree *sp = tsi_stmt_ptr (tsi_last (insert_list)); +- truth_if_transform xf = {sp, newvar, &truth_aoif_to_expand}; +- if ((res = cp_walk_tree (sp, expand_one_truth_if, &xf, NULL))) +- return res; +- } + IF_COND (if_stmt) = newvar; + add_stmt (if_stmt); + *stmt = pop_stmt_list (insert_list); +@@ -3328,7 +3455,6 @@ await_statement_walker (tree *stmt, int *do_subtree, void *d) + d, NULL); + *do_subtree = 0; /* Done subtrees. */ + return res; +- + } + break; + case SWITCH_STMT: +@@ -3372,8 +3498,57 @@ await_statement_walker (tree *stmt, int *do_subtree, void *d) + return res; + } + break; ++ case CO_RETURN_EXPR: ++ { ++ /* Expand the co_return as per [stmt.return.coroutine] ++ - for co_return; ++ { p.return_void (); goto final_suspend; } ++ - for co_return [void expr]; ++ { expr; p.return_void(); goto final_suspend;} ++ - for co_return [non void expr]; ++ { p.return_value(expr); goto final_suspend; } */ ++ if ((res = cp_walk_tree (stmt, analyze_expression_awaits, ++ d, &visited))) ++ return res; ++ location_t loc = EXPR_LOCATION (expr); ++ tree call = TREE_OPERAND (expr, 1); ++ expr = TREE_OPERAND (expr, 0); ++ tree ret_list = push_stmt_list (); ++ /* [stmt.return.coroutine], 2.2 ++ If expr is present and void, it is placed immediately before ++ the call for return_void; */ ++ tree *maybe_await_stmt = NULL; ++ if (expr && VOID_TYPE_P (TREE_TYPE (expr))) ++ { ++ finish_expr_stmt (expr); ++ /* If the return argument was a void expression, then any ++ awaits must be contained in that. */ ++ maybe_await_stmt = tsi_stmt_ptr (tsi_last (ret_list)); ++ } ++ /* Insert p.return_{void,value(expr)}. */ ++ finish_expr_stmt (call); ++ /* Absent a return of a void expression, any awaits must be in ++ the parameter to return_value(). */ ++ if (!maybe_await_stmt) ++ maybe_await_stmt = tsi_stmt_ptr (tsi_last (ret_list)); ++ expr = build1_loc (loc, GOTO_EXPR, void_type_node, awpts->fs_label); ++ finish_expr_stmt (expr); ++ *stmt = pop_stmt_list (ret_list); ++ /* Once this is complete, we will have processed subtrees. */ ++ *do_subtree = 0; ++ if (awpts->saw_awaits) ++ { ++ gcc_checking_assert (maybe_await_stmt); ++ res = cp_walk_tree (maybe_await_stmt, await_statement_walker, ++ d, NULL); ++ if (res) ++ return res; ++ } ++ return NULL_TREE; /* Done. */ ++ } ++ break; + } +- else if (EXPR_P (*stmt)) ++ else if (EXPR_P (expr)) + { + if ((res = cp_walk_tree (stmt, analyze_expression_awaits, d, &visited))) + return res; +@@ -3381,31 +3556,19 @@ await_statement_walker (tree *stmt, int *do_subtree, void *d) + if (!awpts->saw_awaits) + return NULL_TREE; /* Nothing special to do here. */ + +- /* Unless we need to expand any truth-and/or-if expressions, then the +- remaining action is to check for temporaries to await expressions +- captured by refence. */ +- if (!awpts->needs_truth_if_exp) +- return maybe_promote_captured_temps (stmt, d); +- +- gcc_checking_assert (!awpts->bind_stack->is_empty()); +- tree& bind_expr = awpts->bind_stack->last (); +- /* Build a variable to hold the condition, this will be +- included in the frame as a local var. */ +- tree newvar = add_var_to_bind (bind_expr, boolean_type_node, +- "taoi", awpts->cond_number++); +- tree insert_list = push_stmt_list (); +- add_decl_expr (newvar); +- add_stmt (*stmt); +- tree *sp = tsi_stmt_ptr (tsi_last (insert_list)); +- *stmt = pop_stmt_list (insert_list); +- +- truth_if_transform xf = {sp, newvar, &truth_aoif_to_expand}; +- if ((res = cp_walk_tree (sp, expand_one_truth_if, &xf, NULL))) +- return res; +- /* Process the expanded trees. */ +- return cp_walk_tree (stmt, await_statement_walker, d, NULL); ++ if (awpts->needs_truth_if_exp) ++ { ++ /* If a truth-and/or-if expression has an await expression in the ++ conditionally-taken branch, then it must be rewritten into a ++ regular conditional. */ ++ truth_if_transform xf = {stmt, NULL_TREE, &truth_aoif_to_expand}; ++ if ((res = cp_walk_tree (stmt, expand_one_truth_if, &xf, NULL))) ++ return res; ++ } ++ /* Process this statement, which contains at least one await expression ++ to 'promote' temporary values to a coroutine frame slot. */ ++ return maybe_promote_temps (stmt, d); + } +- + /* Continue recursion, if needed. */ + return res; + } +@@ -3421,6 +3584,9 @@ struct param_frame_data + bool param_seen; + }; + ++/* A tree-walk callback that records the use of parameters (to allow for ++ optimizations where handling unused parameters may be omitted). */ ++ + static tree + register_param_uses (tree *stmt, int *do_subtree ATTRIBUTE_UNUSED, void *d) + { +@@ -3456,7 +3622,21 @@ register_param_uses (tree *stmt, int *do_subtree ATTRIBUTE_UNUSED, void *d) + return NULL_TREE; + } + +-/* For figuring out what local variable usage we have. */ ++/* Small helper for the repetitive task of adding a new field to the coro ++ frame type. */ ++ ++static tree ++coro_make_frame_entry (tree *field_list, const char *name, tree fld_type, ++ location_t loc) ++{ ++ tree id = get_identifier (name); ++ tree decl = build_decl (loc, FIELD_DECL, id, fld_type); ++ DECL_CHAIN (decl) = *field_list; ++ *field_list = decl; ++ return id; ++} ++ ++/* For recording local variable usage. */ + + struct local_vars_frame_data + { +@@ -3468,6 +3648,10 @@ struct local_vars_frame_data + bool local_var_seen; + }; + ++/* A tree-walk callback that processes one bind expression noting local ++ variables, and making a coroutine frame slot available for those that ++ need it, so that they can be 'promoted' across suspension points. */ ++ + static tree + register_local_var_uses (tree *stmt, int *do_subtree, void *d) + { +@@ -3524,11 +3708,11 @@ register_local_var_uses (tree *stmt, int *do_subtree, void *d) + tree lvname = DECL_NAME (lvar); + char *buf; + if (lvname != NULL_TREE) +- buf = xasprintf ("__lv.%u.%u.%s", lvd->bind_indx, lvd->nest_depth, +- IDENTIFIER_POINTER (lvname)); ++ buf = xasprintf ("__%s.%u.%u", IDENTIFIER_POINTER (lvname), ++ lvd->nest_depth, lvd->bind_indx); + else +- buf = xasprintf ("__lv.%u.%u.D%u", lvd->bind_indx, lvd->nest_depth, +- DECL_UID (lvar)); ++ buf = xasprintf ("_D%u.%u.%u", DECL_UID (lvar), lvd->nest_depth, ++ lvd->bind_indx); + /* TODO: Figure out if we should build a local type that has any + excess alignment or size from the original decl. */ + local_var.field_id +@@ -3632,7 +3816,7 @@ coro_rewrite_function_body (location_t fn_start, tree fnbody, + fn_start, NULL, /*musthave=*/true); + /* Create and initialize the initial-await-resume-called variable per + [dcl.fct.def.coroutine] / 5.3. */ +- tree i_a_r_c = build_lang_decl (VAR_DECL, get_identifier ("__i_a_r_c"), ++ tree i_a_r_c = build_lang_decl (VAR_DECL, get_identifier ("i_a_r_c"), + boolean_type_node); + DECL_ARTIFICIAL (i_a_r_c) = true; + DECL_CHAIN (i_a_r_c) = var_list; +@@ -3761,9 +3945,7 @@ coro_rewrite_function_body (location_t fn_start, tree fnbody, + short __resume_at; + handle_type self_handle; + (maybe) parameter copies. +- coro1::suspend_never_prt __is; +- coro1::suspend_always_prt __fs; +- (maybe) local variables saved ++ (maybe) local variables saved (including awaitables) + (maybe) trailing space. + }; */ + +@@ -3976,8 +4158,8 @@ morph_fn_to_coro (tree orig, tree *resumer, tree *destroyer) + to promote any temporaries that are captured by reference (to regular + vars) they will get added to the coro frame along with other locals. */ + susp_frame_data body_aw_points +- = {&field_list, handle_type, NULL, NULL, 0, 0, +- hash_set (), NULL, NULL, 0, false, false}; ++ = {&field_list, handle_type, fs_label, NULL, NULL, 0, 0, ++ hash_set (), NULL, NULL, 0, false, false, false}; + body_aw_points.block_stack = make_tree_vector (); + body_aw_points.bind_stack = make_tree_vector (); + body_aw_points.to_replace = make_tree_vector (); +@@ -4565,7 +4747,7 @@ morph_fn_to_coro (tree orig, tree *resumer, tree *destroyer) + + /* Build the actor... */ + build_actor_fn (fn_start, coro_frame_type, actor, fnbody, orig, param_uses, +- &local_var_uses, param_dtor_list, fs_label, resume_fn_field, ++ &local_var_uses, param_dtor_list, resume_fn_field, + body_aw_points.await_number, frame_size); + + /* Destroyer ... */ +--- a/src/gcc/cp/cp-tree.def ++++ b/src/gcc/cp/cp-tree.def +@@ -594,9 +594,9 @@ DEFTREECODE (CO_YIELD_EXPR, "co_yield", tcc_expression, 2) + /* The co_return expression is used to support coroutines. + + Op0 is the original expr, can be void (for use in diagnostics) +- Op2 is the promise return_xxxx call for Op0. */ ++ Op1 is the promise return_xxxx call for for the expression given. */ + +-DEFTREECODE (CO_RETURN_EXPR, "co_return", tcc_expression, 2) ++DEFTREECODE (CO_RETURN_EXPR, "co_return", tcc_statement, 2) + + /* + Local variables: +--- a/src/gcc/cp/parser.c ++++ b/src/gcc/cp/parser.c +@@ -18745,7 +18745,7 @@ cp_parser_elaborated_type_specifier (cp_parser* parser, + if (!template_p) + cp_parser_parse_tentatively (parser); + /* The `template' keyword must follow a nested-name-specifier. */ +- else if (!nested_name_specifier) ++ else if (!nested_name_specifier && !globalscope) + { + cp_parser_error (parser, "% must follow a nested-" + "name-specifier"); +--- a/src/gcc/d/ChangeLog ++++ b/src/gcc/d/ChangeLog +@@ -1,3 +1,14 @@ ++2020-08-01 Iain Buclaw ++ ++ Backported from master: ++ 2020-07-30 Iain Buclaw ++ ++ PR d/96140 ++ * intrinsics.cc (expand_intrinsic_vaarg): Handle ref parameters as ++ arguments to va_arg(). ++ (expand_intrinsic_vastart): Handle ref parameters as arguments to ++ va_start(). ++ + 2020-07-23 Release Manager + + * GCC 10.2.0 released. +--- a/src/gcc/d/intrinsics.cc ++++ b/src/gcc/d/intrinsics.cc +@@ -511,8 +511,17 @@ expand_intrinsic_vaarg (tree callexp) + { + parmn = CALL_EXPR_ARG (callexp, 1); + STRIP_NOPS (parmn); +- gcc_assert (TREE_CODE (parmn) == ADDR_EXPR); +- parmn = TREE_OPERAND (parmn, 0); ++ ++ /* The `ref' argument to va_arg is either an address or reference, ++ get the value of it. */ ++ if (TREE_CODE (parmn) == PARM_DECL && POINTER_TYPE_P (TREE_TYPE (parmn))) ++ parmn = build_deref (parmn); ++ else ++ { ++ gcc_assert (TREE_CODE (parmn) == ADDR_EXPR); ++ parmn = TREE_OPERAND (parmn, 0); ++ } ++ + type = TREE_TYPE (parmn); + } + +@@ -546,10 +555,16 @@ expand_intrinsic_vastart (tree callexp) + /* The va_list argument should already have its address taken. The second + argument, however, is inout and that needs to be fixed to prevent a + warning. Could be casting, so need to check type too? */ +- gcc_assert (TREE_CODE (ap) == ADDR_EXPR && TREE_CODE (parmn) == ADDR_EXPR); ++ gcc_assert (TREE_CODE (ap) == ADDR_EXPR ++ || (TREE_CODE (ap) == PARM_DECL ++ && POINTER_TYPE_P (TREE_TYPE (ap)))); + + /* Assuming nobody tries to change the return type. */ +- parmn = TREE_OPERAND (parmn, 0); ++ if (TREE_CODE (parmn) != PARM_DECL) ++ { ++ gcc_assert (TREE_CODE (parmn) == ADDR_EXPR); ++ parmn = TREE_OPERAND (parmn, 0); ++ } + + return call_builtin_fn (callexp, BUILT_IN_VA_START, 2, ap, parmn); + } +--- a/src/gcc/expr.c ++++ b/src/gcc/expr.c +@@ -11730,15 +11730,19 @@ string_constant (tree arg, tree *ptr_offset, tree *mem_size, tree *decl) + chartype = TREE_TYPE (chartype); + /* Convert a char array to an empty STRING_CST having an array + of the expected type. */ +- if (!initsize) +- initsize = integer_zero_node; ++ if (INTEGRAL_TYPE_P (chartype) ++ && TYPE_PRECISION (chartype) == TYPE_PRECISION (char_type_node)) ++ { ++ if (!initsize) ++ initsize = integer_zero_node; + +- unsigned HOST_WIDE_INT size = tree_to_uhwi (initsize); +- init = build_string_literal (size ? 1 : 0, "", chartype, size); +- init = TREE_OPERAND (init, 0); +- init = TREE_OPERAND (init, 0); ++ unsigned HOST_WIDE_INT size = tree_to_uhwi (initsize); ++ init = build_string_literal (size ? 1 : 0, "", chartype, size); ++ init = TREE_OPERAND (init, 0); ++ init = TREE_OPERAND (init, 0); + +- *ptr_offset = integer_zero_node; ++ *ptr_offset = integer_zero_node; ++ } + } + + if (decl) +--- a/src/gcc/fortran/ChangeLog ++++ b/src/gcc/fortran/ChangeLog +@@ -1,3 +1,98 @@ ++2020-07-29 Mark Eggleston ++ ++ Backported from master: ++ 2020-07-29 Mark Eggleston ++ ++ PR fortran/96319 ++ * intrinsic.c (gfc_convert_type_warn): Add check for ++ LOGICAL type so that warnings are not output. ++ ++2020-07-27 Mark Eggleston ++ ++ Backported from master: ++ 2020-07-14 Steven G. Kargl ++ Mark Eggleston ++ ++ PR fortran/95612 ++ * expr.c (gfc_check_pointer_assigb): Output an error if ++ rvalue is a zero sized array or output an error if rvalue ++ doesn't have a symbol tree. ++ ++2020-07-26 Mark Eggleston ++ ++ Backported from master: ++ 2020-06-22 Steven G. Kargl ++ Mark Eggleston ++ ++ PR fortran/95585 ++ * check.c (gfc_check_reshape): Add check for a value when ++ the symbol has an attribute flavor FL_PARAMETER. ++ ++2020-07-23 Harald Anlauf ++ ++ Backported from master: ++ 2020-07-10 Harald Anlauf ++ ++ PR fortran/95980 ++ * class.c (gfc_add_component_ref, gfc_build_class_symbol): ++ Add checks for NULL pointer dereference. ++ * primary.c (gfc_variable_attr): Likewise. ++ * resolve.c (resolve_variable, resolve_assoc_var) ++ (resolve_fl_var_and_proc, resolve_fl_variable_derived) ++ (resolve_symbol): Likewise. ++ ++2020-07-23 Harald Anlauf ++ ++ Backported from master: ++ 2020-07-06 Harald Anlauf ++ ++ PR fortran/95980 ++ * match.c (copy_ts_from_selector_to_associate, build_class_sym): ++ Distinguish between unlimited polymorphic and ordinary variables ++ to avoid NULL pointer dereference. ++ * resolve.c (resolve_select_type): ++ Distinguish between unlimited polymorphic and ordinary variables ++ to avoid NULL pointer dereference. ++ ++2020-07-23 Harald Anlauf ++ ++ Backported from master: ++ 2020-07-10 Harald Anlauf ++ ++ PR fortran/96086 ++ * match.c (gfc_match_select_rank): Catch NULL pointer ++ dereference. ++ * resolve.c (resolve_assoc_var): Catch NULL pointer dereference ++ that may occur after an illegal declaration. ++ ++2020-07-23 Harald Anlauf ++ ++ Backported from master: ++ 2020-07-21 Harald Anlauf ++ ++ PR fortran/89574 ++ * trans-decl.c (gfc_get_extern_function_decl): Check whether a ++ symbol belongs to a different module. ++ ++2020-07-23 Thomas Koenig ++ ++ Backported from master: ++ 2020-07-19 Thomas Koenig ++ ++ PR fortran/96220 ++ * dump-parse-tree.c (get_c_type_name): Always use the entries from ++ c_interop_kinds_table to find the correct C type. ++ ++2020-07-23 Thomas Koenig ++ ++ PR fortran/96018 ++ * frontend-passes.c (gfc_check_externals): Adjust formatting. ++ (implicit_pure_call): New function. ++ (implicit_pure_expr): New function. ++ (gfc_fix_implicit_pure): New function. ++ * gfortran.h (gfc_fix_implicit_pure): New prototype. ++ * parse.c (translate_all_program_units): Call gfc_fix_implicit_pure. ++ + 2020-07-23 Release Manager + + * GCC 10.2.0 released. +--- a/src/gcc/fortran/check.c ++++ b/src/gcc/fortran/check.c +@@ -4742,7 +4742,8 @@ gfc_check_reshape (gfc_expr *source, gfc_expr *shape, + && shape->ref->u.ar.as->lower[0]->ts.type == BT_INTEGER + && shape->ref->u.ar.as->upper[0]->expr_type == EXPR_CONSTANT + && shape->ref->u.ar.as->upper[0]->ts.type == BT_INTEGER +- && shape->symtree->n.sym->attr.flavor == FL_PARAMETER) ++ && shape->symtree->n.sym->attr.flavor == FL_PARAMETER ++ && shape->symtree->n.sym->value) + { + int i, extent; + gfc_expr *e, *v; +--- a/src/gcc/fortran/class.c ++++ b/src/gcc/fortran/class.c +@@ -228,7 +228,7 @@ gfc_add_component_ref (gfc_expr *e, const char *name) + break; + tail = &((*tail)->next); + } +- if (derived->components && derived->components->next && ++ if (derived && derived->components && derived->components->next && + derived->components->next->ts.type == BT_DERIVED && + derived->components->next->ts.u.derived == NULL) + { +@@ -663,6 +663,10 @@ gfc_build_class_symbol (gfc_typespec *ts, symbol_attribute *attr, + + /* Determine the name of the encapsulating type. */ + rank = !(*as) || (*as)->rank == -1 ? GFC_MAX_DIMENSIONS : (*as)->rank; + + if (!ts->u.derived) + return false; @@ -380,6 +3897,30 @@ } } } +--- a/src/gcc/fortran/expr.c ++++ b/src/gcc/fortran/expr.c +@@ -4271,7 +4271,20 @@ gfc_check_pointer_assign (gfc_expr *lvalue, gfc_expr *rvalue, + gfc_symbol *sym; + bool target; + +- gcc_assert (rvalue->symtree); ++ if (gfc_is_size_zero_array (rvalue)) ++ { ++ gfc_error ("Zero-sized array detected at %L where an entity with " ++ "the TARGET attribute is expected", &rvalue->where); ++ return false; ++ } ++ else if (!rvalue->symtree) ++ { ++ gfc_error ("Pointer assignment target in initialization expression " ++ "does not have the TARGET attribute at %L", ++ &rvalue->where); ++ return false; ++ } ++ + sym = rvalue->symtree->n.sym; + + if (sym->ts.type == BT_CLASS && sym->attr.class_ok) --- a/src/gcc/fortran/frontend-passes.c +++ b/src/gcc/fortran/frontend-passes.c @@ -5516,3 +5516,77 @@ gfc_check_externals (gfc_namespace *ns) @@ -470,6 +4011,21 @@ /* simplify.c */ +--- a/src/gcc/fortran/intrinsic.c ++++ b/src/gcc/fortran/intrinsic.c +@@ -5245,8 +5245,10 @@ gfc_convert_type_warn (gfc_expr *expr, gfc_typespec *ts, int eflag, int wflag, + { + /* Larger kinds can hold values of smaller kinds without problems. + Hence, only warn if target kind is smaller than the source +- kind - or if -Wconversion-extra is specified. */ +- if (expr->expr_type != EXPR_CONSTANT) ++ kind - or if -Wconversion-extra is specified. LOGICAL values ++ will always fit regardless of kind so ignore conversion. */ ++ if (expr->expr_type != EXPR_CONSTANT ++ && ts->type != BT_LOGICAL) + { + if (warn_conversion && from_ts.kind > ts->kind) + gfc_warning_now (OPT_Wconversion, "Possible change of value in " --- a/src/gcc/fortran/match.c +++ b/src/gcc/fortran/match.c @@ -6159,14 +6159,18 @@ copy_ts_from_selector_to_associate (gfc_expr *associate, gfc_expr *selector) @@ -711,124 +4267,600012 @@ if (gsym && !gsym->defined) gsym = NULL; ---- a/src/gcc/testsuite/ChangeLog -+++ b/src/gcc/testsuite/ChangeLog -@@ -1,3 +1,60 @@ -+2020-07-23 Harald Anlauf +--- a/src/gcc/gimple-fold.c ++++ b/src/gcc/gimple-fold.c +@@ -4837,7 +4837,7 @@ replace_stmt_with_simplification (gimple_stmt_iterator *gsi, + /* Canonicalize MEM_REFs invariant address operand after propagation. */ + + static bool +-maybe_canonicalize_mem_ref_addr (tree *t) ++maybe_canonicalize_mem_ref_addr (tree *t, bool is_debug = false) + { + bool res = false; + +@@ -4900,7 +4900,11 @@ maybe_canonicalize_mem_ref_addr (tree *t) + base = get_addr_base_and_unit_offset (TREE_OPERAND (addr, 0), + &coffset); + if (!base) +- gcc_unreachable (); ++ { ++ if (is_debug) ++ return false; ++ gcc_unreachable (); ++ } + + TREE_OPERAND (*t, 0) = build_fold_addr_expr (base); + TREE_OPERAND (*t, 1) = int_const_binop (PLUS_EXPR, +@@ -5055,7 +5059,7 @@ fold_stmt_1 (gimple_stmt_iterator *gsi, bool inplace, tree (*valueize) (tree)) + if (*val + && (REFERENCE_CLASS_P (*val) + || TREE_CODE (*val) == ADDR_EXPR) +- && maybe_canonicalize_mem_ref_addr (val)) ++ && maybe_canonicalize_mem_ref_addr (val, true)) + changed = true; + } + break; +--- a/src/gcc/po/ChangeLog ++++ b/src/gcc/po/ChangeLog +@@ -1,3 +1,13 @@ ++2020-07-29 Joseph Myers ++ ++ * ja.po, sv.po: Update. ++ ++2020-07-27 Joseph Myers ++ ++ * be.po, da.po, de.po, el.po, es.po, fi.po, fr.po, hr.po, id.po, ++ ja.po, nl.po, ru.po, sr.po, sv.po, tr.po, uk.po, vi.po, zh_CN.po, ++ zh_TW.po: Update. ++ + 2020-07-23 Release Manager + + * GCC 10.2.0 released. +--- a/src/gcc/po/be.po ++++ b/src/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: 2020-04-27 21:19+0000\n" ++"POT-Creation-Date: 2020-07-20 18:08+0000\n" + "PO-Revision-Date: 2002-05-17 15:54+0200\n" + "Last-Translator: Ales Nyakhaychyk \n" + "Language-Team: Belarusian \n" +@@ -1941,87 +1941,87 @@ msgstr "" + msgid "" + msgstr "" + +-#: config/aarch64/aarch64.c:9890 ++#: config/aarch64/aarch64.c:9995 + #, fuzzy, c-format + msgid "unsupported operand for code '%c'" + msgstr "Нерэчаісны выбар \"%s\"" + +-#: config/aarch64/aarch64.c:9899 config/aarch64/aarch64.c:9912 +-#: config/aarch64/aarch64.c:9924 config/aarch64/aarch64.c:9935 +-#: config/aarch64/aarch64.c:9951 config/aarch64/aarch64.c:9965 +-#: config/aarch64/aarch64.c:9985 config/aarch64/aarch64.c:10059 +-#: config/aarch64/aarch64.c:10070 config/aarch64/aarch64.c:10084 +-#: config/aarch64/aarch64.c:10306 config/aarch64/aarch64.c:10324 ++#: config/aarch64/aarch64.c:10004 config/aarch64/aarch64.c:10017 ++#: config/aarch64/aarch64.c:10029 config/aarch64/aarch64.c:10040 ++#: config/aarch64/aarch64.c:10056 config/aarch64/aarch64.c:10070 ++#: config/aarch64/aarch64.c:10090 config/aarch64/aarch64.c:10164 ++#: config/aarch64/aarch64.c:10175 config/aarch64/aarch64.c:10189 ++#: config/aarch64/aarch64.c:10411 config/aarch64/aarch64.c:10429 + #: config/pru/pru.c:1700 config/pru/pru.c:1710 config/pru/pru.c:1741 + #: config/pru/pru.c:1752 config/pru/pru.c:1824 + #, fuzzy, c-format + msgid "invalid operand for '%%%c'" + msgstr "Нерэчаісны выбар \"%s\"" + +-#: config/aarch64/aarch64.c:10003 config/aarch64/aarch64.c:10014 +-#: config/aarch64/aarch64.c:10166 config/aarch64/aarch64.c:10177 ++#: config/aarch64/aarch64.c:10108 config/aarch64/aarch64.c:10119 ++#: config/aarch64/aarch64.c:10271 config/aarch64/aarch64.c:10282 + #, fuzzy, c-format + #| msgid "invalid string constant `%E'" + msgid "invalid vector constant" + msgstr "`%E' - нерэчаісная нязьменная тыпу string" + +-#: config/aarch64/aarch64.c:10026 config/aarch64/aarch64.c:10038 ++#: config/aarch64/aarch64.c:10131 config/aarch64/aarch64.c:10143 + #, c-format + msgid "incompatible floating point / vector register operand for '%%%c'" + msgstr "" + +-#: config/aarch64/aarch64.c:10052 ++#: config/aarch64/aarch64.c:10157 + #, fuzzy, c-format + #| msgid "invalid register name for `%s'" + msgid "incompatible register operand for '%%%c'" + msgstr "нерэчаісная назва рэгістра `%s'" + +-#: config/aarch64/aarch64.c:10118 config/arm/arm.c:24045 ++#: config/aarch64/aarch64.c:10223 config/arm/arm.c:24220 + #, fuzzy, c-format + msgid "missing operand" + msgstr "прапушчан ініцыялізатар" + +-#: config/aarch64/aarch64.c:10203 ++#: config/aarch64/aarch64.c:10308 + #, fuzzy, c-format + msgid "invalid constant" + msgstr "Нерэчаісны выбар %s" + +-#: config/aarch64/aarch64.c:10206 ++#: config/aarch64/aarch64.c:10311 + #, fuzzy, c-format + #| msgid "invalid %%d operand" + msgid "invalid operand" + msgstr "нерэчаісны %%d аперанд" + +-#: config/aarch64/aarch64.c:10332 config/aarch64/aarch64.c:10337 ++#: config/aarch64/aarch64.c:10437 config/aarch64/aarch64.c:10442 + #, fuzzy, c-format + msgid "invalid operand prefix '%%%c'" + msgstr "Нерэчаісны выбар \"%s\"" + +-#: config/aarch64/aarch64.c:10357 ++#: config/aarch64/aarch64.c:10462 + #, fuzzy, c-format + #| msgid "invalid address" + msgid "invalid address mode" + msgstr "нерэчаісны адрас" + +-#: config/aarch64/aarch64.c:22579 config/arm/arm.c:33009 ++#: config/aarch64/aarch64.c:22752 config/arm/arm.c:33184 + msgid "invalid conversion from type %" + msgstr "" + +-#: config/aarch64/aarch64.c:22581 config/arm/arm.c:33011 ++#: config/aarch64/aarch64.c:22754 config/arm/arm.c:33186 + msgid "invalid conversion to type %" + msgstr "" + +-#: config/aarch64/aarch64.c:22596 config/aarch64/aarch64.c:22612 +-#: config/arm/arm.c:33026 config/arm/arm.c:33042 ++#: config/aarch64/aarch64.c:22769 config/aarch64/aarch64.c:22785 ++#: config/arm/arm.c:33201 config/arm/arm.c:33217 + msgid "operation not permitted on type %" + msgstr "" + +-#: config/aarch64/aarch64.c:22620 ++#: config/aarch64/aarch64.c:22793 + msgid "cannot combine GNU and SVE vectors in a binary operation" + msgstr "" + + #: config/alpha/alpha.c:5076 config/i386/i386.c:13037 +-#: config/rs6000/rs6000.c:13291 config/sparc/sparc.c:9351 ++#: config/rs6000/rs6000.c:13417 config/sparc/sparc.c:9351 + #, c-format + msgid "'%%&' used without any local dynamic TLS references" + msgstr "" +@@ -2037,18 +2037,18 @@ msgid "invalid %%r value" + msgstr "нерэчаіснае значэньне %%r" + + #: config/alpha/alpha.c:5174 config/ia64/ia64.c:5531 +-#: config/rs6000/rs6000.c:12985 config/xtensa/xtensa.c:2428 ++#: config/rs6000/rs6000.c:13111 config/xtensa/xtensa.c:2428 + #, c-format + msgid "invalid %%R value" + msgstr "нерэчаіснае значэньне %%R" + +-#: config/alpha/alpha.c:5180 config/rs6000/rs6000.c:12905 ++#: config/alpha/alpha.c:5180 config/rs6000/rs6000.c:13031 + #: config/xtensa/xtensa.c:2395 + #, c-format + msgid "invalid %%N value" + msgstr "нерэчаіснае значэньне %%N" + +-#: config/alpha/alpha.c:5188 config/rs6000/rs6000.c:12933 ++#: config/alpha/alpha.c:5188 config/rs6000/rs6000.c:13059 + #, c-format + msgid "invalid %%P value" + msgstr "нерэчаіснае значэньне %%P" +@@ -2078,7 +2078,7 @@ msgstr "нерэчаіснае значэньне %%M" + msgid "invalid %%U value" + msgstr "нерэчаіснае значэньне %%U" + +-#: config/alpha/alpha.c:5274 config/rs6000/rs6000.c:12993 ++#: config/alpha/alpha.c:5274 config/rs6000/rs6000.c:13119 + #, c-format + msgid "invalid %%s value" + msgstr "нерэчаіснае значэньне %%v" +@@ -2088,7 +2088,7 @@ msgstr "нерэчаіснае значэньне %%v" + msgid "invalid %%C value" + msgstr "нерэчаіснае значэньне %%C" + +-#: config/alpha/alpha.c:5322 config/rs6000/rs6000.c:12769 ++#: config/alpha/alpha.c:5322 config/rs6000/rs6000.c:12895 + #, c-format + msgid "invalid %%E value" + msgstr "нерэчаіснае значэньне %%E" +@@ -2098,10 +2098,10 @@ msgstr "нерэчаіснае значэньне %%E" + msgid "unknown relocation unspec" + msgstr "" + +-#: config/alpha/alpha.c:5356 config/cr16/cr16.c:1570 config/gcn/gcn.c:5748 +-#: config/gcn/gcn.c:5757 config/gcn/gcn.c:5817 config/gcn/gcn.c:5825 +-#: config/gcn/gcn.c:5841 config/gcn/gcn.c:5859 config/gcn/gcn.c:5910 +-#: config/gcn/gcn.c:6029 config/gcn/gcn.c:6140 config/rs6000/rs6000.c:13296 ++#: config/alpha/alpha.c:5356 config/cr16/cr16.c:1570 config/gcn/gcn.c:5749 ++#: config/gcn/gcn.c:5758 config/gcn/gcn.c:5818 config/gcn/gcn.c:5826 ++#: config/gcn/gcn.c:5842 config/gcn/gcn.c:5860 config/gcn/gcn.c:5911 ++#: config/gcn/gcn.c:6030 config/gcn/gcn.c:6141 config/rs6000/rs6000.c:13422 + #, c-format + msgid "invalid %%xn code" + msgstr "нерэчаіснае значэньне %%xn" +@@ -2185,36 +2185,36 @@ msgstr "нерэчаісны %%-код" + msgid "unrecognized supposed constant" + msgstr "нераспазнаны выбар \"-%s\"" + +-#: config/arm/arm.c:20413 config/arm/arm.c:20438 config/arm/arm.c:20448 +-#: config/arm/arm.c:20457 config/arm/arm.c:20466 ++#: config/arm/arm.c:20588 config/arm/arm.c:20613 config/arm/arm.c:20623 ++#: config/arm/arm.c:20632 config/arm/arm.c:20641 + #, fuzzy, c-format + #| msgid "invalid %%f operand" + msgid "invalid shift operand" + msgstr "нерэчаісны %%f аперанд" + +-#: config/arm/arm.c:23329 config/arm/arm.c:23347 ++#: config/arm/arm.c:23504 config/arm/arm.c:23522 + #, fuzzy, c-format + msgid "predicated Thumb instruction" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: config/arm/arm.c:23335 ++#: config/arm/arm.c:23510 + #, c-format + msgid "predicated instruction in conditional sequence" + msgstr "" + +-#: config/arm/arm.c:23453 config/arm/arm.c:23466 config/arm/arm.c:23491 ++#: config/arm/arm.c:23628 config/arm/arm.c:23641 config/arm/arm.c:23666 + #: config/nios2/nios2.c:3086 + #, fuzzy, c-format + msgid "Unsupported operand for code '%c'" + msgstr "Нерэчаісны выбар \"%s\"" + +-#: config/arm/arm.c:23568 config/arm/arm.c:23590 config/arm/arm.c:23600 +-#: config/arm/arm.c:23610 config/arm/arm.c:23620 config/arm/arm.c:23659 +-#: config/arm/arm.c:23677 config/arm/arm.c:23702 config/arm/arm.c:23717 +-#: config/arm/arm.c:23744 config/arm/arm.c:23751 config/arm/arm.c:23769 +-#: config/arm/arm.c:23776 config/arm/arm.c:23784 config/arm/arm.c:23805 +-#: config/arm/arm.c:23812 config/arm/arm.c:23992 config/arm/arm.c:23999 +-#: config/arm/arm.c:24026 config/arm/arm.c:24033 config/bfin/bfin.c:1440 ++#: config/arm/arm.c:23743 config/arm/arm.c:23765 config/arm/arm.c:23775 ++#: config/arm/arm.c:23785 config/arm/arm.c:23795 config/arm/arm.c:23834 ++#: config/arm/arm.c:23852 config/arm/arm.c:23877 config/arm/arm.c:23892 ++#: config/arm/arm.c:23919 config/arm/arm.c:23926 config/arm/arm.c:23944 ++#: config/arm/arm.c:23951 config/arm/arm.c:23959 config/arm/arm.c:23980 ++#: config/arm/arm.c:23987 config/arm/arm.c:24167 config/arm/arm.c:24174 ++#: config/arm/arm.c:24201 config/arm/arm.c:24208 config/bfin/bfin.c:1440 + #: config/bfin/bfin.c:1447 config/bfin/bfin.c:1454 config/bfin/bfin.c:1461 + #: config/bfin/bfin.c:1470 config/bfin/bfin.c:1477 config/bfin/bfin.c:1484 + #: config/bfin/bfin.c:1491 config/nds32/nds32.c:3543 +@@ -2222,13 +2222,13 @@ msgstr "Нерэчаісны выбар \"%s\"" + msgid "invalid operand for code '%c'" + msgstr "Нерэчаісны выбар \"%s\"" + +-#: config/arm/arm.c:23672 ++#: config/arm/arm.c:23847 + #, c-format + msgid "instruction never executed" + msgstr "" + + #. Former Maverick support, removed after GCC-4.7. +-#: config/arm/arm.c:23693 ++#: config/arm/arm.c:23868 + #, c-format + msgid "obsolete Maverick format code '%c'" + msgstr "" +@@ -2361,7 +2361,7 @@ msgstr "непадтрымліваемая версія" + + #: config/cris/cris.c:625 config/ft32/ft32.c:110 config/moxie/moxie.c:108 + #: final.c:3607 final.c:3609 fold-const.c:266 gcc.c:5423 gcc.c:5437 +-#: rtl-error.c:101 toplev.c:328 vr-values.c:2486 cp/typeck.c:6747 ++#: rtl-error.c:101 toplev.c:328 vr-values.c:2486 cp/typeck.c:6807 + #: lto/lto-object.c:184 lto/lto-object.c:281 lto/lto-object.c:338 + #: lto/lto-object.c:362 + #, gcc-internal-format, gfc-internal-format +@@ -2580,25 +2580,25 @@ msgstr "" + msgid "bad output_condmove_single operand" + msgstr "" + +-#: config/gcn/gcn.c:5418 config/gcn/gcn.c:5442 config/gcn/gcn.c:5446 +-#: config/gcn/gcn.c:5790 config/gcn/gcn.c:5801 config/gcn/gcn.c:5804 ++#: config/gcn/gcn.c:5419 config/gcn/gcn.c:5443 config/gcn/gcn.c:5447 ++#: config/gcn/gcn.c:5791 config/gcn/gcn.c:5802 config/gcn/gcn.c:5805 + #, c-format + msgid "bad ADDR_SPACE_GLOBAL address" + msgstr "" + +-#: config/gcn/gcn.c:5558 config/gcn/gcn.c:5581 config/gcn/gcn.c:5613 +-#: config/gcn/gcn.c:5629 config/gcn/gcn.c:5644 config/gcn/gcn.c:5663 +-#: config/gcn/gcn.c:5739 config/gcn/gcn.c:5935 config/gcn/gcn.c:6050 ++#: config/gcn/gcn.c:5559 config/gcn/gcn.c:5582 config/gcn/gcn.c:5614 ++#: config/gcn/gcn.c:5630 config/gcn/gcn.c:5645 config/gcn/gcn.c:5664 ++#: config/gcn/gcn.c:5740 config/gcn/gcn.c:5936 config/gcn/gcn.c:6051 + #, fuzzy, c-format + msgid "invalid operand %%xn code" + msgstr "нерэчаісны %%-код" + +-#: config/gcn/gcn.c:6038 ++#: config/gcn/gcn.c:6039 + #, c-format + msgid "operand %%xn code invalid for QImode" + msgstr "" + +-#: config/gcn/gcn.c:6120 ++#: config/gcn/gcn.c:6121 + #, fuzzy, c-format + #| msgid "invalid string constant `%E'" + msgid "invalid fp constant" +@@ -2752,7 +2752,7 @@ msgstr "нерэчаісны %%-код" + msgid "invalid %%P operand" + msgstr "нерэчаісны %%-код" + +-#: config/iq2000/iq2000.c:3134 config/rs6000/rs6000.c:12923 ++#: config/iq2000/iq2000.c:3134 config/rs6000/rs6000.c:13049 + #, c-format + msgid "invalid %%p value" + msgstr "" +@@ -2808,7 +2808,7 @@ msgid "post-increment address is not a register" + msgstr "" + + #: config/m32r/m32r.c:2335 config/m32r/m32r.c:2350 +-#: config/rs6000/rs6000.c:19593 ++#: config/rs6000/rs6000.c:19840 + msgid "bad address" + msgstr "дрэнны адрас" + +@@ -2864,8 +2864,8 @@ msgstr "\"%s\" - гэта не пачатак дэкларацыі" + #: config/mips/mips.c:9084 config/mips/mips.c:9087 config/mips/mips.c:9099 + #: config/mips/mips.c:9102 config/mips/mips.c:9162 config/mips/mips.c:9169 + #: config/mips/mips.c:9190 config/mips/mips.c:9205 config/mips/mips.c:9224 +-#: config/mips/mips.c:9233 config/riscv/riscv.c:3209 config/riscv/riscv.c:3324 +-#: config/riscv/riscv.c:3330 config/riscv/riscv.c:3339 ++#: config/mips/mips.c:9233 config/riscv/riscv.c:3217 config/riscv/riscv.c:3332 ++#: config/riscv/riscv.c:3338 config/riscv/riscv.c:3347 + #, fuzzy, c-format + #| msgid "invalid use of `%D'" + msgid "invalid use of '%%%c'" +@@ -3006,173 +3006,211 @@ msgstr "" + msgid "Try running '%s' in the shell to raise its limit.\n" + msgstr "" + +-#: config/rs6000/rs6000.c:3631 ++#: config/rs6000/rs6000.c:3696 + #, fuzzy + #| msgid "Use hardware floating point" + msgid "%<-mvsx%> requires hardware floating point" + msgstr "Выкарыстоўваць апаратную \"плаваючую кропку\"" + +-#: config/rs6000/rs6000.c:3639 ++#: config/rs6000/rs6000.c:3704 + msgid "%<-mvsx%> needs indexed addressing" + msgstr "" + +-#: config/rs6000/rs6000.c:3644 ++#: config/rs6000/rs6000.c:3709 + msgid "%<-mvsx%> and %<-mno-altivec%> are incompatible" + msgstr "" + +-#: config/rs6000/rs6000.c:3646 ++#: config/rs6000/rs6000.c:3711 + msgid "%<-mno-altivec%> disables vsx" + msgstr "" + +-#: config/rs6000/rs6000.c:3780 ++#: config/rs6000/rs6000.c:3845 + msgid "%<-mquad-memory%> requires 64-bit mode" + msgstr "" + +-#: config/rs6000/rs6000.c:3783 ++#: config/rs6000/rs6000.c:3848 + msgid "%<-mquad-memory-atomic%> requires 64-bit mode" + msgstr "" + +-#: config/rs6000/rs6000.c:3795 ++#: config/rs6000/rs6000.c:3860 + msgid "%<-mquad-memory%> is not available in little endian mode" + msgstr "" + +-#: config/rs6000/rs6000.c:10009 ++#: config/rs6000/rs6000.c:10115 + msgid "bad move" + msgstr "" + +-#: config/rs6000/rs6000.c:12561 ++#: config/rs6000/rs6000.c:12679 + msgid "Bad 128-bit move" + msgstr "" + +-#: config/rs6000/rs6000.c:12742 config/xtensa/xtensa.c:2371 ++#: config/rs6000/rs6000.c:12859 ++#, fuzzy, c-format ++#| msgid "invalid %%Q value" ++msgid "invalid %%A value" ++msgstr "дрэннае %%Q значэнне" ++ ++#: config/rs6000/rs6000.c:12868 config/xtensa/xtensa.c:2371 + #, fuzzy, c-format + msgid "invalid %%D value" + msgstr "дрэннае %%Q значэнне" + +-#: config/rs6000/rs6000.c:12757 ++#: config/rs6000/rs6000.c:12883 + #, fuzzy, c-format + #| msgid "invalid %%Q value" + msgid "invalid %%e value" + msgstr "дрэннае %%Q значэнне" + +-#: config/rs6000/rs6000.c:12778 ++#: config/rs6000/rs6000.c:12904 + #, c-format + msgid "invalid %%f value" + msgstr "" + +-#: config/rs6000/rs6000.c:12787 ++#: config/rs6000/rs6000.c:12913 + #, c-format + msgid "invalid %%F value" + msgstr "" + +-#: config/rs6000/rs6000.c:12796 ++#: config/rs6000/rs6000.c:12922 + #, c-format + msgid "invalid %%G value" + msgstr "" + +-#: config/rs6000/rs6000.c:12831 ++#: config/rs6000/rs6000.c:12957 + #, c-format + msgid "invalid %%j code" + msgstr "" + +-#: config/rs6000/rs6000.c:12841 ++#: config/rs6000/rs6000.c:12967 + #, c-format + msgid "invalid %%J code" + msgstr "" + +-#: config/rs6000/rs6000.c:12851 ++#: config/rs6000/rs6000.c:12977 + #, c-format + msgid "invalid %%k value" + msgstr "" + +-#: config/rs6000/rs6000.c:12866 config/xtensa/xtensa.c:2414 ++#: config/rs6000/rs6000.c:12992 config/xtensa/xtensa.c:2414 + #, c-format + msgid "invalid %%K value" + msgstr "" + +-#: config/rs6000/rs6000.c:12913 ++#: config/rs6000/rs6000.c:13039 + #, c-format + msgid "invalid %%O value" + msgstr "нерэчаіснае значэньне %%O" + +-#: config/rs6000/rs6000.c:12960 ++#: config/rs6000/rs6000.c:13086 + #, c-format + msgid "invalid %%q value" + msgstr "" + +-#: config/rs6000/rs6000.c:13002 ++#: config/rs6000/rs6000.c:13128 + #, fuzzy, c-format + #| msgid "invalid %%Q value" + msgid "invalid %%t value" + msgstr "дрэннае %%Q значэнне" + +-#: config/rs6000/rs6000.c:13019 ++#: config/rs6000/rs6000.c:13145 + #, c-format + msgid "invalid %%T value" + msgstr "" + +-#: config/rs6000/rs6000.c:13031 ++#: config/rs6000/rs6000.c:13157 + #, c-format + msgid "invalid %%u value" + msgstr "" + +-#: config/rs6000/rs6000.c:13045 config/xtensa/xtensa.c:2383 ++#: config/rs6000/rs6000.c:13171 config/xtensa/xtensa.c:2383 + #, c-format + msgid "invalid %%v value" + msgstr "" + +-#: config/rs6000/rs6000.c:13095 ++#: config/rs6000/rs6000.c:13221 + #, c-format + msgid "invalid %%V value" + msgstr "нерэчаіснае значэньне %%V" + +-#: config/rs6000/rs6000.c:13112 config/xtensa/xtensa.c:2435 ++#: config/rs6000/rs6000.c:13238 config/xtensa/xtensa.c:2435 + #, fuzzy, c-format + #| msgid "invalid %%x/X value" + msgid "invalid %%x value" + msgstr "нерэчаіснае значэньне %%x/X" + +-#: config/rs6000/rs6000.c:13169 ++#: config/rs6000/rs6000.c:13295 + #, c-format + msgid "invalid %%z value" + msgstr "" + +-#: config/rs6000/rs6000.c:13238 ++#: config/rs6000/rs6000.c:13364 + #, fuzzy, c-format + msgid "invalid %%y value, try using the 'Z' constraint" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: config/rs6000/rs6000.c:14082 ++#: config/rs6000/rs6000.c:14208 + msgid "__float128 and __ibm128 cannot be used in the same expression" + msgstr "" + +-#: config/rs6000/rs6000.c:14088 ++#: config/rs6000/rs6000.c:14214 + msgid "__ibm128 and long double cannot be used in the same expression" + msgstr "" + +-#: config/rs6000/rs6000.c:14094 ++#: config/rs6000/rs6000.c:14220 + msgid "__float128 and long double cannot be used in the same expression" + msgstr "" + +-#: config/rs6000/rs6000.c:22852 ++#: config/rs6000/rs6000.c:23099 + #, fuzzy + #| msgid "too few arguments to function" + msgid "AltiVec argument passed to unprototyped function" + msgstr "не хапае аргументаў у функцыі" + +-#: config/rs6000/rs6000.c:25800 ++#: config/rs6000/rs6000.c:26116 + #, fuzzy + msgid "Could not generate addis value for fusion" + msgstr "Стварыць код для DLL" + +-#: config/rs6000/rs6000.c:25869 ++#: config/rs6000/rs6000.c:26185 + msgid "Unable to generate load/store offset for fusion" + msgstr "" + +-#: config/rs6000/rs6000.c:25945 ++#: config/rs6000/rs6000.c:26261 + msgid "Bad GPR fusion" + msgstr "" + ++#: config/rs6000/rs6000.c:26740 ++msgid "invalid conversion from type %<__vector_quad%>" ++msgstr "" ++ ++#: config/rs6000/rs6000.c:26742 ++msgid "invalid conversion to type %<__vector_quad%>" ++msgstr "" ++ ++#: config/rs6000/rs6000.c:26744 ++msgid "invalid conversion from type %<__vector_pair%>" ++msgstr "" ++ ++#: config/rs6000/rs6000.c:26746 ++msgid "invalid conversion to type %<__vector_pair%>" ++msgstr "" ++ ++#: config/rs6000/rs6000.c:26754 ++msgid "invalid conversion from type %<* __vector_quad%>" ++msgstr "" ++ ++#: config/rs6000/rs6000.c:26757 ++msgid "invalid conversion to type %<* __vector_quad%>" ++msgstr "" ++ ++#: config/rs6000/rs6000.c:26760 ++msgid "invalid conversion from type %<* __vector_pair%>" ++msgstr "" ++ ++#: config/rs6000/rs6000.c:26763 ++msgid "invalid conversion to type %<* __vector_pair%>" ++msgstr "" ++ + #: config/s390/s390.c:7787 + #, c-format + msgid "symbolic memory references are only supported on z10 or later" +@@ -3183,90 +3221,90 @@ msgstr "" + msgid "cannot decompose address" + msgstr "невядомая назва рэгістра: %s" + +-#: config/s390/s390.c:7880 ++#: config/s390/s390.c:7878 + #, c-format + msgid "invalid comparison operator for 'E' output modifier" + msgstr "" + +-#: config/s390/s390.c:7903 ++#: config/s390/s390.c:7901 + #, c-format + msgid "invalid reference for 'J' output modifier" + msgstr "" + +-#: config/s390/s390.c:7921 ++#: config/s390/s390.c:7919 + #, c-format + msgid "invalid address for 'O' output modifier" + msgstr "" + +-#: config/s390/s390.c:7943 ++#: config/s390/s390.c:7941 + #, c-format + msgid "invalid address for 'R' output modifier" + msgstr "" + +-#: config/s390/s390.c:7961 ++#: config/s390/s390.c:7959 + #, c-format + msgid "memory reference expected for 'S' output modifier" + msgstr "" + +-#: config/s390/s390.c:7971 ++#: config/s390/s390.c:7969 + #, c-format + msgid "invalid address for 'S' output modifier" + msgstr "" + +-#: config/s390/s390.c:7992 ++#: config/s390/s390.c:7990 + #, c-format + msgid "register or memory expression expected for 'N' output modifier" + msgstr "" + +-#: config/s390/s390.c:8003 ++#: config/s390/s390.c:8001 + #, c-format + msgid "register or memory expression expected for 'M' output modifier" + msgstr "" + +-#: config/s390/s390.c:8089 config/s390/s390.c:8110 ++#: config/s390/s390.c:8087 config/s390/s390.c:8108 + #, c-format + msgid "invalid constant for output modifier '%c'" + msgstr "" + +-#: config/s390/s390.c:8107 ++#: config/s390/s390.c:8105 + #, c-format + msgid "invalid constant - try using an output modifier" + msgstr "" + +-#: config/s390/s390.c:8144 ++#: config/s390/s390.c:8142 + #, c-format + msgid "invalid constant vector for output modifier '%c'" + msgstr "" + +-#: config/s390/s390.c:8151 ++#: config/s390/s390.c:8149 + #, c-format + msgid "invalid expression - try using an output modifier" + msgstr "" + +-#: config/s390/s390.c:8154 ++#: config/s390/s390.c:8152 + #, c-format + msgid "invalid expression for output modifier '%c'" + msgstr "" + +-#: config/s390/s390.c:11873 ++#: config/s390/s390.c:11871 + #, fuzzy + #| msgid "too few arguments to function" + msgid "vector argument passed to unprototyped function" + msgstr "не хапае аргументаў у функцыі" + +-#: config/s390/s390.c:16172 ++#: config/s390/s390.c:16238 + msgid "types differ in signedness" + msgstr "" + +-#: config/s390/s390.c:16182 ++#: config/s390/s390.c:16248 + msgid "binary operator does not support two vector bool operands" + msgstr "" + +-#: config/s390/s390.c:16185 ++#: config/s390/s390.c:16251 + msgid "binary operator does not support vector bool operand" + msgstr "" + +-#: config/s390/s390.c:16193 ++#: config/s390/s390.c:16259 + msgid "binary operator does not support mixing vector bool with floating point vector operands" + msgstr "" + +@@ -3534,8 +3572,8 @@ msgstr "" + #: c/gimple-parser.c:2193 c/gimple-parser.c:2230 c/gimple-parser.c:2309 + #: c/gimple-parser.c:2336 c/c-parser.c:3240 c/c-parser.c:3427 + #: c/c-parser.c:3460 c/c-parser.c:11296 c/gimple-parser.c:2027 +-#: c/gimple-parser.c:2066 cp/parser.c:13681 cp/parser.c:30000 +-#: cp/parser.c:30593 ++#: c/gimple-parser.c:2066 cp/parser.c:13686 cp/parser.c:30025 ++#: cp/parser.c:30618 + #, gcc-internal-format + msgid "expected %<;%>" + msgstr "" +@@ -3555,7 +3593,7 @@ msgstr "" + #: c/gimple-parser.c:1456 c/gimple-parser.c:1472 c/gimple-parser.c:1494 + #: c/gimple-parser.c:1524 c/gimple-parser.c:1550 c/gimple-parser.c:1756 + #: c/gimple-parser.c:1949 c/gimple-parser.c:1969 c/gimple-parser.c:2103 +-#: c/gimple-parser.c:2266 c/c-parser.c:7172 cp/parser.c:30641 ++#: c/gimple-parser.c:2266 c/c-parser.c:7172 cp/parser.c:30666 + #, gcc-internal-format + msgid "expected %<)%>" + msgstr "" +@@ -3563,7 +3601,7 @@ msgstr "" + #: c/c-parser.c:4074 c/c-parser.c:4806 c/c-parser.c:4950 c/c-parser.c:5023 + #: c/c-parser.c:5024 c/c-parser.c:5438 c/c-parser.c:5474 c/c-parser.c:7274 + #: c/c-parser.c:9272 c/c-parser.c:10162 c/c-parser.c:10451 c/c-parser.c:13073 +-#: c/gimple-parser.c:1733 cp/parser.c:30605 ++#: c/gimple-parser.c:1733 cp/parser.c:30630 + #, gcc-internal-format + msgid "expected %<]%>" + msgstr "" +@@ -3581,21 +3619,21 @@ msgstr "" + #: c/gimple-parser.c:1430 c/gimple-parser.c:1490 c/gimple-parser.c:1508 + #: c/gimple-parser.c:1543 c/gimple-parser.c:1918 c/gimple-parser.c:1929 + #: c/gimple-parser.c:1935 c/gimple-parser.c:2100 c/gimple-parser.c:2263 +-#: c/c-parser.c:13431 cp/parser.c:30596 ++#: c/c-parser.c:13431 cp/parser.c:30621 + #, gcc-internal-format + msgid "expected %<(%>" + msgstr "" + +-#: c/c-parser.c:4946 c/c-parser.c:4948 c/c-parser.c:13001 cp/parser.c:30608 +-#: cp/parser.c:34267 ++#: c/c-parser.c:4946 c/c-parser.c:4948 c/c-parser.c:13001 cp/parser.c:30633 ++#: cp/parser.c:34293 + #, gcc-internal-format + msgid "expected %<[%>" + msgstr "" + + #: c/c-parser.c:5608 c/c-parser.c:11639 c/c-parser.c:17941 c/c-parser.c:18724 + #: c/c-parser.c:21766 c/gimple-parser.c:385 c/gimple-parser.c:2269 +-#: c/c-parser.c:3228 c/c-parser.c:3450 c/c-parser.c:11191 cp/parser.c:19216 +-#: cp/parser.c:30602 ++#: c/c-parser.c:3228 c/c-parser.c:3450 c/c-parser.c:11191 cp/parser.c:19221 ++#: cp/parser.c:30627 + #, gcc-internal-format + msgid "expected %<{%>" + msgstr "" +@@ -3606,12 +3644,12 @@ msgstr "" + #: c/c-parser.c:15394 c/c-parser.c:15521 c/c-parser.c:20133 c/c-parser.c:20775 + #: c/c-parser.c:20834 c/gimple-parser.c:568 c/gimple-parser.c:871 + #: c/gimple-parser.c:2317 c/gimple-parser.c:2344 c/c-parser.c:7179 +-#: c/c-parser.c:13534 cp/parser.c:30635 cp/parser.c:32280 cp/parser.c:35058 ++#: c/c-parser.c:13534 cp/parser.c:30660 cp/parser.c:32306 cp/parser.c:35084 + #, gcc-internal-format + msgid "expected %<:%>" + msgstr "" + +-#: c/c-parser.c:6736 cp/parser.c:30522 ++#: c/c-parser.c:6736 cp/parser.c:30547 + #, gcc-internal-format + msgid "expected %" + msgstr "" +@@ -3620,7 +3658,7 @@ msgstr "" + #: c/c-parser.c:9343 c/c-parser.c:10054 c/c-parser.c:14363 c/c-parser.c:15477 + #: c/gimple-parser.c:1021 c/gimple-parser.c:1047 c/gimple-parser.c:1175 + #: c/gimple-parser.c:1178 c/gimple-parser.c:1512 c/gimple-parser.c:1518 +-#: cp/parser.c:29998 cp/parser.c:30611 ++#: cp/parser.c:30023 cp/parser.c:30636 + #, gcc-internal-format + msgid "expected %<,%>" + msgstr "" +@@ -3629,18 +3667,18 @@ msgstr "" + msgid "expected %<.%>" + msgstr "" + +-#: c/c-parser.c:10862 c/c-parser.c:10894 c/c-parser.c:11134 cp/parser.c:32854 +-#: cp/parser.c:32928 ++#: c/c-parser.c:10862 c/c-parser.c:10894 c/c-parser.c:11134 cp/parser.c:32880 ++#: cp/parser.c:32954 + #, gcc-internal-format + msgid "expected %<@end%>" + msgstr "" + +-#: c/c-parser.c:11552 c/gimple-parser.c:1348 cp/parser.c:30620 ++#: c/c-parser.c:11552 c/gimple-parser.c:1348 cp/parser.c:30645 + #, gcc-internal-format + msgid "expected %<>%>" + msgstr "" + +-#: c/c-parser.c:14864 c/c-parser.c:15758 cp/parser.c:30644 ++#: c/c-parser.c:14864 c/c-parser.c:15758 cp/parser.c:30669 + #, gcc-internal-format + msgid "expected %<,%> or %<)%>" + msgstr "" +@@ -3648,19 +3686,19 @@ msgstr "" + #. All following cases are statements with LHS. + #: c/c-parser.c:15386 c/c-parser.c:17397 c/c-parser.c:17441 c/c-parser.c:17673 + #: c/c-parser.c:18117 c/c-parser.c:20340 c/c-parser.c:20972 +-#: c/gimple-parser.c:725 c/c-parser.c:5497 cp/parser.c:30623 ++#: c/gimple-parser.c:725 c/c-parser.c:5497 cp/parser.c:30648 + #, gcc-internal-format + msgid "expected %<=%>" + msgstr "" + + #: c/c-parser.c:17689 c/c-parser.c:17989 c/gimple-parser.c:1566 + #: c/gimple-parser.c:1598 c/gimple-parser.c:1608 c/gimple-parser.c:2354 +-#: cp/parser.c:30599 cp/parser.c:33073 ++#: cp/parser.c:30624 cp/parser.c:33099 + #, gcc-internal-format + msgid "expected %<}%>" + msgstr "" + +-#: c/c-parser.c:18767 c/c-parser.c:18757 cp/parser.c:39683 ++#: c/c-parser.c:18767 c/c-parser.c:18757 cp/parser.c:39709 + #, gcc-internal-format + msgid "expected %<#pragma omp section%> or %<}%>" + msgstr "" +@@ -3669,7 +3707,7 @@ msgstr "" + msgid "(anonymous)" + msgstr "" + +-#: c/gimple-parser.c:1337 cp/parser.c:16636 cp/parser.c:30617 ++#: c/gimple-parser.c:1337 cp/parser.c:16641 cp/parser.c:30642 + #, gcc-internal-format + msgid "expected %<<%>" + msgstr "" +@@ -3680,34 +3718,34 @@ msgstr "" + msgid "expected label" + msgstr "" + +-#: cp/call.c:3866 ++#: cp/call.c:3868 + msgid "candidate:" + msgstr "" + +-#: cp/call.c:7217 ++#: cp/call.c:7220 + msgid " after user-defined conversion:" + msgstr "" + +-#: cp/call.c:7351 cp/pt.c:2031 cp/pt.c:24632 ++#: cp/call.c:7387 cp/pt.c:2031 cp/pt.c:24688 + msgid "candidate is:" + msgid_plural "candidates are:" + msgstr[0] "" + msgstr[1] "" + +-#: cp/call.c:11685 ++#: cp/call.c:11715 + msgid "candidate 1:" + msgstr "" + +-#: cp/call.c:11686 ++#: cp/call.c:11716 + msgid "candidate 2:" + msgstr "" + +-#: cp/decl.c:3258 ++#: cp/decl.c:3260 + #, fuzzy + msgid "jump to label %qD" + msgstr "паўтарэнне \"%s\"" + +-#: cp/decl.c:3259 ++#: cp/decl.c:3261 + msgid "jump to case label" + msgstr "" + +@@ -3805,7 +3843,7 @@ msgstr "невыкарыстаемы параметр \"%s\"" + msgid "" + msgstr "" + +-#: cp/error.c:2118 cp/error.c:3161 c-family/c-pretty-print.c:2202 ++#: cp/error.c:2118 cp/error.c:3161 c-family/c-pretty-print.c:2203 + #, gcc-internal-format + msgid "" + msgstr "" +@@ -3986,50 +4024,50 @@ msgstr "" + msgid "source type is not polymorphic" + msgstr "" + +-#: cp/typeck.c:6452 c/c-typeck.c:4396 ++#: cp/typeck.c:6512 c/c-typeck.c:4396 + #, gcc-internal-format + msgid "wrong type argument to unary minus" + msgstr "" + +-#: cp/typeck.c:6453 c/c-typeck.c:4383 ++#: cp/typeck.c:6513 c/c-typeck.c:4383 + #, gcc-internal-format + msgid "wrong type argument to unary plus" + msgstr "" + +-#: cp/typeck.c:6480 c/c-typeck.c:4440 ++#: cp/typeck.c:6540 c/c-typeck.c:4440 + #, gcc-internal-format + msgid "wrong type argument to bit-complement" + msgstr "" + +-#: cp/typeck.c:6497 c/c-typeck.c:4448 ++#: cp/typeck.c:6557 c/c-typeck.c:4448 + #, gcc-internal-format + msgid "wrong type argument to abs" + msgstr "" + +-#: cp/typeck.c:6509 c/c-typeck.c:4470 ++#: cp/typeck.c:6569 c/c-typeck.c:4470 + #, gcc-internal-format + msgid "wrong type argument to conjugation" + msgstr "" + +-#: cp/typeck.c:6527 ++#: cp/typeck.c:6587 + #, fuzzy + #| msgid "too many arguments to function" + msgid "in argument to unary !" + msgstr "вельмі шмат аргументаў у функцыі" + +-#: cp/typeck.c:6573 ++#: cp/typeck.c:6633 + msgid "no pre-increment operator for type" + msgstr "" + +-#: cp/typeck.c:6575 ++#: cp/typeck.c:6635 + msgid "no post-increment operator for type" + msgstr "" + +-#: cp/typeck.c:6577 ++#: cp/typeck.c:6637 + msgid "no pre-decrement operator for type" + msgstr "" + +-#: cp/typeck.c:6579 ++#: cp/typeck.c:6639 + msgid "no post-decrement operator for type" + msgstr "" + +@@ -4071,17 +4109,17 @@ msgstr "пустая сімвальная канстанта" + msgid "elemental binary operation" + msgstr "прапушчан ініцыялізатар" + +-#: fortran/check.c:3702 ++#: fortran/check.c:3709 + #, c-format + msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'" + msgstr "" + +-#: fortran/check.c:3910 fortran/check.c:3991 fortran/check.c:4056 ++#: fortran/check.c:3917 fortran/check.c:3998 fortran/check.c:4063 + #, c-format + msgid "arguments '%s' and '%s' for intrinsic %s" + msgstr "" + +-#: fortran/check.c:4388 fortran/intrinsic.c:4766 ++#: fortran/check.c:4401 fortran/intrinsic.c:4778 + #, c-format + msgid "arguments '%s' and '%s' for intrinsic '%s'" + msgstr "" +@@ -4155,7 +4193,7 @@ msgstr "" + msgid "Driving:" + msgstr "увага:" + +-#: fortran/interface.c:3401 fortran/intrinsic.c:4449 ++#: fortran/interface.c:3404 fortran/intrinsic.c:4461 + msgid "actual argument to INTENT = OUT/INOUT" + msgstr "" + +@@ -4170,7 +4208,7 @@ msgstr "" + + #. For INQUIRE, all tags except FILE, ID and UNIT are variable definition + #. contexts. Thus, use an extended RESOLVE_TAG macro for that. +-#: fortran/io.c:4725 ++#: fortran/io.c:4727 + #, c-format + msgid "%s tag with INQUIRE" + msgstr "" +@@ -4284,11 +4322,11 @@ msgstr "" + msgid "implied END DO" + msgstr "" + +-#: fortran/parse.c:2100 fortran/resolve.c:11845 ++#: fortran/parse.c:2100 fortran/resolve.c:11855 + msgid "assignment" + msgstr "" + +-#: fortran/parse.c:2103 fortran/resolve.c:11896 fortran/resolve.c:11899 ++#: fortran/parse.c:2103 fortran/resolve.c:11906 fortran/resolve.c:11909 + msgid "pointer assignment" + msgstr "" + +@@ -4296,219 +4334,219 @@ msgstr "" + msgid "simple IF" + msgstr "" + +-#: fortran/resolve.c:2300 fortran/resolve.c:2494 ++#: fortran/resolve.c:2302 fortran/resolve.c:2496 + msgid "elemental procedure" + msgstr "" + +-#: fortran/resolve.c:2397 ++#: fortran/resolve.c:2399 + #, fuzzy + #| msgid "no arguments" + msgid "allocatable argument" + msgstr "няма аргументаў" + +-#: fortran/resolve.c:2402 ++#: fortran/resolve.c:2404 + #, fuzzy + #| msgid "no arguments" + msgid "asynchronous argument" + msgstr "няма аргументаў" + +-#: fortran/resolve.c:2407 ++#: fortran/resolve.c:2409 + #, fuzzy + #| msgid "no arguments" + msgid "optional argument" + msgstr "няма аргументаў" + +-#: fortran/resolve.c:2412 ++#: fortran/resolve.c:2414 + #, fuzzy + #| msgid "no arguments" + msgid "pointer argument" + msgstr "няма аргументаў" + +-#: fortran/resolve.c:2417 ++#: fortran/resolve.c:2419 + #, fuzzy + #| msgid "no arguments" + msgid "target argument" + msgstr "няма аргументаў" + +-#: fortran/resolve.c:2422 ++#: fortran/resolve.c:2424 + #, fuzzy + #| msgid "no arguments" + msgid "value argument" + msgstr "няма аргументаў" + +-#: fortran/resolve.c:2427 ++#: fortran/resolve.c:2429 + #, fuzzy + #| msgid "no arguments" + msgid "volatile argument" + msgstr "няма аргументаў" + +-#: fortran/resolve.c:2432 ++#: fortran/resolve.c:2434 + msgid "assumed-shape argument" + msgstr "" + +-#: fortran/resolve.c:2437 ++#: fortran/resolve.c:2439 + #, fuzzy + #| msgid "no arguments" + msgid "assumed-rank argument" + msgstr "няма аргументаў" + +-#: fortran/resolve.c:2442 ++#: fortran/resolve.c:2444 + #, fuzzy + #| msgid "no arguments" + msgid "coarray argument" + msgstr "няма аргументаў" + +-#: fortran/resolve.c:2447 ++#: fortran/resolve.c:2449 + msgid "parametrized derived type argument" + msgstr "" + +-#: fortran/resolve.c:2452 ++#: fortran/resolve.c:2454 + #, fuzzy + #| msgid "no arguments" + msgid "polymorphic argument" + msgstr "няма аргументаў" + +-#: fortran/resolve.c:2457 ++#: fortran/resolve.c:2459 + msgid "NO_ARG_CHECK attribute" + msgstr "" + + #. As assumed-type is unlimited polymorphic (cf. above). + #. See also TS 29113, Note 6.1. +-#: fortran/resolve.c:2464 ++#: fortran/resolve.c:2466 + msgid "assumed-type argument" + msgstr "" + +-#: fortran/resolve.c:2475 ++#: fortran/resolve.c:2477 + msgid "array result" + msgstr "" + +-#: fortran/resolve.c:2480 ++#: fortran/resolve.c:2482 + msgid "pointer or allocatable result" + msgstr "" + +-#: fortran/resolve.c:2487 ++#: fortran/resolve.c:2489 + msgid "result with non-constant character length" + msgstr "" + +-#: fortran/resolve.c:2499 ++#: fortran/resolve.c:2501 + msgid "bind(c) procedure" + msgstr "" + +-#: fortran/resolve.c:4013 ++#: fortran/resolve.c:4015 + #, c-format + msgid "Invalid context for NULL() pointer at %%L" + msgstr "" + +-#: fortran/resolve.c:4029 ++#: fortran/resolve.c:4031 + #, c-format + msgid "Operand of unary numeric operator %%<%s%%> at %%L is %s" + msgstr "" + +-#: fortran/resolve.c:4046 ++#: fortran/resolve.c:4048 + #, c-format + msgid "Unexpected derived-type entities in binary intrinsic numeric operator %%<%s%%> at %%L" + msgstr "" + +-#: fortran/resolve.c:4051 ++#: fortran/resolve.c:4053 + #, c-format + msgid "Operands of binary numeric operator %%<%s%%> at %%L are %s/%s" + msgstr "" + +-#: fortran/resolve.c:4066 ++#: fortran/resolve.c:4068 + #, c-format + msgid "Operands of string concatenation operator at %%L are %s/%s" + msgstr "" + +-#: fortran/resolve.c:4108 ++#: fortran/resolve.c:4110 + #, c-format + msgid "Operands of logical operator %%<%s%%> at %%L are %s/%s" + msgstr "" + +-#: fortran/resolve.c:4131 ++#: fortran/resolve.c:4133 + #, c-format + msgid "Operand of .not. operator at %%L is %s" + msgstr "" + +-#: fortran/resolve.c:4145 ++#: fortran/resolve.c:4147 + msgid "COMPLEX quantities cannot be compared at %L" + msgstr "" + +-#: fortran/resolve.c:4243 ++#: fortran/resolve.c:4245 + #, c-format + msgid "Logicals at %%L must be compared with %s instead of %s" + msgstr "" + +-#: fortran/resolve.c:4249 ++#: fortran/resolve.c:4251 + #, c-format + msgid "Operands of comparison operator %%<%s%%> at %%L are %s/%s" + msgstr "" + +-#: fortran/resolve.c:4262 ++#: fortran/resolve.c:4264 + #, c-format + msgid "Unknown operator %%<%s%%> at %%L; did you mean '%s'?" + msgstr "" + +-#: fortran/resolve.c:4265 ++#: fortran/resolve.c:4267 + #, c-format + msgid "Unknown operator %%<%s%%> at %%L" + msgstr "" + +-#: fortran/resolve.c:4268 ++#: fortran/resolve.c:4270 + #, c-format + msgid "Operand of user operator %%<%s%%> at %%L is %s" + msgstr "" + +-#: fortran/resolve.c:4272 ++#: fortran/resolve.c:4274 + #, c-format + msgid "Operands of user operator %%<%s%%> at %%L are %s/%s" + msgstr "" + +-#: fortran/resolve.c:4358 ++#: fortran/resolve.c:4360 + #, c-format + msgid "Inconsistent ranks for operator at %%L and %%L" + msgstr "" + +-#: fortran/resolve.c:7175 ++#: fortran/resolve.c:7177 + msgid "Loop variable" + msgstr "" + +-#: fortran/resolve.c:7179 ++#: fortran/resolve.c:7181 + msgid "iterator variable" + msgstr "" + +-#: fortran/resolve.c:7183 ++#: fortran/resolve.c:7185 + msgid "Start expression in DO loop" + msgstr "" + +-#: fortran/resolve.c:7187 ++#: fortran/resolve.c:7189 + msgid "End expression in DO loop" + msgstr "" + +-#: fortran/resolve.c:7191 ++#: fortran/resolve.c:7193 + msgid "Step expression in DO loop" + msgstr "" + +-#: fortran/resolve.c:7477 fortran/resolve.c:7480 ++#: fortran/resolve.c:7479 fortran/resolve.c:7482 + msgid "DEALLOCATE object" + msgstr "" + +-#: fortran/resolve.c:7857 fortran/resolve.c:7860 ++#: fortran/resolve.c:7859 fortran/resolve.c:7862 + msgid "ALLOCATE object" + msgstr "" + +-#: fortran/resolve.c:8093 fortran/resolve.c:10035 ++#: fortran/resolve.c:8095 fortran/resolve.c:10037 + msgid "STAT variable" + msgstr "" + +-#: fortran/resolve.c:8137 fortran/resolve.c:10047 ++#: fortran/resolve.c:8139 fortran/resolve.c:10049 + msgid "ERRMSG variable" + msgstr "" + +-#: fortran/resolve.c:9841 ++#: fortran/resolve.c:9843 + msgid "item in READ" + msgstr "" + +-#: fortran/resolve.c:10059 ++#: fortran/resolve.c:10061 + msgid "ACQUIRED_LOCK variable" + msgstr "" + +@@ -4521,27 +4559,27 @@ msgstr "" + msgid "Integer overflow when calculating the amount of memory to allocate" + msgstr "" + +-#: fortran/trans-array.c:9737 ++#: fortran/trans-array.c:9739 + #, c-format + msgid "The value of the PDT LEN parameter '%s' does not agree with that in the dummy declaration" + msgstr "" + +-#: fortran/trans-decl.c:6191 ++#: fortran/trans-decl.c:6196 + #, c-format + msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)" + msgstr "" + +-#: fortran/trans-decl.c:6199 ++#: fortran/trans-decl.c:6204 + #, c-format + msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)" + msgstr "" + +-#: fortran/trans-expr.c:9527 ++#: fortran/trans-expr.c:9534 + #, c-format + msgid "Target of rank remapping is too small (%ld < %ld)" + msgstr "" + +-#: fortran/trans-expr.c:10941 ++#: fortran/trans-expr.c:10948 + msgid "Assignment of scalar to unallocated array" + msgstr "" + +@@ -4616,7 +4654,7 @@ msgstr "" + msgid "Assigned label is not a target label" + msgstr "" + +-#: fortran/trans-stmt.c:1250 ++#: fortran/trans-stmt.c:1251 + #, c-format + msgid "Invalid image number %d in SYNC IMAGES" + msgstr "" +@@ -5070,7 +5108,7 @@ msgstr "немагчыма стварыць часовы файл" + #: common.opt:652 common.opt:790 common.opt:1010 common.opt:1014 + #: common.opt:1018 common.opt:1022 common.opt:1642 common.opt:1698 + #: common.opt:1830 common.opt:1834 common.opt:2068 common.opt:2274 +-#: common.opt:2983 ++#: common.opt:2987 + #, no-c-format + msgid "Does nothing. Preserved for backward compatibility." + msgstr "" +@@ -5653,8 +5691,8 @@ msgstr "" + #: common.opt:1917 common.opt:1960 common.opt:2349 common.opt:2385 + #: common.opt:2478 common.opt:2482 common.opt:2591 common.opt:2682 + #: common.opt:2690 common.opt:2698 common.opt:2706 common.opt:2807 +-#: common.opt:2859 common.opt:2947 common.opt:3084 common.opt:3088 +-#: common.opt:3092 common.opt:3096 ++#: common.opt:2863 common.opt:2951 common.opt:3088 common.opt:3092 ++#: common.opt:3096 common.opt:3100 + #, no-c-format + msgid "Does nothing. Preserved for backward compatibility." + msgstr "" +@@ -8109,105 +8147,100 @@ msgstr "" + + #: analyzer/analyzer.opt:103 + #, no-c-format +-msgid "Warn about code paths in which an uninitialized value is used." +-msgstr "" +- +-#: analyzer/analyzer.opt:107 +-#, no-c-format + msgid "Warn if the code is too complicated for the analyzer to fully explore." + msgstr "" + +-#: analyzer/analyzer.opt:111 ++#: analyzer/analyzer.opt:107 + #, no-c-format + msgid "Restrict the analyzer to run just the named checker." + msgstr "" + +-#: analyzer/analyzer.opt:115 ++#: analyzer/analyzer.opt:111 + #, no-c-format + msgid "Avoid combining multiple statements into one exploded edge." + msgstr "" + +-#: analyzer/analyzer.opt:119 ++#: analyzer/analyzer.opt:115 + #, no-c-format + msgid "Issue a note when diagnostics are deduplicated." + msgstr "" + +-#: analyzer/analyzer.opt:123 ++#: analyzer/analyzer.opt:119 + #, no-c-format + msgid "Purge unneeded state during analysis." + msgstr "" + +-#: analyzer/analyzer.opt:127 ++#: analyzer/analyzer.opt:123 + #, no-c-format + msgid "Merge similar-enough states during analysis." + msgstr "" + +-#: analyzer/analyzer.opt:131 ++#: analyzer/analyzer.opt:127 + #, no-c-format + msgid "Enable transitivity of constraints during analysis." + msgstr "" + +-#: analyzer/analyzer.opt:135 ++#: analyzer/analyzer.opt:131 + #, no-c-format + msgid "Approximate the effect of function calls to simplify analysis." + msgstr "" + +-#: analyzer/analyzer.opt:139 ++#: analyzer/analyzer.opt:135 + #, no-c-format + msgid "Emit more verbose descriptions of control flow in diagnostics." + msgstr "" + +-#: analyzer/analyzer.opt:143 ++#: analyzer/analyzer.opt:139 + #, no-c-format + msgid "Emit more verbose descriptions of state changes in diagnostics." + msgstr "" + +-#: analyzer/analyzer.opt:147 ++#: analyzer/analyzer.opt:143 + #, no-c-format + msgid "Control which events are displayed in diagnostic paths." + msgstr "" + +-#: analyzer/analyzer.opt:151 ++#: analyzer/analyzer.opt:147 + #, no-c-format + msgid "Dump various analyzer internals to SRCFILE.analyzer.txt." + msgstr "" + +-#: analyzer/analyzer.opt:155 ++#: analyzer/analyzer.opt:151 + #, no-c-format + msgid "Dump various analyzer internals to stderr." + msgstr "" + +-#: analyzer/analyzer.opt:159 ++#: analyzer/analyzer.opt:155 + #, no-c-format + msgid "Dump analyzer-specific call graph information to a SRCFILE.callgraph.dot file." + msgstr "" + +-#: analyzer/analyzer.opt:163 ++#: analyzer/analyzer.opt:159 + #, no-c-format + msgid "Dump the analyzer exploded graph to a SRCFILE.eg.dot file." + msgstr "" + +-#: analyzer/analyzer.opt:167 ++#: analyzer/analyzer.opt:163 + #, no-c-format + msgid "Emit diagnostics showing the location of nodes in the exploded graph." + msgstr "" + +-#: analyzer/analyzer.opt:171 ++#: analyzer/analyzer.opt:167 + #, no-c-format + msgid "Dump a textual representation of the exploded graph to SRCFILE.eg.txt." + msgstr "" + +-#: analyzer/analyzer.opt:175 ++#: analyzer/analyzer.opt:171 + #, no-c-format + msgid "Dump a textual representation of the exploded graph to SRCFILE.eg-ID.txt." + msgstr "" + +-#: analyzer/analyzer.opt:179 ++#: analyzer/analyzer.opt:175 + #, no-c-format + msgid "Dump state-purging information to a SRCFILE.state-purge.dot file." + msgstr "" + +-#: analyzer/analyzer.opt:183 ++#: analyzer/analyzer.opt:179 + #, no-c-format + msgid "Dump the analyzer supergraph to a SRCFILE.supergraph.dot file." + msgstr "" +@@ -12740,7 +12773,7 @@ msgstr "" + + #: config/rs6000/rs6000.opt:572 + #, no-c-format +-msgid "Use instructions for a future architecture." ++msgid "Use instructions added in ISA 3.1." + msgstr "" + + #: config/rs6000/rs6000.opt:576 +@@ -12754,6 +12787,12 @@ msgstr "Не генерыраваць сімвальныя інструкцыі" + msgid "Generate (do not generate) pc-relative memory addressing." + msgstr "" + ++#: config/rs6000/rs6000.opt:584 ++#, fuzzy, no-c-format ++#| msgid "Do not generate char instructions" ++msgid "Generate (do not generate) MMA instructions." ++msgstr "Не генерыраваць сімвальныя інструкцыі" ++ + #: config/rs6000/sysv4.opt:24 + #, no-c-format + msgid "-mcall-ABI\tSelect ABI calling convention." +@@ -17775,7 +17814,7 @@ msgstr "" + + #: common.opt:2213 + #, no-c-format +-msgid "Remove prefix from absolute path before manging name for -fprofile-generate= and -fprofile-use=." ++msgid "Remove prefix from absolute path before mangling name for -fprofile-generate= and -fprofile-use=." + msgstr "" + + #: common.opt:2217 +@@ -18428,371 +18467,371 @@ msgstr "" + msgid "Perform loop unrolling for all loops." + msgstr "" + +-#: common.opt:2863 ++#: common.opt:2867 + #, no-c-format + msgid "Allow optimization for floating-point arithmetic which may change the result of the operation due to rounding." + msgstr "" + +-#: common.opt:2868 ++#: common.opt:2872 + #, no-c-format + msgid "Same as -fassociative-math for expressions which include division." + msgstr "" + +-#: common.opt:2876 ++#: common.opt:2880 + #, no-c-format + msgid "Allow math optimizations that may violate IEEE or ISO standards." + msgstr "" + +-#: common.opt:2880 ++#: common.opt:2884 + #, no-c-format + msgid "Perform loop unswitching." + msgstr "" + +-#: common.opt:2884 ++#: common.opt:2888 + #, no-c-format + msgid "Perform loop splitting." + msgstr "" + +-#: common.opt:2888 ++#: common.opt:2892 + #, no-c-format + msgid "Version loops based on whether indices have a stride of one." + msgstr "" + +-#: common.opt:2892 ++#: common.opt:2896 + #, fuzzy, no-c-format + #| msgid "Enable exception handling" + msgid "Just generate unwind tables for exception handling." + msgstr "Уключыць апрацоўку выключэньняў" + +-#: common.opt:2896 ++#: common.opt:2900 + #, no-c-format + msgid "Use the bfd linker instead of the default linker." + msgstr "" + +-#: common.opt:2900 ++#: common.opt:2904 + #, no-c-format + msgid "Use the gold linker instead of the default linker." + msgstr "" + +-#: common.opt:2904 ++#: common.opt:2908 + #, no-c-format + msgid "Use the lld LLVM linker instead of the default linker." + msgstr "" + +-#: common.opt:2916 ++#: common.opt:2920 + #, no-c-format + msgid "Perform variable tracking." + msgstr "" + +-#: common.opt:2924 ++#: common.opt:2928 + #, no-c-format + msgid "Perform variable tracking by annotating assignments." + msgstr "" + +-#: common.opt:2930 ++#: common.opt:2934 + #, no-c-format + msgid "Toggle -fvar-tracking-assignments." + msgstr "" + +-#: common.opt:2938 ++#: common.opt:2942 + #, no-c-format + msgid "Perform variable tracking and also tag variables that are uninitialized." + msgstr "" + +-#: common.opt:2943 ++#: common.opt:2947 + #, no-c-format + msgid "Enable vectorization on trees." + msgstr "" + +-#: common.opt:2951 ++#: common.opt:2955 + #, fuzzy, no-c-format + #| msgid "Enable SSA optimizations" + msgid "Enable loop vectorization on trees." + msgstr "Уключаць SSA аптымізацыю" + +-#: common.opt:2955 ++#: common.opt:2959 + #, no-c-format + msgid "Enable basic block vectorization (SLP) on trees." + msgstr "" + +-#: common.opt:2959 ++#: common.opt:2963 + #, no-c-format + msgid "-fvect-cost-model=[unlimited|dynamic|cheap]\tSpecifies the cost model for vectorization." + msgstr "" + +-#: common.opt:2963 ++#: common.opt:2967 + #, no-c-format + msgid "-fsimd-cost-model=[unlimited|dynamic|cheap]\tSpecifies the vectorization cost model for code marked with a simd directive." + msgstr "" + +-#: common.opt:2979 ++#: common.opt:2983 + #, no-c-format + msgid "Enables the dynamic vectorizer cost model. Preserved for backward compatibility." + msgstr "" + +-#: common.opt:2987 ++#: common.opt:2991 + #, no-c-format + msgid "Enable copy propagation of scalar-evolution information." + msgstr "" + +-#: common.opt:2997 ++#: common.opt:3001 + #, no-c-format + msgid "Add extra commentary to assembler output." + msgstr "" + +-#: common.opt:3001 ++#: common.opt:3005 + #, no-c-format + msgid "-fvisibility=[default|internal|hidden|protected]\tSet the default symbol visibility." + msgstr "" + +-#: common.opt:3020 ++#: common.opt:3024 + #, no-c-format + msgid "Validate vtable pointers before using them." + msgstr "" + +-#: common.opt:3036 ++#: common.opt:3040 + #, no-c-format + msgid "Output vtable verification counters." + msgstr "" + +-#: common.opt:3040 ++#: common.opt:3044 + #, no-c-format + msgid "Output vtable verification pointer sets information." + msgstr "" + +-#: common.opt:3044 ++#: common.opt:3048 + #, no-c-format + msgid "Use expression value profiles in optimizations." + msgstr "" + +-#: common.opt:3048 ++#: common.opt:3052 + #, no-c-format + msgid "Construct webs and split unrelated uses of single variable." + msgstr "" + +-#: common.opt:3052 ++#: common.opt:3056 + #, no-c-format + msgid "Enable conditional dead code elimination for builtin calls." + msgstr "" + +-#: common.opt:3056 ++#: common.opt:3060 + #, no-c-format + msgid "Perform whole program optimizations." + msgstr "" + +-#: common.opt:3060 ++#: common.opt:3064 + #, no-c-format + msgid "Assume pointer overflow wraps around." + msgstr "" + +-#: common.opt:3064 ++#: common.opt:3068 + #, no-c-format + msgid "Assume signed arithmetic overflow wraps around." + msgstr "" + +-#: common.opt:3068 ++#: common.opt:3072 + #, no-c-format + msgid "Put zero initialized data in the bss section." + msgstr "" + +-#: common.opt:3072 ++#: common.opt:3076 + #, no-c-format + msgid "Generate debug information in default format." + msgstr "" + +-#: common.opt:3076 ++#: common.opt:3080 + #, no-c-format + msgid "Assume assembler support for (DWARF2+) .loc directives." + msgstr "" + +-#: common.opt:3080 ++#: common.opt:3084 + #, no-c-format + msgid "Assume assembler support for view in (DWARF2+) .loc directives." + msgstr "" + +-#: common.opt:3100 ++#: common.opt:3104 + #, no-c-format + msgid "Record DW_AT_decl_column and DW_AT_call_column in DWARF." + msgstr "" + +-#: common.opt:3104 ++#: common.opt:3108 + #, no-c-format + msgid "Generate debug information in default version of DWARF format." + msgstr "" + +-#: common.opt:3108 ++#: common.opt:3112 + #, no-c-format + msgid "Generate debug information in DWARF v2 (or later) format." + msgstr "" + +-#: common.opt:3112 ++#: common.opt:3116 + #, no-c-format + msgid "Generate debug information in default extended format." + msgstr "" + +-#: common.opt:3116 ++#: common.opt:3120 + #, no-c-format + msgid "Generate extended entry point information for inlined functions." + msgstr "" + +-#: common.opt:3120 ++#: common.opt:3124 + #, no-c-format + msgid "Compute locview reset points based on insn length estimates." + msgstr "" + +-#: common.opt:3128 ++#: common.opt:3132 + #, no-c-format + msgid "Don't generate DWARF pubnames and pubtypes sections." + msgstr "" + +-#: common.opt:3132 ++#: common.opt:3136 + #, no-c-format + msgid "Generate DWARF pubnames and pubtypes sections." + msgstr "" + +-#: common.opt:3136 ++#: common.opt:3140 + #, no-c-format + msgid "Generate DWARF pubnames and pubtypes sections with GNU extensions." + msgstr "" + +-#: common.opt:3140 ++#: common.opt:3144 + #, no-c-format + msgid "Record gcc command line switches in DWARF DW_AT_producer." + msgstr "" + +-#: common.opt:3144 ++#: common.opt:3148 + #, no-c-format + msgid "Generate debug information in separate .dwo files." + msgstr "" + +-#: common.opt:3148 ++#: common.opt:3152 + #, fuzzy, no-c-format + msgid "Generate debug information in STABS format." + msgstr "Стварыць код для DLL" + +-#: common.opt:3152 ++#: common.opt:3156 + #, no-c-format + msgid "Generate debug information in extended STABS format." + msgstr "" + +-#: common.opt:3156 ++#: common.opt:3160 + #, no-c-format + msgid "Emit progressive recommended breakpoint locations." + msgstr "" + +-#: common.opt:3160 ++#: common.opt:3164 + #, no-c-format + msgid "Don't emit DWARF additions beyond selected version." + msgstr "" + +-#: common.opt:3164 ++#: common.opt:3168 + #, no-c-format + msgid "Add description attributes to some DWARF DIEs that have no name attribute." + msgstr "" + +-#: common.opt:3168 ++#: common.opt:3172 + #, no-c-format + msgid "Toggle debug information generation." + msgstr "" + +-#: common.opt:3172 ++#: common.opt:3176 + #, no-c-format + msgid "Augment variable location lists with progressive views." + msgstr "" + +-#: common.opt:3179 ++#: common.opt:3183 + #, fuzzy, no-c-format + msgid "Generate debug information in VMS format." + msgstr "Стварыць код для DLL" + +-#: common.opt:3183 ++#: common.opt:3187 + #, no-c-format + msgid "Generate debug information in XCOFF format." + msgstr "" + +-#: common.opt:3187 ++#: common.opt:3191 + #, no-c-format + msgid "Generate debug information in extended XCOFF format." + msgstr "" + +-#: common.opt:3205 ++#: common.opt:3209 + #, no-c-format + msgid "Generate compressed debug sections." + msgstr "" + +-#: common.opt:3209 ++#: common.opt:3213 + #, no-c-format + msgid "-gz=\tGenerate compressed debug sections in format ." + msgstr "" + +-#: common.opt:3216 ++#: common.opt:3220 + #, no-c-format + msgid "-iplugindir=\tSet to be the default plugin directory." + msgstr "" + +-#: common.opt:3220 ++#: common.opt:3224 + #, no-c-format + msgid "-imultiarch \tSet to be the multiarch include subdirectory." + msgstr "" + +-#: common.opt:3245 ++#: common.opt:3249 + #, fuzzy, no-c-format + #| msgid " -o Place the output into \n" + msgid "-o \tPlace output into ." + msgstr " -o <файл> Памясціць вывад у <файл>\n" + +-#: common.opt:3249 ++#: common.opt:3253 + #, fuzzy, no-c-format + #| msgid "Enable exception handling" + msgid "Enable function profiling." + msgstr "Уключыць апрацоўку выключэньняў" + +-#: common.opt:3259 ++#: common.opt:3263 + #, no-c-format + msgid "Like -pedantic but issue them as errors." + msgstr "" + +-#: common.opt:3299 ++#: common.opt:3303 + #, no-c-format + msgid "Do not display functions compiled or elapsed time." + msgstr "" + +-#: common.opt:3331 ++#: common.opt:3335 + #, no-c-format + msgid "Enable verbose output." + msgstr "" + +-#: common.opt:3335 ++#: common.opt:3339 + #, no-c-format + msgid "Display the compiler's version." + msgstr "" + +-#: common.opt:3339 ++#: common.opt:3343 + #, no-c-format + msgid "Suppress warnings." + msgstr "" + +-#: common.opt:3349 ++#: common.opt:3353 + #, no-c-format + msgid "Create a shared library." + msgstr "" + +-#: common.opt:3394 ++#: common.opt:3398 + #, no-c-format + msgid "Don't create a dynamically linked position independent executable." + msgstr "" + +-#: common.opt:3398 ++#: common.opt:3402 + #, no-c-format + msgid "Create a dynamically linked position independent executable." + msgstr "" + +-#: common.opt:3402 ++#: common.opt:3406 + #, no-c-format + msgid "Create a static position independent executable." + msgstr "" + +-#: common.opt:3409 ++#: common.opt:3413 + #, no-c-format + msgid "Use caller save register across calls if possible." + msgstr "" +@@ -19942,8 +19981,8 @@ msgstr "" + msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check." + msgstr "" + +-#: go/gofrontend/expressions.cc:116 c-family/c-warn.c:672 cp/cvt.c:1389 +-#: cp/cvt.c:1645 ++#: go/gofrontend/expressions.cc:116 c-family/c-warn.c:672 cp/cvt.c:1388 ++#: cp/cvt.c:1644 + #, gcc-internal-format + msgid "value computed is not used" + msgstr "" +@@ -19971,7 +20010,7 @@ msgid "expected boolean type" + msgstr "" + + #: go/gofrontend/expressions.cc:5048 c/c-parser.c:15301 c/c-parser.c:15308 +-#: cp/parser.c:36331 cp/parser.c:36338 ++#: cp/parser.c:36357 cp/parser.c:36364 + #, gcc-internal-format + msgid "expected integer" + msgstr "" +@@ -20040,7 +20079,7 @@ msgstr "няма аргументаў" + #: go/gofrontend/expressions.cc:10076 go/gofrontend/expressions.cc:10157 + #: go/gofrontend/expressions.cc:10230 go/gofrontend/expressions.cc:11041 + #: go/gofrontend/expressions.cc:12098 go/gofrontend/expressions.cc:12112 +-#: go/gofrontend/expressions.cc:12133 cp/pt.c:8945 ++#: go/gofrontend/expressions.cc:12133 cp/pt.c:8954 + #, fuzzy, gcc-internal-format + #| msgid "too many arguments to function" + msgid "too many arguments" +@@ -20426,7 +20465,7 @@ msgstr "" + + #: attribs.c:452 c-family/c-attribs.c:2080 c-family/c-attribs.c:2497 + #: c-family/c-attribs.c:3886 c-family/c-attribs.c:3900 +-#: c-family/c-attribs.c:3914 c-family/c-attribs.c:3929 cp/decl.c:14810 ++#: c-family/c-attribs.c:3914 c-family/c-attribs.c:3929 cp/decl.c:14819 + #: cp/friend.c:303 cp/tree.c:4792 + #, fuzzy, gcc-internal-format + msgid "previous declaration here" +@@ -20512,12 +20551,12 @@ msgstr "" + #: c-family/c-attribs.c:4363 c-family/c-attribs.c:4419 + #: c-family/c-attribs.c:4435 c-family/c-attribs.c:4529 + #: c-family/c-common.c:5694 c-family/c-common.c:5697 config/darwin.c:2062 +-#: config/arm/arm.c:7149 config/arm/arm.c:7177 config/arm/arm.c:7194 ++#: config/arm/arm.c:7246 config/arm/arm.c:7274 config/arm/arm.c:7291 + #: config/avr/avr.c:9675 config/csky/csky.c:6046 config/csky/csky.c:6068 + #: config/h8300/h8300.c:5347 config/h8300/h8300.c:5371 +-#: config/i386/i386-options.c:3309 config/i386/i386-options.c:3467 +-#: config/i386/i386-options.c:3699 config/ia64/ia64.c:785 +-#: config/rs6000/rs6000.c:19357 ada/gcc-interface/utils.c:6436 ++#: config/i386/i386-options.c:3313 config/i386/i386-options.c:3471 ++#: config/i386/i386-options.c:3703 config/ia64/ia64.c:785 ++#: config/rs6000/rs6000.c:19604 ada/gcc-interface/utils.c:6436 + #: ada/gcc-interface/utils.c:6464 ada/gcc-interface/utils.c:6481 + #: ada/gcc-interface/utils.c:6498 ada/gcc-interface/utils.c:6513 + #: ada/gcc-interface/utils.c:6529 ada/gcc-interface/utils.c:6555 +@@ -20536,8 +20575,8 @@ msgstr "\"%s\" атрыбут ігнарыруецца" + msgid "missing % attribute for multi-versioned %qD" + msgstr "" + +-#: attribs.c:998 cp/decl.c:1162 cp/decl.c:2018 cp/decl.c:2062 cp/decl.c:2073 +-#: cp/decl.c:2676 cp/decl.c:3103 ++#: attribs.c:998 cp/decl.c:1162 cp/decl.c:2018 cp/decl.c:2064 cp/decl.c:2075 ++#: cp/decl.c:2678 cp/decl.c:3105 + #, fuzzy, gcc-internal-format + #| msgid "previous declaration of `%D'" + msgid "previous declaration of %qD" +@@ -20659,7 +20698,7 @@ msgstr "" + msgid "offset %qwi outside bounds of constant string" + msgstr "" + +-#: builtins.c:815 cp/name-lookup.c:5333 ++#: builtins.c:815 cp/name-lookup.c:5335 + #, gcc-internal-format + msgid "%qE declared here" + msgstr "" +@@ -20952,7 +20991,7 @@ msgstr "аргумент для \"%s\" прапушчан" + + #. All valid uses of __builtin_va_arg_pack () are removed during + #. inlining. +-#: builtins.c:7931 expr.c:11097 ++#: builtins.c:7931 expr.c:11102 + #, gcc-internal-format + msgid "%Kinvalid use of %<__builtin_va_arg_pack ()%>" + msgstr "" +@@ -21252,12 +21291,12 @@ msgstr "" + msgid "% clobber conflict with input operand" + msgstr "" + +-#: cfgexpand.c:6420 ++#: cfgexpand.c:6421 + #, gcc-internal-format + msgid "stack protector not protecting local variables: variable length buffer" + msgstr "" + +-#: cfgexpand.c:6424 ++#: cfgexpand.c:6425 + #, gcc-internal-format, gfc-internal-format + msgid "stack protector not protecting function: all local arrays are less than %d bytes long" + msgstr "" +@@ -21786,303 +21825,303 @@ msgstr "" + msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)" + msgstr "" + +-#: cgraph.c:3136 ++#: cgraph.c:3138 + #, gcc-internal-format + msgid "caller edge count invalid" + msgstr "" + +-#: cgraph.c:3232 ++#: cgraph.c:3234 + #, gcc-internal-format + msgid "missing indirect call in speculative call sequence" + msgstr "" + +-#: cgraph.c:3237 ++#: cgraph.c:3239 + #, gcc-internal-format + msgid "indirect call in speculative call sequence has no speculative flag" + msgstr "" + +-#: cgraph.c:3267 ++#: cgraph.c:3269 + #, gcc-internal-format + msgid "speculative edges are not adjacent" + msgstr "" + +-#: cgraph.c:3273 ++#: cgraph.c:3275 + #, gcc-internal-format, gfc-internal-format + msgid "direct call to %s in speculative call sequence has no speculative flag" + msgstr "" + +-#: cgraph.c:3279 cgraph.c:3309 ++#: cgraph.c:3281 cgraph.c:3311 + #, gcc-internal-format, gfc-internal-format + msgid "direct call to %s in speculative call sequence has speculative_id %i out of range" + msgstr "" + +-#: cgraph.c:3286 ++#: cgraph.c:3288 + #, gcc-internal-format, gfc-internal-format + msgid "duplicate direct call to %s in speculative call sequence with speculative_id %i" + msgstr "" + +-#: cgraph.c:3297 ++#: cgraph.c:3299 + #, gcc-internal-format + msgid "call stmt hash does not point to first direct edge of speculative call sequence" + msgstr "" + +-#: cgraph.c:3316 ++#: cgraph.c:3318 + #, gcc-internal-format, gfc-internal-format + msgid "duplicate reference %s in speculative call sequence with speculative_id %i" + msgstr "" + +-#: cgraph.c:3329 ++#: cgraph.c:3331 + #, gcc-internal-format, gfc-internal-format + msgid "missing direct call for speculation %i" + msgstr "" + +-#: cgraph.c:3334 ++#: cgraph.c:3336 + #, fuzzy, gcc-internal-format, gfc-internal-format + msgid "missing ref for speculation %i" + msgstr "аргумент для \"%s\" прапушчан" + +-#: cgraph.c:3343 ++#: cgraph.c:3345 + #, gcc-internal-format, gfc-internal-format + msgid "number of speculative targets %i mismatched with num_speculative_call_targets %i" + msgstr "" + +-#: cgraph.c:3372 ++#: cgraph.c:3374 + #, gcc-internal-format, gfc-internal-format + msgid "aux field set for edge %s->%s" + msgstr "" + +-#: cgraph.c:3379 ++#: cgraph.c:3381 + #, gcc-internal-format + msgid "cgraph count invalid" + msgstr "" + +-#: cgraph.c:3384 ++#: cgraph.c:3386 + #, gcc-internal-format + msgid "inline clone in same comdat group list" + msgstr "" + +-#: cgraph.c:3389 ++#: cgraph.c:3391 + #, gcc-internal-format + msgid "inline clone count is not compatible" + msgstr "" + +-#: cgraph.c:3396 ++#: cgraph.c:3398 + #, gcc-internal-format + msgid "tp_first_run must be non-negative" + msgstr "" + +-#: cgraph.c:3401 ++#: cgraph.c:3403 + #, fuzzy, gcc-internal-format + #| msgid "label `%s' used but not defined" + msgid "local symbols must be defined" + msgstr "адмеціна `%s' выкарыстоўвываецца, але ня вызначана" + +-#: cgraph.c:3406 ++#: cgraph.c:3408 + #, gcc-internal-format + msgid "externally visible inline clone" + msgstr "" + +-#: cgraph.c:3411 ++#: cgraph.c:3413 + #, gcc-internal-format + msgid "inline clone with address taken" + msgstr "" + +-#: cgraph.c:3416 ++#: cgraph.c:3418 + #, gcc-internal-format + msgid "inline clone is forced to output" + msgstr "" + +-#: cgraph.c:3423 ++#: cgraph.c:3425 + #, gcc-internal-format + msgid "calls_comdat_local is set outside of a comdat group" + msgstr "" + +-#: cgraph.c:3428 ++#: cgraph.c:3430 + #, gcc-internal-format + msgid "invalid calls_comdat_local flag" + msgstr "" + +-#: cgraph.c:3435 ++#: cgraph.c:3437 + #, gcc-internal-format + msgid "malloc attribute should be used for a function that returns a pointer" + msgstr "" + +-#: cgraph.c:3443 ++#: cgraph.c:3445 + #, gcc-internal-format, gfc-internal-format + msgid "aux field set for indirect edge from %s" + msgstr "" + +-#: cgraph.c:3449 cgraph.c:3509 ++#: cgraph.c:3451 cgraph.c:3511 + #, gcc-internal-format + msgid "edge count is not compatible with function count" + msgstr "" + +-#: cgraph.c:3457 ++#: cgraph.c:3459 + #, gcc-internal-format, gfc-internal-format + msgid "An indirect edge from %s is not marked as indirect or has associated indirect_info, the corresponding statement is: " + msgstr "" + +-#: cgraph.c:3465 cgraph.c:3536 ++#: cgraph.c:3467 cgraph.c:3538 + #, gcc-internal-format + msgid "edge has both call_stmt and lto_stmt_uid set" + msgstr "" + +-#: cgraph.c:3477 ++#: cgraph.c:3479 + #, gcc-internal-format, gfc-internal-format + msgid "comdat-local function called by %s outside its comdat" + msgstr "" + +-#: cgraph.c:3487 ++#: cgraph.c:3489 + #, gcc-internal-format + msgid "inlined_to pointer is wrong" + msgstr "" + +-#: cgraph.c:3492 ++#: cgraph.c:3494 + #, gcc-internal-format + msgid "multiple inline callers" + msgstr "" + +-#: cgraph.c:3499 ++#: cgraph.c:3501 + #, gcc-internal-format + msgid "inlined_to pointer set for noninline callers" + msgstr "" + +-#: cgraph.c:3526 ++#: cgraph.c:3528 + #, gcc-internal-format + msgid "caller edge count does not match BB count" + msgstr "" + +-#: cgraph.c:3557 ++#: cgraph.c:3559 + #, gcc-internal-format + msgid "indirect call count does not match BB count" + msgstr "" + +-#: cgraph.c:3574 ++#: cgraph.c:3576 + #, gcc-internal-format + msgid "reference has both stmt and lto_stmt_uid set" + msgstr "" + +-#: cgraph.c:3585 ++#: cgraph.c:3587 + #, gcc-internal-format + msgid "inlined_to pointer is set but no predecessors found" + msgstr "" + +-#: cgraph.c:3590 ++#: cgraph.c:3592 + #, gcc-internal-format + msgid "inlined_to pointer refers to itself" + msgstr "" + +-#: cgraph.c:3601 ++#: cgraph.c:3603 + #, gcc-internal-format + msgid "cgraph_node has wrong clone_of" + msgstr "" + +-#: cgraph.c:3614 ++#: cgraph.c:3616 + #, gcc-internal-format + msgid "cgraph_node has wrong clone list" + msgstr "" + +-#: cgraph.c:3620 ++#: cgraph.c:3622 + #, gcc-internal-format + msgid "cgraph_node is in clone list but it is not clone" + msgstr "" + +-#: cgraph.c:3625 ++#: cgraph.c:3627 + #, gcc-internal-format + msgid "cgraph_node has wrong prev_clone pointer" + msgstr "" + +-#: cgraph.c:3630 ++#: cgraph.c:3632 + #, gcc-internal-format + msgid "double linked list of clones corrupted" + msgstr "" + +-#: cgraph.c:3642 ++#: cgraph.c:3644 + #, gcc-internal-format + msgid "Alias has call edges" + msgstr "" + +-#: cgraph.c:3648 ++#: cgraph.c:3650 + #, gcc-internal-format + msgid "Alias has non-alias reference" + msgstr "" + +-#: cgraph.c:3653 ++#: cgraph.c:3655 + #, gcc-internal-format + msgid "Alias has more than one alias reference" + msgstr "" + +-#: cgraph.c:3660 ++#: cgraph.c:3662 + #, gcc-internal-format + msgid "Analyzed alias has no reference" + msgstr "" + +-#: cgraph.c:3669 ++#: cgraph.c:3671 + #, gcc-internal-format + msgid "No edge out of thunk node" + msgstr "" + +-#: cgraph.c:3674 ++#: cgraph.c:3676 + #, gcc-internal-format + msgid "More than one edge out of thunk node" + msgstr "" + +-#: cgraph.c:3679 ++#: cgraph.c:3681 + #, gcc-internal-format + msgid "Thunk is not supposed to have body" + msgstr "" + +-#: cgraph.c:3713 ++#: cgraph.c:3715 + #, gcc-internal-format + msgid "shared call_stmt:" + msgstr "" + +-#: cgraph.c:3721 ++#: cgraph.c:3723 + #, fuzzy, gcc-internal-format + msgid "edge points to wrong declaration:" + msgstr "\"%s\" - гэта не пачатак дэкларацыі" + +-#: cgraph.c:3730 ++#: cgraph.c:3732 + #, gcc-internal-format + msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:" + msgstr "" + +-#: cgraph.c:3740 ++#: cgraph.c:3742 + #, gcc-internal-format + msgid "missing callgraph edge for call stmt:" + msgstr "" + +-#: cgraph.c:3750 ++#: cgraph.c:3752 + #, gcc-internal-format + msgid "reference to dead statement" + msgstr "" + +-#: cgraph.c:3763 ++#: cgraph.c:3765 + #, gcc-internal-format, gfc-internal-format + msgid "edge %s->%s has no corresponding call_stmt" + msgstr "" + +-#: cgraph.c:3775 ++#: cgraph.c:3777 + #, gcc-internal-format, gfc-internal-format + msgid "an indirect edge from %s has no corresponding call_stmt" + msgstr "" + +-#: cgraph.c:3790 cgraph.c:3803 ++#: cgraph.c:3792 cgraph.c:3805 + #, gcc-internal-format + msgid "missing origin for a node in a nested list" + msgstr "" + +-#: cgraph.c:3795 ++#: cgraph.c:3797 + #, gcc-internal-format + msgid "origin points to a different parent" + msgstr "" + +-#: cgraph.c:3810 ++#: cgraph.c:3812 + #, gcc-internal-format + msgid "verify_cgraph_node failed" + msgstr "" + +-#: cgraph.c:3921 varpool.c:303 ++#: cgraph.c:3923 varpool.c:303 + #, fuzzy, gcc-internal-format, gfc-internal-format + #| msgid "argument to `-%s' is missing" + msgid "%s: section %s.%d is missing" +@@ -22169,13 +22208,13 @@ msgid "% attribute ignored because variable is initialized" + msgstr "" + + #. include_self= +-#: cgraphunit.c:1076 c/c-decl.c:11805 ++#: cgraphunit.c:1076 c/c-decl.c:11812 + #, fuzzy, gcc-internal-format + #| msgid "label `%s' used but not defined" + msgid "%q+F used but never defined" + msgstr "адмеціна `%s' выкарыстоўвываецца, але ня вызначана" + +-#: cgraphunit.c:1078 c/c-decl.c:11815 ++#: cgraphunit.c:1078 c/c-decl.c:11822 + #, gcc-internal-format + msgid "%q+F declared % but never defined" + msgstr "" +@@ -22333,7 +22372,7 @@ msgid "LTO support has not been enabled in this configuration" + msgstr "" + + #: collect2.c:1336 graph.c:55 lto-wrapper.c:1520 lto-wrapper.c:1576 +-#: toplev.c:1728 objc/objc-act.c:461 ++#: toplev.c:1733 objc/objc-act.c:461 + #, fuzzy, gcc-internal-format + #| msgid "can't open %s" + msgid "cannot open %s: %m" +@@ -22670,22 +22709,22 @@ msgstr "" + msgid "non-delegitimized UNSPEC %s (%d) found in variable location" + msgstr "" + +-#: emit-rtl.c:2930 ++#: emit-rtl.c:2885 + #, fuzzy, gcc-internal-format + msgid "invalid rtl sharing found in the insn" + msgstr "Нерэчаісны выбар %s" + +-#: emit-rtl.c:2932 ++#: emit-rtl.c:2887 + #, gcc-internal-format + msgid "shared rtx" + msgstr "" + +-#: emit-rtl.c:2934 ++#: emit-rtl.c:2889 + #, fuzzy, gcc-internal-format + msgid "internal consistency failure" + msgstr "унутраная памылка" + +-#: emit-rtl.c:4070 ++#: emit-rtl.c:4025 + #, gcc-internal-format + msgid "ICE: emit_insn used where emit_jump_insn needed:\n" + msgstr "" +@@ -22747,7 +22786,7 @@ msgstr "" + msgid "% does not match %" + msgstr "" + +-#: except.c:3517 tree.c:14717 value-prof.c:517 ++#: except.c:3517 tree.c:14728 value-prof.c:517 + #, gcc-internal-format + msgid "%qs failed" + msgstr "" +@@ -22777,12 +22816,12 @@ msgstr "" + msgid "write of %wu-bit data outside the bound of destination object, data truncated into %wu-bit" + msgstr "" + +-#: expr.c:11109 ++#: expr.c:11114 + #, gcc-internal-format + msgid "%Kcall to %qs declared with attribute error: %s" + msgstr "" + +-#: expr.c:11123 ++#: expr.c:11128 + #, gcc-internal-format + msgid "%Kcall to %qs declared with attribute warning: %s" + msgstr "" +@@ -22798,7 +22837,7 @@ msgstr "нявернае выкарыстанне \"restict\"" + msgid "the frame size of %wu bytes is larger than %wu bytes" + msgstr "памер \"%s\" больш чам %d байт" + +-#: final.c:4809 toplev.c:1552 tree-cfgcleanup.c:1499 ++#: final.c:4809 toplev.c:1557 tree-cfgcleanup.c:1499 + #, fuzzy, gcc-internal-format + msgid "could not open final insn dump file %qs: %m" + msgstr "не магу знайсці крыніцу %s\n" +@@ -22818,37 +22857,37 @@ msgstr "" + msgid "comparison is always %d due to width of bit-field" + msgstr "" + +-#: fold-const.c:5913 tree-ssa-reassoc.c:2726 tree-ssa-reassoc.c:3606 ++#: fold-const.c:5927 tree-ssa-reassoc.c:2726 tree-ssa-reassoc.c:3606 + #, gcc-internal-format + msgid "assuming signed overflow does not occur when simplifying range test" + msgstr "" + +-#: fold-const.c:6366 fold-const.c:6380 ++#: fold-const.c:6380 fold-const.c:6394 + #, gcc-internal-format, gfc-internal-format + msgid "comparison is always %d" + msgstr "" + +-#: fold-const.c:6524 ++#: fold-const.c:6538 + #, gcc-internal-format + msgid "% of unmatched not-equal tests is always 1" + msgstr "" + +-#: fold-const.c:6529 ++#: fold-const.c:6543 + #, gcc-internal-format + msgid "% of mutually exclusive equal-tests is always 0" + msgstr "" + +-#: fold-const.c:9191 ++#: fold-const.c:9205 + #, gcc-internal-format + msgid "assuming signed overflow does not occur when reducing constant in comparison" + msgstr "" + +-#: fold-const.c:9591 ++#: fold-const.c:9605 + #, gcc-internal-format + msgid "assuming signed overflow does not occur when combining constants around a comparison" + msgstr "" + +-#: fold-const.c:12891 ++#: fold-const.c:12905 + #, gcc-internal-format + msgid "fold check: original tree changed by fold" + msgstr "" +@@ -23491,13 +23530,13 @@ msgstr "" + msgid "function returns address of local variable" + msgstr "" + +-#: gimple-ssa-isolate-paths.c:412 tree.c:13082 tree.c:13119 c/c-typeck.c:2929 ++#: gimple-ssa-isolate-paths.c:412 tree.c:13084 tree.c:13121 c/c-typeck.c:2929 + #: c/c-typeck.c:3015 c/c-typeck.c:10615 c/c-typeck.c:10632 +-#: c/gimple-parser.c:2416 c/gimple-parser.c:2424 cp/call.c:7060 cp/call.c:8888 +-#: cp/constexpr.c:852 cp/constexpr.c:3337 cp/cvt.c:1069 cp/cvt.c:1107 +-#: cp/decl.c:7972 cp/decl2.c:5543 cp/decl2.c:5588 cp/pt.c:8753 +-#: cp/semantics.c:1928 cp/semantics.c:4261 cp/typeck.c:1775 cp/typeck.c:1987 +-#: cp/typeck.c:4031 cp/typeck.c:9589 ++#: c/gimple-parser.c:2416 c/gimple-parser.c:2424 cp/call.c:7063 cp/call.c:8917 ++#: cp/constexpr.c:852 cp/constexpr.c:3353 cp/cvt.c:1068 cp/cvt.c:1106 ++#: cp/decl.c:7969 cp/decl2.c:5532 cp/decl2.c:5577 cp/pt.c:8762 ++#: cp/semantics.c:1928 cp/semantics.c:4261 cp/typeck.c:1817 cp/typeck.c:2029 ++#: cp/typeck.c:4089 cp/typeck.c:9649 + #, fuzzy, gcc-internal-format + #| msgid "called from here" + msgid "declared here" +@@ -24066,10 +24105,10 @@ msgid "%G%qD offset %s is out of the bounds of object %qD with type %qT" + msgstr "" + + #: gimple-ssa-warn-restrict.c:1810 c/c-decl.c:3832 c/c-decl.c:4105 +-#: c/c-typeck.c:8743 cp/class.c:1386 cp/class.c:3162 cp/constexpr.c:956 +-#: cp/decl.c:4076 cp/decl.c:11613 cp/decl.c:12084 cp/decl.c:12093 ++#: c/c-typeck.c:8743 cp/class.c:1393 cp/class.c:3187 cp/constexpr.c:956 ++#: cp/decl.c:4078 cp/decl.c:11613 cp/decl.c:12091 cp/decl.c:12100 + #: cp/friend.c:386 cp/friend.c:396 cp/parser.c:3333 cp/parser.c:3472 +-#: cp/parser.c:3523 cp/parser.c:6542 cp/parser.c:22263 ++#: cp/parser.c:3523 cp/parser.c:6542 cp/parser.c:22279 + #, fuzzy, gcc-internal-format + msgid "%qD declared here" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" +@@ -24234,7 +24273,7 @@ msgstr "" + msgid "enclosing %" + msgstr "" + +-#: gimplify.c:7502 gimplify.c:8811 ++#: gimplify.c:7502 gimplify.c:8814 + #, gcc-internal-format + msgid "variable %qE declared in enclosing % region" + msgstr "" +@@ -24284,13 +24323,13 @@ msgstr "" + msgid "% reduction modifier on a construct with a % clause" + msgstr "" + +-#: gimplify.c:8543 gimplify.c:12389 ++#: gimplify.c:8543 gimplify.c:12337 + #, gcc-internal-format + msgid "invalid % reduction modifier on construct other than %, % or %" + msgstr "" + + #: gimplify.c:8553 gimplify.c:8559 gimplify.c:8565 gimplify.c:8571 +-#: gimplify.c:12382 ++#: gimplify.c:12330 + #, gcc-internal-format + msgid "% % clause on %qs construct" + msgstr "" +@@ -24300,147 +24339,147 @@ msgstr "" + msgid "% clause for variable other than loop iterator specified on construct combined with %" + msgstr "" + +-#: gimplify.c:8979 ++#: gimplify.c:8982 + #, gcc-internal-format + msgid "mapping field %qE of variable length structure" + msgstr "" + +-#: gimplify.c:9153 ++#: gimplify.c:9156 + #, gcc-internal-format + msgid "%qE appears more than once in map clauses" + msgstr "" + +-#: gimplify.c:9442 ++#: gimplify.c:9445 + #, gcc-internal-format + msgid "copyprivate variable %qE is not threadprivate or private in outer context" + msgstr "" + +-#: gimplify.c:9499 ++#: gimplify.c:9502 + #, gcc-internal-format + msgid "%s variable %qE is private in outer context" + msgstr "" + +-#: gimplify.c:9527 ++#: gimplify.c:9530 + #, gcc-internal-format + msgid "expected %qs % clause modifier rather than %qs" + msgstr "" + +-#: gimplify.c:9703 ++#: gimplify.c:9706 + #, gcc-internal-format + msgid "%qD specified in %qs clause but not in % % clause on the containing construct" + msgstr "" + +-#: gimplify.c:9913 ++#: gimplify.c:9916 + #, gcc-internal-format + msgid "%<_Atomic%> %qD in implicit % clause" + msgstr "" + +-#: gimplify.c:9962 ++#: gimplify.c:9965 + #, gcc-internal-format + msgid "%<_Atomic%> %qD in implicit % clause on % construct" + msgstr "" + +-#: gimplify.c:10209 ++#: gimplify.c:10212 + #, gcc-internal-format + msgid "%<_Atomic%> %qD in % clause on % construct" + msgstr "" + +-#: gimplify.c:10264 ++#: gimplify.c:10267 + #, gcc-internal-format + msgid "same variable used in % and % clauses on % construct" + msgstr "" + +-#: gimplify.c:10355 ++#: gimplify.c:10358 + #, gcc-internal-format + msgid "incompatible data clause with reduction on %qE; promoting to %" + msgstr "" + +-#: gimplify.c:10501 ++#: gimplify.c:10505 + #, gcc-internal-format + msgid "%qD specified in % % clause but not in % directive clause" + msgstr "" + +-#: gimplify.c:10520 ++#: gimplify.c:10524 + #, fuzzy, gcc-internal-format + msgid "invalid private reduction on %qE" + msgstr "Нерэчаіснае абвяшчэнне" + +-#: gimplify.c:10619 ++#: gimplify.c:10623 + #, gcc-internal-format + msgid "% % clause used together with % clause for a variable other than loop iterator" + msgstr "" + +-#: gimplify.c:10953 ++#: gimplify.c:10957 + #, gcc-internal-format + msgid "% kind in % clause on a % construct" + msgstr "" + +-#: gimplify.c:11493 gimplify.c:11752 ++#: gimplify.c:11441 gimplify.c:11700 + #, gcc-internal-format + msgid "conditional % on loop iterator %qD ignored" + msgstr "" + +-#: gimplify.c:12320 ++#: gimplify.c:12268 + #, gcc-internal-format + msgid "% clause not specified on a % construct not nested inside another OpenMP construct" + msgstr "" + +-#: gimplify.c:12344 ++#: gimplify.c:12292 + #, gcc-internal-format + msgid "% on a % construct nested inside % construct" + msgstr "" + +-#: gimplify.c:12364 ++#: gimplify.c:12312 + #, gcc-internal-format + msgid "% on a % region not strictly nested inside of a % region" + msgstr "" + +-#: gimplify.c:12416 ++#: gimplify.c:12364 + #, gcc-internal-format + msgid "% clause on a % construct refers to a variable %qD which is not the loop iterator" + msgstr "" + +-#: gimplify.c:13274 omp-low.c:3254 ++#: gimplify.c:13222 omp-low.c:3254 + #, gcc-internal-format + msgid "% construct with % clause must be closely nested inside a loop with % clause with a parameter" + msgstr "" + +-#: gimplify.c:13292 ++#: gimplify.c:13240 + #, gcc-internal-format + msgid "variable %qE is not an iteration of outermost loop %d, expected %qE" + msgstr "" + +-#: gimplify.c:13305 ++#: gimplify.c:13253 + #, gcc-internal-format + msgid "number of variables in % clause with % modifier does not match number of iteration variables" + msgstr "" + +-#: gimplify.c:13318 ++#: gimplify.c:13266 + #, gcc-internal-format + msgid "more than one % clause with % modifier on an % construct" + msgstr "" + +-#: gimplify.c:13329 ++#: gimplify.c:13277 + #, gcc-internal-format + msgid "% clause with % modifier specified together with % clauses with % modifier on the same construct" + msgstr "" + +-#: gimplify.c:14619 ++#: gimplify.c:14567 + #, gcc-internal-format + msgid "gimplification failed" + msgstr "" + +-#: gimplify.c:15170 ++#: gimplify.c:15118 + #, gcc-internal-format + msgid "%qT is promoted to %qT when passed through %<...%>" + msgstr "" + +-#: gimplify.c:15175 ++#: gimplify.c:15123 + #, gcc-internal-format + msgid "(so you should pass %qT not %qT to %)" + msgstr "" + +-#: gimplify.c:15182 ++#: gimplify.c:15130 + #, gcc-internal-format + msgid "if this code is reached, the program will abort" + msgstr "" +@@ -24517,7 +24556,7 @@ msgstr "" + msgid "token %u has %" + msgstr "" + +-#: internal-fn.c:504 ++#: internal-fn.c:506 + #, fuzzy, gcc-internal-format + msgid "invalid use of attribute %" + msgstr "нявернае выкарыстанне \"restict\"" +@@ -24789,54 +24828,54 @@ msgstr "" + msgid "the extra base is defined here" + msgstr "" + +-#: ipa-devirt.c:3852 ++#: ipa-devirt.c:3855 + #, gcc-internal-format + msgid "Declaring type %qD final would enable devirtualization of %i call" + msgid_plural "Declaring type %qD final would enable devirtualization of %i calls" + msgstr[0] "" + msgstr[1] "" + +-#: ipa-devirt.c:3861 ++#: ipa-devirt.c:3864 + #, gcc-internal-format + msgid "Declaring type %qD final would enable devirtualization of %i call executed %lli times" + msgid_plural "Declaring type %qD final would enable devirtualization of %i calls executed %lli times" + msgstr[0] "" + msgstr[1] "" + +-#: ipa-devirt.c:3891 ++#: ipa-devirt.c:3894 + #, gcc-internal-format + msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call" + msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls" + msgstr[0] "" + msgstr[1] "" + +-#: ipa-devirt.c:3899 ++#: ipa-devirt.c:3902 + #, gcc-internal-format + msgid "Declaring method %qD final would enable devirtualization of %i call" + msgid_plural "Declaring method %qD final would enable devirtualization of %i calls" + msgstr[0] "" + msgstr[1] "" + +-#: ipa-devirt.c:3907 ++#: ipa-devirt.c:3910 + #, gcc-internal-format + msgid "Declaring virtual destructor of %qD final would enable devirtualization of %i call executed %lli times" + msgid_plural "Declaring virtual destructor of %qD final would enable devirtualization of %i calls executed %lli times" + msgstr[0] "" + msgstr[1] "" + +-#: ipa-devirt.c:3918 ++#: ipa-devirt.c:3921 + #, gcc-internal-format + msgid "Declaring method %qD final would enable devirtualization of %i call executed %lli times" + msgid_plural "Declaring method %qD final would enable devirtualization of %i calls executed %lli times" + msgstr[0] "" + msgstr[1] "" + +-#: ipa-fnsummary.c:4289 ++#: ipa-fnsummary.c:4295 + #, gcc-internal-format + msgid "invalid fnsummary in LTO stream" + msgstr "" + +-#: ipa-fnsummary.c:4358 ++#: ipa-fnsummary.c:4364 + #, gcc-internal-format + msgid "ipa inline summary is missing in input file" + msgstr "" +@@ -24866,37 +24905,37 @@ msgstr "" + msgid "ipa reference summary is missing in ltrans unit" + msgstr "" + +-#: ipa-sra.c:1468 ++#: ipa-sra.c:1470 + #, gcc-internal-format + msgid "Access offset before parent offset" + msgstr "" + +-#: ipa-sra.c:1473 ++#: ipa-sra.c:1475 + #, gcc-internal-format + msgid "Access size greater or equal to its parent size" + msgstr "" + +-#: ipa-sra.c:1478 ++#: ipa-sra.c:1480 + #, gcc-internal-format + msgid "Access terminates outside of its parent" + msgstr "" + +-#: ipa-sra.c:1490 ++#: ipa-sra.c:1492 + #, gcc-internal-format + msgid "Access overlaps with its sibling" + msgstr "" + +-#: ipa-sra.c:1509 ++#: ipa-sra.c:1511 + #, gcc-internal-format + msgid "IPA-SRA access verification failed" + msgstr "" + +-#: ipa-sra.c:2470 ++#: ipa-sra.c:2472 + #, gcc-internal-format + msgid "Function %qs, parameter %u, has IPA-SRA accesses which overlap" + msgstr "" + +-#: ipa-sra.c:2473 ++#: ipa-sra.c:2475 + #, gcc-internal-format, gfc-internal-format + msgid "Function %s, parameter %u, is used but does not have any certain IPA-SRA access" + msgstr "" +@@ -24946,59 +24985,59 @@ msgstr "" + msgid "maximum number of generated reload insns per insn achieved (%d)" + msgstr "" + +-#: lto-cgraph.c:1110 ++#: lto-cgraph.c:1118 + #, gcc-internal-format + msgid "function %qs has been referenced in offloaded code but hasn%'t been marked to be included in the offloaded code" + msgstr "" + +-#: lto-cgraph.c:1115 ++#: lto-cgraph.c:1123 + #, gcc-internal-format + msgid "variable %qs has been referenced in offloaded code but hasn%'t been marked to be included in the offloaded code" + msgstr "" + +-#: lto-cgraph.c:1280 ++#: lto-cgraph.c:1288 + #, gcc-internal-format, gfc-internal-format + msgid "bytecode stream: found multiple instances of cgraph node with uid %d" + msgstr "" + +-#: lto-cgraph.c:1456 ++#: lto-cgraph.c:1464 + #, gcc-internal-format + msgid "bytecode stream: no caller found while reading edge" + msgstr "" + +-#: lto-cgraph.c:1462 ++#: lto-cgraph.c:1470 + #, gcc-internal-format + msgid "bytecode stream: no callee found while reading edge" + msgstr "" + +-#: lto-cgraph.c:1539 ++#: lto-cgraph.c:1547 + #, gcc-internal-format + msgid "bytecode stream: found empty cgraph node" + msgstr "" + +-#: lto-cgraph.c:1655 ++#: lto-cgraph.c:1663 + #, gcc-internal-format, gfc-internal-format + msgid "At most %i profile runs is supported. Perhaps corrupted profile?" + msgstr "" + +-#: lto-cgraph.c:1680 ++#: lto-cgraph.c:1688 + #, gcc-internal-format, gfc-internal-format + msgid "Profile information in %s corrupted" + msgstr "" + +-#: lto-cgraph.c:1718 ++#: lto-cgraph.c:1726 + #, fuzzy, gcc-internal-format, gfc-internal-format + #| msgid "cannot find class `%s'" + msgid "cannot find LTO cgraph in %s" + msgstr "немагчыма знайсьці кляс `%s'" + +-#: lto-cgraph.c:1728 ++#: lto-cgraph.c:1736 + #, fuzzy, gcc-internal-format, gfc-internal-format + #| msgid "cannot find source %s" + msgid "cannot find LTO section refs in %s" + msgstr "не магу знайсці крыніцу %s" + +-#: lto-cgraph.c:1805 ++#: lto-cgraph.c:1813 + #, fuzzy, gcc-internal-format, gfc-internal-format + msgid "invalid offload table in %s" + msgstr "Нерэчаісны выбар %s" +@@ -25252,52 +25291,52 @@ msgstr "" + msgid "% clause with % modifier refers to iteration never in the iteration space" + msgstr "" + +-#: omp-general.c:1751 ++#: omp-general.c:1807 + #, gcc-internal-format + msgid "%qs specifies a conflicting level of parallelism" + msgstr "" + +-#: omp-general.c:1754 ++#: omp-general.c:1810 + #, gcc-internal-format + msgid "... to the previous %qs clause here" + msgstr "" + +-#: omp-general.c:1785 ++#: omp-general.c:1841 + #, gcc-internal-format + msgid "cannot apply %<%s%> to %qD, which has also been marked with an OpenMP 'declare target' directive" + msgstr "" + +-#: omp-general.c:1827 ++#: omp-general.c:1883 + #, gcc-internal-format + msgid "incompatible %qs clause when applying %<%s%> to %qD, which has already been marked with an OpenACC 'routine' directive" + msgstr "" + +-#: omp-general.c:1834 ++#: omp-general.c:1890 + #, gcc-internal-format + msgid "missing %qs clause when applying %<%s%> to %qD, which has already been marked with an OpenACC 'routine' directive" + msgstr "" + +-#: omp-general.c:1843 ++#: omp-general.c:1899 + #, gcc-internal-format + msgid "... with %qs clause here" + msgstr "" + +-#: omp-general.c:1851 ++#: omp-general.c:1907 + #, gcc-internal-format + msgid "... without %qs clause near to here" + msgstr "" + +-#: omp-low.c:2382 omp-offload.c:1205 ++#: omp-low.c:2382 omp-offload.c:1215 + #, gcc-internal-format + msgid "% overrides other OpenACC loop specifiers" + msgstr "" + +-#: omp-low.c:2385 omp-offload.c:1206 ++#: omp-low.c:2385 omp-offload.c:1216 + #, gcc-internal-format + msgid "% conflicts with other OpenACC loop specifiers" + msgstr "" + +-#: omp-low.c:2389 omp-offload.c:1240 ++#: omp-low.c:2389 omp-offload.c:1250 + #, gcc-internal-format + msgid "inner loop uses same OpenACC parallelism as containing loop" + msgstr "" +@@ -25521,52 +25560,52 @@ msgstr "нявернае выкарыстанне \"restict\"" + msgid "invalid branch to/from %s structured block" + msgstr "" + +-#: omp-offload.c:663 ++#: omp-offload.c:673 + #, gcc-internal-format + msgid "%<-fopenacc-dim%> operand is malformed at %qs" + msgstr "" + +-#: omp-offload.c:1238 ++#: omp-offload.c:1248 + #, gcc-internal-format + msgid "routine call uses same OpenACC parallelism as containing loop" + msgstr "" + +-#: omp-offload.c:1242 omp-offload.c:1274 ++#: omp-offload.c:1252 omp-offload.c:1284 + #, gcc-internal-format + msgid "containing loop here" + msgstr "" + +-#: omp-offload.c:1247 ++#: omp-offload.c:1257 + #, gcc-internal-format + msgid "routine call uses OpenACC parallelism disallowed by containing routine" + msgstr "" + +-#: omp-offload.c:1249 ++#: omp-offload.c:1259 + #, gcc-internal-format + msgid "loop uses OpenACC parallelism disallowed by containing routine" + msgstr "" + +-#: omp-offload.c:1254 ++#: omp-offload.c:1264 + #, fuzzy, gcc-internal-format + msgid "routine %qD declared here" + msgstr "тып параметра \"%s\" не аб'яўлены" + +-#: omp-offload.c:1267 ++#: omp-offload.c:1277 + #, gcc-internal-format + msgid "incorrectly nested OpenACC loop parallelism" + msgstr "" + +-#: omp-offload.c:1408 ++#: omp-offload.c:1418 + #, gcc-internal-format + msgid "insufficient partitioning available to parallelize element loop" + msgstr "" + +-#: omp-offload.c:1416 ++#: omp-offload.c:1426 + #, gcc-internal-format + msgid "insufficient partitioning available to parallelize tile loop" + msgstr "" + +-#: omp-offload.c:1418 ++#: omp-offload.c:1428 + #, gcc-internal-format + msgid "insufficient partitioning available to parallelize loop" + msgstr "" +@@ -26920,136 +26959,136 @@ msgstr "атрыбуты секцыі не падтрымліваюцца для + msgid "%<-fabi-version=1%> is no longer supported" + msgstr "-pipe не падтрымліваецца." + +-#: toplev.c:1496 ++#: toplev.c:1501 + #, gcc-internal-format + msgid "instruction scheduling not supported on this target machine" + msgstr "" + +-#: toplev.c:1500 ++#: toplev.c:1505 + #, gcc-internal-format + msgid "this target machine does not have delayed branches" + msgstr "" + +-#: toplev.c:1514 ++#: toplev.c:1519 + #, fuzzy, gcc-internal-format + msgid "%<-f%sleading-underscore%> not supported on this target machine" + msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай" + +-#: toplev.c:1559 ++#: toplev.c:1564 + #, fuzzy, gcc-internal-format + #| msgid "can't close input file %s" + msgid "could not close zeroed insn dump file %qs: %m" + msgstr "немагчыма зачыніць уваходзячы файл %s" + +-#: toplev.c:1594 ++#: toplev.c:1599 + #, gcc-internal-format + msgid "target system does not support the %qs debug format" + msgstr "" + +-#: toplev.c:1607 ++#: toplev.c:1612 + #, gcc-internal-format + msgid "variable tracking requested, but useless unless producing debug info" + msgstr "" + +-#: toplev.c:1611 ++#: toplev.c:1616 + #, gcc-internal-format + msgid "variable tracking requested, but not supported by this debug format" + msgstr "" + +-#: toplev.c:1650 ++#: toplev.c:1655 + #, gcc-internal-format + msgid "var-tracking-assignments changes selective scheduling" + msgstr "" + +-#: toplev.c:1681 ++#: toplev.c:1686 + #, gcc-internal-format + msgid "without %<-gdwarf-5%>, %<-gvariable-location-views=incompat5%> is equivalent to %<-gvariable-location-views%>" + msgstr "" + +-#: toplev.c:1697 ++#: toplev.c:1702 + #, gcc-internal-format + msgid "%<-ginternal-reset-location-views%> is forced disabled without %<-gvariable-location-views%>" + msgstr "" + +-#: toplev.c:1707 ++#: toplev.c:1712 + #, gcc-internal-format + msgid "%<-ginline-points%> is forced disabled without %<-gstatement-frontiers%>" + msgstr "" + +-#: toplev.c:1736 ++#: toplev.c:1741 + #, fuzzy, gcc-internal-format + msgid "%<-ffunction-sections%> not supported for this target" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: toplev.c:1742 ++#: toplev.c:1747 + #, fuzzy, gcc-internal-format + msgid "%<-fdata-sections%> not supported for this target" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: toplev.c:1750 ++#: toplev.c:1755 + #, fuzzy, gcc-internal-format + msgid "%<-fprefetch-loop-arrays%> not supported for this target" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: toplev.c:1756 ++#: toplev.c:1761 + #, fuzzy, gcc-internal-format + msgid "%<-fprefetch-loop-arrays%> not supported for this target (try %<-march%> switches)" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: toplev.c:1766 ++#: toplev.c:1771 + #, fuzzy, gcc-internal-format + msgid "%<-fprefetch-loop-arrays%> is not supported with %<-Os%>" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: toplev.c:1778 ++#: toplev.c:1783 + #, gcc-internal-format + msgid "%<-fassociative-math%> disabled; other options take precedence" + msgstr "" + +-#: toplev.c:1788 ++#: toplev.c:1793 + #, gcc-internal-format + msgid "%<-fstack-clash-protection%> is not supported on targets where the stack grows from lower to higher addresses" + msgstr "" + +-#: toplev.c:1798 ++#: toplev.c:1803 + #, gcc-internal-format + msgid "%<-fstack-check=%> and %<-fstack-clash_protection%> are mutually exclusive; disabling %<-fstack-check=%>" + msgstr "" + +-#: toplev.c:1816 ++#: toplev.c:1821 + #, fuzzy, gcc-internal-format + msgid "%<-fstack-protector%> not supported for this target" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: toplev.c:1828 ++#: toplev.c:1833 + #, fuzzy, gcc-internal-format + #| msgid "section attributes are not supported for this target" + msgid "%<-fsanitize=address%> and %<-fsanitize=kernel-address%> are not supported for this target" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: toplev.c:2132 ++#: toplev.c:2137 + #, fuzzy, gcc-internal-format + #| msgid "error writing to %s" + msgid "error writing to %s: %m" + msgstr "памылка запісу ў %s" + +-#: toplev.c:2134 ++#: toplev.c:2139 + #, fuzzy, gcc-internal-format + #| msgid "error writing to %s" + msgid "error closing %s: %m" + msgstr "памылка запісу ў %s" + +-#: toplev.c:2251 ++#: toplev.c:2256 + #, gcc-internal-format + msgid "mpfr not configured to handle all floating modes" + msgstr "" + +-#: toplev.c:2327 ++#: toplev.c:2332 + #, gcc-internal-format + msgid "self-tests incompatible with %<-E%>" + msgstr "" + +-#: toplev.c:2342 ++#: toplev.c:2347 + #, gcc-internal-format + msgid "self-tests are not enabled in this build" + msgstr "" +@@ -27144,176 +27183,176 @@ msgstr "" + msgid "ignoring loop annotation" + msgstr "Нераспазнаны выбар \"%s\"" + +-#: tree-cfg.c:2968 ++#: tree-cfg.c:2998 + #, gcc-internal-format + msgid "constant not recomputed when % changed" + msgstr "" + +-#: tree-cfg.c:2973 ++#: tree-cfg.c:3003 + #, gcc-internal-format + msgid "side effects not recomputed when % changed" + msgstr "" + +-#: tree-cfg.c:2988 ++#: tree-cfg.c:3018 + #, gcc-internal-format + msgid "% set on a variable with address taken" + msgstr "" + +-#: tree-cfg.c:2994 ++#: tree-cfg.c:3024 + #, gcc-internal-format + msgid "address taken but % bit not set" + msgstr "" + +-#: tree-cfg.c:3016 ++#: tree-cfg.c:3046 + #, fuzzy, gcc-internal-format + #| msgid "invalid %%m value" + msgid "invalid expression for min lvalue" + msgstr "нерэчаіснае значэньне %%m" + +-#: tree-cfg.c:3027 ++#: tree-cfg.c:3057 + #, fuzzy, gcc-internal-format + msgid "invalid operand in indirect reference" + msgstr "Нерэчаісны выбар \"%s\"" + +-#: tree-cfg.c:3052 ++#: tree-cfg.c:3082 + #, gcc-internal-format + msgid "non-scalar %qs" + msgstr "" + +-#: tree-cfg.c:3066 ++#: tree-cfg.c:3096 + #, fuzzy, gcc-internal-format + msgid "invalid position or size operand to %qs" + msgstr "нерэчаісны %%-код" + +-#: tree-cfg.c:3072 ++#: tree-cfg.c:3102 + #, gcc-internal-format + msgid "integral result type precision does not match field size of %qs" + msgstr "" + +-#: tree-cfg.c:3081 ++#: tree-cfg.c:3111 + #, gcc-internal-format + msgid "mode size of non-integral result does not match field size of %qs" + msgstr "" + +-#: tree-cfg.c:3089 ++#: tree-cfg.c:3119 + #, gcc-internal-format + msgid "%qs of non-mode-precision operand" + msgstr "" + +-#: tree-cfg.c:3096 ++#: tree-cfg.c:3126 + #, gcc-internal-format + msgid "position plus size exceeds size of referenced object in %qs" + msgstr "" + +-#: tree-cfg.c:3107 ++#: tree-cfg.c:3137 + #, gcc-internal-format + msgid "type mismatch in %qs reference" + msgstr "" + +-#: tree-cfg.c:3123 ++#: tree-cfg.c:3153 + #, gcc-internal-format + msgid "non-top-level %qs" + msgstr "" + +-#: tree-cfg.c:3138 ++#: tree-cfg.c:3168 + #, fuzzy, gcc-internal-format + msgid "invalid operands to %qs" + msgstr "нерэчаісны %%-код" + +-#: tree-cfg.c:3149 tree-cfg.c:3158 tree-cfg.c:3175 tree-cfg.c:3809 +-#: tree-cfg.c:3838 tree-cfg.c:3855 tree-cfg.c:3876 tree-cfg.c:3922 +-#: tree-cfg.c:3943 tree-cfg.c:3997 tree-cfg.c:4017 tree-cfg.c:4053 +-#: tree-cfg.c:4074 tree-cfg.c:4106 tree-cfg.c:4182 tree-cfg.c:4214 +-#: tree-cfg.c:4226 tree-cfg.c:4285 tree-cfg.c:4310 tree-cfg.c:4383 +-#: tree-cfg.c:4461 ++#: tree-cfg.c:3179 tree-cfg.c:3188 tree-cfg.c:3205 tree-cfg.c:3839 ++#: tree-cfg.c:3868 tree-cfg.c:3885 tree-cfg.c:3906 tree-cfg.c:3952 ++#: tree-cfg.c:3973 tree-cfg.c:4027 tree-cfg.c:4047 tree-cfg.c:4083 ++#: tree-cfg.c:4104 tree-cfg.c:4136 tree-cfg.c:4212 tree-cfg.c:4244 ++#: tree-cfg.c:4256 tree-cfg.c:4315 tree-cfg.c:4340 tree-cfg.c:4413 ++#: tree-cfg.c:4491 + #, gcc-internal-format + msgid "type mismatch in %qs" + msgstr "" + +-#: tree-cfg.c:3169 ++#: tree-cfg.c:3199 + #, fuzzy, gcc-internal-format + #| msgid "invalid %%f operand" + msgid "invalid %qs offset operator" + msgstr "нерэчаісны %%f аперанд" + +-#: tree-cfg.c:3193 ++#: tree-cfg.c:3223 + #, gcc-internal-format + msgid "conversion of %qs on the left hand side of %qs" + msgstr "" + +-#: tree-cfg.c:3201 ++#: tree-cfg.c:3231 + #, gcc-internal-format + msgid "conversion of register to a different size in %qs" + msgstr "" + +-#: tree-cfg.c:3221 tree-cfg.c:3247 ++#: tree-cfg.c:3251 tree-cfg.c:3277 + #, fuzzy, gcc-internal-format + #| msgid "invalid %%d operand" + msgid "invalid address operand in %qs" + msgstr "нерэчаісны %%d аперанд" + +-#: tree-cfg.c:3228 tree-cfg.c:3254 ++#: tree-cfg.c:3258 tree-cfg.c:3284 + #, fuzzy, gcc-internal-format + #| msgid "invalid %%f operand" + msgid "invalid offset operand in %qs" + msgstr "нерэчаісны %%f аперанд" + +-#: tree-cfg.c:3235 tree-cfg.c:3261 ++#: tree-cfg.c:3265 tree-cfg.c:3291 + #, fuzzy, gcc-internal-format + msgid "invalid clique in %qs" + msgstr "Нерэчаісны выбар %s" + +-#: tree-cfg.c:3268 tree-cfg.c:4473 ++#: tree-cfg.c:3298 tree-cfg.c:4503 + #, gcc-internal-format + msgid "%qs in gimple IL" + msgstr "" + +-#: tree-cfg.c:3321 ++#: tree-cfg.c:3351 + #, gcc-internal-format + msgid "gimple call has two targets" + msgstr "" + +-#: tree-cfg.c:3330 ++#: tree-cfg.c:3360 + #, gcc-internal-format + msgid "gimple call has no target" + msgstr "" + +-#: tree-cfg.c:3337 ++#: tree-cfg.c:3367 + #, fuzzy, gcc-internal-format + msgid "invalid function in gimple call" + msgstr "Нерэчаісная спецыфікацыя! Памылка ў cc." + +-#: tree-cfg.c:3347 ++#: tree-cfg.c:3377 + #, gcc-internal-format + msgid "non-function in gimple call" + msgstr "" + +-#: tree-cfg.c:3358 ++#: tree-cfg.c:3388 + #, fuzzy, gcc-internal-format + msgid "invalid pure const state for function" + msgstr "Нерэчаісны выбар \"%s\"" + +-#: tree-cfg.c:3367 ++#: tree-cfg.c:3397 + #, gcc-internal-format + msgid "invalid LHS in gimple call" + msgstr "" + +-#: tree-cfg.c:3375 ++#: tree-cfg.c:3405 + #, gcc-internal-format + msgid "LHS in % call" + msgstr "" + +-#: tree-cfg.c:3389 ++#: tree-cfg.c:3419 + #, gcc-internal-format + msgid "invalid conversion in gimple call" + msgstr "" + +-#: tree-cfg.c:3398 ++#: tree-cfg.c:3428 + #, gcc-internal-format + msgid "invalid static chain in gimple call" + msgstr "" + +-#: tree-cfg.c:3409 ++#: tree-cfg.c:3439 + #, gcc-internal-format + msgid "static chain with function that doesn%'t use one" + msgstr "" +@@ -27324,512 +27363,512 @@ msgstr "" + #. __builtin_unreachable internally, for example when IPA figures + #. out a call cannot happen in a legal program. In such cases, + #. we must make sure arguments are stripped off. +-#: tree-cfg.c:3427 ++#: tree-cfg.c:3457 + #, gcc-internal-format + msgid "%<__builtin_unreachable%> or %<__builtin_trap%> call with arguments" + msgstr "" + +-#: tree-cfg.c:3450 ++#: tree-cfg.c:3480 + #, fuzzy, gcc-internal-format + msgid "invalid argument to gimple call" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: tree-cfg.c:3470 ++#: tree-cfg.c:3500 + #, fuzzy, gcc-internal-format + msgid "invalid operands in gimple comparison" + msgstr "нерэчаісны %%-код" + +-#: tree-cfg.c:3486 ++#: tree-cfg.c:3516 + #, gcc-internal-format + msgid "mismatching comparison operand types" + msgstr "" + +-#: tree-cfg.c:3503 ++#: tree-cfg.c:3533 + #, gcc-internal-format + msgid "unsupported operation or type for vector comparison returning a boolean" + msgstr "" + +-#: tree-cfg.c:3518 ++#: tree-cfg.c:3548 + #, gcc-internal-format + msgid "non-vector operands in vector comparison" + msgstr "" + +-#: tree-cfg.c:3527 ++#: tree-cfg.c:3557 + #, gcc-internal-format + msgid "invalid vector comparison resulting type" + msgstr "" + +-#: tree-cfg.c:3534 ++#: tree-cfg.c:3564 + #, gcc-internal-format + msgid "bogus comparison result type" + msgstr "" + +-#: tree-cfg.c:3556 ++#: tree-cfg.c:3586 + #, gcc-internal-format + msgid "non-register as LHS of unary operation" + msgstr "" + +-#: tree-cfg.c:3562 ++#: tree-cfg.c:3592 + #, fuzzy, gcc-internal-format + msgid "invalid operand in unary operation" + msgstr "нерэчаісны %%-код" + +-#: tree-cfg.c:3585 ++#: tree-cfg.c:3615 + #, gcc-internal-format + msgid "invalid vector types in nop conversion" + msgstr "" + +-#: tree-cfg.c:3614 ++#: tree-cfg.c:3644 + #, fuzzy, gcc-internal-format + msgid "invalid types in nop conversion" + msgstr "нерэчаісны %%-код" + +-#: tree-cfg.c:3629 ++#: tree-cfg.c:3659 + #, gcc-internal-format + msgid "invalid types in address space conversion" + msgstr "" + +-#: tree-cfg.c:3643 ++#: tree-cfg.c:3673 + #, gcc-internal-format + msgid "invalid types in fixed-point conversion" + msgstr "" + +-#: tree-cfg.c:3658 ++#: tree-cfg.c:3688 + #, gcc-internal-format + msgid "invalid types in conversion to floating-point" + msgstr "" + +-#: tree-cfg.c:3673 ++#: tree-cfg.c:3703 + #, gcc-internal-format + msgid "invalid types in conversion to integer" + msgstr "" + +-#: tree-cfg.c:3713 ++#: tree-cfg.c:3743 + #, gcc-internal-format + msgid "type mismatch in %qs expression" + msgstr "" + +-#: tree-cfg.c:3735 ++#: tree-cfg.c:3765 + #, fuzzy, gcc-internal-format + msgid "invalid types for %qs" + msgstr "Нерэчаісны выбар %s" + +-#: tree-cfg.c:3746 ++#: tree-cfg.c:3776 + #, gcc-internal-format + msgid "%qs should be from a scalar to a like vector" + msgstr "" + +-#: tree-cfg.c:3760 ++#: tree-cfg.c:3790 + #, gcc-internal-format + msgid "non-trivial conversion in unary operation" + msgstr "" + +-#: tree-cfg.c:3785 ++#: tree-cfg.c:3815 + #, gcc-internal-format + msgid "non-register as LHS of binary operation" + msgstr "" + +-#: tree-cfg.c:3792 ++#: tree-cfg.c:3822 + #, fuzzy, gcc-internal-format + msgid "invalid operands in binary operation" + msgstr "прапушчан ініцыялізатар" + +-#: tree-cfg.c:3897 ++#: tree-cfg.c:3927 + #, fuzzy, gcc-internal-format + msgid "invalid non-vector operands to %qs" + msgstr "нерэчаісны %%-код" + +-#: tree-cfg.c:3908 ++#: tree-cfg.c:3938 + #, fuzzy, gcc-internal-format + msgid "invalid (pointer) operands %qs" + msgstr "нерэчаісны %%-код" + +-#: tree-cfg.c:4114 ++#: tree-cfg.c:4144 + #, gcc-internal-format + msgid "vector type expected in %qs" + msgstr "" + +-#: tree-cfg.c:4127 ++#: tree-cfg.c:4157 + #, gcc-internal-format + msgid "type mismatch in binary expression" + msgstr "" + +-#: tree-cfg.c:4155 ++#: tree-cfg.c:4185 + #, gcc-internal-format + msgid "non-register as LHS of ternary operation" + msgstr "" + +-#: tree-cfg.c:4164 ++#: tree-cfg.c:4194 + #, fuzzy, gcc-internal-format + msgid "invalid operands in ternary operation" + msgstr "нерэчаісны %%-код" + +-#: tree-cfg.c:4196 ++#: tree-cfg.c:4226 + #, gcc-internal-format + msgid "the first argument of a %qs must be of a boolean vector type of the same number of elements as the result" + msgstr "" + +-#: tree-cfg.c:4238 tree-cfg.c:4297 ++#: tree-cfg.c:4268 tree-cfg.c:4327 + #, gcc-internal-format + msgid "vector types expected in %qs" + msgstr "" + +-#: tree-cfg.c:4253 ++#: tree-cfg.c:4283 + #, gcc-internal-format + msgid "vectors with different element number found in %qs" + msgstr "" + +-#: tree-cfg.c:4269 ++#: tree-cfg.c:4299 + #, fuzzy, gcc-internal-format + msgid "invalid mask type in %qs" + msgstr "Нерэчаісны выбар %s" + +-#: tree-cfg.c:4329 ++#: tree-cfg.c:4359 + #, gcc-internal-format + msgid "not allowed type combination in %qs" + msgstr "" + +-#: tree-cfg.c:4338 ++#: tree-cfg.c:4368 + #, fuzzy, gcc-internal-format + msgid "invalid position or size in %qs" + msgstr "Нерэчаісны выбар %s" + +-#: tree-cfg.c:4344 ++#: tree-cfg.c:4374 + #, gcc-internal-format + msgid "%qs into non-mode-precision operand" + msgstr "" + +-#: tree-cfg.c:4354 ++#: tree-cfg.c:4384 + #, gcc-internal-format + msgid "insertion out of range in %qs" + msgstr "" + +-#: tree-cfg.c:4364 ++#: tree-cfg.c:4394 + #, gcc-internal-format + msgid "%qs not at element boundary" + msgstr "" + +-#: tree-cfg.c:4419 ++#: tree-cfg.c:4449 + #, gcc-internal-format + msgid "non-trivial conversion in %qs" + msgstr "" + +-#: tree-cfg.c:4428 ++#: tree-cfg.c:4458 + #, gcc-internal-format + msgid "%qs LHS in clobber statement" + msgstr "" + +-#: tree-cfg.c:4447 ++#: tree-cfg.c:4477 + #, fuzzy, gcc-internal-format + msgid "invalid operand in %qs" + msgstr "нерэчаісны %%-код" + +-#: tree-cfg.c:4488 tree-cfg.c:4514 ++#: tree-cfg.c:4518 tree-cfg.c:4544 + #, fuzzy, gcc-internal-format + #| msgid "invalid register name for `%s'" + msgid "invalid RHS for gimple memory store: %qs" + msgstr "нерэчаісная назва рэгістра `%s'" + +-#: tree-cfg.c:4548 tree-cfg.c:4566 ++#: tree-cfg.c:4578 tree-cfg.c:4596 + #, gcc-internal-format + msgid "incorrect type of vector %qs elements" + msgstr "" + +-#: tree-cfg.c:4557 tree-cfg.c:4574 ++#: tree-cfg.c:4587 tree-cfg.c:4604 + #, gcc-internal-format + msgid "incorrect number of vector %qs elements" + msgstr "" + +-#: tree-cfg.c:4582 ++#: tree-cfg.c:4612 + #, gcc-internal-format + msgid "incorrect type of vector CONSTRUCTOR elements" + msgstr "" + +-#: tree-cfg.c:4591 ++#: tree-cfg.c:4621 + #, gcc-internal-format + msgid "vector %qs with non-NULL element index" + msgstr "" + +-#: tree-cfg.c:4598 ++#: tree-cfg.c:4628 + #, gcc-internal-format + msgid "vector %qs element is not a GIMPLE value" + msgstr "" + +-#: tree-cfg.c:4607 ++#: tree-cfg.c:4637 + #, gcc-internal-format + msgid "non-vector %qs with elements" + msgstr "" + +-#: tree-cfg.c:4618 ++#: tree-cfg.c:4648 + #, gcc-internal-format + msgid "%qs with an always-false condition" + msgstr "" + +-#: tree-cfg.c:4677 ++#: tree-cfg.c:4707 + #, fuzzy, gcc-internal-format + msgid "invalid operand in return statement" + msgstr "нерэчаісны %%-код" + +-#: tree-cfg.c:4692 c/gimple-parser.c:2422 ++#: tree-cfg.c:4722 c/gimple-parser.c:2422 + #, gcc-internal-format + msgid "invalid conversion in return statement" + msgstr "" + +-#: tree-cfg.c:4716 ++#: tree-cfg.c:4746 + #, gcc-internal-format + msgid "goto destination is neither a label nor a pointer" + msgstr "" + +-#: tree-cfg.c:4735 ++#: tree-cfg.c:4765 + #, fuzzy, gcc-internal-format + msgid "invalid operand to switch statement" + msgstr "нерэчаісны %%-код" + +-#: tree-cfg.c:4743 ++#: tree-cfg.c:4773 + #, gcc-internal-format + msgid "non-integral type switch statement" + msgstr "" + +-#: tree-cfg.c:4753 ++#: tree-cfg.c:4783 + #, gcc-internal-format + msgid "invalid default case label in switch statement" + msgstr "" + +-#: tree-cfg.c:4765 ++#: tree-cfg.c:4795 + #, gcc-internal-format + msgid "invalid %" + msgstr "" + +-#: tree-cfg.c:4771 ++#: tree-cfg.c:4801 + #, gcc-internal-format + msgid "invalid case label in switch statement" + msgstr "" + +-#: tree-cfg.c:4778 ++#: tree-cfg.c:4808 + #, fuzzy, gcc-internal-format + msgid "invalid case range in switch statement" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: tree-cfg.c:4788 ++#: tree-cfg.c:4818 + #, gcc-internal-format + msgid "type mismatch for case label in switch statement" + msgstr "" + +-#: tree-cfg.c:4798 ++#: tree-cfg.c:4828 + #, gcc-internal-format + msgid "type precision mismatch in switch statement" + msgstr "" + +-#: tree-cfg.c:4807 ++#: tree-cfg.c:4837 + #, gcc-internal-format + msgid "case labels not sorted in switch statement" + msgstr "" + +-#: tree-cfg.c:4850 ++#: tree-cfg.c:4880 + #, fuzzy, gcc-internal-format + msgid "label context is not the current function declaration" + msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй" + +-#: tree-cfg.c:4859 ++#: tree-cfg.c:4889 + #, gcc-internal-format + msgid "incorrect entry in %" + msgstr "" + +-#: tree-cfg.c:4869 ++#: tree-cfg.c:4899 + #, gcc-internal-format + msgid "incorrect setting of landing pad number" + msgstr "" + +-#: tree-cfg.c:4885 ++#: tree-cfg.c:4915 + #, fuzzy, gcc-internal-format + msgid "invalid comparison code in gimple cond" + msgstr "нерэчаісны %%-код" + +-#: tree-cfg.c:4893 ++#: tree-cfg.c:4923 + #, gcc-internal-format + msgid "invalid labels in gimple cond" + msgstr "" + +-#: tree-cfg.c:4976 tree-cfg.c:4985 ++#: tree-cfg.c:5006 tree-cfg.c:5015 + #, fuzzy, gcc-internal-format + #| msgid "invalid %%Q value" + msgid "invalid % result" + msgstr "дрэннае %%Q значэнне" + +-#: tree-cfg.c:4995 ++#: tree-cfg.c:5025 + #, gcc-internal-format + msgid "missing % def" + msgstr "" + +-#: tree-cfg.c:5009 ++#: tree-cfg.c:5039 + #, fuzzy, gcc-internal-format + #| msgid "invalid %%Q value" + msgid "invalid % argument" + msgstr "дрэннае %%Q значэнне" + +-#: tree-cfg.c:5016 ++#: tree-cfg.c:5046 + #, gcc-internal-format + msgid "incompatible types in % argument %u" + msgstr "" + +-#: tree-cfg.c:5114 ++#: tree-cfg.c:5144 + #, gcc-internal-format + msgid "% failed" + msgstr "" + +-#: tree-cfg.c:5171 ++#: tree-cfg.c:5201 + #, gcc-internal-format + msgid "dead statement in EH table" + msgstr "" + +-#: tree-cfg.c:5187 ++#: tree-cfg.c:5217 + #, gcc-internal-format + msgid "location references block not in block tree" + msgstr "" + +-#: tree-cfg.c:5236 ++#: tree-cfg.c:5266 + #, fuzzy, gcc-internal-format + msgid "local declaration from a different function" + msgstr "няма папярэдняга аб'яўлення для \"%s\"" + +-#: tree-cfg.c:5339 ++#: tree-cfg.c:5369 + #, gcc-internal-format + msgid "gimple_bb (phi) is set to a wrong basic block" + msgstr "" + +-#: tree-cfg.c:5348 ++#: tree-cfg.c:5378 + #, gcc-internal-format + msgid "PHI node with location" + msgstr "" + +-#: tree-cfg.c:5359 tree-cfg.c:5406 ++#: tree-cfg.c:5389 tree-cfg.c:5436 + #, gcc-internal-format + msgid "incorrect sharing of tree nodes" + msgstr "" + +-#: tree-cfg.c:5367 ++#: tree-cfg.c:5397 + #, gcc-internal-format + msgid "virtual PHI with argument locations" + msgstr "" + +-#: tree-cfg.c:5394 ++#: tree-cfg.c:5424 + #, gcc-internal-format + msgid "gimple_bb (stmt) is set to a wrong basic block" + msgstr "" + +-#: tree-cfg.c:5434 ++#: tree-cfg.c:5464 + #, gcc-internal-format + msgid "statement marked for throw, but doesn%'t" + msgstr "" + +-#: tree-cfg.c:5440 ++#: tree-cfg.c:5470 + #, gcc-internal-format + msgid "statement marked for throw in middle of block" + msgstr "" + +-#: tree-cfg.c:5462 ++#: tree-cfg.c:5492 + #, gcc-internal-format + msgid "verify_gimple failed" + msgstr "" + +-#: tree-cfg.c:5484 ++#: tree-cfg.c:5514 + #, gcc-internal-format + msgid "ENTRY_BLOCK has IL associated with it" + msgstr "" + +-#: tree-cfg.c:5491 ++#: tree-cfg.c:5521 + #, gcc-internal-format + msgid "EXIT_BLOCK has IL associated with it" + msgstr "" + +-#: tree-cfg.c:5498 ++#: tree-cfg.c:5528 + #, gcc-internal-format, gfc-internal-format + msgid "fallthru to exit from bb %d" + msgstr "" + +-#: tree-cfg.c:5522 ++#: tree-cfg.c:5552 + #, gcc-internal-format + msgid "nonlocal label " + msgstr "" + +-#: tree-cfg.c:5531 ++#: tree-cfg.c:5561 + #, gcc-internal-format + msgid "EH landing pad label " + msgstr "" + +-#: tree-cfg.c:5540 tree-cfg.c:5549 tree-cfg.c:5574 ++#: tree-cfg.c:5570 tree-cfg.c:5579 tree-cfg.c:5604 + #, gcc-internal-format + msgid "label " + msgstr "" + +-#: tree-cfg.c:5564 ++#: tree-cfg.c:5594 + #, gcc-internal-format, gfc-internal-format + msgid "control flow in the middle of basic block %d" + msgstr "" + +-#: tree-cfg.c:5597 ++#: tree-cfg.c:5627 + #, gcc-internal-format, gfc-internal-format + msgid "fallthru edge after a control statement in bb %d" + msgstr "" + +-#: tree-cfg.c:5610 ++#: tree-cfg.c:5640 + #, gcc-internal-format, gfc-internal-format + msgid "true/false edge after a non-GIMPLE_COND in bb %d" + msgstr "" + +-#: tree-cfg.c:5633 tree-cfg.c:5655 tree-cfg.c:5672 tree-cfg.c:5741 ++#: tree-cfg.c:5663 tree-cfg.c:5685 tree-cfg.c:5702 tree-cfg.c:5771 + #, gcc-internal-format, gfc-internal-format + msgid "wrong outgoing edge flags at end of bb %d" + msgstr "" + +-#: tree-cfg.c:5643 ++#: tree-cfg.c:5673 + #, gcc-internal-format, gfc-internal-format + msgid "explicit goto at end of bb %d" + msgstr "" + +-#: tree-cfg.c:5677 ++#: tree-cfg.c:5707 + #, gcc-internal-format, gfc-internal-format + msgid "return edge does not point to exit in bb %d" + msgstr "" + +-#: tree-cfg.c:5707 ++#: tree-cfg.c:5737 + #, gcc-internal-format + msgid "found default case not at the start of case vector" + msgstr "" + +-#: tree-cfg.c:5715 ++#: tree-cfg.c:5745 + #, fuzzy, gcc-internal-format + #| msgid "-pipe is not supported" + msgid "case labels not sorted: " + msgstr "-pipe не падтрымліваецца" + +-#: tree-cfg.c:5732 ++#: tree-cfg.c:5762 + #, gcc-internal-format, gfc-internal-format + msgid "extra outgoing edge %d->%d" + msgstr "" + +-#: tree-cfg.c:5755 ++#: tree-cfg.c:5785 + #, fuzzy, gcc-internal-format, gfc-internal-format + #| msgid "missing field '%s' in '%s'" + msgid "missing edge %i->%i" + msgstr "прапушчана поле '%s' у '%s'" + +-#: tree-cfg.c:9383 ++#: tree-cfg.c:9413 + #, gcc-internal-format + msgid "% function does return" + msgstr "" + +-#: tree-cfg.c:9404 tree-cfg.c:9436 ++#: tree-cfg.c:9434 tree-cfg.c:9466 + #, gcc-internal-format + msgid "control reaches end of non-void function" + msgstr "" + +-#: tree-cfg.c:9502 ++#: tree-cfg.c:9532 + #, gcc-internal-format + msgid "ignoring return value of %qD declared with attribute %" + msgstr "" + +-#: tree-cfg.c:9507 cp/cvt.c:1111 ++#: tree-cfg.c:9537 cp/cvt.c:1110 + #, gcc-internal-format + msgid "ignoring return value of function declared with attribute %" + msgstr "" +@@ -27844,47 +27883,47 @@ msgstr "перанакіраванне stdout: %s" + msgid "in expansion of macro %qs" + msgstr "" + +-#: tree-eh.c:4894 ++#: tree-eh.c:4904 + #, gcc-internal-format, gfc-internal-format + msgid "BB %i has multiple EH edges" + msgstr "" + +-#: tree-eh.c:4906 ++#: tree-eh.c:4916 + #, gcc-internal-format, gfc-internal-format + msgid "BB %i cannot throw but has an EH edge" + msgstr "" + +-#: tree-eh.c:4914 ++#: tree-eh.c:4924 + #, gcc-internal-format, gfc-internal-format + msgid "BB %i last statement has incorrectly set lp" + msgstr "" + +-#: tree-eh.c:4920 ++#: tree-eh.c:4930 + #, gcc-internal-format, gfc-internal-format + msgid "BB %i is missing an EH edge" + msgstr "" + +-#: tree-eh.c:4926 ++#: tree-eh.c:4936 + #, gcc-internal-format, gfc-internal-format + msgid "Incorrect EH edge %i->%i" + msgstr "" + +-#: tree-eh.c:4960 tree-eh.c:4979 ++#: tree-eh.c:4970 tree-eh.c:4989 + #, gcc-internal-format, gfc-internal-format + msgid "BB %i is missing an edge" + msgstr "" + +-#: tree-eh.c:4996 ++#: tree-eh.c:5006 + #, gcc-internal-format, gfc-internal-format + msgid "BB %i too many fallthru edges" + msgstr "" + +-#: tree-eh.c:5005 ++#: tree-eh.c:5015 + #, gcc-internal-format, gfc-internal-format + msgid "BB %i has incorrect edge" + msgstr "" + +-#: tree-eh.c:5011 ++#: tree-eh.c:5021 + #, gcc-internal-format, gfc-internal-format + msgid "BB %i has incorrect fallthru edge" + msgstr "" +@@ -28395,12 +28434,12 @@ msgstr "" + msgid "verify_ssa failed" + msgstr "" + +-#: tree-streamer-in.c:353 ++#: tree-streamer-in.c:354 + #, gcc-internal-format + msgid "machine independent builtin code out of range" + msgstr "" + +-#: tree-streamer-in.c:359 ++#: tree-streamer-in.c:360 + #, gcc-internal-format + msgid "target specific builtin not available" + msgstr "" +@@ -28465,7 +28504,7 @@ msgstr "" + msgid "array subscript %qE is outside the bounds of an interior zero-length array %qT" + msgstr "" + +-#: tree-vrp.c:3656 tree-vrp.c:3923 tree-vrp.c:4033 ++#: tree-vrp.c:3656 tree-vrp.c:3909 tree-vrp.c:4019 + #, gcc-internal-format + msgid "while referencing %qD" + msgstr "" +@@ -28475,27 +28514,27 @@ msgstr "" + msgid "defined here %qD" + msgstr "" + +-#: tree-vrp.c:3913 ++#: tree-vrp.c:3899 + #, gcc-internal-format + msgid "array subscript %wi is outside array bounds of %qT" + msgstr "" + +-#: tree-vrp.c:3918 ++#: tree-vrp.c:3904 + #, gcc-internal-format + msgid "array subscript [%wi, %wi] is outside array bounds of %qT" + msgstr "" + +-#: tree-vrp.c:3940 ++#: tree-vrp.c:3926 + #, gcc-internal-format + msgid "intermediate array offset %wi is outside array bounds of %qT" + msgstr "" + +-#: tree-vrp.c:4011 ++#: tree-vrp.c:3997 + #, gcc-internal-format + msgid "array subscript %wi is below array bounds of %qT" + msgstr "" + +-#: tree-vrp.c:4025 ++#: tree-vrp.c:4011 + #, gcc-internal-format + msgid "array subscript %wu is above array bounds of %qT" + msgstr "" +@@ -28570,32 +28609,32 @@ msgstr "" + msgid "tree check: accessed operand %d of % with %d operands in %s, at %s:%d" + msgstr "" + +-#: tree.c:13077 ++#: tree.c:13079 + #, gcc-internal-format + msgid "%qD is deprecated: %s" + msgstr "" + +-#: tree.c:13080 ++#: tree.c:13082 + #, gcc-internal-format + msgid "%qD is deprecated" + msgstr "" + +-#: tree.c:13103 ++#: tree.c:13105 + #, gcc-internal-format + msgid "%qE is deprecated: %s" + msgstr "" + +-#: tree.c:13106 ++#: tree.c:13108 + #, gcc-internal-format + msgid "%qE is deprecated" + msgstr "" + +-#: tree.c:13112 ++#: tree.c:13114 + #, gcc-internal-format, gfc-internal-format + msgid "type is deprecated: %s" + msgstr "" + +-#: tree.c:13115 ++#: tree.c:13117 + #, gcc-internal-format + msgid "type is deprecated" + msgstr "" +@@ -28620,233 +28659,233 @@ msgstr "" + #. - vector types may differ by TYPE_VECTOR_OPAQUE + #. + #. Convenience macro for matching individual fields. +-#: tree.c:13883 ++#: tree.c:13894 + #, gcc-internal-format, gfc-internal-format + msgid "type variant differs by %s" + msgstr "" + +-#: tree.c:13924 ++#: tree.c:13935 + #, gcc-internal-format + msgid "type variant has different %" + msgstr "" + +-#: tree.c:13926 ++#: tree.c:13937 + #, gcc-internal-format + msgid "type variant%'s %" + msgstr "" + +-#: tree.c:13928 ++#: tree.c:13939 + #, gcc-internal-format + msgid "type%'s %" + msgstr "" + +-#: tree.c:13951 ++#: tree.c:13962 + #, gcc-internal-format + msgid "type variant with %" + msgstr "" + +-#: tree.c:13964 ++#: tree.c:13975 + #, gcc-internal-format + msgid "type variant has different %" + msgstr "" + +-#: tree.c:14000 ++#: tree.c:14011 + #, gcc-internal-format + msgid "type variant has different %" + msgstr "" + +-#: tree.c:14002 ++#: tree.c:14013 + #, gcc-internal-format + msgid "type variant%'s %" + msgstr "" + +-#: tree.c:14004 ++#: tree.c:14015 + #, gcc-internal-format + msgid "type%'s %" + msgstr "" + +-#: tree.c:14043 ++#: tree.c:14054 + #, gcc-internal-format + msgid "type variant has different %" + msgstr "" + +-#: tree.c:14045 ++#: tree.c:14056 + #, gcc-internal-format + msgid "first mismatch is field" + msgstr "" + +-#: tree.c:14047 ++#: tree.c:14058 + #, gcc-internal-format + msgid "and field" + msgstr "" + +-#: tree.c:14064 ++#: tree.c:14075 + #, gcc-internal-format + msgid "type variant has different %" + msgstr "" + +-#: tree.c:14066 tree.c:14077 ++#: tree.c:14077 tree.c:14088 + #, gcc-internal-format + msgid "type variant%'s %" + msgstr "" + +-#: tree.c:14068 tree.c:14079 ++#: tree.c:14079 tree.c:14090 + #, gcc-internal-format + msgid "type%'s %" + msgstr "" + +-#: tree.c:14075 ++#: tree.c:14086 + #, gcc-internal-format + msgid "type is not compatible with its variant" + msgstr "" + +-#: tree.c:14387 ++#: tree.c:14398 + #, gcc-internal-format + msgid "main variant is not defined" + msgstr "" + +-#: tree.c:14392 ++#: tree.c:14403 + #, gcc-internal-format + msgid "% has different %" + msgstr "" + +-#: tree.c:14404 ++#: tree.c:14415 + #, gcc-internal-format + msgid "% has different %" + msgstr "" + +-#: tree.c:14423 ++#: tree.c:14434 + #, gcc-internal-format + msgid "% is not compatible" + msgstr "" + +-#: tree.c:14431 ++#: tree.c:14442 + #, gcc-internal-format + msgid "% of % is not compatible" + msgstr "" + +-#: tree.c:14437 ++#: tree.c:14448 + #, gcc-internal-format + msgid "% of main variant is not main variant" + msgstr "" + +-#: tree.c:14453 ++#: tree.c:14464 + #, gcc-internal-format + msgid "% is not % nor %" + msgstr "" + +-#: tree.c:14463 ++#: tree.c:14474 + #, gcc-internal-format + msgid "% is not %" + msgstr "" + +-#: tree.c:14473 ++#: tree.c:14484 + #, gcc-internal-format + msgid "% is not %" + msgstr "" + +-#: tree.c:14494 ++#: tree.c:14505 + #, gcc-internal-format + msgid "% is not %" + msgstr "" + +-#: tree.c:14500 ++#: tree.c:14511 + #, gcc-internal-format + msgid "% type is not %" + msgstr "" + +-#: tree.c:14511 ++#: tree.c:14522 + #, gcc-internal-format + msgid "% is not record nor union" + msgstr "" + +-#: tree.c:14522 ++#: tree.c:14533 + #, gcc-internal-format + msgid "% is not record nor union" + msgstr "" + +-#: tree.c:14540 ++#: tree.c:14551 + #, gcc-internal-format + msgid "% not %" + msgstr "" + +-#: tree.c:14547 ++#: tree.c:14558 + #, gcc-internal-format + msgid "% non-NULL" + msgstr "" + +-#: tree.c:14554 ++#: tree.c:14565 + #, gcc-internal-format + msgid "% field is non-NULL" + msgstr "" + +-#: tree.c:14570 ++#: tree.c:14581 + #, gcc-internal-format + msgid "enum value is not % or %" + msgstr "" + +-#: tree.c:14578 ++#: tree.c:14589 + #, gcc-internal-format + msgid "enum value type is not % nor convertible to the enum" + msgstr "" + +-#: tree.c:14586 ++#: tree.c:14597 + #, gcc-internal-format + msgid "enum value name is not %" + msgstr "" + +-#: tree.c:14596 ++#: tree.c:14607 + #, fuzzy, gcc-internal-format + #| msgid "size of array `%D' has non-integer type" + msgid "array % is not integer type" + msgstr "памер масіва `%D' не цэлалікавы тып" + +-#: tree.c:14605 ++#: tree.c:14616 + #, gcc-internal-format + msgid "% defined in incomplete type" + msgstr "" + +-#: tree.c:14627 ++#: tree.c:14638 + #, gcc-internal-format + msgid "wrong tree in % list" + msgstr "" + +-#: tree.c:14642 ++#: tree.c:14653 + #, gcc-internal-format + msgid "% is %i while % is %p" + msgstr "" + +-#: tree.c:14649 ++#: tree.c:14660 + #, gcc-internal-format + msgid "% is not %" + msgstr "" + +-#: tree.c:14662 ++#: tree.c:14673 + #, gcc-internal-format + msgid "wrong % entry" + msgstr "" + +-#: tree.c:14675 ++#: tree.c:14686 + #, gcc-internal-format + msgid "% is non-NULL in % list" + msgstr "" + +-#: tree.c:14681 ++#: tree.c:14692 + #, gcc-internal-format + msgid "wrong entry in % list" + msgstr "" + +-#: tree.c:14688 ++#: tree.c:14699 + #, gcc-internal-format + msgid "% field is non-NULL" + msgstr "" + +-#: tree.c:14700 ++#: tree.c:14711 + #, gcc-internal-format + msgid "% is set while it should not be" + msgstr "" + +-#: tree.c:14710 ++#: tree.c:14721 + #, gcc-internal-format + msgid "% is not main variant" + msgstr "" +@@ -28973,82 +29012,82 @@ msgstr "" + msgid "storage size of %q+D isn%'t known" + msgstr "" + +-#: varasm.c:5004 ++#: varasm.c:5003 + #, gcc-internal-format + msgid "initializer for integer/fixed-point value is too complicated" + msgstr "" + +-#: varasm.c:5009 ++#: varasm.c:5008 + #, gcc-internal-format + msgid "initializer for floating value is not a floating constant" + msgstr "" + +-#: varasm.c:5348 ++#: varasm.c:5347 + #, fuzzy, gcc-internal-format + msgid "invalid initial value for member %qE" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: varasm.c:5604 ++#: varasm.c:5603 + #, gcc-internal-format + msgid "%+qD declared weak after being used" + msgstr "" + +-#: varasm.c:5656 ++#: varasm.c:5655 + #, gcc-internal-format + msgid "weak declaration of %q+D being applied to a already existing, static definition" + msgstr "" + +-#: varasm.c:5692 ++#: varasm.c:5691 + #, gcc-internal-format + msgid "weak declaration of %q+D must be public" + msgstr "" + +-#: varasm.c:5696 ++#: varasm.c:5695 + #, gcc-internal-format + msgid "weak declaration of %q+D not supported" + msgstr "" + +-#: varasm.c:5725 varasm.c:6045 ++#: varasm.c:5724 varasm.c:6044 + #, gcc-internal-format + msgid "only weak aliases are supported in this configuration" + msgstr "" + +-#: varasm.c:5920 ++#: varasm.c:5919 + #, fuzzy, gcc-internal-format + msgid "weakref is not supported in this configuration" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: varasm.c:5948 ++#: varasm.c:5947 + #, fuzzy, gcc-internal-format + msgid "%qs is not supported on this target" + msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай" + +-#: varasm.c:6004 ++#: varasm.c:6003 + #, fuzzy, gcc-internal-format + msgid "symver is only supported on ELF platforms" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: varasm.c:6023 ++#: varasm.c:6022 + #, gcc-internal-format + msgid "%qs symbol %q+D ultimately targets itself" + msgstr "" + +-#: varasm.c:6025 ++#: varasm.c:6024 + #, gcc-internal-format + msgid "%qs symbol %q+D must have static linkage" + msgstr "" + +-#: varasm.c:6032 ++#: varasm.c:6031 + #, fuzzy, gcc-internal-format + msgid "alias definitions not supported in this configuration" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: varasm.c:6042 ++#: varasm.c:6041 + #, fuzzy, gcc-internal-format + msgid "%qs is not supported in this configuration" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: varasm.c:6260 config/sol2.c:159 config/i386/winnt.c:265 ++#: varasm.c:6259 config/sol2.c:159 config/i386/winnt.c:265 + #, fuzzy, gcc-internal-format + msgid "visibility attribute not supported in this configuration; ignored" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" +@@ -29640,7 +29679,7 @@ msgstr "" + msgid "type was previously declared %qE" + msgstr "няма папярэдняга аб'яўлення для \"%s\"" + +-#: c-family/c-attribs.c:3367 cp/class.c:4618 ++#: c-family/c-attribs.c:3367 cp/class.c:4662 + #, gcc-internal-format + msgid "% may only be specified for a virtual function" + msgstr "" +@@ -29661,7 +29700,7 @@ msgstr "" + msgid "%qE argument is not a function" + msgstr "`%D' - гэта ня функцыя," + +-#: c-family/c-attribs.c:3487 cp/name-lookup.c:5011 ++#: c-family/c-attribs.c:3487 cp/name-lookup.c:5013 + #, gcc-internal-format + msgid "deprecated message is not a string" + msgstr "" +@@ -30034,12 +30073,12 @@ msgstr "" + msgid "the compiler can assume that the address of %qD will always evaluate to %" + msgstr "" + +-#: c-family/c-common.c:3460 cp/semantics.c:663 cp/typeck.c:9371 ++#: c-family/c-common.c:3460 cp/semantics.c:663 cp/typeck.c:9431 + #, gcc-internal-format + msgid "suggest parentheses around assignment used as truth value" + msgstr "" + +-#: c-family/c-common.c:3547 c/c-decl.c:4620 c/c-decl.c:6798 c/c-typeck.c:15201 ++#: c-family/c-common.c:3547 c/c-decl.c:4620 c/c-decl.c:6798 c/c-typeck.c:15217 + #, fuzzy, gcc-internal-format + #| msgid "invalid use of `restrict'" + msgid "invalid use of %" +@@ -30197,13 +30236,13 @@ msgid "% attribute specified with a parameter" + msgstr "" + + #: c-family/c-common.c:5854 c-family/c-common.c:6644 c-family/c-common.c:6691 +-#: c-family/c-common.c:6764 c-family/c-common.c:6837 c/c-typeck.c:3660 ++#: c-family/c-common.c:6766 c-family/c-common.c:6839 c/c-typeck.c:3660 + #, fuzzy, gcc-internal-format + #| msgid "too few arguments to function" + msgid "too few arguments to function %qE" + msgstr "не хапае аргументаў у функцыі" + +-#: c-family/c-common.c:5859 c-family/c-common.c:6697 c-family/c-common.c:6863 ++#: c-family/c-common.c:5859 c-family/c-common.c:6697 c-family/c-common.c:6865 + #: c/c-typeck.c:3524 + #, fuzzy, gcc-internal-format + #| msgid "too many arguments to function" +@@ -30310,7 +30349,7 @@ msgstr "" + msgid "size of array is too large" + msgstr "памер масіва \"%s\" вельмі вялікі" + +-#: c-family/c-common.c:6674 c-family/c-common.c:6796 ++#: c-family/c-common.c:6674 c-family/c-common.c:6798 + #, gcc-internal-format + msgid "operand type %qT is incompatible with argument %d of %qE" + msgstr "" +@@ -30320,127 +30359,127 @@ msgstr "" + msgid "expecting argument of type pointer or of type integer for argument 1" + msgstr "" + +-#: c-family/c-common.c:6722 ++#: c-family/c-common.c:6724 + #, gcc-internal-format + msgid "both arguments must be compatible" + msgstr "" + +-#: c-family/c-common.c:6930 ++#: c-family/c-common.c:6932 + #, fuzzy, gcc-internal-format + #| msgid "too few arguments to function `%s'" + msgid "incorrect number of arguments to function %qE" + msgstr "нехапае аргументаў у функцыі \"%s\"" + +-#: c-family/c-common.c:6944 ++#: c-family/c-common.c:6946 + #, fuzzy, gcc-internal-format + msgid "argument 1 of %qE must be a non-void pointer type" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: c-family/c-common.c:6953 ++#: c-family/c-common.c:6955 + #, fuzzy, gcc-internal-format + msgid "argument 1 of %qE must be a pointer to a constant size type" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: c-family/c-common.c:6964 ++#: c-family/c-common.c:6966 + #, fuzzy, gcc-internal-format + msgid "argument 1 of %qE must be a pointer to a nonzero size object" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: c-family/c-common.c:6985 ++#: c-family/c-common.c:6987 + #, fuzzy, gcc-internal-format + msgid "argument %d of %qE must be a pointer type" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: c-family/c-common.c:6993 ++#: c-family/c-common.c:6995 + #, fuzzy, gcc-internal-format + msgid "argument %d of %qE must be a pointer to a constant size type" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: c-family/c-common.c:6999 ++#: c-family/c-common.c:7001 + #, fuzzy, gcc-internal-format + msgid "argument %d of %qE must not be a pointer to a function" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: c-family/c-common.c:7007 ++#: c-family/c-common.c:7009 + #, gcc-internal-format + msgid "size mismatch in argument %d of %qE" + msgstr "" + +-#: c-family/c-common.c:7019 ++#: c-family/c-common.c:7021 + #, gcc-internal-format + msgid "non-integer memory model argument %d of %qE" + msgstr "" + +-#: c-family/c-common.c:7032 ++#: c-family/c-common.c:7034 + #, gcc-internal-format + msgid "invalid memory model argument %d of %qE" + msgstr "" + +-#: c-family/c-common.c:7433 ++#: c-family/c-common.c:7435 + #, gcc-internal-format + msgid "this target does not define a speculation barrier; your program will still execute correctly, but incorrect speculation may not be restricted" + msgstr "" + +-#: c-family/c-common.c:8053 ++#: c-family/c-common.c:8055 + #, gcc-internal-format + msgid "index value is out of bound" + msgstr "" + +-#: c-family/c-common.c:8095 c-family/c-common.c:8144 c-family/c-common.c:8160 ++#: c-family/c-common.c:8097 c-family/c-common.c:8146 c-family/c-common.c:8162 + #, gcc-internal-format + msgid "conversion of scalar %qT to vector %qT involves truncation" + msgstr "" + + #. Reject arguments that are built-in functions with + #. no library fallback. +-#: c-family/c-common.c:8248 ++#: c-family/c-common.c:8250 + #, gcc-internal-format + msgid "built-in function %qE must be directly called" + msgstr "" + +-#: c-family/c-common.c:8268 ++#: c-family/c-common.c:8270 + #, fuzzy, gcc-internal-format + msgid "size of array %qE is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: c-family/c-common.c:8271 ++#: c-family/c-common.c:8273 + #, fuzzy, gcc-internal-format + msgid "size of array is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: c-family/c-common.c:8275 ++#: c-family/c-common.c:8277 + #, fuzzy, gcc-internal-format + #| msgid "size of array is negative" + msgid "size %qE of array %qE is negative" + msgstr "адмоўны памер масіва " + +-#: c-family/c-common.c:8278 ++#: c-family/c-common.c:8280 + #, fuzzy, gcc-internal-format + #| msgid "size of array is negative" + msgid "size %qE of array is negative" + msgstr "адмоўны памер масіва " + +-#: c-family/c-common.c:8283 ++#: c-family/c-common.c:8285 + #, gcc-internal-format + msgid "size %qE of array %qE exceeds maximum object size %qE" + msgstr "" + +-#: c-family/c-common.c:8286 ++#: c-family/c-common.c:8288 + #, gcc-internal-format + msgid "size %qE of array exceeds maximum object size %qE" + msgstr "" + +-#: c-family/c-common.c:8291 ++#: c-family/c-common.c:8293 + #, gcc-internal-format + msgid "size of array %qE exceeds maximum object size %qE" + msgstr "" + +-#: c-family/c-common.c:8294 ++#: c-family/c-common.c:8296 + #, gcc-internal-format + msgid "size of array exceeds maximum object size %qE" + msgstr "" + +-#: c-family/c-common.c:8365 ++#: c-family/c-common.c:8367 + #, gcc-internal-format + msgid "environment variable %qs must expand to a non-negative integer less than or equal to %wd" + msgstr "" +@@ -30497,509 +30536,509 @@ msgstr "" + msgid "format string argument follows the arguments to be formatted" + msgstr "" + +-#: c-family/c-format.c:1236 ++#: c-family/c-format.c:1238 + #, gcc-internal-format + msgid "function %qD might be a candidate for %qs format attribute" + msgstr "" + +-#: c-family/c-format.c:1327 c-family/c-format.c:1348 c-family/c-format.c:2782 ++#: c-family/c-format.c:1329 c-family/c-format.c:1350 c-family/c-format.c:2784 + #, gcc-internal-format + msgid "missing $ operand number in format" + msgstr "" + +-#: c-family/c-format.c:1357 ++#: c-family/c-format.c:1359 + #, gcc-internal-format, gfc-internal-format + msgid "%s does not support %%n$ operand number formats" + msgstr "" + +-#: c-family/c-format.c:1364 ++#: c-family/c-format.c:1366 + #, gcc-internal-format + msgid "operand number out of range in format" + msgstr "" + +-#: c-family/c-format.c:1387 ++#: c-family/c-format.c:1389 + #, gcc-internal-format, gfc-internal-format + msgid "format argument %d used more than once in %s format" + msgstr "" + +-#: c-family/c-format.c:1420 ++#: c-family/c-format.c:1422 + #, gcc-internal-format + msgid "%<$%>operand number used after format without operand number" + msgstr "" + +-#: c-family/c-format.c:1451 ++#: c-family/c-format.c:1453 + #, gcc-internal-format + msgid "format argument %d unused before used argument %d in %<$%>-style format" + msgstr "" + +-#: c-family/c-format.c:1554 ++#: c-family/c-format.c:1556 + #, gcc-internal-format + msgid "format not a string literal, format string not checked" + msgstr "" + +-#: c-family/c-format.c:1569 c-family/c-format.c:1572 ++#: c-family/c-format.c:1571 c-family/c-format.c:1574 + #, gcc-internal-format + msgid "format not a string literal and no format arguments" + msgstr "" + +-#: c-family/c-format.c:1575 ++#: c-family/c-format.c:1577 + #, gcc-internal-format + msgid "format not a string literal, argument types not checked" + msgstr "" + +-#: c-family/c-format.c:1592 ++#: c-family/c-format.c:1594 + #, gcc-internal-format + msgid "too many arguments for format" + msgstr "" + +-#: c-family/c-format.c:1597 ++#: c-family/c-format.c:1599 + #, gcc-internal-format + msgid "unused arguments in %<$%>-style format" + msgstr "" + +-#: c-family/c-format.c:1600 ++#: c-family/c-format.c:1602 + #, gcc-internal-format, gfc-internal-format + msgid "zero-length %s format string" + msgstr "" + +-#: c-family/c-format.c:1604 ++#: c-family/c-format.c:1606 + #, gcc-internal-format + msgid "format is a wide character string" + msgstr "" + +-#: c-family/c-format.c:1608 ++#: c-family/c-format.c:1610 + #, gcc-internal-format + msgid "format string is not an array of type %qs" + msgstr "" + +-#: c-family/c-format.c:1611 ++#: c-family/c-format.c:1613 + #, gcc-internal-format + msgid "unterminated format string" + msgstr "" + +-#: c-family/c-format.c:2025 ++#: c-family/c-format.c:2027 + #, gcc-internal-format + msgid "%s used with %<%%%c%> %s format" + msgstr "" + +-#: c-family/c-format.c:2035 ++#: c-family/c-format.c:2037 + #, gcc-internal-format, gfc-internal-format + msgid "%s does not support %s" + msgstr "%s не падтрымлівае %s" + +-#: c-family/c-format.c:2045 ++#: c-family/c-format.c:2047 + #, fuzzy, gcc-internal-format + #| msgid "%s does not support %s" + msgid "%s does not support %s with the %<%%%c%> %s format" + msgstr "%s не падтрымлівае %s" + +-#: c-family/c-format.c:2059 ++#: c-family/c-format.c:2061 + #, gcc-internal-format, gfc-internal-format + msgid "%s used within a quoted sequence" + msgstr "" + +-#: c-family/c-format.c:2072 ++#: c-family/c-format.c:2074 + #, gcc-internal-format + msgid "%qc conversion used unquoted" + msgstr "" + +-#: c-family/c-format.c:2190 c-family/c-format.c:2521 ++#: c-family/c-format.c:2192 c-family/c-format.c:2523 + #, gcc-internal-format, gfc-internal-format + msgid "repeated %s in format" + msgstr "" + +-#: c-family/c-format.c:2201 ++#: c-family/c-format.c:2203 + #, gcc-internal-format + msgid "missing fill character at end of strfmon format" + msgstr "" + +-#: c-family/c-format.c:2303 ++#: c-family/c-format.c:2305 + #, gcc-internal-format, gfc-internal-format + msgid "zero width in %s format" + msgstr "" + +-#: c-family/c-format.c:2326 ++#: c-family/c-format.c:2328 + #, gcc-internal-format, gfc-internal-format + msgid "empty left precision in %s format" + msgstr "" + +-#: c-family/c-format.c:2417 ++#: c-family/c-format.c:2419 + #, gcc-internal-format, gfc-internal-format + msgid "empty precision in %s format" + msgstr "" + +-#: c-family/c-format.c:2495 ++#: c-family/c-format.c:2497 + #, fuzzy, gcc-internal-format + #| msgid "%s does not support %s" + msgid "%s does not support the %qs %s length modifier" + msgstr "%s не падтрымлівае %s" + +-#: c-family/c-format.c:2551 ++#: c-family/c-format.c:2553 + #, gcc-internal-format + msgid "unknown conversion type character %qc in format" + msgstr "" + +-#: c-family/c-format.c:2563 ++#: c-family/c-format.c:2565 + #, fuzzy, gcc-internal-format + #| msgid "%s does not support %s" + msgid "%s does not support the %<%%%c%> %s format" + msgstr "%s не падтрымлівае %s" + +-#: c-family/c-format.c:2595 ++#: c-family/c-format.c:2597 + #, gcc-internal-format + msgid "%s ignored with %s and %<%%%c%> %s format" + msgstr "" + +-#: c-family/c-format.c:2600 ++#: c-family/c-format.c:2602 + #, gcc-internal-format, gfc-internal-format + msgid "%s ignored with %s in %s format" + msgstr "" + +-#: c-family/c-format.c:2607 ++#: c-family/c-format.c:2609 + #, gcc-internal-format + msgid "use of %s and %s together with %<%%%c%> %s format" + msgstr "" + +-#: c-family/c-format.c:2612 ++#: c-family/c-format.c:2614 + #, gcc-internal-format, gfc-internal-format + msgid "use of %s and %s together in %s format" + msgstr "" + +-#: c-family/c-format.c:2639 ++#: c-family/c-format.c:2641 + #, gcc-internal-format + msgid "%<%%%c%> yields only last 2 digits of year in some locales" + msgstr "" + +-#: c-family/c-format.c:2643 ++#: c-family/c-format.c:2645 + #, gcc-internal-format + msgid "%<%%%c%> yields only last 2 digits of year" + msgstr "" + +-#: c-family/c-format.c:2670 ++#: c-family/c-format.c:2672 + #, gcc-internal-format + msgid "no closing %<]%> for %<%%[%> format" + msgstr "" + +-#: c-family/c-format.c:2699 ++#: c-family/c-format.c:2701 + #, gcc-internal-format + msgid "use of %qs length modifier with %qc type character has either no effect or undefined behavior" + msgstr "" + +-#: c-family/c-format.c:2721 ++#: c-family/c-format.c:2723 + #, fuzzy, gcc-internal-format + #| msgid "%s does not support %s" + msgid "%s does not support the %<%%%s%c%> %s format" + msgstr "%s не падтрымлівае %s" + +-#: c-family/c-format.c:2759 ++#: c-family/c-format.c:2761 + #, gcc-internal-format + msgid "operand number specified with suppressed assignment" + msgstr "" + +-#: c-family/c-format.c:2763 ++#: c-family/c-format.c:2765 + #, gcc-internal-format + msgid "operand number specified for format taking no argument" + msgstr "" + +-#: c-family/c-format.c:3113 ++#: c-family/c-format.c:3115 + #, gcc-internal-format + msgid "unquoted type name %<%.*s%> in format" + msgstr "" + +-#: c-family/c-format.c:3115 ++#: c-family/c-format.c:3117 + #, gcc-internal-format + msgid "unquoted operator %<%.*s%> in format" + msgstr "" + +-#: c-family/c-format.c:3116 ++#: c-family/c-format.c:3118 + #, gcc-internal-format + msgid "unquoted keyword %<%.*s%> in format" + msgstr "" + +-#: c-family/c-format.c:3119 ++#: c-family/c-format.c:3121 + #, gcc-internal-format + msgid "use %qs instead" + msgstr "" + +-#: c-family/c-format.c:3171 ++#: c-family/c-format.c:3173 + #, fuzzy, gcc-internal-format + #| msgid "`%s' attribute ignored" + msgid "unquoted attribute in format" + msgstr "\"%s\" атрыбут ігнарыруецца" + +-#: c-family/c-format.c:3184 ++#: c-family/c-format.c:3186 + #, fuzzy, gcc-internal-format + msgid "unquoted name of built-in function %<%.*s%> in format" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: c-family/c-format.c:3198 ++#: c-family/c-format.c:3200 + #, gcc-internal-format + msgid "unquoted identifier or keyword %<%.*s%> in format" + msgstr "" + +-#: c-family/c-format.c:3226 ++#: c-family/c-format.c:3228 + #, gcc-internal-format + msgid "misspelled term %<%.*s%> in format; use %<%s%s%> instead" + msgstr "" + +-#: c-family/c-format.c:3270 ++#: c-family/c-format.c:3272 + #, gcc-internal-format + msgid "quoted %qs directive in format; use %qs instead" + msgstr "" + +-#: c-family/c-format.c:3277 c-family/c-format.c:3548 ++#: c-family/c-format.c:3279 c-family/c-format.c:3550 + #, gcc-internal-format + msgid "contraction %<%.*s%> in format; use %qs instead" + msgstr "" + +-#: c-family/c-format.c:3317 ++#: c-family/c-format.c:3319 + #, gcc-internal-format + msgid "unquoted whitespace character %qc in format" + msgstr "" + +-#: c-family/c-format.c:3330 ++#: c-family/c-format.c:3332 + #, gcc-internal-format + msgid "spurious trailing space in format" + msgstr "" + +-#: c-family/c-format.c:3351 ++#: c-family/c-format.c:3353 + #, gcc-internal-format + msgid "inconsistent capitalization in format" + msgstr "" + +-#: c-family/c-format.c:3358 ++#: c-family/c-format.c:3360 + #, gcc-internal-format, gfc-internal-format + msgid "unquoted sequence of %i consecutive space characters in format" + msgstr "" + +-#: c-family/c-format.c:3378 ++#: c-family/c-format.c:3380 + #, gcc-internal-format + msgid "unquoted control characters in format" + msgstr "" + +-#: c-family/c-format.c:3385 ++#: c-family/c-format.c:3387 + #, gcc-internal-format + msgid "unquoted control character %qc in format" + msgstr "" + +-#: c-family/c-format.c:3443 ++#: c-family/c-format.c:3445 + #, gcc-internal-format + msgid "unquoted option name %<%.*s%> in format" + msgstr "" + +-#: c-family/c-format.c:3503 ++#: c-family/c-format.c:3505 + #, gcc-internal-format + msgid "unbalanced punctuation character %qc in format" + msgstr "" + +-#: c-family/c-format.c:3522 ++#: c-family/c-format.c:3524 + #, gcc-internal-format + msgid "unquoted preprocessing directive %<%.*s%> in format" + msgstr "" + +-#: c-family/c-format.c:3558 ++#: c-family/c-format.c:3560 + #, gcc-internal-format + msgid "bare apostrophe %<'%> in format" + msgstr "" + +-#: c-family/c-format.c:3560 ++#: c-family/c-format.c:3562 + #, gcc-internal-format + msgid "if avoiding the apostrophe is not feasible, enclose it in a pair of %qs and %qs directives instead" + msgstr "" + +-#: c-family/c-format.c:3572 ++#: c-family/c-format.c:3574 + #, gcc-internal-format + msgid "grave accent %<`%> in format" + msgstr "" + +-#: c-family/c-format.c:3574 ++#: c-family/c-format.c:3576 + #, gcc-internal-format + msgid "use the apostrophe directive %qs instead" + msgstr "" + +-#: c-family/c-format.c:3586 ++#: c-family/c-format.c:3588 + #, gcc-internal-format + msgid "space followed by punctuation character %<%c%>" + msgstr "" + +-#: c-family/c-format.c:3597 ++#: c-family/c-format.c:3599 + #, gcc-internal-format + msgid "quoted %qs directive in format" + msgstr "" + +-#: c-family/c-format.c:3599 ++#: c-family/c-format.c:3601 + #, gcc-internal-format + msgid "if using %qs is not feasible, use %qs instead" + msgstr "" + +-#: c-family/c-format.c:3628 ++#: c-family/c-format.c:3630 + #, gcc-internal-format + msgid "spurious leading punctuation sequence %<%.*s%> in format" + msgstr "" + +-#: c-family/c-format.c:3668 ++#: c-family/c-format.c:3670 + #, gcc-internal-format + msgid "spurious trailing punctuation sequence %<%.*s%> in format" + msgstr "" + +-#: c-family/c-format.c:3685 ++#: c-family/c-format.c:3687 + #, gcc-internal-format + msgid "unquoted sequence of %i consecutive punctuation characters %q.*s in format" + msgstr "" + +-#: c-family/c-format.c:3705 ++#: c-family/c-format.c:3707 + #, gcc-internal-format + msgid "unquoted non-graph characters in format" + msgstr "" + +-#: c-family/c-format.c:3712 ++#: c-family/c-format.c:3714 + #, gcc-internal-format + msgid "unquoted non-graph character %qc in format" + msgstr "" + +-#: c-family/c-format.c:3744 ++#: c-family/c-format.c:3746 + #, gcc-internal-format + msgid "unbalanced punctuation character %<%c%> in format" + msgstr "" + +-#: c-family/c-format.c:3751 ++#: c-family/c-format.c:3753 + #, fuzzy, gcc-internal-format + #| msgid "unterminated comment" + msgid "unterminated quoting directive" + msgstr "незавершаныя каментарыі" + +-#: c-family/c-format.c:3760 ++#: c-family/c-format.c:3762 + #, gcc-internal-format + msgid "unterminated quote character %<%c%> in format" + msgstr "" + +-#: c-family/c-format.c:3830 ++#: c-family/c-format.c:3832 + #, gcc-internal-format + msgid "spurious trailing %<%%%> in format" + msgstr "" + +-#: c-family/c-format.c:3890 ++#: c-family/c-format.c:3892 + #, gcc-internal-format + msgid "conversion lacks type at end of format" + msgstr "" + +-#: c-family/c-format.c:3919 ++#: c-family/c-format.c:3921 + #, fuzzy, gcc-internal-format + msgid "nested quoting directive" + msgstr "нерэчаісны ініцыялізатар" + +-#: c-family/c-format.c:3930 ++#: c-family/c-format.c:3932 + #, fuzzy, gcc-internal-format + msgid "unmatched quoting directive" + msgstr "нерэчаісны ініцыялізатар" + +-#: c-family/c-format.c:3945 ++#: c-family/c-format.c:3947 + #, gcc-internal-format + msgid "%qc directive redundant after prior occurence of the same" + msgstr "" + +-#: c-family/c-format.c:3951 ++#: c-family/c-format.c:3953 + #, gcc-internal-format + msgid "unmatched color reset directive" + msgstr "" + +-#: c-family/c-format.c:3963 ++#: c-family/c-format.c:3965 + #, gcc-internal-format + msgid "%qc conversion used within a quoted sequence" + msgstr "" + +-#: c-family/c-format.c:4003 ++#: c-family/c-format.c:4005 + #, gcc-internal-format + msgid "embedded %<\\0%> in format" + msgstr "" + +-#: c-family/c-format.c:4019 ++#: c-family/c-format.c:4021 + #, fuzzy, gcc-internal-format + #| msgid "unterminated comment" + msgid "unterminated color directive" + msgstr "незавершаныя каментарыі" + +-#: c-family/c-format.c:4141 ++#: c-family/c-format.c:4143 + #, gcc-internal-format, gfc-internal-format + msgid "writing through null pointer (argument %d)" + msgstr "" + +-#: c-family/c-format.c:4152 ++#: c-family/c-format.c:4154 + #, gcc-internal-format, gfc-internal-format + msgid "reading through null pointer (argument %d)" + msgstr "" + +-#: c-family/c-format.c:4172 ++#: c-family/c-format.c:4174 + #, gcc-internal-format, gfc-internal-format + msgid "writing into constant object (argument %d)" + msgstr "" + +-#: c-family/c-format.c:4184 ++#: c-family/c-format.c:4186 + #, gcc-internal-format, gfc-internal-format + msgid "extra type qualifiers in format argument (argument %d)" + msgstr "" + +-#: c-family/c-format.c:4726 ++#: c-family/c-format.c:4728 + #, gcc-internal-format + msgid "%s %<%s%.*s%> expects argument of type %<%s%s%>, but argument %d has type %qT" + msgstr "" + +-#: c-family/c-format.c:4735 ++#: c-family/c-format.c:4737 + #, gcc-internal-format + msgid "%s %<%s%.*s%> expects a matching %<%s%s%> argument" + msgstr "" + +-#: c-family/c-format.c:4745 ++#: c-family/c-format.c:4747 + #, gcc-internal-format + msgid "%s %<%s%.*s%> expects argument of type %<%T%s%>, but argument %d has type %qT" + msgstr "" + +-#: c-family/c-format.c:4754 ++#: c-family/c-format.c:4756 + #, gcc-internal-format + msgid "%s %<%s%.*s%> expects a matching %<%T%s%> argument" + msgstr "" + +-#: c-family/c-format.c:4816 c-family/c-format.c:4822 c-family/c-format.c:5015 ++#: c-family/c-format.c:4818 c-family/c-format.c:4824 c-family/c-format.c:5017 + #, gcc-internal-format + msgid "%<__gcc_host_wide_int__%> is not defined as a type" + msgstr "" + +-#: c-family/c-format.c:4829 c-family/c-format.c:5025 ++#: c-family/c-format.c:4831 c-family/c-format.c:5027 + #, gcc-internal-format + msgid "%<__gcc_host_wide_int__%> is not defined as % or %" + msgstr "" + +-#: c-family/c-format.c:4877 ++#: c-family/c-format.c:4879 + #, gcc-internal-format + msgid "% is not defined as a type" + msgstr "" + +-#: c-family/c-format.c:4921 ++#: c-family/c-format.c:4923 + #, fuzzy, gcc-internal-format + msgid "%qs is not defined as a type" + msgstr "\"%s\" мае незавершаны тып" + +-#: c-family/c-format.c:4947 ++#: c-family/c-format.c:4949 + #, gcc-internal-format + msgid "% is not defined as a type" + msgstr "" + +-#: c-family/c-format.c:4964 ++#: c-family/c-format.c:4966 + #, gcc-internal-format + msgid "% is not defined as a type" + msgstr "" + +-#: c-family/c-format.c:4970 ++#: c-family/c-format.c:4972 + #, gcc-internal-format + msgid "% is not defined as a pointer type" + msgstr "" + +-#: c-family/c-format.c:5200 ++#: c-family/c-format.c:5202 + #, gcc-internal-format + msgid "argument to be formatted is not %<...%>" + msgstr "" + +-#: c-family/c-format.c:5212 ++#: c-family/c-format.c:5214 + #, gcc-internal-format + msgid "strftime formats cannot format arguments" + msgstr "" +@@ -31163,7 +31202,7 @@ msgstr "" + msgid "% modifier may not be specified on % construct" + msgstr "" + +-#: c-family/c-omp.c:723 cp/semantics.c:9043 ++#: c-family/c-omp.c:723 cp/semantics.c:9059 + #, gcc-internal-format + msgid "invalid type for iteration variable %qE" + msgstr "" +@@ -31179,17 +31218,17 @@ msgstr "" + msgid "%qE is not initialized" + msgstr "прапушчан ініцыялізатар" + +-#: c-family/c-omp.c:765 cp/semantics.c:8932 ++#: c-family/c-omp.c:765 cp/semantics.c:8948 + #, gcc-internal-format + msgid "missing controlling predicate" + msgstr "" + +-#: c-family/c-omp.c:871 cp/semantics.c:8551 ++#: c-family/c-omp.c:871 cp/semantics.c:8567 + #, fuzzy, gcc-internal-format + msgid "invalid controlling predicate" + msgstr "нерэчаісны ініцыялізатар" + +-#: c-family/c-omp.c:878 cp/semantics.c:8938 ++#: c-family/c-omp.c:878 cp/semantics.c:8954 + #, fuzzy, gcc-internal-format + msgid "missing increment expression" + msgstr "аргумент для \"%s\" прапушчан" +@@ -31199,7 +31238,7 @@ msgstr "аргумент для \"%s\" прапушчан" + msgid "increment is not constant 1 or -1 for % condition" + msgstr "" + +-#: c-family/c-omp.c:1009 cp/semantics.c:8666 ++#: c-family/c-omp.c:1009 cp/semantics.c:8682 + #, fuzzy, gcc-internal-format + msgid "invalid increment expression" + msgstr "нерэчаісны ініцыялізатар" +@@ -31805,7 +31844,7 @@ msgid "wrong type argument to %s" + msgstr "не хапае аргументаў у функцыі" + + #: c-family/c-warn.c:56 c-family/c-warn.c:69 cp/constexpr.c:2736 +-#: cp/constexpr.c:5479 ++#: cp/constexpr.c:5495 + #, gcc-internal-format + msgid "overflow in constant expression" + msgstr "" +@@ -32491,7 +32530,7 @@ msgid "% used with length equal to number of elements without multiplic + msgstr "" + + #: c-family/c-warn.c:2240 c/c-typeck.c:11993 c/c-typeck.c:12161 +-#: cp/typeck.c:5266 ++#: cp/typeck.c:5324 + #, gcc-internal-format + msgid "comparison between types %qT and %qT" + msgstr "" +@@ -32570,7 +32609,7 @@ msgid_plural "passing argument %i to %qs-qualified parameter aliases with argume + msgstr[0] "" + msgstr[1] "" + +-#: c-family/c-warn.c:2779 c/c-typeck.c:5485 cp/call.c:5688 ++#: c-family/c-warn.c:2779 c/c-typeck.c:5485 cp/call.c:5690 + #, gcc-internal-format + msgid "this condition has identical branches" + msgstr "" +@@ -32590,7 +32629,7 @@ msgstr "" + msgid "converting a packed %qT pointer (alignment %d) to a %qT pointer (alignment %d) may result in an unaligned pointer value" + msgstr "" + +-#: c-family/c-warn.c:2987 c-family/c-warn.c:2990 cp/init.c:633 ++#: c-family/c-warn.c:2987 c-family/c-warn.c:2990 cp/init.c:635 + #, gcc-internal-format + msgid "defined here" + msgstr "" +@@ -32610,7 +32649,7 @@ msgstr "" + msgid "too many input files" + msgstr "вельмі шмат уваходзячых файлаў" + +-#: common/config/aarch64/aarch64-common.c:512 config/aarch64/aarch64.c:14359 ++#: common/config/aarch64/aarch64-common.c:516 config/aarch64/aarch64.c:14482 + #, gcc-internal-format + msgid "unknown value %qs for %<-mcpu%>" + msgstr "" +@@ -32642,14 +32681,14 @@ msgid "unrecognized option passed to %%:target_mode_check" + msgstr "" + + #: common/config/arm/arm-common.c:331 common/config/arm/arm-common.c:395 +-#: common/config/arm/arm-common.c:442 config/aarch64/aarch64.c:14291 +-#: config/aarch64/aarch64.c:14329 ++#: common/config/arm/arm-common.c:442 config/aarch64/aarch64.c:14414 ++#: config/aarch64/aarch64.c:14452 + #, gcc-internal-format + msgid "valid arguments are: %s; did you mean %qs?" + msgstr "" + + #: common/config/arm/arm-common.c:334 common/config/arm/arm-common.c:398 +-#: common/config/arm/arm-common.c:445 config/aarch64/aarch64.c:14294 ++#: common/config/arm/arm-common.c:445 config/aarch64/aarch64.c:14417 + #, fuzzy, gcc-internal-format, gfc-internal-format + msgid "valid arguments are: %s" + msgstr "нявернае выкарыстанне \"restict\"" +@@ -33173,395 +33212,402 @@ msgstr "-pipe не падтрымліваецца" + msgid "profiler support for VxWorks" + msgstr "" + +-#: config/aarch64/aarch64-builtins.c:1439 +-#: config/aarch64/aarch64-builtins.c:1669 config/arm/arm-builtins.c:3105 ++#: config/aarch64/aarch64-builtins.c:1445 ++#: config/aarch64/aarch64-builtins.c:1675 config/arm/arm-builtins.c:3114 + #, fuzzy, gcc-internal-format + msgid "%Kargument %d must be a constant immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/aarch64/aarch64-builtins.c:1510 config/arm/arm-builtins.c:3450 ++#: config/aarch64/aarch64-builtins.c:1516 config/arm/arm-builtins.c:3459 + #, gcc-internal-format + msgid "%Klane index must be a constant immediate" + msgstr "" + +-#: config/aarch64/aarch64-builtins.c:1513 ++#: config/aarch64/aarch64-builtins.c:1519 + #, gcc-internal-format + msgid "%Ktotal size and element size must be a non-zero constant immediate" + msgstr "" + +-#: config/aarch64/aarch64-builtins.c:1758 ++#: config/aarch64/aarch64-builtins.c:1764 + #, fuzzy, gcc-internal-format + msgid "%Kargument must be a 16-bit constant immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/aarch64/aarch64-builtins.c:1813 ++#: config/aarch64/aarch64-builtins.c:1819 + #, gcc-internal-format + msgid "Memory Tagging Extension does not support %<-mabi=ilp32%>" + msgstr "" + +-#: config/aarch64/aarch64-builtins.c:1847 ++#: config/aarch64/aarch64-builtins.c:1853 + #, gcc-internal-format + msgid "%Kargument %d must be a constant immediate in range [0,15]" + msgstr "" + +-#: config/aarch64/aarch64-builtins.c:2395 +-#: config/aarch64/aarch64-builtins.c:2415 ++#: config/aarch64/aarch64-builtins.c:2404 ++#: config/aarch64/aarch64-builtins.c:2424 + #, gcc-internal-format, gfc-internal-format + msgid "expected 64-bit address but argument 1 is %d-bit" + msgstr "" + +-#: config/aarch64/aarch64-builtins.c:2399 ++#: config/aarch64/aarch64-builtins.c:2408 + #, gcc-internal-format, gfc-internal-format + msgid "expected 64-bit address but argument 2 is %d-bit" + msgstr "" + +-#: config/aarch64/aarch64-c.c:275 ++#: config/aarch64/aarch64-c.c:291 + #, gcc-internal-format + msgid "%<#pragma GCC aarch64%> requires a string parameter" + msgstr "" + +-#: config/aarch64/aarch64-c.c:283 ++#: config/aarch64/aarch64-c.c:299 + #, gcc-internal-format + msgid "unknown %<#pragma GCC aarch64%> option %qs" + msgstr "" + +-#: config/aarch64/aarch64.c:1327 ++#: config/aarch64/aarch64.c:1410 + #, fuzzy, gcc-internal-format + msgid "the %qE attribute cannot be applied to an SVE function type" + msgstr "\"%s\" звычайна функцыя" + +-#: config/aarch64/aarch64.c:1401 config/aarch64/aarch64.c:1415 ++#: config/aarch64/aarch64.c:1485 config/aarch64/aarch64.c:1499 + #, gcc-internal-format + msgid "unexpected %<%s%> after %<%s%>" + msgstr "" + +-#: config/aarch64/aarch64.c:1845 ++#: config/aarch64/aarch64.c:1929 + #, gcc-internal-format + msgid "%qs is incompatible with the use of floating-point types" + msgstr "" + +-#: config/aarch64/aarch64.c:1848 ++#: config/aarch64/aarch64.c:1932 + #, gcc-internal-format + msgid "%qs is incompatible with the use of vector types" + msgstr "" + +-#: config/aarch64/aarch64.c:1852 ++#: config/aarch64/aarch64.c:1936 + #, gcc-internal-format + msgid "%qs feature modifier is incompatible with the use of floating-point types" + msgstr "" + +-#: config/aarch64/aarch64.c:1855 ++#: config/aarch64/aarch64.c:1939 + #, gcc-internal-format + msgid "%qs feature modifier is incompatible with the use of vector types" + msgstr "" + +-#: config/aarch64/aarch64.c:1871 ++#: config/aarch64/aarch64.c:1955 + #, gcc-internal-format + msgid "this operation requires the SVE ISA extension" + msgstr "" + +-#: config/aarch64/aarch64.c:1872 ++#: config/aarch64/aarch64.c:1956 + #, gcc-internal-format + msgid "you can enable SVE using the command-line option %<-march%>, or by using the % attribute or pragma" + msgstr "" + + #. We can't gracefully recover at this point, so make this a + #. fatal error. +-#: config/aarch64/aarch64.c:5341 ++#: config/aarch64/aarch64.c:5426 + #, gcc-internal-format + msgid "arguments of type %qT require the SVE ISA extension" + msgstr "" + +-#: config/aarch64/aarch64.c:5653 ++#: config/aarch64/aarch64.c:5747 + #, fuzzy, gcc-internal-format + msgid "SVE type %qT cannot be passed to an unprototyped function" + msgstr "\"%s\" звычайна функцыя" + +-#: config/aarch64/aarch64.c:5775 config/aarch64/aarch64.c:5838 +-#: config/aarch64/aarch64.c:5958 config/aarch64/aarch64.c:16117 +-#: config/arm/arm.c:6976 config/arm/arm.c:7006 config/arm/arm.c:28383 ++#: config/aarch64/aarch64.c:5869 config/aarch64/aarch64.c:5932 ++#: config/aarch64/aarch64.c:6052 config/aarch64/aarch64.c:16239 ++#: config/arm/arm.c:7073 config/arm/arm.c:7103 config/arm/arm.c:28558 + #, gcc-internal-format + msgid "parameter passing for argument of type %qT changed in GCC 9.1" + msgstr "" + +-#: config/aarch64/aarch64.c:5907 ++#: config/aarch64/aarch64.c:6001 + #, gcc-internal-format + msgid "%qE requires the SVE ISA extension" + msgstr "" + +-#: config/aarch64/aarch64.c:5910 ++#: config/aarch64/aarch64.c:6004 + #, gcc-internal-format + msgid "calls to functions of type %qT require the SVE ISA extension" + msgstr "" + +-#: config/aarch64/aarch64.c:6086 ++#: config/aarch64/aarch64.c:6180 + #, gcc-internal-format + msgid "stack probes for SVE frames" + msgstr "" + +-#: config/aarch64/aarch64.c:13836 ++#: config/aarch64/aarch64.c:13959 + #, gcc-internal-format + msgid "unknown flag passed in %<-moverride=%s%> (%s)" + msgstr "" + +-#: config/aarch64/aarch64.c:13880 ++#: config/aarch64/aarch64.c:14003 + #, gcc-internal-format, gfc-internal-format + msgid "%s string ill-formed\n" + msgstr "" + +-#: config/aarch64/aarch64.c:13936 ++#: config/aarch64/aarch64.c:14059 + #, fuzzy, gcc-internal-format + #| msgid "invalid mode for gen_tst_reg" + msgid "invalid format for sve_width" + msgstr "нерэчаісны рэжым для gen_tst_reg" + +-#: config/aarch64/aarch64.c:13948 ++#: config/aarch64/aarch64.c:14071 + #, fuzzy, gcc-internal-format, gfc-internal-format + #| msgid "invalid %%h value" + msgid "invalid sve_width value: %d" + msgstr "нерэчаіснае значэньне %%h" + +-#: config/aarch64/aarch64.c:13968 ++#: config/aarch64/aarch64.c:14091 + #, fuzzy, gcc-internal-format, gfc-internal-format + msgid "tuning string missing in option (%s)" + msgstr "Нераспазнаны выбар \"%s\"" + +-#: config/aarch64/aarch64.c:13986 ++#: config/aarch64/aarch64.c:14109 + #, fuzzy, gcc-internal-format, gfc-internal-format + msgid "unknown tuning option (%s)" + msgstr "невядомая назва рэгістра: %s\n" + +-#: config/aarch64/aarch64.c:14139 ++#: config/aarch64/aarch64.c:14262 + #, gcc-internal-format + msgid "incompatible options %<-mstack-protector-guard=global%> and %<-mstack-protector-guard-offset=%s%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14148 ++#: config/aarch64/aarch64.c:14271 + #, gcc-internal-format + msgid "both %<-mstack-protector-guard-offset%> and %<-mstack-protector-guard-reg%> must be used with %<-mstack-protector-guard=sysreg%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14156 ++#: config/aarch64/aarch64.c:14279 + #, gcc-internal-format + msgid "specify a system register with a small string length." + msgstr "" + +-#: config/aarch64/aarch64.c:14166 config/rs6000/rs6000.c:4307 ++#: config/aarch64/aarch64.c:14289 config/rs6000/rs6000.c:4385 + #, fuzzy, gcc-internal-format + msgid "%qs is not a valid offset in %qs" + msgstr "Нерэчаісны выбар %s" + +-#: config/aarch64/aarch64.c:14231 ++#: config/aarch64/aarch64.c:14354 + #, gcc-internal-format + msgid "only values 12 (4 KB) and 16 (64 KB) are supported for guard size. Given value %d (%llu KB) is out of range" + msgstr "" + +-#: config/aarch64/aarch64.c:14247 ++#: config/aarch64/aarch64.c:14370 + #, gcc-internal-format + msgid "stack clash guard size %<%d%> must be equal to probing interval %<%d%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14332 ++#: config/aarch64/aarch64.c:14455 + #, fuzzy, gcc-internal-format, gfc-internal-format + msgid "valid arguments are: %s;" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: config/aarch64/aarch64.c:14356 ++#: config/aarch64/aarch64.c:14479 + #, gcc-internal-format + msgid "missing cpu name in %<-mcpu=%s%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14363 ++#: config/aarch64/aarch64.c:14486 + #, gcc-internal-format + msgid "invalid feature modifier %qs in %<-mcpu=%s%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14471 ++#: config/aarch64/aarch64.c:14594 + #, gcc-internal-format + msgid "invalid argument %<%s%> for %<-mbranch-protection=%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14473 ++#: config/aarch64/aarch64.c:14596 + #, fuzzy, gcc-internal-format + msgid "missing argument for %<-mbranch-protection=%>" + msgstr "аргумент для \"%s\" прапушчан" + +-#: config/aarch64/aarch64.c:14497 ++#: config/aarch64/aarch64.c:14620 + #, gcc-internal-format + msgid "missing arch name in %<-march=%s%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14500 ++#: config/aarch64/aarch64.c:14623 + #, gcc-internal-format + msgid "unknown value %qs for %<-march%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14504 ++#: config/aarch64/aarch64.c:14627 + #, gcc-internal-format + msgid "invalid feature modifier %qs in %<-march=%s%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14532 ++#: config/aarch64/aarch64.c:14655 + #, gcc-internal-format + msgid "missing cpu name in %<-mtune=%s%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14535 ++#: config/aarch64/aarch64.c:14658 + #, gcc-internal-format + msgid "unknown value %qs for %<-mtune%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14666 config/arm/arm.c:3251 ++#: config/aarch64/aarch64.c:14789 config/arm/arm.c:3252 + #, gcc-internal-format + msgid "switch %<-mcpu=%s%> conflicts with %<-march=%s%> switch" + msgstr "" + +-#: config/aarch64/aarch64.c:14722 ++#: config/aarch64/aarch64.c:14845 + #, fuzzy, gcc-internal-format + #| msgid "%s does not support %s" + msgid "assembler does not support %<-mabi=ilp32%>" + msgstr "%s не падтрымлівае %s" + +-#: config/aarch64/aarch64.c:14729 ++#: config/aarch64/aarch64.c:14852 + #, gcc-internal-format + msgid "return address signing is only supported for %<-mabi=lp64%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14801 ++#: config/aarch64/aarch64.c:14924 + #, gcc-internal-format + msgid "code model %qs with %<-f%s%>" + msgstr "" + +-#: config/aarch64/aarch64.c:14804 ++#: config/aarch64/aarch64.c:14927 + #, fuzzy, gcc-internal-format + msgid "code model %qs not supported in ilp32 mode" + msgstr "-pipe не падтрымліваецца" + +-#: config/aarch64/aarch64.c:14975 ++#: config/aarch64/aarch64.c:15098 + #, gcc-internal-format + msgid "missing name in % pragma or attribute" + msgstr "" + +-#: config/aarch64/aarch64.c:14978 ++#: config/aarch64/aarch64.c:15101 + #, gcc-internal-format + msgid "invalid name (\"%s\") in % pragma or attribute" + msgstr "" + +-#: config/aarch64/aarch64.c:14982 config/aarch64/aarch64.c:15024 +-#: config/aarch64/aarch64.c:15131 ++#: config/aarch64/aarch64.c:15105 config/aarch64/aarch64.c:15147 ++#: config/aarch64/aarch64.c:15254 + #, gcc-internal-format + msgid "invalid feature modifier %s of value (\"%s\") in % pragma or attribute" + msgstr "" + +-#: config/aarch64/aarch64.c:15017 ++#: config/aarch64/aarch64.c:15140 + #, gcc-internal-format + msgid "missing name in % pragma or attribute" + msgstr "" + +-#: config/aarch64/aarch64.c:15020 ++#: config/aarch64/aarch64.c:15143 + #, gcc-internal-format + msgid "invalid name (\"%s\") in % pragma or attribute" + msgstr "" + +-#: config/aarch64/aarch64.c:15047 ++#: config/aarch64/aarch64.c:15170 + #, gcc-internal-format + msgid "missing argument to % pragma or attribute" + msgstr "" + +-#: config/aarch64/aarch64.c:15051 ++#: config/aarch64/aarch64.c:15174 + #, gcc-internal-format + msgid "invalid protection type (\"%s\") in % pragma or attribute" + msgstr "" + +-#: config/aarch64/aarch64.c:15086 ++#: config/aarch64/aarch64.c:15209 + #, gcc-internal-format + msgid "invalid name (\"%s\") in % pragma or attribute" + msgstr "" + +-#: config/aarch64/aarch64.c:15127 ++#: config/aarch64/aarch64.c:15250 + #, gcc-internal-format + msgid "missing value in % pragma or attribute" + msgstr "" + +-#: config/aarch64/aarch64.c:15183 config/aarch64/aarch64.c:15356 ++#: config/aarch64/aarch64.c:15308 config/aarch64/aarch64.c:15481 + #, gcc-internal-format + msgid "malformed % pragma or attribute" + msgstr "" + +-#: config/aarch64/aarch64.c:15227 ++#: config/aarch64/aarch64.c:15352 + #, gcc-internal-format + msgid "pragma or attribute % does not accept an argument" + msgstr "" + +-#: config/aarch64/aarch64.c:15235 ++#: config/aarch64/aarch64.c:15360 + #, gcc-internal-format + msgid "pragma or attribute % does not allow a negated form" + msgstr "" + +-#: config/aarch64/aarch64.c:15289 ++#: config/aarch64/aarch64.c:15414 + #, gcc-internal-format + msgid "pragma or attribute % is not valid" + msgstr "" + +-#: config/aarch64/aarch64.c:15346 config/arm/arm.c:32215 +-#: config/rs6000/rs6000.c:23178 config/s390/s390.c:15518 ++#: config/aarch64/aarch64.c:15471 config/arm/arm.c:32390 ++#: config/rs6000/rs6000.c:23428 config/s390/s390.c:15584 + #, gcc-internal-format + msgid "attribute % argument not a string" + msgstr "" + +-#: config/aarch64/aarch64.c:15373 ++#: config/aarch64/aarch64.c:15498 + #, gcc-internal-format + msgid "pragma or attribute % is not valid" + msgstr "" + +-#: config/aarch64/aarch64.c:15382 ++#: config/aarch64/aarch64.c:15507 + #, gcc-internal-format + msgid "malformed % pragma or attribute" + msgstr "" + +-#: config/aarch64/aarch64.c:16759 config/rs6000/rs6000-call.c:5747 +-#, gcc-internal-format +-msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 in GCC 10.1" ++#: config/aarch64/aarch64.c:16925 config/arm/arm.c:6425 ++#: config/rs6000/rs6000-call.c:5777 config/s390/s390.c:11970 ++#: config/s390/s390.c:12047 ++msgid "parameter passing for argument of type %qT with %<[[no_unique_address]]%> members changed %{in GCC 10.1%}" ++msgstr "" ++ ++#: config/aarch64/aarch64.c:16930 config/arm/arm.c:6430 ++#: config/rs6000/rs6000-call.c:5772 config/s390/s390.c:11965 ++#: config/s390/s390.c:12042 ++msgid "parameter passing for argument of type %qT when C++17 is enabled changed to match C++14 %{in GCC 10.1%}" + msgstr "" + +-#: config/aarch64/aarch64.c:17832 ++#: config/aarch64/aarch64.c:18004 + #, gcc-internal-format + msgid "%Klane %wd out of range %wd - %wd" + msgstr "" + +-#: config/aarch64/aarch64.c:17834 ++#: config/aarch64/aarch64.c:18006 + #, gcc-internal-format + msgid "lane %wd out of range %wd - %wd" + msgstr "" + +-#: config/aarch64/aarch64.c:22440 config/i386/i386.c:22138 ++#: config/aarch64/aarch64.c:22613 config/i386/i386.c:22138 + #: config/i386/i386.c:22265 + #, fuzzy, gcc-internal-format, gfc-internal-format + #| msgid "unsupported version" + msgid "unsupported simdlen %d" + msgstr "непадтрымліваемая версія" + +-#: config/aarch64/aarch64.c:22450 config/aarch64/aarch64.c:22471 ++#: config/aarch64/aarch64.c:22623 config/aarch64/aarch64.c:22644 + #, gcc-internal-format + msgid "GCC does not currently support mixed size types for % functions" + msgstr "" + +-#: config/aarch64/aarch64.c:22454 ++#: config/aarch64/aarch64.c:22627 + #, gcc-internal-format + msgid "GCC does not currently support return type %qT for % functions" + msgstr "" + +-#: config/aarch64/aarch64.c:22458 ++#: config/aarch64/aarch64.c:22631 + #, gcc-internal-format + msgid "unsupported return type %qT for % functions" + msgstr "" + +-#: config/aarch64/aarch64.c:22475 ++#: config/aarch64/aarch64.c:22648 + #, gcc-internal-format + msgid "GCC does not currently support argument type %qT for % functions" + msgstr "" + +-#: config/aarch64/aarch64.c:22497 ++#: config/aarch64/aarch64.c:22670 + #, gcc-internal-format + msgid "GCC does not currently support simdlen %d for type %qT" + msgstr "" +@@ -33744,17 +33790,17 @@ msgstr "аргумент `__builtin_args_info' павінен быць канс + msgid "argument of %qE attribute is not \"ilink\" or \"firq\"" + msgstr "аргумент `__builtin_args_info' павінен быць канстантай" + +-#: config/arc/arc.c:2130 config/arm/arm.c:7117 config/arm/arm.c:7135 +-#: config/arm/arm.c:7311 config/avr/avr.c:9695 config/avr/avr.c:9711 ++#: config/arc/arc.c:2130 config/arm/arm.c:7214 config/arm/arm.c:7232 ++#: config/arm/arm.c:7408 config/avr/avr.c:9695 config/avr/avr.c:9711 + #: config/bfin/bfin.c:4693 config/bfin/bfin.c:4754 config/bfin/bfin.c:4783 + #: config/csky/csky.c:6006 config/csky/csky.c:6034 + #: config/epiphany/epiphany.c:491 config/gcn/gcn.c:323 +-#: config/h8300/h8300.c:5323 config/i386/i386-options.c:3264 +-#: config/i386/i386-options.c:3441 config/i386/i386-options.c:3497 +-#: config/i386/i386-options.c:3548 config/i386/i386-options.c:3585 ++#: config/h8300/h8300.c:5323 config/i386/i386-options.c:3268 ++#: config/i386/i386-options.c:3445 config/i386/i386-options.c:3501 ++#: config/i386/i386-options.c:3552 config/i386/i386-options.c:3589 + #: config/m68k/m68k.c:792 config/mcore/mcore.c:3066 config/nvptx/nvptx.c:5053 +-#: config/riscv/riscv.c:2924 config/rl78/rl78.c:820 config/rl78/rl78.c:889 +-#: config/rs6000/rs6000.c:19253 config/rx/rx.c:2719 config/rx/rx.c:2745 ++#: config/riscv/riscv.c:2932 config/rl78/rl78.c:820 config/rl78/rl78.c:889 ++#: config/rs6000/rs6000.c:19500 config/rx/rx.c:2719 config/rx/rx.c:2745 + #: config/s390/s390.c:1054 config/s390/s390.c:1141 config/sh/sh.c:8428 + #: config/sh/sh.c:8446 config/sh/sh.c:8470 config/sh/sh.c:8541 + #: config/sh/sh.c:8564 config/stormy16/stormy16.c:2229 config/v850/v850.c:2010 +@@ -33906,12 +33952,12 @@ msgstr "" + msgid "invalid type for % flag output" + msgstr "" + +-#: config/arm/arm-builtins.c:3087 ++#: config/arm/arm-builtins.c:3096 + #, gcc-internal-format + msgid "%Kcoprocessor %d is not enabled with +cdecp%d" + msgstr "" + +-#: config/arm/arm-builtins.c:3090 ++#: config/arm/arm-builtins.c:3099 + #, gcc-internal-format + msgid "%Kcoproc must be a constant immediate in range [0-%d] enabled with +cdecp" + msgstr "" +@@ -33919,198 +33965,198 @@ msgstr "" + #. Here we mention the builtin name to follow the same + #. format that the C/C++ frontends use for referencing + #. a given argument index. +-#: config/arm/arm-builtins.c:3098 ++#: config/arm/arm-builtins.c:3107 + #, gcc-internal-format + msgid "%Kargument %d to %qE must be a constant immediate in range [0-%d]" + msgstr "" + +-#: config/arm/arm-builtins.c:3216 ++#: config/arm/arm-builtins.c:3225 + #, fuzzy, gcc-internal-format + msgid "this builtin is not supported for this target" + msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай" + +-#: config/arm/arm-builtins.c:3323 ++#: config/arm/arm-builtins.c:3332 + #, gcc-internal-format + msgid "%Ksaturation bit range must be in the range [%wd, %wd]" + msgstr "" + +-#: config/arm/arm-builtins.c:3327 ++#: config/arm/arm-builtins.c:3336 + #, gcc-internal-format + msgid "%Ksaturation bit range must be a constant immediate" + msgstr "" + +-#: config/arm/arm-builtins.c:3350 ++#: config/arm/arm-builtins.c:3359 + #, gcc-internal-format + msgid "You must enable MVE instructions to use these intrinsics" + msgstr "" + +-#: config/arm/arm-builtins.c:3372 ++#: config/arm/arm-builtins.c:3381 + #, gcc-internal-format + msgid "You must enable NEON instructions (e.g. %<-mfloat-abi=softfp%> %<-mfpu=neon%>) to use these intrinsics." + msgstr "" + +-#: config/arm/arm-builtins.c:3394 ++#: config/arm/arm-builtins.c:3403 + #, gcc-internal-format + msgid "You must enable VFP instructions to use these intrinsics." + msgstr "" + +-#: config/arm/arm-builtins.c:3472 ++#: config/arm/arm-builtins.c:3481 + #, gcc-internal-format + msgid "You must enable crypto instructions (e.g. include %<-mfloat-abi=softfp%> %<-mfpu=crypto-neon%>) to use these intrinsics." + msgstr "" + + #. @@@ better error message +-#: config/arm/arm-builtins.c:3550 config/arm/arm-builtins.c:3654 ++#: config/arm/arm-builtins.c:3559 config/arm/arm-builtins.c:3663 + #, gcc-internal-format + msgid "selector must be an immediate" + msgstr "" + +-#: config/arm/arm-builtins.c:3558 config/arm/arm-builtins.c:3603 +-#: config/arm/arm-builtins.c:3661 config/arm/arm-builtins.c:3670 ++#: config/arm/arm-builtins.c:3567 config/arm/arm-builtins.c:3612 ++#: config/arm/arm-builtins.c:3670 config/arm/arm-builtins.c:3679 + #, fuzzy, gcc-internal-format + #| msgid "first argument of `%s' should be `int'" + msgid "the range of selector should be in 0 to 7" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/arm/arm-builtins.c:3563 config/arm/arm-builtins.c:3672 ++#: config/arm/arm-builtins.c:3572 config/arm/arm-builtins.c:3681 + #, fuzzy, gcc-internal-format + #| msgid "first argument of `%s' should be `int'" + msgid "the range of selector should be in 0 to 3" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/arm/arm-builtins.c:3568 config/arm/arm-builtins.c:3674 ++#: config/arm/arm-builtins.c:3577 config/arm/arm-builtins.c:3683 + #, fuzzy, gcc-internal-format + #| msgid "first argument of `%s' should be `int'" + msgid "the range of selector should be in 0 to 1" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/arm/arm-builtins.c:3740 ++#: config/arm/arm-builtins.c:3749 + #, gcc-internal-format + msgid "mask must be an immediate" + msgstr "" + +-#: config/arm/arm-builtins.c:3745 ++#: config/arm/arm-builtins.c:3754 + #, fuzzy, gcc-internal-format + #| msgid "first argument of `%s' should be `int'" + msgid "the range of mask should be in 0 to 255" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/arm/arm-builtins.c:3933 ++#: config/arm/arm-builtins.c:3942 + #, gcc-internal-format + msgid "the range of count should be in 0 to 32. please check the intrinsic _mm_rori_pi16 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3935 ++#: config/arm/arm-builtins.c:3944 + #, gcc-internal-format + msgid "the range of count should be in 0 to 32. please check the intrinsic _mm_rori_pi32 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3937 ++#: config/arm/arm-builtins.c:3946 + #, gcc-internal-format + msgid "the range of count should be in 0 to 32. please check the intrinsic _mm_ror_pi16 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3939 ++#: config/arm/arm-builtins.c:3948 + #, gcc-internal-format + msgid "the range of count should be in 0 to 32. please check the intrinsic _mm_ror_pi32 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3945 ++#: config/arm/arm-builtins.c:3954 + #, gcc-internal-format + msgid "the range of count should be in 0 to 64. please check the intrinsic _mm_rori_si64 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3947 ++#: config/arm/arm-builtins.c:3956 + #, gcc-internal-format + msgid "the range of count should be in 0 to 64. please check the intrinsic _mm_ror_si64 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3952 ++#: config/arm/arm-builtins.c:3961 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_srli_pi16 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3954 ++#: config/arm/arm-builtins.c:3963 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_srli_pi32 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3956 ++#: config/arm/arm-builtins.c:3965 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_srli_si64 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3958 ++#: config/arm/arm-builtins.c:3967 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_slli_pi16 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3960 ++#: config/arm/arm-builtins.c:3969 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_slli_pi32 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3962 ++#: config/arm/arm-builtins.c:3971 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_slli_si64 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3964 ++#: config/arm/arm-builtins.c:3973 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_srai_pi16 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3966 ++#: config/arm/arm-builtins.c:3975 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_srai_pi32 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3968 ++#: config/arm/arm-builtins.c:3977 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_srai_si64 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3970 ++#: config/arm/arm-builtins.c:3979 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_srl_pi16 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3972 ++#: config/arm/arm-builtins.c:3981 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_srl_pi32 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3974 ++#: config/arm/arm-builtins.c:3983 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_srl_si64 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3976 ++#: config/arm/arm-builtins.c:3985 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_sll_pi16 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3978 ++#: config/arm/arm-builtins.c:3987 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_sll_pi32 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3980 ++#: config/arm/arm-builtins.c:3989 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_sll_si64 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3982 ++#: config/arm/arm-builtins.c:3991 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_sra_pi16 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3984 ++#: config/arm/arm-builtins.c:3993 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_sra_pi32 in code." + msgstr "" + +-#: config/arm/arm-builtins.c:3986 ++#: config/arm/arm-builtins.c:3995 + #, gcc-internal-format + msgid "the count should be no less than 0. please check the intrinsic _mm_sra_si64 in code." + msgstr "" +@@ -34120,283 +34166,283 @@ msgstr "" + msgid "argument %u to function %qE is of type %qT which is not known to be 128 bits wide" + msgstr "" + +-#: config/arm/arm.c:2911 ++#: config/arm/arm.c:2912 + #, gcc-internal-format + msgid "iWMMXt and NEON are incompatible" + msgstr "" + +-#: config/arm/arm.c:2917 ++#: config/arm/arm.c:2918 + #, fuzzy, gcc-internal-format + msgid "target CPU does not support ARM mode" + msgstr "ISO C не падтрымлівае комлексныя цэлалікавыя тыпы" + +-#: config/arm/arm.c:2921 ++#: config/arm/arm.c:2922 + #, gcc-internal-format + msgid "enabling backtrace support is only meaningful when compiling for the Thumb" + msgstr "" + +-#: config/arm/arm.c:2924 ++#: config/arm/arm.c:2925 + #, gcc-internal-format + msgid "enabling callee interworking support is only meaningful when compiling for the Thumb" + msgstr "" + +-#: config/arm/arm.c:2932 ++#: config/arm/arm.c:2933 + #, gcc-internal-format + msgid "%<-g%> with %<-mno-apcs-frame%> may not give sensible debugging" + msgstr "" + +-#: config/arm/arm.c:2937 ++#: config/arm/arm.c:2938 + #, gcc-internal-format + msgid "iWMMXt unsupported under Thumb mode" + msgstr "" + +-#: config/arm/arm.c:2940 ++#: config/arm/arm.c:2941 + #, gcc-internal-format + msgid "cannot use %<-mtp=cp15%> with 16-bit Thumb" + msgstr "" + +-#: config/arm/arm.c:2944 ++#: config/arm/arm.c:2945 + #, gcc-internal-format + msgid "RTP PIC is incompatible with Thumb" + msgstr "" + +-#: config/arm/arm.c:2957 ++#: config/arm/arm.c:2958 + #, gcc-internal-format, gfc-internal-format + msgid "%s only supports non-pic code on M-profile targets with the MOVT instruction" + msgstr "" + +-#: config/arm/arm.c:2962 ++#: config/arm/arm.c:2963 + #, gcc-internal-format, gfc-internal-format + msgid "%s only supports non-pic code on M-profile targets" + msgstr "" + +-#: config/arm/arm.c:2967 ++#: config/arm/arm.c:2968 + #, gcc-internal-format + msgid "%s incompatible with %<-mword-relocations%>" + msgstr "" + +-#: config/arm/arm.c:3082 ++#: config/arm/arm.c:3083 + #, fuzzy, gcc-internal-format + msgid "target CPU does not support THUMB instructions" + msgstr "ISO C не падтрымлівае комлексныя цэлалікавыя тыпы" + +-#: config/arm/arm.c:3132 ++#: config/arm/arm.c:3133 + #, fuzzy, gcc-internal-format + msgid "target CPU does not support unaligned accesses" + msgstr "ISO C не падтрымлівае комлексныя цэлалікавыя тыпы" + +-#: config/arm/arm.c:3481 ++#: config/arm/arm.c:3482 + #, gcc-internal-format + msgid "%<-mapcs-stack-check%> incompatible with %<-mno-apcs-frame%>" + msgstr "" + +-#: config/arm/arm.c:3490 ++#: config/arm/arm.c:3491 + #, gcc-internal-format + msgid "%<-fpic%> and %<-mapcs-reent%> are incompatible" + msgstr "" + +-#: config/arm/arm.c:3493 ++#: config/arm/arm.c:3494 + #, gcc-internal-format + msgid "APCS reentrant code not supported. Ignored" + msgstr "" + +-#: config/arm/arm.c:3516 ++#: config/arm/arm.c:3517 + #, gcc-internal-format + msgid "option %<-mstructure-size-boundary%> is deprecated" + msgstr "" + +-#: config/arm/arm.c:3524 ++#: config/arm/arm.c:3525 + #, gcc-internal-format + msgid "structure size boundary can only be set to 8, 32 or 64" + msgstr "" + +-#: config/arm/arm.c:3526 ++#: config/arm/arm.c:3527 + #, gcc-internal-format + msgid "structure size boundary can only be set to 8 or 32" + msgstr "" + +-#: config/arm/arm.c:3551 ++#: config/arm/arm.c:3552 + #, gcc-internal-format + msgid "RTP PIC is incompatible with %<-msingle-pic-base%>" + msgstr "" + +-#: config/arm/arm.c:3563 config/arm/arm.c:32229 ++#: config/arm/arm.c:3564 config/arm/arm.c:32404 + #, gcc-internal-format + msgid "FDPIC mode is not supported in Thumb-1 mode" + msgstr "" + +-#: config/arm/arm.c:3571 ++#: config/arm/arm.c:3572 + #, gcc-internal-format + msgid "%<-mpic-register=%> is useless without %<-fpic%>" + msgstr "" + +-#: config/arm/arm.c:3580 ++#: config/arm/arm.c:3581 + #, gcc-internal-format + msgid "unable to use %qs for PIC register" + msgstr "" + +-#: config/arm/arm.c:3602 config/pru/pru.c:643 ++#: config/arm/arm.c:3603 config/pru/pru.c:643 + #, fuzzy, gcc-internal-format + msgid "%<-freorder-blocks-and-partition%> not supported on this architecture" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: config/arm/arm.c:3746 ++#: config/arm/arm.c:3747 + #, gcc-internal-format + msgid "selected fp16 options are incompatible" + msgstr "" + +-#: config/arm/arm.c:3798 ++#: config/arm/arm.c:3799 + #, gcc-internal-format + msgid "iwmmxt requires an AAPCS compatible ABI for proper operation" + msgstr "" + +-#: config/arm/arm.c:3801 ++#: config/arm/arm.c:3802 + #, gcc-internal-format + msgid "iwmmxt abi requires an iwmmxt capable cpu" + msgstr "" + +-#: config/arm/arm.c:3809 ++#: config/arm/arm.c:3810 + #, gcc-internal-format + msgid "target CPU does not support interworking" + msgstr "" + +-#: config/arm/arm.c:3822 ++#: config/arm/arm.c:3823 + #, gcc-internal-format + msgid "AAPCS does not support %<-mcaller-super-interworking%>" + msgstr "" + +-#: config/arm/arm.c:3825 ++#: config/arm/arm.c:3826 + #, gcc-internal-format + msgid "AAPCS does not support %<-mcallee-super-interworking%>" + msgstr "" + +-#: config/arm/arm.c:3830 ++#: config/arm/arm.c:3831 + #, gcc-internal-format + msgid "__fp16 and no ldrh" + msgstr "" + +-#: config/arm/arm.c:3833 ++#: config/arm/arm.c:3834 + #, fuzzy, gcc-internal-format + msgid "target CPU does not support ARMv8-M Security Extensions" + msgstr "ISO C не падтрымлівае комлексныя цэлалікавыя тыпы" + +-#: config/arm/arm.c:3838 ++#: config/arm/arm.c:3839 + #, gcc-internal-format + msgid "ARMv8-M Security Extensions incompatible with selected FPU" + msgstr "" + +-#: config/arm/arm.c:3850 ++#: config/arm/arm.c:3851 + #, gcc-internal-format + msgid "%<-mfloat-abi=hard%>: selected processor lacks an FPU" + msgstr "" + +-#: config/arm/arm.c:3858 ++#: config/arm/arm.c:3859 + #, gcc-internal-format + msgid "%<-mfloat-abi=hard%> and VFP" + msgstr "" + +-#: config/arm/arm.c:6098 ++#: config/arm/arm.c:6099 + #, gcc-internal-format + msgid "non-AAPCS derived PCS variant" + msgstr "" + +-#: config/arm/arm.c:6100 ++#: config/arm/arm.c:6101 + #, gcc-internal-format + msgid "variadic functions must use the base AAPCS variant" + msgstr "" + +-#: config/arm/arm.c:6120 ++#: config/arm/arm.c:6121 + #, gcc-internal-format + msgid "PCS variant" + msgstr "" + +-#: config/arm/arm.c:6318 ++#: config/arm/arm.c:6373 + #, gcc-internal-format + msgid "Thumb-1 hard-float VFP ABI" + msgstr "" + +-#: config/arm/arm.c:6378 ++#: config/arm/arm.c:6462 + #, gcc-internal-format + msgid "argument of type %qT not permitted with -mgeneral-regs-only" + msgstr "" + +-#: config/arm/arm.c:6762 config/arm/arm.c:6970 config/arm/arm.c:7003 +-#: config/arm/arm.c:28376 ++#: config/arm/arm.c:6846 config/arm/arm.c:7067 config/arm/arm.c:7100 ++#: config/arm/arm.c:28551 + #, gcc-internal-format + msgid "parameter passing for argument of type %qT changed in GCC 7.1" + msgstr "" + +-#: config/arm/arm.c:7260 ++#: config/arm/arm.c:7357 + #, gcc-internal-format + msgid "%qE attribute not available to functions with arguments passed on the stack" + msgstr "" + +-#: config/arm/arm.c:7272 ++#: config/arm/arm.c:7369 + #, gcc-internal-format + msgid "%qE attribute not available to functions with variable number of arguments" + msgstr "" + +-#: config/arm/arm.c:7281 ++#: config/arm/arm.c:7378 + #, gcc-internal-format + msgid "%qE attribute not available to functions that return value on the stack" + msgstr "" + +-#: config/arm/arm.c:7303 config/arm/arm.c:7355 ++#: config/arm/arm.c:7400 config/arm/arm.c:7452 + #, fuzzy, gcc-internal-format + msgid "%qE attribute ignored without %<-mcmse%> option." + msgstr "\"%s\" атрыбут ігнарыруецца" + +-#: config/arm/arm.c:7322 ++#: config/arm/arm.c:7419 + #, gcc-internal-format + msgid "%qE attribute has no effect on functions with static linkage" + msgstr "" + +-#: config/arm/arm.c:7371 ++#: config/arm/arm.c:7468 + #, fuzzy, gcc-internal-format + msgid "%qE attribute only applies to base type of a function pointer" + msgstr "\"%s\" звычайна функцыя" + +-#: config/arm/arm.c:9322 ++#: config/arm/arm.c:9423 + #, gcc-internal-format + msgid "accessing thread-local storage is not currently supported with %<-mpure-code%> or %<-mslow-flash-data%>" + msgstr "" + +-#: config/arm/arm.c:13060 ++#: config/arm/arm.c:13161 + #, gcc-internal-format + msgid "%K%s %wd out of range %wd - %wd" + msgstr "" + +-#: config/arm/arm.c:13063 ++#: config/arm/arm.c:13164 + #, gcc-internal-format + msgid "%s %wd out of range %wd - %wd" + msgstr "" + +-#: config/arm/arm.c:25234 ++#: config/arm/arm.c:25409 + #, gcc-internal-format + msgid "unable to compute real location of stacked parameter" + msgstr "" + +-#: config/arm/arm.c:25896 ++#: config/arm/arm.c:26071 + #, gcc-internal-format + msgid "Unexpected thumb1 far jump" + msgstr "" + +-#: config/arm/arm.c:26155 ++#: config/arm/arm.c:26330 + #, gcc-internal-format + msgid "no low registers available for popping high registers" + msgstr "" + +-#: config/arm/arm.c:26407 ++#: config/arm/arm.c:26582 + #, gcc-internal-format + msgid "interrupt Service Routines cannot be coded in Thumb mode" + msgstr "" + +-#: config/arm/arm.c:26653 ++#: config/arm/arm.c:26828 + #, gcc-internal-format + msgid "%<-fstack-check=specific%> for Thumb-1" + msgstr "" + +-#: config/arm/arm.c:32244 ++#: config/arm/arm.c:32419 + #, gcc-internal-format + msgid "invalid fpu for target attribute or pragma %qs" + msgstr "" +@@ -34404,23 +34450,23 @@ msgstr "" + #. This doesn't really make sense until we support + #. general dynamic selection of the architecture and all + #. sub-features. +-#: config/arm/arm.c:32252 ++#: config/arm/arm.c:32427 + #, gcc-internal-format + msgid "auto fpu selection not currently permitted here" + msgstr "" + +-#: config/arm/arm.c:32265 ++#: config/arm/arm.c:32440 + #, gcc-internal-format + msgid "invalid architecture for target attribute or pragma %qs" + msgstr "" + +-#: config/arm/arm.c:32279 ++#: config/arm/arm.c:32454 + #, fuzzy, gcc-internal-format + #| msgid "unknown register name: %s" + msgid "unknown target attribute or pragma %qs" + msgstr "невядомая назва рэгістра: %s" + +-#: config/arm/arm.c:33257 ++#: config/arm/arm.c:33432 + #, fuzzy, gcc-internal-format + msgid "asm flags not supported in thumb1 mode" + msgstr "-pipe не падтрымліваецца" +@@ -34503,18 +34549,18 @@ msgstr "-pipe не падтрымліваецца" + msgid "%<-fPIE%> is not supported" + msgstr "-pipe не падтрымліваецца" + +-#: config/avr/avr.c:1040 config/avr/avr.c:1045 config/riscv/riscv.c:4920 ++#: config/avr/avr.c:1040 config/avr/avr.c:1045 config/riscv/riscv.c:4951 + #, gcc-internal-format + msgid "function attributes %qs and %qs are mutually exclusive" + msgstr "" + +-#: config/avr/avr.c:1066 config/riscv/riscv.c:4932 ++#: config/avr/avr.c:1066 config/riscv/riscv.c:4963 + #, fuzzy, gcc-internal-format + #| msgid "virtual functions cannot be friends" + msgid "%qs function cannot have arguments" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: config/avr/avr.c:1069 config/riscv/riscv.c:4929 ++#: config/avr/avr.c:1069 config/riscv/riscv.c:4960 + #, fuzzy, gcc-internal-format + #| msgid "function does not return string type" + msgid "%qs function cannot return a value" +@@ -34781,7 +34827,7 @@ msgid "indirect call in function, which are not supported by eBPF" + msgstr "" + + #: config/bpf/bpf.c:880 config/mips/mips.c:17025 config/nios2/nios2.c:3600 +-#: config/riscv/riscv-builtins.c:219 ++#: config/riscv/riscv-builtins.c:222 + #, fuzzy, gcc-internal-format + #| msgid "too many arguments to function" + msgid "invalid argument to built-in function" +@@ -35118,52 +35164,52 @@ msgstr "" + msgid "too many arguments passed in sgpr registers" + msgstr "вельмі шмат аргумэнтаў у функцыі `%s'" + +-#: config/gcn/gcn.c:2095 ++#: config/gcn/gcn.c:2096 + #, gcc-internal-format + msgid "A non-default set of initial values has been requested, which violates the ABI!" + msgstr "" + +-#: config/gcn/gcn.c:2331 ++#: config/gcn/gcn.c:2332 + #, fuzzy, gcc-internal-format, gfc-internal-format + msgid "wrong type of argument %s" + msgstr "не хапае аргументаў у функцыі" + +-#: config/gcn/gcn.c:3114 ++#: config/gcn/gcn.c:3115 + #, gcc-internal-format + msgid "nested function trampolines not supported on GCN5 due to non-executable stacks" + msgstr "" + +-#: config/gcn/gcn.c:3223 ++#: config/gcn/gcn.c:3224 + #, gcc-internal-format + msgid "TLS is not implemented for GCN." + msgstr "" + +-#: config/gcn/gcn.c:3834 ++#: config/gcn/gcn.c:3835 + #, gcc-internal-format + msgid "Builtin not implemented" + msgstr "" + +-#: config/gcn/gcn.c:4803 ++#: config/gcn/gcn.c:4804 + #, gcc-internal-format, gfc-internal-format + msgid "using vector_length (64), ignoring %d" + msgstr "" + +-#: config/gcn/gcn.c:4804 ++#: config/gcn/gcn.c:4805 + #, gcc-internal-format + msgid "using vector_length (64), ignoring runtime setting" + msgstr "" + +-#: config/gcn/gcn.c:4816 config/nvptx/nvptx.c:5688 ++#: config/gcn/gcn.c:4817 config/nvptx/nvptx.c:5688 + #, gcc-internal-format, gfc-internal-format + msgid "using num_workers (%d), ignoring %d" + msgstr "" + +-#: config/gcn/gcn.c:4844 config/gcn/gcn.c:4871 ++#: config/gcn/gcn.c:4845 config/gcn/gcn.c:4872 + #, gcc-internal-format, gfc-internal-format + msgid "offload dimension out of range (%d)" + msgstr "" + +-#: config/gcn/gcn.c:5299 ++#: config/gcn/gcn.c:5300 + #, gcc-internal-format + msgid "local data-share memory exhausted" + msgstr "" +@@ -35302,132 +35348,132 @@ msgstr "аргумент `__builtin_args_info' павінен быць канс + msgid "parameter to builtin not valid: %s" + msgstr "параметр \"%s\" ініцыялізаваны" + +-#: config/i386/i386-expand.c:7909 ++#: config/i386/i386-expand.c:7916 + #, gcc-internal-format + msgid "interrupt service routine cannot be called directly" + msgstr "" + +-#: config/i386/i386-expand.c:8313 config/i386/i386-expand.c:9776 ++#: config/i386/i386-expand.c:8320 config/i386/i386-expand.c:9783 + #, fuzzy, gcc-internal-format + msgid "the last argument must be a 2-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:8708 ++#: config/i386/i386-expand.c:8715 + #, fuzzy, gcc-internal-format + msgid "the fifth argument must be an 8-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:8803 ++#: config/i386/i386-expand.c:8810 + #, fuzzy, gcc-internal-format + msgid "the third argument must be an 8-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:9707 ++#: config/i386/i386-expand.c:9714 + #, fuzzy, gcc-internal-format + msgid "the last argument must be an 1-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:9722 ++#: config/i386/i386-expand.c:9729 + #, fuzzy, gcc-internal-format + msgid "the last argument must be a 3-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:9755 ++#: config/i386/i386-expand.c:9762 + #, fuzzy, gcc-internal-format + msgid "the last argument must be a 4-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:9795 ++#: config/i386/i386-expand.c:9802 + #, fuzzy, gcc-internal-format + msgid "the last argument must be a 1-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:9808 ++#: config/i386/i386-expand.c:9815 + #, fuzzy, gcc-internal-format + msgid "the last argument must be a 5-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:9818 ++#: config/i386/i386-expand.c:9825 + #, gcc-internal-format + msgid "the next to last argument must be an 8-bit immediate" + msgstr "" + +-#: config/i386/i386-expand.c:9823 config/i386/i386-expand.c:10729 ++#: config/i386/i386-expand.c:9830 config/i386/i386-expand.c:10736 + #, fuzzy, gcc-internal-format + msgid "the last argument must be an 8-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:9963 ++#: config/i386/i386-expand.c:9970 + #, fuzzy, gcc-internal-format + msgid "the third argument must be comparison constant" + msgstr "аргумент `__builtin_args_info' павінен быць канстантай" + +-#: config/i386/i386-expand.c:9968 ++#: config/i386/i386-expand.c:9975 + #, gcc-internal-format + msgid "incorrect comparison mode" + msgstr "" + +-#: config/i386/i386-expand.c:9974 config/i386/i386-expand.c:10294 ++#: config/i386/i386-expand.c:9981 config/i386/i386-expand.c:10301 + #, gcc-internal-format + msgid "incorrect rounding operand" + msgstr "" + +-#: config/i386/i386-expand.c:10276 ++#: config/i386/i386-expand.c:10283 + #, fuzzy, gcc-internal-format + msgid "the immediate argument must be a 4-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:10282 ++#: config/i386/i386-expand.c:10289 + #, fuzzy, gcc-internal-format + msgid "the immediate argument must be a 5-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:10285 ++#: config/i386/i386-expand.c:10292 + #, gcc-internal-format + msgid "the immediate argument must be an 8-bit immediate" + msgstr "" + +-#: config/i386/i386-expand.c:10727 ++#: config/i386/i386-expand.c:10734 + #, fuzzy, gcc-internal-format + msgid "the last argument must be a 32-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:10809 config/rs6000/rs6000-call.c:9814 ++#: config/i386/i386-expand.c:10816 config/rs6000/rs6000-call.c:10024 + #, gcc-internal-format + msgid "selector must be an integer constant in the range [0, %wi]" + msgstr "" + +-#: config/i386/i386-expand.c:11003 ++#: config/i386/i386-expand.c:11010 + #, gcc-internal-format + msgid "%qE needs unknown isa option" + msgstr "" + +-#: config/i386/i386-expand.c:11007 ++#: config/i386/i386-expand.c:11014 + #, fuzzy, gcc-internal-format + msgid "%qE needs isa option %s" + msgstr "Нерэчаісны выбар %s" + +-#: config/i386/i386-expand.c:11678 ++#: config/i386/i386-expand.c:11685 + #, fuzzy, gcc-internal-format + msgid "last argument must be an immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/i386/i386-expand.c:12434 config/i386/i386-expand.c:12646 ++#: config/i386/i386-expand.c:12441 config/i386/i386-expand.c:12653 + #, gcc-internal-format + msgid "the last argument must be scale 1, 2, 4, 8" + msgstr "" + +-#: config/i386/i386-expand.c:12699 ++#: config/i386/i386-expand.c:12706 + #, gcc-internal-format + msgid "the forth argument must be scale 1, 2, 4, 8" + msgstr "" + +-#: config/i386/i386-expand.c:12705 ++#: config/i386/i386-expand.c:12712 + #, gcc-internal-format + msgid "incorrect hint operand" + msgstr "" + +-#: config/i386/i386-expand.c:12724 ++#: config/i386/i386-expand.c:12731 + #, fuzzy, gcc-internal-format + msgid "the argument to % intrinsic must be an 8-bit immediate" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" +@@ -35810,145 +35856,145 @@ msgstr "" + msgid "%<-mindirect-branch=%s%> and %<-mcmodel=large%> are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3087 ++#: config/i386/i386-options.c:3089 + #, gcc-internal-format + msgid "%<-mindirect-branch%> and %<-fcf-protection%> are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3122 ++#: config/i386/i386-options.c:3124 + #, gcc-internal-format + msgid "%<-mfunction-return=%s%> and %<-mcmodel=large%> are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3130 ++#: config/i386/i386-options.c:3134 + #, gcc-internal-format + msgid "%<-mfunction-return%> and %<-fcf-protection%> are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3224 ++#: config/i386/i386-options.c:3228 + #, gcc-internal-format + msgid "%s instructions aren%'t allowed in an exception service routine" + msgstr "" + +-#: config/i386/i386-options.c:3226 ++#: config/i386/i386-options.c:3230 + #, gcc-internal-format + msgid "%s instructions aren%'t allowed in an interrupt service routine" + msgstr "" + +-#: config/i386/i386-options.c:3230 ++#: config/i386/i386-options.c:3234 + #, gcc-internal-format + msgid "%s instructions aren%'t allowed in a function with the % attribute" + msgstr "" + +-#: config/i386/i386-options.c:3277 config/i386/i386-options.c:3328 ++#: config/i386/i386-options.c:3281 config/i386/i386-options.c:3332 + #, gcc-internal-format + msgid "fastcall and regparm attributes are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3282 ++#: config/i386/i386-options.c:3286 + #, gcc-internal-format + msgid "regparam and thiscall attributes are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3289 config/i386/i386-options.c:3517 ++#: config/i386/i386-options.c:3293 config/i386/i386-options.c:3521 + #, gcc-internal-format + msgid "%qE attribute requires an integer constant argument" + msgstr "" + +-#: config/i386/i386-options.c:3295 ++#: config/i386/i386-options.c:3299 + #, fuzzy, gcc-internal-format + msgid "argument to %qE attribute larger than %d" + msgstr "памер \"%s\" больш чам %d байт" + +-#: config/i386/i386-options.c:3320 config/i386/i386-options.c:3363 ++#: config/i386/i386-options.c:3324 config/i386/i386-options.c:3367 + #, gcc-internal-format + msgid "fastcall and cdecl attributes are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3324 ++#: config/i386/i386-options.c:3328 + #, gcc-internal-format + msgid "fastcall and stdcall attributes are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3332 config/i386/i386-options.c:3381 ++#: config/i386/i386-options.c:3336 config/i386/i386-options.c:3385 + #, gcc-internal-format + msgid "fastcall and thiscall attributes are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3342 config/i386/i386-options.c:3359 ++#: config/i386/i386-options.c:3346 config/i386/i386-options.c:3363 + #, gcc-internal-format + msgid "stdcall and cdecl attributes are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3346 ++#: config/i386/i386-options.c:3350 + #, gcc-internal-format + msgid "stdcall and fastcall attributes are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3350 config/i386/i386-options.c:3377 ++#: config/i386/i386-options.c:3354 config/i386/i386-options.c:3381 + #, gcc-internal-format + msgid "stdcall and thiscall attributes are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3367 config/i386/i386-options.c:3385 ++#: config/i386/i386-options.c:3371 config/i386/i386-options.c:3389 + #, gcc-internal-format + msgid "cdecl and thiscall attributes are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3373 ++#: config/i386/i386-options.c:3377 + #, gcc-internal-format + msgid "%qE attribute is used for non-class method" + msgstr "" + +-#: config/i386/i386-options.c:3477 config/rs6000/rs6000.c:19366 ++#: config/i386/i386-options.c:3481 config/rs6000/rs6000.c:19613 + #, fuzzy, gcc-internal-format + #| msgid "`%s' attribute ignored" + msgid "%qE incompatible attribute ignored" + msgstr "\"%s\" атрыбут ігнарыруецца" + +-#: config/i386/i386-options.c:3504 ++#: config/i386/i386-options.c:3508 + #, fuzzy, gcc-internal-format + msgid "%qE attribute only available for 32-bit" + msgstr "\"%s\" атрыбут ігнарыруецца" + +-#: config/i386/i386-options.c:3525 ++#: config/i386/i386-options.c:3529 + #, fuzzy, gcc-internal-format + msgid "argument to %qE attribute is neither zero, nor one" + msgstr "аргумент `__builtin_args_info' павінен быць канстантай" + +-#: config/i386/i386-options.c:3559 config/i386/i386-options.c:3569 ++#: config/i386/i386-options.c:3563 config/i386/i386-options.c:3573 + #, gcc-internal-format + msgid "%qs and %qs attributes are not compatible" + msgstr "" + +-#: config/i386/i386-options.c:3596 config/i386/i386-options.c:3618 ++#: config/i386/i386-options.c:3600 config/i386/i386-options.c:3622 + #: config/ia64/ia64.c:812 config/s390/s390.c:1151 + #, fuzzy, gcc-internal-format + msgid "%qE attribute requires a string constant argument" + msgstr "аргумент `__builtin_args_info' павінен быць канстантай" + +-#: config/i386/i386-options.c:3606 config/i386/i386-options.c:3628 ++#: config/i386/i386-options.c:3610 config/i386/i386-options.c:3632 + #: config/s390/s390.c:1180 + #, fuzzy, gcc-internal-format + msgid "argument to %qE attribute is not (keep|thunk|thunk-inline|thunk-extern)" + msgstr "аргумент `__builtin_args_info' павінен быць канстантай" + +-#: config/i386/i386-options.c:3660 ++#: config/i386/i386-options.c:3664 + #, gcc-internal-format + msgid "interrupt service routine should have a pointer as the first argument" + msgstr "" + +-#: config/i386/i386-options.c:3667 ++#: config/i386/i386-options.c:3671 + #, gcc-internal-format + msgid "interrupt service routine should have %qs as the second argument" + msgstr "" + +-#: config/i386/i386-options.c:3678 ++#: config/i386/i386-options.c:3682 + #, gcc-internal-format + msgid "interrupt service routine can only have a pointer argument and an optional integer argument" + msgstr "" + +-#: config/i386/i386-options.c:3681 ++#: config/i386/i386-options.c:3685 + #, gcc-internal-format + msgid "interrupt service routine must return %" + msgstr "" +@@ -36399,7 +36445,7 @@ msgstr "" + msgid "%qE redeclared with conflicting %qs attributes" + msgstr "" + +-#: config/mips/mips.c:1511 config/mips/mips.c:1565 config/riscv/riscv.c:2952 ++#: config/mips/mips.c:1511 config/mips/mips.c:1565 config/riscv/riscv.c:2960 + #, gcc-internal-format + msgid "%qE attribute requires a string argument" + msgstr "" +@@ -37487,52 +37533,52 @@ msgstr "" + msgid "%<__delay_cycles%> is limited to 32-bit loop counts" + msgstr "" + +-#: config/riscv/riscv.c:354 ++#: config/riscv/riscv.c:362 + #, gcc-internal-format + msgid "unknown cpu %qs for %<-mtune%>" + msgstr "" + +-#: config/riscv/riscv.c:2572 config/riscv/riscv.c:2614 ++#: config/riscv/riscv.c:2580 config/riscv/riscv.c:2622 + #, gcc-internal-format + msgid "ABI for flattened struct with zero-length bit-fields changed in GCC 10" + msgstr "" + +-#: config/riscv/riscv.c:2963 ++#: config/riscv/riscv.c:2971 + #, fuzzy, gcc-internal-format + msgid "argument to %qE attribute is not \"user\", \"supervisor\", or \"machine\"" + msgstr "аргумент `__builtin_args_info' павінен быць канстантай" + +-#: config/riscv/riscv.c:4594 ++#: config/riscv/riscv.c:4625 + #, gcc-internal-format + msgid "%<-mdiv%> requires %<-march%> to subsume the % extension" + msgstr "" + +-#: config/riscv/riscv.c:4635 ++#: config/riscv/riscv.c:4666 + #, gcc-internal-format + msgid "requested ABI requires %<-march%> to subsume the %qc extension" + msgstr "" + +-#: config/riscv/riscv.c:4639 ++#: config/riscv/riscv.c:4670 + #, gcc-internal-format + msgid "rv32e requires ilp32e ABI" + msgstr "" + +-#: config/riscv/riscv.c:4643 ++#: config/riscv/riscv.c:4674 + #, gcc-internal-format + msgid "ABI requires %<-march=rv%d%>" + msgstr "" + +-#: config/riscv/riscv.c:4653 ++#: config/riscv/riscv.c:4684 + #, gcc-internal-format + msgid "%<-mpreferred-stack-boundary=%d%> must be between %d and %d" + msgstr "" + +-#: config/riscv/riscv.c:4666 ++#: config/riscv/riscv.c:4697 + #, gcc-internal-format + msgid "%<-mriscv-attribute%> RISC-V ELF attribute requires GNU as 2.32 [%<-mriscv-attribute%>]" + msgstr "" + +-#: config/riscv/riscv.c:4958 ++#: config/riscv/riscv.c:4989 + #, gcc-internal-format + msgid "%qs function cannot have different interrupt type" + msgstr "" +@@ -37651,325 +37697,326 @@ msgstr "" + msgid "junk at end of %<#pragma longcall%>" + msgstr "" + +-#: config/rs6000/rs6000-c.c:928 ++#: config/rs6000/rs6000-c.c:934 + #, gcc-internal-format + msgid "% is deprecated for little endian; use assignment for unaligned loads and stores" + msgstr "" + +-#: config/rs6000/rs6000-c.c:932 ++#: config/rs6000/rs6000-c.c:938 + #, gcc-internal-format + msgid "% is deprecated for little endian; use assignment for unaligned loads and stores" + msgstr "" + +-#: config/rs6000/rs6000-c.c:942 config/rs6000/rs6000-c.c:993 +-#: config/rs6000/rs6000-c.c:1263 config/rs6000/rs6000-c.c:1329 +-#: config/rs6000/rs6000-c.c:1695 config/rs6000/rs6000-c.c:1742 ++#: config/rs6000/rs6000-c.c:948 config/rs6000/rs6000-c.c:999 ++#: config/rs6000/rs6000-c.c:1269 config/rs6000/rs6000-c.c:1335 ++#: config/rs6000/rs6000-c.c:1701 config/rs6000/rs6000-c.c:1748 + #, gcc-internal-format + msgid "builtin %qs only accepts 2 arguments" + msgstr "" + +-#: config/rs6000/rs6000-c.c:1066 config/rs6000/rs6000-c.c:1149 +-#: config/rs6000/rs6000-c.c:1507 ++#: config/rs6000/rs6000-c.c:1072 config/rs6000/rs6000-c.c:1155 ++#: config/rs6000/rs6000-c.c:1513 + #, gcc-internal-format + msgid "builtin %qs only accepts 3 arguments" + msgstr "" + +-#: config/rs6000/rs6000-c.c:1258 ++#: config/rs6000/rs6000-c.c:1264 + #, gcc-internal-format + msgid "builtin %qs only accepts 1 argument" + msgstr "" + +-#: config/rs6000/rs6000-c.c:1634 ++#: config/rs6000/rs6000-c.c:1640 + #, gcc-internal-format + msgid "passing argument %d of %qE discards qualifiers from pointer target type" + msgstr "" + +-#: config/rs6000/rs6000-c.c:1833 ++#: config/rs6000/rs6000-c.c:1839 + #, gcc-internal-format + msgid "builtin %qs requires builtin %qs" + msgstr "" + +-#: config/rs6000/rs6000-c.c:1837 ++#: config/rs6000/rs6000-c.c:1843 + #, fuzzy, gcc-internal-format + msgid "%qs is not supported in this compiler configuration" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: config/rs6000/rs6000-c.c:1846 ++#: config/rs6000/rs6000-c.c:1852 + #, gcc-internal-format + msgid "invalid parameter combination for AltiVec intrinsic %qs" + msgstr "" + +-#: config/rs6000/rs6000-call.c:5845 ++#: config/rs6000/rs6000-call.c:5875 + #, gcc-internal-format + msgid "GCC vector returned by reference: non-standard ABI extension with no compatibility guarantee" + msgstr "" + +-#: config/rs6000/rs6000-call.c:6035 ++#: config/rs6000/rs6000-call.c:6065 + #, gcc-internal-format + msgid "cannot return value in vector register because altivec instructions are disabled, use %qs to enable them" + msgstr "" + +-#: config/rs6000/rs6000-call.c:6210 ++#: config/rs6000/rs6000-call.c:6240 + #, gcc-internal-format, gfc-internal-format + msgid "the ABI of passing aggregates with %d-byte alignment has changed in GCC 5" + msgstr "" + +-#: config/rs6000/rs6000-call.c:6480 ++#: config/rs6000/rs6000-call.c:6510 + #, gcc-internal-format + msgid "cannot pass argument in vector register because altivec instructions are disabled, use %qs to enable them" + msgstr "" + +-#: config/rs6000/rs6000-call.c:7220 ++#: config/rs6000/rs6000-call.c:7250 + #, gcc-internal-format + msgid "the ABI of passing homogeneous % aggregates has changed in GCC 5" + msgstr "" + +-#: config/rs6000/rs6000-call.c:7395 ++#: config/rs6000/rs6000-call.c:7425 + #, gcc-internal-format + msgid "GCC vector passed by reference: non-standard ABI extension with no compatibility guarantee" + msgstr "" + +-#: config/rs6000/rs6000-call.c:8187 ++#: config/rs6000/rs6000-call.c:8217 + #, gcc-internal-format + msgid "internal error: builtin function %qs already processed" + msgstr "" + +-#: config/rs6000/rs6000-call.c:8505 ++#: config/rs6000/rs6000-call.c:8588 + #, fuzzy, gcc-internal-format + msgid "%<__builtin_mffsl%> not supported with %<-msoft-float%>" + msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай" + +-#: config/rs6000/rs6000-call.c:8546 ++#: config/rs6000/rs6000-call.c:8629 + #, fuzzy, gcc-internal-format + msgid "argument 1 must be an 8-bit field value" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:8577 ++#: config/rs6000/rs6000-call.c:8660 + #, gcc-internal-format + msgid "%<__builtin_mtfsb0%> and %<__builtin_mtfsb1%> not supported with %<-msoft-float%>" + msgstr "" + +-#: config/rs6000/rs6000-call.c:8589 ++#: config/rs6000/rs6000-call.c:8672 + #, gcc-internal-format + msgid "Argument must be a constant between 0 and 31." + msgstr "" + +-#: config/rs6000/rs6000-call.c:8615 ++#: config/rs6000/rs6000-call.c:8698 + #, fuzzy, gcc-internal-format + msgid "%<__builtin_set_fpscr_rn%> not supported with %<-msoft-float%>" + msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай" + +-#: config/rs6000/rs6000-call.c:8630 ++#: config/rs6000/rs6000-call.c:8713 + #, gcc-internal-format + msgid "Argument must be a value between 0 and 3." + msgstr "" + +-#: config/rs6000/rs6000-call.c:8655 ++#: config/rs6000/rs6000-call.c:8738 + #, fuzzy, gcc-internal-format + msgid "%<__builtin_set_fpscr_drn%> is not supported in 32-bit mode" + msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай" + +-#: config/rs6000/rs6000-call.c:8660 ++#: config/rs6000/rs6000-call.c:8743 + #, fuzzy, gcc-internal-format + msgid "%<__builtin_set_fpscr_drn%> not supported with %<-msoft-float%>" + msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай" + +-#: config/rs6000/rs6000-call.c:8679 ++#: config/rs6000/rs6000-call.c:8762 + #, gcc-internal-format + msgid "Argument must be a value between 0 and 7." + msgstr "" + +-#: config/rs6000/rs6000-call.c:8720 ++#: config/rs6000/rs6000-call.c:8803 + #, fuzzy, gcc-internal-format + msgid "argument 1 must be a 5-bit signed literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:8804 ++#: config/rs6000/rs6000-call.c:8887 + #, fuzzy, gcc-internal-format + msgid "argument 2 must be a 1-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:8815 ++#: config/rs6000/rs6000-call.c:8898 + #, fuzzy, gcc-internal-format + msgid "argument 2 must be a 2-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:8826 ++#: config/rs6000/rs6000-call.c:8909 + #, fuzzy, gcc-internal-format + msgid "argument 2 must be a 3-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:8837 ++#: config/rs6000/rs6000-call.c:8920 + #, fuzzy, gcc-internal-format + msgid "argument 2 must be a 4-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:8851 ++#: config/rs6000/rs6000-call.c:8934 + #, fuzzy, gcc-internal-format + msgid "argument 2 must be a 5-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:8869 ++#: config/rs6000/rs6000-call.c:8952 + #, fuzzy, gcc-internal-format + msgid "argument 1 must be a 6-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:8885 ++#: config/rs6000/rs6000-call.c:8968 + #, fuzzy, gcc-internal-format + msgid "argument 2 must be a 7-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:8924 ++#: config/rs6000/rs6000-call.c:9007 + #, fuzzy, gcc-internal-format + msgid "argument 1 of %qs must be a constant" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:8982 ++#: config/rs6000/rs6000-call.c:9065 + #, fuzzy, gcc-internal-format + #| msgid "argument of `__builtin_args_info' out of range" + msgid "argument 1 of %qs is out of range" + msgstr "аргумент `__builtin_args_info' выйшаў за межы" + +-#: config/rs6000/rs6000-call.c:9255 +-#, gcc-internal-format +-msgid "builtin %qs is only valid in 64-bit mode" +-msgstr "" +- +-#: config/rs6000/rs6000-call.c:9304 ++#: config/rs6000/rs6000-call.c:9354 config/rs6000/rs6000-call.c:9514 + #, fuzzy, gcc-internal-format, gfc-internal-format + msgid "argument %d must be an unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:9306 ++#: config/rs6000/rs6000-call.c:9356 config/rs6000/rs6000-call.c:9516 + #, fuzzy, gcc-internal-format, gfc-internal-format + msgid "argument %d is an unsigned literal that is out of range" + msgstr "аргумент `__builtin_args_info' выйшаў за межы" + +-#: config/rs6000/rs6000-call.c:9451 ++#: config/rs6000/rs6000-call.c:9465 ++#, gcc-internal-format ++msgid "builtin %qs is only valid in 64-bit mode" ++msgstr "" ++ ++#: config/rs6000/rs6000-call.c:9661 + #, gcc-internal-format + msgid "builtin %qs only accepts a string argument" + msgstr "" + + #. Invalid CPU argument. +-#: config/rs6000/rs6000-call.c:9470 ++#: config/rs6000/rs6000-call.c:9680 + #, gcc-internal-format + msgid "cpu %qs is an invalid argument to builtin %qs" + msgstr "" + + #. Invalid HWCAP argument. +-#: config/rs6000/rs6000-call.c:9498 ++#: config/rs6000/rs6000-call.c:9708 + #, gcc-internal-format + msgid "%s %qs is an invalid argument to builtin %qs" + msgstr "" + +-#: config/rs6000/rs6000-call.c:9524 ++#: config/rs6000/rs6000-call.c:9734 + #, gcc-internal-format + msgid "builtin %qs needs GLIBC (2.23 and newer) that exports hardware capability bits" + msgstr "" + +-#: config/rs6000/rs6000-call.c:9577 ++#: config/rs6000/rs6000-call.c:9787 + #, fuzzy, gcc-internal-format + msgid "argument 3 must be a 4-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:9602 ++#: config/rs6000/rs6000-call.c:9812 + #, fuzzy, gcc-internal-format + msgid "argument 3 must be a 2-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:9622 ++#: config/rs6000/rs6000-call.c:9832 + #, fuzzy, gcc-internal-format + msgid "argument 3 must be a 1-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:9634 ++#: config/rs6000/rs6000-call.c:9844 + #, fuzzy, gcc-internal-format + msgid "argument 1 must be 0 or 2" + msgstr "аргумент для \"%s\" прапушчан" + +-#: config/rs6000/rs6000-call.c:9646 ++#: config/rs6000/rs6000-call.c:9856 + #, fuzzy, gcc-internal-format + msgid "argument 1 must be a 1-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:9660 ++#: config/rs6000/rs6000-call.c:9870 + #, fuzzy, gcc-internal-format + msgid "argument 2 must be a 6-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:9672 ++#: config/rs6000/rs6000-call.c:9882 + #, fuzzy, gcc-internal-format + msgid "argument 2 must be 0 or 1" + msgstr "аргумент для \"%s\" прапушчан" + +-#: config/rs6000/rs6000-call.c:9680 ++#: config/rs6000/rs6000-call.c:9890 + #, fuzzy, gcc-internal-format + msgid "argument 3 must be in the range [0, 15]" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:9747 config/rs6000/rs6000-call.c:10087 ++#: config/rs6000/rs6000-call.c:9957 config/rs6000/rs6000-call.c:10297 + #, fuzzy, gcc-internal-format + msgid "argument to %qs must be a 2-bit unsigned literal" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:9912 ++#: config/rs6000/rs6000-call.c:10122 + #, gcc-internal-format + msgid "unresolved overload for Altivec builtin %qF" + msgstr "" + +-#: config/rs6000/rs6000-call.c:10134 ++#: config/rs6000/rs6000-call.c:10344 + #, fuzzy, gcc-internal-format + #| msgid "second argument of `%s' should be `char **'" + msgid "second argument to %qs must be [0, 12]" + msgstr "другім аргументам \"%s\" павінен быць \"char **\"" + +-#: config/rs6000/rs6000-call.c:10149 ++#: config/rs6000/rs6000-call.c:10359 + #, fuzzy, gcc-internal-format + msgid "third argument to %qs must be [0, 12]" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/rs6000/rs6000-call.c:10343 ++#: config/rs6000/rs6000-call.c:10553 + #, gcc-internal-format + msgid "%qs is only valid for the cell processor" + msgstr "" + +-#: config/rs6000/rs6000-call.c:10345 config/rs6000/rs6000-call.c:10347 +-#: config/rs6000/rs6000-call.c:10349 config/rs6000/rs6000-call.c:10355 +-#: config/rs6000/rs6000-call.c:10357 config/rs6000/rs6000-call.c:10363 +-#: config/rs6000/rs6000-call.c:10369 config/rs6000/rs6000-call.c:10373 +-#: config/rs6000/rs6000-call.c:10375 config/rs6000/rs6000-call.c:10379 +-#: config/rs6000/rs6000-call.c:10383 ++#: config/rs6000/rs6000-call.c:10555 config/rs6000/rs6000-call.c:10557 ++#: config/rs6000/rs6000-call.c:10559 config/rs6000/rs6000-call.c:10565 ++#: config/rs6000/rs6000-call.c:10567 config/rs6000/rs6000-call.c:10573 ++#: config/rs6000/rs6000-call.c:10579 config/rs6000/rs6000-call.c:10581 ++#: config/rs6000/rs6000-call.c:10583 config/rs6000/rs6000-call.c:10587 ++#: config/rs6000/rs6000-call.c:10589 config/rs6000/rs6000-call.c:10593 ++#: config/rs6000/rs6000-call.c:10597 + #, gcc-internal-format + msgid "%qs requires the %qs option" + msgstr "" + +-#: config/rs6000/rs6000-call.c:10352 config/rs6000/rs6000-call.c:10360 +-#: config/rs6000/rs6000-call.c:10366 ++#: config/rs6000/rs6000-call.c:10562 config/rs6000/rs6000-call.c:10570 ++#: config/rs6000/rs6000-call.c:10576 + #, gcc-internal-format + msgid "%qs requires the %qs and %qs options" + msgstr "" + +-#: config/rs6000/rs6000-call.c:10381 ++#: config/rs6000/rs6000-call.c:10595 + #, gcc-internal-format + msgid "%qs requires ISA 3.0 IEEE 128-bit floating point" + msgstr "" + +-#: config/rs6000/rs6000-call.c:10386 ++#: config/rs6000/rs6000-call.c:10600 + #, gcc-internal-format + msgid "%qs requires the %qs (or newer), and %qs or %qs options" + msgstr "" + +-#: config/rs6000/rs6000-call.c:10389 ++#: config/rs6000/rs6000-call.c:10603 + #, gcc-internal-format + msgid "%qs is not supported with the current options" + msgstr "" + +-#: config/rs6000/rs6000-call.c:13016 ++#: config/rs6000/rs6000-call.c:13544 + #, gcc-internal-format + msgid "internal error: builtin function %qs had an unexpected return type %qs" + msgstr "" + +-#: config/rs6000/rs6000-call.c:13038 ++#: config/rs6000/rs6000-call.c:13566 + #, gcc-internal-format + msgid "internal error: builtin function %qs, argument %d had unexpected argument type %qs" + msgstr "" +@@ -37991,223 +38038,228 @@ msgstr "Не выкарыстоўваць рэгістра sb" + msgid "Stack frame larger than 2G is not supported for %<-fsplit-stack%>" + msgstr "" + +-#: config/rs6000/rs6000.c:3154 config/rs6000/rs6000.c:3157 +-#: config/rs6000/rs6000.c:3160 ++#: config/rs6000/rs6000.c:3217 config/rs6000/rs6000.c:3220 ++#: config/rs6000/rs6000.c:3223 + #, gcc-internal-format + msgid "%qs requires %qs or %qs" + msgstr "" + +-#: config/rs6000/rs6000.c:3261 ++#: config/rs6000/rs6000.c:3324 + #, gcc-internal-format + msgid "%qs requires PowerPC64 architecture, enabling" + msgstr "" + +-#: config/rs6000/rs6000.c:3454 ++#: config/rs6000/rs6000.c:3519 + #, gcc-internal-format + msgid "%qs is not supported for 64-bit Darwin; it is incompatible with the installed C and C++ libraries" + msgstr "" + +-#: config/rs6000/rs6000.c:3593 ++#: config/rs6000/rs6000.c:3658 + #, fuzzy, gcc-internal-format + msgid "AltiVec not supported in this target" + msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай" + +-#: config/rs6000/rs6000.c:3610 ++#: config/rs6000/rs6000.c:3675 + #, fuzzy, gcc-internal-format + msgid "%qs is not supported on little endian systems" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: config/rs6000/rs6000.c:3689 ++#: config/rs6000/rs6000.c:3754 + #, gcc-internal-format + msgid "power9 target option is incompatible with %<%s=%> for less than power9" + msgstr "" + + #. Enforce that none of the ISA_3_0_MASKS_SERVER flags + #. were explicitly cleared. +-#: config/rs6000/rs6000.c:3697 ++#: config/rs6000/rs6000.c:3762 + #, gcc-internal-format + msgid "%qs incompatible with explicitly disabled options" + msgstr "" + + #. TARGET_VSX = 1 implies Power 7 and newer +-#: config/rs6000/rs6000.c:3722 config/rs6000/rs6000.c:3730 +-#: config/rs6000/rs6000.c:3737 config/rs6000/rs6000.c:3744 +-#: config/rs6000/rs6000.c:3752 config/rs6000/rs6000.c:3771 +-#: config/rs6000/rs6000.c:3833 config/rs6000/rs6000.c:3860 +-#: config/rs6000/rs6000.c:3887 config/rs6000/rs6000.c:3902 +-#: config/rs6000/rs6000.c:3910 config/rs6000/rs6000.c:3939 +-#: config/rs6000/rs6000.c:3941 config/rs6000/rs6000.c:4027 +-#: config/rs6000/rs6000.c:4040 config/rs6000/rs6000.c:4049 +-#: config/rs6000/rs6000.c:4197 ++#: config/rs6000/rs6000.c:3787 config/rs6000/rs6000.c:3795 ++#: config/rs6000/rs6000.c:3802 config/rs6000/rs6000.c:3809 ++#: config/rs6000/rs6000.c:3817 config/rs6000/rs6000.c:3836 ++#: config/rs6000/rs6000.c:3898 config/rs6000/rs6000.c:3925 ++#: config/rs6000/rs6000.c:3952 config/rs6000/rs6000.c:3967 ++#: config/rs6000/rs6000.c:3975 config/rs6000/rs6000.c:4004 ++#: config/rs6000/rs6000.c:4006 config/rs6000/rs6000.c:4092 ++#: config/rs6000/rs6000.c:4105 config/rs6000/rs6000.c:4114 ++#: config/rs6000/rs6000.c:4262 config/rs6000/rs6000.c:4275 + #, gcc-internal-format + msgid "%qs requires %qs" + msgstr "" + +-#: config/rs6000/rs6000.c:3930 ++#: config/rs6000/rs6000.c:3995 + #, gcc-internal-format + msgid "target attribute or pragma changes % size" + msgstr "" + +-#: config/rs6000/rs6000.c:3956 ++#: config/rs6000/rs6000.c:4021 + #, gcc-internal-format + msgid "%qs requires full ISA 2.06 support" + msgstr "" + +-#: config/rs6000/rs6000.c:3965 ++#: config/rs6000/rs6000.c:4030 + #, gcc-internal-format + msgid "Using IEEE extended precision %" + msgstr "" + +-#: config/rs6000/rs6000.c:3968 ++#: config/rs6000/rs6000.c:4033 + #, gcc-internal-format + msgid "Using IBM extended precision %" + msgstr "" + +-#: config/rs6000/rs6000.c:3987 ++#: config/rs6000/rs6000.c:4052 + #, fuzzy, gcc-internal-format + #| msgid "%s does not support %s" + msgid "%qs requires VSX support" + msgstr "%s не падтрымлівае %s" + +-#: config/rs6000/rs6000.c:3996 ++#: config/rs6000/rs6000.c:4061 + #, gcc-internal-format + msgid "The %<-mfloat128%> option may not be fully supported" + msgstr "" + +-#: config/rs6000/rs6000.c:4019 ++#: config/rs6000/rs6000.c:4084 + #, gcc-internal-format + msgid "%qs requires full ISA 3.0 support" + msgstr "" + +-#: config/rs6000/rs6000.c:4106 ++#: config/rs6000/rs6000.c:4171 + #, gcc-internal-format + msgid "unknown vectorization library ABI type (%qs) for %qs switch" + msgstr "" + +-#: config/rs6000/rs6000.c:4129 config/rs6000/rs6000.c:4144 ++#: config/rs6000/rs6000.c:4194 config/rs6000/rs6000.c:4209 + #, gcc-internal-format + msgid "target attribute or pragma changes AltiVec ABI" + msgstr "" + +-#: config/rs6000/rs6000.c:4157 ++#: config/rs6000/rs6000.c:4222 + #, gcc-internal-format + msgid "target attribute or pragma changes darwin64 ABI" + msgstr "" + +-#: config/rs6000/rs6000.c:4302 ++#: config/rs6000/rs6000.c:4380 + #, gcc-internal-format + msgid "%qs is not a valid number in %qs" + msgstr "" + +-#: config/rs6000/rs6000.c:4319 ++#: config/rs6000/rs6000.c:4397 + #, fuzzy, gcc-internal-format + #| msgid "invalid register name for `%s'" + msgid "%qs is not a valid base register in %qs" + msgstr "нерэчаісная назва рэгістра `%s'" + +-#: config/rs6000/rs6000.c:4327 ++#: config/rs6000/rs6000.c:4405 + #, gcc-internal-format + msgid "%qs needs a valid base register" + msgstr "" + +-#: config/rs6000/rs6000.c:4623 ++#: config/rs6000/rs6000.c:4706 + #, fuzzy, gcc-internal-format + msgid "unknown option for %<%s=%s%>" + msgstr "невядомая назва рэгістра: %s\n" + +-#: config/rs6000/rs6000.c:4660 ++#: config/rs6000/rs6000.c:4743 + #, gcc-internal-format + msgid "%qs is deprecated and not recommended in any circumstances" + msgstr "" + +-#: config/rs6000/rs6000.c:7184 ++#: config/rs6000/rs6000.c:7267 + #, gcc-internal-format, gfc-internal-format + msgid "the layout of aggregates containing vectors with %d-byte alignment has changed in GCC 5" + msgstr "" + +-#: config/rs6000/rs6000.c:16737 ++#: config/rs6000/rs6000.c:9945 ++#, gcc-internal-format ++msgid "%qs is an opaque type, and you can't set it to other values." ++msgstr "" ++ ++#: config/rs6000/rs6000.c:16978 + #, gcc-internal-format + msgid "no profiling of 64-bit code for this ABI" + msgstr "" + +-#: config/rs6000/rs6000.c:19039 ++#: config/rs6000/rs6000.c:19280 + #, gcc-internal-format + msgid "you cannot take the address of a nested function if you use the %qs option" + msgstr "" + +-#: config/rs6000/rs6000.c:19121 ++#: config/rs6000/rs6000.c:19362 + #, gcc-internal-format + msgid "use of % in AltiVec types is invalid" + msgstr "" + +-#: config/rs6000/rs6000.c:19123 ++#: config/rs6000/rs6000.c:19364 + #, gcc-internal-format + msgid "use of boolean types in AltiVec types is invalid" + msgstr "" + +-#: config/rs6000/rs6000.c:19125 ++#: config/rs6000/rs6000.c:19366 + #, gcc-internal-format + msgid "use of % in AltiVec types is invalid" + msgstr "" + +-#: config/rs6000/rs6000.c:19127 ++#: config/rs6000/rs6000.c:19368 + #, gcc-internal-format + msgid "use of decimal floating point types in AltiVec types is invalid" + msgstr "" + +-#: config/rs6000/rs6000.c:19133 ++#: config/rs6000/rs6000.c:19374 + #, gcc-internal-format + msgid "use of % in AltiVec types is invalid for 64-bit code without %qs" + msgstr "" + +-#: config/rs6000/rs6000.c:19136 ++#: config/rs6000/rs6000.c:19377 + #, gcc-internal-format + msgid "use of % in AltiVec types is deprecated; use %" + msgstr "" + +-#: config/rs6000/rs6000.c:19141 ++#: config/rs6000/rs6000.c:19382 + #, gcc-internal-format + msgid "use of % in AltiVec types is invalid without %qs" + msgstr "" + +-#: config/rs6000/rs6000.c:19144 ++#: config/rs6000/rs6000.c:19385 + #, gcc-internal-format + msgid "use of % in AltiVec types is invalid without %qs" + msgstr "" + +-#: config/rs6000/rs6000.c:23150 ++#: config/rs6000/rs6000.c:23400 + #, fuzzy, gcc-internal-format + #| msgid "invalid use of `%D'" + msgid "invalid cpu %qs for %s%qs%s" + msgstr "нерэчаіснае выкарыстаньне `%D'" + +-#: config/rs6000/rs6000.c:23153 ++#: config/rs6000/rs6000.c:23403 + #, fuzzy, gcc-internal-format + #| msgid "%s=%s is too large" + msgid "%s%qs%s is not allowed" + msgstr "%s=%s вельмі вялікі" + +-#: config/rs6000/rs6000.c:23155 ++#: config/rs6000/rs6000.c:23405 + #, gcc-internal-format + msgid "%s%qs%s is invalid" + msgstr "" + +-#: config/rs6000/rs6000.c:23692 ++#: config/rs6000/rs6000.c:23942 + #, gcc-internal-format + msgid "%<-mno-%s%> turns off %<-m%s%>" + msgstr "" + +-#: config/rs6000/rs6000.c:23851 ++#: config/rs6000/rs6000.c:24101 + #, gcc-internal-format + msgid "% attribute needs GLIBC (2.23 and newer) that exports hardware capability bits" + msgstr "" + +-#: config/rs6000/rs6000.c:23883 ++#: config/rs6000/rs6000.c:24133 + #, fuzzy, gcc-internal-format + msgid "multiversioning needs ifunc which is not supported on this target" + msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай" + +-#: config/rs6000/rs6000.c:24139 ++#: config/rs6000/rs6000.c:24389 + #, gcc-internal-format + msgid "Virtual function multiversioning not supported" + msgstr "" +@@ -38529,141 +38581,141 @@ msgstr "" + msgid "argument to %qE attribute is not (keep|thunk|thunk-extern)" + msgstr "аргумент `__builtin_args_info' павінен быць канстантай" + +-#: config/s390/s390.c:9873 ++#: config/s390/s390.c:9871 + #, gcc-internal-format + msgid "total size of local variables exceeds architecture limit" + msgstr "" + +-#: config/s390/s390.c:11210 ++#: config/s390/s390.c:11208 + #, gcc-internal-format + msgid "frame size of function %qs is %wd bytes exceeding user provided stack limit of %d bytes. An unconditional trap is added." + msgstr "" + +-#: config/s390/s390.c:11226 ++#: config/s390/s390.c:11224 + #, gcc-internal-format + msgid "frame size of function %qs is %wd bytes which is more than half the stack size. The dynamic check would not be reliable. No check emitted for this function." + msgstr "" + +-#: config/s390/s390.c:11254 ++#: config/s390/s390.c:11252 + #, fuzzy, gcc-internal-format + #| msgid "size of `%s' is %d bytes" + msgid "frame size of %qs is %wd bytes" + msgstr "памер \"%s\" - %d байт" + +-#: config/s390/s390.c:11258 ++#: config/s390/s390.c:11256 + #, gcc-internal-format + msgid "%qs uses dynamic stack allocation" + msgstr "" + +-#: config/s390/s390.c:12900 ++#: config/s390/s390.c:12966 + #, gcc-internal-format + msgid "nested functions cannot be profiled with %<-mfentry%> on s390" + msgstr "" + +-#: config/s390/s390.c:15158 ++#: config/s390/s390.c:15224 + #, gcc-internal-format + msgid "64-bit ABI not supported in ESA/390 mode" + msgstr "" + +-#: config/s390/s390.c:15165 ++#: config/s390/s390.c:15231 + #, gcc-internal-format + msgid "thunk-inline is only supported with %<-mindirect-branch-jump%>" + msgstr "" + +-#: config/s390/s390.c:15200 ++#: config/s390/s390.c:15266 + #, gcc-internal-format, gfc-internal-format + msgid "hardware vector support not available on %s" + msgstr "" + +-#: config/s390/s390.c:15203 ++#: config/s390/s390.c:15269 + #, gcc-internal-format + msgid "hardware vector support not available with %<-msoft-float%>" + msgstr "" + +-#: config/s390/s390.c:15232 ++#: config/s390/s390.c:15298 + #, gcc-internal-format, gfc-internal-format + msgid "hardware decimal floating point instructions not available on %s" + msgstr "" + +-#: config/s390/s390.c:15236 ++#: config/s390/s390.c:15302 + #, gcc-internal-format + msgid "hardware decimal floating point instructions not available in ESA/390 mode" + msgstr "" + +-#: config/s390/s390.c:15248 ++#: config/s390/s390.c:15314 + #, gcc-internal-format + msgid "%<-mhard-dfp%> can%'t be used in conjunction with %<-msoft-float%>" + msgstr "" + +-#: config/s390/s390.c:15257 ++#: config/s390/s390.c:15323 + #, gcc-internal-format + msgid "%<-mbackchain%> %<-mpacked-stack%> %<-mhard-float%> are not supported in combination" + msgstr "" + +-#: config/s390/s390.c:15263 ++#: config/s390/s390.c:15329 + #, gcc-internal-format + msgid "stack size must be greater than the stack guard value" + msgstr "" + +-#: config/s390/s390.c:15265 ++#: config/s390/s390.c:15331 + #, gcc-internal-format + msgid "stack size must not be greater than 64k" + msgstr "" + +-#: config/s390/s390.c:15268 ++#: config/s390/s390.c:15334 + #, gcc-internal-format + msgid "%<-mstack-guard%> implies use of %<-mstack-size%>" + msgstr "" + +-#: config/s390/s390.c:15281 ++#: config/s390/s390.c:15347 + #, gcc-internal-format + msgid "-mtpf-trace-hook-prologue-check requires integer in range 0..4095" + msgstr "" + +-#: config/s390/s390.c:15284 ++#: config/s390/s390.c:15350 + #, gcc-internal-format + msgid "-mtpf-trace-hook-prologue-target requires integer in range 0..4095" + msgstr "" + +-#: config/s390/s390.c:15287 ++#: config/s390/s390.c:15353 + #, gcc-internal-format + msgid "-mtpf-trace-hook-epilogue-check requires integer in range 0..4095" + msgstr "" + +-#: config/s390/s390.c:15290 ++#: config/s390/s390.c:15356 + #, gcc-internal-format + msgid "-mtpf-trace-hook-epilogue-target requires integer in range 0..4095" + msgstr "" + +-#: config/s390/s390.c:15350 ++#: config/s390/s390.c:15416 + #, gcc-internal-format + msgid "%<-mfentry%> is supported only for 64-bit CPUs" + msgstr "" + + #. argument is not a plain number +-#: config/s390/s390.c:15386 ++#: config/s390/s390.c:15452 + #, fuzzy, gcc-internal-format + #| msgid "first argument of `%s' should be `int'" + msgid "arguments to %qs should be non-negative integers" + msgstr "першым аргументам \"%s\" павінен быць \"int\"" + +-#: config/s390/s390.c:15393 ++#: config/s390/s390.c:15459 + #, fuzzy, gcc-internal-format + msgid "argument to %qs is too large (max. %d)" + msgstr "памер \"%s\" больш чам %d байт" + +-#: config/s390/s390.c:15423 ++#: config/s390/s390.c:15489 + #, gcc-internal-format + msgid "%<-mno-pic-data-is-text-relative%> cannot be used without %<-fpic%>/%<-fPIC%>" + msgstr "" + +-#: config/s390/s390.c:15584 config/s390/s390.c:15634 config/s390/s390.c:15651 ++#: config/s390/s390.c:15650 config/s390/s390.c:15700 config/s390/s390.c:15717 + #, gcc-internal-format, gfc-internal-format + msgid "attribute(target(\"%s\")) is unknown" + msgstr "" + + #. Value is not allowed for the target attribute. +-#: config/s390/s390.c:15590 ++#: config/s390/s390.c:15656 + #, fuzzy, gcc-internal-format + msgid "value %qs is not supported by attribute %" + msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай" +@@ -39085,8 +39137,8 @@ msgstr "\"%s\" атрыбут ігнарыруецца" + msgid "could not read the BRIG file" + msgstr "не магу знайсці крыніцу %s\n" + +-#: c/c-convert.c:101 c/c-typeck.c:2200 c/c-typeck.c:12638 cp/typeck.c:2113 +-#: cp/typeck.c:8408 cp/typeck.c:9196 ++#: c/c-convert.c:101 c/c-typeck.c:2200 c/c-typeck.c:12638 cp/typeck.c:2155 ++#: cp/typeck.c:8468 cp/typeck.c:9256 + #, gcc-internal-format + msgid "void value not ignored as it ought to be" + msgstr "" +@@ -39369,7 +39421,7 @@ msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэк + msgid "declaration of %qD shadows a parameter" + msgstr "" + +-#: c/c-decl.c:3024 cp/name-lookup.c:2840 ++#: c/c-decl.c:3024 cp/name-lookup.c:2842 + #, gcc-internal-format + msgid "declaration of %qD shadows a global declaration" + msgstr "" +@@ -39442,7 +39494,7 @@ msgstr "\"%s\" не абвешчан (першае выкарыстанне ў + msgid "each undeclared identifier is reported only once for each function it appears in" + msgstr "(Аб кожным неабвешчаным ідэнтыфікатары паведамляецца" + +-#: c/c-decl.c:3791 cp/decl.c:3147 ++#: c/c-decl.c:3791 cp/decl.c:3149 + #, gcc-internal-format + msgid "label %qE referenced outside of any function" + msgstr "" +@@ -39474,7 +39526,7 @@ msgstr "" + msgid "duplicate label declaration %qE" + msgstr "паўторнае абвяшчэньне адмеціны `%s'" + +-#: c/c-decl.c:4007 cp/decl.c:3553 ++#: c/c-decl.c:4007 cp/decl.c:3555 + #, fuzzy, gcc-internal-format + msgid "duplicate label %qD" + msgstr "паўтарэнне \"%s\"" +@@ -39689,7 +39741,7 @@ msgstr "" + msgid "uninitialized % is invalid in C++" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: c/c-decl.c:5568 cp/decl.c:7933 ++#: c/c-decl.c:5568 cp/decl.c:7930 + #, gcc-internal-format + msgid "%q+D in declare target directive does not have mappable type" + msgstr "" +@@ -40041,7 +40093,7 @@ msgstr "" + msgid "function definition has qualified void return type" + msgstr "функцыя не вяртае тып string" + +-#: c/c-decl.c:6788 cp/decl.c:12138 ++#: c/c-decl.c:6788 cp/decl.c:12145 + #, gcc-internal-format + msgid "type qualifiers ignored on function return type" + msgstr "" +@@ -40354,7 +40406,7 @@ msgstr "перанакіраванне stdout: %s" + msgid "defining type in %qs expression is invalid in C++" + msgstr "" + +-#: c/c-decl.c:8084 cp/decl.c:4991 ++#: c/c-decl.c:8084 cp/decl.c:4993 + #, gcc-internal-format + msgid "declaration does not declare anything" + msgstr "" +@@ -40406,7 +40458,7 @@ msgstr "" + msgid "struct has no members" + msgstr "" + +-#: c/c-decl.c:8488 cp/decl.c:13089 ++#: c/c-decl.c:8488 cp/decl.c:13096 + #, gcc-internal-format + msgid "flexible array member in union" + msgstr "" +@@ -40444,7 +40496,7 @@ msgstr "перанакіраванне stdout: %s" + msgid "redeclaration of %" + msgstr "абвяшчэньне `%#D'" + +-#: c/c-decl.c:8862 cp/decl.c:15536 ++#: c/c-decl.c:8862 cp/decl.c:15545 + #, gcc-internal-format + msgid "specified mode too small for enumerated values" + msgstr "" +@@ -40474,7 +40526,7 @@ msgstr "" + msgid "ISO C restricts enumerator values to range of %" + msgstr "" + +-#: c/c-decl.c:9159 cp/decl.c:5296 cp/decl.c:16095 ++#: c/c-decl.c:9159 cp/decl.c:5298 cp/decl.c:16104 + #, gcc-internal-format + msgid "inline function %qD given attribute %qs" + msgstr "" +@@ -40506,7 +40558,7 @@ msgstr "няма папярэдняга прататыпа для \"%s\"" + msgid "%qD was used with no prototype before its definition" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: c/c-decl.c:9288 cp/decl.c:16230 ++#: c/c-decl.c:9288 cp/decl.c:16239 + #, fuzzy, gcc-internal-format + #| msgid "no previous declaration for `%s'" + msgid "no previous declaration for %qD" +@@ -40626,12 +40678,12 @@ msgstr "" + msgid "argument %qD doesn%'t match prototype" + msgstr "" + +-#: c/c-decl.c:9921 cp/decl.c:17115 ++#: c/c-decl.c:9928 cp/decl.c:17123 + #, gcc-internal-format + msgid "no return statement in function returning non-void" + msgstr "" + +-#: c/c-decl.c:9940 cp/decl.c:17147 ++#: c/c-decl.c:9947 cp/decl.c:17155 + #, fuzzy, gcc-internal-format + #| msgid "label `%D' defined but not used" + msgid "parameter %qD set but not used" +@@ -40640,272 +40692,272 @@ msgstr "адмеціна `%D' вызначана, але не выкарысто + #. If we get here, declarations have been used in a for loop without + #. the C99 for loop scope. This doesn't make much sense, so don't + #. allow it. +-#: c/c-decl.c:10036 ++#: c/c-decl.c:10043 + #, gcc-internal-format + msgid "% loop initial declarations are only allowed in C99 or C11 mode" + msgstr "" + +-#: c/c-decl.c:10041 ++#: c/c-decl.c:10048 + #, gcc-internal-format + msgid "use option %<-std=c99%>, %<-std=gnu99%>, %<-std=c11%> or %<-std=gnu11%> to compile your code" + msgstr "" + +-#: c/c-decl.c:10048 ++#: c/c-decl.c:10055 + #, fuzzy, gcc-internal-format + msgid "ISO C90 does not support % loop initial declarations" + msgstr "ISO C89 не падтрымлівае \"long long\"" + +-#: c/c-decl.c:10080 ++#: c/c-decl.c:10087 + #, gcc-internal-format + msgid "declaration of static variable %qD in % loop initial declaration" + msgstr "" + +-#: c/c-decl.c:10084 ++#: c/c-decl.c:10091 + #, gcc-internal-format + msgid "declaration of % variable %qD in % loop initial declaration" + msgstr "" + +-#: c/c-decl.c:10091 ++#: c/c-decl.c:10098 + #, gcc-internal-format + msgid "% declared in % loop initial declaration" + msgstr "" + +-#: c/c-decl.c:10096 ++#: c/c-decl.c:10103 + #, gcc-internal-format + msgid "% declared in % loop initial declaration" + msgstr "" + +-#: c/c-decl.c:10100 ++#: c/c-decl.c:10107 + #, gcc-internal-format + msgid "% declared in % loop initial declaration" + msgstr "" + +-#: c/c-decl.c:10104 ++#: c/c-decl.c:10111 + #, gcc-internal-format + msgid "declaration of non-variable %qD in % loop initial declaration" + msgstr "" + +-#: c/c-decl.c:10398 ++#: c/c-decl.c:10405 + #, gcc-internal-format + msgid "incompatible address space qualifiers %qs and %qs" + msgstr "" + +-#: c/c-decl.c:10457 c/c-decl.c:10464 ++#: c/c-decl.c:10464 c/c-decl.c:10471 + #, fuzzy, gcc-internal-format + #| msgid "duplicate label declaration `%s'" + msgid "duplicate %qE declaration specifier" + msgstr "паўторнае абвяшчэньне адмеціны `%s'" + +-#: c/c-decl.c:10492 c/c-decl.c:10876 c/c-decl.c:11271 ++#: c/c-decl.c:10499 c/c-decl.c:10883 c/c-decl.c:11278 + #, gcc-internal-format + msgid "two or more data types in declaration specifiers" + msgstr "" + +-#: c/c-decl.c:10504 cp/parser.c:30413 ++#: c/c-decl.c:10511 cp/parser.c:30438 + #, fuzzy, gcc-internal-format + #| msgid "`long long long' is too long for GCC" + msgid "% is too long for GCC" + msgstr "`long long long' - вельмі доўга для GCC" + +-#: c/c-decl.c:10517 ++#: c/c-decl.c:10524 + #, fuzzy, gcc-internal-format + #| msgid "ISO C89 does not support `long long'" + msgid "ISO C90 does not support %" + msgstr "ISO C89 не падтрымлівае `long long'" + +-#: c/c-decl.c:10746 c/c-parser.c:9995 ++#: c/c-decl.c:10753 c/c-parser.c:9995 + #, fuzzy, gcc-internal-format + #| msgid "ISO C89 does not support complex types" + msgid "ISO C90 does not support complex types" + msgstr "ISO C89 не падтрымлівае комлексныя тыпы" + +-#: c/c-decl.c:10792 ++#: c/c-decl.c:10799 + #, fuzzy, gcc-internal-format + #| msgid "ISO C does not support complex integer types" + msgid "ISO C does not support saturating types" + msgstr "ISO C не падтрымлівае комлексныя цэлалікавыя тыпы" + +-#: c/c-decl.c:10863 c/c-decl.c:11429 ++#: c/c-decl.c:10870 c/c-decl.c:11436 + #, fuzzy, gcc-internal-format + #| msgid "duplicate `%s'" + msgid "duplicate %qE" + msgstr "паўтарэньне `%s'" + +-#: c/c-decl.c:10923 ++#: c/c-decl.c:10930 + #, fuzzy, gcc-internal-format + #| msgid "ISO C does not support complex integer types" + msgid "ISO C does not support %<__int%d%> types" + msgstr "ISO C не падтрымлівае комлексныя цэлалікавыя тыпы" + +-#: c/c-decl.c:10945 ++#: c/c-decl.c:10952 + #, fuzzy, gcc-internal-format + msgid "%<__int%d%> is not supported on this target" + msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай" + +-#: c/c-decl.c:10988 ++#: c/c-decl.c:10995 + #, fuzzy, gcc-internal-format + #| msgid "ISO C89 does not support complex types" + msgid "ISO C90 does not support boolean types" + msgstr "ISO C89 не падтрымлівае комлексныя тыпы" + +-#: c/c-decl.c:11107 ++#: c/c-decl.c:11114 + #, fuzzy, gcc-internal-format + #| msgid "ISO C89 does not support complex types" + msgid "ISO C does not support the %<_Float%d%s%> type" + msgstr "ISO C89 не падтрымлівае комлексныя тыпы" + +-#: c/c-decl.c:11157 ++#: c/c-decl.c:11164 + #, fuzzy, gcc-internal-format + msgid "%<_Float%d%s%> is not supported on this target" + msgstr "__buitin_saveregs не падтрымліваецца гэтай мэтай" + +-#: c/c-decl.c:11228 ++#: c/c-decl.c:11235 + #, fuzzy, gcc-internal-format + #| msgid "ISO C does not support complex integer types" + msgid "ISO C does not support decimal floating-point before C2X" + msgstr "ISO C не падтрымлівае комлексныя цэлалікавыя тыпы" + +-#: c/c-decl.c:11252 c/c-decl.c:11525 c/c-parser.c:9009 ++#: c/c-decl.c:11259 c/c-decl.c:11532 c/c-parser.c:9009 + #, fuzzy, gcc-internal-format + msgid "fixed-point types not supported for this target" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: c/c-decl.c:11254 ++#: c/c-decl.c:11261 + #, fuzzy, gcc-internal-format + #| msgid "ISO C does not support complex integer types" + msgid "ISO C does not support fixed-point types" + msgstr "ISO C не падтрымлівае комлексныя цэлалікавыя тыпы" + +-#: c/c-decl.c:11289 ++#: c/c-decl.c:11296 + #, gcc-internal-format + msgid "C++ lookup of %qD would return a field, not a type" + msgstr "" + +-#: c/c-decl.c:11302 ++#: c/c-decl.c:11309 + #, gcc-internal-format + msgid "%qE fails to be a typedef or built in type" + msgstr "" + +-#: c/c-decl.c:11351 ++#: c/c-decl.c:11358 + #, fuzzy, gcc-internal-format + #| msgid "`%s' is not at beginning of declaration" + msgid "%qE is not at beginning of declaration" + msgstr "\"%s\" - гэта не пачатак дэкларацыі" + +-#: c/c-decl.c:11372 ++#: c/c-decl.c:11379 + #, gcc-internal-format + msgid "%qE used with %" + msgstr "" + +-#: c/c-decl.c:11374 ++#: c/c-decl.c:11381 + #, gcc-internal-format + msgid "%qE used with %" + msgstr "" + +-#: c/c-decl.c:11376 ++#: c/c-decl.c:11383 + #, gcc-internal-format + msgid "%qE used with %" + msgstr "" + +-#: c/c-decl.c:11390 c/c-parser.c:8374 ++#: c/c-decl.c:11397 c/c-parser.c:8374 + #, fuzzy, gcc-internal-format + #| msgid "%s does not support %s" + msgid "ISO C99 does not support %qE" + msgstr "%s не падтрымлівае %s" + +-#: c/c-decl.c:11393 c/c-parser.c:8377 ++#: c/c-decl.c:11400 c/c-parser.c:8377 + #, fuzzy, gcc-internal-format + #| msgid "%s does not support %s" + msgid "ISO C90 does not support %qE" + msgstr "%s не падтрымлівае %s" + +-#: c/c-decl.c:11405 ++#: c/c-decl.c:11412 + #, gcc-internal-format + msgid "%<__thread%> before %" + msgstr "" + +-#: c/c-decl.c:11414 ++#: c/c-decl.c:11421 + #, gcc-internal-format + msgid "%<__thread%> before %" + msgstr "" + +-#: c/c-decl.c:11427 ++#: c/c-decl.c:11434 + #, gcc-internal-format + msgid "duplicate %<_Thread_local%> or %<__thread%>" + msgstr "" + +-#: c/c-decl.c:11435 ++#: c/c-decl.c:11442 + #, gcc-internal-format + msgid "multiple storage classes in declaration specifiers" + msgstr "" + +-#: c/c-decl.c:11443 ++#: c/c-decl.c:11450 + #, gcc-internal-format + msgid "%qs used with %qE" + msgstr "" + +-#: c/c-decl.c:11522 ++#: c/c-decl.c:11529 + #, gcc-internal-format + msgid "%<_Sat%> is used without %<_Fract%> or %<_Accum%>" + msgstr "" + +-#: c/c-decl.c:11537 ++#: c/c-decl.c:11544 + #, fuzzy, gcc-internal-format + #| msgid "ISO C does not support plain `complex' meaning `double complex'" + msgid "ISO C does not support plain % meaning %" + msgstr "ISO C не падтрымлівае просты \"complex\" у значэнні \"double complex\"" + +-#: c/c-decl.c:11564 ++#: c/c-decl.c:11571 + #, gcc-internal-format + msgid "%<__auto_type%> followed by %<[[]]%> attributes" + msgstr "" + +-#: c/c-decl.c:11590 c/c-decl.c:11606 c/c-decl.c:11632 ++#: c/c-decl.c:11597 c/c-decl.c:11613 c/c-decl.c:11639 + #, gcc-internal-format + msgid "ISO C does not support complex integer types" + msgstr "ISO C не падтрымлівае комлексныя цэлалікавыя тыпы" + +-#: c/c-decl.c:12031 cp/semantics.c:5624 ++#: c/c-decl.c:12038 cp/semantics.c:5624 + #, gcc-internal-format + msgid "%<#pragma omp declare reduction%> combiner refers to variable %qD which is not % nor %" + msgstr "" + +-#: c/c-decl.c:12035 cp/semantics.c:5628 ++#: c/c-decl.c:12042 cp/semantics.c:5628 + #, gcc-internal-format + msgid "%<#pragma omp declare reduction%> initializer refers to variable %qD which is not % nor %" + msgstr "" + +-#: c/c-fold.c:386 c/c-typeck.c:11920 cp/typeck.c:4906 ++#: c/c-fold.c:387 c/c-typeck.c:11920 cp/typeck.c:4964 + #, gcc-internal-format + msgid "left shift of negative value" + msgstr "" + +-#: c/c-fold.c:396 c/c-typeck.c:11929 cp/typeck.c:4914 ++#: c/c-fold.c:397 c/c-typeck.c:11929 cp/typeck.c:4972 + #, gcc-internal-format + msgid "left shift count is negative" + msgstr "" + +-#: c/c-fold.c:397 c/c-typeck.c:11858 cp/typeck.c:4854 ++#: c/c-fold.c:398 c/c-typeck.c:11858 cp/typeck.c:4912 + #, gcc-internal-format + msgid "right shift count is negative" + msgstr "" + +-#: c/c-fold.c:405 c/c-typeck.c:11948 cp/typeck.c:4922 ++#: c/c-fold.c:406 c/c-typeck.c:11948 cp/typeck.c:4980 + #, gcc-internal-format + msgid "left shift count >= width of type" + msgstr "" + +-#: c/c-fold.c:406 c/c-typeck.c:11882 cp/typeck.c:4865 ++#: c/c-fold.c:407 c/c-typeck.c:11882 cp/typeck.c:4923 + #, gcc-internal-format + msgid "right shift count >= width of type" + msgstr "" + +-#: c/c-fold.c:413 c/c-typeck.c:11940 ++#: c/c-fold.c:414 c/c-typeck.c:11940 + #, gcc-internal-format + msgid "left shift count >= width of vector element" + msgstr "" + +-#: c/c-fold.c:414 c/c-typeck.c:11869 ++#: c/c-fold.c:415 c/c-typeck.c:11869 + #, gcc-internal-format + msgid "right shift count >= width of vector element" + msgstr "" +@@ -40925,7 +40977,7 @@ msgstr "" + msgid "to match this %qs" + msgstr "" + +-#: c/c-parser.c:1296 cp/parser.c:30647 ++#: c/c-parser.c:1296 cp/parser.c:30672 + #, gcc-internal-format + msgid "expected end of line" + msgstr "" +@@ -40973,7 +41025,7 @@ msgid "unknown type name %qE" + msgstr "невядомая назва рэгістра: %s" + + #: c/c-parser.c:1969 c/c-parser.c:12498 c/c-parser.c:18659 c/c-parser.c:19170 +-#: c/c-parser.c:19679 cp/parser.c:40091 cp/parser.c:43923 ++#: c/c-parser.c:19679 cp/parser.c:40117 cp/parser.c:43949 + #, fuzzy, gcc-internal-format + #| msgid "empty declaration" + msgid "expected declaration specifiers" +@@ -40995,7 +41047,7 @@ msgstr "" + msgid "expected %<;%>, identifier or %<(%>" + msgstr "" + +-#: c/c-parser.c:2034 cp/parser.c:32843 cp/parser.c:32917 ++#: c/c-parser.c:2034 cp/parser.c:32869 cp/parser.c:32943 + #, fuzzy, gcc-internal-format + msgid "prefix attributes are ignored for methods" + msgstr "\"%s\" атрыбут ігнарыруецца" +@@ -41011,8 +41063,8 @@ msgstr "атрыбуты секцыі не падтрымліваюцца для + msgid "unexpected attribute" + msgstr "" + +-#: c/c-parser.c:2100 c/c-parser.c:5948 c/c-parser.c:6272 cp/parser.c:11503 +-#: cp/parser.c:11710 ++#: c/c-parser.c:2100 c/c-parser.c:5948 c/c-parser.c:6272 cp/parser.c:11508 ++#: cp/parser.c:11715 + #, gcc-internal-format + msgid "% attribute not followed by %<;%>" + msgstr "" +@@ -41050,7 +41102,7 @@ msgstr "" + msgid "%<__auto_type%> may only be used with a single declarator" + msgstr "" + +-#: c/c-parser.c:2381 cp/parser.c:13840 ++#: c/c-parser.c:2381 cp/parser.c:13845 + #, gcc-internal-format + msgid "expected %<,%> or %<;%>" + msgstr "" +@@ -41080,7 +41132,7 @@ msgstr "ISO C89 не падтрымлівае комлексныя тыпы" + msgid "ISO C90 does not support %<_Static_assert%>" + msgstr "ISO C89 не падтрымлівае комлексныя тыпы" + +-#: c/c-parser.c:2611 c/c-parser.c:7402 c/c-parser.c:12559 cp/parser.c:43531 ++#: c/c-parser.c:2611 c/c-parser.c:7402 c/c-parser.c:12559 cp/parser.c:43557 + #, gcc-internal-format + msgid "expected string literal" + msgstr "" +@@ -41111,7 +41163,7 @@ msgstr "" + msgid "static assertion failed: %E" + msgstr "" + +-#: c/c-parser.c:2649 cp/semantics.c:9686 ++#: c/c-parser.c:2649 cp/semantics.c:9702 + #, gcc-internal-format + msgid "static assertion failed" + msgstr "" +@@ -41158,14 +41210,14 @@ msgstr "параметр \"%s\" ініцыялізаваны" + #: c/c-parser.c:12087 c/c-parser.c:12140 c/c-parser.c:12156 c/c-parser.c:12202 + #: c/c-parser.c:12986 c/c-parser.c:13019 c/c-parser.c:15269 c/c-parser.c:15379 + #: c/c-parser.c:15652 c/c-parser.c:17751 c/c-parser.c:20193 c/c-parser.c:20384 +-#: c/gimple-parser.c:1776 c/gimple-parser.c:1814 cp/parser.c:8693 +-#: cp/parser.c:30650 cp/parser.c:33699 cp/parser.c:33729 cp/parser.c:33799 +-#: cp/parser.c:36297 cp/parser.c:36419 cp/parser.c:41637 cp/parser.c:43235 ++#: c/gimple-parser.c:1776 c/gimple-parser.c:1814 cp/parser.c:8698 ++#: cp/parser.c:30675 cp/parser.c:33725 cp/parser.c:33755 cp/parser.c:33825 ++#: cp/parser.c:36323 cp/parser.c:36445 cp/parser.c:41663 cp/parser.c:43261 + #, gcc-internal-format + msgid "expected identifier" + msgstr "" + +-#: c/c-parser.c:3204 cp/parser.c:19435 ++#: c/c-parser.c:3204 cp/parser.c:19445 + #, gcc-internal-format + msgid "comma at end of enumerator list" + msgstr "" +@@ -41252,7 +41304,7 @@ msgstr "" + msgid "parentheses must be omitted if attribute argument list is empty" + msgstr "" + +-#: c/c-parser.c:4903 cp/parser.c:26871 ++#: c/c-parser.c:4903 cp/parser.c:26887 + #, gcc-internal-format + msgid "%qE attribute does not take any arguments" + msgstr "" +@@ -41262,7 +41314,7 @@ msgstr "" + msgid "ISO C does not support %<[[]]%> attributes before C2X" + msgstr "ISO C89 не падтрымлівае \"long long\"" + +-#: c/c-parser.c:4987 cp/parser.c:26937 ++#: c/c-parser.c:4987 cp/parser.c:26953 + #, gcc-internal-format + msgid "attribute % can appear at most once in an attribute-list" + msgstr "" +@@ -41323,7 +41375,7 @@ msgstr "ISO C не дазваляе дэкларацыі метак (label)" + msgid "expected %<}%> before %" + msgstr "" + +-#: c/c-parser.c:5793 cp/parser.c:11833 ++#: c/c-parser.c:5793 cp/parser.c:11838 + #, gcc-internal-format + msgid "% without a previous %" + msgstr "" +@@ -41338,7 +41390,7 @@ msgstr "" + #. delimiter without consuming it, but here we need to consume + #. it to proceed further. + #: c/c-parser.c:5831 c/c-parser.c:6293 c/gimple-parser.c:2276 +-#: cp/parser.c:11453 ++#: cp/parser.c:11458 + #, gcc-internal-format + msgid "expected statement" + msgstr "" +@@ -41363,19 +41415,19 @@ msgstr "" + msgid "expected identifier or %<*%>" + msgstr "" + +-#: c/c-parser.c:6400 cp/parser.c:13214 ++#: c/c-parser.c:6400 cp/parser.c:13219 + #, fuzzy, gcc-internal-format + #| msgid "empty body in an else-statement" + msgid "suggest braces around empty body in an % statement" + msgstr "пустое цела ў else-выражэнні" + +-#: c/c-parser.c:6442 cp/parser.c:13217 ++#: c/c-parser.c:6442 cp/parser.c:13222 + #, fuzzy, gcc-internal-format + #| msgid "empty body in an else-statement" + msgid "suggest braces around empty body in an % statement" + msgstr "пустое цела ў else-выражэнні" + +-#: c/c-parser.c:6576 cp/parser.c:12110 ++#: c/c-parser.c:6576 cp/parser.c:12115 + #, gcc-internal-format + msgid "suggest explicit braces to avoid ambiguous %" + msgstr "" +@@ -41395,12 +41447,12 @@ msgstr "" + msgid "invalid iterating variable in fast enumeration" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: c/c-parser.c:6946 cp/parser.c:12382 ++#: c/c-parser.c:6946 cp/parser.c:12387 + #, gcc-internal-format + msgid "missing loop condition in loop with % pragma" + msgstr "" + +-#: c/c-parser.c:6952 cp/parser.c:12388 ++#: c/c-parser.c:6952 cp/parser.c:12393 + #, gcc-internal-format + msgid "missing loop condition in loop with % pragma" + msgstr "" +@@ -41415,8 +41467,8 @@ msgstr "" + msgid "duplicate % qualifier %qE" + msgstr "паўтарэнне \"volatile\"" + +-#: c/c-parser.c:7099 c/c-parser.c:7110 c/c-parser.c:7121 cp/parser.c:20209 +-#: cp/parser.c:20226 cp/parser.c:20240 ++#: c/c-parser.c:7099 c/c-parser.c:7110 c/c-parser.c:7121 cp/parser.c:20219 ++#: cp/parser.c:20236 cp/parser.c:20250 + #, gcc-internal-format + msgid "first seen here" + msgstr "" +@@ -41443,12 +41495,12 @@ msgstr "ISO C не дазваляе пусты ізыходны файл" + + #. Location of the binary operator. + #. Quiet warning. +-#: c/c-parser.c:7877 cp/typeck.c:4689 ++#: c/c-parser.c:7877 cp/typeck.c:4747 + #, gcc-internal-format + msgid "division % does not compute the number of array elements" + msgstr "" + +-#: c/c-parser.c:7883 cp/typeck.c:4694 ++#: c/c-parser.c:7883 cp/typeck.c:4752 + #, gcc-internal-format + msgid "first % operand was declared here" + msgstr "" +@@ -41847,61 +41899,61 @@ msgstr "" + msgid "no type or storage class may be specified here," + msgstr "" + +-#: c/c-parser.c:12003 c/c-parser.c:12060 cp/parser.c:33759 ++#: c/c-parser.c:12003 c/c-parser.c:12060 cp/parser.c:33785 + #, gcc-internal-format + msgid "unknown property attribute" + msgstr "" + +-#: c/c-parser.c:12024 cp/parser.c:33719 ++#: c/c-parser.c:12024 cp/parser.c:33745 + #, gcc-internal-format + msgid "missing %<=%> (after % attribute)" + msgstr "" + +-#: c/c-parser.c:12027 cp/parser.c:33722 ++#: c/c-parser.c:12027 cp/parser.c:33748 + #, gcc-internal-format + msgid "missing %<=%> (after % attribute)" + msgstr "" + +-#: c/c-parser.c:12041 cp/parser.c:33737 ++#: c/c-parser.c:12041 cp/parser.c:33763 + #, gcc-internal-format + msgid "the % attribute may only be specified once" + msgstr "" + +-#: c/c-parser.c:12046 cp/parser.c:33743 ++#: c/c-parser.c:12046 cp/parser.c:33769 + #, gcc-internal-format + msgid "setter name must terminate with %<:%>" + msgstr "" + +-#: c/c-parser.c:12053 cp/parser.c:33751 ++#: c/c-parser.c:12053 cp/parser.c:33777 + #, gcc-internal-format + msgid "the % attribute may only be specified once" + msgstr "" + +-#: c/c-parser.c:12247 cp/parser.c:43571 ++#: c/c-parser.c:12247 cp/parser.c:43597 + #, gcc-internal-format + msgid "%<#pragma GCC unroll%> requires an assignment-expression that evaluates to a non-negative integral constant less than %u" + msgstr "" + + #: c/c-parser.c:12291 c/c-parser.c:19167 c/c-parser.c:19458 c/c-parser.c:19517 +-#: c/c-parser.c:19601 cp/parser.c:40088 cp/parser.c:40418 cp/parser.c:40506 +-#: cp/parser.c:40577 cp/parser.c:43618 cp/parser.c:43633 cp/parser.c:43648 +-#: cp/parser.c:43664 cp/parser.c:43680 cp/parser.c:43696 cp/parser.c:43723 +-#: cp/parser.c:43736 cp/parser.c:43759 cp/parser.c:43772 ++#: c/c-parser.c:19601 cp/parser.c:40114 cp/parser.c:40444 cp/parser.c:40532 ++#: cp/parser.c:40603 cp/parser.c:43644 cp/parser.c:43659 cp/parser.c:43674 ++#: cp/parser.c:43690 cp/parser.c:43706 cp/parser.c:43722 cp/parser.c:43749 ++#: cp/parser.c:43762 cp/parser.c:43785 cp/parser.c:43798 + #, gcc-internal-format + msgid "%<#pragma %s%> may only be used in compound statements" + msgstr "" + +-#: c/c-parser.c:12314 cp/parser.c:43749 ++#: c/c-parser.c:12314 cp/parser.c:43775 + #, gcc-internal-format + msgid "%<#pragma acc routine%> must be at file scope" + msgstr "" + +-#: c/c-parser.c:12401 cp/parser.c:43842 ++#: c/c-parser.c:12401 cp/parser.c:43868 + #, gcc-internal-format + msgid "%<#pragma omp scan%> may only be used in a loop construct with % % clause" + msgstr "" + +-#: c/c-parser.c:12408 cp/parser.c:43848 ++#: c/c-parser.c:12408 cp/parser.c:43874 + #, gcc-internal-format + msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct" + msgstr "" +@@ -41911,18 +41963,18 @@ msgstr "" + msgid "%<#pragma omp requires%> may only be used at file scope" + msgstr "" + +-#: c/c-parser.c:12443 c/c-parser.c:12467 cp/parser.c:43877 cp/parser.c:43910 ++#: c/c-parser.c:12443 c/c-parser.c:12467 cp/parser.c:43903 cp/parser.c:43936 + #, gcc-internal-format + msgid "for, while or do statement expected" + msgstr "" + +-#: c/c-parser.c:12480 cp/parser.c:43608 ++#: c/c-parser.c:12480 cp/parser.c:43634 + #, gcc-internal-format + msgid "%<#pragma GCC pch_preprocess%> must be first" + msgstr "" + + #: c/c-parser.c:12817 c/c-parser.c:15763 c/c-parser.c:21198 c/c-parser.c:21206 +-#: cp/parser.c:34165 cp/parser.c:36770 cp/parser.c:42687 cp/parser.c:42695 ++#: cp/parser.c:34191 cp/parser.c:36796 cp/parser.c:42713 cp/parser.c:42721 + #, fuzzy, gcc-internal-format + #| msgid "too many input files" + msgid "too many %qs clauses" +@@ -41943,54 +41995,54 @@ msgstr "" + msgid "%qD is not a variable" + msgstr "\"%s\" мае незавершаны тып" + +-#: c/c-parser.c:13255 cp/semantics.c:7466 ++#: c/c-parser.c:13255 cp/semantics.c:7482 + #, fuzzy, gcc-internal-format + msgid "%qD is not a pointer variable" + msgstr "\"%s\" звычайна функцыя" + +-#: c/c-parser.c:13297 cp/parser.c:34844 ++#: c/c-parser.c:13297 cp/parser.c:34870 + #, gcc-internal-format + msgid "collapse argument needs positive constant integer expression" + msgstr "" + +-#: c/c-parser.c:13374 cp/parser.c:34908 ++#: c/c-parser.c:13374 cp/parser.c:34934 + #, gcc-internal-format + msgid "expected % or %" + msgstr "" + +-#: c/c-parser.c:13376 cp/parser.c:34910 ++#: c/c-parser.c:13376 cp/parser.c:34936 + #, gcc-internal-format + msgid "expected % or %" + msgstr "" + +-#: c/c-parser.c:13496 cp/parser.c:35021 ++#: c/c-parser.c:13496 cp/parser.c:35047 + #, gcc-internal-format + msgid "expected %, %, % or %" + msgstr "" + +-#: c/c-parser.c:13516 c/c-parser.c:19510 c/c-parser.c:19594 cp/parser.c:35039 +-#: cp/parser.c:40410 cp/parser.c:40498 ++#: c/c-parser.c:13516 c/c-parser.c:19510 c/c-parser.c:19594 cp/parser.c:35065 ++#: cp/parser.c:40436 cp/parser.c:40524 + #, gcc-internal-format + msgid "expected %" + msgstr "" + +-#: c/c-parser.c:13569 cp/parser.c:35094 ++#: c/c-parser.c:13569 cp/parser.c:35120 + #, gcc-internal-format + msgid "too many % clauses with %qs modifier" + msgstr "" + +-#: c/c-parser.c:13576 cp/parser.c:35101 ++#: c/c-parser.c:13576 cp/parser.c:35127 + #, fuzzy, gcc-internal-format + #| msgid "too many input files" + msgid "too many % clauses" + msgstr "вельмі шмат уваходзячых файлаў" + +-#: c/c-parser.c:13578 cp/parser.c:35103 ++#: c/c-parser.c:13578 cp/parser.c:35129 + #, gcc-internal-format + msgid "too many % clauses without modifier" + msgstr "" + +-#: c/c-parser.c:13584 cp/parser.c:35109 ++#: c/c-parser.c:13584 cp/parser.c:35135 + #, gcc-internal-format + msgid "if any % clause has modifier, then all % clauses have to use modifier" + msgstr "" +@@ -42012,12 +42064,12 @@ msgstr "" + msgid "% value must be positive" + msgstr "" + +-#: c/c-parser.c:13792 cp/semantics.c:7669 ++#: c/c-parser.c:13792 cp/semantics.c:7685 + #, gcc-internal-format + msgid "% value must be positive" + msgstr "" + +-#: c/c-parser.c:13839 cp/semantics.c:7699 ++#: c/c-parser.c:13839 cp/semantics.c:7715 + #, gcc-internal-format + msgid "% value must be non-negative" + msgstr "" +@@ -42027,22 +42079,22 @@ msgstr "" + msgid "expected constant integer expression" + msgstr "" + +-#: c/c-parser.c:13914 cp/parser.c:35334 ++#: c/c-parser.c:13914 cp/parser.c:35360 + #, gcc-internal-format + msgid "expected %, %, %, %, %, % or %" + msgstr "" + +-#: c/c-parser.c:13975 cp/parser.c:35399 ++#: c/c-parser.c:13975 cp/parser.c:35425 + #, gcc-internal-format + msgid "expected %, % or %" + msgstr "" + +-#: c/c-parser.c:14041 cp/parser.c:35468 ++#: c/c-parser.c:14041 cp/parser.c:35494 + #, gcc-internal-format + msgid "too many % clauses with %qs category" + msgstr "" + +-#: c/c-parser.c:14044 cp/parser.c:35471 ++#: c/c-parser.c:14044 cp/parser.c:35497 + #, gcc-internal-format + msgid "too many % clauses with unspecified category" + msgstr "" +@@ -42057,54 +42109,54 @@ msgstr "" + msgid "%qs value must be positive" + msgstr "" + +-#: c/c-parser.c:14192 cp/parser.c:34616 ++#: c/c-parser.c:14192 cp/parser.c:34642 + #, fuzzy, gcc-internal-format + #| msgid "too many arguments to function" + msgid "too many % arguments" + msgstr "вельмі шмат аргументаў у функцыі" + +-#: c/c-parser.c:14226 cp/parser.c:34649 ++#: c/c-parser.c:14226 cp/parser.c:34675 + #, fuzzy, gcc-internal-format + #| msgid "no arguments" + msgid "unexpected argument" + msgstr "няма аргументаў" + +-#: c/c-parser.c:14393 cp/semantics.c:7831 ++#: c/c-parser.c:14393 cp/semantics.c:7847 + #, gcc-internal-format + msgid "% argument needs positive integral constant" + msgstr "" + +-#: c/c-parser.c:14451 c/c-parser.c:14457 cp/parser.c:35503 cp/parser.c:35513 ++#: c/c-parser.c:14451 c/c-parser.c:14457 cp/parser.c:35529 cp/parser.c:35539 + #, gcc-internal-format + msgid "expected %" + msgstr "" + +-#: c/c-parser.c:14491 cp/parser.c:35551 ++#: c/c-parser.c:14491 cp/parser.c:35577 + #, gcc-internal-format + msgid "expected %, % or %" + msgstr "" + +-#: c/c-parser.c:14544 cp/parser.c:35619 ++#: c/c-parser.c:14544 cp/parser.c:35645 + #, gcc-internal-format + msgid "ordered argument needs positive constant integer expression" + msgstr "" + +-#: c/c-parser.c:14669 c/c-parser.c:20764 cp/parser.c:42346 ++#: c/c-parser.c:14669 c/c-parser.c:20764 cp/parser.c:42372 + #, gcc-internal-format + msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier" + msgstr "" + +-#: c/c-parser.c:14782 cp/parser.c:35870 ++#: c/c-parser.c:14782 cp/parser.c:35896 + #, gcc-internal-format + msgid "both % and % modifiers specified" + msgstr "" + +-#: c/c-parser.c:14836 cp/parser.c:35886 ++#: c/c-parser.c:14836 cp/parser.c:35912 + #, gcc-internal-format + msgid "schedule % does not take a % parameter" + msgstr "" + +-#: c/c-parser.c:14840 cp/parser.c:35889 ++#: c/c-parser.c:14840 cp/parser.c:35915 + #, gcc-internal-format + msgid "schedule % does not take a % parameter" + msgstr "" +@@ -42114,7 +42166,7 @@ msgstr "" + msgid "chunk size value must be positive" + msgstr "" + +-#: c/c-parser.c:14875 cp/parser.c:35909 ++#: c/c-parser.c:14875 cp/parser.c:35935 + #, fuzzy, gcc-internal-format + #| msgid "invalid %%-code" + msgid "invalid schedule kind" +@@ -42150,24 +42202,24 @@ msgstr "" + msgid "% clause expression must be positive constant integer expression" + msgstr "" + +-#: c/c-parser.c:15506 cp/parser.c:36551 ++#: c/c-parser.c:15506 cp/parser.c:36577 + #, gcc-internal-format + msgid "% modifier incompatible with %qs" + msgstr "" + +-#: c/c-parser.c:15553 cp/parser.c:36599 cp/parser.c:36828 cp/parser.c:36878 ++#: c/c-parser.c:15553 cp/parser.c:36625 cp/parser.c:36854 cp/parser.c:36904 + #, fuzzy, gcc-internal-format + #| msgid "invalid %%d operand" + msgid "invalid depend kind" + msgstr "нерэчаісны %%d аперанд" + +-#: c/c-parser.c:15640 cp/parser.c:36674 ++#: c/c-parser.c:15640 cp/parser.c:36700 + #, fuzzy, gcc-internal-format + #| msgid "invalid mask" + msgid "invalid map kind" + msgstr "нерэчаісная маска" + +-#: c/c-parser.c:15738 cp/parser.c:36775 ++#: c/c-parser.c:15738 cp/parser.c:36801 + #, gcc-internal-format + msgid "invalid dist_schedule kind" + msgstr "" +@@ -42182,78 +42234,78 @@ msgstr "Нерэчаісны выбар %s" + msgid "expected %, % or %" + msgstr "" + +-#: c/c-parser.c:16082 cp/parser.c:37109 ++#: c/c-parser.c:16082 cp/parser.c:37135 + #, gcc-internal-format + msgid "expected %<#pragma acc%> clause" + msgstr "" + +-#: c/c-parser.c:16093 c/c-parser.c:16417 cp/parser.c:37120 cp/parser.c:37483 ++#: c/c-parser.c:16093 c/c-parser.c:16417 cp/parser.c:37146 cp/parser.c:37509 + #, fuzzy, gcc-internal-format + #| msgid "complex invalid for `%s'" + msgid "%qs is not valid for %qs" + msgstr "complex нерэчаісны для \"%s\"" + +-#: c/c-parser.c:16137 cp/parser.c:37167 ++#: c/c-parser.c:16137 cp/parser.c:37193 + #, gcc-internal-format + msgid "clauses in % trait should be separated by %<,%>" + msgstr "" + +-#: c/c-parser.c:16278 cp/parser.c:37345 ++#: c/c-parser.c:16278 cp/parser.c:37371 + #, gcc-internal-format + msgid "%qs must be the first clause of %qs" + msgstr "" + +-#: c/c-parser.c:16406 cp/parser.c:37472 ++#: c/c-parser.c:16406 cp/parser.c:37498 + #, gcc-internal-format + msgid "expected %<#pragma omp%> clause" + msgstr "" + +-#: c/c-parser.c:16539 cp/parser.c:40925 ++#: c/c-parser.c:16539 cp/parser.c:40951 + #, gcc-internal-format + msgid "no valid clauses specified in %<#pragma acc declare%>" + msgstr "" + +-#: c/c-parser.c:16549 cp/parser.c:40935 ++#: c/c-parser.c:16549 cp/parser.c:40961 + #, gcc-internal-format + msgid "array section in %<#pragma acc declare%>" + msgstr "" + +-#: c/c-parser.c:16569 cp/parser.c:40955 ++#: c/c-parser.c:16569 cp/parser.c:40981 + #, gcc-internal-format + msgid "%qD must be a global variable in %<#pragma acc declare link%>" + msgstr "" + +-#: c/c-parser.c:16580 cp/parser.c:40966 ++#: c/c-parser.c:16580 cp/parser.c:40992 + #, gcc-internal-format + msgid "invalid OpenACC clause at file scope" + msgstr "" + +-#: c/c-parser.c:16587 cp/parser.c:40973 ++#: c/c-parser.c:16587 cp/parser.c:40999 + #, gcc-internal-format + msgid "invalid use of % variable %qD in %<#pragma acc declare%>" + msgstr "" + +-#: c/c-parser.c:16595 cp/parser.c:40981 ++#: c/c-parser.c:16595 cp/parser.c:41007 + #, gcc-internal-format + msgid "invalid use of % variable %qD in %<#pragma acc declare%>" + msgstr "" + +-#: c/c-parser.c:16606 cp/parser.c:40999 ++#: c/c-parser.c:16606 cp/parser.c:41025 + #, gcc-internal-format + msgid "%qD must be a variable declared in the same scope as %<#pragma acc declare%>" + msgstr "" + +-#: c/c-parser.c:16616 cp/parser.c:41009 ++#: c/c-parser.c:16616 cp/parser.c:41035 + #, gcc-internal-format + msgid "variable %qD used more than once with %<#pragma acc declare%>" + msgstr "" + +-#: c/c-parser.c:16709 cp/parser.c:41096 ++#: c/c-parser.c:16709 cp/parser.c:41122 + #, gcc-internal-format + msgid "expected % after %<#pragma acc %s%>" + msgstr "" + +-#: c/c-parser.c:16725 cp/parser.c:41113 ++#: c/c-parser.c:16725 cp/parser.c:41139 + #, gcc-internal-format + msgid "%<#pragma acc %s data%> has no data movement clause" + msgstr "" +@@ -42268,7 +42320,7 @@ msgstr "" + msgid "expected function name" + msgstr "" + +-#: c/c-parser.c:16996 cp/parser.c:42930 ++#: c/c-parser.c:16996 cp/parser.c:42956 + #, fuzzy, gcc-internal-format + #| msgid "`%D' is not a function," + msgid "%qD does not refer to a function" +@@ -42279,68 +42331,68 @@ msgstr "`%D' - гэта ня функцыя," + msgid "%<#pragma acc routine%> not immediately followed by function declaration or definition" + msgstr "" + +-#: c/c-parser.c:17059 cp/parser.c:42984 cp/parser.c:43029 ++#: c/c-parser.c:17059 cp/parser.c:43010 cp/parser.c:43055 + #, gcc-internal-format + msgid "%<#pragma acc routine%> not immediately followed by a single function declaration or definition" + msgstr "" + +-#: c/c-parser.c:17090 cp/parser.c:43058 ++#: c/c-parser.c:17090 cp/parser.c:43084 + #, gcc-internal-format + msgid "%<#pragma acc routine%> must be applied before use" + msgstr "" + +-#: c/c-parser.c:17091 cp/parser.c:43060 ++#: c/c-parser.c:17091 cp/parser.c:43086 + #, gcc-internal-format + msgid "%<#pragma acc routine%> must be applied before definition" + msgstr "" + +-#: c/c-parser.c:17135 cp/parser.c:41314 ++#: c/c-parser.c:17135 cp/parser.c:41340 + #, gcc-internal-format + msgid "%<#pragma acc update%> must contain at least one % or % or % clause" + msgstr "" + +-#: c/c-parser.c:17287 cp/parser.c:37650 ++#: c/c-parser.c:17287 cp/parser.c:37676 + #, gcc-internal-format + msgid "expected %, %, %, %, %, %, %, % or % clause" + msgstr "" + +-#: c/c-parser.c:17296 cp/parser.c:37659 ++#: c/c-parser.c:17296 cp/parser.c:37685 + #, fuzzy, gcc-internal-format + #| msgid "too many input files" + msgid "too many atomic clauses" + msgstr "вельмі шмат уваходзячых файлаў" + +-#: c/c-parser.c:17303 cp/parser.c:37666 ++#: c/c-parser.c:17303 cp/parser.c:37692 + #, gcc-internal-format + msgid "too many memory order clauses" + msgstr "" + +-#: c/c-parser.c:17358 cp/parser.c:37721 ++#: c/c-parser.c:17358 cp/parser.c:37747 + #, gcc-internal-format + msgid "%<#pragma omp atomic read%> incompatible with % or % clauses" + msgstr "" + +-#: c/c-parser.c:17367 cp/parser.c:37730 ++#: c/c-parser.c:17367 cp/parser.c:37756 + #, gcc-internal-format + msgid "%<#pragma omp atomic write%> incompatible with % or % clauses" + msgstr "" + +-#: c/c-parser.c:17376 cp/parser.c:37739 ++#: c/c-parser.c:17376 cp/parser.c:37765 + #, gcc-internal-format + msgid "%<#pragma omp atomic update%> incompatible with % or % clauses" + msgstr "" + +-#: c/c-parser.c:17642 cp/parser.c:37944 cp/parser.c:37970 ++#: c/c-parser.c:17642 cp/parser.c:37970 cp/parser.c:37996 + #, gcc-internal-format + msgid "invalid form of %<#pragma omp atomic%>" + msgstr "" + +-#: c/c-parser.c:17646 cp/parser.c:38001 cp/parser.c:38017 ++#: c/c-parser.c:17646 cp/parser.c:38027 cp/parser.c:38043 + #, gcc-internal-format + msgid "invalid operator for %<#pragma omp atomic%>" + msgstr "" + +-#: c/c-parser.c:17695 cp/semantics.c:9322 cp/semantics.c:9332 ++#: c/c-parser.c:17695 cp/semantics.c:9338 cp/semantics.c:9348 + #, gcc-internal-format + msgid "%<#pragma omp atomic capture%> uses two different expressions for memory" + msgstr "" +@@ -42350,57 +42402,57 @@ msgstr "" + msgid "expected %<(%> or end of line" + msgstr "" + +-#: c/c-parser.c:17804 cp/semantics.c:9397 ++#: c/c-parser.c:17804 cp/semantics.c:9413 + #, gcc-internal-format + msgid "% expression is not lvalue expression" + msgstr "" + +-#: c/c-parser.c:17861 cp/parser.c:38202 ++#: c/c-parser.c:17861 cp/parser.c:38228 + #, gcc-internal-format + msgid "expected %, %, % or %" + msgstr "" + +-#: c/c-parser.c:17873 cp/parser.c:38218 ++#: c/c-parser.c:17873 cp/parser.c:38244 + #, gcc-internal-format + msgid "expected %, % or % clause" + msgstr "" + +-#: c/c-parser.c:17909 cp/parser.c:38251 ++#: c/c-parser.c:17909 cp/parser.c:38277 + #, gcc-internal-format + msgid "expected %, % or %" + msgstr "" + +-#: c/c-parser.c:17916 cp/parser.c:38258 ++#: c/c-parser.c:17916 cp/parser.c:38284 + #, gcc-internal-format + msgid "% list specified together with memory order clause" + msgstr "" + +-#: c/c-parser.c:17975 cp/parser.c:38863 ++#: c/c-parser.c:17975 cp/parser.c:38889 + #, gcc-internal-format + msgid "expected % or % clause" + msgstr "" + +-#: c/c-parser.c:17980 cp/parser.c:38869 ++#: c/c-parser.c:17980 cp/parser.c:38895 + #, gcc-internal-format + msgid "expected %<#pragma omp scan%>" + msgstr "" + +-#: c/c-parser.c:18035 cp/parser.c:38920 ++#: c/c-parser.c:18035 cp/parser.c:38946 + #, gcc-internal-format + msgid "% clause parameter is less than %" + msgstr "" + +-#: c/c-parser.c:18046 cp/parser.c:38931 ++#: c/c-parser.c:18046 cp/parser.c:38957 + #, gcc-internal-format + msgid "% clause may not be specified together with % clause with a parameter" + msgstr "" + +-#: c/c-parser.c:18064 cp/parser.c:38959 ++#: c/c-parser.c:18064 cp/parser.c:38985 + #, fuzzy, gcc-internal-format + msgid "for statement expected" + msgstr "вельмі шмат аргументаў у функцыі" + +-#: c/c-parser.c:18134 cp/semantics.c:8919 cp/semantics.c:9010 ++#: c/c-parser.c:18134 cp/semantics.c:8935 cp/semantics.c:9026 + #, gcc-internal-format + msgid "expected iteration declaration or initialization" + msgstr "" +@@ -42410,72 +42462,72 @@ msgstr "" + msgid "not enough perfectly nested loops" + msgstr "" + +-#: c/c-parser.c:18284 cp/parser.c:39273 ++#: c/c-parser.c:18284 cp/parser.c:39299 + #, gcc-internal-format + msgid "collapsed loops not perfectly nested" + msgstr "" + +-#: c/c-parser.c:18331 cp/parser.c:39069 cp/parser.c:39111 cp/pt.c:17552 ++#: c/c-parser.c:18331 cp/parser.c:39095 cp/parser.c:39137 cp/pt.c:17586 + #, gcc-internal-format + msgid "iteration variable %qD should not be firstprivate" + msgstr "" + +-#: c/c-parser.c:18465 cp/parser.c:39392 ++#: c/c-parser.c:18465 cp/parser.c:39418 + #, gcc-internal-format + msgid "% clause with parameter may not be specified on %qs construct" + msgstr "" + +-#: c/c-parser.c:18678 cp/parser.c:39609 ++#: c/c-parser.c:18678 cp/parser.c:39635 + #, gcc-internal-format + msgid "%<#pragma omp ordered%> with % clause may only be used in compound statements" + msgstr "" + +-#: c/c-parser.c:18886 cp/parser.c:39808 ++#: c/c-parser.c:18886 cp/parser.c:39834 + #, gcc-internal-format + msgid "expected % after %qs" + msgstr "" + +-#: c/c-parser.c:19158 cp/parser.c:40079 ++#: c/c-parser.c:19158 cp/parser.c:40105 + #, gcc-internal-format + msgid "expected %" + msgstr "" + +-#: c/c-parser.c:19407 cp/parser.c:40348 ++#: c/c-parser.c:19407 cp/parser.c:40374 + #, gcc-internal-format + msgid "%<#pragma omp target data%> with map-type other than %, %, % or % on % clause" + msgstr "" + +-#: c/c-parser.c:19423 cp/parser.c:40364 ++#: c/c-parser.c:19423 cp/parser.c:40390 + #, gcc-internal-format + msgid "%<#pragma omp target data%> must contain at least one %, % or % clause" + msgstr "" + +-#: c/c-parser.c:19471 cp/parser.c:40590 ++#: c/c-parser.c:19471 cp/parser.c:40616 + #, gcc-internal-format + msgid "%<#pragma omp target update%> must contain at least one % or % clauses" + msgstr "" + +-#: c/c-parser.c:19543 cp/parser.c:40445 ++#: c/c-parser.c:19543 cp/parser.c:40471 + #, gcc-internal-format + msgid "%<#pragma omp target enter data%> with map-type other than % or % on % clause" + msgstr "" + +-#: c/c-parser.c:19555 cp/parser.c:40457 ++#: c/c-parser.c:19555 cp/parser.c:40483 + #, gcc-internal-format + msgid "%<#pragma omp target enter data%> must contain at least one % clause" + msgstr "" + +-#: c/c-parser.c:19629 cp/parser.c:40534 ++#: c/c-parser.c:19629 cp/parser.c:40560 + #, gcc-internal-format + msgid "%<#pragma omp target exit data%> with map-type other than %, % or % on % clause" + msgstr "" + +-#: c/c-parser.c:19642 cp/parser.c:40547 ++#: c/c-parser.c:19642 cp/parser.c:40573 + #, gcc-internal-format + msgid "%<#pragma omp target exit data%> must contain at least one % clause" + msgstr "" + +-#: c/c-parser.c:19861 cp/parser.c:40804 ++#: c/c-parser.c:19861 cp/parser.c:40830 + #, gcc-internal-format + msgid "%<#pragma omp target%> with map-type other than %, %, % or % on % clause" + msgstr "" +@@ -42490,57 +42542,57 @@ msgstr "" + msgid "%<#pragma omp declare %s%> must be followed by function declaration or definition" + msgstr "" + +-#: c/c-parser.c:20035 cp/parser.c:41465 ++#: c/c-parser.c:20035 cp/parser.c:41491 + #, gcc-internal-format + msgid "expected trait selector name" + msgstr "" + +-#: c/c-parser.c:20088 cp/parser.c:41517 ++#: c/c-parser.c:20088 cp/parser.c:41543 + #, gcc-internal-format + msgid "selector %qs not allowed for context selector set %qs" + msgstr "" + +-#: c/c-parser.c:20113 cp/parser.c:41541 ++#: c/c-parser.c:20113 cp/parser.c:41567 + #, gcc-internal-format + msgid "selector %qs does not accept any properties" + msgstr "" + +-#: c/c-parser.c:20140 cp/parser.c:41580 cp/pt.c:11321 ++#: c/c-parser.c:20140 cp/parser.c:41606 cp/pt.c:11339 + #, gcc-internal-format + msgid "score argument must be constant integer expression" + msgstr "" + +-#: c/c-parser.c:20143 cp/parser.c:41583 cp/pt.c:11338 ++#: c/c-parser.c:20143 cp/parser.c:41609 cp/pt.c:11356 + #, gcc-internal-format + msgid "score argument must be non-negative" + msgstr "" + +-#: c/c-parser.c:20167 cp/parser.c:41611 cp/pt.c:11324 ++#: c/c-parser.c:20167 cp/parser.c:41637 cp/pt.c:11342 + #, gcc-internal-format + msgid "property must be constant integer expression or string literal" + msgstr "" + +-#: c/c-parser.c:20212 cp/parser.c:41655 ++#: c/c-parser.c:20212 cp/parser.c:41681 + #, gcc-internal-format + msgid "expected identifier or string literal" + msgstr "" + +-#: c/c-parser.c:20234 cp/parser.c:41677 cp/pt.c:11328 ++#: c/c-parser.c:20234 cp/parser.c:41703 cp/pt.c:11346 + #, gcc-internal-format + msgid "property must be constant integer expression" + msgstr "" + +-#: c/c-parser.c:20245 cp/parser.c:41688 ++#: c/c-parser.c:20245 cp/parser.c:41714 + #, gcc-internal-format + msgid "properties for % selector may not be specified in %" + msgstr "" + +-#: c/c-parser.c:20332 cp/parser.c:41774 ++#: c/c-parser.c:20332 cp/parser.c:41800 + #, gcc-internal-format + msgid "expected %, %, % or %" + msgstr "" + +-#: c/c-parser.c:20407 cp/parser.c:41882 ++#: c/c-parser.c:20407 cp/parser.c:41908 + #, gcc-internal-format + msgid "expected %" + msgstr "" +@@ -42551,12 +42603,12 @@ msgstr "" + msgid "variant %qD is not a function" + msgstr "`%D' - гэта ня функцыя," + +-#: c/c-parser.c:20433 cp/decl.c:7318 ++#: c/c-parser.c:20433 cp/decl.c:7312 + #, fuzzy, gcc-internal-format + msgid "variant %qD and base %qD have incompatible types" + msgstr "\"%s\" мае незавершаны тып" + +-#: c/c-parser.c:20445 cp/decl.c:7327 ++#: c/c-parser.c:20445 cp/decl.c:7321 + #, gcc-internal-format + msgid "variant %qD is a built-in" + msgstr "" +@@ -42566,32 +42618,32 @@ msgstr "" + msgid "%<#pragma omp declare %s%> not immediately followed by a function declaration or definition" + msgstr "" + +-#: c/c-parser.c:20496 cp/parser.c:41927 ++#: c/c-parser.c:20496 cp/parser.c:41953 + #, gcc-internal-format + msgid "%<#pragma omp declare %s%> not immediately followed by a single function declaration or definition" + msgstr "" + +-#: c/c-parser.c:20605 cp/parser.c:42032 ++#: c/c-parser.c:20605 cp/parser.c:42058 + #, gcc-internal-format + msgid "%qD specified both in declare target % and % clauses" + msgstr "" + +-#: c/c-parser.c:20654 cp/parser.c:42081 ++#: c/c-parser.c:20654 cp/parser.c:42107 + #, gcc-internal-format + msgid "directive with only % clauses ignored" + msgstr "" + +-#: c/c-parser.c:20673 cp/parser.c:42106 ++#: c/c-parser.c:20673 cp/parser.c:42132 + #, gcc-internal-format + msgid "expected %" + msgstr "" + +-#: c/c-parser.c:20680 cp/parser.c:42113 ++#: c/c-parser.c:20680 cp/parser.c:42139 + #, gcc-internal-format + msgid "expected %" + msgstr "" + +-#: c/c-parser.c:20686 cp/parser.c:42120 ++#: c/c-parser.c:20686 cp/parser.c:42146 + #, gcc-internal-format + msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%>" + msgstr "" +@@ -42646,42 +42698,42 @@ msgstr "" + msgid "one of the initializer call arguments should be %<&omp_priv%>" + msgstr "" + +-#: c/c-parser.c:21096 cp/parser.c:42580 ++#: c/c-parser.c:21096 cp/parser.c:42606 + #, gcc-internal-format + msgid "expected %, %, % or %" + msgstr "" + +-#: c/c-parser.c:21160 cp/parser.c:42643 ++#: c/c-parser.c:21160 cp/parser.c:42669 + #, gcc-internal-format + msgid "expected %, % or %" + msgstr "" + +-#: c/c-parser.c:21180 cp/parser.c:42669 ++#: c/c-parser.c:21180 cp/parser.c:42695 + #, gcc-internal-format + msgid "expected %, %, %, % or % clause" + msgstr "" + +-#: c/c-parser.c:21189 cp/parser.c:42678 ++#: c/c-parser.c:21189 cp/parser.c:42704 + #, gcc-internal-format + msgid "%qs clause on % directive not supported yet" + msgstr "" + +-#: c/c-parser.c:21201 cp/parser.c:42690 ++#: c/c-parser.c:21201 cp/parser.c:42716 + #, gcc-internal-format + msgid "%qs clause used lexically after first target construct or offloading API" + msgstr "" + +-#: c/c-parser.c:21213 cp/parser.c:42702 ++#: c/c-parser.c:21213 cp/parser.c:42728 + #, gcc-internal-format + msgid "more than one % clause in a single compilation unit" + msgstr "" + +-#: c/c-parser.c:21222 cp/parser.c:42711 ++#: c/c-parser.c:21222 cp/parser.c:42737 + #, gcc-internal-format + msgid "% clause used lexically after first % construct without memory order clause" + msgstr "" + +-#: c/c-parser.c:21236 cp/parser.c:42725 ++#: c/c-parser.c:21236 cp/parser.c:42751 + #, gcc-internal-format + msgid "% requires at least one clause" + msgstr "" +@@ -42696,27 +42748,27 @@ msgstr "" + msgid "variable sized type %qT in % clause" + msgstr "" + +-#: c/c-parser.c:21497 cp/semantics.c:8358 ++#: c/c-parser.c:21497 cp/semantics.c:8374 + #, gcc-internal-format + msgid "%qE declared % after first use" + msgstr "" + +-#: c/c-parser.c:21499 cp/semantics.c:8360 ++#: c/c-parser.c:21499 cp/semantics.c:8376 + #, gcc-internal-format + msgid "automatic variable %qE cannot be %" + msgstr "" + +-#: c/c-parser.c:21503 cp/semantics.c:8362 ++#: c/c-parser.c:21503 cp/semantics.c:8378 + #, fuzzy, gcc-internal-format + msgid "% %qE has incomplete type" + msgstr "\"%s\" мае незавершаны тып" + +-#: c/c-parser.c:21682 cp/parser.c:43459 ++#: c/c-parser.c:21682 cp/parser.c:43485 + #, gcc-internal-format + msgid "%<__transaction_cancel%> without transactional memory support enabled" + msgstr "" + +-#: c/c-parser.c:21688 cp/parser.c:43465 ++#: c/c-parser.c:21688 cp/parser.c:43491 + #, gcc-internal-format + msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>" + msgstr "" +@@ -42726,7 +42778,7 @@ msgstr "" + msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%> or a % function" + msgstr "" + +-#: c/c-parser.c:21705 cp/parser.c:43483 ++#: c/c-parser.c:21705 cp/parser.c:43509 + #, gcc-internal-format + msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>" + msgstr "" +@@ -42742,7 +42794,7 @@ msgstr "" + msgid "%qD has an incomplete type %qT" + msgstr "\"%s\" мае незавершаны тып" + +-#: c/c-typeck.c:238 c/c-typeck.c:10461 c/c-typeck.c:10503 cp/call.c:4459 ++#: c/c-typeck.c:238 c/c-typeck.c:10461 c/c-typeck.c:10503 cp/call.c:4461 + #, gcc-internal-format + msgid "invalid use of void expression" + msgstr "" +@@ -42863,7 +42915,7 @@ msgstr "" + msgid "subscripted value is neither array nor pointer nor vector" + msgstr "" + +-#: c/c-typeck.c:2642 cp/typeck.c:3529 cp/typeck.c:3622 ++#: c/c-typeck.c:2642 cp/typeck.c:3587 cp/typeck.c:3680 + #, gcc-internal-format + msgid "array subscript is not an integer" + msgstr "" +@@ -42888,7 +42940,7 @@ msgstr "ISO C не дазваляе дэкларацыі метак (label)" + msgid "enum constant defined here" + msgstr "" + +-#: c/c-typeck.c:2926 cp/typeck.c:1773 ++#: c/c-typeck.c:2926 cp/typeck.c:1815 + #, gcc-internal-format + msgid "% on array function parameter %qE will return size of %qT" + msgstr "" +@@ -43004,17 +43056,17 @@ msgstr "" + msgid "too few arguments to built-in function %qE expecting %u" + msgstr "нехапае аргументаў у функцыі \"%s\"" + +-#: c/c-typeck.c:3847 c/c-typeck.c:3875 cp/typeck.c:4952 cp/typeck.c:5221 ++#: c/c-typeck.c:3847 c/c-typeck.c:3875 cp/typeck.c:5010 cp/typeck.c:5279 + #, gcc-internal-format + msgid "comparison with string literal results in unspecified behavior" + msgstr "" + +-#: c/c-typeck.c:3855 c/c-typeck.c:3866 cp/typeck.c:4979 cp/typeck.c:5003 ++#: c/c-typeck.c:3855 c/c-typeck.c:3866 cp/typeck.c:5037 cp/typeck.c:5061 + #, gcc-internal-format + msgid "comparison between pointer and zero character constant" + msgstr "" + +-#: c/c-typeck.c:3858 c/c-typeck.c:3869 cp/typeck.c:4982 cp/typeck.c:5006 ++#: c/c-typeck.c:3858 c/c-typeck.c:3869 cp/typeck.c:5040 cp/typeck.c:5064 + #, gcc-internal-format + msgid "did you mean to dereference the pointer?" + msgstr "" +@@ -43039,7 +43091,7 @@ msgstr "" + msgid "arithmetic on pointer to an incomplete type" + msgstr "" + +-#: c/c-typeck.c:3987 cp/typeck.c:5905 ++#: c/c-typeck.c:3987 cp/typeck.c:5965 + #, gcc-internal-format + msgid "arithmetic on pointer to an empty aggregate" + msgstr "" +@@ -43289,7 +43341,7 @@ msgstr "" + msgid "cast from function call of type %qT to non-matching type %qT" + msgstr "" + +-#: c/c-typeck.c:5896 cp/typeck.c:8243 ++#: c/c-typeck.c:5896 cp/typeck.c:8303 + #, gcc-internal-format + msgid "cast to pointer from integer of different size" + msgstr "" +@@ -43458,7 +43510,7 @@ msgstr "" + msgid "initialization left-hand side might be a candidate for a format attribute" + msgstr "" + +-#: c/c-typeck.c:7138 cp/typeck.c:9349 ++#: c/c-typeck.c:7138 cp/typeck.c:9409 + #, gcc-internal-format + msgid "return type might be a candidate for a format attribute" + msgstr "" +@@ -43618,7 +43670,7 @@ msgstr "" + msgid "array of inappropriate type initialized from string constant" + msgstr "" + +-#: c/c-typeck.c:7912 cp/typeck.c:2149 ++#: c/c-typeck.c:7912 cp/typeck.c:2191 + #, gcc-internal-format + msgid "invalid use of non-lvalue array" + msgstr "" +@@ -43649,7 +43701,7 @@ msgstr "" + msgid "invalid initializer" + msgstr "нерэчаісны ініцыялізатар" + +-#: c/c-typeck.c:8310 cp/decl.c:6709 ++#: c/c-typeck.c:8310 cp/decl.c:6713 + #, gcc-internal-format + msgid "opaque vector types cannot be initialized" + msgstr "" +@@ -43795,7 +43847,7 @@ msgstr "" + msgid "ISO C forbids %" + msgstr "ISO C не падтрымлівае \"goto *expr;\"" + +-#: c/c-typeck.c:10581 c/gimple-parser.c:2404 cp/typeck.c:9797 ++#: c/c-typeck.c:10581 c/gimple-parser.c:2404 cp/typeck.c:9857 + #, fuzzy, gcc-internal-format + #| msgid "function does not return string type" + msgid "function declared % has a % statement" +@@ -43836,7 +43888,7 @@ msgstr "" + msgid "case label is not an integer constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: c/c-typeck.c:10868 cp/parser.c:11624 ++#: c/c-typeck.c:10868 cp/parser.c:11629 + #, gcc-internal-format + msgid "case label not within a switch statement" + msgstr "" +@@ -43846,17 +43898,17 @@ msgstr "" + msgid "% label not within a switch statement" + msgstr "" + +-#: c/c-typeck.c:11052 cp/parser.c:13050 ++#: c/c-typeck.c:11052 cp/parser.c:13055 + #, gcc-internal-format + msgid "break statement not within loop or switch" + msgstr "" + +-#: c/c-typeck.c:11054 cp/parser.c:13073 ++#: c/c-typeck.c:11054 cp/parser.c:13078 + #, gcc-internal-format + msgid "continue statement not within a loop" + msgstr "" + +-#: c/c-typeck.c:11059 cp/parser.c:13063 ++#: c/c-typeck.c:11059 cp/parser.c:13068 + #, gcc-internal-format + msgid "break statement used with OpenMP for loop" + msgstr "" +@@ -43871,7 +43923,7 @@ msgstr "" + msgid "continue statement within %<#pragma simd%> loop body" + msgstr "" + +-#: c/c-typeck.c:11092 cp/cp-gimplify.c:499 ++#: c/c-typeck.c:11092 cp/cp-gimplify.c:500 + #, gcc-internal-format + msgid "statement with no effect" + msgstr "" +@@ -43881,22 +43933,22 @@ msgstr "" + msgid "expression statement has incomplete type" + msgstr "" + +-#: c/c-typeck.c:11970 c/c-typeck.c:12138 cp/typeck.c:5235 ++#: c/c-typeck.c:11970 c/c-typeck.c:12138 cp/typeck.c:5293 + #, gcc-internal-format + msgid "comparing vectors with different element types" + msgstr "" + +-#: c/c-typeck.c:11978 c/c-typeck.c:12146 cp/typeck.c:5248 ++#: c/c-typeck.c:11978 c/c-typeck.c:12146 cp/typeck.c:5306 + #, gcc-internal-format + msgid "comparing vectors with different number of elements" + msgstr "" + +-#: c/c-typeck.c:12003 c/c-typeck.c:12171 cp/typeck.c:5283 ++#: c/c-typeck.c:12003 c/c-typeck.c:12171 cp/typeck.c:5341 + #, gcc-internal-format + msgid "could not find an integer type of the same size as %qT" + msgstr "" + +-#: c/c-typeck.c:12017 cp/typeck.c:4941 ++#: c/c-typeck.c:12017 cp/typeck.c:4999 + #, gcc-internal-format + msgid "comparing floating-point with %<==%> or % is unsafe" + msgstr "" +@@ -43947,7 +43999,7 @@ msgid "ordered comparison of pointer with null pointer" + msgstr "" + + #: c/c-typeck.c:12230 c/c-typeck.c:12233 c/c-typeck.c:12240 c/c-typeck.c:12243 +-#: cp/typeck.c:5306 cp/typeck.c:5313 ++#: cp/typeck.c:5364 cp/typeck.c:5371 + #, gcc-internal-format + msgid "ordered comparison of pointer with integer zero" + msgstr "" +@@ -43977,51 +44029,51 @@ msgstr "" + msgid "used vector type where scalar is required" + msgstr "" + +-#: c/c-typeck.c:12840 cp/semantics.c:9470 ++#: c/c-typeck.c:12840 cp/semantics.c:9486 + #, gcc-internal-format + msgid "%<#pragma omp cancel%> must specify one of %, %, % or % clauses" + msgstr "" + +-#: c/c-typeck.c:12851 c/c-typeck.c:12861 cp/semantics.c:9481 +-#: cp/semantics.c:9491 ++#: c/c-typeck.c:12851 c/c-typeck.c:12861 cp/semantics.c:9497 ++#: cp/semantics.c:9507 + #, gcc-internal-format + msgid "expected % % clause modifier" + msgstr "" + +-#: c/c-typeck.c:12896 cp/semantics.c:9526 ++#: c/c-typeck.c:12896 cp/semantics.c:9542 + #, gcc-internal-format + msgid "%<#pragma omp cancellation point%> must specify one of %, %, % or % clauses" + msgstr "" + +-#: c/c-typeck.c:12940 c/c-typeck.c:14498 c/c-typeck.c:14569 c/c-typeck.c:14640 ++#: c/c-typeck.c:12940 c/c-typeck.c:14498 c/c-typeck.c:14585 c/c-typeck.c:14656 + #, gcc-internal-format + msgid "%<_Atomic%> %qE in %qs clause" + msgstr "" + +-#: c/c-typeck.c:12952 c/c-typeck.c:14430 c/c-typeck.c:14555 +-#: cp/semantics.c:4766 cp/semantics.c:7226 cp/semantics.c:7368 ++#: c/c-typeck.c:12952 c/c-typeck.c:14430 c/c-typeck.c:14571 ++#: cp/semantics.c:4766 cp/semantics.c:7226 cp/semantics.c:7384 + #, gcc-internal-format + msgid "bit-field %qE in %qs clause" + msgstr "" + +-#: c/c-typeck.c:12961 c/c-typeck.c:14579 cp/semantics.c:4776 +-#: cp/semantics.c:7387 ++#: c/c-typeck.c:12961 c/c-typeck.c:14595 cp/semantics.c:4776 ++#: cp/semantics.c:7403 + #, gcc-internal-format + msgid "%qE is a member of a union" + msgstr "" + +-#: c/c-typeck.c:12969 c/c-typeck.c:14588 ++#: c/c-typeck.c:12969 c/c-typeck.c:14604 + #, fuzzy, gcc-internal-format + msgid "cannot dereference %qE in %qs clause" + msgstr "Не магу знайсці файл для класа %s." + +-#: c/c-typeck.c:12980 cp/semantics.c:4792 cp/semantics.c:7414 ++#: c/c-typeck.c:12980 cp/semantics.c:4792 cp/semantics.c:7430 + #, gcc-internal-format + msgid "%qD is not a variable in %qs clause" + msgstr "" + +-#: c/c-typeck.c:12984 c/c-typeck.c:14605 cp/semantics.c:4796 +-#: cp/semantics.c:7418 ++#: c/c-typeck.c:12984 c/c-typeck.c:14621 cp/semantics.c:4796 ++#: cp/semantics.c:7434 + #, gcc-internal-format + msgid "%qE is not a variable in %qs clause" + msgstr "" +@@ -44031,8 +44083,8 @@ msgstr "" + msgid "%<_Atomic%> %qD in %qs clause" + msgstr "" + +-#: c/c-typeck.c:13000 c/c-typeck.c:14612 c/c-typeck.c:14722 +-#: cp/semantics.c:4814 cp/semantics.c:7425 cp/semantics.c:7604 ++#: c/c-typeck.c:13000 c/c-typeck.c:14628 c/c-typeck.c:14738 ++#: cp/semantics.c:4814 cp/semantics.c:7441 cp/semantics.c:7620 + #, gcc-internal-format + msgid "%qD is threadprivate variable in %qs clause" + msgstr "" +@@ -44200,12 +44252,12 @@ msgstr "" + msgid "variable length element type in array % clause" + msgstr "" + +-#: c/c-typeck.c:14112 c/c-typeck.c:14796 cp/semantics.c:8045 ++#: c/c-typeck.c:14112 c/c-typeck.c:14812 cp/semantics.c:8061 + #, gcc-internal-format + msgid "% clause must not be used together with %" + msgstr "" + +-#: c/c-typeck.c:14124 cp/semantics.c:8088 ++#: c/c-typeck.c:14124 cp/semantics.c:8104 + #, gcc-internal-format + msgid "%qE must be % for %" + msgstr "" +@@ -44230,8 +44282,8 @@ msgstr "" + msgid "% clause step %qE is neither constant nor a parameter" + msgstr "" + +-#: c/c-typeck.c:14203 c/c-typeck.c:14715 c/c-typeck.c:14920 +-#: cp/semantics.c:6595 cp/semantics.c:7597 cp/semantics.c:7892 ++#: c/c-typeck.c:14203 c/c-typeck.c:14731 c/c-typeck.c:14936 ++#: cp/semantics.c:6595 cp/semantics.c:7613 cp/semantics.c:7908 + #, gcc-internal-format + msgid "%qE is not a variable in clause %qs" + msgstr "" +@@ -44246,19 +44298,19 @@ msgstr "" + msgid "%qE appears more than once in data clauses" + msgstr "" + +-#: c/c-typeck.c:14239 c/c-typeck.c:14270 c/c-typeck.c:14519 c/c-typeck.c:14651 +-#: c/c-typeck.c:14658 c/c-typeck.c:14674 c/c-typeck.c:14685 ++#: c/c-typeck.c:14239 c/c-typeck.c:14270 c/c-typeck.c:14519 c/c-typeck.c:14667 ++#: c/c-typeck.c:14674 c/c-typeck.c:14690 c/c-typeck.c:14701 + #: cp/semantics.c:6623 cp/semantics.c:6631 cp/semantics.c:6688 + #: cp/semantics.c:6695 cp/semantics.c:6739 cp/semantics.c:7317 +-#: cp/semantics.c:7476 cp/semantics.c:7483 cp/semantics.c:7501 +-#: cp/semantics.c:7512 ++#: cp/semantics.c:7492 cp/semantics.c:7499 cp/semantics.c:7517 ++#: cp/semantics.c:7528 + #, gcc-internal-format + msgid "%qD appears more than once in data clauses" + msgstr "" + +-#: c/c-typeck.c:14242 c/c-typeck.c:14273 c/c-typeck.c:14661 c/c-typeck.c:14688 +-#: cp/semantics.c:6634 cp/semantics.c:6698 cp/semantics.c:7486 +-#: cp/semantics.c:7515 ++#: c/c-typeck.c:14242 c/c-typeck.c:14273 c/c-typeck.c:14677 c/c-typeck.c:14704 ++#: cp/semantics.c:6634 cp/semantics.c:6698 cp/semantics.c:7502 ++#: cp/semantics.c:7531 + #, gcc-internal-format + msgid "%qD appears both in data and map clauses" + msgstr "" +@@ -44328,116 +44380,116 @@ msgstr "" + msgid "array section does not have mappable type in %qs clause" + msgstr "" + +-#: c/c-typeck.c:14515 c/c-typeck.c:14671 cp/semantics.c:7313 +-#: cp/semantics.c:7498 ++#: c/c-typeck.c:14515 c/c-typeck.c:14687 cp/semantics.c:7313 ++#: cp/semantics.c:7514 + #, gcc-internal-format + msgid "%qD appears more than once in motion clauses" + msgstr "" + +-#: c/c-typeck.c:14523 c/c-typeck.c:14677 cp/semantics.c:7321 +-#: cp/semantics.c:7504 ++#: c/c-typeck.c:14523 c/c-typeck.c:14693 cp/semantics.c:7321 ++#: cp/semantics.c:7520 + #, gcc-internal-format + msgid "%qD appears more than once in map clauses" + msgstr "" + +-#: c/c-typeck.c:14562 cp/semantics.c:7375 ++#: c/c-typeck.c:14578 cp/semantics.c:7391 + #, gcc-internal-format + msgid "%qE does not have a mappable type in %qs clause" + msgstr "" + +-#: c/c-typeck.c:14631 c/c-typeck.c:14729 cp/semantics.c:7455 +-#: cp/semantics.c:7611 ++#: c/c-typeck.c:14647 c/c-typeck.c:14745 cp/semantics.c:7471 ++#: cp/semantics.c:7627 + #, gcc-internal-format + msgid "%qD does not have a mappable type in %qs clause" + msgstr "" + +-#: c/c-typeck.c:14710 cp/semantics.c:7591 ++#: c/c-typeck.c:14726 cp/semantics.c:7607 + #, gcc-internal-format + msgid "%qE is neither a variable nor a function name in clause %qs" + msgstr "" + +-#: c/c-typeck.c:14738 cp/semantics.c:7621 ++#: c/c-typeck.c:14754 cp/semantics.c:7637 + #, gcc-internal-format + msgid "%qE appears more than once on the same % directive" + msgstr "" + +-#: c/c-typeck.c:14752 cp/semantics.c:7637 ++#: c/c-typeck.c:14768 cp/semantics.c:7653 + #, gcc-internal-format + msgid "%qD is not an argument in % clause" + msgstr "" + +-#: c/c-typeck.c:14755 cp/semantics.c:7640 ++#: c/c-typeck.c:14771 cp/semantics.c:7656 + #, gcc-internal-format + msgid "%qE is not an argument in % clause" + msgstr "" + +-#: c/c-typeck.c:14772 ++#: c/c-typeck.c:14788 + #, gcc-internal-format + msgid "%qs variable is not a pointer" + msgstr "" + +-#: c/c-typeck.c:14779 ++#: c/c-typeck.c:14795 + #, gcc-internal-format + msgid "%qs variable is neither a pointer nor an array" + msgstr "" + +-#: c/c-typeck.c:14809 c/c-typeck.c:14881 cp/semantics.c:8034 ++#: c/c-typeck.c:14825 c/c-typeck.c:14897 cp/semantics.c:8050 + #, gcc-internal-format + msgid "% clause must not be used together with %" + msgstr "" + +-#: c/c-typeck.c:14903 cp/semantics.c:7860 ++#: c/c-typeck.c:14919 cp/semantics.c:7876 + #, gcc-internal-format + msgid "% clause is incompatible with %" + msgstr "" + +-#: c/c-typeck.c:14970 cp/semantics.c:8147 ++#: c/c-typeck.c:14986 cp/semantics.c:8163 + #, gcc-internal-format + msgid "%qE is predetermined %qs for %qs" + msgstr "" + +-#: c/c-typeck.c:14980 ++#: c/c-typeck.c:14996 + #, gcc-internal-format + msgid "% qualified %qE may appear only in % or % clauses" + msgstr "" + +-#: c/c-typeck.c:14999 cp/semantics.c:7986 ++#: c/c-typeck.c:15015 cp/semantics.c:8002 + #, gcc-internal-format + msgid "% clause value is bigger than % clause value" + msgstr "" + +-#: c/c-typeck.c:15011 cp/semantics.c:7999 ++#: c/c-typeck.c:15027 cp/semantics.c:8015 + #, gcc-internal-format + msgid "% schedule modifier specified together with % clause" + msgstr "" + +-#: c/c-typeck.c:15022 c/c-typeck.c:15030 cp/semantics.c:8008 +-#: cp/semantics.c:8026 ++#: c/c-typeck.c:15038 c/c-typeck.c:15046 cp/semantics.c:8024 ++#: cp/semantics.c:8042 + #, gcc-internal-format + msgid "%qs clause specified together with % % clause" + msgstr "" + +-#: c/c-typeck.c:15045 cp/semantics.c:7966 ++#: c/c-typeck.c:15061 cp/semantics.c:7982 + #, gcc-internal-format + msgid "% clause step is a parameter %qD not specified in % clause" + msgstr "" + +-#: c/c-typeck.c:15062 cp/semantics.c:8016 ++#: c/c-typeck.c:15078 cp/semantics.c:8032 + #, gcc-internal-format + msgid "% clause must not be used together with % clause" + msgstr "" + +-#: c/c-typeck.c:15229 ++#: c/c-typeck.c:15245 + #, gcc-internal-format + msgid "cannot use % with reverse storage order" + msgstr "" + +-#: c/c-typeck.c:15234 ++#: c/c-typeck.c:15250 + #, fuzzy, gcc-internal-format + msgid "second argument to % is of incomplete type %qT" + msgstr "\"%s\" мае незавершаны тып" + +-#: c/c-typeck.c:15240 ++#: c/c-typeck.c:15256 + #, gcc-internal-format + msgid "C++ requires promoted type, not enum type, in %" + msgstr "" +@@ -44625,789 +44677,789 @@ msgid "expected case label" + msgstr "" + + #. A bad conversion for 'this' must be discarding cv-quals. +-#: cp/call.c:3652 ++#: cp/call.c:3654 + #, gcc-internal-format + msgid " passing %qT as % argument discards qualifiers" + msgstr "" + +-#: cp/call.c:3656 ++#: cp/call.c:3658 + msgid " no known conversion for implicit % parameter from %qH to %qI" + msgstr "" + +-#: cp/call.c:3663 ++#: cp/call.c:3665 + #, gcc-internal-format, gfc-internal-format + msgid " conversion of argument %d would be ill-formed:" + msgstr "" + + #. Conversion of conversion function return value failed. +-#: cp/call.c:3670 ++#: cp/call.c:3672 + #, fuzzy + #| msgid "converting from `%T' to `%T'" + msgid " no known conversion from %qH to %qI" + msgstr "пераўтварэньне з `%T' у `%T'" + +-#: cp/call.c:3676 ++#: cp/call.c:3678 + msgid " no known conversion for argument %d from %qH to %qI" + msgstr "" + +-#: cp/call.c:3688 cp/pt.c:6807 ++#: cp/call.c:3690 cp/pt.c:6816 + #, gcc-internal-format, gfc-internal-format + msgid " candidate expects %d argument, %d provided" + msgid_plural " candidate expects %d arguments, %d provided" + msgstr[0] "" + msgstr[1] "" + +-#: cp/call.c:3716 ++#: cp/call.c:3718 + #, gcc-internal-format + msgid "%s%<%D(%T, %T, %T)%> (built-in)" + msgstr "" + +-#: cp/call.c:3721 ++#: cp/call.c:3723 + #, gcc-internal-format + msgid "%s%<%D(%T, %T)%> (built-in)" + msgstr "" + +-#: cp/call.c:3725 ++#: cp/call.c:3727 + #, gcc-internal-format + msgid "%s%<%D(%T)%> (built-in)" + msgstr "" + +-#: cp/call.c:3729 ++#: cp/call.c:3731 + #, gcc-internal-format + msgid "%s%qT (conversion)" + msgstr "" + +-#: cp/call.c:3731 ++#: cp/call.c:3733 + #, gcc-internal-format + msgid "%s%#qD (near match)" + msgstr "" + +-#: cp/call.c:3733 ++#: cp/call.c:3735 + #, gcc-internal-format + msgid "%s%#qD (deleted)" + msgstr "" + +-#: cp/call.c:3735 ++#: cp/call.c:3737 + #, gcc-internal-format + msgid "%s%#qD (reversed)" + msgstr "" + +-#: cp/call.c:3737 ++#: cp/call.c:3739 + #, gcc-internal-format + msgid "%s%#qD (rewritten)" + msgstr "" + +-#: cp/call.c:3739 ++#: cp/call.c:3741 + #, gcc-internal-format + msgid "%s%#qD" + msgstr "" + +-#: cp/call.c:3743 ++#: cp/call.c:3745 + #, gcc-internal-format + msgid " inherited here" + msgstr "" + +-#: cp/call.c:3763 ++#: cp/call.c:3765 + #, gcc-internal-format + msgid " return type %qT of explicit conversion function cannot be converted to %qT with a qualification conversion" + msgstr "" + +-#: cp/call.c:3769 ++#: cp/call.c:3771 + #, gcc-internal-format + msgid " conversion from return type %qT of template conversion function specialization to %qT is not an exact match" + msgstr "" + +-#: cp/call.c:3780 ++#: cp/call.c:3782 + #, gcc-internal-format + msgid " substitution of deduced template arguments resulted in errors seen above" + msgstr "" + + #. Re-run template unification with diagnostics. +-#: cp/call.c:3785 ++#: cp/call.c:3787 + #, fuzzy, gcc-internal-format + msgid " template argument deduction/substitution failed:" + msgstr "параметр \"%s\" ініцыялізаваны" + +-#: cp/call.c:3799 ++#: cp/call.c:3801 + #, gcc-internal-format + msgid " a constructor taking a single argument of its own class type is invalid" + msgstr "" + +-#: cp/call.c:3806 ++#: cp/call.c:3808 + #, gcc-internal-format + msgid " an inherited constructor is not a candidate for initialization from an expression of the same or derived type" + msgstr "" + +-#: cp/call.c:4199 ++#: cp/call.c:4201 + msgid "conversion from %qH to %qI is ambiguous" + msgstr "" + +-#: cp/call.c:4345 ++#: cp/call.c:4347 + msgid "initializing %qH with %qI in converted constant expression does not bind directly" + msgstr "" + +-#: cp/call.c:4366 ++#: cp/call.c:4368 + msgid "conversion from %qH to %qI in a converted constant expression" + msgstr "" + +-#: cp/call.c:4400 cp/call.c:11869 cp/cvt.c:855 ++#: cp/call.c:4402 cp/call.c:11899 cp/cvt.c:855 + msgid "could not convert %qE from %qH to %qI" + msgstr "" + +-#: cp/call.c:4548 ++#: cp/call.c:4550 + #, gcc-internal-format + msgid "no matching function for call to %<%D(%A)%>" + msgstr "" + +-#: cp/call.c:4551 ++#: cp/call.c:4553 + #, gcc-internal-format + msgid "call of overloaded %<%D(%A)%> is ambiguous" + msgstr "" + + #. It's no good looking for an overloaded operator() on a + #. pointer-to-member-function. +-#: cp/call.c:4775 ++#: cp/call.c:4777 + #, gcc-internal-format + msgid "pointer-to-member function %qE cannot be called without an object; consider using %<.*%> or %<->*%>" + msgstr "" + +-#: cp/call.c:4847 ++#: cp/call.c:4849 + #, gcc-internal-format + msgid "no match for call to %<(%T) (%A)%>" + msgstr "" + +-#: cp/call.c:4861 ++#: cp/call.c:4863 + #, fuzzy, gcc-internal-format + msgid "call of %<(%T) (%A)%> is ambiguous" + msgstr "памер \"%s\" - %d байт" + +-#: cp/call.c:4913 ++#: cp/call.c:4915 + #, gcc-internal-format + msgid "ambiguous overload for " + msgstr "" + +-#: cp/call.c:4914 ++#: cp/call.c:4916 + #, gcc-internal-format + msgid "no match for " + msgstr "" + +-#: cp/call.c:4917 ++#: cp/call.c:4919 + #, gcc-internal-format + msgid " (operand types are %qT, %qT, and %qT)" + msgstr "" + +-#: cp/call.c:4919 ++#: cp/call.c:4921 + #, gcc-internal-format + msgid " (operand types are %qT and %qT)" + msgstr "" + +-#: cp/call.c:4921 ++#: cp/call.c:4923 + #, gcc-internal-format + msgid " (operand type is %qT)" + msgstr "" + +-#: cp/call.c:4938 ++#: cp/call.c:4940 + #, fuzzy, gcc-internal-format + msgid "ternary %" + msgstr "Унутраная памылка: %s" + +-#: cp/call.c:4942 ++#: cp/call.c:4944 + #, gcc-internal-format + msgid "ternary % in %<%E ? %E : %E%>" + msgstr "" + +-#: cp/call.c:4951 cp/call.c:4995 cp/call.c:5005 ++#: cp/call.c:4953 cp/call.c:4997 cp/call.c:5007 + #, gcc-internal-format + msgid "%" + msgstr "" + +-#: cp/call.c:4954 ++#: cp/call.c:4956 + #, gcc-internal-format + msgid "% in %<%E%s%>" + msgstr "" + +-#: cp/call.c:4961 ++#: cp/call.c:4963 + #, gcc-internal-format + msgid "%" + msgstr "" + +-#: cp/call.c:4964 ++#: cp/call.c:4966 + #, gcc-internal-format + msgid "% in %<%E[%E]%>" + msgstr "" + +-#: cp/call.c:4972 ++#: cp/call.c:4974 + #, fuzzy, gcc-internal-format + #| msgid "%s\n" + msgid "%qs" + msgstr "%s\n" + +-#: cp/call.c:4975 ++#: cp/call.c:4977 + #, gcc-internal-format + msgid "%qs in %<%s %E%>" + msgstr "" + +-#: cp/call.c:4981 ++#: cp/call.c:4983 + #, gcc-internal-format + msgid "%" + msgstr "" + +-#: cp/call.c:4984 ++#: cp/call.c:4986 + #, gcc-internal-format + msgid "% in %<%s%E%>" + msgstr "" + +-#: cp/call.c:4999 ++#: cp/call.c:5001 + #, gcc-internal-format + msgid "% in %<%E %s %E%>" + msgstr "" + +-#: cp/call.c:5008 ++#: cp/call.c:5010 + #, gcc-internal-format + msgid "% in %<%s%E%>" + msgstr "" + +-#: cp/call.c:5118 ++#: cp/call.c:5120 + #, fuzzy, gcc-internal-format + msgid "ISO C++ forbids omitting the middle term of a % expression" + msgstr "ISO C не дазваляе пусты ізыходны файл" + +-#: cp/call.c:5185 ++#: cp/call.c:5187 + #, gcc-internal-format + msgid "inferred scalar type %qT is not an integer or floating-point type of the same size as %qT" + msgstr "" + +-#: cp/call.c:5202 cp/call.c:5209 ++#: cp/call.c:5204 cp/call.c:5211 + msgid "conversion of scalar %qH to vector %qI involves truncation" + msgstr "" + +-#: cp/call.c:5265 ++#: cp/call.c:5267 + #, gcc-internal-format + msgid "incompatible vector types in conditional expression: %qT, %qT and %qT" + msgstr "" + +-#: cp/call.c:5345 ++#: cp/call.c:5347 + #, gcc-internal-format + msgid "second operand to the conditional operator is of type %, but the third operand is neither a throw-expression nor of type %" + msgstr "" + +-#: cp/call.c:5350 ++#: cp/call.c:5352 + #, gcc-internal-format + msgid "third operand to the conditional operator is of type %, but the second operand is neither a throw-expression nor of type %" + msgstr "" + +-#: cp/call.c:5399 cp/call.c:5516 cp/call.c:5664 ++#: cp/call.c:5401 cp/call.c:5518 cp/call.c:5666 + #, gcc-internal-format + msgid "operands to % have different types %qT and %qT" + msgstr "" + +-#: cp/call.c:5403 ++#: cp/call.c:5405 + #, gcc-internal-format + msgid " and each type can be converted to the other" + msgstr "" + +-#: cp/call.c:5592 ++#: cp/call.c:5594 + msgid "implicit conversion from %qH to %qI to match other result of conditional" + msgstr "" + +-#: cp/call.c:5608 ++#: cp/call.c:5610 + #, gcc-internal-format + msgid "enumerated mismatch in conditional expression: %qT vs %qT" + msgstr "" + +-#: cp/call.c:5620 ++#: cp/call.c:5622 + #, gcc-internal-format + msgid "enumerated and non-enumerated type in conditional expression" + msgstr "" + +-#: cp/call.c:6223 ++#: cp/call.c:6225 + #, gcc-internal-format + msgid "no %<%D(int)%> declared for postfix %qs, trying prefix operator instead" + msgstr "" + +-#: cp/call.c:6225 ++#: cp/call.c:6227 + #, gcc-internal-format + msgid "no %<%D(int)%> declared for postfix %qs" + msgstr "" + +-#: cp/call.c:6303 ++#: cp/call.c:6305 + #, gcc-internal-format + msgid "in C++20 this comparison calls the current function recursively with reversed arguments" + msgstr "" + +-#: cp/call.c:6359 ++#: cp/call.c:6361 + #, fuzzy, gcc-internal-format + #| msgid "return type of `%s' is not `int'" + msgid "return type of %qD is not %qs" + msgstr "вяртаемы тып \"%s\" не \"int\"" + +-#: cp/call.c:6361 ++#: cp/call.c:6363 + #, gcc-internal-format + msgid "used as rewritten candidate for comparison of %qT and %qT" + msgstr "" + +-#: cp/call.c:6431 ++#: cp/call.c:6434 + #, gcc-internal-format + msgid "comparison between %q#T and %q#T" + msgstr "" + +-#: cp/call.c:6815 ++#: cp/call.c:6818 + #, gcc-internal-format + msgid "exception cleanup for this placement new selects non-placement %" + msgstr "" + +-#: cp/call.c:6818 ++#: cp/call.c:6821 + #, gcc-internal-format + msgid "%qD is a usual (non-placement) deallocation function in C++14 (or with %<-fsized-deallocation%>)" + msgstr "" + +-#: cp/call.c:6857 ++#: cp/call.c:6860 + #, gcc-internal-format + msgid "%qD is a usual (non-placement) deallocation function" + msgstr "" + +-#: cp/call.c:7021 ++#: cp/call.c:7024 + #, gcc-internal-format + msgid "no corresponding deallocation function for %qD" + msgstr "" + +-#: cp/call.c:7027 ++#: cp/call.c:7030 + #, fuzzy, gcc-internal-format + #| msgid "impossible operator '%s'" + msgid "no suitable % for %qT" + msgstr "немагчымы апэратар '%s'" + +-#: cp/call.c:7045 ++#: cp/call.c:7048 + #, gcc-internal-format + msgid "%q#D is private within this context" + msgstr "" + +-#: cp/call.c:7047 cp/decl.c:7981 ++#: cp/call.c:7050 cp/decl.c:7978 + #, fuzzy, gcc-internal-format + msgid "declared private here" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/call.c:7052 ++#: cp/call.c:7055 + #, fuzzy, gcc-internal-format + msgid "%q#D is protected within this context" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/call.c:7054 cp/decl.c:7982 ++#: cp/call.c:7057 cp/decl.c:7979 + #, fuzzy, gcc-internal-format + #| msgid "called from here" + msgid "declared protected here" + msgstr "выклікана адсюль" + +-#: cp/call.c:7059 ++#: cp/call.c:7062 + #, gcc-internal-format + msgid "%q#D is inaccessible within this context" + msgstr "" + +-#: cp/call.c:7168 ++#: cp/call.c:7171 + #, gcc-internal-format + msgid "passing NULL to non-pointer argument %P of %qD" + msgstr "" + +-#: cp/call.c:7171 cp/call.c:7190 cp/decl.c:9647 cp/typeck.c:4128 ++#: cp/call.c:7174 cp/call.c:7193 cp/decl.c:9647 cp/typeck.c:4186 + #, fuzzy, gcc-internal-format + #| msgid " from here" + msgid " declared here" + msgstr " адсюль" + +-#: cp/call.c:7175 ++#: cp/call.c:7178 + #, gcc-internal-format + msgid "converting to non-pointer type %qT from NULL" + msgstr "" + +-#: cp/call.c:7187 ++#: cp/call.c:7190 + #, gcc-internal-format + msgid "converting % to pointer type for argument %P of %qD" + msgstr "" + +-#: cp/call.c:7194 ++#: cp/call.c:7197 + #, gcc-internal-format + msgid "converting % to pointer type %qT" + msgstr "" + +-#: cp/call.c:7261 ++#: cp/call.c:7264 + #, gcc-internal-format + msgid " initializing argument %P of %qD" + msgstr "" + +-#: cp/call.c:7281 ++#: cp/call.c:7284 + #, gcc-internal-format + msgid "conversions to arrays of unknown bound are only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/call.c:7327 ++#: cp/call.c:7363 + #, fuzzy, gcc-internal-format + msgid "too many braces around initializer for %qT" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/call.c:7338 ++#: cp/call.c:7374 + msgid "converting to %qH from %qI requires direct-initialization" + msgstr "" + +-#: cp/call.c:7347 ++#: cp/call.c:7383 + msgid "invalid user-defined conversion from %qH to %qI" + msgstr "" + +-#: cp/call.c:7387 cp/cvt.c:227 ++#: cp/call.c:7423 cp/cvt.c:227 + #, fuzzy + #| msgid "converting from `%T' to `%T'" + msgid "invalid conversion from %qH to %qI" + msgstr "пераўтварэньне з `%T' у `%T'" + +-#: cp/call.c:7442 cp/call.c:7449 ++#: cp/call.c:7465 cp/call.c:7472 + #, gcc-internal-format + msgid "converting to %qT from initializer list would use explicit constructor %qD" + msgstr "" + +-#: cp/call.c:7445 ++#: cp/call.c:7468 + #, gcc-internal-format + msgid "in C++11 and above a default constructor can be explicit" + msgstr "" + +-#: cp/call.c:7715 ++#: cp/call.c:7738 + msgid "cannot bind rvalue reference of type %qH to lvalue of type %qI" + msgstr "" + +-#: cp/call.c:7719 ++#: cp/call.c:7742 + msgid "cannot bind non-const lvalue reference of type %qH to an rvalue of type %qI" + msgstr "" + +-#: cp/call.c:7730 ++#: cp/call.c:7753 + msgid "cannot bind reference of type %qH to %qI due to different array bounds" + msgstr "" + +-#: cp/call.c:7733 ++#: cp/call.c:7756 + msgid "binding reference of type %qH to %qI discards qualifiers" + msgstr "" + +-#: cp/call.c:7772 ++#: cp/call.c:7795 + #, fuzzy, gcc-internal-format + msgid "cannot bind bit-field %qE to %qT" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/call.c:7775 cp/call.c:7793 ++#: cp/call.c:7798 cp/call.c:7816 + #, gcc-internal-format + msgid "cannot bind packed field %qE to %qT" + msgstr "" + +-#: cp/call.c:7778 ++#: cp/call.c:7801 + #, fuzzy, gcc-internal-format + msgid "cannot bind rvalue %qE to %qT" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/call.c:7897 ++#: cp/call.c:7920 + msgid "implicit conversion from %qH to %qI when passing argument to function" + msgstr "" + +-#: cp/call.c:7921 cp/cvt.c:1978 ++#: cp/call.c:7944 cp/cvt.c:1977 + #, gcc-internal-format + msgid "scoped enum %qT passed through %<...%> as %qT before %<-fabi-version=6%>, %qT after" + msgstr "" + +-#: cp/call.c:7965 ++#: cp/call.c:7988 + #, gcc-internal-format + msgid "passing objects of non-trivially-copyable type %q#T through %<...%> is conditionally supported" + msgstr "" + +-#: cp/call.c:8001 ++#: cp/call.c:8024 + #, gcc-internal-format + msgid "cannot receive reference type %qT through %<...%>" + msgstr "" + +-#: cp/call.c:8011 ++#: cp/call.c:8034 + #, gcc-internal-format + msgid "receiving objects of non-trivially-copyable type %q#T through %<...%> is conditionally-supported" + msgstr "" + +-#: cp/call.c:8079 ++#: cp/call.c:8102 + #, fuzzy, gcc-internal-format + msgid "recursive evaluation of default argument for %q#D" + msgstr "нехапае аргументаў у функцыі \"%s\"" + +-#: cp/call.c:8088 ++#: cp/call.c:8111 + #, gcc-internal-format + msgid "call to %qD uses the default argument for parameter %P, which is not yet defined" + msgstr "" + +-#: cp/call.c:8192 ++#: cp/call.c:8215 + #, gcc-internal-format + msgid "argument of function call might be a candidate for a format attribute" + msgstr "" + +-#: cp/call.c:8251 ++#: cp/call.c:8274 + #, gcc-internal-format + msgid "use of multiversioned function without a default" + msgstr "" + +-#: cp/call.c:8678 ++#: cp/call.c:8701 + #, gcc-internal-format + msgid "passing %qT as % argument discards qualifiers" + msgstr "" + +-#: cp/call.c:8681 cp/call.c:11309 ++#: cp/call.c:8704 cp/call.c:11338 + #, gcc-internal-format + msgid " in call to %qD" + msgstr "" + +-#: cp/call.c:8718 ++#: cp/call.c:8747 + #, gcc-internal-format + msgid "%qT is not an accessible base of %qT" + msgstr "" + +-#: cp/call.c:8886 ++#: cp/call.c:8915 + #, gcc-internal-format + msgid "passing arguments to ellipsis of inherited constructor %qD" + msgstr "" + +-#: cp/call.c:9017 ++#: cp/call.c:9046 + #, gcc-internal-format + msgid "assignment from temporary % does not extend the lifetime of the underlying array" + msgstr "" + +-#: cp/call.c:9416 ++#: cp/call.c:9445 + #, gcc-internal-format + msgid "%qD writing to an object of type %#qT with no trivial copy-assignment" + msgstr "" + +-#: cp/call.c:9419 ++#: cp/call.c:9448 + #, gcc-internal-format + msgid "%qD writing to an object of non-trivial type %#qT%s" + msgstr "" + +-#: cp/call.c:9424 ++#: cp/call.c:9453 + #, gcc-internal-format + msgid "%qD writing to an object of type %#qT with %qs member %qD" + msgstr "" + +-#: cp/call.c:9429 ++#: cp/call.c:9458 + #, gcc-internal-format + msgid "%qD writing to an object of type %#qT containing a pointer to data member%s" + msgstr "" + +-#: cp/call.c:9444 ++#: cp/call.c:9473 + #, gcc-internal-format + msgid "; use assignment or value-initialization instead" + msgstr "" + +-#: cp/call.c:9446 ++#: cp/call.c:9475 + #, gcc-internal-format + msgid "; use assignment instead" + msgstr "" + +-#: cp/call.c:9448 ++#: cp/call.c:9477 + #, gcc-internal-format + msgid "; use value-initialization instead" + msgstr "" + +-#: cp/call.c:9451 ++#: cp/call.c:9480 + #, gcc-internal-format + msgid "%qD clearing an object of type %#qT with no trivial copy-assignment%s" + msgstr "" + +-#: cp/call.c:9454 ++#: cp/call.c:9483 + #, gcc-internal-format + msgid "%qD clearing an object of non-trivial type %#qT%s" + msgstr "" + +-#: cp/call.c:9456 ++#: cp/call.c:9485 + #, gcc-internal-format + msgid "%qD clearing an object of type %#qT containing a pointer-to-member%s" + msgstr "" + +-#: cp/call.c:9477 ++#: cp/call.c:9506 + #, gcc-internal-format + msgid "; use copy-assignment or copy-initialization instead" + msgstr "" + +-#: cp/call.c:9479 ++#: cp/call.c:9508 + #, gcc-internal-format + msgid "; use copy-assignment instead" + msgstr "" + +-#: cp/call.c:9481 ++#: cp/call.c:9510 + #, gcc-internal-format + msgid "; use copy-initialization instead" + msgstr "" + +-#: cp/call.c:9484 ++#: cp/call.c:9513 + #, gcc-internal-format + msgid "%qD writing to an object of type %#qT with no trivial copy-assignment%s" + msgstr "" + +-#: cp/call.c:9487 ++#: cp/call.c:9516 + #, gcc-internal-format + msgid "%qD writing to an object of non-trivially copyable type %#qT%s" + msgstr "" + +-#: cp/call.c:9490 ++#: cp/call.c:9519 + #, gcc-internal-format + msgid "%qD writing to an object with a deleted copy constructor" + msgstr "" + +-#: cp/call.c:9501 ++#: cp/call.c:9530 + #, gcc-internal-format + msgid "%qD copying an object of non-trivial type %#qT from an array of %#qT" + msgstr "" + +-#: cp/call.c:9513 ++#: cp/call.c:9542 + #, gcc-internal-format + msgid "%qD copying an object of type %#qT with %qs member %qD from an array of %#qT; use assignment or copy-initialization instead" + msgstr "" + +-#: cp/call.c:9530 ++#: cp/call.c:9559 + #, gcc-internal-format + msgid "%qD writing to an object of a non-trivial type %#qT leaves %wu bytes unchanged" + msgstr "" + +-#: cp/call.c:9533 ++#: cp/call.c:9562 + #, gcc-internal-format + msgid "%qD writing to an object of a non-trivial type %#qT leaves %wu byte unchanged" + msgstr "" + +-#: cp/call.c:9543 ++#: cp/call.c:9572 + #, gcc-internal-format + msgid "%qD moving an object of non-trivially copyable type %#qT; use % and % instead" + msgstr "" + +-#: cp/call.c:9546 ++#: cp/call.c:9575 + #, gcc-internal-format + msgid "%qD moving an object of type %#qT with deleted copy constructor; use % and % instead" + msgstr "" + +-#: cp/call.c:9549 ++#: cp/call.c:9578 + #, gcc-internal-format + msgid "%qD moving an object of type %#qT with deleted destructor" + msgstr "" + +-#: cp/call.c:9558 ++#: cp/call.c:9587 + #, gcc-internal-format + msgid "%qD moving an object of non-trivial type %#qT and size %E into a region of size %E" + msgstr "" + +-#: cp/call.c:9580 ++#: cp/call.c:9609 + #, gcc-internal-format + msgid "%#qT declared here" + msgstr "" + +-#: cp/call.c:9680 ++#: cp/call.c:9709 + #, gcc-internal-format + msgid "constructor delegates to itself" + msgstr "" + +-#: cp/call.c:9954 cp/typeck.c:9284 ++#: cp/call.c:9983 cp/typeck.c:9344 + msgid "cannot convert %qH to %qI" + msgstr "" + +-#: cp/call.c:9976 ++#: cp/call.c:10005 + #, gcc-internal-format + msgid "no matching function for call to %<%T::operator %T(%A)%#V%>" + msgstr "" + +-#: cp/call.c:10008 ++#: cp/call.c:10037 + #, gcc-internal-format + msgid "no matching function for call to %<%T::%s%E(%A)%#V%>" + msgstr "" + +-#: cp/call.c:10055 ++#: cp/call.c:10084 + #, gcc-internal-format + msgid "call to non-function %qD" + msgstr "" + +-#: cp/call.c:10093 cp/pt.c:16025 cp/typeck.c:3127 ++#: cp/call.c:10122 cp/pt.c:16059 cp/typeck.c:3169 + #, gcc-internal-format + msgid "cannot call constructor %<%T::%D%> directly" + msgstr "" + +-#: cp/call.c:10095 ++#: cp/call.c:10124 + #, gcc-internal-format + msgid "for a function-style cast, remove the redundant %<::%D%>" + msgstr "" + +-#: cp/call.c:10287 ++#: cp/call.c:10316 + #, gcc-internal-format + msgid "no matching function for call to %<%s(%A)%>" + msgstr "" + +-#: cp/call.c:10290 ++#: cp/call.c:10319 + #, gcc-internal-format + msgid "call of overloaded %<%s(%A)%> is ambiguous" + msgstr "" + +-#: cp/call.c:10311 ++#: cp/call.c:10340 + #, gcc-internal-format + msgid "pure virtual %q#D called from non-static data member initializer" + msgstr "" + +-#: cp/call.c:10316 ++#: cp/call.c:10345 + #, gcc-internal-format + msgid "pure virtual %q#D called from constructor" + msgstr "" + +-#: cp/call.c:10317 ++#: cp/call.c:10346 + #, gcc-internal-format + msgid "pure virtual %q#D called from destructor" + msgstr "" + +-#: cp/call.c:10340 ++#: cp/call.c:10369 + #, gcc-internal-format + msgid "cannot call member function %qD without object" + msgstr "" + +-#: cp/call.c:11307 ++#: cp/call.c:11336 + #, gcc-internal-format + msgid "passing %qT chooses %qT over %qT" + msgstr "" + +-#: cp/call.c:11376 ++#: cp/call.c:11405 + #, gcc-internal-format + msgid "choosing %qD over %qD" + msgstr "" + +-#: cp/call.c:11377 ++#: cp/call.c:11406 + #, fuzzy + #| msgid "converting from `%T' to `%T'" + msgid " for conversion from %qH to %qI" + msgstr "пераўтварэньне з `%T' у `%T'" + +-#: cp/call.c:11380 ++#: cp/call.c:11409 + #, gcc-internal-format + msgid " because conversion sequence for the argument is better" + msgstr "" + +-#: cp/call.c:11629 ++#: cp/call.c:11659 + #, gcc-internal-format + msgid "default argument mismatch in overload resolution" + msgstr "" + +-#: cp/call.c:11633 ++#: cp/call.c:11663 + #, gcc-internal-format + msgid " candidate 1: %q#F" + msgstr "" + +-#: cp/call.c:11635 ++#: cp/call.c:11665 + #, gcc-internal-format + msgid " candidate 2: %q#F" + msgstr "" + +-#: cp/call.c:11681 ++#: cp/call.c:11711 + #, gcc-internal-format + msgid "ISO C++ says that these are ambiguous, even though the worst conversion for the first is better than the worst conversion for the second:" + msgstr "" + +-#: cp/call.c:12083 ++#: cp/call.c:12113 + #, gcc-internal-format + msgid "a temporary bound to %qD only persists until the constructor exits" + msgstr "" + +-#: cp/call.c:12238 ++#: cp/call.c:12268 + msgid "invalid initialization of non-const reference of type %qH from an rvalue of type %qI" + msgstr "" + +-#: cp/call.c:12242 ++#: cp/call.c:12272 + msgid "invalid initialization of reference of type %qH from expression of type %qI" + msgstr "" + +@@ -45436,524 +45488,524 @@ msgstr "" + msgid "cannot convert from %qT to base class %qT because %qT is incomplete" + msgstr "" + +-#: cp/class.c:1149 ++#: cp/class.c:1156 + #, fuzzy, gcc-internal-format + msgid "%q#D conflicts with version inherited from %qT" + msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй" + +-#: cp/class.c:1152 ++#: cp/class.c:1159 + #, gcc-internal-format + msgid "version inherited from %qT declared here" + msgstr "" + +-#: cp/class.c:1172 ++#: cp/class.c:1179 + #, gcc-internal-format + msgid "%q#D cannot be overloaded with %q#D" + msgstr "" + +-#: cp/class.c:1174 cp/decl.c:1705 cp/decl.c:1714 cp/decl.c:1739 cp/decl.c:1762 ++#: cp/class.c:1181 cp/decl.c:1705 cp/decl.c:1714 cp/decl.c:1739 cp/decl.c:1762 + #: cp/name-lookup.c:2280 cp/name-lookup.c:2565 + #, fuzzy, gcc-internal-format + #| msgid "previous declaration `%D'" + msgid "previous declaration %q#D" + msgstr "папярэдняе абвяшчэньне `%D'" + +-#: cp/class.c:1217 ++#: cp/class.c:1224 + #, gcc-internal-format + msgid "conflicting access specifications for method %q+D, ignored" + msgstr "" + +-#: cp/class.c:1220 ++#: cp/class.c:1227 + #, gcc-internal-format + msgid "conflicting access specifications for field %qE, ignored" + msgstr "" + +-#: cp/class.c:1289 ++#: cp/class.c:1296 + #, gcc-internal-format + msgid "%qD invalid in %q#T because of local method %q#D with same name" + msgstr "" + +-#: cp/class.c:1293 ++#: cp/class.c:1300 + #, gcc-internal-format + msgid "local method %q#D declared here" + msgstr "" + +-#: cp/class.c:1299 ++#: cp/class.c:1306 + #, gcc-internal-format + msgid "%qD invalid in %q#T because of local member %q#D with same name" + msgstr "" + +-#: cp/class.c:1303 ++#: cp/class.c:1310 + #, fuzzy, gcc-internal-format + msgid "local member %q#D declared here" + msgstr "тып параметра \"%s\" не аб'яўлены" + +-#: cp/class.c:1359 ++#: cp/class.c:1366 + #, gcc-internal-format + msgid "%qD inherits the %E ABI tag that %qT (used in its return type) has" + msgstr "" + +-#: cp/class.c:1362 cp/class.c:1369 cp/class.c:1376 cp/class.c:1388 +-#: cp/cvt.c:1092 ++#: cp/class.c:1369 cp/class.c:1376 cp/class.c:1383 cp/class.c:1395 ++#: cp/cvt.c:1091 + #, gcc-internal-format + msgid "%qT declared here" + msgstr "" + +-#: cp/class.c:1367 ++#: cp/class.c:1374 + #, gcc-internal-format + msgid "%qD inherits the %E ABI tag that %qT (used in its type) has" + msgstr "" + +-#: cp/class.c:1374 ++#: cp/class.c:1381 + #, gcc-internal-format + msgid "%qT does not have the %E ABI tag that base %qT has" + msgstr "" + +-#: cp/class.c:1382 ++#: cp/class.c:1389 + #, gcc-internal-format + msgid "%qT does not have the %E ABI tag that %qT (used in the type of %qD) has" + msgstr "" + +-#: cp/class.c:1685 ++#: cp/class.c:1692 + #, gcc-internal-format + msgid "cannot derive from % base %qT in derived type %qT" + msgstr "" + +-#: cp/class.c:2148 ++#: cp/class.c:2155 + #, gcc-internal-format + msgid "all member functions in class %qT are private" + msgstr "" + +-#: cp/class.c:2160 ++#: cp/class.c:2167 + #, gcc-internal-format + msgid "%q#T only defines a private destructor and has no friends" + msgstr "" + +-#: cp/class.c:2201 ++#: cp/class.c:2208 + #, gcc-internal-format + msgid "%q#T only defines private constructors and has no friends" + msgstr "" + +-#: cp/class.c:2205 ++#: cp/class.c:2212 + #, gcc-internal-format + msgid "%q#D is public, but requires an existing %q#T object" + msgstr "" + +-#: cp/class.c:2479 ++#: cp/class.c:2504 + #, gcc-internal-format + msgid "no unique final overrider for %qD in %qT" + msgstr "" + +-#: cp/class.c:2841 ++#: cp/class.c:2866 + #, gcc-internal-format + msgid "%qD can be marked override" + msgstr "" + +-#: cp/class.c:2844 ++#: cp/class.c:2869 + #, gcc-internal-format + msgid "%q+#D marked %, but does not override" + msgstr "" + +-#: cp/class.c:2859 ++#: cp/class.c:2884 + #, gcc-internal-format + msgid "%q+#D marked %, but is not virtual" + msgstr "" + +-#: cp/class.c:2922 ++#: cp/class.c:2947 + #, gcc-internal-format + msgid "%qD was hidden" + msgstr "" + +-#: cp/class.c:2923 ++#: cp/class.c:2948 + #, gcc-internal-format + msgid " by %qD" + msgstr "" + +-#: cp/class.c:2958 ++#: cp/class.c:2983 + #, gcc-internal-format + msgid "%q#D invalid; an anonymous union may only have public non-static data members" + msgstr "" + +-#: cp/class.c:2968 cp/parser.c:20876 ++#: cp/class.c:2993 cp/parser.c:20886 + #, gcc-internal-format + msgid "this flexibility is deprecated and will be removed" + msgstr "" + +-#: cp/class.c:3161 ++#: cp/class.c:3186 + #, gcc-internal-format + msgid "the ellipsis in %qD is not inherited" + msgstr "" + +-#: cp/class.c:3347 ++#: cp/class.c:3377 + #, fuzzy, gcc-internal-format + msgid "bit-field %q#D with non-integral type %qT" + msgstr "бітавае поле \"%s\" мае нерэчаісны тып" + +-#: cp/class.c:3363 ++#: cp/class.c:3393 + #, fuzzy, gcc-internal-format + msgid "bit-field %q+D width not an integer constant" + msgstr "бітавае поле \"%s\" мае нерэчаісны тып" + +-#: cp/class.c:3368 ++#: cp/class.c:3398 + #, gcc-internal-format + msgid "negative width in bit-field %q+D" + msgstr "" + +-#: cp/class.c:3373 ++#: cp/class.c:3403 + #, gcc-internal-format + msgid "zero width for bit-field %q+D" + msgstr "" + +-#: cp/class.c:3383 ++#: cp/class.c:3413 + #, gcc-internal-format + msgid "width of %qD exceeds its type" + msgstr "" + +-#: cp/class.c:3389 ++#: cp/class.c:3419 + #, gcc-internal-format + msgid "%qD is too small to hold all values of %q#T" + msgstr "" + +-#: cp/class.c:3450 ++#: cp/class.c:3480 + #, gcc-internal-format + msgid "member %q+#D with constructor not allowed in union" + msgstr "" + +-#: cp/class.c:3453 ++#: cp/class.c:3483 + #, gcc-internal-format + msgid "member %q+#D with destructor not allowed in union" + msgstr "" + +-#: cp/class.c:3455 ++#: cp/class.c:3485 + #, gcc-internal-format + msgid "member %q+#D with copy assignment operator not allowed in union" + msgstr "" + +-#: cp/class.c:3459 ++#: cp/class.c:3489 + #, gcc-internal-format + msgid "unrestricted unions only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/class.c:3575 ++#: cp/class.c:3605 + #, gcc-internal-format + msgid "in C++98 %q+D may not be static because it is a member of a union" + msgstr "" + +-#: cp/class.c:3588 ++#: cp/class.c:3618 + #, gcc-internal-format + msgid "non-static data member %q+D in a union may not have reference type %qT" + msgstr "" + +-#: cp/class.c:3601 ++#: cp/class.c:3631 + #, fuzzy, gcc-internal-format + msgid "data member %q+D invalidly declared function type" + msgstr "тып параметра \"%s\" не аб'яўлены" + +-#: cp/class.c:3607 ++#: cp/class.c:3637 + #, fuzzy, gcc-internal-format + msgid "data member %q+D invalidly declared method type" + msgstr "тып параметра \"%s\" не аб'яўлены" + +-#: cp/class.c:3678 ++#: cp/class.c:3708 + #, gcc-internal-format + msgid "ignoring packed attribute because of unpacked non-POD field %q#D" + msgstr "" + +-#: cp/class.c:3729 ++#: cp/class.c:3760 + #, gcc-internal-format + msgid "member %q+D cannot be declared as a % reference" + msgstr "" + +-#: cp/class.c:3732 ++#: cp/class.c:3763 + #, gcc-internal-format + msgid "member %q+D cannot be declared both % and %" + msgstr "" + +-#: cp/class.c:3763 ++#: cp/class.c:3794 + #, gcc-internal-format + msgid "multiple fields in union %qT initialized" + msgstr "" + +-#: cp/class.c:3765 ++#: cp/class.c:3796 + #, gcc-internal-format + msgid "initialized member %q+D declared here" + msgstr "" + +-#: cp/class.c:3808 ++#: cp/class.c:3839 + #, gcc-internal-format + msgid "field %q#D with same name as class" + msgstr "" + +-#: cp/class.c:3836 ++#: cp/class.c:3867 + #, gcc-internal-format + msgid "%q#T has pointer data members" + msgstr "" + +-#: cp/class.c:3841 ++#: cp/class.c:3872 + #, gcc-internal-format + msgid " but does not declare %<%T(const %T&)%>" + msgstr "" + +-#: cp/class.c:3843 ++#: cp/class.c:3874 + #, gcc-internal-format + msgid " or %" + msgstr "" + +-#: cp/class.c:3847 ++#: cp/class.c:3878 + #, gcc-internal-format + msgid " but does not declare %" + msgstr "" + +-#: cp/class.c:3849 ++#: cp/class.c:3880 + #, fuzzy, gcc-internal-format + msgid "pointer member %q+D declared here" + msgstr "тып параметра \"%s\" не аб'яўлены" + +-#: cp/class.c:4287 ++#: cp/class.c:4318 + #, gcc-internal-format + msgid "alignment of %qD increased in %<-fabi-version=9%> (GCC 5.2)" + msgstr "" + +-#: cp/class.c:4290 ++#: cp/class.c:4321 + #, gcc-internal-format + msgid "alignment of %qD will increase in %<-fabi-version=9%>" + msgstr "" + +-#: cp/class.c:4604 ++#: cp/class.c:4648 + #, fuzzy, gcc-internal-format + msgid "initializer specified for non-virtual method %q+D" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/class.c:4637 ++#: cp/class.c:4681 + #, fuzzy, gcc-internal-format + msgid "destructor for %qT is ambiguous" + msgstr "памер \"%s\" - %d байт" + +-#: cp/class.c:5039 ++#: cp/class.c:5191 + #, gcc-internal-format + msgid "method overrides both % and %qE methods" + msgstr "" + +-#: cp/class.c:5060 ++#: cp/class.c:5212 + #, gcc-internal-format + msgid "method declared %qE overriding %qE method" + msgstr "" + +-#: cp/class.c:5716 cp/constexpr.c:254 ++#: cp/class.c:5868 cp/constexpr.c:254 + #, gcc-internal-format + msgid "enclosing class of % non-static member function %q+#D is not a literal type" + msgstr "" + +-#: cp/class.c:5742 ++#: cp/class.c:5894 + #, gcc-internal-format + msgid "%q+T is not literal because:" + msgstr "" + +-#: cp/class.c:5745 ++#: cp/class.c:5897 + #, gcc-internal-format + msgid " %qT is a closure type, which is only literal in C++17 and later" + msgstr "" + +-#: cp/class.c:5748 ++#: cp/class.c:5900 + #, gcc-internal-format + msgid " %q+T has a non-trivial destructor" + msgstr "" + +-#: cp/class.c:5751 ++#: cp/class.c:5903 + #, gcc-internal-format + msgid " %q+T does not have % destructor" + msgstr "" + +-#: cp/class.c:5759 ++#: cp/class.c:5911 + #, gcc-internal-format + msgid " %q+T is not an aggregate, does not have a trivial default constructor, and has no % constructor that is not a copy or move constructor" + msgstr "" + +-#: cp/class.c:5792 ++#: cp/class.c:5944 + #, gcc-internal-format + msgid " base class %qT of %q+T is non-literal" + msgstr "" + +-#: cp/class.c:5807 ++#: cp/class.c:5959 + #, gcc-internal-format + msgid " non-static data member %qD has non-literal type" + msgstr "" + +-#: cp/class.c:5814 ++#: cp/class.c:5966 + #, gcc-internal-format + msgid " non-static data member %qD has volatile type" + msgstr "" + +-#: cp/class.c:5935 ++#: cp/class.c:6087 + #, gcc-internal-format + msgid "base class %q#T has accessible non-virtual destructor" + msgstr "" + +-#: cp/class.c:5964 ++#: cp/class.c:6116 + #, gcc-internal-format + msgid "non-static reference %q#D in class without a constructor" + msgstr "" + +-#: cp/class.c:5970 ++#: cp/class.c:6122 + #, gcc-internal-format + msgid "non-static const member %q#D in class without a constructor" + msgstr "" + +-#: cp/class.c:6291 ++#: cp/class.c:6443 + #, gcc-internal-format + msgid "direct base %qT inaccessible in %qT due to ambiguity" + msgstr "" + +-#: cp/class.c:6303 ++#: cp/class.c:6455 + #, gcc-internal-format + msgid "virtual base %qT inaccessible in %qT due to ambiguity" + msgstr "" + +-#: cp/class.c:6548 ++#: cp/class.c:6703 + #, gcc-internal-format + msgid "offset of %qD is not ABI-compliant and may change in a future version of GCC" + msgstr "" + +-#: cp/class.c:6718 ++#: cp/class.c:6873 + #, fuzzy, gcc-internal-format + #| msgid "size of `%s' is larger than %d bytes" + msgid "size of type %qT is too large (%qE bytes)" + msgstr "памер \"%s\" больш чам %d байт" + +-#: cp/class.c:7004 ++#: cp/class.c:7159 + #, gcc-internal-format + msgid "invalid use of %q#T with a zero-size array in %q#D" + msgstr "" + +-#: cp/class.c:7006 ++#: cp/class.c:7161 + #, gcc-internal-format + msgid "invalid use of %q#T with a flexible array member in %q#T" + msgstr "" + +-#: cp/class.c:7011 ++#: cp/class.c:7166 + #, fuzzy, gcc-internal-format + msgid "array member %q#D declared here" + msgstr "тып параметра \"%s\" не аб'яўлены" + +-#: cp/class.c:7039 ++#: cp/class.c:7194 + #, gcc-internal-format + msgid "zero-size array member %qD not at end of %q#T" + msgstr "" + +-#: cp/class.c:7041 ++#: cp/class.c:7196 + #, gcc-internal-format + msgid "zero-size array member %qD in an otherwise empty %q#T" + msgstr "" + +-#: cp/class.c:7050 cp/class.c:7081 ++#: cp/class.c:7205 cp/class.c:7236 + #, fuzzy, gcc-internal-format + #| msgid "previous definition of `%#T'" + msgid "in the definition of %q#T" + msgstr "папярэдняе вызначэньне `%#T'" + +-#: cp/class.c:7058 ++#: cp/class.c:7213 + #, gcc-internal-format + msgid "flexible array member %qD not at end of %q#T" + msgstr "" + +-#: cp/class.c:7060 ++#: cp/class.c:7215 + #, gcc-internal-format + msgid "flexible array member %qD in an otherwise empty %q#T" + msgstr "" + +-#: cp/class.c:7079 ++#: cp/class.c:7234 + #, gcc-internal-format + msgid "next member %q#D declared here" + msgstr "" + +-#: cp/class.c:7193 cp/parser.c:24604 ++#: cp/class.c:7348 cp/parser.c:24620 + #, fuzzy, gcc-internal-format + #| msgid "previous definition of `%#T'" + msgid "redefinition of %q#T" + msgstr "папярэдняе вызначэньне `%#T'" + +-#: cp/class.c:7330 ++#: cp/class.c:7485 + #, gcc-internal-format + msgid "%q#T has virtual functions and accessible non-virtual destructor" + msgstr "" + +-#: cp/class.c:7361 ++#: cp/class.c:7516 + #, gcc-internal-format + msgid "type transparent %q#T does not have any fields" + msgstr "" + +-#: cp/class.c:7367 ++#: cp/class.c:7522 + #, gcc-internal-format + msgid "type transparent class %qT has base classes" + msgstr "" + +-#: cp/class.c:7371 ++#: cp/class.c:7526 + #, gcc-internal-format + msgid "type transparent class %qT has virtual functions" + msgstr "" + +-#: cp/class.c:7377 ++#: cp/class.c:7532 + #, gcc-internal-format + msgid "type transparent %q#T cannot be made transparent because the type of the first field has a different ABI from the class overall" + msgstr "" + +-#: cp/class.c:7539 ++#: cp/class.c:7694 + #, gcc-internal-format + msgid "definition of %qD does not match %<#include %>" + msgstr "" + +-#: cp/class.c:7550 ++#: cp/class.c:7705 + #, gcc-internal-format + msgid "trying to finish struct, but kicked out due to previous parse errors" + msgstr "" + +-#: cp/class.c:8057 ++#: cp/class.c:8212 + #, fuzzy, gcc-internal-format + #| msgid "language %s not recognized" + msgid "language string %<\"%E\"%> not recognized" + msgstr "мова %s не распазнана" + +-#: cp/class.c:8147 ++#: cp/class.c:8302 + #, gcc-internal-format + msgid "cannot resolve overloaded function %qD based on conversion to type %qT" + msgstr "" + +-#: cp/class.c:8292 ++#: cp/class.c:8447 + #, gcc-internal-format + msgid "no matches converting function %qD to type %q#T" + msgstr "" + +-#: cp/class.c:8319 ++#: cp/class.c:8474 + #, gcc-internal-format + msgid "converting overloaded function %qD to type %q#T is ambiguous" + msgstr "" + +-#: cp/class.c:8346 ++#: cp/class.c:8501 + #, fuzzy, gcc-internal-format + msgid "assuming pointer to member %qD" + msgstr "прапушчан ініцыялізатар" + +-#: cp/class.c:8349 ++#: cp/class.c:8504 + #, gcc-internal-format + msgid "(a pointer to member can only be formed with %<&%E%>)" + msgstr "" + +-#: cp/class.c:8425 cp/class.c:8467 ++#: cp/class.c:8580 cp/class.c:8622 + #, gcc-internal-format + msgid "not enough type information" + msgstr "" + +-#: cp/class.c:8445 ++#: cp/class.c:8600 + #, gcc-internal-format + msgid "cannot convert %qE from type %qT to type %qT" + msgstr "" + +-#: cp/class.c:8718 ++#: cp/class.c:8873 + #, gcc-internal-format + msgid "declaration of %q#D changes meaning of %qD" + msgstr "" + +-#: cp/class.c:8721 ++#: cp/class.c:8876 + #, gcc-internal-format + msgid "%qD declared here as %q#D" + msgstr "" +@@ -46033,7 +46085,7 @@ msgstr "" + msgid "%q+E is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:1660 cp/constexpr.c:7410 ++#: cp/constexpr.c:1660 cp/constexpr.c:7401 + #, fuzzy, gcc-internal-format + #| msgid "can't initialize friend function `%s'" + msgid "call to internal function %qE" +@@ -46090,7 +46142,7 @@ msgstr "" + msgid "deallocation of storage that was not previously allocated" + msgstr "" + +-#: cp/constexpr.c:2250 cp/constexpr.c:7442 ++#: cp/constexpr.c:2250 cp/constexpr.c:7433 + #, gcc-internal-format + msgid "call to non-% function %qD" + msgstr "" +@@ -46145,373 +46197,372 @@ msgstr "" + msgid "arithmetic involving a null pointer in %qE" + msgstr "" + +-#: cp/constexpr.c:3332 ++#: cp/constexpr.c:3348 + #, gcc-internal-format + msgid "array subscript value %qE is outside the bounds of array %qD of type %qT" + msgstr "" + +-#: cp/constexpr.c:3335 ++#: cp/constexpr.c:3351 + #, gcc-internal-format + msgid "nonzero array subscript %qE is used with array %qD of type %qT with unknown bounds" + msgstr "" + +-#: cp/constexpr.c:3340 ++#: cp/constexpr.c:3356 + #, gcc-internal-format + msgid "array subscript value %qE is outside the bounds of array type %qT" + msgstr "" + +-#: cp/constexpr.c:3343 ++#: cp/constexpr.c:3359 + #, gcc-internal-format + msgid "nonzero array subscript %qE is used with array of type %qT with unknown bounds" + msgstr "" + +-#: cp/constexpr.c:3526 ++#: cp/constexpr.c:3542 + #, fuzzy, gcc-internal-format + msgid "accessing uninitialized array element" + msgstr "прапушчан ініцыялізатар" + +-#: cp/constexpr.c:3566 ++#: cp/constexpr.c:3582 + #, gcc-internal-format + msgid "dereferencing a null pointer in %qE" + msgstr "" + +-#: cp/constexpr.c:3583 cp/constexpr.c:3682 cp/constexpr.c:5527 +-#: cp/constexpr.c:5624 cp/constexpr.c:7362 ++#: cp/constexpr.c:3599 cp/constexpr.c:3698 cp/constexpr.c:5543 ++#: cp/constexpr.c:5640 cp/constexpr.c:7353 + #, fuzzy, gcc-internal-format + msgid "%qE is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:3589 ++#: cp/constexpr.c:3605 + #, fuzzy, gcc-internal-format + msgid "mutable %qD is not usable in a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:3620 cp/constexpr.c:3642 ++#: cp/constexpr.c:3636 cp/constexpr.c:3658 + #, fuzzy, gcc-internal-format + msgid "accessing uninitialized member %qD" + msgstr "прапушчан ініцыялізатар" + +-#: cp/constexpr.c:3622 ++#: cp/constexpr.c:3638 + #, gcc-internal-format + msgid "accessing %qD member instead of initialized %qD member in constant expression" + msgstr "" + +-#: cp/constexpr.c:4392 cp/constexpr.c:6162 ++#: cp/constexpr.c:4408 cp/constexpr.c:6178 + #, gcc-internal-format + msgid "dereferencing a null pointer" + msgstr "" + +-#: cp/constexpr.c:4412 ++#: cp/constexpr.c:4428 + #, gcc-internal-format + msgid "accessing value of %qE through a %qT glvalue in a constant expression" + msgstr "" + +-#: cp/constexpr.c:4455 ++#: cp/constexpr.c:4471 + #, fuzzy, gcc-internal-format + msgid "the content of uninitialized storage is not usable in a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:4457 cp/constexpr.c:4464 ++#: cp/constexpr.c:4473 cp/constexpr.c:4480 + #, fuzzy, gcc-internal-format + #| msgid "called from here" + msgid "allocated here" + msgstr "выклікана адсюль" + +-#: cp/constexpr.c:4462 ++#: cp/constexpr.c:4478 + #, fuzzy, gcc-internal-format + msgid "use of allocated storage after deallocation in a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:4467 ++#: cp/constexpr.c:4483 + #, fuzzy, gcc-internal-format + msgid "the value of %qD is not usable in a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:4474 ++#: cp/constexpr.c:4490 + #, fuzzy, gcc-internal-format + #| msgid "invalid initializer" + msgid "%qD used in its own initializer" + msgstr "нерэчаісны ініцыялізатар" + +-#: cp/constexpr.c:4479 ++#: cp/constexpr.c:4495 + #, fuzzy, gcc-internal-format + #| msgid "`%D' is not a function," + msgid "%q#D is not const" + msgstr "`%D' - гэта ня функцыя," + +-#: cp/constexpr.c:4482 ++#: cp/constexpr.c:4498 + #, gcc-internal-format + msgid "%q#D is volatile" + msgstr "" + +-#: cp/constexpr.c:4487 cp/constexpr.c:4494 ++#: cp/constexpr.c:4503 cp/constexpr.c:4510 + #, fuzzy, gcc-internal-format + msgid "%qD was not initialized with a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:4500 ++#: cp/constexpr.c:4516 + #, fuzzy, gcc-internal-format + msgid "%qD was not declared %" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/constexpr.c:4503 ++#: cp/constexpr.c:4519 + #, gcc-internal-format + msgid "%qD does not have integral or enumeration type" + msgstr "" + +-#: cp/constexpr.c:4749 ++#: cp/constexpr.c:4765 + #, fuzzy, gcc-internal-format + msgid "modification of %qE is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:4810 ++#: cp/constexpr.c:4826 + #, gcc-internal-format + msgid "change of the active member of a union from %qD to %qD" + msgstr "" + +-#: cp/constexpr.c:4823 ++#: cp/constexpr.c:4839 + #, gcc-internal-format + msgid "change of the active member of a union from %qD to %qD during initialization" + msgstr "" + +-#: cp/constexpr.c:5215 cp/constexpr.c:6455 ++#: cp/constexpr.c:5231 cp/constexpr.c:6433 + #, fuzzy, gcc-internal-format + msgid "statement is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:5321 ++#: cp/constexpr.c:5337 + #, gcc-internal-format + msgid "% loop iteration count exceeds limit of %d (use %<-fconstexpr-loop-limit=%> to increase the limit)" + msgstr "" + +-#: cp/constexpr.c:5423 ++#: cp/constexpr.c:5439 + #, fuzzy, gcc-internal-format + msgid "inline assembly is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:5424 ++#: cp/constexpr.c:5440 + #, gcc-internal-format + msgid "only unevaluated inline assembly is allowed in a % function in C++2a" + msgstr "" + +-#: cp/constexpr.c:5489 ++#: cp/constexpr.c:5505 + #, fuzzy, gcc-internal-format + msgid "value %qE of type %qT is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:5502 ++#: cp/constexpr.c:5518 + #, gcc-internal-format + msgid "% evaluation operation count exceeds limit of %wd (use %<-fconstexpr-ops-limit=%> to increase the limit)" + msgstr "" + +-#: cp/constexpr.c:5684 cp/constexpr.c:8006 ++#: cp/constexpr.c:5700 cp/constexpr.c:8003 + #, fuzzy, gcc-internal-format + msgid "temporary of non-literal type %qT in a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:6122 cp/constexpr.c:7556 ++#: cp/constexpr.c:6138 cp/constexpr.c:7553 + #, fuzzy, gcc-internal-format + msgid "% is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:6174 ++#: cp/constexpr.c:6190 + #, fuzzy, gcc-internal-format + msgid "conversion of %qT null pointer to %qT is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:6188 ++#: cp/constexpr.c:6204 + #, gcc-internal-format + msgid "%(%E)%> is not a constant expression" + msgstr "" + +-#: cp/constexpr.c:6289 cp/constexpr.c:6307 cp/constexpr.c:6323 +-#: cp/constexpr.c:7832 cp/constexpr.c:8177 ++#: cp/constexpr.c:6305 cp/constexpr.c:7829 cp/constexpr.c:8174 + #, fuzzy, gcc-internal-format + msgid "expression %qE is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:6422 ++#: cp/constexpr.c:6400 + #, gcc-internal-format + msgid "unexpected template-id %qE" + msgstr "" + +-#: cp/constexpr.c:6428 ++#: cp/constexpr.c:6406 + #, gcc-internal-format + msgid "function concept must be called" + msgstr "" + +-#: cp/constexpr.c:6458 ++#: cp/constexpr.c:6436 + #, gcc-internal-format + msgid "unexpected expression %qE of kind %s" + msgstr "" + +-#: cp/constexpr.c:6686 ++#: cp/constexpr.c:6664 + #, gcc-internal-format + msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT" + msgstr "" + +-#: cp/constexpr.c:6694 ++#: cp/constexpr.c:6672 + #, gcc-internal-format + msgid "%qE is not a constant expression because it refers to an incompletely initialized variable" + msgstr "" + +-#: cp/constexpr.c:6709 ++#: cp/constexpr.c:6687 + #, gcc-internal-format + msgid "%qE is not a constant expression because it refers to a result of %" + msgstr "" + +-#: cp/constexpr.c:6719 ++#: cp/constexpr.c:6697 + #, gcc-internal-format + msgid "%qE is not a constant expression because allocated storage has not been deallocated" + msgstr "" + +-#: cp/constexpr.c:6739 ++#: cp/constexpr.c:6717 + #, gcc-internal-format + msgid "immediate evaluation returns address of immediate function %qD" + msgstr "" + +-#: cp/constexpr.c:6753 ++#: cp/constexpr.c:6731 + #, gcc-internal-format + msgid "conversion from pointer type %qT to arithmetic type %qT in a constant expression" + msgstr "" + +-#: cp/constexpr.c:7302 ++#: cp/constexpr.c:7293 + #, gcc-internal-format + msgid "lvalue-to-rvalue conversion of a volatile lvalue %qE with type %qT" + msgstr "" + +-#: cp/constexpr.c:7526 ++#: cp/constexpr.c:7523 + #, fuzzy, gcc-internal-format + msgid "lambda capture of %qE is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:7529 ++#: cp/constexpr.c:7526 + #, gcc-internal-format + msgid "because it is used as a glvalue" + msgstr "" + +-#: cp/constexpr.c:7576 ++#: cp/constexpr.c:7573 + #, gcc-internal-format + msgid "% from integer to pointer" + msgstr "" + +-#: cp/constexpr.c:7609 ++#: cp/constexpr.c:7606 + #, gcc-internal-format + msgid "address-of an object %qE with thread local or automatic storage is not a constant expression" + msgstr "" + +-#: cp/constexpr.c:7648 ++#: cp/constexpr.c:7645 + #, fuzzy, gcc-internal-format + msgid "use of % in a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:7779 ++#: cp/constexpr.c:7776 + #, gcc-internal-format + msgid "lambda-expression is not a constant expression before C++17" + msgstr "" + +-#: cp/constexpr.c:7846 ++#: cp/constexpr.c:7843 + #, fuzzy, gcc-internal-format + #| msgid "virtual functions cannot be friends" + msgid "virtual functions cannot be % before C++2a" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/constexpr.c:7861 ++#: cp/constexpr.c:7858 + #, gcc-internal-format + msgid "% is not a constant expression because %qE is of polymorphic type" + msgstr "" + +-#: cp/constexpr.c:7925 ++#: cp/constexpr.c:7922 + #, fuzzy, gcc-internal-format + msgid "cast to non-integral type %qT in a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:7975 ++#: cp/constexpr.c:7972 + #, fuzzy, gcc-internal-format + msgid "%qD declared % in % context" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/constexpr.c:7982 ++#: cp/constexpr.c:7979 + #, gcc-internal-format + msgid "%qD declared % in % context" + msgstr "" + +-#: cp/constexpr.c:8055 ++#: cp/constexpr.c:8052 + #, fuzzy, gcc-internal-format + msgid "division by zero is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:8153 ++#: cp/constexpr.c:8150 + #, fuzzy, gcc-internal-format + msgid "% is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:8185 ++#: cp/constexpr.c:8182 + #, fuzzy, gcc-internal-format + msgid "non-constant array initialization" + msgstr "нерэчаісны ініцыялізатар" + +-#: cp/constexpr.c:8215 ++#: cp/constexpr.c:8212 + #, fuzzy, gcc-internal-format + msgid "% is not a constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/constexpr.c:8232 ++#: cp/constexpr.c:8229 + #, gcc-internal-format, gfc-internal-format + msgid "unexpected AST of kind %s" + msgstr "" + +-#: cp/cp-gimplify.c:213 ++#: cp/cp-gimplify.c:214 + #, gcc-internal-format + msgid "both branches of % statement marked as %qs" + msgstr "" + +-#: cp/cp-gimplify.c:1595 ++#: cp/cp-gimplify.c:1596 + #, gcc-internal-format + msgid "% will always call %" + msgstr "" + +-#: cp/cp-gimplify.c:1598 ++#: cp/cp-gimplify.c:1599 + #, gcc-internal-format + msgid "in C++11 destructors default to %" + msgstr "" + +-#: cp/cp-gimplify.c:1610 ++#: cp/cp-gimplify.c:1611 + #, gcc-internal-format + msgid "in C++11 this % will call % because destructors default to %" + msgstr "" + +-#: cp/cp-gimplify.c:2990 ++#: cp/cp-gimplify.c:3056 + #, gcc-internal-format + msgid "ignoring attribute %qE after earlier %qE" + msgstr "" + +-#: cp/cp-gimplify.c:3012 cp/cp-gimplify.c:3024 cp/decl.c:3926 cp/method.c:955 ++#: cp/cp-gimplify.c:3078 cp/cp-gimplify.c:3090 cp/decl.c:3928 cp/method.c:955 + #, fuzzy, gcc-internal-format + msgid "%qD is not a type" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/cp-gimplify.c:3030 ++#: cp/cp-gimplify.c:3096 + #, fuzzy, gcc-internal-format + msgid "%qD is not a class type" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/cp-gimplify.c:3047 ++#: cp/cp-gimplify.c:3113 + #, gcc-internal-format + msgid "%qD does not have % type" + msgstr "" + +-#: cp/cp-gimplify.c:3058 ++#: cp/cp-gimplify.c:3124 + #, fuzzy, gcc-internal-format + msgid "%qD does not have integral type" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/cp-gimplify.c:3070 ++#: cp/cp-gimplify.c:3136 + #, gcc-internal-format + msgid "% does not contain only non-static data members %<_M_file_name%>, %<_M_function_name%>, %<_M_line%> and %<_M_column%>" + msgstr "" + +-#: cp/cp-gimplify.c:3159 ++#: cp/cp-gimplify.c:3225 + #, gcc-internal-format + msgid "evaluating %qs" + msgstr "" +@@ -46553,7 +46604,7 @@ msgstr "" + msgid "conversion from %qH to %qI discards qualifiers" + msgstr "" + +-#: cp/cvt.c:498 cp/typeck.c:7774 ++#: cp/cvt.c:498 cp/typeck.c:7834 + #, gcc-internal-format + msgid "casting %qT to %qT does not dereference pointer" + msgstr "" +@@ -46592,292 +46643,292 @@ msgstr "" + msgid "conversion from %qH to non-scalar type %qI requested" + msgstr "" + +-#: cp/cvt.c:1062 ++#: cp/cvt.c:1061 + #, gcc-internal-format + msgid "ignoring return value of %qD, declared with attribute %: %<%s%>" + msgstr "" + +-#: cp/cvt.c:1064 ++#: cp/cvt.c:1063 + #, gcc-internal-format + msgid "ignoring return value of %qD, declared with attribute %%s" + msgstr "" + +-#: cp/cvt.c:1080 ++#: cp/cvt.c:1079 + #, gcc-internal-format + msgid "ignoring returned value of type %qT, declared with attribute %: %<%s%>" + msgstr "" + +-#: cp/cvt.c:1082 ++#: cp/cvt.c:1081 + #, gcc-internal-format + msgid "ignoring returned value of type %qT, declared with attribute %%s" + msgstr "" + +-#: cp/cvt.c:1090 ++#: cp/cvt.c:1089 + #, gcc-internal-format + msgid "in call to %qD, declared here" + msgstr "" + +-#: cp/cvt.c:1104 ++#: cp/cvt.c:1103 + #, gcc-internal-format + msgid "ignoring return value of %qD, declared with attribute %" + msgstr "" + +-#: cp/cvt.c:1158 ++#: cp/cvt.c:1157 + #, gcc-internal-format + msgid "pseudo-destructor is not called" + msgstr "" + +-#: cp/cvt.c:1252 ++#: cp/cvt.c:1251 + #, gcc-internal-format + msgid "conversion to void will not access object of incomplete type %qT" + msgstr "" + +-#: cp/cvt.c:1256 ++#: cp/cvt.c:1255 + #, gcc-internal-format + msgid "indirection will not access object of incomplete type %qT in second operand of conditional expression" + msgstr "" + +-#: cp/cvt.c:1261 ++#: cp/cvt.c:1260 + #, gcc-internal-format + msgid "indirection will not access object of incomplete type %qT in third operand of conditional expression" + msgstr "" + +-#: cp/cvt.c:1266 ++#: cp/cvt.c:1265 + #, gcc-internal-format + msgid "indirection will not access object of incomplete type %qT in right operand of comma operator" + msgstr "" + +-#: cp/cvt.c:1271 ++#: cp/cvt.c:1270 + #, gcc-internal-format + msgid "indirection will not access object of incomplete type %qT in left operand of comma operator" + msgstr "" + +-#: cp/cvt.c:1276 ++#: cp/cvt.c:1275 + #, gcc-internal-format + msgid "indirection will not access object of incomplete type %qT in statement" + msgstr "" + +-#: cp/cvt.c:1280 ++#: cp/cvt.c:1279 + #, gcc-internal-format + msgid "indirection will not access object of incomplete type %qT in for increment expression" + msgstr "" + +-#: cp/cvt.c:1296 ++#: cp/cvt.c:1295 + #, gcc-internal-format + msgid "conversion to void will not access object of type %qT" + msgstr "" + +-#: cp/cvt.c:1300 ++#: cp/cvt.c:1299 + #, gcc-internal-format + msgid "implicit dereference will not access object of type %qT in second operand of conditional expression" + msgstr "" + +-#: cp/cvt.c:1305 ++#: cp/cvt.c:1304 + #, gcc-internal-format + msgid "implicit dereference will not access object of type %qT in third operand of conditional expression" + msgstr "" + +-#: cp/cvt.c:1310 ++#: cp/cvt.c:1309 + #, gcc-internal-format + msgid "implicit dereference will not access object of type %qT in right operand of comma operator" + msgstr "" + +-#: cp/cvt.c:1315 ++#: cp/cvt.c:1314 + #, gcc-internal-format + msgid "implicit dereference will not access object of type %qT in left operand of comma operator" + msgstr "" + +-#: cp/cvt.c:1320 ++#: cp/cvt.c:1319 + #, gcc-internal-format + msgid "implicit dereference will not access object of type %qT in statement" + msgstr "" + +-#: cp/cvt.c:1324 ++#: cp/cvt.c:1323 + #, gcc-internal-format + msgid "implicit dereference will not access object of type %qT in for increment expression" + msgstr "" + +-#: cp/cvt.c:1338 ++#: cp/cvt.c:1337 + #, gcc-internal-format + msgid "conversion to void will not access object of non-trivially-copyable type %qT" + msgstr "" + +-#: cp/cvt.c:1343 ++#: cp/cvt.c:1342 + #, gcc-internal-format + msgid "indirection will not access object of non-trivially-copyable type %qT in second operand of conditional expression" + msgstr "" + +-#: cp/cvt.c:1348 ++#: cp/cvt.c:1347 + #, gcc-internal-format + msgid "indirection will not access object of non-trivially-copyable type %qT in third operand of conditional expression" + msgstr "" + +-#: cp/cvt.c:1353 ++#: cp/cvt.c:1352 + #, gcc-internal-format + msgid "indirection will not access object of non-trivially-copyable type %qT in right operand of comma operator" + msgstr "" + +-#: cp/cvt.c:1358 ++#: cp/cvt.c:1357 + #, gcc-internal-format + msgid "indirection will not access object of non-trivially-copyable type %qT in left operand of comma operator" + msgstr "" + +-#: cp/cvt.c:1363 ++#: cp/cvt.c:1362 + #, gcc-internal-format + msgid "indirection will not access object of non-trivially-copyable type %qT in statement" + msgstr "" + +-#: cp/cvt.c:1368 ++#: cp/cvt.c:1367 + #, gcc-internal-format + msgid "indirection will not access object of non-trivially-copyable type %qT in for increment expression" + msgstr "" + +-#: cp/cvt.c:1409 ++#: cp/cvt.c:1408 + #, gcc-internal-format + msgid "conversion to void will not access object %qE of incomplete type %qT" + msgstr "" + +-#: cp/cvt.c:1413 ++#: cp/cvt.c:1412 + #, gcc-internal-format + msgid "variable %qE of incomplete type %qT will not be accessed in second operand of conditional expression" + msgstr "" + +-#: cp/cvt.c:1418 ++#: cp/cvt.c:1417 + #, gcc-internal-format + msgid "variable %qE of incomplete type %qT will not be accessed in third operand of conditional expression" + msgstr "" + +-#: cp/cvt.c:1423 ++#: cp/cvt.c:1422 + #, gcc-internal-format + msgid "variable %qE of incomplete type %qT will not be accessed in right operand of comma operator" + msgstr "" + +-#: cp/cvt.c:1428 ++#: cp/cvt.c:1427 + #, gcc-internal-format + msgid "variable %qE of incomplete type %qT will not be accessed in left operand of comma operator" + msgstr "" + +-#: cp/cvt.c:1433 ++#: cp/cvt.c:1432 + #, gcc-internal-format + msgid "variable %qE of incomplete type %qT will not be accessed in statement" + msgstr "" + +-#: cp/cvt.c:1437 ++#: cp/cvt.c:1436 + #, gcc-internal-format + msgid "variable %qE of incomplete type %qT will not be accessed in for increment expression" + msgstr "" + +-#: cp/cvt.c:1490 ++#: cp/cvt.c:1489 + #, gcc-internal-format + msgid "conversion to void cannot resolve address of overloaded function" + msgstr "" + +-#: cp/cvt.c:1494 ++#: cp/cvt.c:1493 + #, gcc-internal-format + msgid "second operand of conditional expression cannot resolve address of overloaded function" + msgstr "" + +-#: cp/cvt.c:1498 ++#: cp/cvt.c:1497 + #, gcc-internal-format + msgid "third operand of conditional expression cannot resolve address of overloaded function" + msgstr "" + +-#: cp/cvt.c:1502 ++#: cp/cvt.c:1501 + #, gcc-internal-format + msgid "right operand of comma operator cannot resolve address of overloaded function" + msgstr "" + +-#: cp/cvt.c:1506 ++#: cp/cvt.c:1505 + #, gcc-internal-format + msgid "left operand of comma operator cannot resolve address of overloaded function" + msgstr "" + +-#: cp/cvt.c:1510 ++#: cp/cvt.c:1509 + #, gcc-internal-format + msgid "statement cannot resolve address of overloaded function" + msgstr "" + +-#: cp/cvt.c:1514 ++#: cp/cvt.c:1513 + #, gcc-internal-format + msgid "for increment expression cannot resolve address of overloaded function" + msgstr "" + +-#: cp/cvt.c:1530 ++#: cp/cvt.c:1529 + #, gcc-internal-format + msgid "second operand of conditional expression is a reference, not call, to function %qE" + msgstr "" + +-#: cp/cvt.c:1535 ++#: cp/cvt.c:1534 + #, gcc-internal-format + msgid "third operand of conditional expression is a reference, not call, to function %qE" + msgstr "" + +-#: cp/cvt.c:1540 ++#: cp/cvt.c:1539 + #, gcc-internal-format + msgid "right operand of comma operator is a reference, not call, to function %qE" + msgstr "" + +-#: cp/cvt.c:1545 ++#: cp/cvt.c:1544 + #, gcc-internal-format + msgid "left operand of comma operator is a reference, not call, to function %qE" + msgstr "" + +-#: cp/cvt.c:1550 ++#: cp/cvt.c:1549 + #, gcc-internal-format + msgid "statement is a reference, not call, to function %qE" + msgstr "" + +-#: cp/cvt.c:1555 ++#: cp/cvt.c:1554 + #, gcc-internal-format + msgid "for increment expression is a reference, not call, to function %qE" + msgstr "" + +-#: cp/cvt.c:1583 ++#: cp/cvt.c:1582 + #, gcc-internal-format + msgid "second operand of conditional expression has no effect" + msgstr "" + +-#: cp/cvt.c:1588 ++#: cp/cvt.c:1587 + #, gcc-internal-format + msgid "third operand of conditional expression has no effect" + msgstr "" + +-#: cp/cvt.c:1593 ++#: cp/cvt.c:1592 + #, gcc-internal-format + msgid "right operand of comma operator has no effect" + msgstr "" + +-#: cp/cvt.c:1597 ++#: cp/cvt.c:1596 + #, gcc-internal-format + msgid "left operand of comma operator has no effect" + msgstr "" + +-#: cp/cvt.c:1601 ++#: cp/cvt.c:1600 + #, gcc-internal-format + msgid "statement has no effect" + msgstr "" + +-#: cp/cvt.c:1605 ++#: cp/cvt.c:1604 + #, gcc-internal-format + msgid "for increment expression has no effect" + msgstr "" + +-#: cp/cvt.c:1760 ++#: cp/cvt.c:1759 + #, gcc-internal-format + msgid "converting NULL to non-pointer type" + msgstr "" + +-#: cp/cvt.c:1878 ++#: cp/cvt.c:1877 + #, gcc-internal-format + msgid "default type conversion cannot deduce template argument for %qD" + msgstr "" + +-#: cp/cvt.c:1893 ++#: cp/cvt.c:1892 + #, gcc-internal-format + msgid "ambiguous default type conversion from %qT" + msgstr "" + +-#: cp/cvt.c:1896 ++#: cp/cvt.c:1895 + #, gcc-internal-format + msgid " candidate conversions include %qD and %qD" + msgstr "" +@@ -46946,7 +46997,7 @@ msgstr "папярэдняе абвяшчэньне `%D'" + msgid "redeclaration %qD differs in %qs from previous declaration" + msgstr "гэта папярэдняе абвяшчэньне" + +-#: cp/decl.c:1264 cp/decl.c:14963 ++#: cp/decl.c:1264 cp/decl.c:14972 + #, fuzzy, gcc-internal-format + #| msgid "previous declaration `%D'" + msgid "previous declaration %qD" +@@ -47133,12 +47184,12 @@ msgstr "няма папярэдняга аб'яўлення для \"%s\"" + msgid "function %qD declared %<[[noreturn]]%> but its first declaration was not" + msgstr "" + +-#: cp/decl.c:2059 ++#: cp/decl.c:2061 + #, fuzzy, gcc-internal-format + msgid "redundant redeclaration of %qD in same scope" + msgstr "паўторнае абвяшчэнне меткі \"%s\"" + +-#: cp/decl.c:2071 ++#: cp/decl.c:2073 + #, fuzzy, gcc-internal-format + #| msgid "previous definition of `%#T'" + msgid "deleted definition of %qD" +@@ -47152,46 +47203,46 @@ msgstr "папярэдняе вызначэньне `%#T'" + #. that specialization that would cause an implicit + #. instantiation to take place, in every translation unit in + #. which such a use occurs. +-#: cp/decl.c:2535 ++#: cp/decl.c:2537 + #, fuzzy, gcc-internal-format + msgid "explicit specialization of %qD after first use" + msgstr "ініцыялізацыя" + +-#: cp/decl.c:2673 ++#: cp/decl.c:2675 + #, fuzzy, gcc-internal-format + #| msgid "section of `%s' conflicts with previous declaration" + msgid "%qD: visibility attribute ignored because it conflicts with previous declaration" + msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй" + + #. Reject two definitions. +-#: cp/decl.c:2927 cp/decl.c:2956 cp/decl.c:2994 cp/decl.c:3011 cp/decl.c:3109 ++#: cp/decl.c:2929 cp/decl.c:2958 cp/decl.c:2996 cp/decl.c:3013 cp/decl.c:3111 + #: cp/decl2.c:921 + #, fuzzy, gcc-internal-format + #| msgid "previous definition of `%#T'" + msgid "redefinition of %q#D" + msgstr "папярэдняе вызначэньне `%#T'" + +-#: cp/decl.c:2943 ++#: cp/decl.c:2945 + #, fuzzy, gcc-internal-format + msgid "%qD conflicts with used function" + msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй" + +-#: cp/decl.c:2953 ++#: cp/decl.c:2955 + #, fuzzy, gcc-internal-format + msgid "%q#D not declared in class" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/decl.c:2967 cp/decl.c:3021 ++#: cp/decl.c:2969 cp/decl.c:3023 + #, gcc-internal-format + msgid "%q+D redeclared inline with % attribute" + msgstr "" + +-#: cp/decl.c:2970 cp/decl.c:3024 ++#: cp/decl.c:2972 cp/decl.c:3026 + #, gcc-internal-format + msgid "%q+D redeclared inline without % attribute" + msgstr "" + +-#: cp/decl.c:2980 ++#: cp/decl.c:2982 + #, gcc-internal-format + msgid "comparison operator %q+D defaulted after its first declaration" + msgstr "" +@@ -47199,849 +47250,849 @@ msgstr "" + #. is_primary= + #. is_partial= + #. is_friend_decl= +-#: cp/decl.c:3041 ++#: cp/decl.c:3043 + #, gcc-internal-format + msgid "redeclaration of friend %q#D may not have default template arguments" + msgstr "" + +-#: cp/decl.c:3055 ++#: cp/decl.c:3057 + #, gcc-internal-format + msgid "thread-local declaration of %q#D follows non-thread-local declaration" + msgstr "" + +-#: cp/decl.c:3058 ++#: cp/decl.c:3060 + #, gcc-internal-format + msgid "non-thread-local declaration of %q#D follows thread-local declaration" + msgstr "" + +-#: cp/decl.c:3073 cp/decl.c:3117 cp/name-lookup.c:2275 cp/name-lookup.c:2718 ++#: cp/decl.c:3075 cp/decl.c:3119 cp/name-lookup.c:2275 cp/name-lookup.c:2718 + #: cp/name-lookup.c:2742 + #, fuzzy, gcc-internal-format + #| msgid "declaration of `%#D'" + msgid "redeclaration of %q#D" + msgstr "абвяшчэньне `%#D'" + +-#: cp/decl.c:3100 ++#: cp/decl.c:3102 + #, gcc-internal-format + msgid "redundant redeclaration of % static data member %qD" + msgstr "" + +-#: cp/decl.c:3166 ++#: cp/decl.c:3168 + #, gcc-internal-format + msgid "local label %qE conflicts with existing label" + msgstr "" + +-#: cp/decl.c:3167 ++#: cp/decl.c:3169 + #, gcc-internal-format + msgid "previous label" + msgstr "" + +-#: cp/decl.c:3261 ++#: cp/decl.c:3263 + #, gcc-internal-format + msgid " from here" + msgstr " адсюль" + +-#: cp/decl.c:3284 cp/decl.c:3512 ++#: cp/decl.c:3286 cp/decl.c:3514 + #, gcc-internal-format + msgid " exits OpenMP structured block" + msgstr "" + +-#: cp/decl.c:3312 ++#: cp/decl.c:3314 + #, fuzzy, gcc-internal-format + msgid " crosses initialization of %q#D" + msgstr "ініцыялізацыя" + +-#: cp/decl.c:3315 ++#: cp/decl.c:3317 + #, gcc-internal-format + msgid " enters scope of %q#D, which has non-trivial destructor" + msgstr "" + +-#: cp/decl.c:3329 cp/decl.c:3483 ++#: cp/decl.c:3331 cp/decl.c:3485 + #, gcc-internal-format + msgid " enters % block" + msgstr "" + +-#: cp/decl.c:3335 cp/decl.c:3465 cp/decl.c:3485 ++#: cp/decl.c:3337 cp/decl.c:3467 cp/decl.c:3487 + #, gcc-internal-format + msgid " enters % block" + msgstr "" + +-#: cp/decl.c:3341 cp/decl.c:3495 ++#: cp/decl.c:3343 cp/decl.c:3497 + #, gcc-internal-format + msgid " enters OpenMP structured block" + msgstr "" + +-#: cp/decl.c:3347 cp/decl.c:3487 ++#: cp/decl.c:3349 cp/decl.c:3489 + #, gcc-internal-format + msgid " enters synchronized or atomic statement" + msgstr "" + +-#: cp/decl.c:3354 cp/decl.c:3489 ++#: cp/decl.c:3356 cp/decl.c:3491 + #, gcc-internal-format + msgid " enters % statement" + msgstr "" + +-#: cp/decl.c:3472 ++#: cp/decl.c:3474 + #, fuzzy, gcc-internal-format + msgid " skips initialization of %q#D" + msgstr "ініцыялізацыя" + +-#: cp/decl.c:3475 ++#: cp/decl.c:3477 + #, gcc-internal-format + msgid " enters scope of %q#D which has non-trivial destructor" + msgstr "" + +-#: cp/decl.c:3527 cp/parser.c:13060 cp/parser.c:13081 ++#: cp/decl.c:3529 cp/parser.c:13065 cp/parser.c:13086 + #, gcc-internal-format + msgid "invalid exit from OpenMP structured block" + msgstr "" + +-#: cp/decl.c:3933 cp/parser.c:6581 ++#: cp/decl.c:3935 cp/parser.c:6581 + #, gcc-internal-format + msgid "%qD used without template arguments" + msgstr "" + +-#: cp/decl.c:3944 ++#: cp/decl.c:3946 + #, fuzzy, gcc-internal-format + msgid "%q#T is not a class" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/decl.c:3972 cp/decl.c:4065 ++#: cp/decl.c:3974 cp/decl.c:4067 + #, gcc-internal-format + msgid "no class template named %q#T in %q#T" + msgstr "" + +-#: cp/decl.c:3973 ++#: cp/decl.c:3975 + #, fuzzy, gcc-internal-format + msgid "no type named %q#T in %q#T" + msgstr "вяртаемы тып \"%s\" не \"int\"" + +-#: cp/decl.c:3986 ++#: cp/decl.c:3988 + #, fuzzy, gcc-internal-format + msgid "lookup of %qT in %qT is ambiguous" + msgstr "памер \"%s\" - %d байт" + +-#: cp/decl.c:3995 ++#: cp/decl.c:3997 + #, gcc-internal-format + msgid "% names %q#T, which is not a class template" + msgstr "" + +-#: cp/decl.c:4002 ++#: cp/decl.c:4004 + #, gcc-internal-format + msgid "% names %q#T, which is not a type" + msgstr "" + +-#: cp/decl.c:4074 ++#: cp/decl.c:4076 + #, fuzzy, gcc-internal-format + msgid "template parameters do not match template %qD" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/decl.c:4398 ++#: cp/decl.c:4400 + #, gcc-internal-format + msgid "%<-faligned-new=%d%> is not a power of two" + msgstr "" + +-#: cp/decl.c:4890 ++#: cp/decl.c:4892 + #, gcc-internal-format + msgid "member %q+#D with constructor not allowed in anonymous aggregate" + msgstr "" + +-#: cp/decl.c:4893 ++#: cp/decl.c:4895 + #, gcc-internal-format + msgid "member %q+#D with destructor not allowed in anonymous aggregate" + msgstr "" + +-#: cp/decl.c:4896 ++#: cp/decl.c:4898 + #, gcc-internal-format + msgid "member %q+#D with copy assignment operator not allowed in anonymous aggregate" + msgstr "" + +-#: cp/decl.c:4915 ++#: cp/decl.c:4917 + #, fuzzy, gcc-internal-format + msgid "attribute ignored in declaration of %q#T" + msgstr "няма папярэдняга аб'яўлення для \"%s\"" + +-#: cp/decl.c:4918 ++#: cp/decl.c:4920 + #, gcc-internal-format + msgid "attribute for %q#T must follow the %qs keyword" + msgstr "" + +-#: cp/decl.c:4960 ++#: cp/decl.c:4962 + #, gcc-internal-format + msgid "multiple types in one declaration" + msgstr "" + +-#: cp/decl.c:4965 ++#: cp/decl.c:4967 + #, fuzzy, gcc-internal-format + msgid "redeclaration of C++ built-in type %qT" + msgstr "няма папярэдняга аб'яўлення для \"%s\"" + +-#: cp/decl.c:4982 ++#: cp/decl.c:4984 + #, gcc-internal-format + msgid "% can only be specified for variables or function declarations" + msgstr "" + +-#: cp/decl.c:5015 ++#: cp/decl.c:5017 + #, gcc-internal-format + msgid "missing type-name in typedef-declaration" + msgstr "" + +-#: cp/decl.c:5023 ++#: cp/decl.c:5025 + #, gcc-internal-format + msgid "ISO C++ prohibits anonymous structs" + msgstr "" + +-#: cp/decl.c:5030 ++#: cp/decl.c:5032 + #, fuzzy, gcc-internal-format + msgid "% can only be specified for functions" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/decl.c:5033 ++#: cp/decl.c:5035 + #, gcc-internal-format + msgid "% can only be specified for functions" + msgstr "" + +-#: cp/decl.c:5038 ++#: cp/decl.c:5040 + #, gcc-internal-format + msgid "% can only be specified inside a class" + msgstr "" + +-#: cp/decl.c:5041 ++#: cp/decl.c:5043 + #, gcc-internal-format + msgid "% can only be specified for constructors" + msgstr "" + +-#: cp/decl.c:5044 ++#: cp/decl.c:5046 + #, gcc-internal-format + msgid "a storage class can only be specified for objects and functions" + msgstr "" + +-#: cp/decl.c:5048 ++#: cp/decl.c:5050 + #, gcc-internal-format + msgid "% can only be specified for objects and functions" + msgstr "" + +-#: cp/decl.c:5052 ++#: cp/decl.c:5054 + #, gcc-internal-format + msgid "% can only be specified for objects and functions" + msgstr "" + +-#: cp/decl.c:5056 ++#: cp/decl.c:5058 + #, gcc-internal-format + msgid "%<__restrict%> can only be specified for objects and functions" + msgstr "" + +-#: cp/decl.c:5060 ++#: cp/decl.c:5062 + #, gcc-internal-format + msgid "%<__thread%> can only be specified for objects and functions" + msgstr "" + +-#: cp/decl.c:5064 ++#: cp/decl.c:5066 + #, gcc-internal-format + msgid "% was ignored in this declaration" + msgstr "" + +-#: cp/decl.c:5067 cp/decl.c:5070 cp/decl.c:5073 ++#: cp/decl.c:5069 cp/decl.c:5072 cp/decl.c:5075 + #, fuzzy, gcc-internal-format + msgid "%qs cannot be used for type declarations" + msgstr "\"%s\" звычайна функцыя" + +-#: cp/decl.c:5095 ++#: cp/decl.c:5097 + #, fuzzy, gcc-internal-format + msgid "attribute ignored in explicit instantiation %q#T" + msgstr "паўторнае абвяшчэнне меткі \"%s\"" + +-#: cp/decl.c:5098 ++#: cp/decl.c:5100 + #, fuzzy, gcc-internal-format + msgid "no attribute can be applied to an explicit instantiation" + msgstr "\"%s\" звычайна функцыя" + +-#: cp/decl.c:5170 ++#: cp/decl.c:5172 + #, gcc-internal-format + msgid "ignoring attributes applied to class type %qT outside of definition" + msgstr "" + + #. A template type parameter or other dependent type. +-#: cp/decl.c:5174 ++#: cp/decl.c:5176 + #, gcc-internal-format + msgid "ignoring attributes applied to dependent type %qT without an associated declaration" + msgstr "" + +-#: cp/decl.c:5244 cp/decl2.c:851 ++#: cp/decl.c:5246 cp/decl2.c:851 + #, fuzzy, gcc-internal-format + msgid "typedef %qD is initialized (use %qs instead)" + msgstr "параметр \"%s\" ініцыялізаваны" + +-#: cp/decl.c:5253 ++#: cp/decl.c:5255 + #, gcc-internal-format + msgid "declaration of %q#D has % and is initialized" + msgstr "" + +-#: cp/decl.c:5283 ++#: cp/decl.c:5285 + #, gcc-internal-format + msgid "definition of %q#D is marked %" + msgstr "" + +-#: cp/decl.c:5307 ++#: cp/decl.c:5309 + #, gcc-internal-format + msgid "%q+#D is not a static data member of %q#T" + msgstr "" + +-#: cp/decl.c:5315 ++#: cp/decl.c:5317 + #, fuzzy, gcc-internal-format + msgid "non-member-template declaration of %qD" + msgstr "пустое абвяшчэнне" + +-#: cp/decl.c:5316 ++#: cp/decl.c:5318 + #, fuzzy, gcc-internal-format + msgid "does not match member template declaration here" + msgstr "паўторнае абвяшчэнне меткі \"%s\"" + +-#: cp/decl.c:5328 ++#: cp/decl.c:5330 + #, gcc-internal-format + msgid "ISO C++ does not permit %<%T::%D%> to be defined as %<%T::%D%>" + msgstr "" + +-#: cp/decl.c:5340 ++#: cp/decl.c:5342 + #, fuzzy, gcc-internal-format + msgid "duplicate initialization of %qD" + msgstr "паўторнае абвяшчэнне меткі \"%s\"" + +-#: cp/decl.c:5390 ++#: cp/decl.c:5392 + #, gcc-internal-format + msgid "declaration of %q#D outside of class is not definition" + msgstr "" + +-#: cp/decl.c:5431 ++#: cp/decl.c:5433 + #, fuzzy, gcc-internal-format + #| msgid "`%s' undeclared (first use in this function)" + msgid "%qD declared % in %qs function" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/decl.c:5436 ++#: cp/decl.c:5438 + #, fuzzy, gcc-internal-format + msgid "%qD declared % in %qs function" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/decl.c:5510 ++#: cp/decl.c:5512 + #, fuzzy, gcc-internal-format + msgid "variable %q#D has initializer but incomplete type" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/decl.c:5516 cp/decl.c:6567 ++#: cp/decl.c:5518 cp/decl.c:6571 + #, fuzzy, gcc-internal-format + msgid "elements of array %q#D have incomplete type" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/decl.c:5526 ++#: cp/decl.c:5528 + #, gcc-internal-format + msgid "aggregate %q#D has incomplete type and cannot be defined" + msgstr "" + +-#: cp/decl.c:5562 ++#: cp/decl.c:5564 + #, gcc-internal-format + msgid "%qD declared as reference but not initialized" + msgstr "" + +-#: cp/decl.c:5649 ++#: cp/decl.c:5651 + #, gcc-internal-format + msgid "name used in a GNU-style designated initializer for an array" + msgstr "" + +-#: cp/decl.c:5655 ++#: cp/decl.c:5657 + #, gcc-internal-format + msgid "name %qD used in a GNU-style designated initializer for an array" + msgstr "" + +-#: cp/decl.c:5674 ++#: cp/decl.c:5676 + #, gcc-internal-format + msgid "non-trivial designated initializers not supported" + msgstr "" + +-#: cp/decl.c:5678 ++#: cp/decl.c:5680 + #, fuzzy, gcc-internal-format + msgid "C99 designator %qE is not an integral constant-expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/decl.c:5734 ++#: cp/decl.c:5736 + #, gcc-internal-format + msgid "initializer fails to determine size of %qD" + msgstr "" + +-#: cp/decl.c:5741 ++#: cp/decl.c:5743 + #, fuzzy, gcc-internal-format + #| msgid "array size missing in `%D'" + msgid "array size missing in %qD" + msgstr "прапушчан памер масіва ў `%D'" + +-#: cp/decl.c:5753 ++#: cp/decl.c:5755 + #, fuzzy, gcc-internal-format + #| msgid "zero-size array `%D'" + msgid "zero-size array %qD" + msgstr "нулявы памер масіва `%D'" + +-#: cp/decl.c:5793 ++#: cp/decl.c:5795 + #, gcc-internal-format + msgid "storage size of %qD isn%'t known" + msgstr "" + +-#: cp/decl.c:5817 ++#: cp/decl.c:5819 + #, fuzzy, gcc-internal-format + msgid "storage size of %qD isn%'t constant" + msgstr "тып параметра \"%s\" не аб'яўлены" + +-#: cp/decl.c:5868 ++#: cp/decl.c:5870 + #, gcc-internal-format + msgid "sorry: semantics of inline variable %q#D are wrong (you%'ll wind up with multiple copies)" + msgstr "" + +-#: cp/decl.c:5872 ++#: cp/decl.c:5874 + #, gcc-internal-format + msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)" + msgstr "" + +-#: cp/decl.c:5878 ++#: cp/decl.c:5880 + #, gcc-internal-format + msgid "you can work around this by removing the initializer" + msgstr "" + +-#: cp/decl.c:5920 ++#: cp/decl.c:5922 + #, fuzzy, gcc-internal-format + msgid "uninitialized %" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/decl.c:5927 ++#: cp/decl.c:5929 + #, gcc-internal-format + msgid "uninitialized variable %qD in % function" + msgstr "" + +-#: cp/decl.c:5936 ++#: cp/decl.c:5938 + #, gcc-internal-format + msgid "uninitialized variable %qD in % context" + msgstr "" + +-#: cp/decl.c:5944 ++#: cp/decl.c:5946 + #, gcc-internal-format + msgid "%q#T has no user-provided default constructor" + msgstr "" + +-#: cp/decl.c:5948 ++#: cp/decl.c:5950 + #, gcc-internal-format + msgid "constructor is not user-provided because it is explicitly defaulted in the class body" + msgstr "" + +-#: cp/decl.c:5951 ++#: cp/decl.c:5953 + #, gcc-internal-format + msgid "and the implicitly-defined constructor does not initialize %q#D" + msgstr "" + +-#: cp/decl.c:6117 ++#: cp/decl.c:6121 + #, fuzzy, gcc-internal-format + msgid "invalid type %qT as initializer for a vector of type %qT" + msgstr "нерэчаісны ініцыялізатар" + +-#: cp/decl.c:6159 ++#: cp/decl.c:6163 + #, gcc-internal-format + msgid "initializer for %qT must be brace-enclosed" + msgstr "" + +-#: cp/decl.c:6194 ++#: cp/decl.c:6198 + #, gcc-internal-format + msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT" + msgstr "" + +-#: cp/decl.c:6202 ++#: cp/decl.c:6206 + #, gcc-internal-format + msgid "%qT has no non-static data member named %qD" + msgstr "" + +-#: cp/decl.c:6223 ++#: cp/decl.c:6227 + #, fuzzy, gcc-internal-format + #| msgid "invalid initializer" + msgid "invalid initializer for %q#D" + msgstr "нерэчаісны ініцыялізатар" + +-#: cp/decl.c:6254 ++#: cp/decl.c:6258 + #, gcc-internal-format + msgid "C99 designator %qE outside aggregate initializer" + msgstr "" + +-#: cp/decl.c:6293 cp/decl.c:6539 cp/typeck2.c:1475 cp/typeck2.c:1800 +-#: cp/typeck2.c:1848 cp/typeck2.c:1895 ++#: cp/decl.c:6297 cp/decl.c:6543 cp/typeck2.c:1475 cp/typeck2.c:1804 ++#: cp/typeck2.c:1852 cp/typeck2.c:1899 + #, fuzzy, gcc-internal-format + msgid "too many initializers for %qT" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/decl.c:6330 ++#: cp/decl.c:6334 + #, fuzzy, gcc-internal-format + msgid "braces around scalar initializer for type %qT" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/decl.c:6340 ++#: cp/decl.c:6344 + #, gcc-internal-format + msgid "too many braces around scalar initializer for type %qT" + msgstr "" + +-#: cp/decl.c:6458 ++#: cp/decl.c:6462 + #, fuzzy, gcc-internal-format + msgid "missing braces around initializer for %qT" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/decl.c:6569 ++#: cp/decl.c:6573 + #, fuzzy, gcc-internal-format + msgid "elements of array %q#T have incomplete type" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/decl.c:6582 ++#: cp/decl.c:6586 + #, gcc-internal-format + msgid "variable-sized compound literal" + msgstr "" + +-#: cp/decl.c:6637 ++#: cp/decl.c:6641 + #, fuzzy, gcc-internal-format + msgid "%q#D has incomplete type" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/decl.c:6658 ++#: cp/decl.c:6662 + #, gcc-internal-format + msgid "scalar object %qD requires one element in initializer" + msgstr "" + +-#: cp/decl.c:6703 ++#: cp/decl.c:6707 + #, gcc-internal-format + msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>" + msgstr "" + +-#: cp/decl.c:6850 ++#: cp/decl.c:6854 + #, gcc-internal-format + msgid "array %qD initialized by parenthesized string literal %qE" + msgstr "" + +-#: cp/decl.c:6885 ++#: cp/decl.c:6889 + #, gcc-internal-format + msgid "initializer invalid for static member with constructor" + msgstr "" + +-#: cp/decl.c:6887 ++#: cp/decl.c:6891 + #, gcc-internal-format + msgid "non-constant in-class initialization invalid for static member %qD" + msgstr "" + +-#: cp/decl.c:6890 ++#: cp/decl.c:6894 + #, gcc-internal-format + msgid "non-constant in-class initialization invalid for non-inline static member %qD" + msgstr "" + +-#: cp/decl.c:6895 ++#: cp/decl.c:6899 + #, gcc-internal-format + msgid "(an out of class initialization is required)" + msgstr "" + +-#: cp/decl.c:7073 ++#: cp/decl.c:7077 + #, fuzzy, gcc-internal-format + msgid "reference %qD is initialized with itself" + msgstr "параметр \"%s\" ініцыялізаваны" + +-#: cp/decl.c:7341 ++#: cp/decl.c:7335 + #, fuzzy, gcc-internal-format + msgid "could not find variant declaration" + msgstr "Не магу знайсці дэкларацыю інтэрфейса для \"%s\"" + +-#: cp/decl.c:7365 ++#: cp/decl.c:7359 + #, gcc-internal-format + msgid "% on constructor %qD" + msgstr "" + +-#: cp/decl.c:7370 ++#: cp/decl.c:7364 + #, gcc-internal-format + msgid "% on destructor %qD" + msgstr "" + +-#: cp/decl.c:7375 ++#: cp/decl.c:7369 + #, gcc-internal-format + msgid "% on defaulted %qD" + msgstr "" + +-#: cp/decl.c:7380 ++#: cp/decl.c:7374 + #, fuzzy, gcc-internal-format + #| msgid "declaration of template `%#D'" + msgid "% on deleted %qD" + msgstr "абвяшчэньне шаблёну `%#D'" + +-#: cp/decl.c:7385 ++#: cp/decl.c:7379 + #, gcc-internal-format + msgid "% on virtual %qD" + msgstr "" + +-#: cp/decl.c:7435 ++#: cp/decl.c:7429 + #, gcc-internal-format + msgid "assignment (not initialization) in declaration" + msgstr "" + +-#: cp/decl.c:7453 cp/decl.c:13717 ++#: cp/decl.c:7447 cp/decl.c:13726 + #, gcc-internal-format + msgid "ISO C++17 does not allow % storage class specifier" + msgstr "" + +-#: cp/decl.c:7457 cp/decl.c:13721 ++#: cp/decl.c:7451 cp/decl.c:13730 + #, gcc-internal-format + msgid "% storage class specifier used" + msgstr "" + +-#: cp/decl.c:7504 ++#: cp/decl.c:7498 + #, gcc-internal-format + msgid "initializer for % has function type; did you forget the %<()%>?" + msgstr "" + +-#: cp/decl.c:7616 ++#: cp/decl.c:7610 + #, gcc-internal-format + msgid "variable concept has no initializer" + msgstr "" + +-#: cp/decl.c:7669 ++#: cp/decl.c:7663 + #, fuzzy, gcc-internal-format + msgid "shadowing previous type declaration of %q#D" + msgstr "няма папярэдняга аб'яўлення для \"%s\"" + +-#: cp/decl.c:7712 ++#: cp/decl.c:7706 + #, gcc-internal-format + msgid "% can only be applied to a variable with static or thread storage duration" + msgstr "" + +-#: cp/decl.c:7881 ++#: cp/decl.c:7878 + #, gcc-internal-format + msgid "function %q#D is initialized like a variable" + msgstr "" + +-#: cp/decl.c:7967 ++#: cp/decl.c:7964 + #, gcc-internal-format + msgid "cannot decompose class type %qT because it has an anonymous struct member" + msgstr "" + +-#: cp/decl.c:7970 ++#: cp/decl.c:7967 + #, gcc-internal-format + msgid "cannot decompose class type %qT because it has an anonymous union member" + msgstr "" + +-#: cp/decl.c:7977 ++#: cp/decl.c:7974 + #, gcc-internal-format + msgid "cannot decompose inaccessible member %qD of %qT" + msgstr "" + +-#: cp/decl.c:8003 ++#: cp/decl.c:8000 + #, gcc-internal-format + msgid "cannot decompose class type %qT: both it and its base class %qT have non-static data members" + msgstr "" + +-#: cp/decl.c:8012 ++#: cp/decl.c:8009 + #, gcc-internal-format + msgid "cannot decompose class type %qT: its base classes %qT and %qT have non-static data members" + msgstr "" + +-#: cp/decl.c:8222 ++#: cp/decl.c:8219 + #, fuzzy, gcc-internal-format + msgid "structured binding refers to incomplete type %qT" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/decl.c:8238 ++#: cp/decl.c:8235 + #, gcc-internal-format + msgid "cannot decompose variable length array %qT" + msgstr "" + +-#: cp/decl.c:8247 cp/decl.c:8332 ++#: cp/decl.c:8244 cp/decl.c:8329 + #, gcc-internal-format, gfc-internal-format + msgid "%u name provided for structured binding" + msgid_plural "%u names provided for structured binding" + msgstr[0] "" + msgstr[1] "" + +-#: cp/decl.c:8251 ++#: cp/decl.c:8248 + #, gcc-internal-format, gfc-internal-format + msgid "only %u name provided for structured binding" + msgid_plural "only %u names provided for structured binding" + msgstr[0] "" + msgstr[1] "" + +-#: cp/decl.c:8254 ++#: cp/decl.c:8251 + #, gcc-internal-format + msgid "while %qT decomposes into %wu element" + msgid_plural "while %qT decomposes into %wu elements" + msgstr[0] "" + msgstr[1] "" + +-#: cp/decl.c:8299 ++#: cp/decl.c:8296 + #, gcc-internal-format + msgid "cannot decompose variable length vector %qT" + msgstr "" + +-#: cp/decl.c:8325 ++#: cp/decl.c:8322 + #, fuzzy, gcc-internal-format + msgid "%::value%> is not an integral constant expression" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/decl.c:8334 ++#: cp/decl.c:8331 + #, gcc-internal-format + msgid "while %qT decomposes into %E elements" + msgstr "" + +-#: cp/decl.c:8355 ++#: cp/decl.c:8352 + #, gcc-internal-format + msgid "in initialization of structured binding variable %qD" + msgstr "" + +-#: cp/decl.c:8384 ++#: cp/decl.c:8381 + #, gcc-internal-format + msgid "cannot decompose union type %qT" + msgstr "" + +-#: cp/decl.c:8389 ++#: cp/decl.c:8386 + #, gcc-internal-format + msgid "cannot decompose non-array non-class type %qT" + msgstr "" + +-#: cp/decl.c:8394 ++#: cp/decl.c:8391 + #, gcc-internal-format + msgid "cannot decompose lambda closure type %qT" + msgstr "" + +-#: cp/decl.c:8398 ++#: cp/decl.c:8397 + #, gcc-internal-format + msgid "structured binding refers to incomplete class type %qT" + msgstr "" + +-#: cp/decl.c:8407 ++#: cp/decl.c:8406 + #, gcc-internal-format + msgid "cannot decompose class type %qT without non-static data members" + msgstr "" + +-#: cp/decl.c:8854 ++#: cp/decl.c:8853 + #, gcc-internal-format + msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization" + msgstr "" + +-#: cp/decl.c:8857 ++#: cp/decl.c:8856 + #, gcc-internal-format + msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor" + msgstr "" + +-#: cp/decl.c:8862 ++#: cp/decl.c:8861 + #, gcc-internal-format + msgid "C++11 % allows dynamic initialization and destruction" + msgstr "" + +-#: cp/decl.c:9091 ++#: cp/decl.c:9090 + #, gcc-internal-format + msgid "initializer fails to determine size of %qT" + msgstr "" + +-#: cp/decl.c:9095 ++#: cp/decl.c:9094 + #, fuzzy, gcc-internal-format + #| msgid "array size missing in `%D'" + msgid "array size missing in %qT" + msgstr "прапушчан памер масіва ў `%D'" + +-#: cp/decl.c:9098 ++#: cp/decl.c:9097 + #, fuzzy, gcc-internal-format + #| msgid "zero-size array `%D'" + msgid "zero-size array %qT" + msgstr "нулявы памер масіва `%D'" + +-#: cp/decl.c:9114 ++#: cp/decl.c:9113 + #, gcc-internal-format + msgid "destructor for alien class %qT cannot be a member" + msgstr "" + +-#: cp/decl.c:9116 ++#: cp/decl.c:9115 + #, gcc-internal-format + msgid "constructor for alien class %qT cannot be a member" + msgstr "" + +-#: cp/decl.c:9142 ++#: cp/decl.c:9141 + #, gcc-internal-format + msgid "%qD declared as a % variable" + msgstr "" + +-#: cp/decl.c:9144 ++#: cp/decl.c:9143 + #, gcc-internal-format + msgid "% and % function specifiers on %qD invalid in variable declaration" + msgstr "" + +-#: cp/decl.c:9150 ++#: cp/decl.c:9149 + #, gcc-internal-format + msgid "%qD declared as a % parameter" + msgstr "" + +-#: cp/decl.c:9153 ++#: cp/decl.c:9152 + #, gcc-internal-format + msgid "%qD declared as an % parameter" + msgstr "" + +-#: cp/decl.c:9155 ++#: cp/decl.c:9154 + #, gcc-internal-format + msgid "% and % function specifiers on %qD invalid in parameter declaration" + msgstr "" + +-#: cp/decl.c:9161 ++#: cp/decl.c:9160 + #, gcc-internal-format + msgid "%qD declared as a % type" + msgstr "" + +-#: cp/decl.c:9164 ++#: cp/decl.c:9163 + #, gcc-internal-format + msgid "%qD declared as an % type" + msgstr "" + +-#: cp/decl.c:9166 ++#: cp/decl.c:9165 + #, gcc-internal-format + msgid "% and % function specifiers on %qD invalid in type declaration" + msgstr "" + +-#: cp/decl.c:9172 ++#: cp/decl.c:9171 + #, gcc-internal-format + msgid "%qD declared as a % field" + msgstr "" + +-#: cp/decl.c:9175 ++#: cp/decl.c:9174 + #, gcc-internal-format + msgid "%qD declared as an % field" + msgstr "" + +-#: cp/decl.c:9177 ++#: cp/decl.c:9176 + #, gcc-internal-format + msgid "% and % function specifiers on %qD invalid in field declaration" + msgstr "" + +-#: cp/decl.c:9184 ++#: cp/decl.c:9183 + #, gcc-internal-format + msgid "%q+D declared as a friend" + msgstr "" + +-#: cp/decl.c:9191 ++#: cp/decl.c:9190 + #, fuzzy, gcc-internal-format + msgid "%q+D declared with an exception specification" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/decl.c:9223 ++#: cp/decl.c:9222 + #, gcc-internal-format + msgid "definition of %qD is not in namespace enclosing %qT" + msgstr "" + +-#: cp/decl.c:9263 ++#: cp/decl.c:9262 + #, gcc-internal-format + msgid "static member function %q#D declared with type qualifiers" + msgstr "" + +-#: cp/decl.c:9274 ++#: cp/decl.c:9273 + #, gcc-internal-format + msgid "concept %q#D declared with function parameters" + msgstr "" + +-#: cp/decl.c:9281 ++#: cp/decl.c:9280 + #, gcc-internal-format + msgid "concept %q#D declared with a deduced return type" + msgstr "" + +-#: cp/decl.c:9284 ++#: cp/decl.c:9283 + #, gcc-internal-format + msgid "concept %q#D with non-% return type %qT" + msgstr "" +@@ -48315,7 +48366,7 @@ msgstr "" + msgid "%qD declared as array of %qT" + msgstr "" + +-#: cp/decl.c:10559 cp/pt.c:15746 ++#: cp/decl.c:10559 cp/pt.c:15780 + #, gcc-internal-format + msgid "creating array of %qT" + msgstr "" +@@ -48482,7 +48533,7 @@ msgstr "" + msgid "function definition does not declare parameters" + msgstr "" + +-#: cp/decl.c:11193 cp/decl.c:11202 cp/decl.c:12981 ++#: cp/decl.c:11193 cp/decl.c:11202 cp/decl.c:12988 + #, fuzzy, gcc-internal-format + msgid "declaration of %qD as non-function" + msgstr "няма папярэдняга аб'яўлення для \"%s\"" +@@ -48694,819 +48745,819 @@ msgstr "\"%s\" атрыбут ігнарыруецца" + msgid "an attribute that appertains to a type-specifier is ignored" + msgstr "" + +-#: cp/decl.c:11964 ++#: cp/decl.c:11971 + #, fuzzy, gcc-internal-format + msgid "unnecessary parentheses in declaration of %qs" + msgstr "няма папярэдняга аб'яўлення для \"%s\"" + +-#: cp/decl.c:12016 ++#: cp/decl.c:12023 + #, gcc-internal-format + msgid "requires-clause on return type" + msgstr "" + +-#: cp/decl.c:12039 ++#: cp/decl.c:12046 + #, gcc-internal-format + msgid "%qs function uses % type specifier without trailing return type" + msgstr "" + +-#: cp/decl.c:12043 ++#: cp/decl.c:12050 + #, gcc-internal-format + msgid "deduced return type only available with %<-std=c++14%> or %<-std=gnu++14%>" + msgstr "" + +-#: cp/decl.c:12048 ++#: cp/decl.c:12055 + #, fuzzy, gcc-internal-format + #| msgid "virtual functions cannot be friends" + msgid "virtual function cannot have deduced return type" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/decl.c:12055 ++#: cp/decl.c:12062 + #, gcc-internal-format + msgid "%qs function with trailing return type has %qT as its type rather than plain %" + msgstr "" + +-#: cp/decl.c:12064 ++#: cp/decl.c:12071 + #, gcc-internal-format + msgid "%qs function with trailing return type has % as its type rather than plain %" + msgstr "" + +-#: cp/decl.c:12069 ++#: cp/decl.c:12076 + #, fuzzy, gcc-internal-format + msgid "invalid use of %" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/decl.c:12080 ++#: cp/decl.c:12087 + #, gcc-internal-format + msgid "deduced class type %qD in function return type" + msgstr "" + +-#: cp/decl.c:12089 ++#: cp/decl.c:12096 + #, gcc-internal-format + msgid "deduction guide for %qT must have trailing return type" + msgstr "" + +-#: cp/decl.c:12102 ++#: cp/decl.c:12109 + #, gcc-internal-format + msgid "trailing return type %qT of deduction guide is not a specialization of %qT" + msgstr "" + +-#: cp/decl.c:12116 ++#: cp/decl.c:12123 + #, gcc-internal-format + msgid "trailing return type only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/decl.c:12119 ++#: cp/decl.c:12126 + #, gcc-internal-format + msgid "%qs function with trailing return type not declared with % type specifier" + msgstr "" + +-#: cp/decl.c:12144 ++#: cp/decl.c:12151 + #, gcc-internal-format + msgid "%-qualified return type is deprecated" + msgstr "" + +-#: cp/decl.c:12156 ++#: cp/decl.c:12163 + #, fuzzy, gcc-internal-format + #| msgid "`%s' undeclared (first use in this function)" + msgid "%qs declared as function returning a function" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/decl.c:12162 ++#: cp/decl.c:12169 + #, gcc-internal-format + msgid "%qs declared as function returning an array" + msgstr "" + +-#: cp/decl.c:12169 ++#: cp/decl.c:12176 + #, gcc-internal-format + msgid "% on function return type is not allowed" + msgstr "" + +-#: cp/decl.c:12178 cp/pt.c:28963 ++#: cp/decl.c:12185 cp/pt.c:29031 + #, gcc-internal-format + msgid "%qT as type rather than plain %" + msgstr "" + +-#: cp/decl.c:12209 ++#: cp/decl.c:12216 + #, gcc-internal-format + msgid "destructor cannot be static member function" + msgstr "" + +-#: cp/decl.c:12211 ++#: cp/decl.c:12218 + #, gcc-internal-format + msgid "constructor cannot be static member function" + msgstr "" + +-#: cp/decl.c:12216 ++#: cp/decl.c:12223 + #, gcc-internal-format + msgid "destructors may not be cv-qualified" + msgstr "" + +-#: cp/decl.c:12217 ++#: cp/decl.c:12224 + #, gcc-internal-format + msgid "constructors may not be cv-qualified" + msgstr "" + +-#: cp/decl.c:12225 ++#: cp/decl.c:12232 + #, gcc-internal-format + msgid "destructors may not be ref-qualified" + msgstr "" + +-#: cp/decl.c:12226 ++#: cp/decl.c:12233 + #, gcc-internal-format + msgid "constructors may not be ref-qualified" + msgstr "" + +-#: cp/decl.c:12244 ++#: cp/decl.c:12251 + #, fuzzy, gcc-internal-format + msgid "constructors cannot be declared %" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/decl.c:12261 ++#: cp/decl.c:12268 + #, gcc-internal-format + msgid "virtual functions cannot be friends" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/decl.c:12266 ++#: cp/decl.c:12273 + #, gcc-internal-format + msgid "friend declaration not in class definition" + msgstr "" + +-#: cp/decl.c:12270 ++#: cp/decl.c:12277 + #, fuzzy, gcc-internal-format + msgid "cannot define friend function %qs in a local class definition" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/decl.c:12280 ++#: cp/decl.c:12287 + #, gcc-internal-format + msgid "friend function definition %qs cannot have a name qualified with %<::%>" + msgstr "" + +-#: cp/decl.c:12284 ++#: cp/decl.c:12291 + #, gcc-internal-format + msgid "friend function definition %qs cannot have a name qualified with %<%D::%>" + msgstr "" + +-#: cp/decl.c:12297 ++#: cp/decl.c:12304 + #, gcc-internal-format + msgid "a conversion function cannot have a trailing return type" + msgstr "" + +-#: cp/decl.c:12324 ++#: cp/decl.c:12331 + #, gcc-internal-format + msgid "destructors may not have parameters" + msgstr "" + +-#: cp/decl.c:12364 ++#: cp/decl.c:12371 + #, fuzzy, gcc-internal-format + msgid "cannot declare pointer to %q#T" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/decl.c:12377 cp/decl.c:12384 ++#: cp/decl.c:12384 cp/decl.c:12391 + #, fuzzy, gcc-internal-format + msgid "cannot declare reference to %q#T" + msgstr "Не магу знайсці файл для класа %s." + +-#: cp/decl.c:12386 ++#: cp/decl.c:12393 + #, gcc-internal-format + msgid "cannot declare pointer to %q#T member" + msgstr "" + +-#: cp/decl.c:12415 ++#: cp/decl.c:12422 + #, gcc-internal-format + msgid "cannot declare reference to qualified function type %qT" + msgstr "" + +-#: cp/decl.c:12416 ++#: cp/decl.c:12423 + #, fuzzy, gcc-internal-format + msgid "cannot declare pointer to qualified function type %qT" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/decl.c:12489 ++#: cp/decl.c:12496 + #, gcc-internal-format + msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument" + msgstr "" + +-#: cp/decl.c:12560 ++#: cp/decl.c:12567 + #, gcc-internal-format + msgid "template-id %qD used as a declarator" + msgstr "" + +-#: cp/decl.c:12586 ++#: cp/decl.c:12593 + #, gcc-internal-format + msgid "member functions are implicitly friends of their class" + msgstr "" + +-#: cp/decl.c:12591 ++#: cp/decl.c:12598 + #, gcc-internal-format + msgid "extra qualification %<%T::%> on member %qs" + msgstr "" + +-#: cp/decl.c:12621 ++#: cp/decl.c:12628 + #, gcc-internal-format + msgid "cannot define member function %<%T::%s%> within %qT" + msgstr "" + +-#: cp/decl.c:12623 ++#: cp/decl.c:12630 + #, gcc-internal-format + msgid "cannot declare member function %<%T::%s%> within %qT" + msgstr "" + +-#: cp/decl.c:12631 ++#: cp/decl.c:12638 + #, gcc-internal-format + msgid "cannot declare member %<%T::%s%> within %qT" + msgstr "" + +-#: cp/decl.c:12671 ++#: cp/decl.c:12678 + #, gcc-internal-format + msgid "non-parameter %qs cannot be a parameter pack" + msgstr "" + +-#: cp/decl.c:12680 ++#: cp/decl.c:12687 + #, gcc-internal-format + msgid "data member may not have variably modified type %qT" + msgstr "" + +-#: cp/decl.c:12683 ++#: cp/decl.c:12690 + #, gcc-internal-format + msgid "parameter may not have variably modified type %qT" + msgstr "" + +-#: cp/decl.c:12694 ++#: cp/decl.c:12701 + #, fuzzy, gcc-internal-format + #| msgid "duplicate label declaration `%s'" + msgid "% outside class declaration" + msgstr "паўторнае абвяшчэньне адмеціны `%s'" + +-#: cp/decl.c:12697 ++#: cp/decl.c:12704 + #, fuzzy, gcc-internal-format + msgid "% in friend declaration" + msgstr "няма папярэдняга аб'яўлення для \"%s\"" + +-#: cp/decl.c:12700 ++#: cp/decl.c:12707 + #, gcc-internal-format + msgid "only declarations of constructors and conversion operators can be %" + msgstr "" + +-#: cp/decl.c:12710 ++#: cp/decl.c:12717 + #, fuzzy, gcc-internal-format + msgid "non-member %qs cannot be declared %" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/decl.c:12717 ++#: cp/decl.c:12724 + #, gcc-internal-format + msgid "non-object member %qs cannot be declared %" + msgstr "" + +-#: cp/decl.c:12723 ++#: cp/decl.c:12730 + #, fuzzy, gcc-internal-format + msgid "function %qs cannot be declared %" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/decl.c:12729 ++#: cp/decl.c:12736 + #, gcc-internal-format + msgid "% %qs cannot be declared %" + msgstr "" + +-#: cp/decl.c:12735 ++#: cp/decl.c:12742 + #, fuzzy, gcc-internal-format + msgid "% %qs cannot be declared %" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/decl.c:12741 ++#: cp/decl.c:12748 + #, fuzzy, gcc-internal-format + msgid "reference %qs cannot be declared %" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/decl.c:12757 ++#: cp/decl.c:12764 + #, gcc-internal-format + msgid "typedef may not be a function definition" + msgstr "" + +-#: cp/decl.c:12760 ++#: cp/decl.c:12767 + #, gcc-internal-format + msgid "typedef may not be a member function definition" + msgstr "" + +-#: cp/decl.c:12786 ++#: cp/decl.c:12793 + #, fuzzy, gcc-internal-format + msgid "% not allowed in alias declaration" + msgstr "\"%s\" - гэта не пачатак дэкларацыі" + +-#: cp/decl.c:12789 ++#: cp/decl.c:12796 + #, gcc-internal-format + msgid "typedef declared %" + msgstr "" + +-#: cp/decl.c:12794 ++#: cp/decl.c:12801 + #, gcc-internal-format + msgid "requires-clause on typedef" + msgstr "" + +-#: cp/decl.c:12798 ++#: cp/decl.c:12805 + #, gcc-internal-format + msgid "typedef name may not be a nested-name-specifier" + msgstr "" + +-#: cp/decl.c:12822 ++#: cp/decl.c:12829 + #, gcc-internal-format + msgid "ISO C++ forbids nested type %qD with same name as enclosing class" + msgstr "" + +-#: cp/decl.c:12911 ++#: cp/decl.c:12918 + #, fuzzy, gcc-internal-format + msgid "% specified for friend class declaration" + msgstr "паўторнае абвяшчэнне меткі \"%s\"" + +-#: cp/decl.c:12919 ++#: cp/decl.c:12926 + #, fuzzy, gcc-internal-format + msgid "template parameters cannot be friends" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/decl.c:12921 ++#: cp/decl.c:12928 + #, gcc-internal-format + msgid "friend declaration requires class-key, i.e. %" + msgstr "" + +-#: cp/decl.c:12925 ++#: cp/decl.c:12932 + #, gcc-internal-format + msgid "friend declaration requires class-key, i.e. %" + msgstr "" + +-#: cp/decl.c:12938 ++#: cp/decl.c:12945 + #, gcc-internal-format + msgid "trying to make class %qT a friend of global scope" + msgstr "" + +-#: cp/decl.c:12958 ++#: cp/decl.c:12965 + #, gcc-internal-format + msgid "invalid qualifiers on non-member function type" + msgstr "" + +-#: cp/decl.c:12962 ++#: cp/decl.c:12969 + #, gcc-internal-format + msgid "requires-clause on type-id" + msgstr "" + +-#: cp/decl.c:12972 ++#: cp/decl.c:12979 + #, gcc-internal-format + msgid "abstract declarator %qT used as declaration" + msgstr "" + +-#: cp/decl.c:12987 ++#: cp/decl.c:12994 + #, fuzzy, gcc-internal-format + msgid "requires-clause on declaration of non-function type %qT" + msgstr "няма папярэдняга аб'яўлення для \"%s\"" + +-#: cp/decl.c:13006 ++#: cp/decl.c:13013 + #, fuzzy, gcc-internal-format + msgid "cannot use %<::%> in parameter declaration" + msgstr "Не магу знайсці дэкларацыю пратакола для \"%s\"" + +-#: cp/decl.c:13015 cp/parser.c:18438 ++#: cp/decl.c:13022 cp/parser.c:18443 + #, gcc-internal-format + msgid "cannot declare a parameter with %" + msgstr "" + +-#: cp/decl.c:13018 ++#: cp/decl.c:13025 + #, gcc-internal-format + msgid "% parameter not permitted in this context" + msgstr "" + +-#: cp/decl.c:13021 ++#: cp/decl.c:13028 + #, fuzzy, gcc-internal-format + msgid "parameter declared %" + msgstr "тып параметра \"%s\" не аб'яўлены" + +-#: cp/decl.c:13072 cp/parser.c:3328 ++#: cp/decl.c:13079 cp/parser.c:3328 + #, fuzzy, gcc-internal-format + msgid "invalid use of template-name %qE without an argument list" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/decl.c:13076 ++#: cp/decl.c:13083 + #, gcc-internal-format + msgid "non-static data member declared with placeholder %qT" + msgstr "" + +-#: cp/decl.c:13097 ++#: cp/decl.c:13104 + #, fuzzy, gcc-internal-format + msgid "ISO C++ forbids flexible array member %qs" + msgstr "ISO C не дазваляе дэкларацыі метак (label)" + +-#: cp/decl.c:13100 ++#: cp/decl.c:13107 + #, fuzzy, gcc-internal-format + msgid "ISO C++ forbids flexible array members" + msgstr "ISO C не дазваляе дэкларацыі метак (label)" + + #. Something like struct S { int N::j; }; +-#: cp/decl.c:13116 ++#: cp/decl.c:13123 + #, fuzzy, gcc-internal-format + #| msgid "invalid use of `::'" + msgid "invalid use of %<::%>" + msgstr "нерэчаіснае выкарыстаньне `::'" + +-#: cp/decl.c:13137 ++#: cp/decl.c:13144 + #, fuzzy, gcc-internal-format + msgid "declaration of function %qD in invalid context" + msgstr "няма папярэдняга аб'яўлення для \"%s\"" + +-#: cp/decl.c:13147 ++#: cp/decl.c:13154 + #, fuzzy, gcc-internal-format + msgid "function %qD declared % inside a union" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/decl.c:13157 ++#: cp/decl.c:13164 + #, gcc-internal-format + msgid "%qD cannot be declared %, since it is always static" + msgstr "" + +-#: cp/decl.c:13171 ++#: cp/decl.c:13178 + #, gcc-internal-format + msgid "expected qualified name in friend declaration for destructor %qD" + msgstr "" + +-#: cp/decl.c:13178 ++#: cp/decl.c:13185 + #, fuzzy, gcc-internal-format + #| msgid "declaration of template `%#D'" + msgid "declaration of %qD as member of %qT" + msgstr "абвяшчэньне шаблёну `%#D'" + +-#: cp/decl.c:13185 cp/decl.c:13198 ++#: cp/decl.c:13192 cp/decl.c:13205 + #, gcc-internal-format + msgid "a destructor cannot be %qs" + msgstr "" + +-#: cp/decl.c:13191 ++#: cp/decl.c:13198 + #, gcc-internal-format + msgid "% destructors only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/decl.c:13204 ++#: cp/decl.c:13211 + #, gcc-internal-format + msgid "expected qualified name in friend declaration for constructor %qD" + msgstr "" + +-#: cp/decl.c:13213 ++#: cp/decl.c:13220 + #, gcc-internal-format + msgid "a constructor cannot be %" + msgstr "" + +-#: cp/decl.c:13219 ++#: cp/decl.c:13226 + #, fuzzy, gcc-internal-format + msgid "a concept cannot be a member function" + msgstr "\"%s\" звычайна функцыя" + +-#: cp/decl.c:13227 cp/decl.c:13554 ++#: cp/decl.c:13234 cp/decl.c:13562 + #, fuzzy, gcc-internal-format + #| msgid "[cannot find %s]" + msgid "%qD cannot be %qs" + msgstr "[нельга знайсці %s]" + +-#: cp/decl.c:13236 ++#: cp/decl.c:13243 + #, gcc-internal-format + msgid "specialization of variable template %qD declared as function" + msgstr "" + +-#: cp/decl.c:13239 ++#: cp/decl.c:13246 + #, fuzzy, gcc-internal-format + msgid "variable template declared here" + msgstr "паўторнае абвяшчэнне меткі \"%s\"" + +-#: cp/decl.c:13301 ++#: cp/decl.c:13309 + #, fuzzy, gcc-internal-format + msgid "field %qD has incomplete type %qT" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/decl.c:13306 ++#: cp/decl.c:13314 + #, fuzzy, gcc-internal-format + msgid "name %qT has incomplete type" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/decl.c:13326 ++#: cp/decl.c:13334 + #, fuzzy, gcc-internal-format + msgid "%qE is neither function nor member function; cannot be declared friend" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/decl.c:13329 ++#: cp/decl.c:13337 + #, gcc-internal-format + msgid "unnamed field is neither function nor member function; cannot be declared friend" + msgstr "" + +-#: cp/decl.c:13379 cp/decl.c:13390 ++#: cp/decl.c:13387 cp/decl.c:13398 + #, gcc-internal-format + msgid "static data member %qE declared %qs" + msgstr "" + +-#: cp/decl.c:13384 ++#: cp/decl.c:13392 + #, gcc-internal-format + msgid "% static data member %qD must have an initializer" + msgstr "" + +-#: cp/decl.c:13418 cp/decl.c:13426 cp/decl.c:13433 cp/decl.c:13440 ++#: cp/decl.c:13426 cp/decl.c:13434 cp/decl.c:13441 cp/decl.c:13448 + #, gcc-internal-format + msgid "non-static data member %qE declared %qs" + msgstr "" + +-#: cp/decl.c:13495 ++#: cp/decl.c:13503 + #, gcc-internal-format + msgid "storage class % invalid for function %qs" + msgstr "" + +-#: cp/decl.c:13498 ++#: cp/decl.c:13506 + #, gcc-internal-format + msgid "storage class % invalid for function %qs" + msgstr "" + +-#: cp/decl.c:13504 ++#: cp/decl.c:13512 + #, gcc-internal-format + msgid "storage class %<__thread%> invalid for function %qs" + msgstr "" + +-#: cp/decl.c:13508 ++#: cp/decl.c:13516 + #, gcc-internal-format + msgid "storage class % invalid for function %qs" + msgstr "" + +-#: cp/decl.c:13513 ++#: cp/decl.c:13521 + #, gcc-internal-format + msgid "virt-specifiers in %qs not allowed outside a class definition" + msgstr "" + +-#: cp/decl.c:13525 ++#: cp/decl.c:13533 + #, gcc-internal-format + msgid "% specifier invalid for function %qs declared out of global scope" + msgstr "" + +-#: cp/decl.c:13529 ++#: cp/decl.c:13537 + #, gcc-internal-format + msgid "% specifier invalid for function %qs declared out of global scope" + msgstr "" + +-#: cp/decl.c:13537 ++#: cp/decl.c:13545 + #, gcc-internal-format + msgid "virtual non-class function %qs" + msgstr "" + +-#: cp/decl.c:13544 ++#: cp/decl.c:13552 + #, gcc-internal-format + msgid "%qs defined in a non-class scope" + msgstr "" + +-#: cp/decl.c:13545 ++#: cp/decl.c:13553 + #, fuzzy, gcc-internal-format + msgid "%qs declared in a non-class scope" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/decl.c:13588 ++#: cp/decl.c:13597 + #, gcc-internal-format + msgid "cannot declare member function %qD to have static linkage" + msgstr "" + +-#: cp/decl.c:13597 ++#: cp/decl.c:13606 + #, gcc-internal-format + msgid "cannot declare static function inside another function" + msgstr "" + +-#: cp/decl.c:13636 ++#: cp/decl.c:13645 + #, gcc-internal-format + msgid "% may not be used when defining (as opposed to declaring) a static data member" + msgstr "" + +-#: cp/decl.c:13643 ++#: cp/decl.c:13652 + #, gcc-internal-format + msgid "static member %qD declared %" + msgstr "" + +-#: cp/decl.c:13649 ++#: cp/decl.c:13658 + #, gcc-internal-format + msgid "cannot explicitly declare member %q#D to have extern linkage" + msgstr "" + +-#: cp/decl.c:13657 ++#: cp/decl.c:13666 + #, gcc-internal-format + msgid "declaration of % variable %qD is not a definition" + msgstr "" + +-#: cp/decl.c:13664 ++#: cp/decl.c:13673 + #, gcc-internal-format + msgid "a variable cannot be declared %" + msgstr "" + +-#: cp/decl.c:13684 ++#: cp/decl.c:13693 + #, fuzzy, gcc-internal-format + msgid "declaration of %q#D has no initializer" + msgstr "няма папярэдняга аб'яўлення для \"%s\"" + +-#: cp/decl.c:13696 ++#: cp/decl.c:13705 + #, gcc-internal-format + msgid "%qs initialized and declared %" + msgstr "" + +-#: cp/decl.c:13701 ++#: cp/decl.c:13710 + #, gcc-internal-format + msgid "%qs has both % and initializer" + msgstr "" + +-#: cp/decl.c:13868 ++#: cp/decl.c:13877 + #, fuzzy, gcc-internal-format + msgid "default argument %qE uses %qD" + msgstr "нехапае аргументаў у функцыі \"%s\"" + +-#: cp/decl.c:13871 ++#: cp/decl.c:13880 + #, fuzzy, gcc-internal-format + msgid "default argument %qE uses local variable %qD" + msgstr "нехапае аргументаў у функцыі \"%s\"" + +-#: cp/decl.c:13958 ++#: cp/decl.c:13967 + #, fuzzy, gcc-internal-format + msgid "invalid use of cv-qualified type %qT in parameter declaration" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/decl.c:13962 ++#: cp/decl.c:13971 + #, fuzzy, gcc-internal-format + msgid "invalid use of type % in parameter declaration" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/decl.c:13984 ++#: cp/decl.c:13993 + #, gcc-internal-format + msgid "%-qualified parameter is deprecated" + msgstr "" + +-#: cp/decl.c:13992 ++#: cp/decl.c:14001 + #, fuzzy, gcc-internal-format + msgid "parameter %qD invalidly declared method type" + msgstr "тып параметра \"%s\" не аб'яўлены" + +-#: cp/decl.c:14019 ++#: cp/decl.c:14028 + #, gcc-internal-format + msgid "parameter %qD includes pointer to array of unknown bound %qT" + msgstr "" + +-#: cp/decl.c:14021 ++#: cp/decl.c:14030 + #, gcc-internal-format + msgid "parameter %qD includes reference to array of unknown bound %qT" + msgstr "" + +-#: cp/decl.c:14268 ++#: cp/decl.c:14277 + #, gcc-internal-format + msgid "invalid constructor; you probably meant %<%T (const %T&)%>" + msgstr "" + +-#: cp/decl.c:14347 ++#: cp/decl.c:14356 + #, fuzzy, gcc-internal-format + msgid "%qD may not be declared within a namespace" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/decl.c:14354 ++#: cp/decl.c:14363 + #, fuzzy, gcc-internal-format + msgid "%qD may not be declared as static" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/decl.c:14384 ++#: cp/decl.c:14393 + #, gcc-internal-format + msgid "%qD must be a nonstatic member function" + msgstr "" + +-#: cp/decl.c:14390 ++#: cp/decl.c:14399 + #, gcc-internal-format + msgid "%qD must be either a non-static member function or a non-member function" + msgstr "" + +-#: cp/decl.c:14400 ++#: cp/decl.c:14409 + #, gcc-internal-format + msgid "%qD must have an argument of class or enumerated type" + msgstr "" + + #. 13.4.0.3 +-#: cp/decl.c:14426 ++#: cp/decl.c:14435 + #, gcc-internal-format + msgid "ISO C++ prohibits overloading %" + msgstr "" + + #. Variadic. +-#: cp/decl.c:14437 ++#: cp/decl.c:14446 + #, gcc-internal-format + msgid "%qD must not have variable number of arguments" + msgstr "" + +-#: cp/decl.c:14463 ++#: cp/decl.c:14472 + #, gcc-internal-format + msgid "%qD must have either zero or one argument" + msgstr "" + +-#: cp/decl.c:14464 ++#: cp/decl.c:14473 + #, gcc-internal-format + msgid "%qD must have either one or two arguments" + msgstr "" + +-#: cp/decl.c:14476 ++#: cp/decl.c:14485 + #, gcc-internal-format + msgid "postfix %qD must have % as its argument" + msgstr "" + +-#: cp/decl.c:14477 ++#: cp/decl.c:14486 + #, gcc-internal-format + msgid "postfix %qD must have % as its second argument" + msgstr "" + +-#: cp/decl.c:14488 ++#: cp/decl.c:14497 + #, fuzzy, gcc-internal-format + #| msgid "no arguments" + msgid "%qD must have no arguments" + msgstr "няма аргументаў" + +-#: cp/decl.c:14489 cp/decl.c:14499 ++#: cp/decl.c:14498 cp/decl.c:14508 + #, gcc-internal-format + msgid "%qD must have exactly one argument" + msgstr "" + +-#: cp/decl.c:14500 ++#: cp/decl.c:14509 + #, gcc-internal-format + msgid "%qD must have exactly two arguments" + msgstr "" + +-#: cp/decl.c:14514 ++#: cp/decl.c:14523 + #, fuzzy, gcc-internal-format + msgid "%qD cannot have default arguments" + msgstr "нехапае аргументаў у функцыі \"%s\"" + +-#: cp/decl.c:14538 ++#: cp/decl.c:14547 + #, gcc-internal-format + msgid "converting %qT to % will never use a type conversion operator" + msgstr "" + +-#: cp/decl.c:14545 ++#: cp/decl.c:14554 + #, gcc-internal-format + msgid "converting %qT to a reference to the same type will never use a type conversion operator" + msgstr "" + +-#: cp/decl.c:14547 ++#: cp/decl.c:14556 + #, gcc-internal-format + msgid "converting %qT to the same type will never use a type conversion operator" + msgstr "" + +-#: cp/decl.c:14556 ++#: cp/decl.c:14565 + #, gcc-internal-format + msgid "converting %qT to a reference to a base class %qT will never use a type conversion operator" + msgstr "" + +-#: cp/decl.c:14558 ++#: cp/decl.c:14567 + #, gcc-internal-format + msgid "converting %qT to a base class %qT will never use a type conversion operator" + msgstr "" + +-#: cp/decl.c:14574 ++#: cp/decl.c:14583 + #, gcc-internal-format + msgid "user-defined %qD always evaluates both arguments" + msgstr "" + +-#: cp/decl.c:14593 ++#: cp/decl.c:14602 + #, gcc-internal-format + msgid "prefix %qD should return %qT" + msgstr "" + +-#: cp/decl.c:14600 ++#: cp/decl.c:14609 + #, gcc-internal-format + msgid "postfix %qD should return %qT" + msgstr "" + +-#: cp/decl.c:14612 ++#: cp/decl.c:14621 + #, gcc-internal-format + msgid "%qD should return by value" + msgstr "" + +-#: cp/decl.c:14667 ++#: cp/decl.c:14676 + #, fuzzy, gcc-internal-format + msgid "using template type parameter %qT after %qs" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/decl.c:14690 ++#: cp/decl.c:14699 + #, gcc-internal-format + msgid "using alias template specialization %qT after %qs" + msgstr "" + +-#: cp/decl.c:14693 ++#: cp/decl.c:14702 + #, gcc-internal-format + msgid "using typedef-name %qD after %qs" + msgstr "" + +-#: cp/decl.c:14695 ++#: cp/decl.c:14704 + #, fuzzy, gcc-internal-format + #| msgid "this is a previous declaration" + msgid "%qD has a previous declaration here" + msgstr "гэта папярэдняе абвяшчэньне" + +-#: cp/decl.c:14703 ++#: cp/decl.c:14712 + #, gcc-internal-format + msgid "%qT referred to as %qs" + msgstr "" + +-#: cp/decl.c:14704 cp/decl.c:14711 ++#: cp/decl.c:14713 cp/decl.c:14720 + #, fuzzy, gcc-internal-format + #| msgid "this is a previous declaration" + msgid "%qT has a previous declaration here" + msgstr "гэта папярэдняе абвяшчэньне" + +-#: cp/decl.c:14710 ++#: cp/decl.c:14719 + #, gcc-internal-format + msgid "%qT referred to as enum" + msgstr "" +@@ -49518,96 +49569,96 @@ msgstr "" + #. void f(class C); // No template header here + #. + #. then the required template argument is missing. +-#: cp/decl.c:14725 ++#: cp/decl.c:14734 + #, fuzzy, gcc-internal-format + msgid "template argument required for %<%s %T%>" + msgstr "параметр \"%s\" ініцыялізаваны" + +-#: cp/decl.c:14779 cp/name-lookup.c:4480 ++#: cp/decl.c:14788 cp/name-lookup.c:4482 + #, gcc-internal-format + msgid "%qD has the same name as the class in which it is declared" + msgstr "" + +-#: cp/decl.c:14809 cp/friend.c:302 cp/parser.c:3153 cp/parser.c:6302 +-#: cp/pt.c:9647 ++#: cp/decl.c:14818 cp/friend.c:302 cp/parser.c:3153 cp/parser.c:6302 ++#: cp/pt.c:9656 + #, fuzzy, gcc-internal-format + msgid "%qT is not a template" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/decl.c:14814 ++#: cp/decl.c:14823 + #, gcc-internal-format + msgid "perhaps you want to explicitly add %<%T::%>" + msgstr "" + +-#: cp/decl.c:14823 cp/name-lookup.c:4719 cp/name-lookup.c:4830 +-#: cp/parser.c:6591 cp/parser.c:28376 ++#: cp/decl.c:14832 cp/name-lookup.c:4721 cp/name-lookup.c:4832 ++#: cp/parser.c:6591 cp/parser.c:28401 + #, fuzzy, gcc-internal-format + msgid "reference to %qD is ambiguous" + msgstr "памер \"%s\" - %d байт" + +-#: cp/decl.c:14926 ++#: cp/decl.c:14935 + #, fuzzy, gcc-internal-format + msgid "use of enum %q#D without previous declaration" + msgstr "секцыя \"%s\" канфліктуе з папярэдняй дэкларацыяй" + +-#: cp/decl.c:14962 ++#: cp/decl.c:14971 + #, fuzzy, gcc-internal-format + #| msgid "declaration of template `%#D'" + msgid "redeclaration of %qT as a non-template" + msgstr "абвяшчэньне шаблёну `%#D'" + +-#: cp/decl.c:15102 ++#: cp/decl.c:15111 + #, gcc-internal-format + msgid "derived union %qT invalid" + msgstr "" + +-#: cp/decl.c:15109 ++#: cp/decl.c:15118 + #, gcc-internal-format + msgid "%qT defined with multiple direct bases" + msgstr "" + +-#: cp/decl.c:15120 ++#: cp/decl.c:15129 + #, gcc-internal-format + msgid "%qT defined with direct virtual base" + msgstr "" + +-#: cp/decl.c:15145 ++#: cp/decl.c:15154 + #, gcc-internal-format + msgid "base type %qT fails to be a struct or class type" + msgstr "" + +-#: cp/decl.c:15175 ++#: cp/decl.c:15184 + #, gcc-internal-format + msgid "recursive type %qT undefined" + msgstr "" + +-#: cp/decl.c:15177 ++#: cp/decl.c:15186 + #, fuzzy, gcc-internal-format + msgid "duplicate base type %qT invalid" + msgstr "паўтарэнне \"restrict\"" + +-#: cp/decl.c:15322 ++#: cp/decl.c:15331 + #, gcc-internal-format + msgid "scoped/unscoped mismatch in enum %q#T" + msgstr "" + +-#: cp/decl.c:15325 cp/decl.c:15333 cp/decl.c:15343 cp/decl.c:15926 +-#: cp/parser.c:19339 ++#: cp/decl.c:15334 cp/decl.c:15342 cp/decl.c:15352 cp/decl.c:15935 ++#: cp/parser.c:19344 + #, gcc-internal-format + msgid "previous definition here" + msgstr "папярэдняе вызначэньне" + +-#: cp/decl.c:15330 ++#: cp/decl.c:15339 + #, gcc-internal-format + msgid "underlying type mismatch in enum %q#T" + msgstr "" + +-#: cp/decl.c:15340 ++#: cp/decl.c:15349 + #, gcc-internal-format + msgid "different underlying type in enum %q#T" + msgstr "" + +-#: cp/decl.c:15413 ++#: cp/decl.c:15422 + #, gcc-internal-format + msgid "underlying type %qT of %qT must be an integral type" + msgstr "" +@@ -49616,73 +49667,73 @@ msgstr "" + #. + #. IF no integral type can represent all the enumerator values, the + #. enumeration is ill-formed. +-#: cp/decl.c:15560 ++#: cp/decl.c:15569 + #, gcc-internal-format + msgid "no integral type can represent all of the enumerator values for %qT" + msgstr "" + +-#: cp/decl.c:15728 ++#: cp/decl.c:15737 + #, gcc-internal-format + msgid "enumerator value for %qD must have integral or unscoped enumeration type" + msgstr "" + +-#: cp/decl.c:15738 ++#: cp/decl.c:15747 + #, fuzzy, gcc-internal-format + msgid "enumerator value for %qD is not an integer constant" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/decl.c:15787 ++#: cp/decl.c:15796 + #, gcc-internal-format + msgid "incremented enumerator value is too large for %" + msgstr "" + +-#: cp/decl.c:15788 ++#: cp/decl.c:15797 + #, gcc-internal-format + msgid "incremented enumerator value is too large for %" + msgstr "" + +-#: cp/decl.c:15799 ++#: cp/decl.c:15808 + #, gcc-internal-format + msgid "overflow in enumeration values at %qD" + msgstr "" + +-#: cp/decl.c:15819 ++#: cp/decl.c:15828 + #, gcc-internal-format + msgid "enumerator value %qE is outside the range of underlying type %qT" + msgstr "" + +-#: cp/decl.c:15924 cp/parser.c:19337 ++#: cp/decl.c:15933 cp/parser.c:19342 + #, fuzzy, gcc-internal-format + #| msgid "previous definition of `%#T'" + msgid "multiple definition of %q#T" + msgstr "папярэдняе вызначэньне `%#T'" + +-#: cp/decl.c:15964 ++#: cp/decl.c:15973 + #, fuzzy, gcc-internal-format + msgid "return type %q#T is incomplete" + msgstr "вяртаемы тып \"%s\" не \"int\"" + +-#: cp/decl.c:16139 cp/typeck.c:9971 ++#: cp/decl.c:16148 cp/typeck.c:10031 + #, gcc-internal-format + msgid "% should return a reference to %<*this%>" + msgstr "" + +-#: cp/decl.c:17003 ++#: cp/decl.c:17011 + #, gcc-internal-format + msgid "no return statements in function returning %qT" + msgstr "" + +-#: cp/decl.c:17005 cp/typeck.c:9851 ++#: cp/decl.c:17013 cp/typeck.c:9911 + #, gcc-internal-format + msgid "only plain % return type can be deduced to %" + msgstr "" + +-#: cp/decl.c:17241 ++#: cp/decl.c:17250 + #, fuzzy, gcc-internal-format + msgid "%qD is already defined in class %qT" + msgstr "не знойдзен клас \"%s\"" + +-#: cp/decl.c:17619 ++#: cp/decl.c:17628 + #, gcc-internal-format + msgid "use of %qD before deduction of %" + msgstr "" +@@ -49722,7 +49773,7 @@ msgstr "" + msgid "deleting %qT is undefined" + msgstr "метка \"%s\" ужываецца, але не вызначана" + +-#: cp/decl2.c:582 cp/pt.c:5767 ++#: cp/decl2.c:582 cp/pt.c:5776 + #, fuzzy, gcc-internal-format + msgid "template declaration of %q#D" + msgstr "пустое абвяшчэнне" +@@ -49732,7 +49783,7 @@ msgstr "пустое абвяшчэнне" + msgid "template parameter lists provided don%'t match the template parameters of %qD" + msgstr "" + +-#: cp/decl2.c:637 cp/pt.c:5724 ++#: cp/decl2.c:637 cp/pt.c:5733 + #, gcc-internal-format + msgid "destructor %qD declared as member template" + msgstr "" +@@ -50061,148 +50112,148 @@ msgstr "" + + #. We mark a lambda conversion op as deleted if we can't + #. generate it properly; see maybe_add_lambda_conv_op. +-#: cp/decl2.c:5538 ++#: cp/decl2.c:5527 + #, gcc-internal-format + msgid "converting lambda that uses %<...%> to function pointer" + msgstr "" + +-#: cp/decl2.c:5541 ++#: cp/decl2.c:5530 + #, gcc-internal-format + msgid "use of deleted function %qD" + msgstr "" + +-#: cp/decl2.c:5585 ++#: cp/decl2.c:5574 + #, gcc-internal-format + msgid "use of function %qD with unsatisfied constraints" + msgstr "" + +-#: cp/decl2.c:5607 ++#: cp/decl2.c:5596 + #, gcc-internal-format + msgid "use of built-in parameter pack %qD outside of a template" + msgstr "" + +-#: cp/error.c:3876 ++#: cp/error.c:3868 + #, fuzzy, gcc-internal-format + #| msgid "no arguments" + msgid "(no argument)" + msgstr "няма аргументаў" + +-#: cp/error.c:3968 ++#: cp/error.c:3960 + #, gcc-internal-format + msgid "[...]" + msgstr "" + +-#: cp/error.c:4319 ++#: cp/error.c:4311 + #, gcc-internal-format + msgid "extended initializer lists only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4324 ++#: cp/error.c:4316 + #, gcc-internal-format + msgid "explicit conversion operators only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4329 ++#: cp/error.c:4321 + #, gcc-internal-format + msgid "variadic templates only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4334 ++#: cp/error.c:4326 + #, gcc-internal-format + msgid "lambda expressions only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4339 ++#: cp/error.c:4331 + #, gcc-internal-format + msgid "C++11 auto only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4344 ++#: cp/error.c:4336 + #, gcc-internal-format + msgid "scoped enums only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4349 ++#: cp/error.c:4341 + #, gcc-internal-format + msgid "defaulted and deleted functions only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4354 ++#: cp/error.c:4346 + #, gcc-internal-format + msgid "inline namespaces only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4359 ++#: cp/error.c:4351 + #, gcc-internal-format + msgid "override controls (override/final) only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4364 ++#: cp/error.c:4356 + #, gcc-internal-format + msgid "non-static data member initializers only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4369 ++#: cp/error.c:4361 + #, gcc-internal-format + msgid "user-defined literals only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4374 ++#: cp/error.c:4366 + #, gcc-internal-format + msgid "delegating constructors only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4379 ++#: cp/error.c:4371 + #, gcc-internal-format + msgid "inheriting constructors only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4384 ++#: cp/error.c:4376 + #, gcc-internal-format + msgid "c++11 attributes only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4389 ++#: cp/error.c:4381 + #, gcc-internal-format + msgid "ref-qualifiers only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/error.c:4439 ++#: cp/error.c:4431 + #, gcc-internal-format + msgid "incomplete type %qT used in nested name specifier" + msgstr "" + +-#: cp/error.c:4443 ++#: cp/error.c:4435 + #, fuzzy, gcc-internal-format + msgid "reference to %<%T::%D%> is ambiguous" + msgstr "памер \"%s\" - %d байт" + +-#: cp/error.c:4457 ++#: cp/error.c:4449 + #, gcc-internal-format + msgid "%qD is not a member of %qT; did you mean %qs?" + msgstr "" + +-#: cp/error.c:4461 cp/typeck.c:2517 ++#: cp/error.c:4453 cp/typeck.c:2559 + #, gcc-internal-format + msgid "%qD is not a member of %qT" + msgstr "" + +-#: cp/error.c:4483 ++#: cp/error.c:4475 + #, gcc-internal-format + msgid "%qD is not a member of %qD; did you mean %qs?" + msgstr "" + +-#: cp/error.c:4487 cp/typeck.c:3111 ++#: cp/error.c:4479 cp/typeck.c:3153 + #, gcc-internal-format + msgid "%qD is not a member of %qD" + msgstr "" + +-#: cp/error.c:4498 ++#: cp/error.c:4490 + #, gcc-internal-format + msgid "%<::%D%> has not been declared; did you mean %qs?" + msgstr "" + +-#: cp/error.c:4502 ++#: cp/error.c:4494 + #, gcc-internal-format + msgid "%<::%D%> has not been declared" + msgstr "" +@@ -50383,340 +50434,340 @@ msgstr "" + msgid "recursive instantiation of default member initializer for %qD" + msgstr "" + +-#: cp/init.c:631 ++#: cp/init.c:633 + #, gcc-internal-format + msgid "default member initializer for %qD required before the end of its enclosing class" + msgstr "" + +-#: cp/init.c:695 ++#: cp/init.c:697 + #, fuzzy, gcc-internal-format + msgid "initializer for flexible array member %q#D" + msgstr "прапушчан ініцыялізатар" + +-#: cp/init.c:753 ++#: cp/init.c:755 + #, gcc-internal-format + msgid "initializing %qD from %qE does not extend the lifetime of the underlying array" + msgstr "" + +-#: cp/init.c:779 ++#: cp/init.c:781 + #, fuzzy, gcc-internal-format + msgid "%qD should be initialized in the member initialization list" + msgstr "нерэчаісны ініцыялізатар" + +-#: cp/init.c:800 ++#: cp/init.c:802 + #, fuzzy, gcc-internal-format + msgid "%qD is initialized with itself" + msgstr "параметр \"%s\" ініцыялізаваны" + +-#: cp/init.c:904 ++#: cp/init.c:906 + #, fuzzy, gcc-internal-format + msgid "invalid initializer for array member %q#D" + msgstr "нерэчаісны ініцыялізатар" + +-#: cp/init.c:919 cp/init.c:945 cp/init.c:2483 cp/method.c:2051 ++#: cp/init.c:921 cp/init.c:947 cp/init.c:2485 cp/method.c:2076 + #, fuzzy, gcc-internal-format + msgid "uninitialized const member in %q#T" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/init.c:921 cp/init.c:939 cp/init.c:947 cp/init.c:2468 cp/init.c:2496 +-#: cp/method.c:2054 cp/method.c:2065 ++#: cp/init.c:923 cp/init.c:941 cp/init.c:949 cp/init.c:2470 cp/init.c:2498 ++#: cp/method.c:2079 cp/method.c:2090 + #, fuzzy, gcc-internal-format + msgid "%q#D should be initialized" + msgstr "параметр \"%s\" ініцыялізаваны" + +-#: cp/init.c:937 cp/init.c:2455 cp/method.c:2062 ++#: cp/init.c:939 cp/init.c:2457 cp/method.c:2087 + #, fuzzy, gcc-internal-format + msgid "uninitialized reference member in %q#T" + msgstr "прапушчан ініцыялізатар" + +-#: cp/init.c:1114 ++#: cp/init.c:1116 + #, gcc-internal-format + msgid "%qD will be initialized after" + msgstr "" + +-#: cp/init.c:1117 ++#: cp/init.c:1119 + #, fuzzy, gcc-internal-format + msgid "base %qT will be initialized after" + msgstr "Клас \"%s\" ужо існуе" + +-#: cp/init.c:1121 ++#: cp/init.c:1123 + #, gcc-internal-format + msgid " %q#D" + msgstr "" + +-#: cp/init.c:1123 ++#: cp/init.c:1125 + #, gcc-internal-format + msgid " base %qT" + msgstr "" + +-#: cp/init.c:1125 ++#: cp/init.c:1127 + #, fuzzy, gcc-internal-format + #| msgid "invalid initializer" + msgid " when initialized here" + msgstr "нерэчаісны ініцыялізатар" + +-#: cp/init.c:1142 ++#: cp/init.c:1144 + #, fuzzy, gcc-internal-format + msgid "multiple initializations given for %qD" + msgstr "ініцыялізацыя" + +-#: cp/init.c:1146 ++#: cp/init.c:1148 + #, gcc-internal-format + msgid "multiple initializations given for base %qT" + msgstr "" + +-#: cp/init.c:1231 ++#: cp/init.c:1233 + #, gcc-internal-format + msgid "initializations for multiple members of %qT" + msgstr "" + +-#: cp/init.c:1328 ++#: cp/init.c:1330 + #, gcc-internal-format + msgid "base class %q#T should be explicitly initialized in the copy constructor" + msgstr "" + +-#: cp/init.c:1555 cp/init.c:1574 ++#: cp/init.c:1557 cp/init.c:1576 + #, gcc-internal-format + msgid "class %qT does not have any field named %qD" + msgstr "" + +-#: cp/init.c:1561 ++#: cp/init.c:1563 + #, gcc-internal-format + msgid "%q#D is a static data member; it can only be initialized at its definition" + msgstr "" + +-#: cp/init.c:1568 ++#: cp/init.c:1570 + #, gcc-internal-format + msgid "%q#D is not a non-static data member of %qT" + msgstr "" + +-#: cp/init.c:1607 ++#: cp/init.c:1609 + #, gcc-internal-format + msgid "unnamed initializer for %qT, which has no base classes" + msgstr "" + +-#: cp/init.c:1615 ++#: cp/init.c:1617 + #, gcc-internal-format + msgid "unnamed initializer for %qT, which uses multiple inheritance" + msgstr "" + +-#: cp/init.c:1662 ++#: cp/init.c:1664 + #, gcc-internal-format + msgid "%qD is both a direct base and an indirect virtual base" + msgstr "" + +-#: cp/init.c:1670 ++#: cp/init.c:1672 + #, gcc-internal-format + msgid "type %qT is not a direct or virtual base of %qT" + msgstr "" + +-#: cp/init.c:1673 ++#: cp/init.c:1675 + #, gcc-internal-format + msgid "type %qT is not a direct base of %qT" + msgstr "" + +-#: cp/init.c:1785 cp/init.c:4614 cp/typeck2.c:1333 ++#: cp/init.c:1787 cp/init.c:4616 cp/typeck2.c:1333 + #, gcc-internal-format + msgid "array must be initialized with a brace-enclosed initializer" + msgstr "" + +-#: cp/init.c:2094 cp/semantics.c:3449 ++#: cp/init.c:2096 cp/semantics.c:3449 + #, fuzzy, gcc-internal-format + msgid "%qT is not a class type" + msgstr "\"%s\" мае незавершаны тып" + +-#: cp/init.c:2150 ++#: cp/init.c:2152 + #, gcc-internal-format + msgid "incomplete type %qT does not have member %qD" + msgstr "" + +-#: cp/init.c:2164 ++#: cp/init.c:2166 + #, fuzzy, gcc-internal-format + msgid "invalid pointer to bit-field %qD" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/init.c:2250 cp/typeck.c:1985 ++#: cp/init.c:2252 cp/typeck.c:2027 + #, fuzzy, gcc-internal-format + msgid "invalid use of non-static member function %qD" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/init.c:2257 cp/semantics.c:1927 ++#: cp/init.c:2259 cp/semantics.c:1927 + #, fuzzy, gcc-internal-format + msgid "invalid use of non-static data member %qD" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/init.c:2452 ++#: cp/init.c:2454 + #, gcc-internal-format + msgid "uninitialized reference member in %q#T using % without new-initializer" + msgstr "" + +-#: cp/init.c:2460 ++#: cp/init.c:2462 + #, gcc-internal-format + msgid "uninitialized reference member in base %q#T of %q#T using % without new-initializer" + msgstr "" + +-#: cp/init.c:2464 ++#: cp/init.c:2466 + #, gcc-internal-format + msgid "uninitialized reference member in base %q#T of %q#T" + msgstr "" + +-#: cp/init.c:2480 ++#: cp/init.c:2482 + #, gcc-internal-format + msgid "uninitialized const member in %q#T using % without new-initializer" + msgstr "" + +-#: cp/init.c:2488 ++#: cp/init.c:2490 + #, gcc-internal-format + msgid "uninitialized const member in base %q#T of %q#T using % without new-initializer" + msgstr "" + +-#: cp/init.c:2492 ++#: cp/init.c:2494 + #, gcc-internal-format + msgid "uninitialized const member in base %q#T of %q#T" + msgstr "" + +-#: cp/init.c:2789 ++#: cp/init.c:2791 + #, gcc-internal-format + msgid "placement new constructing an object of type %<%T [%wu]%> and size %qwu in a region of type %qT and size %qwi" + msgstr "" + +-#: cp/init.c:2800 ++#: cp/init.c:2802 + #, gcc-internal-format + msgid "placement new constructing an array of objects of type %qT and size %qwu in a region of type %qT and size %qwi" + msgstr "" + +-#: cp/init.c:2811 ++#: cp/init.c:2813 + #, gcc-internal-format + msgid "placement new constructing an object of type %qT and size %qwu in a region of type %qT and size %qwi" + msgstr "" + +-#: cp/init.c:3033 ++#: cp/init.c:3035 + #, gcc-internal-format + msgid "integer overflow in array size" + msgstr "" + +-#: cp/init.c:3043 ++#: cp/init.c:3045 + #, gcc-internal-format + msgid "array size in new-expression must be constant" + msgstr "" + +-#: cp/init.c:3061 ++#: cp/init.c:3063 + #, gcc-internal-format + msgid "variably modified type not allowed in new-expression" + msgstr "" + +-#: cp/init.c:3077 ++#: cp/init.c:3079 + #, gcc-internal-format + msgid "non-constant array new length must be specified directly, not by %" + msgstr "" + +-#: cp/init.c:3079 ++#: cp/init.c:3081 + #, gcc-internal-format + msgid "non-constant array new length must be specified without parentheses around the type-id" + msgstr "" + +-#: cp/init.c:3089 ++#: cp/init.c:3091 + #, gcc-internal-format + msgid "invalid type % for %" + msgstr "" + +-#: cp/init.c:3095 ++#: cp/init.c:3097 + #, gcc-internal-format + msgid "% of % does not extend the lifetime of the underlying array" + msgstr "" + +-#: cp/init.c:3137 ++#: cp/init.c:3139 + #, fuzzy, gcc-internal-format + msgid "uninitialized const in % of %q#T" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/init.c:3281 ++#: cp/init.c:3283 + #, fuzzy, gcc-internal-format + #| msgid "field '%s' not found in class" + msgid "no suitable %qD found in class %qT" + msgstr "поле \"%s\" не знойдзена ў класе" + +-#: cp/init.c:3288 cp/search.c:1039 ++#: cp/init.c:3290 cp/search.c:1039 + #, fuzzy, gcc-internal-format + msgid "request for member %qD is ambiguous" + msgstr "памер \"%s\" - %d байт" + +-#: cp/init.c:3362 ++#: cp/init.c:3364 + #, gcc-internal-format + msgid "% of type %qT with extended alignment %d" + msgstr "" + +-#: cp/init.c:3365 ++#: cp/init.c:3367 + #, gcc-internal-format + msgid "uses %qD, which does not have an alignment parameter" + msgstr "" + +-#: cp/init.c:3368 ++#: cp/init.c:3370 + #, gcc-internal-format + msgid "use %<-faligned-new%> to enable C++17 over-aligned new support" + msgstr "" + +-#: cp/init.c:3563 ++#: cp/init.c:3565 + #, gcc-internal-format + msgid "parenthesized initializer in array new" + msgstr "" + +-#: cp/init.c:3857 ++#: cp/init.c:3859 + #, gcc-internal-format + msgid "size in array new must have integral type" + msgstr "" + +-#: cp/init.c:3886 ++#: cp/init.c:3888 + #, gcc-internal-format + msgid "new cannot be applied to a reference type" + msgstr "" + +-#: cp/init.c:3895 ++#: cp/init.c:3897 + #, gcc-internal-format + msgid "new cannot be applied to a function type" + msgstr "" + +-#: cp/init.c:3970 ++#: cp/init.c:3972 + #, gcc-internal-format + msgid "possible problem detected in invocation of operator %" + msgstr "" + +-#: cp/init.c:3974 ++#: cp/init.c:3976 + #, gcc-internal-format + msgid "neither the destructor nor the class-specific operator % will be called, even if they are declared when the class is defined" + msgstr "" + +-#: cp/init.c:4523 ++#: cp/init.c:4525 + #, gcc-internal-format + msgid "initializer ends prematurely" + msgstr "" + +-#: cp/init.c:4829 ++#: cp/init.c:4831 + #, gcc-internal-format + msgid "unknown array size in delete" + msgstr "" + +-#: cp/init.c:4863 ++#: cp/init.c:4865 + #, gcc-internal-format + msgid "possible problem detected in invocation of %" + msgstr "" + +-#: cp/init.c:4868 ++#: cp/init.c:4870 + #, gcc-internal-format + msgid "neither the destructor nor the class-specific % will be called, even if they are declared when the class is defined" + msgstr "" + +-#: cp/init.c:4883 ++#: cp/init.c:4885 + #, gcc-internal-format + msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior" + msgstr "" + +-#: cp/init.c:4888 ++#: cp/init.c:4890 + #, gcc-internal-format + msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior" + msgstr "" + +-#: cp/init.c:5196 ++#: cp/init.c:5198 + #, gcc-internal-format + msgid "type to vector delete is neither pointer or array type" + msgstr "" +@@ -50877,12 +50928,12 @@ msgstr "" + msgid "the mangled name of the initialization guard variable for %qD changes between %<-fabi-version=%d%> and %<-fabi-version=%d%>" + msgstr "" + +-#: cp/method.c:832 cp/method.c:2004 ++#: cp/method.c:832 cp/method.c:2029 + #, gcc-internal-format + msgid "non-static const member %q#D, cannot use default assignment operator" + msgstr "" + +-#: cp/method.c:838 cp/method.c:2010 ++#: cp/method.c:838 cp/method.c:2035 + #, gcc-internal-format + msgid "non-static reference member %q#D, cannot use default assignment operator" + msgstr "" +@@ -50907,157 +50958,162 @@ msgstr "" + msgid "defaulted %qD only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/method.c:1108 ++#: cp/method.c:1115 + #, gcc-internal-format +-msgid "three-way comparison operator can only be defaulted in a class definition" ++msgid "defaulted %qD must return %" + msgstr "" + +-#: cp/method.c:1111 ++#: cp/method.c:1123 + #, gcc-internal-format +-msgid "equality comparison operator can only be defaulted in a class definition" ++msgid "defaulted %qD must be %" + msgstr "" + +-#: cp/method.c:1126 ++#: cp/method.c:1128 + #, gcc-internal-format +-msgid "defaulted %qD must return %" ++msgid "defaulted %qD must not have %<&&%> ref-qualifier" + msgstr "" + +-#: cp/method.c:1134 ++#: cp/method.c:1155 + #, gcc-internal-format +-msgid "defaulted %qD must be %" ++msgid "defaulted %qD is not a friend of %qT" + msgstr "" + +-#: cp/method.c:1158 ++#: cp/method.c:1164 + #, gcc-internal-format + msgid "defaulted member %qD must have parameter type %" + msgstr "" + +-#: cp/method.c:1161 ++#: cp/method.c:1167 + #, gcc-internal-format + msgid "defaulted %qD must have parameters of either type % or %qT" + msgstr "" + +-#: cp/method.c:1164 ++#: cp/method.c:1170 + #, gcc-internal-format + msgid "defaulted %qD must have parameters of either type % or %qT, not both" + msgstr "" + +-#: cp/method.c:1319 ++#: cp/method.c:1324 + #, fuzzy, gcc-internal-format + msgid "cannot default compare union %qT" + msgstr "нехапае аргументаў у функцыі \"%s\"" + +-#: cp/method.c:1355 ++#: cp/method.c:1361 + #, gcc-internal-format + msgid "cannot default compare reference member %qD" + msgstr "" + +-#: cp/method.c:1363 ++#: cp/method.c:1370 + #, gcc-internal-format + msgid "cannot default compare anonymous union member" + msgstr "" + +-#: cp/method.c:1580 ++#: cp/method.c:1394 ++#, gcc-internal-format ++msgid "three-way comparison of %qD has type %qT, not a comparison category type" ++msgstr "" ++ ++#: cp/method.c:1605 + #, gcc-internal-format + msgid "synthesized method %qD first required here" + msgstr "" + +-#: cp/method.c:1949 ++#: cp/method.c:1974 + #, gcc-internal-format + msgid "union member %q+D with non-trivial %qD" + msgstr "" + +-#: cp/method.c:1960 ++#: cp/method.c:1985 + #, gcc-internal-format + msgid "defaulted destructor calls non-% %qD" + msgstr "" + +-#: cp/method.c:1961 ++#: cp/method.c:1986 + #, gcc-internal-format + msgid "defaulted constructor calls non-% %qD" + msgstr "" + +-#: cp/method.c:2027 ++#: cp/method.c:2052 + #, fuzzy, gcc-internal-format + msgid "initializer for %q#D is invalid" + msgstr "complex нерэчаісны для \"%s\"" + +-#: cp/method.c:2084 ++#: cp/method.c:2109 + #, gcc-internal-format + msgid "defaulted default constructor does not initialize %q#D" + msgstr "" + +-#: cp/method.c:2095 ++#: cp/method.c:2120 + #, gcc-internal-format + msgid "copying non-static data member %q#D of rvalue reference type" + msgstr "" + + #. A trivial constructor doesn't have any NSDMI. +-#: cp/method.c:2302 ++#: cp/method.c:2327 + #, gcc-internal-format + msgid "defaulted default constructor does not initialize any non-static data member" + msgstr "" + +-#: cp/method.c:2345 ++#: cp/method.c:2370 + #, gcc-internal-format + msgid "defaulted move assignment for %qT calls a non-trivial move assignment operator for virtual base %qT" + msgstr "" + +-#: cp/method.c:2479 ++#: cp/method.c:2501 + #, gcc-internal-format + msgid "a lambda closure type has a deleted default constructor" + msgstr "" + +-#: cp/method.c:2482 ++#: cp/method.c:2504 + #, gcc-internal-format + msgid "a lambda closure type has a deleted copy assignment operator" + msgstr "" + +-#: cp/method.c:2491 ++#: cp/method.c:2513 + #, gcc-internal-format + msgid "%q#D is implicitly declared as deleted because %qT declares a move constructor or move assignment operator" + msgstr "" + +-#: cp/method.c:2502 ++#: cp/method.c:2524 + #, gcc-internal-format + msgid "%q#D inherits from multiple base subobjects" + msgstr "" + +-#: cp/method.c:2510 cp/method.c:2534 ++#: cp/method.c:2532 cp/method.c:2556 + #, gcc-internal-format + msgid "%q#D is implicitly deleted because the default definition would be ill-formed:" + msgstr "" + +-#: cp/method.c:2543 ++#: cp/method.c:2565 + msgid "%q#F is implicitly deleted because its exception-specification does not match the implicit exception-specification %qX" + msgstr "" + +-#: cp/method.c:2960 ++#: cp/method.c:2951 + #, gcc-internal-format + msgid "defaulted declaration %q+D does not match the expected signature" + msgstr "" + +-#: cp/method.c:2963 ++#: cp/method.c:2954 + #, gcc-internal-format + msgid "expected signature: %qD" + msgstr "" + +-#: cp/method.c:2995 ++#: cp/method.c:2986 + #, gcc-internal-format + msgid "explicitly defaulted function %q+D cannot be declared %qs because the implicit declaration is not %qs:" + msgstr "" + +-#: cp/method.c:3015 ++#: cp/method.c:3006 + #, fuzzy, gcc-internal-format + msgid "a template cannot be defaulted" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/method.c:3050 ++#: cp/method.c:3041 + #, fuzzy, gcc-internal-format + msgid "%qD cannot be defaulted" + msgstr "YYDEBUG не вызначан." + +-#: cp/method.c:3059 ++#: cp/method.c:3050 + #, gcc-internal-format + msgid "defaulted function %q+D with default argument" + msgstr "" +@@ -51099,213 +51155,213 @@ msgstr "тып параметра \"%s\" не аб'яўлены" + msgid "declaration of %q#D shadows a parameter" + msgstr "абвяшчэньне `%#D'" + +-#: cp/name-lookup.c:2820 ++#: cp/name-lookup.c:2822 + #, gcc-internal-format + msgid "declaration of %qD shadows a member of %qT" + msgstr "" + +-#: cp/name-lookup.c:2974 ++#: cp/name-lookup.c:2976 + #, fuzzy, gcc-internal-format + msgid "local external declaration %q#D" + msgstr "паўторнае абвяшчэнне меткі \"%s\"" + +-#: cp/name-lookup.c:2976 ++#: cp/name-lookup.c:2978 + #, fuzzy, gcc-internal-format + #| msgid "conflicts with previous declaration `%#D'" + msgid "does not match previous declaration %q#D" + msgstr "канфлікт з папярэднім абвяшчэньнем `%#D'" + +-#: cp/name-lookup.c:3100 ++#: cp/name-lookup.c:3102 + #, gcc-internal-format + msgid "friend declaration %qD in local class without prior local declaration" + msgstr "" + +-#: cp/name-lookup.c:3293 ++#: cp/name-lookup.c:3295 + #, gcc-internal-format + msgid "%s %<%s(%E)%> %p %d" + msgstr "" + +-#: cp/name-lookup.c:3296 ++#: cp/name-lookup.c:3298 + #, gcc-internal-format + msgid "%s %s %p %d" + msgstr "" + +-#: cp/name-lookup.c:4615 ++#: cp/name-lookup.c:4617 + #, gcc-internal-format + msgid "using-declaration for non-member at class scope" + msgstr "" + +-#: cp/name-lookup.c:4623 ++#: cp/name-lookup.c:4625 + #, gcc-internal-format + msgid "using-declaration may not name enumerator %<%E::%D%>" + msgstr "" + +-#: cp/name-lookup.c:4632 ++#: cp/name-lookup.c:4634 + #, gcc-internal-format + msgid "using-declaration for member at non-class scope" + msgstr "" + +-#: cp/name-lookup.c:4639 ++#: cp/name-lookup.c:4641 + #, gcc-internal-format + msgid "%<%T::%D%> names destructor" + msgstr "" + +-#: cp/name-lookup.c:4656 ++#: cp/name-lookup.c:4658 + #, fuzzy, gcc-internal-format + msgid "%<%T::%D%> names constructor in %qT" + msgstr "дэструктару неабходны \"%#D\"" + +-#: cp/name-lookup.c:4694 ++#: cp/name-lookup.c:4696 + #, gcc-internal-format + msgid "cannot inherit constructors from indirect base %qT" + msgstr "" + +-#: cp/name-lookup.c:4711 ++#: cp/name-lookup.c:4713 + #, fuzzy, gcc-internal-format + msgid "%qD has not been declared in %qE" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/name-lookup.c:4727 ++#: cp/name-lookup.c:4729 + #, fuzzy, gcc-internal-format + #| msgid "declaration of template `%#D'" + msgid "using-declaration may not name namespace %qD" + msgstr "абвяшчэньне шаблёну `%#D'" + +-#: cp/name-lookup.c:4810 ++#: cp/name-lookup.c:4812 + #, gcc-internal-format + msgid "declaration of %qD not in a namespace surrounding %qD" + msgstr "" + +-#: cp/name-lookup.c:4850 ++#: cp/name-lookup.c:4852 + #, fuzzy, gcc-internal-format + msgid "explicit qualification in declaration of %qD" + msgstr "паўторнае абвяшчэнне меткі \"%s\"" + +-#: cp/name-lookup.c:4902 ++#: cp/name-lookup.c:4904 + #, fuzzy, gcc-internal-format + msgid "%qD has not been declared within %qD" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/name-lookup.c:4904 ++#: cp/name-lookup.c:4906 + #, gcc-internal-format + msgid "only here as a %" + msgstr "" + +-#: cp/name-lookup.c:4913 ++#: cp/name-lookup.c:4915 + #, gcc-internal-format + msgid "%qD should have been declared inside %qD" + msgstr "" + +-#: cp/name-lookup.c:4961 ++#: cp/name-lookup.c:4963 + #, gcc-internal-format + msgid "%qD attribute requires a single NTBS argument" + msgstr "" + +-#: cp/name-lookup.c:4968 ++#: cp/name-lookup.c:4970 + #, gcc-internal-format + msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols" + msgstr "" + +-#: cp/name-lookup.c:4978 cp/name-lookup.c:5005 ++#: cp/name-lookup.c:4980 cp/name-lookup.c:5007 + #, gcc-internal-format + msgid "ignoring %qD attribute on anonymous namespace" + msgstr "" + +-#: cp/name-lookup.c:4984 ++#: cp/name-lookup.c:4986 + #, gcc-internal-format + msgid "ignoring %qD attribute on non-inline namespace" + msgstr "" + +-#: cp/name-lookup.c:5021 cp/name-lookup.c:7309 ++#: cp/name-lookup.c:5023 cp/name-lookup.c:7311 + #, fuzzy, gcc-internal-format + #| msgid "`%s' attribute ignored" + msgid "%qD attribute directive ignored" + msgstr "\"%s\" атрыбут ігнарыруецца" + +-#: cp/name-lookup.c:5307 ++#: cp/name-lookup.c:5309 + #, gcc-internal-format + msgid "maximum limit of %d namespaces searched for %qE" + msgstr "" + +-#: cp/name-lookup.c:5359 ++#: cp/name-lookup.c:5361 + #, gcc-internal-format + msgid "suggested alternative:" + msgid_plural "suggested alternatives:" + msgstr[0] "" + msgstr[1] "" + +-#: cp/name-lookup.c:5365 ++#: cp/name-lookup.c:5367 + #, gcc-internal-format + msgid " %qE" + msgstr "" + +-#: cp/name-lookup.c:5892 ++#: cp/name-lookup.c:5894 + #, gcc-internal-format + msgid "% is defined in header %qs; did you forget to %<#include %s%>?" + msgstr "" + +-#: cp/name-lookup.c:5898 ++#: cp/name-lookup.c:5900 + #, gcc-internal-format + msgid "% is only available from %s onwards" + msgstr "" + +-#: cp/name-lookup.c:6167 ++#: cp/name-lookup.c:6169 + #, gcc-internal-format + msgid "the macro %qs had not yet been defined" + msgstr "" + +-#: cp/name-lookup.c:6170 ++#: cp/name-lookup.c:6172 + #, gcc-internal-format + msgid "it was later defined here" + msgstr "" + +-#: cp/name-lookup.c:6926 ++#: cp/name-lookup.c:6928 + #, gcc-internal-format + msgid "declaration of % does not match %<#include %>, isn%'t a template" + msgstr "" + +-#: cp/name-lookup.c:7303 ++#: cp/name-lookup.c:7305 + #, gcc-internal-format + msgid "% using directive no longer supported" + msgstr "" + +-#: cp/name-lookup.c:7306 ++#: cp/name-lookup.c:7308 + #, gcc-internal-format + msgid "you can use an inline namespace instead" + msgstr "" + +-#: cp/name-lookup.c:7409 ++#: cp/name-lookup.c:7411 + #, fuzzy, gcc-internal-format + msgid "% is ambiguous" + msgstr "памер \"%s\" - %d байт" + +-#: cp/name-lookup.c:7425 ++#: cp/name-lookup.c:7427 + #, fuzzy, gcc-internal-format + msgid "namespace alias %qD not allowed here, assuming %qD" + msgstr "\"%s\" - гэта не пачатак дэкларацыі" + + #. We only allow depth 255. +-#: cp/name-lookup.c:7445 ++#: cp/name-lookup.c:7447 + #, gcc-internal-format, gfc-internal-format + msgid "cannot nest more than %d namespaces" + msgstr "" + +-#: cp/name-lookup.c:7480 ++#: cp/name-lookup.c:7482 + #, gcc-internal-format + msgid "inline namespace must be specified at initial definition" + msgstr "" + +-#: cp/name-lookup.c:7481 ++#: cp/name-lookup.c:7483 + #, fuzzy, gcc-internal-format + msgid "%qD defined here" + msgstr "YYDEBUG не вызначан." + +-#: cp/name-lookup.c:7554 ++#: cp/name-lookup.c:7556 + #, gcc-internal-format + msgid "XXX entering %" + msgstr "" + +-#: cp/name-lookup.c:7563 ++#: cp/name-lookup.c:7565 + #, gcc-internal-format + msgid "XXX leaving %" + msgstr "" +@@ -51330,7 +51386,7 @@ msgstr "" + msgid "% is not set to true" + msgstr "" + +-#: cp/parser.c:1363 cp/parser.c:41427 ++#: cp/parser.c:1363 cp/parser.c:41453 + #, gcc-internal-format + msgid "%<#pragma omp declare %s%> not immediately followed by function declaration or definition" + msgstr "" +@@ -51355,7 +51411,7 @@ msgstr "" + msgid "request for member %qE in non-class type %qT" + msgstr "" + +-#: cp/parser.c:3005 cp/parser.c:19276 ++#: cp/parser.c:3005 cp/parser.c:19281 + #, gcc-internal-format + msgid "%<%T::%E%> has not been declared" + msgstr "" +@@ -51435,7 +51491,7 @@ msgstr "Нерэчаісны выбар %s" + msgid "ISO C++ forbids using a floating-point literal in a constant-expression" + msgstr "" + +-#: cp/parser.c:3200 cp/pt.c:19309 ++#: cp/parser.c:3200 cp/pt.c:19354 + #, gcc-internal-format + msgid "a cast to a type other than an integral or enumeration type cannot appear in a constant-expression" + msgstr "" +@@ -51557,7 +51613,7 @@ msgstr "" + msgid "% only available with %<-std=c++2a%> or %<-fconcepts%>" + msgstr "" + +-#: cp/parser.c:3382 cp/parser.c:27700 ++#: cp/parser.c:3382 cp/parser.c:27723 + #, gcc-internal-format + msgid "% only available with %<-std=c++2a%> or %<-fconcepts%>" + msgstr "" +@@ -51677,7 +51733,7 @@ msgstr "" + msgid "unable to find string literal operator %qD with %qT, %qT arguments" + msgstr "" + +-#: cp/parser.c:4727 cp/parser.c:13626 ++#: cp/parser.c:4727 cp/parser.c:13631 + #, fuzzy, gcc-internal-format + #| msgid "empty declaration" + msgid "expected declaration" +@@ -51779,12 +51835,12 @@ msgstr "" + msgid "typedef-name %qD used as destructor declarator" + msgstr "" + +-#: cp/parser.c:6276 cp/parser.c:21434 ++#: cp/parser.c:6276 cp/parser.c:21450 + #, gcc-internal-format + msgid "expected unqualified-id" + msgstr "" + +-#: cp/parser.c:6303 cp/typeck.c:2810 cp/typeck.c:2813 cp/typeck.c:2830 ++#: cp/parser.c:6303 cp/typeck.c:2852 cp/typeck.c:2855 cp/typeck.c:2872 + #, fuzzy, gcc-internal-format + msgid "%qD is not a template" + msgstr "\"%s\" мае незавершаны тып" +@@ -51819,7 +51875,7 @@ msgstr "" + msgid "expected nested-name-specifier" + msgstr "" + +-#: cp/parser.c:6917 cp/parser.c:9319 ++#: cp/parser.c:6917 cp/parser.c:9324 + #, gcc-internal-format + msgid "types may not be defined in casts" + msgstr "" +@@ -51835,7 +51891,7 @@ msgstr "" + msgid "wrong number of arguments to %<__builtin_addressof%>" + msgstr "памылковая колькасьць аргументаў, зададзеных для атрыбута `%s'" + +-#: cp/parser.c:7110 cp/pt.c:19928 ++#: cp/parser.c:7110 cp/pt.c:19975 + #, fuzzy, gcc-internal-format + #| msgid "wrong number of arguments specified for `%s' attribute" + msgid "wrong number of arguments to %<__builtin_launder%>" +@@ -51851,7 +51907,7 @@ msgstr "ISO C не дазваляе дэкларацыі метак (label)" + msgid "two consecutive %<[%> shall only introduce an attribute" + msgstr "" + +-#: cp/parser.c:7825 cp/typeck.c:2698 ++#: cp/parser.c:7825 cp/typeck.c:2740 + #, fuzzy, gcc-internal-format + #| msgid "invalid use of `%D'" + msgid "invalid use of %qD" +@@ -51877,924 +51933,929 @@ msgstr "ISO C не дазваляе дэкларацыі метак (label)" + msgid "types may not be defined in % expressions" + msgstr "" + +-#: cp/parser.c:8618 cp/parser.c:30169 ++#: cp/parser.c:8618 cp/parser.c:30194 + #, gcc-internal-format + msgid "types may not be defined in %qs expressions" + msgstr "" + +-#: cp/parser.c:8764 ++#: cp/parser.c:8683 ++#, gcc-internal-format ++msgid "%<__builtin_has_attribute%> with dependent argument not supported yet" ++msgstr "" ++ ++#: cp/parser.c:8769 + #, gcc-internal-format + msgid "types may not be defined in a new-expression" + msgstr "" + +-#: cp/parser.c:8780 ++#: cp/parser.c:8785 + #, gcc-internal-format + msgid "array bound forbidden after parenthesized type-id" + msgstr "" + +-#: cp/parser.c:8782 ++#: cp/parser.c:8787 + #, gcc-internal-format + msgid "try removing the parentheses around the type-id" + msgstr "" + +-#: cp/parser.c:8814 ++#: cp/parser.c:8819 + #, gcc-internal-format + msgid "initialization of new-expression for type % requires exactly one element" + msgstr "" + +-#: cp/parser.c:8859 ++#: cp/parser.c:8864 + #, gcc-internal-format + msgid "expected expression-list or type-id" + msgstr "" + +-#: cp/parser.c:8888 ++#: cp/parser.c:8893 + #, gcc-internal-format + msgid "types may not be defined in a new-type-id" + msgstr "" + +-#: cp/parser.c:9017 ++#: cp/parser.c:9022 + #, gcc-internal-format + msgid "expression in new-declarator must have integral or enumeration type" + msgstr "" + +-#: cp/parser.c:9424 ++#: cp/parser.c:9429 + #, gcc-internal-format + msgid "use of old-style cast to %q#T" + msgstr "" + +-#: cp/parser.c:9573 ++#: cp/parser.c:9578 + #, gcc-internal-format + msgid "%<>>%> operator is treated as two right angle brackets in C++11" + msgstr "" + +-#: cp/parser.c:9576 ++#: cp/parser.c:9581 + #, gcc-internal-format + msgid "suggest parentheses around %<>>%> expression" + msgstr "" + +-#: cp/parser.c:9784 ++#: cp/parser.c:9789 + #, gcc-internal-format + msgid "ISO C++ does not allow % with omitted middle operand" + msgstr "" + +-#: cp/parser.c:10073 ++#: cp/parser.c:10078 + #, gcc-internal-format + msgid "top-level comma expression in array subscript is deprecated" + msgstr "" + +-#: cp/parser.c:10223 ++#: cp/parser.c:10228 + #, gcc-internal-format + msgid "types may not be defined within %<__builtin_offsetof%>" + msgstr "" + +-#: cp/parser.c:10512 ++#: cp/parser.c:10517 + #, gcc-internal-format + msgid "lambda-expression in unevaluated context only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/parser.c:10522 ++#: cp/parser.c:10527 + #, gcc-internal-format + msgid "lambda-expression in template-argument only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/parser.c:10674 ++#: cp/parser.c:10679 + #, gcc-internal-format + msgid "non-local lambda expression cannot have a capture-default" + msgstr "" + +-#: cp/parser.c:10696 ++#: cp/parser.c:10701 + #, gcc-internal-format + msgid "expected end of capture-list" + msgstr "" + +-#: cp/parser.c:10711 ++#: cp/parser.c:10716 + #, gcc-internal-format + msgid "explicit by-copy capture of % redundant with by-copy capture default" + msgstr "" + +-#: cp/parser.c:10716 cp/parser.c:10737 cp/parser.c:10929 ++#: cp/parser.c:10721 cp/parser.c:10742 cp/parser.c:10934 + #, gcc-internal-format + msgid "already captured %qD in lambda expression" + msgstr "" + +-#: cp/parser.c:10731 ++#: cp/parser.c:10736 + #, gcc-internal-format + msgid "%<*this%> capture only available with %<-std=c++17%> or %<-std=gnu++17%>" + msgstr "" + +-#: cp/parser.c:10751 ++#: cp/parser.c:10756 + #, fuzzy, gcc-internal-format + msgid "% cannot be captured by reference" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/parser.c:10770 ++#: cp/parser.c:10775 + #, gcc-internal-format + msgid "pack init-capture only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/parser.c:10781 ++#: cp/parser.c:10786 + #, gcc-internal-format + msgid "%<&%> should come before %<...%>" + msgstr "" + +-#: cp/parser.c:10812 ++#: cp/parser.c:10817 + #, gcc-internal-format + msgid "lambda capture initializers only available with %<-std=c++14%> or %<-std=gnu++14%>" + msgstr "" + +-#: cp/parser.c:10819 ++#: cp/parser.c:10824 + #, gcc-internal-format + msgid "empty initializer for lambda init-capture" + msgstr "" + +-#: cp/parser.c:10843 ++#: cp/parser.c:10848 + #, gcc-internal-format + msgid "capture of non-variable %qE" + msgstr "" + +-#: cp/parser.c:10847 cp/parser.c:10857 cp/semantics.c:3633 cp/semantics.c:3645 ++#: cp/parser.c:10852 cp/parser.c:10862 cp/semantics.c:3633 cp/semantics.c:3645 + #, fuzzy, gcc-internal-format + msgid "%q#D declared here" + msgstr "\"%s\" не абвешчан (першае выкарыстанне ў гэтай функцыі)" + +-#: cp/parser.c:10853 ++#: cp/parser.c:10858 + #, gcc-internal-format + msgid "capture of variable %qD with non-automatic storage duration" + msgstr "" + +-#: cp/parser.c:10891 ++#: cp/parser.c:10896 + #, gcc-internal-format + msgid "too many %<...%> in lambda capture" + msgstr "" + +-#: cp/parser.c:10902 ++#: cp/parser.c:10907 + #, gcc-internal-format + msgid "explicit by-copy capture of %qD redundant with by-copy capture default" + msgstr "" + +-#: cp/parser.c:10907 ++#: cp/parser.c:10912 + #, gcc-internal-format + msgid "explicit by-reference capture of %qD redundant with by-reference capture default" + msgstr "" + +-#: cp/parser.c:10986 ++#: cp/parser.c:10991 + #, gcc-internal-format + msgid "lambda templates are only available with %<-std=c++14%> or %<-std=gnu++14%>" + msgstr "" + +-#: cp/parser.c:10990 ++#: cp/parser.c:10995 + #, gcc-internal-format + msgid "lambda templates are only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/parser.c:11058 ++#: cp/parser.c:11063 + #, fuzzy, gcc-internal-format + #| msgid "wrong number of arguments specified for `%s' attribute" + msgid "default argument specified for lambda parameter" + msgstr "памылковая колькасьць аргументаў, зададзеных для атрыбута `%s'" + +-#: cp/parser.c:11076 ++#: cp/parser.c:11081 + #, fuzzy, gcc-internal-format + msgid "duplicate %" + msgstr "паўтарэнне \"%s\"" + +-#: cp/parser.c:11128 ++#: cp/parser.c:11133 + #, gcc-internal-format + msgid "% lambda only available with %<-std=c++17%> or %<-std=gnu++17%>" + msgstr "" + +-#: cp/parser.c:11516 cp/parser.c:11717 ++#: cp/parser.c:11521 cp/parser.c:11722 + #, gcc-internal-format + msgid "attributes at the beginning of statement are ignored" + msgstr "" + +-#: cp/parser.c:11556 ++#: cp/parser.c:11561 + #, fuzzy, gcc-internal-format + #| msgid "empty body in an else-statement" + msgid "expected labeled-statement" + msgstr "пустое цела ў else-выражэнні" + +-#: cp/parser.c:11605 ++#: cp/parser.c:11610 + #, gcc-internal-format + msgid "case label %qE not within a switch statement" + msgstr "" + +-#: cp/parser.c:11724 ++#: cp/parser.c:11729 + #, gcc-internal-format + msgid "need % before %qE because %qT is a dependent scope" + msgstr "" + +-#: cp/parser.c:11733 ++#: cp/parser.c:11738 + #, gcc-internal-format + msgid "%<%T::%D%> names the constructor, not the type" + msgstr "" + +-#: cp/parser.c:11781 ++#: cp/parser.c:11786 + #, gcc-internal-format + msgid "compound-statement in % function" + msgstr "" + +-#: cp/parser.c:11946 ++#: cp/parser.c:11951 + #, gcc-internal-format + msgid "% only available with %<-std=c++17%> or %<-std=gnu++17%>" + msgstr "" + +-#: cp/parser.c:11973 ++#: cp/parser.c:11978 + #, gcc-internal-format + msgid "init-statement in selection statements only available with %<-std=c++17%> or %<-std=gnu++17%>" + msgstr "" + +-#: cp/parser.c:12150 cp/parser.c:30653 ++#: cp/parser.c:12155 cp/parser.c:30678 + #, fuzzy, gcc-internal-format + #| msgid "empty body in an else-statement" + msgid "expected selection-statement" + msgstr "пустое цела ў else-выражэнні" + +-#: cp/parser.c:12191 ++#: cp/parser.c:12196 + #, gcc-internal-format + msgid "condition declares an array" + msgstr "" + +-#: cp/parser.c:12193 ++#: cp/parser.c:12198 + #, fuzzy, gcc-internal-format + #| msgid "too few arguments to function" + msgid "condition declares a function" + msgstr "не хапае аргументаў у функцыі" + +-#: cp/parser.c:12233 ++#: cp/parser.c:12238 + #, gcc-internal-format + msgid "types may not be defined in conditions" + msgstr "" + + #. Anything else is an error. +-#: cp/parser.c:12314 cp/parser.c:20746 cp/parser.c:23181 ++#: cp/parser.c:12319 cp/parser.c:20756 cp/parser.c:23197 + #, fuzzy, gcc-internal-format + #| msgid "invalid initializer" + msgid "expected initializer" + msgstr "нерэчаісны ініцыялізатар" + +-#: cp/parser.c:12696 ++#: cp/parser.c:12701 + #, gcc-internal-format + msgid "range-based % expression of type %qT has incomplete type" + msgstr "" + +-#: cp/parser.c:12780 ++#: cp/parser.c:12785 + #, gcc-internal-format + msgid "inconsistent begin/end types in range-based % statement: %qT and %qT" + msgstr "" + +-#: cp/parser.c:12923 cp/parser.c:30656 ++#: cp/parser.c:12928 cp/parser.c:30681 + #, fuzzy, gcc-internal-format + #| msgid "empty body in an else-statement" + msgid "expected iteration-statement" + msgstr "пустое цела ў else-выражэнні" + +-#: cp/parser.c:12969 ++#: cp/parser.c:12974 + #, gcc-internal-format + msgid "range-based % loops with initializer only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/parser.c:12993 ++#: cp/parser.c:12998 + #, gcc-internal-format + msgid "range-based % loops only available with %<-std=c++11%> or %<-std=gnu++11%>" + msgstr "" + +-#: cp/parser.c:13124 ++#: cp/parser.c:13129 + #, gcc-internal-format + msgid "% in % function" + msgstr "" + + #. Issue a warning about this use of a GNU extension. +-#: cp/parser.c:13132 ++#: cp/parser.c:13137 + #, gcc-internal-format + msgid "ISO C++ forbids computed gotos" + msgstr "" + +-#: cp/parser.c:13145 cp/parser.c:30659 ++#: cp/parser.c:13150 cp/parser.c:30684 + #, gcc-internal-format + msgid "expected jump-statement" + msgstr "" + +-#: cp/parser.c:13457 cp/parser.c:24950 ++#: cp/parser.c:13462 cp/parser.c:24966 + #, gcc-internal-format + msgid "extra %<;%>" + msgstr "" + +-#: cp/parser.c:13549 ++#: cp/parser.c:13554 + #, gcc-internal-format + msgid "%<__label__%> not at the beginning of a block" + msgstr "" + +-#: cp/parser.c:13764 ++#: cp/parser.c:13769 + #, gcc-internal-format + msgid "non-variable %qD in declaration with more than one declarator with placeholder type" + msgstr "" + +-#: cp/parser.c:13784 ++#: cp/parser.c:13789 + #, gcc-internal-format + msgid "inconsistent deduction for %qT: %qT and then %qT" + msgstr "" + +-#: cp/parser.c:13805 ++#: cp/parser.c:13810 + #, gcc-internal-format + msgid "mixing declarations and function-definitions is forbidden" + msgstr "" + +-#: cp/parser.c:13829 ++#: cp/parser.c:13834 + #, gcc-internal-format + msgid "types may not be defined in a for-range-declaration" + msgstr "" + +-#: cp/parser.c:13884 ++#: cp/parser.c:13889 + #, gcc-internal-format + msgid "initializer in range-based % loop" + msgstr "" + +-#: cp/parser.c:13887 ++#: cp/parser.c:13892 + #, fuzzy, gcc-internal-format + #| msgid "multiple declarations `%T' and `%T'" + msgid "multiple declarations in range-based % loop" + msgstr "неаднолькавае абвяшчэньне `%T' і `%T'" + +-#: cp/parser.c:13938 ++#: cp/parser.c:13943 + #, gcc-internal-format + msgid "structured bindings only available with %<-std=c++17%> or %<-std=gnu++17%>" + msgstr "" + +-#: cp/parser.c:13990 ++#: cp/parser.c:13995 + #, fuzzy, gcc-internal-format + #| msgid "empty declaration" + msgid "empty structured binding declaration" + msgstr "пустое абвяшчэньне" + +-#: cp/parser.c:14008 ++#: cp/parser.c:14013 + #, fuzzy, gcc-internal-format + msgid "invalid initializer for structured binding declaration" + msgstr "нерэчаісны ініцыялізатар" + +-#: cp/parser.c:14180 ++#: cp/parser.c:14185 + #, gcc-internal-format + msgid "% used outside of class" + msgstr "" + +-#: cp/parser.c:14219 ++#: cp/parser.c:14224 + #, gcc-internal-format + msgid "the % keyword is not allowed in a C++20 concept definition" + msgstr "" + +-#: cp/parser.c:14222 ++#: cp/parser.c:14227 + #, gcc-internal-format + msgid "C++20 concept definition syntax is % = %>" + msgstr "" + +-#: cp/parser.c:14289 ++#: cp/parser.c:14294 + #, gcc-internal-format + msgid "% changes meaning in C++11; please remove it" + msgstr "" + +-#: cp/parser.c:14325 ++#: cp/parser.c:14330 + #, gcc-internal-format + msgid "% invalid in condition" + msgstr "" + +-#: cp/parser.c:14332 ++#: cp/parser.c:14337 + #, fuzzy, gcc-internal-format + msgid "%qD invalid in lambda" + msgstr "Нерэчаісны выбар \"%s\"" + +-#: cp/parser.c:14413 ++#: cp/parser.c:14418 + #, gcc-internal-format + msgid "type-specifier invalid in lambda" + msgstr "" + +-#: cp/parser.c:14432 ++#: cp/parser.c:14437 + #, fuzzy, gcc-internal-format + msgid "class definition may not be declared a friend" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/parser.c:14505 cp/parser.c:25464 ++#: cp/parser.c:14510 cp/parser.c:25480 + #, gcc-internal-format + msgid "templates may not be %" + msgstr "" + +-#: cp/parser.c:14524 ++#: cp/parser.c:14529 + #, gcc-internal-format + msgid "types may not be defined in explicit-specifier" + msgstr "" + +-#: cp/parser.c:14528 ++#: cp/parser.c:14533 + #, gcc-internal-format + msgid "% only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/parser.c:14592 ++#: cp/parser.c:14597 + #, fuzzy, gcc-internal-format + msgid "invalid linkage-specification" + msgstr "Нерэчаісная спецыфікацыя! Памылка ў cc." + +-#: cp/parser.c:14696 ++#: cp/parser.c:14701 + #, gcc-internal-format + msgid "% without a message only available with %<-std=c++17%> or %<-std=gnu++17%>" + msgstr "" + +-#: cp/parser.c:14901 ++#: cp/parser.c:14906 + #, gcc-internal-format + msgid "types may not be defined in % expressions" + msgstr "" + +-#: cp/parser.c:15064 ++#: cp/parser.c:15069 + #, gcc-internal-format + msgid "types may not be defined in a conversion-type-id" + msgstr "" + +-#: cp/parser.c:15093 ++#: cp/parser.c:15098 + #, gcc-internal-format + msgid "invalid use of % in conversion operator" + msgstr "" + +-#: cp/parser.c:15097 ++#: cp/parser.c:15102 + #, gcc-internal-format + msgid "use of % in member template conversion operator can never be deduced" + msgstr "" + +-#: cp/parser.c:15181 ++#: cp/parser.c:15186 + #, gcc-internal-format + msgid "only constructors take member initializers" + msgstr "" + +-#: cp/parser.c:15208 ++#: cp/parser.c:15213 + #, fuzzy, gcc-internal-format + msgid "cannot expand initializer for member %qD" + msgstr "прапушчан ініцыялізатар" + +-#: cp/parser.c:15220 cp/pt.c:25968 ++#: cp/parser.c:15225 cp/pt.c:26036 + #, gcc-internal-format + msgid "mem-initializer for %qD follows constructor delegation" + msgstr "" + +-#: cp/parser.c:15232 cp/pt.c:25980 ++#: cp/parser.c:15237 cp/pt.c:26048 + #, gcc-internal-format + msgid "constructor delegation follows mem-initializer for %qD" + msgstr "" + +-#: cp/parser.c:15284 ++#: cp/parser.c:15289 + #, gcc-internal-format + msgid "anachronistic old-style base class initializer" + msgstr "" + +-#: cp/parser.c:15356 ++#: cp/parser.c:15361 + #, gcc-internal-format + msgid "keyword % not allowed in this context (a qualified member initializer is implicitly a type)" + msgstr "" + +-#: cp/parser.c:15757 ++#: cp/parser.c:15762 + #, gcc-internal-format + msgid "unexpected keyword; remove space between quotes and suffix identifier" + msgstr "" + +-#: cp/parser.c:15763 ++#: cp/parser.c:15768 + #, gcc-internal-format + msgid "expected suffix identifier" + msgstr "" + +-#: cp/parser.c:15772 ++#: cp/parser.c:15777 + #, gcc-internal-format + msgid "expected empty string after % keyword" + msgstr "" + +-#: cp/parser.c:15778 ++#: cp/parser.c:15783 + #, gcc-internal-format + msgid "invalid encoding prefix in literal operator" + msgstr "" + +-#: cp/parser.c:15812 ++#: cp/parser.c:15817 + #, fuzzy, gcc-internal-format + #| msgid "unregistered operator %s" + msgid "expected operator" + msgstr "нераспазнаны аператар %s" + + #. Warn that we do not support `export'. +-#: cp/parser.c:15858 ++#: cp/parser.c:15863 + #, gcc-internal-format + msgid "keyword % not implemented, and will be ignored" + msgstr "" + +-#: cp/parser.c:16037 ++#: cp/parser.c:16042 + #, fuzzy, gcc-internal-format + msgid "invalid constrained type parameter" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/parser.c:16045 ++#: cp/parser.c:16050 + #, fuzzy, gcc-internal-format + msgid "cv-qualified type parameter" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/parser.c:16188 ++#: cp/parser.c:16193 + #, fuzzy, gcc-internal-format + msgid "invalid use of % in default template argument" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/parser.c:16424 cp/parser.c:16510 cp/parser.c:22952 ++#: cp/parser.c:16429 cp/parser.c:16515 cp/parser.c:22968 + #, fuzzy, gcc-internal-format + msgid "template parameter pack %qD cannot have a default argument" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/parser.c:16428 cp/parser.c:16514 ++#: cp/parser.c:16433 cp/parser.c:16519 + #, fuzzy, gcc-internal-format + msgid "template parameter packs cannot have default arguments" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/parser.c:16581 ++#: cp/parser.c:16586 + #, gcc-internal-format + msgid "expected template-id" + msgstr "" + +-#: cp/parser.c:16643 ++#: cp/parser.c:16648 + #, gcc-internal-format + msgid "%<<::%> cannot begin a template-argument list" + msgstr "" + +-#: cp/parser.c:16647 ++#: cp/parser.c:16652 + #, gcc-internal-format + msgid "%<<:%> is an alternate spelling for %<[%>. Insert whitespace between %<<%> and %<::%>" + msgstr "" + +-#: cp/parser.c:16651 ++#: cp/parser.c:16656 + #, gcc-internal-format + msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)" + msgstr "" + +-#: cp/parser.c:16681 ++#: cp/parser.c:16686 + #, fuzzy, gcc-internal-format + msgid "invalid template-argument-list" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/parser.c:16682 ++#: cp/parser.c:16687 + #, gcc-internal-format + msgid "function name as the left hand operand of %<<%> is ill-formed in C++2a; wrap the function name in %<()%>" + msgstr "" + +-#: cp/parser.c:16689 ++#: cp/parser.c:16694 + #, gcc-internal-format + msgid "expected %<(%> after template-argument-list" + msgstr "" + +-#: cp/parser.c:16793 ++#: cp/parser.c:16798 + #, gcc-internal-format + msgid "parse error in template argument list" + msgstr "" + + #. The name does not name a template. +-#: cp/parser.c:16878 cp/parser.c:17044 cp/parser.c:17249 ++#: cp/parser.c:16883 cp/parser.c:17049 cp/parser.c:17254 + #, gcc-internal-format + msgid "expected template-name" + msgstr "" + + #. Explain what went wrong. +-#: cp/parser.c:16924 ++#: cp/parser.c:16929 + #, gcc-internal-format + msgid "non-template %qD used as template" + msgstr "" + +-#: cp/parser.c:16926 ++#: cp/parser.c:16931 + #, gcc-internal-format + msgid "use %<%T::template %D%> to indicate that it is a template" + msgstr "" + +-#: cp/parser.c:17105 ++#: cp/parser.c:17110 + #, gcc-internal-format + msgid "expected parameter pack before %<...%>" + msgstr "" + +-#: cp/parser.c:17214 cp/parser.c:17232 cp/parser.c:17403 ++#: cp/parser.c:17219 cp/parser.c:17237 cp/parser.c:17408 + #, gcc-internal-format + msgid "expected template-argument" + msgstr "" + +-#: cp/parser.c:17370 ++#: cp/parser.c:17375 + #, fuzzy, gcc-internal-format + msgid "invalid non-type template argument" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/parser.c:17507 ++#: cp/parser.c:17512 + #, gcc-internal-format + msgid "explicit instantiation shall not use % specifier" + msgstr "" + +-#: cp/parser.c:17511 ++#: cp/parser.c:17516 + #, gcc-internal-format + msgid "explicit instantiation shall not use % specifier" + msgstr "" + +-#: cp/parser.c:17515 ++#: cp/parser.c:17520 + #, gcc-internal-format + msgid "explicit instantiation shall not use % specifier" + msgstr "" + +-#: cp/parser.c:17574 ++#: cp/parser.c:17579 + #, gcc-internal-format + msgid "template specialization with C linkage" + msgstr "" + +-#: cp/parser.c:17795 ++#: cp/parser.c:17800 + #, gcc-internal-format + msgid "expected type specifier" + msgstr "" + +-#: cp/parser.c:17988 ++#: cp/parser.c:17993 + #, gcc-internal-format + msgid "use of % in lambda parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>" + msgstr "" + +-#: cp/parser.c:17994 ++#: cp/parser.c:17999 + #, gcc-internal-format + msgid "use of % in parameter declaration only available with %<-std=c++14%> or %<-std=gnu++14%>" + msgstr "" + +-#: cp/parser.c:17999 ++#: cp/parser.c:18004 + #, gcc-internal-format + msgid "use of % in parameter declaration only available with %<-fconcepts-ts%>" + msgstr "" + +-#: cp/parser.c:18156 ++#: cp/parser.c:18161 + #, gcc-internal-format + msgid "expected template-id for type" + msgstr "" + +-#: cp/parser.c:18286 ++#: cp/parser.c:18291 + #, gcc-internal-format + msgid "expected type-name" + msgstr "" + +-#: cp/parser.c:18396 ++#: cp/parser.c:18401 + #, fuzzy, gcc-internal-format + #| msgid "function does not return string type" + msgid "%qE does not constrain a type" + msgstr "функцыя не вяртае тып string" + +-#: cp/parser.c:18397 ++#: cp/parser.c:18402 + #, gcc-internal-format + msgid "concept defined here" + msgstr "" + +-#: cp/parser.c:18419 ++#: cp/parser.c:18424 + #, gcc-internal-format + msgid "expected % or % after %qE" + msgstr "" + +-#: cp/parser.c:18426 ++#: cp/parser.c:18431 + #, gcc-internal-format + msgid "unexpected placeholder in constrained result type" + msgstr "" + +-#: cp/parser.c:18669 ++#: cp/parser.c:18674 + #, gcc-internal-format + msgid "elaborated-type-specifier for a scoped enum must not use the %qD keyword" + msgstr "" + +-#: cp/parser.c:18745 ++#: cp/parser.c:18750 + #, gcc-internal-format + msgid "% must follow a nested-name-specifier" + msgstr "" + +-#: cp/parser.c:18906 ++#: cp/parser.c:18911 + #, gcc-internal-format + msgid "declaration %qD does not declare anything" + msgstr "" + +-#: cp/parser.c:18994 ++#: cp/parser.c:18999 + #, gcc-internal-format + msgid "attributes ignored on uninstantiated type" + msgstr "" + +-#: cp/parser.c:18998 ++#: cp/parser.c:19003 + #, gcc-internal-format + msgid "attributes ignored on template instantiation" + msgstr "" + +-#: cp/parser.c:19003 ++#: cp/parser.c:19008 + #, gcc-internal-format + msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration" + msgstr "" + +-#: cp/parser.c:19143 ++#: cp/parser.c:19148 + #, fuzzy, gcc-internal-format + msgid "%qD is an enumeration template" + msgstr "\"%s\" звычайна функцыя" + +-#: cp/parser.c:19154 ++#: cp/parser.c:19159 + #, gcc-internal-format + msgid "%qD does not name an enumeration in %qT" + msgstr "" + +-#: cp/parser.c:19169 ++#: cp/parser.c:19174 + #, gcc-internal-format + msgid "unnamed scoped enum is not allowed" + msgstr "" + +-#: cp/parser.c:19226 ++#: cp/parser.c:19231 + #, gcc-internal-format + msgid "expected %<;%> or %<{%>" + msgstr "" + +-#: cp/parser.c:19270 ++#: cp/parser.c:19275 + #, gcc-internal-format + msgid "cannot add an enumerator list to a template instantiation" + msgstr "" + +-#: cp/parser.c:19284 ++#: cp/parser.c:19289 + #, gcc-internal-format + msgid "nested name specifier %qT for enum declaration does not name a class or namespace" + msgstr "" + +-#: cp/parser.c:19296 cp/parser.c:24433 ++#: cp/parser.c:19301 cp/parser.c:24449 + #, gcc-internal-format + msgid "declaration of %qD in namespace %qD which does not enclose %qD" + msgstr "" + +-#: cp/parser.c:19301 cp/parser.c:24438 ++#: cp/parser.c:19306 cp/parser.c:24454 + #, gcc-internal-format + msgid "declaration of %qD in %qD which does not enclose %qD" + msgstr "" + +-#: cp/parser.c:19313 cp/parser.c:24451 ++#: cp/parser.c:19318 cp/parser.c:24467 + #, gcc-internal-format + msgid "extra qualification not allowed" + msgstr "" + +-#: cp/parser.c:19350 ++#: cp/parser.c:19355 + #, fuzzy, gcc-internal-format + #| msgid "ISO C forbids an empty source file" + msgid "ISO C++ forbids empty unnamed enum" + msgstr "ISO C не дазваляе пусты ізыходны файл" + +-#: cp/parser.c:19370 ++#: cp/parser.c:19380 + #, gcc-internal-format + msgid "opaque-enum-specifier without name" + msgstr "" + +-#: cp/parser.c:19373 ++#: cp/parser.c:19383 + #, gcc-internal-format + msgid "opaque-enum-specifier must use a simple identifier" + msgstr "" + +-#: cp/parser.c:19560 ++#: cp/parser.c:19570 + #, gcc-internal-format + msgid "%qD is not a namespace-name; did you mean %qs?" + msgstr "" + +-#: cp/parser.c:19564 ++#: cp/parser.c:19574 + #, fuzzy, gcc-internal-format + #| msgid "`%D' is not a function," + msgid "%qD is not a namespace-name" + msgstr "`%D' - гэта ня функцыя," + +-#: cp/parser.c:19568 ++#: cp/parser.c:19578 + #, gcc-internal-format + msgid "expected namespace-name" + msgstr "" + +-#: cp/parser.c:19629 ++#: cp/parser.c:19639 + #, gcc-internal-format + msgid "nested inline namespace definitions only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/parser.c:19640 ++#: cp/parser.c:19650 + #, gcc-internal-format + msgid "standard attributes on namespaces must precede the namespace name" + msgstr "" + +-#: cp/parser.c:19659 ++#: cp/parser.c:19669 + #, gcc-internal-format + msgid "nested namespace definitions only available with %<-std=c++17%> or %<-std=gnu++17%>" + msgstr "" + +-#: cp/parser.c:19669 ++#: cp/parser.c:19679 + #, gcc-internal-format + msgid "nested namespace name required" + msgstr "" + +-#: cp/parser.c:19674 ++#: cp/parser.c:19684 + #, gcc-internal-format + msgid "namespace name required" + msgstr "" + +-#: cp/parser.c:19678 ++#: cp/parser.c:19688 + #, gcc-internal-format + msgid "a nested namespace definition cannot have attributes" + msgstr "" + +-#: cp/parser.c:19681 ++#: cp/parser.c:19691 + #, gcc-internal-format + msgid "a nested namespace definition cannot be inline" + msgstr "" + +-#: cp/parser.c:19688 ++#: cp/parser.c:19698 + #, gcc-internal-format + msgid "namespace %qD entered" + msgstr "" + +-#: cp/parser.c:19743 ++#: cp/parser.c:19753 + #, gcc-internal-format + msgid "% definition is not allowed here" + msgstr "" + +-#: cp/parser.c:19897 ++#: cp/parser.c:19907 + #, gcc-internal-format + msgid "pack expansion in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>" + msgstr "" + +-#: cp/parser.c:19912 ++#: cp/parser.c:19922 + #, fuzzy, gcc-internal-format + msgid "a template-id may not appear in a using-declaration" + msgstr "\"%s\" - гэта не пачатак дэкларацыі" + +-#: cp/parser.c:19942 ++#: cp/parser.c:19952 + #, gcc-internal-format + msgid "comma-separated list in using-declaration only available with %<-std=c++17%> or %<-std=gnu++17%>" + msgstr "" + +-#: cp/parser.c:19952 ++#: cp/parser.c:19962 + #, gcc-internal-format + msgid "access declarations are deprecated in favour of using-declarations; suggestion: add the % keyword" + msgstr "" + +-#: cp/parser.c:20017 ++#: cp/parser.c:20027 + #, gcc-internal-format + msgid "types may not be defined in alias template declarations" + msgstr "" + +-#: cp/parser.c:20188 ++#: cp/parser.c:20198 + #, gcc-internal-format + msgid "% in % function only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/parser.c:20207 cp/parser.c:20224 cp/parser.c:20238 ++#: cp/parser.c:20217 cp/parser.c:20234 cp/parser.c:20248 + #, fuzzy, gcc-internal-format + msgid "duplicate % qualifier %qT" + msgstr "паўтарэнне \"volatile\"" + +-#: cp/parser.c:20214 ++#: cp/parser.c:20224 + #, gcc-internal-format + msgid "% qualifier %qT ignored outside of function body" + msgstr "" + +-#: cp/parser.c:20251 ++#: cp/parser.c:20261 + #, gcc-internal-format + msgid "%qT is not an % qualifier" + msgstr "" + +-#: cp/parser.c:20267 ++#: cp/parser.c:20277 + #, gcc-internal-format + msgid "% qualifier outside of function body" + msgstr "" + +-#: cp/parser.c:20641 ++#: cp/parser.c:20651 + #, fuzzy, gcc-internal-format + msgid "a function-definition is not allowed here" + msgstr "атрыбуты секцыі не падтрымліваюцца для гэтай мэты" + +-#: cp/parser.c:20652 ++#: cp/parser.c:20662 + #, gcc-internal-format + msgid "an % specification is not allowed on a function-definition" + msgstr "" + +-#: cp/parser.c:20656 ++#: cp/parser.c:20666 + #, fuzzy, gcc-internal-format + msgid "attributes are not allowed on a function-definition" + msgstr "\"%s\" - гэта не пачатак дэкларацыі" + +-#: cp/parser.c:20707 ++#: cp/parser.c:20717 + #, gcc-internal-format + msgid "expected constructor, destructor, or type conversion" + msgstr "" + +-#: cp/parser.c:20827 ++#: cp/parser.c:20837 + #, fuzzy, gcc-internal-format + msgid "initializer provided for function" + msgstr "не магу ініцыялізаваць сяброўскую функцыю \"%s\"" + +-#: cp/parser.c:20869 ++#: cp/parser.c:20879 + #, gcc-internal-format + msgid "attributes after parenthesized initializer ignored" + msgstr "" + +-#: cp/parser.c:20883 ++#: cp/parser.c:20893 + #, gcc-internal-format + msgid "non-function %qD declared as implicit template" + msgstr "" + +-#: cp/parser.c:21354 ++#: cp/parser.c:21370 + #, fuzzy, gcc-internal-format + msgid "array bound is not an integer constant" + msgstr "памер масіва \"%s\" адмоўны" + +-#: cp/parser.c:21480 ++#: cp/parser.c:21496 + #, gcc-internal-format + msgid "cannot define member of dependent typedef %qT" + msgstr "" + +-#: cp/parser.c:21484 ++#: cp/parser.c:21500 + #, fuzzy, gcc-internal-format + msgid "%<%T::%E%> is not a type" + msgstr "\"%s\" мае незавершаны тып" +@@ -52803,437 +52864,437 @@ msgstr "\"%s\" мае незавершаны тып" + #. here because we do not have enough + #. information about its original syntactic + #. form. +-#: cp/parser.c:21513 ++#: cp/parser.c:21529 + #, gcc-internal-format + msgid "invalid declarator" + msgstr "нерэчаісны абвяшчальнік" + +-#: cp/parser.c:21521 ++#: cp/parser.c:21537 + #, fuzzy, gcc-internal-format + msgid "invalid use of constructor as a template" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/parser.c:21523 ++#: cp/parser.c:21539 + #, gcc-internal-format + msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name" + msgstr "" + + #. But declarations with qualified-ids can't appear in a + #. function. +-#: cp/parser.c:21632 ++#: cp/parser.c:21648 + #, fuzzy, gcc-internal-format + #| msgid "Invalid declaration" + msgid "qualified-id in declaration" + msgstr "Нерэчаіснае абвяшчэнне" + +-#: cp/parser.c:21657 ++#: cp/parser.c:21673 + #, fuzzy, gcc-internal-format + #| msgid "empty declaration" + msgid "expected declarator" + msgstr "пустое абвяшчэньне" + +-#: cp/parser.c:21776 ++#: cp/parser.c:21792 + #, gcc-internal-format + msgid "%qD is a namespace" + msgstr "" + +-#: cp/parser.c:21778 ++#: cp/parser.c:21794 + #, gcc-internal-format + msgid "cannot form pointer to member of non-class %q#T" + msgstr "" + +-#: cp/parser.c:21799 ++#: cp/parser.c:21815 + #, gcc-internal-format + msgid "expected ptr-operator" + msgstr "" + +-#: cp/parser.c:21860 ++#: cp/parser.c:21876 + #, fuzzy, gcc-internal-format + #| msgid "duplicate `volatile'" + msgid "duplicate cv-qualifier" + msgstr "паўтарэнне \"volatile\"" + +-#: cp/parser.c:21914 ++#: cp/parser.c:21930 + #, gcc-internal-format + msgid "multiple ref-qualifiers" + msgstr "" + +-#: cp/parser.c:21951 ++#: cp/parser.c:21967 + #, gcc-internal-format + msgid "%qE requires %<-fgnu-tm%>" + msgstr "" + +-#: cp/parser.c:22009 ++#: cp/parser.c:22025 + #, fuzzy, gcc-internal-format + #| msgid "duplicate `volatile'" + msgid "duplicate virt-specifier" + msgstr "паўтарэнне \"volatile\"" + +-#: cp/parser.c:22261 ++#: cp/parser.c:22277 + #, fuzzy, gcc-internal-format + msgid "missing template arguments after %qT" + msgstr "невыкарыстаемы параметр \"%s\"" + +-#: cp/parser.c:22267 cp/typeck2.c:495 cp/typeck2.c:542 cp/typeck2.c:2306 ++#: cp/parser.c:22283 cp/typeck2.c:495 cp/typeck2.c:542 cp/typeck2.c:2310 + #, fuzzy, gcc-internal-format + #| msgid "invalid use of `%T'" + msgid "invalid use of %qT" + msgstr "нерэчаіснае выкарыстаньне `%T'" + +-#: cp/parser.c:22293 ++#: cp/parser.c:22309 + #, gcc-internal-format + msgid "types may not be defined in template arguments" + msgstr "" + +-#: cp/parser.c:22298 ++#: cp/parser.c:22314 + #, fuzzy, gcc-internal-format + msgid "invalid use of % in template argument" + msgstr "нявернае выкарыстанне \"restict\"" + +-#: cp/parser.c:22404 ++#: cp/parser.c:22420 + #, gcc-internal-format + msgid "expected type-specifier" + msgstr "" + +-#: cp/parser.c:22679 ++#: cp/parser.c:22695 + #, gcc-internal-format + msgid "expected %<,%> or %<...%>" + msgstr "" + +-#: cp/parser.c:22757 ++#: cp/parser.c:22773 + #, gcc-internal-format + msgid "types may not be defined in parameter types" + msgstr "" + +-#: cp/parser.c:22936 ++#: cp/parser.c:22952 + #, gcc-internal-format + msgid "default arguments are only permitted for function parameters" + msgstr "" + +-#: cp/parser.c:22954 ++#: cp/parser.c:22970 + #, gcc-internal-format + msgid "parameter pack %qD cannot have a default argument" + msgstr "" + +-#: cp/parser.c:22960 ++#: cp/parser.c:22976 + #, fuzzy, gcc-internal-format + msgid "template parameter pack cannot have a default argument" + msgstr "віртуальныя функцыі не могуць быць сяброўскімі" + +-#: cp/parser.c:22962 ++#: cp/parser.c:22978 + #, gcc-internal-format + msgid "parameter pack cannot have a default argument" + msgstr "" + +-#: cp/parser.c:23088 ++#: cp/parser.c:23104 + #, gcc-internal-format + msgid "function-try-block body of % constructor only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/parser.c:23092 ++#: cp/parser.c:23108 + #, gcc-internal-format + msgid "function-try-block body of % function only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/parser.c:23416 ++#: cp/parser.c:23432 + #, gcc-internal-format + msgid "C++ designated initializers only available with %<-std=c++2a%> or %<-std=gnu++2a%>" + msgstr "" + +-#: cp/parser.c:23436 ++#: cp/parser.c:23452 + #, gcc-internal-format + msgid "ISO C++ does not allow GNU designated initializers" + msgstr "" + +-#: cp/parser.c:23474 ++#: cp/parser.c:23490 + #, gcc-internal-format + msgid "ISO C++ does not allow C99 designated initializers" + msgstr "" + +-#: cp/parser.c:23488 ++#: cp/parser.c:23504 + #, gcc-internal-format + msgid "either all initializer clauses should be designated or none of them should be" + msgstr "" + +-#: cp/parser.c:23513 ++#: cp/parser.c:23529 + #, gcc-internal-format + msgid "%<...%> not allowed in designated initializer list" + msgstr "" + +-#: cp/parser.c:23564 ++#: cp/parser.c:23580 + #, gcc-internal-format + msgid "%<.%s%> designator used multiple times in the same initializer list" + msgstr "" + +-#: cp/parser.c:23623 cp/parser.c:23751 ++#: cp/parser.c:23639 cp/parser.c:23767 + #, gcc-internal-format + msgid "expected class-name" + msgstr "" + +-#: cp/parser.c:23981 ++#: cp/parser.c:23997 + #, gcc-internal-format + msgid "expected %<;%> after class definition" + msgstr "" + +-#: cp/parser.c:23984 ++#: cp/parser.c:24000 + #, gcc-internal-format + msgid "expected %<;%> after struct definition" + msgstr "" + +-#: cp/parser.c:23987 ++#: cp/parser.c:24003 + #, gcc-internal-format + msgid "expected %<;%> after union definition" + msgstr "" + +-#: cp/parser.c:24375 ++#: cp/parser.c:24391 + #, gcc-internal-format + msgid "expected %<{%> or %<:%>" + msgstr "" + +-#: cp/parser.c:24386 ++#: cp/parser.c:24402 + #, fuzzy, gcc-internal-format + #| msgid "cannot find file for class %s" + msgid "cannot specify % for a class" + msgstr "немагчыма знайсьці файл для кляса %s" + +-#: cp/parser.c:24394 ++#: cp/parser.c:24410 + #, gcc-internal-format + msgid "global qualification of class name is invalid" + msgstr "" + +-#: cp/parser.c:24401 ++#: cp/parser.c:24417 + #, gcc-internal-format + msgid "qualified name does not name a class" + msgstr "" + +-#: cp/parser.c:24413 ++#: cp/parser.c:24429 + #, gcc-internal-format + msgid "keyword % not allowed in class-head-name" + msgstr "" + +-#: cp/parser.c:24419 ++#: cp/parser.c:24435 + #, fuzzy, gcc-internal-format + msgid "invalid class name in declaration of %qD" + msgstr "Нерэчаіснае абвяшчэнне" + +-#: cp/parser.c:24473 ++#: cp/parser.c:24489 + #, fuzzy, gcc-internal-format + msgid "an explicit specialization must be preceded by %