Merge branches/gcc-6-branch rev 237469.

author Yvan Roux <yvan.roux@linaro.org>

Wed, 15 Jun 2016 08:42:05 +0000 (10:42 +0200)

committer Yvan Roux <yvan.roux@linaro.org>

Wed, 15 Jun 2016 08:42:05 +0000 (10:42 +0200)
author Yvan Roux <yvan.roux@linaro.org>
Wed, 15 Jun 2016 08:42:05 +0000 (10:42 +0200)
committer Yvan Roux <yvan.roux@linaro.org>
Wed, 15 Jun 2016 08:42:05 +0000 (10:42 +0200)
diff --git a/gcc/ChangeLog b/gcc/ChangeLog

index 0962f97..a44905c 100644 (file)
--- a/gcc/ChangeLog
+++ b/gcc/ChangeLog
@@ -1,3 +1,1064 @@
+2016-06-14  Jakub Jelinek  <jakub@redhat.com>
+
+       Backported from mainline
+       2016-06-10  Jakub Jelinek  <jakub@redhat.com>
+
+       PR middle-end/71494
+       * tree-nested.c (convert_nonlocal_reference_stmt): For GIMPLE_GOTO
+       without LABEL_DECL, set *handled_ops_p to false instead of true.
+
+       2016-06-08  Jakub Jelinek  <jakub@redhat.com>
+                   Richard Biener  <rguenther@suse.de>
+
+       PR c++/71448
+       * fold-const.c (fold_comparison): Handle CONSTANT_CLASS_P (base0)
+       the same as DECL_P (base0) for indirect_base0.  Use equality_code
+       in one further place.
+
+       2016-06-04  Jakub Jelinek  <jakub@redhat.com>
+
+       PR tree-optimization/71405
+       * tree-ssa.c (execute_update_addresses_taken): For clobber with
+       incompatible type, build a new clobber with the right type instead
+       of building a VIEW_CONVERT_EXPR around it.
+
+2016-06-13  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * tree-ssa-sccvn.c (vn_reference_lookup_3): Use a uniform test and
+       update shared_lookup_references only once after changing operands.
+
+2016-06-13  Richard Biener  <rguenther@suse.de>
+
+       PR tree-optimization/71505
+       * tree-vect-data-refs.c (vect_analyze_data_ref_accesses): Make
+       assert match comment.
+
+2016-06-13  Andreas Krebbel  <krebbel@linux.vnet.ibm.com>
+
+       Backport from mainline
+       2016-06-13  Andreas Krebbel  <krebbel@linux.vnet.ibm.com>
+
+       PR target/71379
+       * config/s390/s390.c (s390_expand_builtin): Increase MAX_ARGS by
+       one.
+
+2016-06-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+       PR middle-end/71373
+       Backport from trunk r237291:
+       * tree-nested.c (convert_nonlocal_omp_clauses)
+       (convert_local_omp_clauses): Handle OMP_CLAUSE_ASYNC,
+       OMP_CLAUSE_WAIT, OMP_CLAUSE_INDEPENDENT, OMP_CLAUSE_AUTO,
+       OMP_CLAUSE__CACHE_, OMP_CLAUSE_TILE.
+
+       Backport from trunk r237291:
+       * gimplify.c (gimplify_adjust_omp_clauses): Discard
+       OMP_CLAUSE_TILE.
+       * omp-low.c (scan_sharing_clauses): Don't expect OMP_CLAUSE_TILE.
+
+       Backport from trunk r237290:
+       * omp-low.c (scan_sharing_clauses): Don't expect
+       OMP_CLAUSE__CACHE_.
+
+       Backport trunk r235964:
+       2016-05-06  Nathan Sidwell  <nathan@codesourcery.com>
+
+       * gimple.c (gimple_call_same_target_p): Unique functions are eq.
+       * tree-ssa-tail-merge.c (same_succ::equal): Check pointer eq
+       equality first.
+
+2016-06-09  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       Back port from trunk
+       2016-05-31  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       * config/rs6000/vsx.md (vsx_splat_<mode>, V2DI/V2DF): Simplify
+       alternatives, eliminating preferred register class.  Add support
+       for the MTVSRDD instruction in ISA 3.0.
+       (vsx_splat_v4si_internal): Use splat_input_operand instead of
+       reg_or_indexed_operand.
+       (vsx_splat_v4sf_internal): Likewise.
+
+       Back port from trunk
+       2016-05-31  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       PR target/71186
+       * config/rs6000/vsx.md (xxspltib_<mode>_nosplit): Add alternatives
+       for loading up all 0's or all 1's.
+
+       Back port from trunk
+       2016-05-18  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       PR target/70915
+       * config/rs6000/constraints.md (wE constraint): New constraint
+       for a vector constant that can be loaded with XXSPLTIB.
+       (wM constraint): New constraint for a vector constant of a 1's.
+       (wS constraint): New constraint for a vector constant that can be
+       loaded with XXSPLTIB and a vector sign extend instruction.
+       * config/rs6000/predicates.md (xxspltib_constant_split): New
+       predicates for wE/wS constraints.
+       (xxspltib_constant_nosplit): Likewise.
+       (easy_vector_constant): Add support for constants that can be
+       loaded via XXSPLTIB.
+       (splat_input_operand): Add support for ISA 3.0 word splat operations.
+       * config/rs6000/rs6000.c (xxspltib_constant_p): New function to
+       return if a constant can be loaded with the ISA 3.0 XXSPLTIB
+       instruction and possibly with a sign extension.
+       (output_vec_const_move): Add support for XXSPLTIB. If we are
+       loading up 0/-1 into Altivec registers, prefer using VSPLTISW
+       instead of XXLXOR/XXLORC.
+       (rs6000_expand_vector_init): Add support for ISA 3.0 word splat
+       operations.
+       (rs6000_legitimize_reload_address): Likewise.
+       (rs6000_output_move_128bit): Use output_vec_const_move to emit
+       constants.
+       * config/rs6000/vsx.md (VSX_M): Add TImode (if -mvsx-timode) and
+       combine VSX_M and VSX_M2 into one iterator.
+       (VSX_M2): Likewise.
+       (VSINT_84): New iterators for loading constants with XXSPLTIB.
+       (VSINT_842): Likewise.
+       (UNSPEC_VSX_SIGN_EXTEND): New UNSPEC.
+       (xxspltib_v16qi): New insns to load up constants with the ISA 3.0
+       XXSPLTIB instruction.
+       (xxspltib_<mode>_nosplit): Likewise.
+       (xxspltib_<mode>_split): New insn to load up constants with
+       XXSPLTIB and a sign extend instruction.
+       (vsx_mov<mode>): Replace single move that handled all vector types
+       with separate 32-bit and 64-bit moves.  Combine the movti_<bit>
+       moves (when -mvsx-timode is in effect) into the main vector
+       moves.  Eliminate separate moves for <VSr> <VSa>, where the
+       preferred register class (<VSr>) is listed first, and the
+       secondary register class (<VSa>) is listed second with a '?' to
+       discourage use.  Prefer loading 0/-1 in any VSX register for ISA
+       3.0, and Altivec registers for ISA 2.06/2.07 (PR target/70915) so
+       that if the register was involved in a slow operation, the
+       clear/set operation does not wait for the slow operation to
+       finish.  Adjust the length attributes for 32-bit mode.  Use
+       rs6000_output_move_128bit and drop the use of the string
+       instructions for 32-bit movti when -mvsx-timode is in effect.  Use
+       spacing so that the alternatives and attributes don't generate
+       long lines, and put things in columns, so that it is easier to
+       match up the operands and attributes with the insn alternatives.
+       (vsx_mov<mode>_64bit): Likewise.
+       (vsx_mov<mode>_32bit): Likewise.
+       (vsx_movti_64bit): Fold movti into normal vector moves.
+       (vsx_movti_32bit): Likewise.
+       (vsx_splat_<mode>, V4SI/V4SF modes): Add support for ISA 3.0 word
+       splat instructions.
+       (vsx_splat_v4si_internal): Likewise.
+       (vsx_splat_v4sf_internal): Likewise.
+       (vector fusion peepholes): Use VSX_M instead of VSX_M2.
+       (vsx_sign_extend_qi_<mode>): New ISA 3.0 instructions to sign
+       extend vector elements.
+       (vsx_sign_extend_hi_<mode>): Likewise.
+       (vsx_sign_extend_si_v2di): Likewise.
+       * config/rs6000/rs6000-protos.h (xxspltib_constant_p): Add
+       declaration.
+       * doc/md.texi (PowerPC constraints): Document the wE, wM, and wS
+       constraints.  Add trailing period to wL documentation.
+
+2016-06-08  Jose E. Marchesi  <jose.marchesi@oracle.com>
+
+       Backport from mainline
+       2016-06-08  Jose E. Marchesi  <jose.marchesi@oracle.com>
+
+       * config/sparc/driver-sparc.c (cpu_names): Fix the entry for the
+       SPARC-M7 and add an entry for SPARC-S7 cpus (Sonoma).
+
+2016-06-08  Eric Botcazou  <ebotcazou@adacore.com>
+
+       Backport from mainline
+       2016-06-06  Jose E. Marchesi  <jose.marchesi@oracle.com>
+
+       * config/sparc/sparc.md (cpu): Add niagara7 cpu type.
+       Include the M7 SPARC DFA scheduler.
+       New attribute v3pipe.
+       Annotate insns with v3pipe where appropriate.
+       Define cpu_feature vis4.
+       Add lzd instruction type and set it on clzdi_sp64 and clzsi_sp64.
+       Add (V8QI "8") to vbits.
+       Add insns {add,sub}v8qi3
+       Add insns ss{add,sub}v8qi3
+       Add insns us{add,sub}{v8qi,v4hi}3
+       Add insns {min,max}{v8qi,v4hi,v2si}3
+       Add insns {minu,maxu}{v8qi,v4hi,v2si}3
+       Add insns fpcmp{le,gt,ule,ug,ule,ugt}{8,16,32}_vis.
+       * config/sparc/niagara4.md: Add a comment explaining the
+       discrepancy between the documented latenty numbers and the
+       implemented ones.
+       * config/sparc/niagara7.md: New file.
+       * configure.ac (HAVE_AS_SPARC5_VIS4): Define if the assembler
+       supports SPARC5 and VIS 4.0 instructions.
+       * configure: Regenerate.
+       * config.in: Likewise.
+       * config.gcc: niagara7 is a supported cpu in sparc*-*-* targets.
+       * config/sparc/sol2.h (ASM_CPU32_DEFAUILT_SPEC): Set for
+       TARGET_CPU_niagara7.
+       (ASM_CPU64_DEFAULT_SPEC): Likewise.
+       (CPP_CPU_SPEC): Handle niagara7.
+       (ASM_CPU_SPEC): Likewise.
+       * config/sparc/sparc-opts.h (processor_type): Add
+       PROCESSOR_NIAGARA7.
+       (mvis4): New option.
+       * config/sparc/sparc.h (TARGET_CPU_niagara7): Define.
+       (AS_NIAGARA7_FLAG): Define.
+       (ASM_CPU64_DEFAULT_SPEC): Set for niagara7.
+       (CPP_CPU64_DEFAULT_SPEC): Likewise.
+       (CPP_CPU_SPEC): Handle niagara7.
+       (ASM_CPU_SPEC): Likewise.
+       * config/sparc/sparc.c (niagara7_costs): Define.
+       (sparc_option_override): Handle niagara7 and adjust cache-related
+       parameters with better values for niagara cpus.  Also support VIS4.
+       (sparc32_initialize_trampoline): Likewise.
+       (sparc_use_sched_lookahead): Likewise.
+       (sparc_issue_rate): Likewise.
+       (sparc_register_move_cost): Likewise.
+       (dump_target_flag_bits): Support VIS4.
+       (sparc_vis_init_builtins): Likewise.
+       (sparc_builtins): Likewise.
+       * config/sparc/sparc-c.c (sparc_target_macros): Define __VIS__ for
+       VIS4 4.0.
+       * config/sparc/driver-sparc.c (cpu_names): Add SPARC-M7 and
+       UltraSparc M7.
+       * config/sparc/sparc.opt (sparc_processor_type): New value
+       niagara7.
+       * config/sparc/visintrin.h (__attribute__): Prototypes for the
+       VIS4 builtins.
+       * doc/invoke.texi (SPARC Options): Document -mcpu=niagara7 and
+       -mvis4.
+       * doc/extend.texi (SPARC VIS Built-in Functions): Document the
+       VIS4 builtins.
+
+       2016-05-30  Jose E. Marchesi  <jose.marchesi@oracle.com>
+
+       * config.gcc (sparc*-*-*): Support cpu_32, cpu_64, tune_32 and
+       tune_64.
+       * doc/install.texi (--with-cpu-32, --with-cpu-64): Document
+       support on SPARC.
+       * config/sparc/linux64.h (OPTION_DEFAULT_SPECS): Add entries for
+       cpu_32, cpu_64, tune_32 and tune_64.
+       * config/sparc/sol2.h (OPTION_DEFAULT_SPECS): Likewise.
+
+2016-06-08  Ilya Verbin  <ilya.verbin@intel.com>
+
+       Backport from mainline
+       2016-05-25  Ilya Verbin  <ilya.verbin@intel.com>
+
+       * config/i386/i386-builtin-types.def: Add V16SI_FTYPE_V16SF,
+       V8DF_FTYPE_V8DF_ROUND, V16SF_FTYPE_V16SF_ROUND, V16SI_FTYPE_V16SF_ROUND.
+       * config/i386/i386.c (enum ix86_builtins): Add
+       IX86_BUILTIN_CVTPS2DQ512_MASK, IX86_BUILTIN_FLOORPS512,
+       IX86_BUILTIN_FLOORPD512, IX86_BUILTIN_CEILPS512, IX86_BUILTIN_CEILPD512,
+       IX86_BUILTIN_TRUNCPS512, IX86_BUILTIN_TRUNCPD512,
+       IX86_BUILTIN_CVTPS2DQ512, IX86_BUILTIN_VEC_PACK_SFIX512,
+       IX86_BUILTIN_FLOORPS_SFIX512, IX86_BUILTIN_CEILPS_SFIX512,
+       IX86_BUILTIN_ROUNDPS_AZ_SFIX512.
+       (builtin_description bdesc_args): Add __builtin_ia32_floorps512,
+       __builtin_ia32_ceilps512, __builtin_ia32_truncps512,
+       __builtin_ia32_floorpd512, __builtin_ia32_ceilpd512,
+       __builtin_ia32_truncpd512, __builtin_ia32_cvtps2dq512,
+       __builtin_ia32_vec_pack_sfix512, __builtin_ia32_roundps_az_sfix512,
+       __builtin_ia32_floorps_sfix512, __builtin_ia32_ceilps_sfix512.
+       Change IX86_BUILTIN_CVTPS2DQ512 to IX86_BUILTIN_CVTPS2DQ512_MASK for
+       __builtin_ia32_cvtps2dq512_mask.
+       (ix86_expand_args_builtin): Handle V8DF_FTYPE_V8DF_ROUND,
+       V16SF_FTYPE_V16SF_ROUND, V16SI_FTYPE_V16SF_ROUND, V16SI_FTYPE_V16SF.
+       (ix86_builtin_vectorized_function): Handle builtins mentioned above.
+       * config/i386/sse.md
+       (<mask_codefor>avx512f_fix_notruncv16sfv16si<mask_name><round_name>):
+       Rename to ...
+       (avx512f_fix_notruncv16sfv16si<mask_name><round_name>): ... this.
+       (<mask_codefor>avx512f_cvtpd2dq512<mask_name><round_name>): Rename
+       to ...
+       (avx512f_cvtpd2dq512<mask_name><round_name>): ... this.
+       (avx512f_vec_pack_sfix_v8df): New define_expand.
+       (avx512f_roundpd512): Rename to ...
+       (avx512f_round<castmode>512): ... this.  Change iterator.
+       (avx512f_roundps512_sfix): New define_expand.
+       (round<mode>2_sfix): Change iterator.
+
+2016-06-07  Peter Bergner  <bergner@vnet.ibm.com>
+
+       Backport from mainline
+       2016-06-07  Peter Bergner  <bergner@vnet.ibm.com>
+
+       * doc/invoke.texi (RS/6000 and PowerPC Options): Document -mhtm and
+       -mno-htm.
+
+2016-06-07  Uros Bizjak  <ubizjak@gmail.com>
+
+       PR target/71389
+       * config/i386/i386.c (ix86_avx256_split_vector_move_misalign):
+       Copy op1 RTX to avoid invalid sharing.
+       (ix86_expand_vector_move_misalign): Ditto.
+
+2016-06-06  Jakub Jelinek  <jakub@redhat.com>
+
+       PR tree-optimization/71259
+       * tree-vect-slp.c (vect_get_constant_vectors): For
+       VECTOR_BOOLEAN_TYPE_P, return all ones constant instead of
+       one for constant op, and use COND_EXPR for non-constant.
+
+2016-06-06  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+       Backport from trunk
+       2016-06-02  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+       PR target/70830
+       * config/arm/arm.c (arm_output_multireg_pop): Guard "pop" on update.
+
+2016-06-05  Uros Bizjak  <ubizjak@gmail.com>
+
+       Backport from mainline
+       2016-06-01  Uros Bizjak  <ubizjak@gmail.com>
+                   Jocelyn Mayer  <l_indien@magic.fr>
+
+       PR target/67310
+       * config/i386/driver-i386.c (host_detect_local_cpu): Correctly
+       detect processor family for signature_CENTAUR_ebx.
+       <case PROCESSOR_I486>: Pass c3, winchip2 or winchip-c6 for
+       signature_CENTAUR_ebx.
+       <case PROCESSOR _PENTIUMPRO>: Pass c3-2 for signature_CENTAUR_ebx.
+       <default>: Pass x86-64 for has_longmode.
+
+2016-06-03  Jakub Jelinek  <jakub@redhat.com>
+
+       PR middle-end/71387
+       * cgraph.c (cgraph_edge::redirect_call_stmt_to_callee): If redirecting
+       to noreturn e->callee->decl that has void return type and void
+       arguments, adjust gimple_call_fntype and remove lhs even if it had
+       previously addressable type.
+
+2016-06-02  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       Back port from trunk
+       2016-05-26  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       * config/rs6000/rs6000.c (rs6000_emit_p9_fp_minmax): New function
+       for ISA 3.0 min/max support.
+       (rs6000_emit_p9_fp_cmove): New function for ISA 3.0 floating point
+       conditional move support.
+       (rs6000_emit_cmove): Call rs6000_emit_p9_fp_minmax and
+       rs6000_emit_p9_fp_cmove if the ISA 3.0 instructions are
+       available.
+       * config/rs6000/rs6000.md (SFDF2): New iterator to allow doing
+       conditional moves where the comparison type is different from move
+       type.
+       (fp_minmax): New code iterator for smin/smax.
+       (minmax): New code attributes for min/max.
+       (SMINMAX): Likewise.
+       (smax<mode>3): Combine min, max insns into one insn using the
+       fp_minmax code iterator.  Add support for ISA 3.0 min/max
+       instructions that don't need -ffast-math.
+       (s<minmax><mode>3): Likewise.
+       (smax<mode>3_vsx): Likewise.
+       (smin<mode>3): Likewise.
+       (s<minmax><mode>3_vsx): Likewise.
+       (smin<mode>3_vsx): Likewise.
+       (pre-VSX min/max splitters): Likewise.
+       (s<minmax><mode>3_fpr): Likewise.
+       (movsfcc): Rewrite floating point conditional moves to combine
+       SFmode/DFmode into a single insn.
+       (mov<mode>cc): Likewise.
+       (movdfcc): Likewise.
+       (fselsfsf4): Combine FSEL cases into a single insn, using SFDF and
+       SFDF2 iterators to handle all combinations.
+       (fseldfsf4): Likewise.
+       (fsel<SFDF:mode><SFDF2:mode>4): Likewise.
+       (fseldfdf4): Likewise.
+       (fselsfdf4): Likewise.
+       (mov<SFDF:mode><SFDF2:mode>cc_p9): Add support for the ISA 3.0
+       comparison instructions that set a 0/-1 mask, and use it for
+       floating point conditional move via XXSEL.
+       (fpmask<mode>): Likewise.
+       (xxsel<mode>): Likewise.
+       * config/rs6000/predicates.md (min_max_operator): Delete, no
+       longer used.
+       (fpmask_comparison_operaton): New insn for ISA 3.0 comparison
+       instructions that generate a 0/-1 mask for use with XXSEL.
+       * config/rs6000/rs6000.h (TARGET_MINMAX_SF): New helper macros to
+       say whether floating point min/max is available, either through
+       FSEL, ISA 2.06 min/max, and ISA 3.0 min/max instrucitons.
+       (TARGET_MINMAX_DF): Likewise.
+
+       Back port from trunk
+       2016-05-18  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       * config/rs6000/predicate.md (all_ones_constant): New predicate
+       for vector constant with all 1's set.
+
+2016-06-02  Kelvin Nilsen  <kelvin@gcc.gnu.org>
+
+       Back port from trunk
+       2016-05-19  Kelvin Nilsen  <kelvin@gcc.gnu.org>
+
+       * config/rs6000/altivec.md (UNSPEC_DARN): New unspec constant.
+       (UNSPEC_DARN_32): New unspec constant.
+       (UNSPEC_DARN_RAW): New unspec constant.
+       (darn_32): New instruction.
+       (darn_raw): New instruction.
+       (darn): New instruction.
+       * config/rs6000/rs6000-builtin.def (RS6000_BUILTIN_0): Add
+       support and documentation for this macro.
+       (BU_P9_MISC_1): New macro definition.
+       (BU_P9_64BIT_MISC_0): New macro definition.
+       (BU_P9_MISC_0): New macro definition.
+       (darn_32): New builtin definition.
+       (darn_raw): New builtin definition.
+       (darn): New builtin definition.
+       * config/rs6000/rs6000.c: Add #define RS6000_BUILTIN_0 and #undef
+       RS6000_BUILTIN_0 directives to surround each occurrence of
+       #include "rs6000-builtin.def".
+       (rs6000_builtin_mask_calculate): Add in the RS6000_BTM_MODULO and
+       RS6000_BTM_64BIT flags to the returned mask, depending on
+       configuration.
+       (def_builtin): Correct an error in the assignments made to the
+       debugging variable attr_string.
+       (rs6000_expand_builtin): Add support for no-operand built-in
+       functions.
+       (builtin_function_type): Remove fatal_error assertion that is no
+       longer valid.
+       (rs6000_common_init_builtins): Add support for no-operand built-in
+       functions.
+       * config/rs6000/rs6000.h (RS6000_BTM_MODULO): New macro
+       definition.
+       (RS6000_BTM_PURE): Enhance comment to clarify intent of this flag
+       definition.
+       (RS6000_BTM_64BIT): New macro definition.
+       * doc/extend.texi: Document __builtin_darn (void),
+       __builtin_darn_raw (void), and __builtin_darn_32 (void) built-in
+       functions.
+
+2016-06-01  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       Back port from trunk
+       2016-05-23  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       PR target/71201
+       * config/rs6000/altivec.md (altivec_vperm_<mode>_internal): Drop
+       ISA 3.0 xxperm fusion alternative.
+       (altivec_vperm_v8hiv16qi): Likewise.
+       (altivec_vperm_<mode>_uns_internal): Likewise.
+       (vperm_v8hiv4si): Likewise.
+       (vperm_v16qiv8hi): Likewise.
+
+       Back port from trunk
+       2016-05-23  Michael Meissner  <meissner@linux.vnet.ibm.com>
+                   Kelvin Nilsen  <kelvin@gcc.gnu.org>
+
+       * config/rs6000/rs6000.c (rs6000_expand_vector_set): Generate
+       vpermr/xxpermr on ISA 3.0.
+       (altivec_expand_vec_perm_le): Likewise.
+       * config/rs6000/altivec.md (UNSPEC_VPERMR): New unspec.
+       (altivec_vpermr_<mode>_internal): Add VPERMR/XXPERMR support for
+       ISA 3.0.
+
+       Back port from trunk
+       2016-05-24  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       * config/rs6000/altivec.md (VParity): New mode iterator for vector
+       parity built-in functions.
+       (p9v_ctz<mode>2): Add support for ISA 3.0 vector count trailing
+       zeros.
+       (p9v_parity<mode>2): Likewise.
+       * config/rs6000/vector.md (VEC_IP): New mode iterator for vector
+       parity.
+       (ctz<mode>2): ISA 3.0 expander for vector count trailing zeros.
+       (parity<mode>2): ISA 3.0 expander for vector parity.
+       * config/rs6000/rs6000-builtin.def (BU_P9_MISC_1): New macros for
+       power9 built-ins.
+       (BU_P9_64BIT_MISC_0): Likewise.
+       (BU_P9_MISC_0): Likewise.
+       (BU_P9V_AV_1): Likewise.
+       (BU_P9V_AV_2): Likewise.
+       (BU_P9V_AV_3): Likewise.
+       (BU_P9V_AV_P): Likewise.
+       (BU_P9V_VSX_1): Likewise.
+       (BU_P9V_OVERLOAD_1): Likewise.
+       (BU_P9V_OVERLOAD_2): Likewise.
+       (BU_P9V_OVERLOAD_3): Likewise.
+       (VCTZB): Add vector count trailing zeros support.
+       (VCTZH): Likewise.
+       (VCTZW): Likewise.
+       (VCTZD): Likewise.
+       (VPRTYBD): Add vector parity support.
+       (VPRTYBQ): Likewise.
+       (VPRTYBW): Likewise.
+       (VCTZ): Add overloaded vector count trailing zeros support.
+       (VPRTYB): Add overloaded vector parity support.
+       * config/rs6000/rs6000-c.c (altivec_overloaded_builtins): Add
+       overloaded vector count trailing zeros and parity instructions.
+       * config/rs6000/rs6000.md (wd mode attribute): Add V1TI and TI for
+       vector parity support.
+       * config/rs6000/altivec.h (vec_vctz): Add ISA 3.0 vector count
+       trailing zeros support.
+       (vec_cntlz): Likewise.
+       (vec_vctzb): Likewise.
+       (vec_vctzd): Likewise.
+       (vec_vctzh): Likewise.
+       (vec_vctzw): Likewise.
+       (vec_vprtyb): Add ISA 3.0 vector parity support.
+       (vec_vprtybd): Likewise.
+       (vec_vprtybw): Likewise.
+       (vec_vprtybq): Likewise.
+       * doc/extend.texi (PowerPC AltiVec Built-in Functions): Document
+       the ISA 3.0 vector count trailing zeros and vector parity built-in
+       functions.
+
+       Back port from trunk
+       2016-05-24  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       * config/rs6000/altivec.md (VNEG iterator): New iterator for
+       VNEGW/VNEGD instructions.
+       (p9_neg<mode>2): New insns for ISA 3.0 VNEGW/VNEGD.
+       (neg<mode>2): Add expander for V2DImode added in ISA 2.07, and
+       support for ISA 3.0 VNEGW/VNEGD instructions.
+
+       Back port from trunk
+       2016-05-11  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       * config/rs6000/predicates.md (quad_memory_operand): Move most of
+       the code into quad_address_p and call it to share code with
+       vsx_quad_dform_memory_operand.
+       (vsx_quad_dform_memory_operand): New predicate for ISA 3.0 vector
+       d-form support.
+       * config/rs6000/rs6000.opt (-mlra): Switch to being an option mask
+       bit instead of being a separate word.  Split -mpower9-dform into
+       two switches, -mpower9-dform-scalar and -mpower9-dform-vector.
+       * config/rs6000/rs6000.c (RELOAD_REG_QUAD_OFFSET): New addr_mask
+       for the register class supporting 128-bit quad word memory offsets.
+       (mode_supports_vsx_dform_quad): Helper function to return if the
+       register class uses quad word memory offsets.
+       (rs6000_debug_addr_mask): Add support for quad word memory offsets.
+       (rs6000_debug_reg_global): Always print if we are using LRA or not.
+       (rs6000_setup_reg_addr_masks): If ISA 3.0 vector d-form
+       instructions are enabled, set up the appropriate addr_masks for
+       128-bit types.
+       (rs6000_init_hard_regno_mode_ok): wb constraint is now based on
+       -mpower9-dform-scalar, instead of -mpower9-dform.
+       (rs6000_option_override_internal): Split -mpower9-dform into two
+       switches, -mpower9-dform-scalar and -mpower9-dform-vector.  The
+       -mpower9-dform switch sets or clears both.  If we are not using
+       the LRA register allocator, do not enable -mpower9-dform-vector by
+       default.  If we are using LRA, enable -mpower9-dform-vector and
+       -mvsx-timode if it is appropriate.  Issue a warning if either
+       -mpower9-dform-vector or -mvsx-timode are explicitly used without
+       enabling LRA.
+       (quad_address_offset_p): New helper function to return if the
+       offset is legal for quad word memory instructions.
+       (quad_address_p): New function to determin if GPR or vector
+       register quad word memory addresses are legal.
+       (mem_operand_gpr): Validate quad word address offsets.
+       (reg_offset_addressing_ok_p): Add support for ISA 3.0 vector
+       d-form (register + offset) instructions.
+       (offsettable_ok_by_alignment): Likewise.
+       (rs6000_legitimate_offset_address_p): Likewise.
+       (legitimate_lo_sum_address_p): Likewise.
+       (rs6000_legitimize_address): Likewise.
+       (rs6000_legitimize_reload_address): Add more debug statements for
+       -mdebug=addr.
+       (rs6000_legitimate_address_p): Add support for ISA 3.0 vector
+       d-form instructions.
+       (rs6000_secondary_reload_memory): Add support for ISA 3.0 vector
+       d-form instructions.  Distinguish different cases in debug
+       output. (rs6000_secondary_reload_inner): Add support for ISA 3.0 vector
+       d-form instructions.
+       (rs6000_preferred_reload_class): Likewise.
+       (rs6000_output_move_128bit): Add support for ISA 3.0 d-form
+       instructions.  If ISA 3.0 is available, generate lxvx/stxvx instead
+       of the ISA 2.06 indexed memory instructions.
+       (rs6000_emit_prologue): If we have ISA 3.0 d-form instructions,
+       use them to save/restore the saved vector registers instead of
+       using Altivec instructions.
+       (rs6000_emit_epilogue): Likewise.
+       (rs6000_lra_p): Use TARGET_LRA instead of the old option word.
+       (rs6000_opt_masks): Split -mpower9-dform into
+       -mpower9-dform-scalar and -mpower9-dform-vector.
+       (rs6000_print_options_internal): Print -mno-<switch> if <switch>
+       was not selected.
+       * config/rs6000/vsx.md (p9_vecload_<mode>): Delete hack to emit
+       ISA 3.0 vector indexed memory instructions, and fold the code into
+       the normal mov<mode> patterns.
+       (p9_vecstore_<mode>): Likewise.
+       (vsx_mov<mode>): Add support for ISA 3.0 vector d-form
+       instructions.
+       (vsx_movti_64bit): Likewise.
+       (vsx_movti_32bit): Likewise.
+       * config/rs6000/constraints.md (wO constraint): New constraint for
+       ISA 3.0 vector d-form support.
+       * config/rs6000/rs6000-cpus.def (ISA_3_0_MASKS_SERVER): Use
+       -mpower9-dform-scalar instead of -mpower9-dform.  Add note not to
+       include -mpower9-dform-vector until we switch over to LRA.
+       (POWERPC_MASKS): Add -mlra. Split -mpower9-dform into two.
+       switches, -mpower9-dform-scalar and -mpower9-dform-vector.
+       * config/rs6000/rs6000-protos.h (quad_address_p): Add declaration.
+       * doc/invoke.texi (RS/6000 and PowerPC Options): Add documentation
+       for -mpower9-dform and -mlra.
+       * doc/md.texi (wO constraint): Document wO constraint.
+
+2016-06-01  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * tree-vect-loop.c (vect_determine_vectorization_factor): Also compute
+       the factor for live Phi nodes.
+
+2016-06-01  Jakub Jelinek  <jakub@redhat.com>
+
+       PR middle-end/71371
+       * gimplify.c (gimplify_omp_for): Temporarily clear gimplify_omp_ctxp
+       around creation of the temporary.
+
+2016-06-01  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * tree-vect-loop.c (vect_determine_vectorization_factor): Also take
+       into account live statements for mask producers.
+
+2016-05-31  Richard Biener  <rguenther@suse.de>
+
+       Backport from mainline
+       2016-05-11  Richard Biener  <rguenther@suse.de>
+
+       PR debug/71057
+       * dwarf2out.c (retry_incomplete_types): Set early_dwarf.
+       (dwarf2out_finish): Move retry_incomplete_types call ...
+       (dwarf2out_early_finish): ... here.
+
+2016-05-31  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+       PR target/71056
+       * config/arm/arm-builtins.c (arm_builtin_vectorized_function): Return
+       NULL_TREE early if NEON is not available.  Remove now redundant check
+       in ARM_CHECK_BUILTIN_MODE.
+
+2016-05-31  Tom de Vries  <tom@codesourcery.com>
+
+       backport:
+       2016-05-31  Tom de Vries  <tom@codesourcery.com>
+
+       PR tree-optimization/69068
+       * graphite-isl-ast-to-gimple.c (copy_bb_and_scalar_dependences): Handle
+       phis with more than two args.
+
+2016-05-30  Andreas Tobler  <andreast@gcc.gnu.org>
+
+       Backport from mainline
+       2016-05-30  Andreas Tobler  <andreast@gcc.gnu.org>
+
+       * config.gcc: Move hard float support for arm*hf*-*-freebsd* into
+       armv6*-*-freebsd* for FreeBSD 11. Eliminate the arm*hf*-*-freebsd*
+       target.
+
+2016-05-30  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+       Backport from mainline
+       2016-04-29  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+       * config/rs6000/altivec.h: Change definitions of vec_xl and
+       vec_xst.
+       * config/rs6000/rs6000-builtin.def (LD_ELEMREV_V2DF): New.
+       (LD_ELEMREV_V2DI): New.
+       (LD_ELEMREV_V4SF): New.
+       (LD_ELEMREV_V4SI): New.
+       (LD_ELEMREV_V8HI): New.
+       (LD_ELEMREV_V16QI): New.
+       (ST_ELEMREV_V2DF): New.
+       (ST_ELEMREV_V2DI): New.
+       (ST_ELEMREV_V4SF): New.
+       (ST_ELEMREV_V4SI): New.
+       (ST_ELEMREV_V8HI): New.
+       (ST_ELEMREV_V16QI): New.
+       (XL): New.
+       (XST): New.
+       * config/rs6000/rs6000-c.c (altivec_overloaded_builtins): Add
+       descriptions for VSX_BUILTIN_VEC_XL and VSX_BUILTIN_VEC_XST.
+       * config/rs6000/rs6000.c (rs6000_builtin_mask_calculate): Map from
+       TARGET_P9_VECTOR to RS6000_BTM_P9_VECTOR.
+       (altivec_expand_builtin): Add handling for
+       VSX_BUILTIN_ST_ELEMREV_<MODE> and VSX_BUILTIN_LD_ELEMREV_<MODE>.
+       (rs6000_invalid_builtin): Add error-checking for
+       RS6000_BTM_P9_VECTOR.
+       (altivec_init_builtins): Define builtins used to implement vec_xl
+       and vec_xst.
+       (rs6000_builtin_mask_names): Define power9-vector.
+       * config/rs6000/rs6000.h (MASK_P9_VECTOR): Define.
+       (RS6000_BTM_P9_VECTOR): Define.
+       (RS6000_BTM_COMMON): Include RS6000_BTM_P9_VECTOR.
+       * config/rs6000/vsx.md (vsx_ld_elemrev_v2di): New define_insn.
+       (vsx_ld_elemrev_v2df): Likewise.
+       (vsx_ld_elemrev_v4sf): Likewise.
+       (vsx_ld_elemrev_v4si): Likewise.
+       (vsx_ld_elemrev_v8hi): Likewise.
+       (vsx_ld_elemrev_v16qi): Likewise.
+       (vsx_st_elemrev_v2df): Likewise.
+       (vsx_st_elemrev_v2di): Likewise.
+       (vsx_st_elemrev_v4sf): Likewise.
+       (vsx_st_elemrev_v4si): Likewise.
+       (vsx_st_elemrev_v8hi): Likewise.
+       (vsx_st_elemrev_v16qi): Likewise.
+       * doc/extend.texi: Add prototypes for vec_xl and vec_xst.  Correct
+       grammar.
+
+2016-05-30  Richard Biener  <rguenther@suse.de>
+
+       Backport from mainline
+       2016-05-11  Richard Biener  <rguenther@suse.de>
+
+       PR middle-end/71002
+       * alias.c (reference_alias_ptr_type): Preserve alias-set zero
+       if the langhook insists on it.
+       * fold-const.c (make_bit_field_ref): Add arg for the original
+       reference and preserve its alias-set.
+       (decode_field_reference): Take exp by reference and adjust it
+       to the original memory reference.
+       (optimize_bit_field_compare): Adjust callers.
+       (fold_truth_andor_1): Likewise.
+
+       2016-05-13  Jakub Jelinek  <jakub@redhat.com>
+
+       PR bootstrap/71071
+       * fold-const.c (fold_checksum_tree): Allow modification
+       of TYPE_ALIAS_SET during folding.
+
+2016-05-30  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * config/visium/visium.c (visium_split_double_add): Minor tweaks.
+       (visium_expand_copysign): Use gen_int_mode directly.
+       (visium_compute_frame_size): Minor tweaks.
+
+2016-05-30  Tom de Vries  <tom@codesourcery.com>
+
+       backport:
+       2016-05-30  Tom de Vries  <tom@codesourcery.com>
+
+       PR tree-optimization/69067
+       * graphite-isl-ast-to-gimple.c (get_def_bb_for_const): Remove assert.
+
+2016-05-27  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * config/visium/visium-protos.h (split_double_move): Rename into...
+       (visium_split_double_move): ...this.
+       (visium_split_double_add): Declare.
+       * config/visium/visium.c (split_double_move): Rename into...
+       (visium_split_double_move): ...this.
+       (visium_split_double_add): New function.
+       (visium_expand_copysign): Renumber operands for consistency.
+       * config/visium/visium.md (DImode move splitter): Adjust to renaming.
+       (DFmode move splitter): Likewise.
+       (*addi3_insn): Split by means of visium_split_double_add.
+       (*adddi3_insn_flags): Delete.
+       (*plus_plus_sltu<subst_arith>): New insn.
+       (*subdi3_insn): Split by means of visium_split_double_add.
+       (subdi3_insn_flags): Delete.
+       (*minus_minus_sltu<subst_arith>): New insn.
+       (*negdi2_insn): Split by means of visium_split_double_add.
+       (*negdi2_insn_flags): Delete.
+
+2016-05-27  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       Backport from mainline r236810.
+       2016-05-27  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       PR middle-end/71279
+       * fold-const.c (fold_ternary_loc): Don't fold VEC_COND_EXPR
+       into comparison.
+
+2016-05-25  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * tree-ssa-phiopt.c (factor_out_conditional_conversion): Remove
+       redundant test and bail out if the type of the new operand is not
+       a GIMPLE register type after stripping a VIEW_CONVERT_EXPR.
+
+2016-05-24  Martin Sebor  <msebor@redhat.com>
+
+       PR c++/71147
+       * tree.h (complete_or_array_type_p): New inline function.
+
+2016-05-24  Jakub Jelinek  <jakub@redhat.com>
+
+       * config/i386/i386.h (TARGET_AVOID_4BYTE_PREFIXES): Define.
+       * config/i386/constraints.md (Yr): Test TARGET_AVOID_4BYTE_PREFIXES
+       rather than X86_TUNE_AVOID_4BYTE_PREFIXES.  Use SSE_REGS instead
+       of ALL_SSE_REGS.  Return SSE_REGS also when TARGET_AVX.
+
+2016-05-24  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71257
+       * tree-vect-stmts.c (vectorizable_simd_clone_call): Handle
+       SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP like
+       SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP.  Add
+       SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP and
+       SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP cases explicitly.
+
+2016-05-23  Martin Jambor  <mjambor@suse.cz>
+
+       * hsa-gen.c (gen_hsa_insns_for_switch_stmt): Create an empty
+       default block if a PHI node in the original one would be resized.
+
+2016-05-23  Martin Jambor  <mjambor@suse.cz>
+
+       PR tree-optimization/70884
+       * tree-sra.c (initialize_constant_pool_replacements): Do not check
+       should_scalarize_away_bitmap and cannot_scalarize_away_bitmap bits.
+       (sort_and_splice_var_accesses): Do not consider multiple scalar reads
+       of constant pool data as a reason for scalarization.
+
+2016-05-20  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * config/arm/arm.c (arm_expand_prologue): Set the stack usage to 0
+       for naked functions.
+       (thumb1_expand_prologue): Likewise.
+
+2016-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71210
+       * gimple-fold.c (gimple_fold_call): Do not remove lhs of noreturn
+       calls if the LHS is variable length or has addressable type.
+       If targets[0]->decl is a noreturn call with void return type and
+       zero arguments, adjust fntype and remove lhs in that case.
+
+2016-05-20  Uros Bizjak  <ubizjak@gmail.com>
+
+       * sched-deps.c (sched_analyze_2) <case TRAP_IF>: Also
+       force pending loads from memory.
+
+2016-05-19  Marek Polacek  <polacek@redhat.com>
+
+       Backport from mainline
+       2016-05-19  Marek Polacek  <polacek@redhat.com>
+
+       PR tree-optimization/71031
+       * tree-vrp.c (extract_range_from_binary_expr_1): Turn assert into a
+       condition and adjust the code a bit.
+
+2016-05-19  Martin Jambor  <mjambor@suse.cz>
+
+       PR ipa/70646
+       * ipa-prop.c (determine_locally_known_aggregate_parts): Bail out early
+       if parameter PARAM_IPA_MAX_AGG_ITEMS is zero.
+
+2016-05-19  Martin Jambor  <mjambor@suse.cz>
+
+       PR ipa/70646
+       * ipa-inline.h (condition): New field size.
+       * ipa-inline-analysis.c (add_condition): New parameter SIZE, use it
+       for comaprison and store it into the new condition.
+       (evaluate_conditions_for_known_args): Use condition size to check
+       access sizes for all but CHANGED conditions.
+       (unmodified_parm_1): New parameter size_p, store access size into it.
+       (unmodified_parm): Likewise.
+       (unmodified_parm_or_parm_agg_item): Likewise.
+       (eliminated_by_inlining_prob): Pass NULL to unmodified_parm as size_p.
+       (set_cond_stmt_execution_predicate): Extract access sizes and store
+       them to conditions.
+       (set_switch_stmt_execution_predicate): Likewise.
+       (will_be_nonconstant_expr_predicate): Likewise.
+       (will_be_nonconstant_predicate): Likewise.
+       (inline_read_section): Stream condition size.
+       (inline_write_summary): Likewise.
+       * lto-streamer.h (LTO_minor_version): Bump.
+
+2016-05-18  Martin Liska  <mliska@suse.cz>
+
+       Backport from mainline
+       2016-05-18  Martin Liska  <mliska@suse.cz>
+
+       PR fortran/70856
+       * ipa-icf.c (sem_variable::merge): Set DECL_PT_UID for
+       merged variables.
+
+2016-05-18  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71100
+       * cgraph.c (cgraph_edge::redirect_call_stmt_to_callee): Don't drop
+       lhs if it has TREE_ADDRESSABLE type.
+
+2016-05-18  Uros Bizjak  <ubizjak@gmail.com>
+
+       PR target/71145
+       * config/alpha/alpha.md (trap): Add (use (reg:DI 29)).
+       (*exception_receiver_1): Return "#" for TARGET_EXPLICIT_RELOCS.
+
+2016-05-17  Thomas Schwinge  <thomas@codesourcery.com>
+
+       Backport trunk r235748:
+       PR target/70860
+       * config/nvptx/nvptx.c (nvptx_libcall_value): Handle NULL cfun.
+       (nvptx_function_value): Assert non-NULL cfun.
+
+2016-05-17  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+       Backport from mainline
+       2016-05-17  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+       PR target/70809
+       * config/aarch64/aarch64-simd.md (aarch64_vmls<mode>): Delete.
+
+2016-05-16  Martin Jambor  <mjambor@suse.cz>
+
+       * hsa-gen.c (fillup_for_decl): Increase alignment to natural one.
+       (get_symbol_for_decl): Sorry if a global symbol in under-aligned.
+
+2016-05-16  Martin Jambor  <mjambor@suse.cz>
+
+       PR hsa/70857
+       * omp-low.c (grid_expand_target_grid_body): Copy RESULT_DECL of
+       the outlined kernel function.
+
+2016-05-16  James Norris  <jnorris@codesourcery.com>
+
+       Backport from mainline r236098.
+       2016-05-10  James Norris  <jnorris@codesourcery.com>
+
+       PR driver/68463
+       * config/rs6000/sysv4.h (CRTOFFLOADBEGIN): Define. Add crtoffloadbegin.o
+       if offloading is enabled and -fopenacc or -fopenmp is specified.
+       (CRTOFFLOADEND): Likewise.
+       (STARTFILE_LINUX_SPEC): Add CRTOFFLOADBEGIN.
+       (ENDFILE_LINUX_SPEC): Add CRTOFFLOADEND.
+
+2016-05-16  Alan Modra  <amodra@gmail.com>
+
+       Apply from mainline
+       2016-05-10  Alan Modra  <amodra@gmail.com>
+       PR target/70947
+       * config/rs6000/rs6000.c (rs6000_expand_split_stack_prologue): Stop
+       regrename modifying insns saving lr before __morestack call.
+       * config/rs6000/rs6000.md (split_stack_return): Similarly for
+       insns restoring lr after __morestack call.
+
+2016-05-13  Richard Biener  <rguenther@suse.de>
+
+       Backport from mainline
+       2016-04-27  Richard Biener  <rguenther@suse.de>
+
+       PR ipa/70760
+       * tree-ssa-structalias.c (find_func_aliases_for_call): Use
+       aggregate_value_p to determine if a function result is
+       returned by reference.
+
+       2016-05-06  Richard Biener  <rguenther@suse.de>
+
+       PR middle-end/70931
+       * dwarf2out.c (native_encode_initializer): Skip zero-sized fields.
+
+       2016-05-06  Richard Biener  <rguenther@suse.de>
+
+       PR middle-end/70941
+       * fold-const.c (split_tree): Always convert to the original type
+       before negating.
+
+2016-05-12  Martin Liska  <mliska@suse.cz>
+
+       Backport from mainline
+       2016-05-10  Martin Liska  <mliska@suse.cz>
+
+       * tree-inline.c (remap_dependence_clique): Do not remap
+       debugging statements.
+
+2016-05-12  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       Backport from mainline r236171.
+       2016-05-12  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       PR tree-optimization/71006
+       * tree-vect-loop.c (vect_determine_vectorization_factor): Don't
+       consider COND_EXPR as a mask producer.
+
+2016-05-12  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+       Backport from mainline
+       2016-05-12  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+       PR target/70830
+       * config/arm/arm.c (arm_output_multireg_pop): Avoid POP instruction
+       when popping the PC and within an interrupt handler routine.
+       Add missing tab to output of "ldmfd".
+       (output_return_instruction): Output LDMFD with SP update rather
+       than POP when returning from interrupt handler.
+
+2016-05-11  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       Backport from mainline r236088.
+       2016-05-10  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       PR middle-end/70877
+       * tree-chkp.c (chkp_add_bounds_to_call_stmt): Handle
+       calls with type casted fndecl.
+
+2016-05-11  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       Backport from mainline r236086.
+       2016-05-10  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       PR tree-optimization/70876
+       * tree-chkp.c (chkp_find_bounds_1): Support WITH_SIZE_EXPR.
+       * gcc/calls.c (initialize_argument_information): Bind bounds
+       with corresponding args passed by reference.
+
+2016-05-10  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+       Backport from mainline
+       2016-05-10  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+       PR target/70963
+       * config/rs6000/vsx.md (vsx_xvcvdpsxds_scale): Generate correct
+       code for a zero scale factor.
+       (vsx_xvcvdpuxds_scale): Likewise.
+
+2016-05-10  Jakub Jelinek  <jakub@redhat.com>
+
+       Backported from mainline
+       2016-05-03  Jakub Jelinek  <jakub@redhat.com>
+
+       PR tree-optimization/70916
+       * tree-vect-patterns.c (vect_recog_mask_conversion_pattern): Give up
+       if COND_EXPR rhs1 is neither SSA_NAME nor COMPARISON_CLASS_P.
+
+2016-05-10  Yuri Rumyantsev  <ysrumyan@gmail.com>
+
+       Backport from mainline r235962.
+       2016-05-06  Yuri Rumyantsev  <ysrumyan@gmail.com>
+
+       PR debug/70935
+       * tree-ssa-loop-unswitch.c (find_loop_guard): Reject guard edge with
+       loop latch destination.
+
+2016-05-10  Andreas Krebbel  <krebbel@linux.vnet.ibm.com>
+
+       Backport from mainline
+       2016-05-10  Andreas Krebbel  <krebbel@linux.vnet.ibm.com>
+
+       * config/s390/s390.md ("*vec_cmp<insn_cmp>df_cconly")
+       ("*fixuns_truncdfdi2_z13")
+       ("*fixuns_trunc<FP:mode><GPR:mode>2_z196")
+       ("*fix_truncdfdi2_bfp_z13", "*floatunsdidf2_z13")
+       ("*extendsfdf2_z13"): Replace TARGET_Z13 with TARGET_VX.
+
+2016-05-10  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+       Backport from mainline
+       2016-04-27  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+       * config/rtems.h (LIB_SPEC): Add -latomic.
+
+2016-05-10  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+       Backport from mainline
+       2016-04-27  Joel Sherrill  <joel@rtems.org>
+
+       * config/microblaze/rtems.h: Redefine LINK_SPEC to avoid
+       xilink.ld and flags not relevant to RTEMS.
+
+2016-05-09  Uros Bizjak  <ubizjak@gmail.com>
+
+       * config/i386/i386.md (absneg splitters with general regs): Use
+       general_reg_operand predicate.
+       (btsq peephole2): Use x86_64_immediate_operand to check if new
+       value is suitable for immediate operand.  Generate emitted insn
+       using RTL expressions.
+       (btcq peephole2): Ditto.
+       (btrq peephole2): Ditto.  Generate correct immediate operand
+       for AND masking.
+
  2016-05-07  Tom de Vries  <tom@codesourcery.com>
  
         backport:
@@ -158,7 +1219,7 @@
         constant boolean.
  
  2016-04-20  Andrew Pinski  <apinski@cavium.com>
-            Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+           Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
  
         PR target/64971
         * config/aarch64/aarch64.md (sibcall): Force call
diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP

index 7aaf7de..8cee680 100644 (file)
--- a/gcc/DATESTAMP
+++ b/gcc/DATESTAMP
@@ -1 +1 @@
-20160509
+20160615
diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog

index 9856530..233e097 100644 (file)
--- a/gcc/ada/ChangeLog
+++ b/gcc/ada/ChangeLog
@@ -1,3 +1,50 @@
+2016-06-13  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * gcc-interface/decl.c (gnat_to_gnu_entity) <E_Variable>: Deal with
+       PLUS_EXPR in the expression of a renaming.
+
+2016-06-11  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * gcc-interface/trans.c (Case_Statement_to_gnu): Deal with characters.
+
+2016-06-11  Pierre-Marie de Rodat  <derodat@adacore.com>
+
+       * gcc-interface/decl.c (gnat_to_gnu_entity): Do not clobber
+       gnat_entity_name with temporary names for XUP and XUT types.
+
+2016-06-06  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * gcc-interface/utils.c (gnat_internal_attribute_table): Add support
+       for noinline and noclone attributes.
+       (handle_noinline_attribute): New handler.
+       (handle_noclone_attribute): Likewise.
+
+2016-06-06  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * gcc-interface/utils2.c (build_call_alloc_dealloc): Do not substitute
+       placeholder expressions here but...
+       * gcc-interface/trans.c (gnat_to_gnu) <N_Free_Statement>: ...here.
+       Make an exception to the protection of a CALL_EXPR result with an
+       unconstrained type only in the same cases as Call_to_gnu.
+
+2016-06-01  Simon Wright  <simon@pushface.org>
+
+       PR ada/71358
+       * g-comlin.adb (Display_Section_Help): Do not dereference
+       Config.Switches if it's null.
+       (Getopt): Likewise.
+
+2016-05-31  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * s-osinte-kfreebsd-gnu.ads (clock_getres): Define.
+       (Get_Page_Size): Remove duplicate and return int.
+
+2016-05-31  Jan Sommer  <soja-lists@aries.uberspace.de>
+
+       PR ada/71317
+       * s-osinte-rtems.ads (clock_getres): Define.
+       (Get_Page_Size): Remove duplicate and return int.
+
  2016-05-06  Eric Botcazou  <ebotcazou@adacore.com>
  
         PR ada/70969
diff --git a/gcc/ada/g-comlin.adb b/gcc/ada/g-comlin.adb

index de2f3f9..172edaf 100644 (file)
--- a/gcc/ada/g-comlin.adb
+++ b/gcc/ada/g-comlin.adb
@@ -6,7 +6,7 @@
  --                                                                          --
  --                                 B o d y                                  --
  --                                                                          --
---          Copyright (C) 1999-2015, Free Software Foundation, Inc.         --
+--          Copyright (C) 1999-2016, Free Software Foundation, Inc.         --
  --                                                                          --
  -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  -- terms of the  GNU General Public License as published  by the Free Soft- --
@@ -3151,16 +3151,18 @@ package body GNAT.Command_Line is
  
           New_Line;
  
-         if Section /= "" then
+         if Section /= "" and then Config.Switches /= null then
              Put_Line ("Switches after " & Section);
           end if;
  
           --  Compute size of the switches column
  
-         for S in Config.Switches'Range loop
-            Max_Len := Natural'Max
-              (Max_Len, Switch_Name (Config.Switches (S), Section)'Length);
-         end loop;
+         if Config.Switches /= null then
+            for S in Config.Switches'Range loop
+               Max_Len := Natural'Max
+                 (Max_Len, Switch_Name (Config.Switches (S), Section)'Length);
+            end loop;
+         end if;
  
           if Config.Aliases /= null then
              for A in Config.Aliases'Range loop
@@ -3173,25 +3175,27 @@ package body GNAT.Command_Line is
  
           --  Display the switches
  
-         for S in Config.Switches'Range loop
-            declare
-               N : constant String :=
-                     Switch_Name (Config.Switches (S), Section);
+         if Config.Switches /= null then
+            for S in Config.Switches'Range loop
+               declare
+                  N : constant String :=
+                    Switch_Name (Config.Switches (S), Section);
  
-            begin
-               if N /= "" then
-                  Put (" ");
-                  Put (N);
-                  Put ((1 .. Max_Len - N'Length + 1 => ' '));
+               begin
+                  if N /= "" then
+                     Put (" ");
+                     Put (N);
+                     Put ((1 .. Max_Len - N'Length + 1 => ' '));
  
-                  if Config.Switches (S).Help /= null then
-                     Put (Config.Switches (S).Help.all);
-                  end if;
+                     if Config.Switches (S).Help /= null then
+                        Put (Config.Switches (S).Help.all);
+                     end if;
  
-                  New_Line;
-               end if;
-            end;
-         end loop;
+                     New_Line;
+                  end if;
+               end;
+            end loop;
+         end if;
  
           --  Display the aliases
  
@@ -3454,25 +3458,27 @@ package body GNAT.Command_Line is
  
        --  Initialize output values for automatically handled switches
  
-      for S in Config.Switches'Range loop
-         case Config.Switches (S).Typ is
-            when Switch_Untyped =>
-               null;   --  Nothing to do
+      if Config.Switches /= null then
+         for S in Config.Switches'Range loop
+            case Config.Switches (S).Typ is
+               when Switch_Untyped =>
+                  null;   --  Nothing to do
  
-            when Switch_Boolean =>
-               Config.Switches (S).Boolean_Output.all :=
-                 not Config.Switches (S).Boolean_Value;
+               when Switch_Boolean =>
+                  Config.Switches (S).Boolean_Output.all :=
+                    not Config.Switches (S).Boolean_Value;
  
-            when Switch_Integer =>
-               Config.Switches (S).Integer_Output.all :=
-                 Config.Switches (S).Integer_Initial;
+               when Switch_Integer =>
+                  Config.Switches (S).Integer_Output.all :=
+                    Config.Switches (S).Integer_Initial;
  
-            when Switch_String =>
-               if Config.Switches (S).String_Output.all = null then
-                  Config.Switches (S).String_Output.all := new String'("");
-               end if;
-         end case;
-      end loop;
+               when Switch_String =>
+                  if Config.Switches (S).String_Output.all = null then
+                     Config.Switches (S).String_Output.all := new String'("");
+                  end if;
+            end case;
+         end loop;
+      end if;
  
        --  For all sections, and all switches within those sections
  
diff --git a/gcc/ada/gcc-interface/decl.c b/gcc/ada/gcc-interface/decl.c

index 87026e7..6f2b0bb 100644 (file)
--- a/gcc/ada/gcc-interface/decl.c
+++ b/gcc/ada/gcc-interface/decl.c
@@ -966,6 +966,7 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
                  && !call_is_atomic_load (inner))
                 || TREE_CODE (inner) == ADDR_EXPR
                 || TREE_CODE (inner) == NULL_EXPR
+               || TREE_CODE (inner) == PLUS_EXPR
                 || TREE_CODE (inner) == CONSTRUCTOR
                 || CONSTANT_CLASS_P (inner)
                 /* We need to detect the case where a temporary is created to
@@ -2321,10 +2322,12 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
           gnat_name = Packed_Array_Impl_Type (gnat_entity);
         else
           gnat_name = gnat_entity;
-       if (gnat_encodings != DWARF_GNAT_ENCODINGS_MINIMAL)
-         gnu_entity_name = create_concat_name (gnat_name, "XUP");
-       create_type_decl (gnu_entity_name, gnu_fat_type, artificial_p,
-                         debug_info_p, gnat_entity);
+       tree xup_name
+         = (gnat_encodings == DWARF_GNAT_ENCODINGS_MINIMAL)
+           ? get_entity_name (gnat_name)
+           : create_concat_name (gnat_name, "XUP");
+       create_type_decl (xup_name, gnu_fat_type, artificial_p, debug_info_p,
+                         gnat_entity);
  
         /* Create the type to be designated by thin pointers: a record type for
            the array and its template.  We used to shift the fields to have the
@@ -2334,11 +2337,11 @@ gnat_to_gnu_entity (Entity_Id gnat_entity, tree gnu_expr, int definition)
            Note that GDB can handle standard DWARF information for them, so we
            don't have to name them as a GNAT encoding, except if specifically
            asked to.  */
-       if (gnat_encodings != DWARF_GNAT_ENCODINGS_MINIMAL)
-         gnu_entity_name = create_concat_name (gnat_name, "XUT");
-       else
-         gnu_entity_name = get_entity_name (gnat_name);
-       tem = build_unc_object_type (gnu_template_type, tem, gnu_entity_name,
+       tree xut_name
+         = (gnat_encodings == DWARF_GNAT_ENCODINGS_MINIMAL)
+           ? get_entity_name (gnat_name)
+           : create_concat_name (gnat_name, "XUT");
+       tem = build_unc_object_type (gnu_template_type, tem, xut_name,
                                      debug_info_p);
  
         SET_TYPE_UNCONSTRAINED_ARRAY (tem, gnu_type);
diff --git a/gcc/ada/gcc-interface/trans.c b/gcc/ada/gcc-interface/trans.c

index 357d26f..cf64d22 100644 (file)
--- a/gcc/ada/gcc-interface/trans.c
+++ b/gcc/ada/gcc-interface/trans.c
@@ -2483,13 +2483,15 @@ Attribute_to_gnu (Node_Id gnat_node, tree *gnu_result_type_p, int attribute)
  static tree
  Case_Statement_to_gnu (Node_Id gnat_node)
  {
-  tree gnu_result, gnu_expr, gnu_label;
+  tree gnu_result, gnu_expr, gnu_type, gnu_label;
    Node_Id gnat_when;
    location_t end_locus;
    bool may_fallthru = false;
  
    gnu_expr = gnat_to_gnu (Expression (gnat_node));
    gnu_expr = convert (get_base_type (TREE_TYPE (gnu_expr)), gnu_expr);
+  gnu_expr = maybe_character_value (gnu_expr);
+  gnu_type = TREE_TYPE (gnu_expr);
  
    /* We build a SWITCH_EXPR that contains the code with interspersed
       CASE_LABEL_EXPRs for each label.  */
@@ -2559,6 +2561,11 @@ Case_Statement_to_gnu (Node_Id gnat_node)
           gcc_assert (!gnu_low  || TREE_CODE (gnu_low)  == INTEGER_CST);
           gcc_assert (!gnu_high || TREE_CODE (gnu_high) == INTEGER_CST);
  
+         if (gnu_low && TREE_TYPE (gnu_low) != gnu_type)
+           gnu_low = convert (gnu_type, gnu_low);
+         if (gnu_high && TREE_TYPE (gnu_high) != gnu_type)
+           gnu_high = convert (gnu_type, gnu_high);
+
           add_stmt_with_node (build_case_label (gnu_low, gnu_high, label),
                               gnat_choice);
           choices_added_p = true;
@@ -2590,8 +2597,8 @@ Case_Statement_to_gnu (Node_Id gnat_node)
    /* Now emit a definition of the label the cases branch to, if any.  */
    if (may_fallthru)
      add_stmt (build1 (LABEL_EXPR, void_type_node, gnu_label));
-  gnu_result = build3 (SWITCH_EXPR, TREE_TYPE (gnu_expr), gnu_expr,
-                      end_stmt_group (), NULL_TREE);
+  gnu_result
+    = build3 (SWITCH_EXPR, gnu_type, gnu_expr, end_stmt_group (), NULL_TREE);
  
    return gnu_result;
  }
@@ -7635,10 +7642,11 @@ gnat_to_gnu (Node_Id gnat_node)
           else
             gnu_actual_obj_type = gnu_obj_type;
  
+         tree gnu_size = TYPE_SIZE_UNIT (gnu_actual_obj_type);
+         gnu_size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (gnu_size, gnu_ptr);
+
           gnu_result
-             = build_call_alloc_dealloc (gnu_ptr,
-                                         TYPE_SIZE_UNIT (gnu_actual_obj_type),
-                                         gnu_obj_type,
+             = build_call_alloc_dealloc (gnu_ptr, gnu_size, gnu_obj_type,
                                           Procedure_To_Call (gnat_node),
                                           Storage_Pool (gnat_node),
                                           gnat_node);
@@ -7719,16 +7727,22 @@ gnat_to_gnu (Node_Id gnat_node)
                                     N_Raise_Constraint_Error));
      }
  
-  /* If the result has side-effects and is of an unconstrained type, make a
-     SAVE_EXPR so that we can be sure it will only be referenced once.  But
-     this is useless for a call to a function that returns an unconstrained
-     type with default discriminant, as we cannot compute the size of the
-     actual returned object.  We must do this before any conversions.  */
+  /* If the result has side-effects and is of an unconstrained type, protect
+     the expression in case it will be referenced multiple times, i.e. for
+     its value and to compute the size of an object.  But do it neither for
+     an object nor a renaming declaration, nor a return statement of a call
+     to a function that returns an unconstrained record type with default
+     discriminant, because there is no size to be computed in these cases
+     and this will create a useless temporary.  We must do this before any
+     conversions.  */
    if (TREE_SIDE_EFFECTS (gnu_result)
-      && !(TREE_CODE (gnu_result) == CALL_EXPR
-          && type_is_padding_self_referential (TREE_TYPE (gnu_result)))
        && (TREE_CODE (gnu_result_type) == UNCONSTRAINED_ARRAY_TYPE
-         || CONTAINS_PLACEHOLDER_P (TYPE_SIZE (gnu_result_type))))
+         || CONTAINS_PLACEHOLDER_P (TYPE_SIZE (gnu_result_type)))
+      && !(TREE_CODE (gnu_result) == CALL_EXPR
+          && type_is_padding_self_referential (TREE_TYPE (gnu_result))
+          && (Nkind (Parent (gnat_node)) == N_Object_Declaration
+              || Nkind (Parent (gnat_node)) == N_Object_Renaming_Declaration
+              || Nkind (Parent (gnat_node)) == N_Simple_Return_Statement)))
      gnu_result = gnat_protect_expr (gnu_result);
  
    /* Now convert the result to the result type, unless we are in one of the
diff --git a/gcc/ada/gcc-interface/utils.c b/gcc/ada/gcc-interface/utils.c

index 9bd2773..4226f95 100644 (file)
--- a/gcc/ada/gcc-interface/utils.c
+++ b/gcc/ada/gcc-interface/utils.c
@@ -90,6 +90,8 @@ static tree handle_novops_attribute (tree *, tree, tree, int, bool *);
  static tree handle_nonnull_attribute (tree *, tree, tree, int, bool *);
  static tree handle_sentinel_attribute (tree *, tree, tree, int, bool *);
  static tree handle_noreturn_attribute (tree *, tree, tree, int, bool *);
+static tree handle_noinline_attribute (tree *, tree, tree, int, bool *);
+static tree handle_noclone_attribute (tree *, tree, tree, int, bool *);
  static tree handle_leaf_attribute (tree *, tree, tree, int, bool *);
  static tree handle_always_inline_attribute (tree *, tree, tree, int, bool *);
  static tree handle_malloc_attribute (tree *, tree, tree, int, bool *);
@@ -121,6 +123,10 @@ const struct attribute_spec gnat_internal_attribute_table[] =
      false },
    { "noreturn",     0, 0,  true,  false, false, handle_noreturn_attribute,
      false },
+  { "noinline",     0, 0,  true,  false, false, handle_noinline_attribute,
+    false },
+  { "noclone",      0, 0,  true,  false, false, handle_noclone_attribute,
+    false },
    { "leaf",         0, 0,  true,  false, false, handle_leaf_attribute,
      false },
    { "always_inline",0, 0,  true,  false, false, handle_always_inline_attribute,
@@ -5974,6 +5980,51 @@ handle_noreturn_attribute (tree *node, tree name, tree ARG_UNUSED (args),
    return NULL_TREE;
  }
  
+/* Handle a "noinline" attribute; arguments as in
+   struct attribute_spec.handler.  */
+
+static tree
+handle_noinline_attribute (tree *node, tree name,
+                          tree ARG_UNUSED (args),
+                          int ARG_UNUSED (flags), bool *no_add_attrs)
+{
+  if (TREE_CODE (*node) == FUNCTION_DECL)
+    {
+      if (lookup_attribute ("always_inline", DECL_ATTRIBUTES (*node)))
+       {
+         warning (OPT_Wattributes, "%qE attribute ignored due to conflict "
+                  "with attribute %qs", name, "always_inline");
+         *no_add_attrs = true;
+       }
+      else
+       DECL_UNINLINABLE (*node) = 1;
+    }
+  else
+    {
+      warning (OPT_Wattributes, "%qE attribute ignored", name);
+      *no_add_attrs = true;
+    }
+
+  return NULL_TREE;
+}
+
+/* Handle a "noclone" attribute; arguments as in
+   struct attribute_spec.handler.  */
+
+static tree
+handle_noclone_attribute (tree *node, tree name,
+                         tree ARG_UNUSED (args),
+                         int ARG_UNUSED (flags), bool *no_add_attrs)
+{
+  if (TREE_CODE (*node) != FUNCTION_DECL)
+    {
+      warning (OPT_Wattributes, "%qE attribute ignored", name);
+      *no_add_attrs = true;
+    }
+
+  return NULL_TREE;
+}
+
  /* Handle a "leaf" attribute; arguments as in
     struct attribute_spec.handler.  */
  
diff --git a/gcc/ada/gcc-interface/utils2.c b/gcc/ada/gcc-interface/utils2.c

index c1bb74d..6f05ee2 100644 (file)
--- a/gcc/ada/gcc-interface/utils2.c
+++ b/gcc/ada/gcc-interface/utils2.c
@@ -2266,8 +2266,6 @@ build_call_alloc_dealloc (tree gnu_obj, tree gnu_size, tree gnu_type,
                            Entity_Id gnat_proc, Entity_Id gnat_pool,
                            Node_Id gnat_node)
  {
-  gnu_size = SUBSTITUTE_PLACEHOLDER_IN_EXPR (gnu_size, gnu_obj);
-
    /* Explicit proc to call ?  This one is assumed to deal with the type
       alignment constraints.  */
    if (Present (gnat_proc))
diff --git a/gcc/ada/s-osinte-kfreebsd-gnu.ads b/gcc/ada/s-osinte-kfreebsd-gnu.ads

index 3f6ef9b..647778b 100644 (file)
--- a/gcc/ada/s-osinte-kfreebsd-gnu.ads
+++ b/gcc/ada/s-osinte-kfreebsd-gnu.ads
@@ -7,7 +7,7 @@
  --                                  S p e c                                 --
  --                                                                          --
  --               Copyright (C) 1991-1994, Florida State University          --
---            Copyright (C) 1995-2015, Free Software Foundation, Inc.       --
+--            Copyright (C) 1995-2016, Free Software Foundation, Inc.       --
  --                                                                          --
  -- GNAT is free software;  you can  redistribute it  and/or modify it under --
  -- terms of the  GNU General Public License as published  by the Free Soft- --
@@ -216,6 +216,11 @@ package System.OS_Interface is
        return int;
     pragma Import (C, clock_gettime, "clock_gettime");
  
+   function clock_getres
+     (clock_id : clockid_t;
+      res      : access timespec) return int;
+   pragma Import (C, clock_getres, "clock_getres");
+
     function To_Duration (TS : timespec) return Duration;
     pragma Inline (To_Duration);
  
@@ -330,8 +335,7 @@ package System.OS_Interface is
     --  returns the stack base of the specified thread. Only call this function
     --  when Stack_Base_Available is True.
  
-   function Get_Page_Size return size_t;
-   function Get_Page_Size return Address;
+   function Get_Page_Size return int;
     pragma Import (C, Get_Page_Size, "getpagesize");
     --  Returns the size of a page
  
diff --git a/gcc/ada/s-osinte-rtems.ads b/gcc/ada/s-osinte-rtems.ads

index 5a143cc..a658bbe 100644 (file)
--- a/gcc/ada/s-osinte-rtems.ads
+++ b/gcc/ada/s-osinte-rtems.ads
@@ -6,7 +6,7 @@
  --                                                                          --
  --                                   S p e c                                --
  --                                                                          --
---          Copyright (C) 1997-2011 Free Software Foundation, Inc.          --
+--          Copyright (C) 1997-2016 Free Software Foundation, Inc.          --
  --                                                                          --
  -- GNARL is free software; you can  redistribute it  and/or modify it under --
  -- terms of the  GNU General Public License as published  by the Free Soft- --
@@ -188,6 +188,11 @@ package System.OS_Interface is
        tp       : access timespec) return int;
     pragma Import (C, clock_gettime, "clock_gettime");
  
+   function clock_getres
+     (clock_id : clockid_t;
+      res      : access timespec) return int;
+   pragma Import (C, clock_getres, "clock_getres");
+
     function To_Duration (TS : timespec) return Duration;
     pragma Inline (To_Duration);
  
@@ -291,8 +296,7 @@ package System.OS_Interface is
     --  These two functions are only needed to share s-taprop.adb with
     --  FSU threads.
  
-   function Get_Page_Size return size_t;
-   function Get_Page_Size return Address;
+   function Get_Page_Size return int;
     pragma Import (C, Get_Page_Size, "getpagesize");
     --  Returns the size of a page
  
diff --git a/gcc/alias.c b/gcc/alias.c

index a0e25dc..ea226fc 100644 (file)
--- a/gcc/alias.c
+++ b/gcc/alias.c
@@ -769,6 +769,10 @@ reference_alias_ptr_type_1 (tree *t)
  tree
  reference_alias_ptr_type (tree t)
  {
+  /* If the frontend assigns this alias-set zero, preserve that.  */
+  if (lang_hooks.get_alias_set (t) == 0)
+    return ptr_type_node;
+
    tree ptype = reference_alias_ptr_type_1 (&t);
    /* If there is a given pointer type for aliasing purposes, return it.  */
    if (ptype != NULL_TREE)
diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog

index 1e7b27b..7b53889 100644 (file)
--- a/gcc/c-family/ChangeLog
+++ b/gcc/c-family/ChangeLog
@@ -1,3 +1,25 @@
+2016-06-14  Jakub Jelinek  <jakub@redhat.com>
+
+       Backported from mainline
+       2016-06-10  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c/68657
+       * c.opt (Wpsabi): Add Warning flag.
+
+2016-06-13  Jakub Jelinek  <jakub@redhat.com>
+
+       PR sanitizer/71498
+       * c-gimplify.c (ubsan_walk_array_refs_r): Set *walk_subtrees = 0 on
+       all BIND_EXPRs, and on all BIND_EXPRs recurse also on BIND_EXPR_BODY.
+
+2016-05-30  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71349
+       * c-omp.c (c_omp_split_clauses): Put OMP_CLAUSE_DEPEND to
+       C_OMP_CLAUSE_SPLIT_TARGET.  Put OMP_CLAUSE_NOWAIT to
+       C_OMP_CLAUSE_SPLIT_TARGET if combined with target construct,
+       instead of C_OMP_CLAUSE_SPLIT_FOR.
+
  2016-04-29  Cesar Philippidis  <cesar@codesourcery.com>
  
         PR middle-end/70626
diff --git a/gcc/c-family/c-gimplify.c b/gcc/c-family/c-gimplify.c

index 0757193..c18b057 100644 (file)
--- a/gcc/c-family/c-gimplify.c
+++ b/gcc/c-family/c-gimplify.c
@@ -67,23 +67,23 @@ ubsan_walk_array_refs_r (tree *tp, int *walk_subtrees, void *data)
  {
    hash_set<tree> *pset = (hash_set<tree> *) data;
  
-  /* Since walk_tree doesn't call the callback function on the decls
-     in BIND_EXPR_VARS, we have to walk them manually.  */
    if (TREE_CODE (*tp) == BIND_EXPR)
      {
+      /* Since walk_tree doesn't call the callback function on the decls
+        in BIND_EXPR_VARS, we have to walk them manually, so we can avoid
+        instrumenting DECL_INITIAL of TREE_STATIC vars.  */
+      *walk_subtrees = 0;
        for (tree decl = BIND_EXPR_VARS (*tp); decl; decl = DECL_CHAIN (decl))
         {
           if (TREE_STATIC (decl))
-           {
-             *walk_subtrees = 0;
-             continue;
-           }
+           continue;
           walk_tree (&DECL_INITIAL (decl), ubsan_walk_array_refs_r, pset,
                      pset);
           walk_tree (&DECL_SIZE (decl), ubsan_walk_array_refs_r, pset, pset);
           walk_tree (&DECL_SIZE_UNIT (decl), ubsan_walk_array_refs_r, pset,
                      pset);
         }
+      walk_tree (&BIND_EXPR_BODY (*tp), ubsan_walk_array_refs_r, pset, pset);
      }
    else if (TREE_CODE (*tp) == ADDR_EXPR
            && TREE_CODE (TREE_OPERAND (*tp, 0)) == ARRAY_REF)
diff --git a/gcc/c-family/c-omp.c b/gcc/c-family/c-omp.c

index be401bb..1691c40 100644 (file)
--- a/gcc/c-family/c-omp.c
+++ b/gcc/c-family/c-omp.c
@@ -983,6 +983,7 @@ c_omp_split_clauses (location_t loc, enum tree_code code,
         case OMP_CLAUSE_MAP:
         case OMP_CLAUSE_IS_DEVICE_PTR:
         case OMP_CLAUSE_DEFAULTMAP:
+       case OMP_CLAUSE_DEPEND:
           s = C_OMP_CLAUSE_SPLIT_TARGET;
           break;
         case OMP_CLAUSE_NUM_TEAMS:
@@ -998,7 +999,6 @@ c_omp_split_clauses (location_t loc, enum tree_code code,
           s = C_OMP_CLAUSE_SPLIT_PARALLEL;
           break;
         case OMP_CLAUSE_ORDERED:
-       case OMP_CLAUSE_NOWAIT:
           s = C_OMP_CLAUSE_SPLIT_FOR;
           break;
         case OMP_CLAUSE_SCHEDULE:
@@ -1333,6 +1333,18 @@ c_omp_split_clauses (location_t loc, enum tree_code code,
           else
             s = C_OMP_CLAUSE_SPLIT_FOR;
           break;
+       case OMP_CLAUSE_NOWAIT:
+         /* Nowait clause is allowed on target, for and sections, but
+            is not allowed on parallel for or parallel sections.  Therefore,
+            put it on target construct if present, because that can only
+            be combined with parallel for{, simd} and not with for{, simd},
+            otherwise to the worksharing construct.  */
+         if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP))
+             != 0)
+           s = C_OMP_CLAUSE_SPLIT_TARGET;
+         else
+           s = C_OMP_CLAUSE_SPLIT_FOR;
+         break;
         default:
           gcc_unreachable ();
         }
diff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt

index 4f86876..88038a0 100644 (file)
--- a/gcc/c-family/c.opt
+++ b/gcc/c-family/c.opt
@@ -265,7 +265,7 @@ C++ ObjC++ Var(warn_abi_tag) Warning
  Warn if a subobject has an abi_tag attribute that the complete object type does not have.
  
  Wpsabi
-C ObjC C++ ObjC++ LTO Var(warn_psabi) Init(1) Undocumented LangEnabledBy(C ObjC C++ ObjC++,Wabi)
+C ObjC C++ ObjC++ LTO Var(warn_psabi) Init(1) Warning Undocumented LangEnabledBy(C ObjC C++ ObjC++,Wabi)
  
  Waddress
  C ObjC C++ ObjC++ Var(warn_address) Warning LangEnabledBy(C ObjC C++ ObjC++,Wall)
diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog

index 5be1b5f..7edb380 100644 (file)
--- a/gcc/c/ChangeLog
+++ b/gcc/c/ChangeLog
@@ -1,3 +1,27 @@
+2016-06-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+       PR c/71381
+       Backport from trunk r237290:
+       * c-parser.c (c_parser_omp_variable_list) <OMP_CLAUSE__CACHE_>:
+       Loosen checking.
+
+2016-05-30  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71349
+       * c-parser.c (c_parser_omp_for): Don't disallow nowait clause
+       when combined with target construct.
+
+2016-05-19  David Malcolm  <dmalcolm@redhat.com>
+
+       Backport from trunk r236488.
+       PR c/71171
+       * c-parser.c (c_parser_generic_selection): Use c_expr::set_error
+       in error-handling.
+       (c_parser_postfix_expression): Likewise.
+       * c-tree.h (c_expr::set_error): New method.
+       * c-typeck.c (parser_build_binary_op): In error-handling, ensure
+       that result's range is initialized.
+
  2016-04-29  Cesar Philippidis  <cesar@codesourcery.com>
  
         PR middle-end/70626
diff --git a/gcc/c/c-parser.c b/gcc/c/c-parser.c

index 17df493..c9eb8dd 100644 (file)
--- a/gcc/c/c-parser.c
+++ b/gcc/c/c-parser.c
@@ -7185,7 +7185,7 @@ c_parser_generic_selection (c_parser *parser)
  
    error_expr.original_code = ERROR_MARK;
    error_expr.original_type = NULL;
-  error_expr.value = error_mark_node;
+  error_expr.set_error ();
    matched_assoc.type_location = UNKNOWN_LOCATION;
    matched_assoc.type = NULL_TREE;
    matched_assoc.expression = error_expr;
@@ -7496,13 +7496,13 @@ c_parser_postfix_expression (c_parser *parser)
             gcc_assert (c_dialect_objc ());
             if (!c_parser_require (parser, CPP_DOT, "expected %<.%>"))
               {
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
             if (c_parser_next_token_is_not (parser, CPP_NAME))
               {
                 c_parser_error (parser, "expected identifier");
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
             c_token *component_tok = c_parser_peek_token (parser);
@@ -7516,7 +7516,7 @@ c_parser_postfix_expression (c_parser *parser)
           }
         default:
           c_parser_error (parser, "expected expression");
-         expr.value = error_mark_node;
+         expr.set_error ();
           break;
         }
        break;
@@ -7538,7 +7538,7 @@ c_parser_postfix_expression (c_parser *parser)
               parser->error = true;
               c_parser_skip_until_found (parser, CPP_CLOSE_BRACE, NULL);
               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-             expr.value = error_mark_node;
+             expr.set_error ();
               break;
             }
           stmt = c_begin_stmt_expr ();
@@ -7567,7 +7567,7 @@ c_parser_postfix_expression (c_parser *parser)
                                      "expected %<)%>");
           if (type_name == NULL)
             {
-             expr.value = error_mark_node;
+             expr.set_error ();
             }
           else
             expr = c_parser_postfix_expression_after_paren_type (parser,
@@ -7627,7 +7627,7 @@ c_parser_postfix_expression (c_parser *parser)
             c_parser_consume_token (parser);
             if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
               {
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
             e1 = c_parser_expr_no_commas (parser, NULL);
@@ -7636,7 +7636,7 @@ c_parser_postfix_expression (c_parser *parser)
             if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
               {
                 c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
             loc = c_parser_peek_token (parser)->location;
@@ -7646,7 +7646,7 @@ c_parser_postfix_expression (c_parser *parser)
                                        "expected %<)%>");
             if (t1 == NULL)
               {
-               expr.value = error_mark_node;
+               expr.set_error ();
               }
             else
               {
@@ -7668,7 +7668,7 @@ c_parser_postfix_expression (c_parser *parser)
           c_parser_consume_token (parser);
           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
             {
-             expr.value = error_mark_node;
+             expr.set_error ();
               break;
             }
           t1 = c_parser_type_name (parser);
@@ -7679,7 +7679,7 @@ c_parser_postfix_expression (c_parser *parser)
           if (parser->error)
             {
               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-             expr.value = error_mark_node;
+             expr.set_error ();
               break;
             }
  
@@ -7768,7 +7768,7 @@ c_parser_postfix_expression (c_parser *parser)
                                             &cexpr_list, true,
                                             &close_paren_loc))
               {
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
  
@@ -7776,7 +7776,7 @@ c_parser_postfix_expression (c_parser *parser)
               {
                 error_at (loc, "wrong number of arguments to "
                                "%<__builtin_choose_expr%>");
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
  
@@ -7801,25 +7801,25 @@ c_parser_postfix_expression (c_parser *parser)
           c_parser_consume_token (parser);
           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
             {
-             expr.value = error_mark_node;
+             expr.set_error ();
               break;
             }
           t1 = c_parser_type_name (parser);
           if (t1 == NULL)
             {
-             expr.value = error_mark_node;
+             expr.set_error ();
               break;
             }
           if (!c_parser_require (parser, CPP_COMMA, "expected %<,%>"))
             {
               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-             expr.value = error_mark_node;
+             expr.set_error ();
               break;
             }
           t2 = c_parser_type_name (parser);
           if (t2 == NULL)
             {
-             expr.value = error_mark_node;
+             expr.set_error ();
               break;
             }
           {
@@ -7831,7 +7831,7 @@ c_parser_postfix_expression (c_parser *parser)
             e2 = groktypename (t2, NULL, NULL);
             if (e1 == error_mark_node || e2 == error_mark_node)
               {
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
  
@@ -7856,14 +7856,14 @@ c_parser_postfix_expression (c_parser *parser)
                                             &cexpr_list, false,
                                             &close_paren_loc))
               {
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
             if (vec_safe_length (cexpr_list) != 2)
               {
                 error_at (loc, "wrong number of arguments to "
                                "%<__builtin_call_with_static_chain%>");
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
  
@@ -7898,7 +7898,7 @@ c_parser_postfix_expression (c_parser *parser)
                                             &cexpr_list, false,
                                             &close_paren_loc))
               {
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
  
@@ -7906,7 +7906,7 @@ c_parser_postfix_expression (c_parser *parser)
               {
                 error_at (loc, "wrong number of arguments to "
                                "%<__builtin_complex%>");
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
  
@@ -7928,7 +7928,7 @@ c_parser_postfix_expression (c_parser *parser)
               {
                 error_at (loc, "%<__builtin_complex%> operand "
                           "not of real binary floating-point type");
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
             if (TYPE_MAIN_VARIANT (TREE_TYPE (e1_p->value))
@@ -7936,7 +7936,7 @@ c_parser_postfix_expression (c_parser *parser)
               {
                 error_at (loc,
                           "%<__builtin_complex%> operands of different types");
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
             pedwarn_c90 (loc, OPT_Wpedantic,
@@ -7962,7 +7962,7 @@ c_parser_postfix_expression (c_parser *parser)
                                             &cexpr_list, false,
                                             &close_paren_loc))
               {
-               expr.value = error_mark_node;
+               expr.set_error ();
                 break;
               }
  
@@ -7985,7 +7985,7 @@ c_parser_postfix_expression (c_parser *parser)
               {
                 error_at (loc, "wrong number of arguments to "
                                "%<__builtin_shuffle%>");
-               expr.value = error_mark_node;
+               expr.set_error ();
               }
             set_c_expr_source_range (&expr, loc, close_paren_loc);
             break;
@@ -7995,7 +7995,7 @@ c_parser_postfix_expression (c_parser *parser)
           c_parser_consume_token (parser);
           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
             {
-             expr.value = error_mark_node;
+             expr.set_error ();
               break;
             }
           {
@@ -8012,14 +8012,14 @@ c_parser_postfix_expression (c_parser *parser)
           c_parser_consume_token (parser);
           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
             {
-             expr.value = error_mark_node;
+             expr.set_error ();
               break;
             }
           if (c_parser_next_token_is_not (parser, CPP_NAME))
             {
               c_parser_error (parser, "expected identifier");
               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
-             expr.value = error_mark_node;
+             expr.set_error ();
               break;
             }
           {
@@ -8038,13 +8038,13 @@ c_parser_postfix_expression (c_parser *parser)
           c_parser_consume_token (parser);
           if (!c_parser_require (parser, CPP_OPEN_PAREN, "expected %<(%>"))
             {
-             expr.value = error_mark_node;
+             expr.set_error ();
               break;
             }
           t1 = c_parser_type_name (parser);
           if (t1 == NULL)
             {
-             expr.value = error_mark_node;
+             expr.set_error ();
               c_parser_skip_until_found (parser, CPP_CLOSE_PAREN, NULL);
               break;
             }
@@ -8067,7 +8067,7 @@ c_parser_postfix_expression (c_parser *parser)
               error_at (loc, "-fcilkplus must be enabled to use "
                         "%<_Cilk_spawn%>");
               expr = c_parser_cast_expression (parser, NULL);
-             expr.value = error_mark_node;
+             expr.set_error ();
             }
           else if (c_parser_peek_token (parser)->keyword == RID_CILK_SPAWN)
             {
@@ -8086,7 +8086,7 @@ c_parser_postfix_expression (c_parser *parser)
           break;
         default:
           c_parser_error (parser, "expected expression");
-         expr.value = error_mark_node;
+         expr.set_error ();
           break;
         }
        break;
@@ -8107,7 +8107,7 @@ c_parser_postfix_expression (c_parser *parser)
        /* Else fall through to report error.  */
      default:
        c_parser_error (parser, "expected expression");
-      expr.value = error_mark_node;
+      expr.set_error ();
        break;
      }
    return c_parser_postfix_expression_after_primary
@@ -8325,7 +8325,7 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
           else
             {
               c_parser_error (parser, "expected identifier");
-             expr.value = error_mark_node;
+             expr.set_error ();
               expr.original_code = ERROR_MARK;
                expr.original_type = NULL;
               return expr;
@@ -8357,7 +8357,7 @@ c_parser_postfix_expression_after_primary (c_parser *parser,
           else
             {
               c_parser_error (parser, "expected identifier");
-             expr.value = error_mark_node;
+             expr.set_error ();
               expr.original_code = ERROR_MARK;
               expr.original_type = NULL;
               return expr;
@@ -10595,6 +10595,8 @@ c_parser_omp_variable_list (c_parser *parser,
           switch (kind)
             {
             case OMP_CLAUSE__CACHE_:
+             /* The OpenACC cache directive explicitly only allows "array
+                elements or subarrays".  */
               if (c_parser_peek_token (parser)->type != CPP_OPEN_SQUARE)
                 {
                   c_parser_error (parser, "expected %<[%>");
@@ -10657,25 +10659,6 @@ c_parser_omp_variable_list (c_parser *parser,
                       break;
                     }
  
-                 if (kind == OMP_CLAUSE__CACHE_)
-                   {
-                     if (TREE_CODE (low_bound) != INTEGER_CST
-                         && !TREE_READONLY (low_bound))
-                       {
-                         error_at (clause_loc,
-                                   "%qD is not a constant", low_bound);
-                         t = error_mark_node;
-                       }
-
-                     if (TREE_CODE (length) != INTEGER_CST
-                         && !TREE_READONLY (length))
-                       {
-                         error_at (clause_loc,
-                                   "%qD is not a constant", length);
-                         t = error_mark_node;
-                       }
-                   }
-
                   t = tree_cons (low_bound, length, t);
                 }
               break;
@@ -15094,7 +15077,9 @@ c_parser_omp_for (location_t loc, c_parser *parser,
  
    strcat (p_name, " for");
    mask |= OMP_FOR_CLAUSE_MASK;
-  if (cclauses)
+  /* parallel for{, simd} disallows nowait clause, but for
+     target {teams distribute ,}parallel for{, simd} it should be accepted.  */
+  if (cclauses && (mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP)) == 0)
      mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT);
    /* Composite distribute parallel for{, simd} disallows ordered clause.  */
    if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
diff --git a/gcc/c/c-tree.h b/gcc/c/c-tree.h

index d559207..bb12a20 100644 (file)
--- a/gcc/c/c-tree.h
+++ b/gcc/c/c-tree.h
@@ -143,6 +143,15 @@ struct c_expr
       of this expression.  */
    location_t get_start () const { return src_range.m_start; }
    location_t get_finish () const { return src_range.m_finish; }
+
+  /* Set the value to error_mark_node whilst ensuring that src_range
+     is initialized.  */
+  void set_error ()
+  {
+    value = error_mark_node;
+    src_range.m_start = UNKNOWN_LOCATION;
+    src_range.m_finish = UNKNOWN_LOCATION;
+  }
  };
  
  /* Type alias for struct c_expr. This allows to use the structure
diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c

index 59a3c61..8ad99d5 100644 (file)
--- a/gcc/c/c-typeck.c
+++ b/gcc/c/c-typeck.c
@@ -3530,7 +3530,12 @@ parser_build_binary_op (location_t location, enum tree_code code,
    result.original_type = NULL;
  
    if (TREE_CODE (result.value) == ERROR_MARK)
-    return result;
+    {
+      set_c_expr_source_range (&result,
+                              arg1.get_start (),
+                              arg2.get_finish ());
+      return result;
+    }
  
    if (location != UNKNOWN_LOCATION)
      protected_set_expr_location (result.value, location);
diff --git a/gcc/calls.c b/gcc/calls.c

index 6415e08..6cc1fc7 100644 (file)
--- a/gcc/calls.c
+++ b/gcc/calls.c
@@ -1188,6 +1188,7 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
             j--;
           }
        }
+    argpos = 0;
      FOR_EACH_CALL_EXPR_ARG (arg, iter, exp)
        {
         tree argtype = TREE_TYPE (arg);
@@ -1206,6 +1207,14 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
                 chkp_find_bound_slots (argtype, slots);
               }
           }
+       else if (CALL_WITH_BOUNDS_P (exp)
+                && pass_by_reference (NULL, TYPE_MODE (argtype), argtype,
+                                      argpos < n_named_args))
+         {
+           if (slots)
+             BITMAP_FREE (slots);
+           ptr_arg = j;
+         }
         else if (POINTER_BOUNDS_TYPE_P (argtype))
           {
             /* We expect bounds in instrumented calls only.
@@ -1249,6 +1258,7 @@ initialize_argument_information (int num_actuals ATTRIBUTE_UNUSED,
         else
           args[j].tree_value = arg;
         j--;
+       argpos++;
        }
  
      if (slots)
diff --git a/gcc/cgraph.c b/gcc/cgraph.c

index 4804081..ed9f841 100644 (file)
--- a/gcc/cgraph.c
+++ b/gcc/cgraph.c
@@ -1504,10 +1504,21 @@ cgraph_edge::redirect_call_stmt_to_callee (void)
        update_stmt_fn (DECL_STRUCT_FUNCTION (e->caller->decl), new_stmt);
      }
  
+  /* If changing the call to __cxa_pure_virtual or similar noreturn function,
+     adjust gimple_call_fntype too.  */
+  if (gimple_call_noreturn_p (new_stmt)
+      && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (e->callee->decl)))
+      && TYPE_ARG_TYPES (TREE_TYPE (e->callee->decl))
+      && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (e->callee->decl)))
+         == void_type_node))
+    gimple_call_set_fntype (new_stmt, TREE_TYPE (e->callee->decl));
+
    /* If the call becomes noreturn, remove the LHS if possible.  */
    if (lhs
        && (gimple_call_flags (new_stmt) & ECF_NORETURN)
-      && TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs))) == INTEGER_CST)
+      && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (new_stmt)))
+         || (TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs))) == INTEGER_CST
+             && !TREE_ADDRESSABLE (TREE_TYPE (lhs)))))
      {
        if (TREE_CODE (lhs) == SSA_NAME)
         {
diff --git a/gcc/config.gcc b/gcc/config.gcc

index 9d27dc4..1f3da54 100644 (file)
--- a/gcc/config.gcc
+++ b/gcc/config.gcc
@@ -1058,11 +1058,9 @@ arm*-*-freebsd*)                # ARM FreeBSD EABI
         case $target in
         armv6*-*-freebsd*)
             tm_defines="${tm_defines} TARGET_FREEBSD_ARMv6=1"
-           ;;
-       esac
-       case $target in
-       arm*hf-*-freebsd*)
-           tm_defines="${tm_defines} TARGET_FREEBSD_ARM_HARD_FLOAT=1"
+            if test $fbsd_major -ge 11; then
+               tm_defines="${tm_defines} TARGET_FREEBSD_ARM_HARD_FLOAT=1"
+            fi
             ;;
         esac
         with_tls=${with_tls:-gnu}
@@ -4282,9 +4280,9 @@ case "${target}" in
                 esac
                 ;;
         sparc*-*-*)
-               supported_defaults="cpu float tune"
+               supported_defaults="cpu cpu_32 cpu_64 float tune tune_32 tune_64"
  
-               for which in cpu tune; do
+               for which in cpu cpu_32 cpu_64 tune tune_32 tune_64; do
                         eval "val=\$with_$which"
                         case ${val} in
                         "" | sparc | sparcv9 | sparc64 \
@@ -4293,7 +4291,7 @@ case "${target}" in
                         | sparclite | f930 | f934 | sparclite86x \
                         | sparclet | tsc701 \
                         | v9 | ultrasparc | ultrasparc3 | niagara | niagara2 \
-                       | niagara3 | niagara4)
+                       | niagara3 | niagara4 | niagara7)
                                 # OK
                                 ;;
                         *)
diff --git a/gcc/config.in b/gcc/config.in

index 115cb61..86bd5b0 100644 (file)
--- a/gcc/config.in
+++ b/gcc/config.in
@@ -622,6 +622,12 @@
  #endif
  
  
+/* Define if your assembler supports SPARC5 and VIS 4.0 instructions. */
+#ifndef USED_FOR_TARGET
+#undef HAVE_AS_SPARC5_VIS4
+#endif
+
+
  /* Define if your assembler and linker support GOTDATA_OP relocs. */
  #ifndef USED_FOR_TARGET
  #undef HAVE_AS_SPARC_GOTDATA_OP
diff --git a/gcc/config/aarch64/aarch64-simd.md b/gcc/config/aarch64/aarch64-simd.md

index 0e4a0a7..6ea35bf 100644 (file)
--- a/gcc/config/aarch64/aarch64-simd.md
+++ b/gcc/config/aarch64/aarch64-simd.md
@@ -1919,16 +1919,6 @@
    }
  )
  
-(define_insn "aarch64_vmls<mode>"
-  [(set (match_operand:VDQF 0 "register_operand" "=w")
-       (minus:VDQF (match_operand:VDQF 1 "register_operand" "0")
-                  (mult:VDQF (match_operand:VDQF 2 "register_operand" "w")
-                             (match_operand:VDQF 3 "register_operand" "w"))))]
-  "TARGET_SIMD"
- "fmls\\t%0.<Vtype>, %2.<Vtype>, %3.<Vtype>"
-  [(set_attr "type" "neon_fp_mla_<Vetype>_scalar<q>")]
-)
-
  ;; FP Max/Min
  ;; Max/Min are introduced by idiom recognition by GCC's mid-end.  An
  ;; expression like:
diff --git a/gcc/config/alpha/alpha.md b/gcc/config/alpha/alpha.md

index 932608b..3e4594b 100644 (file)
--- a/gcc/config/alpha/alpha.md
+++ b/gcc/config/alpha/alpha.md
@@ -3738,7 +3738,8 @@
  
  ;; BUGCHK is documented common to OSF/1 and VMS PALcode.
  (define_insn "trap"
-  [(trap_if (const_int 1) (const_int 0))]
+  [(trap_if (const_int 1) (const_int 0))
+   (use (reg:DI 29))]
    ""
    "call_pal 0x81"
    [(set_attr "type" "callpal")])
@@ -5157,7 +5158,7 @@
    "TARGET_ABI_OSF"
  {
    if (TARGET_EXPLICIT_RELOCS)
-    return "ldah $29,0($26)\t\t!gpdisp!%*\;lda $29,0($29)\t\t!gpdisp!%*";
+    return "#";
    else
      return "ldgp $29,0($26)";
  }
diff --git a/gcc/config/arm/arm-builtins.c b/gcc/config/arm/arm-builtins.c

index 90fb40f..68b2839 100644 (file)
--- a/gcc/config/arm/arm-builtins.c
+++ b/gcc/config/arm/arm-builtins.c
@@ -2861,6 +2861,10 @@ arm_builtin_vectorized_function (unsigned int fn, tree type_out, tree type_in)
    int in_n, out_n;
    bool out_unsigned_p = TYPE_UNSIGNED (type_out);
  
+  /* Can't provide any vectorized builtins when we can't use NEON.  */
+  if (!TARGET_NEON)
+    return NULL_TREE;
+
    if (TREE_CODE (type_out) != VECTOR_TYPE
        || TREE_CODE (type_in) != VECTOR_TYPE)
      return NULL_TREE;
@@ -2875,7 +2879,7 @@ arm_builtin_vectorized_function (unsigned int fn, tree type_out, tree type_in)
     NULL_TREE is returned if no such builtin is available.  */
  #undef ARM_CHECK_BUILTIN_MODE
  #define ARM_CHECK_BUILTIN_MODE(C)    \
-  (TARGET_NEON && TARGET_FPU_ARMV8   \
+  (TARGET_FPU_ARMV8   \
     && flag_unsafe_math_optimizations \
     && ARM_CHECK_BUILTIN_MODE_1 (C))
  
diff --git a/gcc/config/arm/arm.c b/gcc/config/arm/arm.c

index 3d4c27c..32accc9 100644 (file)
--- a/gcc/config/arm/arm.c
+++ b/gcc/config/arm/arm.c
@@ -17759,6 +17759,7 @@ arm_output_multireg_pop (rtx *operands, bool return_pc, rtx cond, bool reverse,
    int num_saves = XVECLEN (operands[0], 0);
    unsigned int regno;
    unsigned int regno_base = REGNO (operands[1]);
+  bool interrupt_p = IS_INTERRUPT (arm_current_func_type ());
  
    offset = 0;
    offset += update ? 1 : 0;
@@ -17776,20 +17777,16 @@ arm_output_multireg_pop (rtx *operands, bool return_pc, rtx cond, bool reverse,
      }
  
    conditional = reverse ? "%?%D0" : "%?%d0";
-  if ((regno_base == SP_REGNUM) && update)
-    {
-      sprintf (pattern, "pop%s\t{", conditional);
-    }
+  /* Can't use POP if returning from an interrupt.  */
+  if ((regno_base == SP_REGNUM) && update && !(interrupt_p && return_pc))
+    sprintf (pattern, "pop%s\t{", conditional);
    else
      {
        /* Output ldmfd when the base register is SP, otherwise output ldmia.
           It's just a convention, their semantics are identical.  */
        if (regno_base == SP_REGNUM)
-         /* update is never true here, hence there is no need to handle
-            pop here.  */
-       sprintf (pattern, "ldmfd%s", conditional);
-
-      if (update)
+       sprintf (pattern, "ldmfd%s\t", conditional);
+      else if (update)
         sprintf (pattern, "ldmia%s\t", conditional);
        else
         sprintf (pattern, "ldm%s\t", conditional);
@@ -17815,7 +17812,7 @@ arm_output_multireg_pop (rtx *operands, bool return_pc, rtx cond, bool reverse,
  
    strcat (pattern, "}");
  
-  if (IS_INTERRUPT (arm_current_func_type ()) && return_pc)
+  if (interrupt_p && return_pc)
      strcat (pattern, "^");
  
    output_asm_insn (pattern, &cond);
@@ -19626,8 +19623,12 @@ output_return_instruction (rtx operand, bool really_return, bool reverse,
                   sprintf (instr, "ldmfd%s\t%%|sp, {", conditional);
                 }
             }
+         /* For interrupt returns we have to use an LDM rather than
+            a POP so that we can use the exception return variant.  */
+         else if (IS_INTERRUPT (func_type))
+           sprintf (instr, "ldmfd%s\t%%|sp!, {", conditional);
           else
-             sprintf (instr, "pop%s\t{", conditional);
+           sprintf (instr, "pop%s\t{", conditional);
  
           p = instr + strlen (instr);
  
@@ -21465,7 +21466,11 @@ arm_expand_prologue (void)
  
    /* Naked functions don't have prologues.  */
    if (IS_NAKED (func_type))
-    return;
+    {
+      if (flag_stack_usage_info)
+       current_function_static_stack_size = 0;
+      return;
+    }
  
    /* Make a copy of c_f_p_a_s as we may need to modify it locally.  */
    args_to_push = crtl->args.pretend_args_size;
@@ -24719,7 +24724,11 @@ thumb1_expand_prologue (void)
  
    /* Naked functions don't have prologues.  */
    if (IS_NAKED (func_type))
-    return;
+    {
+      if (flag_stack_usage_info)
+       current_function_static_stack_size = 0;
+      return;
+    }
  
    if (IS_INTERRUPT (func_type))
      {
diff --git a/gcc/config/i386/constraints.md b/gcc/config/i386/constraints.md

index afdc546..1a4c701 100644 (file)
--- a/gcc/config/i386/constraints.md
+++ b/gcc/config/i386/constraints.md
@@ -141,8 +141,12 @@
   "(ix86_fpmath & FPMATH_387) ? FLOAT_REGS : NO_REGS"
   "@internal Any x87 register when 80387 FP arithmetic is enabled.")
  
+;; Yr constraint is meant to be used in noavx contexts only, for VEX and EVEX
+;; the lower register numbers need the same instruction sizes as any other.
+;; In case Yr constraint is misused, try to limit the damage, by treating
+;; it as x constraint in avx mode, not v constraint.
  (define_register_constraint "Yr"
- "TARGET_SSE ? (X86_TUNE_AVOID_4BYTE_PREFIXES ? NO_REX_SSE_REGS : ALL_SSE_REGS) : NO_REGS"
+ "TARGET_SSE ? ((TARGET_AVOID_4BYTE_PREFIXES && !TARGET_AVX) ? NO_REX_SSE_REGS : SSE_REGS) : NO_REGS"
   "@internal Lower SSE register when avoiding REX prefix and all SSE registers otherwise.")
  
  ;; We use the B prefix to denote any number of internal operands:
diff --git a/gcc/config/i386/driver-i386.c b/gcc/config/i386/driver-i386.c

index b121466..a9d5135 100644 (file)
--- a/gcc/config/i386/driver-i386.c
+++ b/gcc/config/i386/driver-i386.c
@@ -637,33 +637,27 @@ const char *host_detect_local_cpu (int argc, const char **argv)
      }
    else if (vendor == signature_CENTAUR_ebx)
      {
-      if (arch)
+      processor = PROCESSOR_GENERIC;
+
+      switch (family)
         {
-         switch (family)
-           {
-           case 6:
-             if (model > 9)
-               /* Use the default detection procedure.  */
-               processor = PROCESSOR_GENERIC;
-             else if (model == 9)
-               cpu = "c3-2";
-             else if (model >= 6)
-               cpu = "c3";
-             else
-               processor = PROCESSOR_GENERIC;
-             break;
-           case 5:
-             if (has_3dnow)
-               cpu = "winchip2";
-             else if (has_mmx)
-               cpu = "winchip2-c6";
-             else
-               processor = PROCESSOR_GENERIC;
-             break;
-           default:
-             /* We have no idea.  */
-             processor = PROCESSOR_GENERIC;
-           }
+       default:
+         /* We have no idea.  */
+         break;
+
+       case 5:
+         if (has_3dnow || has_mmx)
+           processor = PROCESSOR_I486;
+         break;
+
+       case 6:
+         if (model > 9 || has_longmode)
+           /* Use the default detection procedure.  */
+           ;
+         else if (model == 9)
+           processor = PROCESSOR_PENTIUMPRO;
+         else if (model >= 6)
+           processor = PROCESSOR_I486;
         }
      }
    else
@@ -694,7 +688,18 @@ const char *host_detect_local_cpu (int argc, const char **argv)
        /* Default.  */
        break;
      case PROCESSOR_I486:
-      cpu = "i486";
+      if (arch && vendor == signature_CENTAUR_ebx)
+       {
+         if (model >= 6)
+           cpu = "c3";
+         else if (has_3dnow)
+           cpu = "winchip2";
+         else
+           /* Assume WinChip C6.  */
+           cpu = "winchip-c6";
+       }
+      else
+       cpu = "i486";
        break;
      case PROCESSOR_PENTIUM:
        if (arch && has_mmx)
@@ -817,8 +822,13 @@ const char *host_detect_local_cpu (int argc, const char **argv)
                 /* It is Pentium M.  */
                 cpu = "pentium-m";
               else if (has_sse)
-               /* It is Pentium III.  */
-               cpu = "pentium3";
+               {
+                 if (vendor == signature_CENTAUR_ebx)
+                   cpu = "c3-2";
+                 else
+                   /* It is Pentium III.  */
+                   cpu = "pentium3";
+               }
               else if (has_mmx)
                 /* It is Pentium II.  */
                 cpu = "pentium2";
@@ -902,6 +912,11 @@ const char *host_detect_local_cpu (int argc, const char **argv)
               else
                 cpu = "prescott";
             }
+         else if (has_longmode)
+           /* Perhaps some emulator?  Assume x86-64, otherwise gcc
+              -march=native would be unusable for 64-bit compilations,
+              as all the CPUs below are 32-bit only.  */
+           cpu = "x86-64";
           else if (has_sse2)
             cpu = "pentium4";
           else if (has_cmov)
diff --git a/gcc/config/i386/i386-builtin-types.def b/gcc/config/i386/i386-builtin-types.def

index b892f08..86139db 100644 (file)
--- a/gcc/config/i386/i386-builtin-types.def
+++ b/gcc/config/i386/i386-builtin-types.def
@@ -292,6 +292,7 @@ DEF_FUNCTION_TYPE (V8DF, V4DF)
  DEF_FUNCTION_TYPE (V8DF, V2DF)
  DEF_FUNCTION_TYPE (V16SI, V4SI)
  DEF_FUNCTION_TYPE (V16SI, V8SI)
+DEF_FUNCTION_TYPE (V16SI, V16SF)
  DEF_FUNCTION_TYPE (V16SI, V16SI, V16SI, UHI)
  DEF_FUNCTION_TYPE (V8DI, V8DI, V8DI, UQI)
  DEF_FUNCTION_TYPE (V8DI, PV8DI)
@@ -1035,14 +1036,17 @@ DEF_FUNCTION_TYPE (VOID, QI, V8DI, PCINT, INT, INT)
  
  DEF_FUNCTION_TYPE_ALIAS (V2DF_FTYPE_V2DF, ROUND)
  DEF_FUNCTION_TYPE_ALIAS (V4DF_FTYPE_V4DF, ROUND)
+DEF_FUNCTION_TYPE_ALIAS (V8DF_FTYPE_V8DF, ROUND)
  DEF_FUNCTION_TYPE_ALIAS (V4SF_FTYPE_V4SF, ROUND)
  DEF_FUNCTION_TYPE_ALIAS (V8SF_FTYPE_V8SF, ROUND)
+DEF_FUNCTION_TYPE_ALIAS (V16SF_FTYPE_V16SF, ROUND)
  
  DEF_FUNCTION_TYPE_ALIAS (V4SI_FTYPE_V2DF_V2DF, ROUND)
  DEF_FUNCTION_TYPE_ALIAS (V8SI_FTYPE_V4DF_V4DF, ROUND)
  DEF_FUNCTION_TYPE_ALIAS (V16SI_FTYPE_V8DF_V8DF, ROUND)
  DEF_FUNCTION_TYPE_ALIAS (V4SI_FTYPE_V4SF, ROUND)
  DEF_FUNCTION_TYPE_ALIAS (V8SI_FTYPE_V8SF, ROUND)
+DEF_FUNCTION_TYPE_ALIAS (V16SI_FTYPE_V16SF, ROUND)
  
  DEF_FUNCTION_TYPE_ALIAS (INT_FTYPE_V2DF_V2DF, PTEST)
  DEF_FUNCTION_TYPE_ALIAS (INT_FTYPE_V2DI_V2DI, PTEST)
diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c

index f5d095c..cb4bd8f 100644 (file)
--- a/gcc/config/i386/i386.c
+++ b/gcc/config/i386/i386.c
@@ -18895,7 +18895,7 @@ ix86_avx256_split_vector_move_misalign (rtx op0, rtx op1)
           m = adjust_address (op0, mode, 0);
           emit_insn (extract (m, op1, const0_rtx));
           m = adjust_address (op0, mode, 16);
-         emit_insn (extract (m, op1, const1_rtx));
+         emit_insn (extract (m, copy_rtx (op1), const1_rtx));
         }
        else
         emit_insn (store_unaligned (op0, op1));
@@ -19203,7 +19203,7 @@ ix86_expand_vector_move_misalign (machine_mode mode, rtx operands[])
               m = adjust_address (op0, V2SFmode, 0);
               emit_insn (gen_sse_storelps (m, op1));
               m = adjust_address (op0, V2SFmode, 8);
-             emit_insn (gen_sse_storehps (m, op1));
+             emit_insn (gen_sse_storehps (m, copy_rtx (op1)));
             }
         }
      }
@@ -30686,7 +30686,7 @@ enum ix86_builtins
    IX86_BUILTIN_CVTPD2PS512,
    IX86_BUILTIN_CVTPD2UDQ512,
    IX86_BUILTIN_CVTPH2PS512,
-  IX86_BUILTIN_CVTPS2DQ512,
+  IX86_BUILTIN_CVTPS2DQ512_MASK,
    IX86_BUILTIN_CVTPS2PD512,
    IX86_BUILTIN_CVTPS2PH512,
    IX86_BUILTIN_CVTPS2UDQ512,
@@ -32126,14 +32126,25 @@ enum ix86_builtins
    IX86_BUILTIN_COPYSIGNQ,
  
    /* Vectorizer support builtins.  */
-  IX86_BUILTIN_CEILPD_VEC_PACK_SFIX512,
    IX86_BUILTIN_CPYSGNPS,
    IX86_BUILTIN_CPYSGNPD,
    IX86_BUILTIN_CPYSGNPS256,
    IX86_BUILTIN_CPYSGNPS512,
    IX86_BUILTIN_CPYSGNPD256,
    IX86_BUILTIN_CPYSGNPD512,
+  IX86_BUILTIN_FLOORPS512,
+  IX86_BUILTIN_FLOORPD512,
+  IX86_BUILTIN_CEILPS512,
+  IX86_BUILTIN_CEILPD512,
+  IX86_BUILTIN_TRUNCPS512,
+  IX86_BUILTIN_TRUNCPD512,
+  IX86_BUILTIN_CVTPS2DQ512,
+  IX86_BUILTIN_VEC_PACK_SFIX512,
+  IX86_BUILTIN_FLOORPS_SFIX512,
    IX86_BUILTIN_FLOORPD_VEC_PACK_SFIX512,
+  IX86_BUILTIN_CEILPS_SFIX512,
+  IX86_BUILTIN_CEILPD_VEC_PACK_SFIX512,
+  IX86_BUILTIN_ROUNDPS_AZ_SFIX512,
    IX86_BUILTIN_ROUNDPD_AZ_VEC_PACK_SFIX512,
  
  
@@ -33948,6 +33959,17 @@ static const struct builtin_description bdesc_args[] =
    { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_sqrtv8df2, "__builtin_ia32_sqrtpd512", IX86_BUILTIN_SQRTPD512, UNKNOWN, (int) V8DF_FTYPE_V8DF },
    { OPTION_MASK_ISA_AVX512F, CODE_FOR_sqrtv16sf2, "__builtin_ia32_sqrtps512", IX86_BUILTIN_SQRTPS_NR512, UNKNOWN, (int) V16SF_FTYPE_V16SF },
    { OPTION_MASK_ISA_AVX512ER, CODE_FOR_avx512er_exp2v16sf, "__builtin_ia32_exp2ps", IX86_BUILTIN_EXP2PS, UNKNOWN, (int) V16SF_FTYPE_V16SF },
+  { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_roundps512, "__builtin_ia32_floorps512", IX86_BUILTIN_FLOORPS512, (enum rtx_code) ROUND_FLOOR, (int) V16SF_FTYPE_V16SF_ROUND },
+  { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_roundps512, "__builtin_ia32_ceilps512", IX86_BUILTIN_CEILPS512, (enum rtx_code) ROUND_CEIL, (int) V16SF_FTYPE_V16SF_ROUND },
+  { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_roundps512, "__builtin_ia32_truncps512", IX86_BUILTIN_TRUNCPS512, (enum rtx_code) ROUND_TRUNC, (int) V16SF_FTYPE_V16SF_ROUND },
+  { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_roundpd512, "__builtin_ia32_floorpd512", IX86_BUILTIN_FLOORPD512, (enum rtx_code) ROUND_FLOOR, (int) V8DF_FTYPE_V8DF_ROUND },
+  { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_roundpd512, "__builtin_ia32_ceilpd512", IX86_BUILTIN_CEILPD512, (enum rtx_code) ROUND_CEIL, (int) V8DF_FTYPE_V8DF_ROUND },
+  { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_roundpd512, "__builtin_ia32_truncpd512", IX86_BUILTIN_TRUNCPD512, (enum rtx_code) ROUND_TRUNC, (int) V8DF_FTYPE_V8DF_ROUND },
+  { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_fix_notruncv16sfv16si, "__builtin_ia32_cvtps2dq512", IX86_BUILTIN_CVTPS2DQ512, UNKNOWN, (int) V16SI_FTYPE_V16SF },
+  { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_vec_pack_sfix_v8df, "__builtin_ia32_vec_pack_sfix512", IX86_BUILTIN_VEC_PACK_SFIX512, UNKNOWN, (int) V16SI_FTYPE_V8DF_V8DF },
+  { OPTION_MASK_ISA_AVX512F, CODE_FOR_roundv16sf2_sfix, "__builtin_ia32_roundps_az_sfix512", IX86_BUILTIN_ROUNDPS_AZ_SFIX512, UNKNOWN, (int) V16SI_FTYPE_V16SF },
+  { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_roundps512_sfix, "__builtin_ia32_floorps_sfix512", IX86_BUILTIN_FLOORPS_SFIX512, (enum rtx_code) ROUND_FLOOR, (int) V16SI_FTYPE_V16SF_ROUND },
+  { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_roundps512_sfix, "__builtin_ia32_ceilps_sfix512", IX86_BUILTIN_CEILPS_SFIX512, (enum rtx_code) ROUND_CEIL, (int) V16SI_FTYPE_V16SF_ROUND },
    { OPTION_MASK_ISA_AVX512F, CODE_FOR_roundv8df2_vec_pack_sfix, "__builtin_ia32_roundpd_az_vec_pack_sfix512", IX86_BUILTIN_ROUNDPD_AZ_VEC_PACK_SFIX512, UNKNOWN, (int) V16SI_FTYPE_V8DF_V8DF },
    { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_roundpd_vec_pack_sfix512, "__builtin_ia32_floorpd_vec_pack_sfix512", IX86_BUILTIN_FLOORPD_VEC_PACK_SFIX512, (enum rtx_code) ROUND_FLOOR, (int) V16SI_FTYPE_V8DF_V8DF_ROUND },
    { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_roundpd_vec_pack_sfix512, "__builtin_ia32_ceilpd_vec_pack_sfix512", IX86_BUILTIN_CEILPD_VEC_PACK_SFIX512, (enum rtx_code) ROUND_CEIL, (int) V16SI_FTYPE_V8DF_V8DF_ROUND },
@@ -34864,7 +34886,7 @@ static const struct builtin_description bdesc_round_args[] =
    { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_cvtpd2ps512_mask_round,  "__builtin_ia32_cvtpd2ps512_mask", IX86_BUILTIN_CVTPD2PS512, UNKNOWN, (int) V8SF_FTYPE_V8DF_V8SF_QI_INT },
    { OPTION_MASK_ISA_AVX512F, CODE_FOR_ufix_notruncv8dfv8si2_mask_round, "__builtin_ia32_cvtpd2udq512_mask", IX86_BUILTIN_CVTPD2UDQ512, UNKNOWN, (int) V8SI_FTYPE_V8DF_V8SI_QI_INT },
    { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_vcvtph2ps512_mask_round,  "__builtin_ia32_vcvtph2ps512_mask", IX86_BUILTIN_CVTPH2PS512, UNKNOWN, (int) V16SF_FTYPE_V16HI_V16SF_HI_INT },
-  { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_fix_notruncv16sfv16si_mask_round, "__builtin_ia32_cvtps2dq512_mask", IX86_BUILTIN_CVTPS2DQ512, UNKNOWN, (int) V16SI_FTYPE_V16SF_V16SI_HI_INT },
+  { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_fix_notruncv16sfv16si_mask_round, "__builtin_ia32_cvtps2dq512_mask", IX86_BUILTIN_CVTPS2DQ512_MASK, UNKNOWN, (int) V16SI_FTYPE_V16SF_V16SI_HI_INT },
    { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_cvtps2pd512_mask_round, "__builtin_ia32_cvtps2pd512_mask", IX86_BUILTIN_CVTPS2PD512, UNKNOWN, (int) V8DF_FTYPE_V8SF_V8DF_QI_INT },
    { OPTION_MASK_ISA_AVX512F, CODE_FOR_avx512f_ufix_notruncv16sfv16si_mask_round, "__builtin_ia32_cvtps2udq512_mask", IX86_BUILTIN_CVTPS2UDQ512, UNKNOWN, (int) V16SI_FTYPE_V16SF_V16SI_HI_INT },
    { OPTION_MASK_ISA_AVX512F, CODE_FOR_sse2_cvtsd2ss_round, "__builtin_ia32_cvtsd2ss_round", IX86_BUILTIN_CVTSD2SS_ROUND, UNKNOWN, (int) V4SF_FTYPE_V4SF_V2DF_INT },
@@ -38441,10 +38463,13 @@ ix86_expand_args_builtin (const struct builtin_description *d,
      {
      case V2DF_FTYPE_V2DF_ROUND:
      case V4DF_FTYPE_V4DF_ROUND:
+    case V8DF_FTYPE_V8DF_ROUND:
      case V4SF_FTYPE_V4SF_ROUND:
      case V8SF_FTYPE_V8SF_ROUND:
+    case V16SF_FTYPE_V16SF_ROUND:
      case V4SI_FTYPE_V4SF_ROUND:
      case V8SI_FTYPE_V8SF_ROUND:
+    case V16SI_FTYPE_V16SF_ROUND:
        return ix86_expand_sse_round (d, exp, target);
      case V4SI_FTYPE_V2DF_V2DF_ROUND:
      case V8SI_FTYPE_V4DF_V4DF_ROUND:
@@ -38558,6 +38583,7 @@ ix86_expand_args_builtin (const struct builtin_description *d,
      case V16SI_FTYPE_V8SI:
      case V16SF_FTYPE_V4SF:
      case V16SI_FTYPE_V4SI:
+    case V16SI_FTYPE_V16SF:
      case V16SF_FTYPE_V16SF:
      case V8DI_FTYPE_UQI:
      case V8DF_FTYPE_V4DF:
@@ -42263,6 +42289,8 @@ ix86_builtin_vectorized_function (unsigned int fn, tree type_out,
             return ix86_get_builtin (IX86_BUILTIN_FLOORPS_SFIX);
           else if (out_n == 8 && in_n == 8)
             return ix86_get_builtin (IX86_BUILTIN_FLOORPS_SFIX256);
+         else if (out_n == 16 && in_n == 16)
+           return ix86_get_builtin (IX86_BUILTIN_FLOORPS_SFIX512);
         }
        break;
  
@@ -42288,6 +42316,8 @@ ix86_builtin_vectorized_function (unsigned int fn, tree type_out,
             return ix86_get_builtin (IX86_BUILTIN_CEILPS_SFIX);
           else if (out_n == 8 && in_n == 8)
             return ix86_get_builtin (IX86_BUILTIN_CEILPS_SFIX256);
+         else if (out_n == 16 && in_n == 16)
+           return ix86_get_builtin (IX86_BUILTIN_CEILPS_SFIX512);
         }
        break;
  
@@ -42300,6 +42330,8 @@ ix86_builtin_vectorized_function (unsigned int fn, tree type_out,
             return ix86_get_builtin (IX86_BUILTIN_VEC_PACK_SFIX);
           else if (out_n == 8 && in_n == 4)
             return ix86_get_builtin (IX86_BUILTIN_VEC_PACK_SFIX256);
+         else if (out_n == 16 && in_n == 8)
+           return ix86_get_builtin (IX86_BUILTIN_VEC_PACK_SFIX512);
         }
        if (out_mode == SImode && in_mode == SFmode)
         {
@@ -42307,6 +42339,8 @@ ix86_builtin_vectorized_function (unsigned int fn, tree type_out,
             return ix86_get_builtin (IX86_BUILTIN_CVTPS2DQ);
           else if (out_n == 8 && in_n == 8)
             return ix86_get_builtin (IX86_BUILTIN_CVTPS2DQ256);
+         else if (out_n == 16 && in_n == 16)
+           return ix86_get_builtin (IX86_BUILTIN_CVTPS2DQ512);
         }
        break;
  
@@ -42332,6 +42366,8 @@ ix86_builtin_vectorized_function (unsigned int fn, tree type_out,
             return ix86_get_builtin (IX86_BUILTIN_ROUNDPS_AZ_SFIX);
           else if (out_n == 8 && in_n == 8)
             return ix86_get_builtin (IX86_BUILTIN_ROUNDPS_AZ_SFIX256);
+         else if (out_n == 16 && in_n == 16)
+           return ix86_get_builtin (IX86_BUILTIN_ROUNDPS_AZ_SFIX512);
         }
        break;
  
@@ -42346,6 +42382,8 @@ ix86_builtin_vectorized_function (unsigned int fn, tree type_out,
             return ix86_get_builtin (IX86_BUILTIN_FLOORPD);
           else if (out_n == 4 && in_n == 4)
             return ix86_get_builtin (IX86_BUILTIN_FLOORPD256);
+         else if (out_n == 8 && in_n == 8)
+           return ix86_get_builtin (IX86_BUILTIN_FLOORPD512);
         }
        if (out_mode == SFmode && in_mode == SFmode)
         {
@@ -42353,6 +42391,8 @@ ix86_builtin_vectorized_function (unsigned int fn, tree type_out,
             return ix86_get_builtin (IX86_BUILTIN_FLOORPS);
           else if (out_n == 8 && in_n == 8)
             return ix86_get_builtin (IX86_BUILTIN_FLOORPS256);
+         else if (out_n == 16 && in_n == 16)
+           return ix86_get_builtin (IX86_BUILTIN_FLOORPS512);
         }
        break;
  
@@ -42367,6 +42407,8 @@ ix86_builtin_vectorized_function (unsigned int fn, tree type_out,
             return ix86_get_builtin (IX86_BUILTIN_CEILPD);
           else if (out_n == 4 && in_n == 4)
             return ix86_get_builtin (IX86_BUILTIN_CEILPD256);
+         else if (out_n == 8 && in_n == 8)
+           return ix86_get_builtin (IX86_BUILTIN_CEILPD512);
         }
        if (out_mode == SFmode && in_mode == SFmode)
         {
@@ -42374,6 +42416,8 @@ ix86_builtin_vectorized_function (unsigned int fn, tree type_out,
             return ix86_get_builtin (IX86_BUILTIN_CEILPS);
           else if (out_n == 8 && in_n == 8)
             return ix86_get_builtin (IX86_BUILTIN_CEILPS256);
+         else if (out_n == 16 && in_n == 16)
+           return ix86_get_builtin (IX86_BUILTIN_CEILPS512);
         }
        break;
  
@@ -42388,6 +42432,8 @@ ix86_builtin_vectorized_function (unsigned int fn, tree type_out,
             return ix86_get_builtin (IX86_BUILTIN_TRUNCPD);
           else if (out_n == 4 && in_n == 4)
             return ix86_get_builtin (IX86_BUILTIN_TRUNCPD256);
+         else if (out_n == 8 && in_n == 8)
+           return ix86_get_builtin (IX86_BUILTIN_TRUNCPD512);
         }
        if (out_mode == SFmode && in_mode == SFmode)
         {
@@ -42395,6 +42441,8 @@ ix86_builtin_vectorized_function (unsigned int fn, tree type_out,
             return ix86_get_builtin (IX86_BUILTIN_TRUNCPS);
           else if (out_n == 8 && in_n == 8)
             return ix86_get_builtin (IX86_BUILTIN_TRUNCPS256);
+         else if (out_n == 16 && in_n == 16)
+           return ix86_get_builtin (IX86_BUILTIN_TRUNCPS512);
         }
        break;
  
diff --git a/gcc/config/i386/i386.h b/gcc/config/i386/i386.h

index d0b418b..ec306f3 100644 (file)
--- a/gcc/config/i386/i386.h
+++ b/gcc/config/i386/i386.h
@@ -465,6 +465,8 @@ extern unsigned char ix86_tune_features[X86_TUNE_LAST];
         ix86_tune_features[X86_TUNE_SLOW_PSHUFB]
  #define TARGET_VECTOR_PARALLEL_EXECUTION \
         ix86_tune_features[X86_TUNE_VECTOR_PARALLEL_EXECUTION]
+#define TARGET_AVOID_4BYTE_PREFIXES \
+       ix86_tune_features[X86_TUNE_AVOID_4BYTE_PREFIXES]
  #define TARGET_FUSE_CMP_AND_BRANCH_32 \
         ix86_tune_features[X86_TUNE_FUSE_CMP_AND_BRANCH_32]
  #define TARGET_FUSE_CMP_AND_BRANCH_64 \
diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md

index cf29e5d..b1780a7 100644 (file)
--- a/gcc/config/i386/i386.md
+++ b/gcc/config/i386/i386.md
@@ -9332,7 +9332,7 @@
  })
  
  (define_split
-  [(set (match_operand:SF 0 "register_operand")
+  [(set (match_operand:SF 0 "general_reg_operand")
         (match_operator:SF 1 "absneg_operator" [(match_dup 0)]))
     (use (match_operand:V4SF 2))
     (clobber (reg:CC FLAGS_REG))]
@@ -9356,7 +9356,7 @@
  })
  
  (define_split
-  [(set (match_operand:DF 0 "register_operand")
+  [(set (match_operand:DF 0 "general_reg_operand")
         (match_operator:DF 1 "absneg_operator" [(match_dup 0)]))
     (use (match_operand 2))
     (clobber (reg:CC FLAGS_REG))]
@@ -9394,7 +9394,7 @@
  })
  
  (define_split
-  [(set (match_operand:XF 0 "register_operand")
+  [(set (match_operand:XF 0 "general_reg_operand")
         (match_operator:XF 1 "absneg_operator" [(match_dup 0)]))
     (use (match_operand 2))
     (clobber (reg:CC FLAGS_REG))]
@@ -11078,20 +11078,19 @@
                    (const_int 1))
               (clobber (reg:CC FLAGS_REG))])]
    "TARGET_64BIT && !TARGET_USE_BT"
-  [(const_int 0)]
+  [(parallel [(set (match_dup 0)
+                  (ior:DI (match_dup 0) (match_dup 3)))
+             (clobber (reg:CC FLAGS_REG))])]
  {
    int i = INTVAL (operands[1]);
  
-  rtx op1 = gen_int_mode (HOST_WIDE_INT_1U << i, DImode);
+  operands[3] = gen_int_mode (HOST_WIDE_INT_1U << i, DImode);
  
-  if (i >= 31)
+  if (!x86_64_immediate_operand (operands[3], DImode))
      {
-      emit_move_insn (operands[2], op1);
-      op1 = operands[2];
+      emit_move_insn (operands[2], operands[3]);
+      operands[3] = operands[2];
      }
-
-  emit_insn (gen_iordi3 (operands[0], operands[0], op1));
-  DONE;
  })
  
  (define_peephole2
@@ -11103,20 +11102,19 @@
                    (const_int 0))
               (clobber (reg:CC FLAGS_REG))])]
    "TARGET_64BIT && !TARGET_USE_BT"
-  [(const_int 0)]
+  [(parallel [(set (match_dup 0)
+                  (and:DI (match_dup 0) (match_dup 3)))
+             (clobber (reg:CC FLAGS_REG))])]
  {
    int i = INTVAL (operands[1]);
  
-  rtx op1 = gen_int_mode (HOST_WIDE_INT_1U << i, DImode);
+  operands[3] = gen_int_mode (~(HOST_WIDE_INT_1U << i), DImode);
   
-  if (i >= 32)
+  if (!x86_64_immediate_operand (operands[3], DImode))
      {
-      emit_move_insn (operands[2], op1);
-      op1 = operands[2];
+      emit_move_insn (operands[2], operands[3]);
+      operands[3] = operands[2];
      }
-
-  emit_insn (gen_anddi3 (operands[0], operands[0], op1));
-  DONE;
  })
  
  (define_peephole2
@@ -11129,20 +11127,19 @@
                         (match_dup 0) (const_int 1) (match_dup 1))))
               (clobber (reg:CC FLAGS_REG))])]
    "TARGET_64BIT && !TARGET_USE_BT"
-  [(const_int 0)]
+  [(parallel [(set (match_dup 0)
+                  (xor:DI (match_dup 0) (match_dup 3)))
+             (clobber (reg:CC FLAGS_REG))])]
  {
    int i = INTVAL (operands[1]);
  
-  rtx op1 = gen_int_mode (HOST_WIDE_INT_1U << i, DImode);
+  operands[3] = gen_int_mode (HOST_WIDE_INT_1U << i, DImode);
  
-  if (i >= 31)
+  if (!x86_64_immediate_operand (operands[3], DImode))
      {
-      emit_move_insn (operands[2], op1);
-      op1 = operands[2];
+      emit_move_insn (operands[2], operands[3]);
+      operands[3] = operands[2];
      }
-
-  emit_insn (gen_xordi3 (operands[0], operands[0], op1));
-  DONE;
  })
  
  (define_insn "*bt<mode>"
diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md

index a30b0b8..42506ef 100644 (file)
--- a/gcc/config/i386/sse.md
+++ b/gcc/config/i386/sse.md
@@ -4488,7 +4488,7 @@
     (set_attr "prefix" "maybe_vex")
     (set_attr "mode" "<sseinsnmode>")])
  
-(define_insn "<mask_codefor>avx512f_fix_notruncv16sfv16si<mask_name><round_name>"
+(define_insn "avx512f_fix_notruncv16sfv16si<mask_name><round_name>"
    [(set (match_operand:V16SI 0 "register_operand" "=v")
         (unspec:V16SI
           [(match_operand:V16SF 1 "<round_nimm_predicate>" "<round_constraint>")]
@@ -5046,7 +5046,7 @@
     (set_attr "ssememalign" "64")
     (set_attr "mode" "V2DF")])
  
-(define_insn "<mask_codefor>avx512f_cvtpd2dq512<mask_name><round_name>"
+(define_insn "avx512f_cvtpd2dq512<mask_name><round_name>"
    [(set (match_operand:V8SI 0 "register_operand" "=v")
         (unspec:V8SI
           [(match_operand:V8DF 1 "<round_nimm_predicate>" "<round_constraint>")]
@@ -6006,6 +6006,23 @@
    DONE;
  })
  
+(define_expand "avx512f_vec_pack_sfix_v8df"
+  [(match_operand:V16SI 0 "register_operand")
+   (match_operand:V8DF 1 "nonimmediate_operand")
+   (match_operand:V8DF 2 "nonimmediate_operand")]
+  "TARGET_AVX512F"
+{
+  rtx r1, r2;
+
+  r1 = gen_reg_rtx (V8SImode);
+  r2 = gen_reg_rtx (V8SImode);
+
+  emit_insn (gen_avx512f_cvtpd2dq512 (r1, operands[1]));
+  emit_insn (gen_avx512f_cvtpd2dq512 (r2, operands[2]));
+  emit_insn (gen_avx_vec_concatv16si (operands[0], r1, r2));
+  DONE;
+})
+
  (define_expand "vec_pack_sfix_v4df"
    [(match_operand:V8SI 0 "register_operand")
     (match_operand:V4DF 1 "nonimmediate_operand")
@@ -15247,13 +15264,25 @@
    DONE;
  })
  
-(define_expand "avx512f_roundpd512"
-  [(match_operand:V8DF 0 "register_operand")
-   (match_operand:V8DF 1 "nonimmediate_operand")
+(define_expand "avx512f_round<castmode>512"
+  [(match_operand:VF_512 0 "register_operand")
+   (match_operand:VF_512 1 "nonimmediate_operand")
+   (match_operand:SI 2 "const_0_to_15_operand")]
+  "TARGET_AVX512F"
+{
+  emit_insn (gen_avx512f_rndscale<mode> (operands[0], operands[1], operands[2]));
+  DONE;
+})
+
+(define_expand "avx512f_roundps512_sfix"
+  [(match_operand:V16SI 0 "register_operand")
+   (match_operand:V16SF 1 "nonimmediate_operand")
     (match_operand:SI 2 "const_0_to_15_operand")]
    "TARGET_AVX512F"
  {
-  emit_insn (gen_avx512f_rndscalev8df (operands[0], operands[1], operands[2]));
+  rtx tmp = gen_reg_rtx (V16SFmode);
+  emit_insn (gen_avx512f_rndscalev16sf (tmp, operands[1], operands[2]));
+  emit_insn (gen_fix_truncv16sfv16si2 (operands[0], tmp));
    DONE;
  })
  
@@ -15353,7 +15382,7 @@
  
  (define_expand "round<mode>2_sfix"
    [(match_operand:<sseintvecmode> 0 "register_operand")
-   (match_operand:VF1_128_256 1 "register_operand")]
+   (match_operand:VF1 1 "register_operand")]
    "TARGET_ROUND && !flag_trapping_math"
  {
    rtx tmp = gen_reg_rtx (<MODE>mode);
diff --git a/gcc/config/microblaze/rtems.h b/gcc/config/microblaze/rtems.h

index 68aa381..56f3f70 100644 (file)
--- a/gcc/config/microblaze/rtems.h
+++ b/gcc/config/microblaze/rtems.h
@@ -23,3 +23,10 @@ along with GCC; see the file COPYING3.  If not see
    builtin_define( "__rtems__" );               \
    builtin_assert( "system=rtems" );            \
  } while (0)
+
+/* Redefine to include only items relevant for RTEMS */
+#undef LINK_SPEC
+#define LINK_SPEC "%{shared:-shared} -N -relax \
+  %{mbig-endian:-EB --oformat=elf32-microblaze} \
+  %{mlittle-endian:-EL --oformat=elf32-microblazeel} \
+  %{mxl-gp-opt:%{G*}} %{!mxl-gp-opt: -G 0}"
diff --git a/gcc/config/nvptx/nvptx.c b/gcc/config/nvptx/nvptx.c

index b088cf8..a6c90b6 100644 (file)
--- a/gcc/config/nvptx/nvptx.c
+++ b/gcc/config/nvptx/nvptx.c
@@ -483,7 +483,7 @@ nvptx_strict_argument_naming (cumulative_args_t cum_v)
  static rtx
  nvptx_libcall_value (machine_mode mode, const_rtx)
  {
-  if (!cfun->machine->doing_call)
+  if (!cfun || !cfun->machine->doing_call)
      /* Pretend to return in a hard reg for early uses before pseudos can be
         generated.  */
      return gen_rtx_REG (mode, NVPTX_RETURN_REGNUM);
@@ -502,6 +502,7 @@ nvptx_function_value (const_tree type, const_tree ARG_UNUSED (func),
  
    if (outgoing)
      {
+      gcc_assert (cfun);
        cfun->machine->return_mode = mode;
        return gen_rtx_REG (mode, NVPTX_RETURN_REGNUM);
      }
diff --git a/gcc/config/rs6000/altivec.h b/gcc/config/rs6000/altivec.h

index ea6af8d..f9fac68 100644 (file)
--- a/gcc/config/rs6000/altivec.h
+++ b/gcc/config/rs6000/altivec.h
@@ -327,8 +327,8 @@
  #define vec_sqrt __builtin_vec_sqrt
  #define vec_vsx_ld __builtin_vec_vsx_ld
  #define vec_vsx_st __builtin_vec_vsx_st
-#define vec_xl __builtin_vec_vsx_ld
-#define vec_xst __builtin_vec_vsx_st
+#define vec_xl __builtin_vec_xl
+#define vec_xst __builtin_vec_xst
  
  /* Note, xxsldi and xxpermdi were added as __builtin_vsx_<xxx> functions
     instead of __builtin_vec_<xxx>  */
@@ -384,6 +384,23 @@
  #define vec_vupklsw __builtin_vec_vupklsw
  #endif
  
+#ifdef _ARCH_PWR9
+/* Vector additions added in ISA 3.0.  */
+#define vec_vctz __builtin_vec_vctz
+#define vec_cntlz __builtin_vec_vctz
+#define vec_vctzb __builtin_vec_vctzb
+#define vec_vctzd __builtin_vec_vctzd
+#define vec_vctzh __builtin_vec_vctzh
+#define vec_vctzw __builtin_vec_vctzw
+#define vec_vprtyb __builtin_vec_vprtyb
+#define vec_vprtybd __builtin_vec_vprtybd
+#define vec_vprtybw __builtin_vec_vprtybw
+
+#ifdef _ARCH_PPC64
+#define vec_vprtybq __builtin_vec_vprtybq
+#endif
+#endif
+
  /* Predicates.
     For C++, we use templates in order to allow non-parenthesized arguments.
     For C, instead, we use macros since non-parenthesized arguments were
diff --git a/gcc/config/rs6000/altivec.md b/gcc/config/rs6000/altivec.md

index 9c3084d..3707091 100644 (file)
--- a/gcc/config/rs6000/altivec.md
+++ b/gcc/config/rs6000/altivec.md
@@ -58,6 +58,7 @@
     UNSPEC_VSUM2SWS
     UNSPEC_VSUMSWS
     UNSPEC_VPERM
+   UNSPEC_VPERMR
     UNSPEC_VPERM_UNS
     UNSPEC_VRFIN
     UNSPEC_VCFUX
@@ -73,6 +74,9 @@
     UNSPEC_VUNPACK_LO_SIGN_DIRECT
     UNSPEC_VUPKHPX
     UNSPEC_VUPKLPX
+   UNSPEC_DARN
+   UNSPEC_DARN_32
+   UNSPEC_DARN_RAW
     UNSPEC_DST
     UNSPEC_DSTT
     UNSPEC_DSTST
@@ -189,6 +193,13 @@
                            (KF "FLOAT128_VECTOR_P (KFmode)")
                            (TF "FLOAT128_VECTOR_P (TFmode)")])
  
+;; Specific iterator for parity which does not have a byte/half-word form, but
+;; does have a quad word form
+(define_mode_iterator VParity [V4SI
+                              V2DI
+                              V1TI
+                              (TI "TARGET_VSX_TIMODE")])
+
  (define_mode_attr VI_char [(V2DI "d") (V4SI "w") (V8HI "h") (V16QI "b")])
  (define_mode_attr VI_scalar [(V2DI "DI") (V4SI "SI") (V8HI "HI") (V16QI "QI")])
  (define_mode_attr VI_unit [(V16QI "VECTOR_UNIT_ALTIVEC_P (V16QImode)")
@@ -203,6 +214,9 @@
  (define_mode_attr VP_small_lc [(V2DI "v4si") (V4SI "v8hi") (V8HI "v16qi")])
  (define_mode_attr VU_char [(V2DI "w") (V4SI "h") (V8HI "b")])
  
+;; Vector negate
+(define_mode_iterator VNEG [V4SI V2DI])
+
  ;; Vector move instructions.
  (define_insn "*altivec_mov<mode>"
    [(set (match_operand:VM2 0 "nonimmediate_operand" "=Z,v,v,*Y,*r,*r,v,v,*r")
@@ -1949,32 +1963,30 @@
  
  ;; Slightly prefer vperm, since the target does not overlap the source
  (define_insn "*altivec_vperm_<mode>_internal"
-  [(set (match_operand:VM 0 "register_operand" "=v,?wo,?&wo")
-       (unspec:VM [(match_operand:VM 1 "register_operand" "v,0,wo")
-                   (match_operand:VM 2 "register_operand" "v,wo,wo")
-                   (match_operand:V16QI 3 "register_operand" "v,wo,wo")]
+  [(set (match_operand:VM 0 "register_operand" "=v,?wo")
+       (unspec:VM [(match_operand:VM 1 "register_operand" "v,0")
+                   (match_operand:VM 2 "register_operand" "v,wo")
+                   (match_operand:V16QI 3 "register_operand" "v,wo")]
                    UNSPEC_VPERM))]
    "TARGET_ALTIVEC"
    "@
     vperm %0,%1,%2,%3
-   xxperm %x0,%x2,%x3
-   xxlor %x0,%x1,%x1\t\t# xxperm fusion\;xxperm %x0,%x2,%x3"
+   xxperm %x0,%x2,%x3"
    [(set_attr "type" "vecperm")
-   (set_attr "length" "4,4,8")])
+   (set_attr "length" "4")])
  
  (define_insn "altivec_vperm_v8hiv16qi"
-  [(set (match_operand:V16QI 0 "register_operand" "=v,?wo,?&wo")
-       (unspec:V16QI [(match_operand:V8HI 1 "register_operand" "v,0,wo")
-                      (match_operand:V8HI 2 "register_operand" "v,wo,wo")
-                      (match_operand:V16QI 3 "register_operand" "v,wo,wo")]
+  [(set (match_operand:V16QI 0 "register_operand" "=v,?wo")
+       (unspec:V16QI [(match_operand:V8HI 1 "register_operand" "v,0")
+                      (match_operand:V8HI 2 "register_operand" "v,wo")
+                      (match_operand:V16QI 3 "register_operand" "v,wo")]
                    UNSPEC_VPERM))]
    "TARGET_ALTIVEC"
    "@
     vperm %0,%1,%2,%3
-   xxperm %x0,%x2,%x3
-   xxlor %x0,%x1,%x1\t\t# xxperm fusion\;xxperm %x0,%x2,%x3"
+   xxperm %x0,%x2,%x3"
    [(set_attr "type" "vecperm")
-   (set_attr "length" "4,4,8")])
+   (set_attr "length" "4")])
  
  (define_expand "altivec_vperm_<mode>_uns"
    [(set (match_operand:VM 0 "register_operand" "")
@@ -1992,18 +2004,17 @@
  })
  
  (define_insn "*altivec_vperm_<mode>_uns_internal"
-  [(set (match_operand:VM 0 "register_operand" "=v,?wo,?&wo")
-       (unspec:VM [(match_operand:VM 1 "register_operand" "v,0,wo")
-                   (match_operand:VM 2 "register_operand" "v,wo,wo")
-                   (match_operand:V16QI 3 "register_operand" "v,wo,wo")]
+  [(set (match_operand:VM 0 "register_operand" "=v,?wo")
+       (unspec:VM [(match_operand:VM 1 "register_operand" "v,0")
+                   (match_operand:VM 2 "register_operand" "v,wo")
+                   (match_operand:V16QI 3 "register_operand" "v,wo")]
                    UNSPEC_VPERM_UNS))]
    "TARGET_ALTIVEC"
    "@
     vperm %0,%1,%2,%3
-   xxperm %x0,%x2,%x3
-   xxlor %x0,%x1,%x1\t\t# xxperm fusion\;xxperm %x0,%x2,%x3"
+   xxperm %x0,%x2,%x3"
    [(set_attr "type" "vecperm")
-   (set_attr "length" "4,4,8")])
+   (set_attr "length" "4")])
  
  (define_expand "vec_permv16qi"
    [(set (match_operand:V16QI 0 "register_operand" "")
@@ -2032,6 +2043,19 @@
      FAIL;
  })
  
+(define_insn "*altivec_vpermr_<mode>_internal"
+  [(set (match_operand:VM 0 "register_operand" "=v,?wo")
+       (unspec:VM [(match_operand:VM 1 "register_operand" "v,0")
+                   (match_operand:VM 2 "register_operand" "v,wo")
+                   (match_operand:V16QI 3 "register_operand" "v,wo")]
+                  UNSPEC_VPERMR))]
+  "TARGET_P9_VECTOR"
+  "@
+   vpermr %0,%1,%2,%3
+   xxpermr %x0,%x2,%x3"
+  [(set_attr "type" "vecperm")
+   (set_attr "length" "4")])
+
  (define_insn "altivec_vrfip"           ; ceil
    [(set (match_operand:V4SF 0 "register_operand" "=v")
          (unspec:V4SF [(match_operand:V4SF 1 "register_operand" "v")]
@@ -2690,20 +2714,28 @@
    DONE;
  })
  
+(define_insn "*p9_neg<mode>2"
+  [(set (match_operand:VNEG 0 "altivec_register_operand" "=v")
+       (neg:VNEG (match_operand:VNEG 1 "altivec_register_operand" "v")))]
+  "TARGET_P9_VECTOR"
+  "vneg<VI_char> %0,%1"
+  [(set_attr "type" "vecsimple")])
+
  (define_expand "neg<mode>2"
-  [(use (match_operand:VI 0 "register_operand" ""))
-   (use (match_operand:VI 1 "register_operand" ""))]
-  "TARGET_ALTIVEC"
-  "
+  [(set (match_operand:VI2 0 "register_operand" "")
+       (neg:VI2 (match_operand:VI2 1 "register_operand" "")))]
+  "<VI_unit>"
  {
-  rtx vzero;
+  if (!TARGET_P9_VECTOR || (<MODE>mode != V4SImode && <MODE>mode != V2DImode))
+    {
+      rtx vzero;
  
-  vzero = gen_reg_rtx (GET_MODE (operands[0]));
-  emit_insn (gen_altivec_vspltis<VI_char> (vzero, const0_rtx));
-  emit_insn (gen_sub<mode>3 (operands[0], vzero, operands[1])); 
-  
-  DONE;
-}")
+      vzero = gen_reg_rtx (GET_MODE (operands[0]));
+      emit_move_insn (vzero, CONST0_RTX (<MODE>mode));
+      emit_insn (gen_sub<mode>3 (operands[0], vzero, operands[1]));
+      DONE;
+    }
+})
  
  (define_expand "udot_prod<mode>"
    [(set (match_operand:V4SI 0 "register_operand" "=v")
@@ -2791,32 +2823,30 @@
    "")
  
  (define_insn "vperm_v8hiv4si"
-  [(set (match_operand:V4SI 0 "register_operand" "=v,?wo,?&wo")
-        (unspec:V4SI [(match_operand:V8HI 1 "register_operand" "v,0,wo")
-                     (match_operand:V4SI 2 "register_operand" "v,wo,wo")
-                     (match_operand:V16QI 3 "register_operand" "v,wo,wo")]
+  [(set (match_operand:V4SI 0 "register_operand" "=v,?wo")
+        (unspec:V4SI [(match_operand:V8HI 1 "register_operand" "v,0")
+                     (match_operand:V4SI 2 "register_operand" "v,wo")
+                     (match_operand:V16QI 3 "register_operand" "v,wo")]
                    UNSPEC_VPERMSI))]
    "TARGET_ALTIVEC"
    "@
     vperm %0,%1,%2,%3
-   xxperm %x0,%x2,%x3
-   xxlor %x0,%x1,%x1\t\t# xxperm fusion\;xxperm %x0,%x2,%x3"
+   xxperm %x0,%x2,%x3"
    [(set_attr "type" "vecperm")
-   (set_attr "length" "4,4,8")])
+   (set_attr "length" "4")])
  
  (define_insn "vperm_v16qiv8hi"
-  [(set (match_operand:V8HI 0 "register_operand" "=v,?wo,?&wo")
-        (unspec:V8HI [(match_operand:V16QI 1 "register_operand" "v,0,wo")
-                     (match_operand:V8HI 2 "register_operand" "v,wo,wo")
-                     (match_operand:V16QI 3 "register_operand" "v,wo,wo")]
+  [(set (match_operand:V8HI 0 "register_operand" "=v,?wo")
+        (unspec:V8HI [(match_operand:V16QI 1 "register_operand" "v,0")
+                     (match_operand:V8HI 2 "register_operand" "v,wo")
+                     (match_operand:V16QI 3 "register_operand" "v,wo")]
                    UNSPEC_VPERMHI))]
    "TARGET_ALTIVEC"
    "@
     vperm %0,%1,%2,%3
-   xxperm %x0,%x2,%x3
-   xxlor %x0,%x1,%x1\t\t# xxperm fusion\;xxperm %x0,%x2,%x3"
+   xxperm %x0,%x2,%x3"
    [(set_attr "type" "vecperm")
-   (set_attr "length" "4,4,8")])
+   (set_attr "length" "4")])
  
  
  (define_expand "vec_unpacku_hi_v16qi"
@@ -3353,7 +3383,7 @@
  }")
  
  \f
-;; Power8 vector instructions encoded as Altivec instructions
+;; Power8/power9 vector instructions encoded as Altivec instructions
  
  ;; Vector count leading zeros
  (define_insn "*p8v_clz<mode>2"
@@ -3364,6 +3394,15 @@
    [(set_attr "length" "4")
     (set_attr "type" "vecsimple")])
  
+;; Vector count trailing zeros
+(define_insn "*p9v_ctz<mode>2"
+  [(set (match_operand:VI2 0 "register_operand" "=v")
+       (ctz:VI2 (match_operand:VI2 1 "register_operand" "v")))]
+  "TARGET_P9_VECTOR"
+  "vctz<wd> %0,%1"
+  [(set_attr "length" "4")
+   (set_attr "type" "vecsimple")])
+
  ;; Vector population count
  (define_insn "*p8v_popcount<mode>2"
    [(set (match_operand:VI2 0 "register_operand" "=v")
@@ -3373,6 +3412,15 @@
    [(set_attr "length" "4")
     (set_attr "type" "vecsimple")])
  
+;; Vector parity
+(define_insn "*p9v_parity<mode>2"
+  [(set (match_operand:VParity 0 "register_operand" "=v")
+        (parity:VParity (match_operand:VParity 1 "register_operand" "v")))]
+  "TARGET_P9_VECTOR"
+  "vprtyb<wd> %0,%1"
+  [(set_attr "length" "4")
+   (set_attr "type" "vecsimple")])
+
  ;; Vector Gather Bits by Bytes by Doubleword
  (define_insn "p8v_vgbbd"
    [(set (match_operand:V16QI 0 "register_operand" "=v")
@@ -3540,6 +3588,27 @@
    [(set_attr "length" "4")
     (set_attr "type" "vecsimple")])
  
+(define_insn "darn_32"
+  [(set (match_operand:SI 0 "register_operand" "=r")
+        (unspec:SI [(const_int 0)] UNSPEC_DARN_32))]
+  "TARGET_MODULO"
+  "darn %0,0"
+  [(set_attr "type" "integer")])
+
+(define_insn "darn_raw"
+  [(set (match_operand:DI 0 "register_operand" "=r")
+        (unspec:DI [(const_int 0)] UNSPEC_DARN_RAW))]
+  "TARGET_MODULO && TARGET_64BIT"
+  "darn %0,2"
+  [(set_attr "type" "integer")])
+
+(define_insn "darn"
+  [(set (match_operand:DI 0 "register_operand" "=r")
+        (unspec:DI [(const_int 0)] UNSPEC_DARN))]
+  "TARGET_MODULO && TARGET_64BIT"
+  "darn %0,1"
+  [(set_attr "type" "integer")])
+
  (define_expand "bcd<bcd_add_sub>_<code>"
    [(parallel [(set (reg:CCFP 74)
                    (compare:CCFP
diff --git a/gcc/config/rs6000/constraints.md b/gcc/config/rs6000/constraints.md

index ea15764..ef8f617 100644 (file)
--- a/gcc/config/rs6000/constraints.md
+++ b/gcc/config/rs6000/constraints.md
@@ -140,6 +140,10 @@
    (and (match_code "const_int")
         (match_test "TARGET_VSX && (ival == VECTOR_ELEMENT_SCALAR_64BIT)")))
  
+(define_constraint "wE"
+  "Vector constant that can be loaded with the XXSPLTIB instruction."
+  (match_test "xxspltib_constant_nosplit (op, mode)"))
+
  ;; Extended fusion store
  (define_memory_constraint "wF"
    "Memory operand suitable for power9 fusion load/stores"
@@ -156,11 +160,26 @@
         (and (match_test "TARGET_DIRECT_MOVE_128")
             (match_test "(ival == VECTOR_ELEMENT_MFVSRLD_64BIT)"))))
  
+;; Generate the XXORC instruction to set a register to all 1's
+(define_constraint "wM"
+  "Match vector constant with all 1's if the XXLORC instruction is available"
+  (and (match_test "TARGET_P8_VECTOR")
+       (match_operand 0 "all_ones_constant")))
+
+;; ISA 3.0 vector d-form addresses
+(define_memory_constraint "wO"
+  "Memory operand suitable for the ISA 3.0 vector d-form instructions."
+  (match_operand 0 "vsx_quad_dform_memory_operand"))
+
  ;; Lq/stq validates the address for load/store quad
  (define_memory_constraint "wQ"
    "Memory operand suitable for the load/store quad instructions"
    (match_operand 0 "quad_memory_operand"))
  
+(define_constraint "wS"
+  "Vector constant that can be loaded with XXSPLTIB & sign extension."
+  (match_test "xxspltib_constant_split (op, mode)"))
+
  ;; Altivec style load/store that ignores the bottom bits of the address
  (define_memory_constraint "wZ"
    "Indexed or indirect memory operand, ignoring the bottom 4 bits"
diff --git a/gcc/config/rs6000/predicates.md b/gcc/config/rs6000/predicates.md

index 71fac76..d03d164 100644 (file)
--- a/gcc/config/rs6000/predicates.md
+++ b/gcc/config/rs6000/predicates.md
@@ -572,6 +572,38 @@
      }
  })
  
+;; Return 1 if the operand is a CONST_VECTOR or VEC_DUPLICATE of a constant
+;; that can loaded with a XXSPLTIB instruction and then a VUPKHSB, VECSB2W or
+;; VECSB2D instruction.
+
+(define_predicate "xxspltib_constant_split"
+  (match_code "const_vector,vec_duplicate,const_int")
+{
+  int value = 256;
+  int num_insns = -1;
+
+  if (!xxspltib_constant_p (op, mode, &num_insns, &value))
+    return false;
+
+  return num_insns > 1;
+})
+
+
+;; Return 1 if the operand is a CONST_VECTOR that can loaded directly with a
+;; XXSPLTIB instruction.
+
+(define_predicate "xxspltib_constant_nosplit"
+  (match_code "const_vector,vec_duplicate,const_int")
+{
+  int value = 256;
+  int num_insns = -1;
+
+  if (!xxspltib_constant_p (op, mode, &num_insns, &value))
+    return false;
+
+  return num_insns == 1;
+})
+
  ;; Return 1 if the operand is a CONST_VECTOR and can be loaded into a
  ;; vector register without using memory.
  (define_predicate "easy_vector_constant"
@@ -590,7 +622,14 @@
  
    if (VECTOR_MEM_ALTIVEC_OR_VSX_P (mode))
      {
-      if (zero_constant (op, mode))
+      int value = 256;
+      int num_insns = -1;
+
+      if (zero_constant (op, mode) || all_ones_constant (op, mode))
+       return true;
+
+      if (TARGET_P9_VECTOR
+          && xxspltib_constant_p (op, mode, &num_insns, &value))
         return true;
  
        return easy_altivec_constant (op, mode);
@@ -669,6 +708,11 @@
    (and (match_code "const_int,const_double,const_wide_int,const_vector")
         (match_test "op == CONST0_RTX (mode)")))
  
+;; Return 1 if operand is constant -1 (scalars and vectors).
+(define_predicate "all_ones_constant"
+  (and (match_code "const_int,const_double,const_wide_int,const_vector")
+       (match_test "op == CONSTM1_RTX (mode) && !FLOAT_MODE_P (mode)")))
+
  ;; Return 1 if operand is 0.0.
  (define_predicate "zero_fp_constant"
    (and (match_code "const_double")
@@ -698,48 +742,25 @@
  (define_predicate "quad_memory_operand"
    (match_code "mem")
  {
-  rtx addr, op0, op1;
-  int ret;
-
    if (!TARGET_QUAD_MEMORY && !TARGET_SYNC_TI)
-    ret = 0;
-
-  else if (!memory_operand (op, mode))
-    ret = 0;
-
-  else if (GET_MODE_SIZE (GET_MODE (op)) != 16)
-    ret = 0;
-
-  else if (MEM_ALIGN (op) < 128)
-    ret = 0;
-
-  else
-    {
-      addr = XEXP (op, 0);
-      if (int_reg_operand (addr, Pmode))
-       ret = 1;
+    return false;
  
-      else if (GET_CODE (addr) != PLUS)
-       ret = 0;
+  if (GET_MODE_SIZE (mode) != 16 || !MEM_P (op) || MEM_ALIGN (op) < 128)
+    return false;
  
-      else
-       {
-         op0 = XEXP (addr, 0);
-         op1 = XEXP (addr, 1);
-         ret = (int_reg_operand (op0, Pmode)
-                && GET_CODE (op1) == CONST_INT
-                && IN_RANGE (INTVAL (op1), -32768, 32767)
-                && (INTVAL (op1) & 15) == 0);
-       }
-    }
+  return quad_address_p (XEXP (op, 0), mode, true);
+})
  
-  if (TARGET_DEBUG_ADDR)
-    {
-      fprintf (stderr, "\nquad_memory_operand, ret = %s\n", ret ? "true" : "false");
-      debug_rtx (op);
-    }
+;; Return 1 if the operand is suitable for load/store to vector registers with
+;; d-form addressing (register+offset), which was added in ISA 3.0.
+;; Unlike quad_memory_operand, we do not have to check for alignment.
+(define_predicate "vsx_quad_dform_memory_operand"
+  (match_code "mem")
+{
+  if (!TARGET_P9_DFORM_VECTOR || !MEM_P (op) || GET_MODE_SIZE (mode) != 16)
+    return false;
  
-  return ret;
+  return quad_address_p (XEXP (op, 0), mode, false);
  })
  
  ;; Return 1 if the operand is an indexed or indirect memory operand.
@@ -1054,6 +1075,10 @@
         mode = V2DFmode;
        else if (mode == DImode)
         mode = V2DImode;
+      else if (mode == SImode && TARGET_P9_VECTOR)
+       mode = V4SImode;
+      else if (mode == SFmode && TARGET_P9_VECTOR)
+       mode = V4SFmode;
        else
         gcc_unreachable ();
        return memory_address_addr_space_p (mode, XEXP (op, 0),
@@ -1091,10 +1116,6 @@
  (define_special_predicate "equality_operator"
    (match_code "eq,ne"))
  
-;; Return true if operand is MIN or MAX operator.
-(define_predicate "min_max_operator"
-  (match_code "smin,smax,umin,umax"))
-
  ;; Return 1 if OP is a comparison operation that is valid for a branch
  ;; instruction.  We check the opcode against the mode of the CC value.
  ;; validate_condition_mode is an assertion.
@@ -1137,6 +1158,11 @@
    (and (match_operand 0 "branch_comparison_operator")
         (match_code "ne,le,ge,leu,geu,ordered")))
  
+;; Return 1 if OP is a comparison operator suitable for vector/scalar
+;; comparisons that generate a -1/0 mask.
+(define_predicate "fpmask_comparison_operator"
+  (match_code "eq,gt,ge"))
+
  ;; Return 1 if OP is a comparison operation that is valid for a branch
  ;; insn, which is true if the corresponding bit in the CC register is set.
  (define_predicate "branch_positive_comparison_operator"
diff --git a/gcc/config/rs6000/rs6000-builtin.def b/gcc/config/rs6000/rs6000-builtin.def

index 891d240..e0dac7c 100644 (file)
--- a/gcc/config/rs6000/rs6000-builtin.def
+++ b/gcc/config/rs6000/rs6000-builtin.def
@@ -24,6 +24,7 @@
     <http://www.gnu.org/licenses/>.  */
  
  /* Before including this file, some macros must be defined:
+   RS6000_BUILTIN_0 -- 0 arg builtins
     RS6000_BUILTIN_1 -- 1 arg builtins
     RS6000_BUILTIN_2 -- 2 arg builtins
     RS6000_BUILTIN_3 -- 3 arg builtins
@@ -43,6 +44,10 @@
         ATTR    builtin attribute information.
         ICODE   Insn code of the function that implents the builtin.  */
  
+#ifndef RS6000_BUILTIN_0
+  #error "RS6000_BUILTIN_0 is not defined."
+#endif
+
  #ifndef RS6000_BUILTIN_1
    #error "RS6000_BUILTIN_1 is not defined."
  #endif
@@ -637,6 +642,41 @@
                      | RS6000_BTC_TERNARY),                             \
                     CODE_FOR_ ## ICODE)                 /* ICODE */
  
+/* Miscellaneous builtins for instructions added in ISA 3.0.  These
+   instructions don't require either the DFP or VSX options, just the basic
+   ISA 3.0 enablement since they operate on general purpose registers.  */
+#define BU_P9_MISC_1(ENUM, NAME, ATTR, ICODE)                          \
+  RS6000_BUILTIN_1 (MISC_BUILTIN_ ## ENUM,             /* ENUM */      \
+                   "__builtin_" NAME,                  /* NAME */      \
+                   RS6000_BTM_MODULO,                  /* MASK */      \
+                   (RS6000_BTC_ ## ATTR                /* ATTR */      \
+                    | RS6000_BTC_UNARY),                               \
+                   CODE_FOR_ ## ICODE)                 /* ICODE */
+
+/* Miscellaneous builtins for instructions added in ISA 3.0.  These
+   instructions don't require either the DFP or VSX options, just the basic
+   ISA 3.0 enablement since they operate on general purpose registers,
+   and they require 64-bit addressing.  */
+#define BU_P9_64BIT_MISC_0(ENUM, NAME, ATTR, ICODE)                    \
+  RS6000_BUILTIN_0 (MISC_BUILTIN_ ## ENUM,             /* ENUM */      \
+                   "__builtin_" NAME,                  /* NAME */      \
+                   RS6000_BTM_MODULO                                   \
+                     | RS6000_BTM_64BIT,               /* MASK */      \
+                   (RS6000_BTC_ ## ATTR                /* ATTR */      \
+                    | RS6000_BTC_SPECIAL),                             \
+                   CODE_FOR_ ## ICODE)                 /* ICODE */
+
+/* Miscellaneous builtins for instructions added in ISA 3.0.  These
+   instructions don't require either the DFP or VSX options, just the basic
+   ISA 3.0 enablement since they operate on general purpose registers.  */
+#define BU_P9_MISC_0(ENUM, NAME, ATTR, ICODE)                      \
+  RS6000_BUILTIN_0 (MISC_BUILTIN_ ## ENUM,             /* ENUM */      \
+                   "__builtin_" NAME,                  /* NAME */      \
+                   RS6000_BTM_MODULO,                  /* MASK */      \
+                   (RS6000_BTC_ ## ATTR                /* ATTR */      \
+                    | RS6000_BTC_SPECIAL),                             \
+                   CODE_FOR_ ## ICODE)                 /* ICODE */
+
  /* 128-bit long double floating point builtins.  */
  #define BU_LDBL128_2(ENUM, NAME, ATTR, ICODE)                          \
    RS6000_BUILTIN_2 (MISC_BUILTIN_ ## ENUM,             /* ENUM */      \
@@ -647,8 +687,113 @@
                      | RS6000_BTC_BINARY),                              \
                     CODE_FOR_ ## ICODE)                 /* ICODE */
  
+
+/* Miscellaneous builtins for instructions added in ISA 3.0.  These
+   instructions don't require either the DFP or VSX options, just the basic 
+   ISA 3.0 enablement since they operate on general purpose registers.  */
+#define BU_P9_MISC_1(ENUM, NAME, ATTR, ICODE)                          \
+  RS6000_BUILTIN_1 (MISC_BUILTIN_ ## ENUM,             /* ENUM */      \
+                   "__builtin_" NAME,                  /* NAME */      \
+                   RS6000_BTM_MODULO,                  /* MASK */      \
+                   (RS6000_BTC_ ## ATTR                /* ATTR */      \
+                    | RS6000_BTC_UNARY),                               \
+                   CODE_FOR_ ## ICODE)                 /* ICODE */
+
+/* Miscellaneous builtins for instructions added in ISA 3.0.  These
+   instructions don't require either the DFP or VSX options, just the basic 
+   ISA 3.0 enablement since they operate on general purpose registers,
+   and they require 64-bit addressing.  */
+#define BU_P9_64BIT_MISC_0(ENUM, NAME, ATTR, ICODE)                    \
+  RS6000_BUILTIN_0 (MISC_BUILTIN_ ## ENUM,             /* ENUM */      \
+                   "__builtin_" NAME,                  /* NAME */      \
+                   RS6000_BTM_MODULO                                   \
+                     | RS6000_BTM_64BIT,               /* MASK */      \
+                   (RS6000_BTC_ ## ATTR                /* ATTR */      \
+                    | RS6000_BTC_SPECIAL),                             \
+                   CODE_FOR_ ## ICODE)                 /* ICODE */
+
+/* Miscellaneous builtins for instructions added in ISA 3.0.  These
+   instructions don't require either the DFP or VSX options, just the basic 
+   ISA 3.0 enablement since they operate on general purpose registers.  */
+#define BU_P9_MISC_0(ENUM, NAME, ATTR, ICODE)                      \
+  RS6000_BUILTIN_0 (MISC_BUILTIN_ ## ENUM,             /* ENUM */      \
+                   "__builtin_" NAME,                  /* NAME */      \
+                   RS6000_BTM_MODULO,                  /* MASK */      \
+                   (RS6000_BTC_ ## ATTR                /* ATTR */      \
+                    | RS6000_BTC_SPECIAL),                             \
+                   CODE_FOR_ ## ICODE)                 /* ICODE */
+
+/* ISA 3.0 (power9) vector convenience macros.  */
+/* For the instructions that are encoded as altivec instructions use
+   __builtin_altivec_ as the builtin name.  */
+#define BU_P9V_AV_1(ENUM, NAME, ATTR, ICODE)                           \
+  RS6000_BUILTIN_1 (P9V_BUILTIN_ ## ENUM,              /* ENUM */      \
+                   "__builtin_altivec_" NAME,          /* NAME */      \
+                   RS6000_BTM_P9_VECTOR,               /* MASK */      \
+                   (RS6000_BTC_ ## ATTR                /* ATTR */      \
+                    | RS6000_BTC_UNARY),                               \
+                   CODE_FOR_ ## ICODE)                 /* ICODE */
+
+#define BU_P9V_AV_2(ENUM, NAME, ATTR, ICODE)                           \
+  RS6000_BUILTIN_2 (P9V_BUILTIN_ ## ENUM,              /* ENUM */      \
+                   "__builtin_altivec_" NAME,          /* NAME */      \
+                   RS6000_BTM_P9_VECTOR,               /* MASK */      \
+                   (RS6000_BTC_ ## ATTR                /* ATTR */      \
+                    | RS6000_BTC_BINARY),                              \
+                   CODE_FOR_ ## ICODE)                 /* ICODE */
+
+#define BU_P9V_AV_3(ENUM, NAME, ATTR, ICODE)                           \
+  RS6000_BUILTIN_3 (P9V_BUILTIN_ ## ENUM,              /* ENUM */      \
+                   "__builtin_altivec_" NAME,          /* NAME */      \
+                   RS6000_BTM_P9_VECTOR,               /* MASK */      \
+                   (RS6000_BTC_ ## ATTR                /* ATTR */      \
+                    | RS6000_BTC_TERNARY),                             \
+                   CODE_FOR_ ## ICODE)                 /* ICODE */
+
+#define BU_P9V_AV_P(ENUM, NAME, ATTR, ICODE)                           \
+  RS6000_BUILTIN_P (P9V_BUILTIN_ ## ENUM,              /* ENUM */      \
+                   "__builtin_altivec_" NAME,          /* NAME */      \
+                   RS6000_BTM_P9_VECTOR,               /* MASK */      \
+                   (RS6000_BTC_ ## ATTR                /* ATTR */      \
+                    | RS6000_BTC_PREDICATE),                           \
+                   CODE_FOR_ ## ICODE)                 /* ICODE */
+
+/* For the instructions encoded as VSX instructions use __builtin_vsx as the
+   builtin name.  */
+#define BU_P9V_VSX_1(ENUM, NAME, ATTR, ICODE)                          \
+  RS6000_BUILTIN_1 (P9V_BUILTIN_ ## ENUM,              /* ENUM */      \
+                   "__builtin_vsx_" NAME,              /* NAME */      \
+                   RS6000_BTM_P9_VECTOR,               /* MASK */      \
+                   (RS6000_BTC_ ## ATTR                /* ATTR */      \
+                    | RS6000_BTC_UNARY),                               \
+                   CODE_FOR_ ## ICODE)                 /* ICODE */
+
+#define BU_P9V_OVERLOAD_1(ENUM, NAME)                                  \
+  RS6000_BUILTIN_1 (P9V_BUILTIN_VEC_ ## ENUM,          /* ENUM */      \
+                   "__builtin_vec_" NAME,              /* NAME */      \
+                   RS6000_BTM_P9_VECTOR,               /* MASK */      \
+                   (RS6000_BTC_OVERLOADED              /* ATTR */      \
+                    | RS6000_BTC_UNARY),                               \
+                   CODE_FOR_nothing)                   /* ICODE */
+
+#define BU_P9V_OVERLOAD_2(ENUM, NAME)                                  \
+  RS6000_BUILTIN_2 (P9V_BUILTIN_VEC_ ## ENUM,          /* ENUM */      \
+                   "__builtin_vec_" NAME,              /* NAME */      \
+                   RS6000_BTM_P9_VECTOR,               /* MASK */      \
+                   (RS6000_BTC_OVERLOADED              /* ATTR */      \
+                    | RS6000_BTC_BINARY),                              \
+                   CODE_FOR_nothing)                   /* ICODE */
+
+#define BU_P9V_OVERLOAD_3(ENUM, NAME)                                  \
+  RS6000_BUILTIN_3 (P9V_BUILTIN_VEC_ ## ENUM,          /* ENUM */      \
+                   "__builtin_vec_" NAME,              /* NAME */      \
+                   RS6000_BTM_P9_VECTOR,               /* MASK */      \
+                   (RS6000_BTC_OVERLOADED              /* ATTR */      \
+                    | RS6000_BTC_TERNARY),                             \
+                   CODE_FOR_nothing)                   /* ICODE */
  #endif
  
+\f
  /* Insure 0 is not a legitimate index.  */
  BU_SPECIAL_X (RS6000_BUILTIN_NONE, NULL, 0, RS6000_BTC_MISC)
  
@@ -1398,6 +1543,18 @@ BU_VSX_X (STXVW4X_V4SF,        "stxvw4x_v4sf",   MEM)
  BU_VSX_X (STXVW4X_V4SI,              "stxvw4x_v4si",   MEM)
  BU_VSX_X (STXVW4X_V8HI,              "stxvw4x_v8hi",   MEM)
  BU_VSX_X (STXVW4X_V16QI,      "stxvw4x_v16qi", MEM)
+BU_VSX_X (LD_ELEMREV_V2DF,    "ld_elemrev_v2df",  MEM)
+BU_VSX_X (LD_ELEMREV_V2DI,    "ld_elemrev_v2di",  MEM)
+BU_VSX_X (LD_ELEMREV_V4SF,    "ld_elemrev_v4sf",  MEM)
+BU_VSX_X (LD_ELEMREV_V4SI,    "ld_elemrev_v4si",  MEM)
+BU_VSX_X (LD_ELEMREV_V8HI,    "ld_elemrev_v8hi",  MEM)
+BU_VSX_X (LD_ELEMREV_V16QI,   "ld_elemrev_v16qi", MEM)
+BU_VSX_X (ST_ELEMREV_V2DF,    "st_elemrev_v2df",  MEM)
+BU_VSX_X (ST_ELEMREV_V2DI,    "st_elemrev_v2di",  MEM)
+BU_VSX_X (ST_ELEMREV_V4SF,    "st_elemrev_v4sf",  MEM)
+BU_VSX_X (ST_ELEMREV_V4SI,    "st_elemrev_v4si",  MEM)
+BU_VSX_X (ST_ELEMREV_V8HI,    "st_elemrev_v8hi",  MEM)
+BU_VSX_X (ST_ELEMREV_V16QI,   "st_elemrev_v16qi", MEM)
  BU_VSX_X (XSABSDP,           "xsabsdp",        CONST)
  BU_VSX_X (XSADDDP,           "xsadddp",        FP)
  BU_VSX_X (XSCMPODP,          "xscmpodp",       FP)
@@ -1455,6 +1612,8 @@ BU_VSX_OVERLOAD_1 (DOUBLE,   "double")
  /* VSX builtins that are handled as special cases.  */
  BU_VSX_OVERLOAD_X (LD,      "ld")
  BU_VSX_OVERLOAD_X (ST,      "st")
+BU_VSX_OVERLOAD_X (XL,      "xl")
+BU_VSX_OVERLOAD_X (XST,             "xst")
  \f
  /* 1 argument VSX instructions added in ISA 2.07.  */
  BU_P8V_VSX_1 (XSCVSPDPN,      "xscvspdpn",     CONST,  vsx_xscvspdpn)
@@ -1639,12 +1798,37 @@ BU_P8V_MISC_3 (BCDSUB_OV,       "bcdsub_ov",    CONST,  bcdsub_unordered)
  BU_DFP_MISC_2 (PACK_TD,                "pack_dec128",          CONST,  packtd)
  BU_DFP_MISC_2 (UNPACK_TD,      "unpack_dec128",        CONST,  unpacktd)
  
+/* 0 argument general-purpose register functions added in ISA 3.0 (power9).  */
+BU_P9_MISC_0 (DARN_32,         "darn_32",              MISC, darn_32)
+BU_P9_64BIT_MISC_0 (DARN_RAW,  "darn_raw",             MISC, darn_raw)
+BU_P9_64BIT_MISC_0 (DARN,      "darn",                 MISC, darn)
+
  BU_LDBL128_2 (PACK_TF,         "pack_longdouble",      CONST,  packtf)
  BU_LDBL128_2 (UNPACK_TF,       "unpack_longdouble",    CONST,  unpacktf)
  
  BU_P7_MISC_2 (PACK_V1TI,       "pack_vector_int128",   CONST,  packv1ti)
  BU_P7_MISC_2 (UNPACK_V1TI,     "unpack_vector_int128", CONST,  unpackv1ti)
  
+/* 1 argument vector functions added in ISA 3.0 (power9).  */
+BU_P9V_AV_1 (VCTZB,            "vctzb",                CONST,  ctzv16qi2)
+BU_P9V_AV_1 (VCTZH,            "vctzh",                CONST,  ctzv8hi2)
+BU_P9V_AV_1 (VCTZW,            "vctzw",                CONST,  ctzv4si2)
+BU_P9V_AV_1 (VCTZD,            "vctzd",                CONST,  ctzv2di2)
+BU_P9V_AV_1 (VPRTYBD,          "vprtybd",              CONST,  parityv2di2)
+BU_P9V_AV_1 (VPRTYBQ,          "vprtybq",              CONST,  parityv1ti2)
+BU_P9V_AV_1 (VPRTYBW,          "vprtybw",              CONST,  parityv4si2)
+
+/* ISA 3.0 vector overloaded 1 argument functions.  */
+BU_P9V_OVERLOAD_1 (VCTZ,       "vctz")
+BU_P9V_OVERLOAD_1 (VCTZB,      "vctzb")
+BU_P9V_OVERLOAD_1 (VCTZH,      "vctzh")
+BU_P9V_OVERLOAD_1 (VCTZW,      "vctzw")
+BU_P9V_OVERLOAD_1 (VCTZD,      "vctzd")
+BU_P9V_OVERLOAD_1 (VPRTYB,     "vprtyb")
+BU_P9V_OVERLOAD_1 (VPRTYBD,    "vprtybd")
+BU_P9V_OVERLOAD_1 (VPRTYBQ,    "vprtybq")
+BU_P9V_OVERLOAD_1 (VPRTYBW,    "vprtybw")
+
  \f
  /* 1 argument crypto functions.  */
  BU_CRYPTO_1 (VSBOX,            "vsbox",          CONST, crypto_vsbox)
diff --git a/gcc/config/rs6000/rs6000-c.c b/gcc/config/rs6000/rs6000-c.c

index ceb80b2..5b4ccf1 100644 (file)
--- a/gcc/config/rs6000/rs6000-c.c
+++ b/gcc/config/rs6000/rs6000-c.c
@@ -2726,6 +2726,49 @@ const struct altivec_builtin_types altivec_overloaded_builtins[] = {
      RS6000_BTI_V4SI, RS6000_BTI_V4SI, RS6000_BTI_V4SI, 0 },
    { ALTIVEC_BUILTIN_VEC_SUMS, ALTIVEC_BUILTIN_VSUMSWS,
      RS6000_BTI_V4SI, RS6000_BTI_V4SI, RS6000_BTI_V4SI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V2DF,
+    RS6000_BTI_V2DF, RS6000_BTI_INTSI, ~RS6000_BTI_V2DF, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V2DF,
+    RS6000_BTI_V2DF, RS6000_BTI_INTSI, ~RS6000_BTI_double, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V2DI,
+    RS6000_BTI_V2DI, RS6000_BTI_INTSI, ~RS6000_BTI_V2DI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V2DI,
+    RS6000_BTI_V2DI, RS6000_BTI_INTSI, ~RS6000_BTI_long_long, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V2DI,
+    RS6000_BTI_unsigned_V2DI, RS6000_BTI_INTSI,
+    ~RS6000_BTI_unsigned_V2DI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V2DI,
+    RS6000_BTI_unsigned_V2DI, RS6000_BTI_INTSI,
+    ~RS6000_BTI_unsigned_long_long, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V4SF,
+    RS6000_BTI_V4SF, RS6000_BTI_INTSI, ~RS6000_BTI_V4SF, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V4SF,
+    RS6000_BTI_V4SF, RS6000_BTI_INTSI, ~RS6000_BTI_float, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V4SI,
+    RS6000_BTI_V4SI, RS6000_BTI_INTSI, ~RS6000_BTI_V4SI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V4SI,
+    RS6000_BTI_V4SI, RS6000_BTI_INTSI, ~RS6000_BTI_INTSI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V4SI,
+    RS6000_BTI_unsigned_V4SI, RS6000_BTI_INTSI, ~RS6000_BTI_unsigned_V4SI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V4SI,
+    RS6000_BTI_unsigned_V4SI, RS6000_BTI_INTSI, ~RS6000_BTI_UINTSI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V8HI,
+    RS6000_BTI_V8HI, RS6000_BTI_INTSI, ~RS6000_BTI_V8HI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V8HI,
+    RS6000_BTI_V8HI, RS6000_BTI_INTSI, ~RS6000_BTI_INTHI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V8HI,
+    RS6000_BTI_unsigned_V8HI, RS6000_BTI_INTSI, ~RS6000_BTI_unsigned_V8HI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V8HI,
+    RS6000_BTI_unsigned_V8HI, RS6000_BTI_INTSI, ~RS6000_BTI_UINTHI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V16QI,
+    RS6000_BTI_V16QI, RS6000_BTI_INTSI, ~RS6000_BTI_V16QI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V16QI,
+    RS6000_BTI_V16QI, RS6000_BTI_INTSI, ~RS6000_BTI_INTQI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V16QI,
+    RS6000_BTI_unsigned_V16QI, RS6000_BTI_INTSI,
+    ~RS6000_BTI_unsigned_V16QI, 0 },
+  { VSX_BUILTIN_VEC_XL, VSX_BUILTIN_LD_ELEMREV_V16QI,
+    RS6000_BTI_unsigned_V16QI, RS6000_BTI_INTSI, ~RS6000_BTI_UINTQI, 0 },
    { ALTIVEC_BUILTIN_VEC_XOR, ALTIVEC_BUILTIN_VXOR,
      RS6000_BTI_V4SF, RS6000_BTI_V4SF, RS6000_BTI_V4SF, 0 },
    { ALTIVEC_BUILTIN_VEC_XOR, ALTIVEC_BUILTIN_VXOR,
@@ -3475,6 +3518,55 @@ const struct altivec_builtin_types altivec_overloaded_builtins[] = {
      RS6000_BTI_void, RS6000_BTI_unsigned_V16QI, RS6000_BTI_INTSI, ~RS6000_BTI_unsigned_V16QI },
    { ALTIVEC_BUILTIN_VEC_STVRXL, ALTIVEC_BUILTIN_STVRXL,
      RS6000_BTI_void, RS6000_BTI_unsigned_V16QI, RS6000_BTI_INTSI, ~RS6000_BTI_UINTQI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V2DF,
+    RS6000_BTI_void, RS6000_BTI_V2DF, RS6000_BTI_INTSI, ~RS6000_BTI_V2DF },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V2DF,
+    RS6000_BTI_void, RS6000_BTI_V2DF, RS6000_BTI_INTSI, ~RS6000_BTI_double },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V2DI,
+    RS6000_BTI_void, RS6000_BTI_V2DI, RS6000_BTI_INTSI, ~RS6000_BTI_V2DI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V2DI,
+    RS6000_BTI_void, RS6000_BTI_V2DI, RS6000_BTI_INTSI,
+    ~RS6000_BTI_long_long },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V2DI,
+    RS6000_BTI_void, RS6000_BTI_unsigned_V2DI, RS6000_BTI_INTSI,
+    ~RS6000_BTI_unsigned_V2DI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V2DI,
+    RS6000_BTI_void, RS6000_BTI_unsigned_V2DI, RS6000_BTI_INTSI,
+    ~RS6000_BTI_unsigned_long_long },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V4SF,
+    RS6000_BTI_void, RS6000_BTI_V4SF, RS6000_BTI_INTSI, ~RS6000_BTI_V4SF },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V4SF,
+    RS6000_BTI_void, RS6000_BTI_V4SF, RS6000_BTI_INTSI, ~RS6000_BTI_float },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V4SI,
+    RS6000_BTI_void, RS6000_BTI_V4SI, RS6000_BTI_INTSI, ~RS6000_BTI_V4SI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V4SI,
+    RS6000_BTI_void, RS6000_BTI_V4SI, RS6000_BTI_INTSI, ~RS6000_BTI_INTSI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V4SI,
+    RS6000_BTI_void, RS6000_BTI_unsigned_V4SI, RS6000_BTI_INTSI,
+    ~RS6000_BTI_unsigned_V4SI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V4SI,
+    RS6000_BTI_void, RS6000_BTI_unsigned_V4SI, RS6000_BTI_INTSI,
+    ~RS6000_BTI_UINTSI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V8HI,
+    RS6000_BTI_void, RS6000_BTI_V8HI, RS6000_BTI_INTSI, ~RS6000_BTI_V8HI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V8HI,
+    RS6000_BTI_void, RS6000_BTI_V8HI, RS6000_BTI_INTSI, ~RS6000_BTI_INTHI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V8HI,
+    RS6000_BTI_void, RS6000_BTI_unsigned_V8HI, RS6000_BTI_INTSI,
+    ~RS6000_BTI_unsigned_V8HI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V8HI,
+    RS6000_BTI_void, RS6000_BTI_unsigned_V8HI, RS6000_BTI_INTSI,
+    ~RS6000_BTI_UINTHI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V16QI,
+    RS6000_BTI_void, RS6000_BTI_V16QI, RS6000_BTI_INTSI, ~RS6000_BTI_V16QI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V16QI,
+    RS6000_BTI_void, RS6000_BTI_V16QI, RS6000_BTI_INTSI, ~RS6000_BTI_INTQI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V16QI,
+    RS6000_BTI_void, RS6000_BTI_unsigned_V16QI, RS6000_BTI_INTSI,
+    ~RS6000_BTI_unsigned_V16QI },
+  { VSX_BUILTIN_VEC_XST, VSX_BUILTIN_ST_ELEMREV_V16QI,
+    RS6000_BTI_void, RS6000_BTI_unsigned_V16QI, RS6000_BTI_INTSI,
+    ~RS6000_BTI_UINTQI },
    { VSX_BUILTIN_VEC_XXSLDWI, VSX_BUILTIN_XXSLDWI_16QI,
      RS6000_BTI_V16QI, RS6000_BTI_V16QI, RS6000_BTI_V16QI, RS6000_BTI_NOT_OPAQUE },
    { VSX_BUILTIN_VEC_XXSLDWI, VSX_BUILTIN_XXSLDWI_16QI,
@@ -4123,6 +4215,43 @@ const struct altivec_builtin_types altivec_overloaded_builtins[] = {
    { P8V_BUILTIN_VEC_VCLZD, P8V_BUILTIN_VCLZD,
      RS6000_BTI_unsigned_V2DI, RS6000_BTI_unsigned_V2DI, 0, 0 },
  
+  { P9V_BUILTIN_VEC_VCTZ, P9V_BUILTIN_VCTZB,
+    RS6000_BTI_V16QI, RS6000_BTI_V16QI, 0, 0 },
+  { P9V_BUILTIN_VEC_VCTZ, P9V_BUILTIN_VCTZB,
+    RS6000_BTI_unsigned_V16QI, RS6000_BTI_unsigned_V16QI, 0, 0 },
+  { P9V_BUILTIN_VEC_VCTZ, P9V_BUILTIN_VCTZH,
+    RS6000_BTI_V8HI, RS6000_BTI_V8HI, 0, 0 },
+  { P9V_BUILTIN_VEC_VCTZ, P9V_BUILTIN_VCTZH,
+    RS6000_BTI_unsigned_V8HI, RS6000_BTI_unsigned_V8HI, 0, 0 },
+  { P9V_BUILTIN_VEC_VCTZ, P9V_BUILTIN_VCTZW,
+    RS6000_BTI_V4SI, RS6000_BTI_V4SI, 0, 0 },
+  { P9V_BUILTIN_VEC_VCTZ, P9V_BUILTIN_VCTZW,
+    RS6000_BTI_unsigned_V4SI, RS6000_BTI_unsigned_V4SI, 0, 0 },
+  { P9V_BUILTIN_VEC_VCTZ, P9V_BUILTIN_VCTZD,
+    RS6000_BTI_V2DI, RS6000_BTI_V2DI, 0, 0 },
+  { P9V_BUILTIN_VEC_VCTZ, P9V_BUILTIN_VCTZD,
+    RS6000_BTI_unsigned_V2DI, RS6000_BTI_unsigned_V2DI, 0, 0 },
+
+  { P9V_BUILTIN_VEC_VCTZB, P9V_BUILTIN_VCTZB,
+    RS6000_BTI_V16QI, RS6000_BTI_V16QI, 0, 0 },
+  { P9V_BUILTIN_VEC_VCTZB, P9V_BUILTIN_VCTZB,
+    RS6000_BTI_unsigned_V16QI, RS6000_BTI_unsigned_V16QI, 0, 0 },
+
+  { P9V_BUILTIN_VEC_VCTZH, P9V_BUILTIN_VCTZH,
+    RS6000_BTI_V8HI, RS6000_BTI_V8HI, 0, 0 },
+  { P9V_BUILTIN_VEC_VCTZH, P9V_BUILTIN_VCTZH,
+    RS6000_BTI_unsigned_V8HI, RS6000_BTI_unsigned_V8HI, 0, 0 },
+
+  { P9V_BUILTIN_VEC_VCTZW, P9V_BUILTIN_VCTZW,
+    RS6000_BTI_V4SI, RS6000_BTI_V4SI, 0, 0 },
+  { P9V_BUILTIN_VEC_VCTZW, P9V_BUILTIN_VCTZW,
+    RS6000_BTI_unsigned_V4SI, RS6000_BTI_unsigned_V4SI, 0, 0 },
+
+  { P9V_BUILTIN_VEC_VCTZD, P9V_BUILTIN_VCTZD,
+    RS6000_BTI_V2DI, RS6000_BTI_V2DI, 0, 0 },
+  { P9V_BUILTIN_VEC_VCTZD, P9V_BUILTIN_VCTZD,
+    RS6000_BTI_unsigned_V2DI, RS6000_BTI_unsigned_V2DI, 0, 0 },
+
    { P8V_BUILTIN_VEC_VGBBD, P8V_BUILTIN_VGBBD,
      RS6000_BTI_V16QI, RS6000_BTI_V16QI, 0, 0 },
    { P8V_BUILTIN_VEC_VGBBD, P8V_BUILTIN_VGBBD,
@@ -4252,6 +4381,42 @@ const struct altivec_builtin_types altivec_overloaded_builtins[] = {
    { P8V_BUILTIN_VEC_VPOPCNTD, P8V_BUILTIN_VPOPCNTD,
      RS6000_BTI_unsigned_V2DI, RS6000_BTI_unsigned_V2DI, 0, 0 },
  
+  { P9V_BUILTIN_VEC_VPRTYB, P9V_BUILTIN_VPRTYBW,
+    RS6000_BTI_V4SI, RS6000_BTI_V4SI, 0, 0 },
+  { P9V_BUILTIN_VEC_VPRTYB, P9V_BUILTIN_VPRTYBW,
+    RS6000_BTI_unsigned_V4SI, RS6000_BTI_unsigned_V4SI, 0, 0 },
+  { P9V_BUILTIN_VEC_VPRTYB, P9V_BUILTIN_VPRTYBD,
+    RS6000_BTI_V2DI, RS6000_BTI_V2DI, 0, 0 },
+  { P9V_BUILTIN_VEC_VPRTYB, P9V_BUILTIN_VPRTYBD,
+    RS6000_BTI_unsigned_V2DI, RS6000_BTI_unsigned_V2DI, 0, 0 },
+  { P9V_BUILTIN_VEC_VPRTYB, P9V_BUILTIN_VPRTYBQ,
+    RS6000_BTI_V1TI, RS6000_BTI_V1TI, 0, 0 },
+  { P9V_BUILTIN_VEC_VPRTYB, P9V_BUILTIN_VPRTYBQ,
+    RS6000_BTI_unsigned_V1TI, RS6000_BTI_unsigned_V1TI, 0, 0 },
+  { P9V_BUILTIN_VEC_VPRTYB, P9V_BUILTIN_VPRTYBQ,
+    RS6000_BTI_INTTI, RS6000_BTI_INTTI, 0, 0 },
+  { P9V_BUILTIN_VEC_VPRTYB, P9V_BUILTIN_VPRTYBQ,
+    RS6000_BTI_UINTTI, RS6000_BTI_UINTTI, 0, 0 },
+
+  { P9V_BUILTIN_VEC_VPRTYBW, P9V_BUILTIN_VPRTYBW,
+    RS6000_BTI_V4SI, RS6000_BTI_V4SI, 0, 0 },
+  { P9V_BUILTIN_VEC_VPRTYBW, P9V_BUILTIN_VPRTYBW,
+    RS6000_BTI_unsigned_V4SI, RS6000_BTI_unsigned_V4SI, 0, 0 },
+
+  { P9V_BUILTIN_VEC_VPRTYBD, P9V_BUILTIN_VPRTYBD,
+    RS6000_BTI_V2DI, RS6000_BTI_V2DI, 0, 0 },
+  { P9V_BUILTIN_VEC_VPRTYBD, P9V_BUILTIN_VPRTYBD,
+    RS6000_BTI_unsigned_V2DI, RS6000_BTI_unsigned_V2DI, 0, 0 },
+
+  { P9V_BUILTIN_VEC_VPRTYBQ, P9V_BUILTIN_VPRTYBQ,
+    RS6000_BTI_V1TI, RS6000_BTI_V1TI, 0, 0 },
+  { P9V_BUILTIN_VEC_VPRTYBQ, P9V_BUILTIN_VPRTYBQ,
+    RS6000_BTI_unsigned_V1TI, RS6000_BTI_unsigned_V1TI, 0, 0 },
+  { P9V_BUILTIN_VEC_VPRTYBQ, P9V_BUILTIN_VPRTYBQ,
+    RS6000_BTI_INTTI, RS6000_BTI_INTTI, 0, 0 },
+  { P9V_BUILTIN_VEC_VPRTYBQ, P9V_BUILTIN_VPRTYBQ,
+    RS6000_BTI_UINTTI, RS6000_BTI_UINTTI, 0, 0 },
+
    { P8V_BUILTIN_VEC_VPKUDUM, P8V_BUILTIN_VPKUDUM,
      RS6000_BTI_V4SI, RS6000_BTI_V2DI, RS6000_BTI_V2DI, 0 },
    { P8V_BUILTIN_VEC_VPKUDUM, P8V_BUILTIN_VPKUDUM,
diff --git a/gcc/config/rs6000/rs6000-cpus.def b/gcc/config/rs6000/rs6000-cpus.def

index 275404a..27239f1 100644 (file)
--- a/gcc/config/rs6000/rs6000-cpus.def
+++ b/gcc/config/rs6000/rs6000-cpus.def
@@ -60,13 +60,14 @@
                                  | OPTION_MASK_UPPER_REGS_SF)
  
  /* Add ISEL back into ISA 3.0, since it is supposed to be a win.  Do not add
-   P9_DFORM or P9_MINMAX until they are fully debugged.  */
+   P9_MINMAX until the hardware that supports it is available. Do not add
+   P9_DFORM_VECTOR until LRA is the default register allocator.  */
  #define ISA_3_0_MASKS_SERVER   (ISA_2_7_MASKS_SERVER                   \
                                  | OPTION_MASK_FLOAT128_HW              \
                                  | OPTION_MASK_ISEL                     \
                                  | OPTION_MASK_MODULO                   \
                                  | OPTION_MASK_P9_FUSION                \
-                                | OPTION_MASK_P9_DFORM                 \
+                                | OPTION_MASK_P9_DFORM_SCALAR          \
                                  | OPTION_MASK_P9_VECTOR)
  
  #define POWERPC_7400_MASK      (OPTION_MASK_PPC_GFXOPT | OPTION_MASK_ALTIVEC)
@@ -94,6 +95,7 @@
                                  | OPTION_MASK_FPRND                    \
                                  | OPTION_MASK_HTM                      \
                                  | OPTION_MASK_ISEL                     \
+                                | OPTION_MASK_LRA                      \
                                  | OPTION_MASK_MFCRF                    \
                                  | OPTION_MASK_MFPGPR                   \
                                  | OPTION_MASK_MODULO                   \
@@ -101,7 +103,8 @@
                                  | OPTION_MASK_NO_UPDATE                \
                                  | OPTION_MASK_P8_FUSION                \
                                  | OPTION_MASK_P8_VECTOR                \
-                                | OPTION_MASK_P9_DFORM                 \
+                                | OPTION_MASK_P9_DFORM_SCALAR          \
+                                | OPTION_MASK_P9_DFORM_VECTOR          \
                                  | OPTION_MASK_P9_FUSION                \
                                  | OPTION_MASK_P9_MINMAX                \
                                  | OPTION_MASK_P9_VECTOR                \
diff --git a/gcc/config/rs6000/rs6000-protos.h b/gcc/config/rs6000/rs6000-protos.h

index d9a6b1f..6b4d178 100644 (file)
--- a/gcc/config/rs6000/rs6000-protos.h
+++ b/gcc/config/rs6000/rs6000-protos.h
@@ -31,6 +31,7 @@ extern void init_cumulative_args (CUMULATIVE_ARGS *, tree, rtx, int, int, int,
  #endif /* TREE_CODE */
  
  extern bool easy_altivec_constant (rtx, machine_mode);
+extern bool xxspltib_constant_p (rtx, machine_mode, int *, int *);
  extern int vspltis_shifted (rtx);
  extern HOST_WIDE_INT const_vector_elt_as_int (rtx, unsigned int);
  extern bool macho_lo_sum_memory_operand (rtx, machine_mode);
@@ -86,6 +87,7 @@ extern int registers_ok_for_quad_peep (rtx, rtx);
  extern int mems_ok_for_quad_peep (rtx, rtx);
  extern bool gpr_or_gpr_p (rtx, rtx);
  extern bool direct_move_p (rtx, rtx);
+extern bool quad_address_p (rtx, machine_mode, bool);
  extern bool quad_load_store_p (rtx, rtx);
  extern bool fusion_gpr_load_p (rtx, rtx, rtx, rtx);
  extern void expand_fusion_gpr_load (rtx *);
diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c

index 1d0076c..7749483 100644 (file)
--- a/gcc/config/rs6000/rs6000.c
+++ b/gcc/config/rs6000/rs6000.c
@@ -452,6 +452,7 @@ typedef unsigned char addr_mask_type;
  #define RELOAD_REG_PRE_INCDEC  0x10    /* PRE_INC/PRE_DEC valid.  */
  #define RELOAD_REG_PRE_MODIFY  0x20    /* PRE_MODIFY valid.  */
  #define RELOAD_REG_AND_M16     0x40    /* AND -16 addressing.  */
+#define RELOAD_REG_QUAD_OFFSET 0x80    /* quad offset is limited.  */
  
  /* Register type masks based on the type, of valid addressing modes.  */
  struct rs6000_reg_addr {
@@ -499,6 +500,16 @@ mode_supports_vmx_dform (machine_mode mode)
    return ((reg_addr[mode].addr_mask[RELOAD_REG_VMX] & RELOAD_REG_OFFSET) != 0);
  }
  
+/* Return true if we have D-form addressing in VSX registers.  This addressing
+   is more limited than normal d-form addressing in that the offset must be
+   aligned on a 16-byte boundary.  */
+static inline bool
+mode_supports_vsx_dform_quad (machine_mode mode)
+{
+  return ((reg_addr[mode].addr_mask[RELOAD_REG_ANY] & RELOAD_REG_QUAD_OFFSET)
+         != 0);
+}
+
  \f
  /* Target cpu costs.  */
  
@@ -1128,6 +1139,7 @@ struct processor_costs ppca2_cost = {
  
  \f
  /* Table that classifies rs6000 builtin functions (pure, const, etc.).  */
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -1140,6 +1152,9 @@ struct processor_costs ppca2_cost = {
  #undef RS6000_BUILTIN_S
  #undef RS6000_BUILTIN_X
  
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE) \
+  { NAME, ICODE, MASK, ATTR },
+
  #define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE) \
    { NAME, ICODE, MASK, ATTR },
  
@@ -1185,6 +1200,7 @@ static const struct rs6000_builtin_info_type rs6000_builtin_info[] =
  #include "rs6000-builtin.def"
  };
  
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -2105,7 +2121,9 @@ rs6000_debug_addr_mask (addr_mask_type mask, bool keep_spaces)
    else if (keep_spaces)
      *p++ = ' ';
  
-  if ((mask & RELOAD_REG_OFFSET) != 0)
+  if ((mask & RELOAD_REG_QUAD_OFFSET) != 0)
+    *p++ = 'O';
+  else if ((mask & RELOAD_REG_OFFSET) != 0)
      *p++ = 'o';
    else if (keep_spaces)
      *p++ = ' ';
@@ -2642,8 +2660,7 @@ rs6000_debug_reg_global (void)
    if (TARGET_LINK_STACK)
      fprintf (stderr, DEBUG_FMT_S, "link_stack", "true");
  
-  if (targetm.lra_p ())
-    fprintf (stderr, DEBUG_FMT_S, "lra", "true");
+  fprintf (stderr, DEBUG_FMT_S, "lra", TARGET_LRA ? "true" : "false");
  
    if (TARGET_P8_FUSION)
      {
@@ -2769,17 +2786,31 @@ rs6000_setup_reg_addr_masks (void)
             }
  
           /* GPR and FPR registers can do REG+OFFSET addressing, except
-            possibly for SDmode.  ISA 3.0 (i.e. power9) adds D-form
-            addressing for scalars to altivec registers.  */
+            possibly for SDmode.  ISA 3.0 (i.e. power9) adds D-form addressing
+            for 64-bit scalars and 32-bit SFmode to altivec registers.  */
           if ((addr_mask != 0) && !indexed_only_p
               && msize <= 8
               && (rc == RELOAD_REG_GPR
-                 || rc == RELOAD_REG_FPR
-                 || (rc == RELOAD_REG_VMX
-                     && TARGET_P9_DFORM
-                     && (m2 == DFmode || m2 == SFmode))))
+                 || ((msize == 8 || m2 == SFmode)
+                     && (rc == RELOAD_REG_FPR
+                         || (rc == RELOAD_REG_VMX
+                             && TARGET_P9_DFORM_SCALAR)))))
             addr_mask |= RELOAD_REG_OFFSET;
  
+         /* VSX registers can do REG+OFFSET addresssing if ISA 3.0
+            instructions are enabled.  The offset for 128-bit VSX registers is
+            only 12-bits.  While GPRs can handle the full offset range, VSX
+            registers can only handle the restricted range.  */
+         else if ((addr_mask != 0) && !indexed_only_p
+                  && msize == 16 && TARGET_P9_DFORM_VECTOR
+                  && (ALTIVEC_OR_VSX_VECTOR_MODE (m2)
+                      || (m2 == TImode && TARGET_VSX_TIMODE)))
+           {
+             addr_mask |= RELOAD_REG_OFFSET;
+             if (rc == RELOAD_REG_FPR || rc == RELOAD_REG_VMX)
+               addr_mask |= RELOAD_REG_QUAD_OFFSET;
+           }
+
           /* VMX registers can do (REG & -16) and ((REG+REG) & -16)
              addressing on 128-bit types.  */
           if (rc == RELOAD_REG_VMX && msize == 16
@@ -3102,7 +3133,7 @@ rs6000_init_hard_regno_mode_ok (bool global_init_p)
      }
  
    /* Support for new D-form instructions.  */
-  if (TARGET_P9_DFORM)
+  if (TARGET_P9_DFORM_SCALAR)
      rs6000_constraints[RS6000_CONSTRAINT_wb] = ALTIVEC_REGS;
  
    /* Support for ISA 3.0 (power9) vectors.  */
@@ -3621,6 +3652,9 @@ rs6000_builtin_mask_calculate (void)
           | ((TARGET_POPCNTD)               ? RS6000_BTM_POPCNTD   : 0)
           | ((rs6000_cpu == PROCESSOR_CELL) ? RS6000_BTM_CELL      : 0)
           | ((TARGET_P8_VECTOR)             ? RS6000_BTM_P8_VECTOR : 0)
+         | ((TARGET_P9_VECTOR)             ? RS6000_BTM_P9_VECTOR : 0)
+         | ((TARGET_MODULO)                ? RS6000_BTM_MODULO    : 0)
+         | ((TARGET_64BIT)                 ? RS6000_BTM_64BIT     : 0)
           | ((TARGET_CRYPTO)                ? RS6000_BTM_CRYPTO    : 0)
           | ((TARGET_HTM)                   ? RS6000_BTM_HTM       : 0)
           | ((TARGET_DFP)                   ? RS6000_BTM_DFP       : 0)
@@ -3974,7 +4008,8 @@ rs6000_option_override_internal (bool global_init_p)
  
    /* For the newer switches (vsx, dfp, etc.) set some of the older options,
       unless the user explicitly used the -mno-<option> to disable the code.  */
-  if (TARGET_P9_VECTOR || TARGET_MODULO || TARGET_P9_DFORM || TARGET_P9_MINMAX)
+  if (TARGET_P9_VECTOR || TARGET_MODULO || TARGET_P9_DFORM_SCALAR
+      || TARGET_P9_DFORM_VECTOR || TARGET_P9_DFORM_BOTH > 0 || TARGET_P9_MINMAX)
      rs6000_isa_flags |= (ISA_3_0_MASKS_SERVER & ~rs6000_isa_flags_explicit);
    else if (TARGET_P8_VECTOR || TARGET_DIRECT_MOVE || TARGET_CRYPTO)
      rs6000_isa_flags |= (ISA_2_7_MASKS_SERVER & ~rs6000_isa_flags_explicit);
@@ -4188,26 +4223,49 @@ rs6000_option_override_internal (bool global_init_p)
        && !(rs6000_isa_flags_explicit & OPTION_MASK_TOC_FUSION))
      rs6000_isa_flags |= OPTION_MASK_TOC_FUSION;
  
+  /* -mpower9-dform turns on both -mpower9-dform-scalar and
+      -mpower9-dform-vector. There are currently problems if
+      -mpower9-dform-vector instructions are enabled when we use the RELOAD
+      register allocator.  */
+  if (TARGET_P9_DFORM_BOTH > 0)
+    {
+      if (!(rs6000_isa_flags_explicit & OPTION_MASK_P9_DFORM_VECTOR)
+         && TARGET_LRA)
+       rs6000_isa_flags |= OPTION_MASK_P9_DFORM_VECTOR;
+
+      if (!(rs6000_isa_flags_explicit & OPTION_MASK_P9_DFORM_SCALAR))
+       rs6000_isa_flags |= OPTION_MASK_P9_DFORM_SCALAR;
+    }
+  else if (TARGET_P9_DFORM_BOTH == 0)
+    {
+      if (!(rs6000_isa_flags_explicit & OPTION_MASK_P9_DFORM_VECTOR))
+       rs6000_isa_flags &= ~OPTION_MASK_P9_DFORM_VECTOR;
+
+      if (!(rs6000_isa_flags_explicit & OPTION_MASK_P9_DFORM_SCALAR))
+       rs6000_isa_flags &= ~OPTION_MASK_P9_DFORM_SCALAR;
+    }
+
    /* ISA 3.0 D-form instructions require p9-vector and upper-regs.  */
-  if (TARGET_P9_DFORM && !TARGET_P9_VECTOR)
+  if ((TARGET_P9_DFORM_SCALAR || TARGET_P9_DFORM_VECTOR) && !TARGET_P9_VECTOR)
      {
        if (rs6000_isa_flags_explicit & OPTION_MASK_P9_VECTOR)
         error ("-mpower9-dform requires -mpower9-vector");
-      rs6000_isa_flags &= ~OPTION_MASK_P9_DFORM;
+      rs6000_isa_flags &= ~(OPTION_MASK_P9_DFORM_SCALAR
+                           | OPTION_MASK_P9_DFORM_VECTOR);
      }
  
-  if (TARGET_P9_DFORM && !TARGET_UPPER_REGS_DF)
+  if (TARGET_P9_DFORM_SCALAR && !TARGET_UPPER_REGS_DF)
      {
        if (rs6000_isa_flags_explicit & OPTION_MASK_UPPER_REGS_DF)
         error ("-mpower9-dform requires -mupper-regs-df");
-      rs6000_isa_flags &= ~OPTION_MASK_P9_DFORM;
+      rs6000_isa_flags &= ~OPTION_MASK_P9_DFORM_SCALAR;
      }
  
-  if (TARGET_P9_DFORM && !TARGET_UPPER_REGS_SF)
+  if (TARGET_P9_DFORM_SCALAR && !TARGET_UPPER_REGS_SF)
      {
        if (rs6000_isa_flags_explicit & OPTION_MASK_UPPER_REGS_SF)
         error ("-mpower9-dform requires -mupper-regs-sf");
-      rs6000_isa_flags &= ~OPTION_MASK_P9_DFORM;
+      rs6000_isa_flags &= ~OPTION_MASK_P9_DFORM_SCALAR;
      }
  
    /* ISA 3.0 vector instructions include ISA 2.07.  */
@@ -4218,6 +4276,47 @@ rs6000_option_override_internal (bool global_init_p)
        rs6000_isa_flags &= ~OPTION_MASK_P9_VECTOR;
      }
  
+  /* There have been bugs with both -mvsx-timode and -mpower9-dform-vector that
+     don't show up with -mlra, but do show up with -mno-lra.  Given -mlra will
+     become the default once PR 69847 is fixed, turn off the options with
+     problems by default if -mno-lra was used, and warn if the user explicitly
+     asked for the option.
+
+     Enable -mpower9-dform-vector by default if LRA and other power9 options.
+     Enable -mvsx-timode by default if LRA and VSX.  */
+  if (!TARGET_LRA)
+    {
+      if (TARGET_VSX_TIMODE)
+       {
+         if ((rs6000_isa_flags_explicit & OPTION_MASK_VSX_TIMODE) != 0)
+           warning (0, "-mvsx-timode might need -mlra");
+
+         else
+           rs6000_isa_flags &= ~OPTION_MASK_VSX_TIMODE;
+       }
+
+      if (TARGET_P9_DFORM_VECTOR)
+       {
+         if ((rs6000_isa_flags_explicit & OPTION_MASK_P9_DFORM_VECTOR) != 0)
+           warning (0, "-mpower9-dform-vector might need -mlra");
+
+         else
+           rs6000_isa_flags &= ~OPTION_MASK_P9_DFORM_VECTOR;
+       }
+    }
+
+  else
+    {
+      if (TARGET_VSX && !TARGET_VSX_TIMODE
+         && (rs6000_isa_flags_explicit & OPTION_MASK_VSX_TIMODE) == 0)
+       rs6000_isa_flags |= OPTION_MASK_VSX_TIMODE;
+
+      if (TARGET_VSX && TARGET_P9_VECTOR && !TARGET_P9_DFORM_VECTOR
+         && TARGET_P9_DFORM_SCALAR && TARGET_P9_DFORM_BOTH < 0
+         && (rs6000_isa_flags_explicit & OPTION_MASK_P9_DFORM_VECTOR) == 0)
+       rs6000_isa_flags |= OPTION_MASK_P9_DFORM_VECTOR;
+    }
+
    /* Set -mallow-movmisalign to explicitly on if we have full ISA 2.07
       support. If we only have ISA 2.06 support, and the user did not specify
       the switch, leave it set to -1 so the movmisalign patterns are enabled,
@@ -6134,6 +6233,128 @@ gen_easy_altivec_constant (rtx op)
    gcc_unreachable ();
  }
  
+/* Return true if OP is of the given MODE and can be synthesized with ISA 3.0
+   instructions (xxspltib, vupkhsb/vextsb2w/vextb2d).
+
+   Return the number of instructions needed (1 or 2) into the address pointed
+   via NUM_INSNS_PTR.
+
+   If NOSPLIT_P, only return true for constants that only generate the XXSPLTIB
+   instruction and can go in any VSX register.  If !NOSPLIT_P, only return true
+   for constants that generate XXSPLTIB and need a sign extend operation, which
+   restricts us to the Altivec registers.
+
+   Allow either (vec_const [...]) or (vec_duplicate <const>).  If OP is a valid
+   XXSPLTIB constant, return the constant being set via the CONST_PTR
+   pointer.  */
+
+bool
+xxspltib_constant_p (rtx op,
+                    machine_mode mode,
+                    int *num_insns_ptr,
+                    int *constant_ptr)
+{
+  size_t nunits = GET_MODE_NUNITS (mode);
+  size_t i;
+  HOST_WIDE_INT value;
+  rtx element;
+
+  /* Set the returned values to out of bound values.  */
+  *num_insns_ptr = -1;
+  *constant_ptr = 256;
+
+  if (!TARGET_P9_VECTOR)
+    return false;
+
+  if (mode == VOIDmode)
+    mode = GET_MODE (op);
+
+  else if (mode != GET_MODE (op))
+    return false;
+
+  /* Handle (vec_duplicate <constant>).  */
+  if (GET_CODE (op) == VEC_DUPLICATE)
+    {
+      if (mode != V16QImode && mode != V8HImode && mode != V4SImode
+         && mode != V2DImode)
+       return false;
+
+      element = XEXP (op, 0);
+      if (!CONST_INT_P (element))
+       return false;
+
+      value = INTVAL (element);
+      if (!IN_RANGE (value, -128, 127))
+       return false;
+    }
+
+  /* Handle (const_vector [...]).  */
+  else if (GET_CODE (op) == CONST_VECTOR)
+    {
+      if (mode != V16QImode && mode != V8HImode && mode != V4SImode
+         && mode != V2DImode)
+       return false;
+
+      element = CONST_VECTOR_ELT (op, 0);
+      if (!CONST_INT_P (element))
+       return false;
+
+      value = INTVAL (element);
+      if (!IN_RANGE (value, -128, 127))
+       return false;
+
+      for (i = 1; i < nunits; i++)
+       {
+         element = CONST_VECTOR_ELT (op, i);
+         if (!CONST_INT_P (element))
+           return false;
+
+         if (value != INTVAL (element))
+           return false;
+       }
+
+      /* See if we could generate vspltisw/vspltish directly instead of
+        xxspltib + sign extend.  Special case 0/-1 to allow getting
+         any VSX register instead of an Altivec register.  */
+      if (!IN_RANGE (value, -1, 0) && EASY_VECTOR_15 (value)
+         && (mode == V4SImode || mode == V8HImode))
+       return false;
+    }
+
+  /* Handle integer constants being loaded into the upper part of the VSX
+     register as a scalar.  If the value isn't 0/-1, only allow it if
+     the mode can go in Altivec registers.  */
+  else if (CONST_INT_P (op))
+    {
+      if (!SCALAR_INT_MODE_P (mode))
+       return false;
+
+      value = INTVAL (op);
+      if (!IN_RANGE (value, -128, 127))
+       return false;
+
+      if (!IN_RANGE (value, -1, 0)
+         && (reg_addr[mode].addr_mask[RELOAD_REG_VMX] & RELOAD_REG_VALID) == 0)
+       return false;
+    }
+
+  else
+    return false;
+
+  /* Return # of instructions and the constant byte for XXSPLTIB.  */
+  if (mode == V16QImode)
+    *num_insns_ptr = 1;
+
+  else if (IN_RANGE (value, -1, 0))
+    *num_insns_ptr = 1;
+
+  else
+    *num_insns_ptr = 2;
+
+  *constant_ptr = (int) value;
+  return true;
+}
+
  const char *
  output_vec_const_move (rtx *operands)
  {
@@ -6147,23 +6368,60 @@ output_vec_const_move (rtx *operands)
  
    if (TARGET_VSX)
      {
+      bool dest_vmx_p = ALTIVEC_REGNO_P (REGNO (dest));
+      int xxspltib_value = 256;
+      int num_insns = -1;
+
        if (zero_constant (vec, mode))
-       return "xxlxor %x0,%x0,%x0";
+       {
+         if (TARGET_P9_VECTOR)
+           return "xxspltib %x0,0";
  
-      if (TARGET_P8_VECTOR && vec == CONSTM1_RTX (mode))
-       return "xxlorc %x0,%x0,%x0";
+         else if (dest_vmx_p)
+           return "vspltisw %0,0";
+
+         else
+           return "xxlxor %x0,%x0,%x0";
+       }
+
+      if (all_ones_constant (vec, mode))
+       {
+         if (TARGET_P9_VECTOR)
+           return "xxspltib %x0,255";
  
-      if ((mode == V2DImode || mode == V1TImode)
-         && INTVAL (CONST_VECTOR_ELT (vec, 0)) == -1
-         && INTVAL (CONST_VECTOR_ELT (vec, 1)) == -1)
-       return (TARGET_P8_VECTOR) ? "xxlorc %x0,%x0,%x0" : "vspltisw %0,-1";
+         else if (dest_vmx_p)
+           return "vspltisw %0,-1";
+
+         else if (TARGET_P8_VECTOR)
+           return "xxlorc %x0,%x0,%x0";
+
+         else
+           gcc_unreachable ();
+       }
+
+      if (TARGET_P9_VECTOR
+         && xxspltib_constant_p (vec, mode, &num_insns, &xxspltib_value))
+       {
+         if (num_insns == 1)
+           {
+             operands[2] = GEN_INT (xxspltib_value & 0xff);
+             return "xxspltib %x0,%2";
+           }
+
+         return "#";
+       }
      }
  
    if (TARGET_ALTIVEC)
      {
        rtx splat_vec;
+
+      gcc_assert (ALTIVEC_REGNO_P (REGNO (dest)));
        if (zero_constant (vec, mode))
-       return "vxor %0,%0,%0";
+       return "vspltisw %0,0";
+
+      if (all_ones_constant (vec, mode))
+       return "vspltisw %0,-1";
  
        /* Do we need to construct a value using VSLDOI?  */
        shift = vspltis_shifted (vec);
@@ -6436,6 +6694,15 @@ rs6000_expand_vector_init (rtx target, rtx vals)
        return;
      }
  
+  /* Word values on ISA 3.0 can use mtvsrws, lxvwsx, or vspltisw.  V4SF is
+     complicated since scalars are stored as doubles in the registers.  */
+  if (TARGET_P9_VECTOR && mode == V4SImode && all_same
+      && VECTOR_MEM_VSX_P (mode))
+    {
+      emit_insn (gen_vsx_splat_v4si (target, XVECEXP (vals, 0, 0)));
+      return;
+    }
+
    /* With single precision floating point on VSX, know that internally single
       precision is actually represented as a double, and either make 2 V2DF
       vectors, and convert these vectors to single precision, or do one
@@ -6444,14 +6711,23 @@ rs6000_expand_vector_init (rtx target, rtx vals)
      {
        if (all_same)
         {
-         rtx freg = gen_reg_rtx (V4SFmode);
-         rtx sreg = force_reg (SFmode, XVECEXP (vals, 0, 0));
-         rtx cvt  = ((TARGET_XSCVDPSPN)
-                     ? gen_vsx_xscvdpspn_scalar (freg, sreg)
-                     : gen_vsx_xscvdpsp_scalar (freg, sreg));
+         rtx op0 = XVECEXP (vals, 0, 0);
+
+         if (TARGET_P9_VECTOR)
+           emit_insn (gen_vsx_splat_v4sf (target, op0));
  
-         emit_insn (cvt);
-         emit_insn (gen_vsx_xxspltw_v4sf_direct (target, freg, const0_rtx));
+         else
+           {
+             rtx freg = gen_reg_rtx (V4SFmode);
+             rtx sreg = force_reg (SFmode, op0);
+             rtx cvt  = (TARGET_XSCVDPSPN
+                         ? gen_vsx_xscvdpspn_scalar (freg, sreg)
+                         : gen_vsx_xscvdpsp_scalar (freg, sreg));
+
+             emit_insn (cvt);
+             emit_insn (gen_vsx_xxspltw_v4sf_direct (target, freg,
+                                                     const0_rtx));
+           }
         }
        else
         {
@@ -6572,21 +6848,29 @@ rs6000_expand_vector_set (rtx target, rtx val, int elt)
                         gen_rtvec (3, target, reg,
                                    force_reg (V16QImode, x)),
                         UNSPEC_VPERM);
-  else 
+  else
      {
-      /* Invert selector.  We prefer to generate VNAND on P8 so
-         that future fusion opportunities can kick in, but must
-         generate VNOR elsewhere.  */
-      rtx notx = gen_rtx_NOT (V16QImode, force_reg (V16QImode, x));
-      rtx iorx = (TARGET_P8_VECTOR
-                 ? gen_rtx_IOR (V16QImode, notx, notx)
-                 : gen_rtx_AND (V16QImode, notx, notx));
-      rtx tmp = gen_reg_rtx (V16QImode);
-      emit_insn (gen_rtx_SET (tmp, iorx));
+      if (TARGET_P9_VECTOR)
+       x = gen_rtx_UNSPEC (mode,
+                           gen_rtvec (3, target, reg,
+                                      force_reg (V16QImode, x)),
+                           UNSPEC_VPERMR);
+      else
+       {
+         /* Invert selector.  We prefer to generate VNAND on P8 so
+            that future fusion opportunities can kick in, but must
+            generate VNOR elsewhere.  */
+         rtx notx = gen_rtx_NOT (V16QImode, force_reg (V16QImode, x));
+         rtx iorx = (TARGET_P8_VECTOR
+                     ? gen_rtx_IOR (V16QImode, notx, notx)
+                     : gen_rtx_AND (V16QImode, notx, notx));
+         rtx tmp = gen_reg_rtx (V16QImode);
+         emit_insn (gen_rtx_SET (tmp, iorx));
  
-      /* Permute with operands reversed and adjusted selector.  */
-      x = gen_rtx_UNSPEC (mode, gen_rtvec (3, reg, target, tmp),
-                         UNSPEC_VPERM);
+         /* Permute with operands reversed and adjusted selector.  */
+         x = gen_rtx_UNSPEC (mode, gen_rtvec (3, reg, target, tmp),
+                             UNSPEC_VPERM);
+       }
      }
  
    emit_insn (gen_rtx_SET (target, x));
@@ -6902,6 +7186,59 @@ direct_move_p (rtx op0, rtx op1)
    return false;
  }
  
+/* Return true if the OFFSET is valid for the quad address instructions that
+   use d-form (register + offset) addressing.  */
+
+static inline bool
+quad_address_offset_p (HOST_WIDE_INT offset)
+{
+  return (IN_RANGE (offset, -32768, 32767) && ((offset) & 0xf) == 0);
+}
+
+/* Return true if the ADDR is an acceptable address for a quad memory
+   operation of mode MODE (either LQ/STQ for general purpose registers, or
+   LXV/STXV for vector registers under ISA 3.0.  GPR_P is true if this address
+   is intended for LQ/STQ.  If it is false, the address is intended for the ISA
+   3.0 LXV/STXV instruction.  */
+
+bool
+quad_address_p (rtx addr, machine_mode mode, bool gpr_p)
+{
+  rtx op0, op1;
+
+  if (GET_MODE_SIZE (mode) != 16)
+    return false;
+
+  if (gpr_p)
+    {
+      if (!TARGET_QUAD_MEMORY && !TARGET_SYNC_TI)
+       return false;
+
+      /* LQ/STQ can handle indirect addresses.  */
+      if (base_reg_operand (addr, Pmode))
+       return true;
+    }
+
+  else
+    {
+      if (!mode_supports_vsx_dform_quad (mode))
+       return false;
+    }
+
+  if (GET_CODE (addr) != PLUS)
+    return false;
+
+  op0 = XEXP (addr, 0);
+  if (!base_reg_operand (op0, Pmode))
+    return false;
+
+  op1 = XEXP (addr, 1);
+  if (!CONST_INT_P (op1))
+    return false;
+
+  return quad_address_offset_p (INTVAL (op1));
+}
+
  /* Return true if this is a load or store quad operation.  This function does
     not handle the atomic quad memory instructions.  */
  
@@ -6994,6 +7331,10 @@ mem_operand_gpr (rtx op, machine_mode mode)
    if (TARGET_POWERPC64 && (offset & 3) != 0)
      return false;
  
+  if (mode_supports_vsx_dform_quad (mode)
+      && !quad_address_offset_p (offset))
+    return false;
+
    extra = GET_MODE_SIZE (mode) - UNITS_PER_WORD;
    if (extra < 0)
      extra = 0;
@@ -7023,13 +7364,14 @@ reg_offset_addressing_ok_p (machine_mode mode)
      case TImode:
      case TFmode:
      case KFmode:
-      /* AltiVec/VSX vector modes.  Only reg+reg addressing is valid.  While
-        TImode is not a vector mode, if we want to use the VSX registers to
-        move it around, we need to restrict ourselves to reg+reg addressing.
-        Similarly for IEEE 128-bit floating point that is passed in a single
-        vector register.  */
+      /* AltiVec/VSX vector modes.  Only reg+reg addressing was valid until the
+        ISA 3.0 vector d-form addressing mode was added.  While TImode is not
+        a vector mode, if we want to use the VSX registers to move it around,
+        we need to restrict ourselves to reg+reg addressing.  Similarly for
+        IEEE 128-bit floating point that is passed in a single vector
+        register.  */
        if (VECTOR_MEM_ALTIVEC_OR_VSX_P (mode))
-       return false;
+       return mode_supports_vsx_dform_quad (mode);
        break;
  
      case V4HImode:
@@ -7096,6 +7438,11 @@ offsettable_ok_by_alignment (rtx op, HOST_WIDE_INT offset,
    if (GET_CODE (op) != SYMBOL_REF)
      return false;
  
+  /* ISA 3.0 vector d-form addressing is restricted, don't allow
+     SYMBOL_REF.  */
+  if (mode_supports_vsx_dform_quad (mode))
+    return false;
+
    dsize = GET_MODE_SIZE (mode);
    decl = SYMBOL_REF_DECL (op);
    if (!decl)
@@ -7250,6 +7597,9 @@ rs6000_legitimate_offset_address_p (machine_mode mode, rtx x,
      return false;
    if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
      return false;
+  if (mode_supports_vsx_dform_quad (mode))
+    return (virtual_stack_registers_memory_p (x)
+           || quad_address_p (x, mode, false));
    if (!reg_offset_addressing_ok_p (mode))
      return virtual_stack_registers_memory_p (x);
    if (legitimate_constant_pool_address_p (x, mode, strict || lra_in_progress))
@@ -7388,6 +7738,9 @@ legitimate_lo_sum_address_p (machine_mode mode, rtx x, int strict)
      return false;
    if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
      return false;
+  /* quad word addresses are restricted, and we can't use LO_SUM.  */
+  if (mode_supports_vsx_dform_quad (mode))
+    return false;
    /* Restrict addressing for DI because of our SUBREG hackery.  */
    if (TARGET_E500_DOUBLE && GET_MODE_SIZE (mode) > UNITS_PER_WORD)
      return false;
@@ -7399,7 +7752,7 @@ legitimate_lo_sum_address_p (machine_mode mode, rtx x, int strict)
  
        if (DEFAULT_ABI == ABI_V4 && flag_pic)
         return false;
-      /* LRA don't use LEGITIMIZE_RELOAD_ADDRESS as it usually calls
+      /* LRA doesn't use LEGITIMIZE_RELOAD_ADDRESS as it usually calls
          push_reload from reload pass code.  LEGITIMIZE_RELOAD_ADDRESS
          recognizes some LO_SUM addresses as valid although this
          function says opposite.  In most cases, LRA through different
@@ -7453,7 +7806,8 @@ rs6000_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
  {
    unsigned int extra;
  
-  if (!reg_offset_addressing_ok_p (mode))
+  if (!reg_offset_addressing_ok_p (mode)
+      || mode_supports_vsx_dform_quad (mode))
      {
        if (virtual_stack_registers_memory_p (x))
         return x;
@@ -8149,12 +8503,16 @@ rs6000_legitimize_reload_address (rtx x, machine_mode mode,
  {
    bool reg_offset_p = reg_offset_addressing_ok_p (mode);
  
-  /* Nasty hack for vsx_splat_V2DF/V2DI load from mem, which takes a
-     DFmode/DImode MEM.  */
+  /* Nasty hack for vsx_splat_v2df/v2di load from mem, which takes a
+     DFmode/DImode MEM.  Ditto for ISA 3.0 vsx_splat_v4sf/v4si.  */
    if (reg_offset_p
        && opnum == 1
        && ((mode == DFmode && recog_data.operand_mode[0] == V2DFmode)
-         || (mode == DImode && recog_data.operand_mode[0] == V2DImode)))
+         || (mode == DImode && recog_data.operand_mode[0] == V2DImode)
+         || (mode == SFmode && recog_data.operand_mode[0] == V4SFmode
+             && TARGET_P9_VECTOR)
+         || (mode == SImode && recog_data.operand_mode[0] == V4SImode
+             && TARGET_P9_VECTOR)))
      reg_offset_p = false;
  
    /* We must recognize output that we have already generated ourselves.  */
@@ -8164,6 +8522,11 @@ rs6000_legitimize_reload_address (rtx x, machine_mode mode,
        && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
        && GET_CODE (XEXP (x, 1)) == CONST_INT)
      {
+      if (TARGET_DEBUG_ADDR)
+       {
+         fprintf (stderr, "\nlegitimize_reload_address push_reload #1:\n");
+         debug_rtx (x);
+       }
        push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
                    opnum, (enum reload_type) type);
@@ -8175,6 +8538,11 @@ rs6000_legitimize_reload_address (rtx x, machine_mode mode,
    if (GET_CODE (x) == LO_SUM
        && GET_CODE (XEXP (x, 0)) == HIGH)
      {
+      if (TARGET_DEBUG_ADDR)
+       {
+         fprintf (stderr, "\nlegitimize_reload_address push_reload #2:\n");
+         debug_rtx (x);
+       }
        push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
                    opnum, (enum reload_type) type);
@@ -8207,6 +8575,11 @@ rs6000_legitimize_reload_address (rtx x, machine_mode mode,
      {
        rtx hi = gen_rtx_HIGH (Pmode, copy_rtx (x));
        x = gen_rtx_LO_SUM (Pmode, hi, x);
+      if (TARGET_DEBUG_ADDR)
+       {
+         fprintf (stderr, "\nlegitimize_reload_address push_reload #3:\n");
+         debug_rtx (x);
+       }
        push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
                    opnum, (enum reload_type) type);
@@ -8244,6 +8617,11 @@ rs6000_legitimize_reload_address (rtx x, machine_mode mode,
                                       GEN_INT (high)),
                         GEN_INT (low));
  
+      if (TARGET_DEBUG_ADDR)
+       {
+         fprintf (stderr, "\nlegitimize_reload_address push_reload #4:\n");
+         debug_rtx (x);
+       }
        push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
                    opnum, (enum reload_type) type);
@@ -8304,6 +8682,11 @@ rs6000_legitimize_reload_address (rtx x, machine_mode mode,
         x = gen_rtx_LO_SUM (GET_MODE (x),
               gen_rtx_HIGH (Pmode, x), x);
  
+      if (TARGET_DEBUG_ADDR)
+       {
+         fprintf (stderr, "\nlegitimize_reload_address push_reload #5:\n");
+         debug_rtx (x);
+       }
        push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
                    opnum, (enum reload_type) type);
@@ -8337,9 +8720,16 @@ rs6000_legitimize_reload_address (rtx x, machine_mode mode,
      {
        x = create_TOC_reference (x, NULL_RTX);
        if (TARGET_CMODEL != CMODEL_SMALL)
-       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
-                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
-                    opnum, (enum reload_type) type);
+       {
+         if (TARGET_DEBUG_ADDR)
+           {
+             fprintf (stderr, "\nlegitimize_reload_address push_reload #6:\n");
+             debug_rtx (x);
+           }
+         push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
+                      BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
+                      opnum, (enum reload_type) type);
+       }
        *win = 1;
        return x;
      }
@@ -8395,6 +8785,7 @@ static bool
  rs6000_legitimate_address_p (machine_mode mode, rtx x, bool reg_ok_strict)
  {
    bool reg_offset_p = reg_offset_addressing_ok_p (mode);
+  bool quad_offset_p = mode_supports_vsx_dform_quad (mode);
  
    /* If this is an unaligned stvx/ldvx type address, discard the outer AND.  */
    if (VECTOR_MEM_ALTIVEC_P (mode)
@@ -8414,15 +8805,26 @@ rs6000_legitimate_address_p (machine_mode mode, rtx x, bool reg_ok_strict)
      return 1;
    if (virtual_stack_registers_memory_p (x))
      return 1;
-  if (reg_offset_p && legitimate_small_data_p (mode, x))
-    return 1;
-  if (reg_offset_p
-      && legitimate_constant_pool_address_p (x, mode,
+
+  /* Handle restricted vector d-form offsets in ISA 3.0.  */
+  if (quad_offset_p)
+    {
+      if (quad_address_p (x, mode, false))
+       return 1;
+    }
+
+  else if (reg_offset_p)
+    {
+      if (legitimate_small_data_p (mode, x))
+       return 1;
+      if (legitimate_constant_pool_address_p (x, mode,
                                              reg_ok_strict || lra_in_progress))
-    return 1;
-  if (reg_offset_p && reg_addr[mode].fused_toc && GET_CODE (x) == UNSPEC
-      && XINT (x, 1) == UNSPEC_FUSION_ADDIS)
-    return 1;
+       return 1;
+      if (reg_addr[mode].fused_toc && GET_CODE (x) == UNSPEC
+         && XINT (x, 1) == UNSPEC_FUSION_ADDIS)
+       return 1;
+    }
+
    /* For TImode, if we have load/store quad and TImode in VSX registers, only
       allow register indirect addresses.  This will allow the values to go in
       either GPRs or VSX registers without reloading.  The vector types would
@@ -8461,7 +8863,8 @@ rs6000_legitimate_address_p (machine_mode mode, rtx x, bool reg_ok_strict)
               && legitimate_indexed_address_p (XEXP (x, 1), reg_ok_strict)))
        && rtx_equal_p (XEXP (XEXP (x, 1), 0), XEXP (x, 0)))
      return 1;
-  if (reg_offset_p && legitimate_lo_sum_address_p (mode, x, reg_ok_strict))
+  if (reg_offset_p && !quad_offset_p
+      && legitimate_lo_sum_address_p (mode, x, reg_ok_strict))
      return 1;
    return 0;
  }
@@ -12260,7 +12663,7 @@ def_builtin (const char *name, tree type, enum rs6000_builtins code)
        /* const function, function only depends on the inputs.  */
        TREE_READONLY (t) = 1;
        TREE_NOTHROW (t) = 1;
-      attr_string = ", pure";
+      attr_string = ", const";
      }
    else if ((classify & RS6000_BTC_PURE) != 0)
      {
@@ -12268,7 +12671,7 @@ def_builtin (const char *name, tree type, enum rs6000_builtins code)
          external state.  */
        DECL_PURE_P (t) = 1;
        TREE_NOTHROW (t) = 1;
-      attr_string = ", const";
+      attr_string = ", pure";
      }
    else if ((classify & RS6000_BTC_FP) != 0)
      {
@@ -12300,6 +12703,7 @@ def_builtin (const char *name, tree type, enum rs6000_builtins code)
  
  /* Simple ternary operations: VECd = foo (VECa, VECb, VECc).  */
  
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -12312,6 +12716,7 @@ def_builtin (const char *name, tree type, enum rs6000_builtins code)
  #undef RS6000_BUILTIN_S
  #undef RS6000_BUILTIN_X
  
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_2(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_3(ENUM, NAME, MASK, ATTR, ICODE) \
@@ -12333,6 +12738,7 @@ static const struct builtin_description bdesc_3arg[] =
  
  /* DST operations: void foo (void *, const int, const char).  */
  
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -12345,6 +12751,7 @@ static const struct builtin_description bdesc_3arg[] =
  #undef RS6000_BUILTIN_S
  #undef RS6000_BUILTIN_X
  
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_2(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_3(ENUM, NAME, MASK, ATTR, ICODE)
@@ -12366,6 +12773,7 @@ static const struct builtin_description bdesc_dst[] =
  
  /* Simple binary operations: VECc = foo (VECa, VECb).  */
  
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -12378,6 +12786,7 @@ static const struct builtin_description bdesc_dst[] =
  #undef RS6000_BUILTIN_S
  #undef RS6000_BUILTIN_X
  
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_2(ENUM, NAME, MASK, ATTR, ICODE) \
    { MASK, ICODE, NAME, ENUM },
@@ -12397,6 +12806,7 @@ static const struct builtin_description bdesc_2arg[] =
  #include "rs6000-builtin.def"
  };
  
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -12409,6 +12819,7 @@ static const struct builtin_description bdesc_2arg[] =
  #undef RS6000_BUILTIN_S
  #undef RS6000_BUILTIN_X
  
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_2(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_3(ENUM, NAME, MASK, ATTR, ICODE)
@@ -12431,6 +12842,7 @@ static const struct builtin_description bdesc_altivec_preds[] =
  };
  
  /* SPE predicates.  */
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -12443,6 +12855,7 @@ static const struct builtin_description bdesc_altivec_preds[] =
  #undef RS6000_BUILTIN_S
  #undef RS6000_BUILTIN_X
  
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_2(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_3(ENUM, NAME, MASK, ATTR, ICODE)
@@ -12463,6 +12876,7 @@ static const struct builtin_description bdesc_spe_predicates[] =
  };
  
  /* SPE evsel predicates.  */
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -12475,6 +12889,7 @@ static const struct builtin_description bdesc_spe_predicates[] =
  #undef RS6000_BUILTIN_S
  #undef RS6000_BUILTIN_X
  
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_2(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_3(ENUM, NAME, MASK, ATTR, ICODE)
@@ -12495,6 +12910,7 @@ static const struct builtin_description bdesc_spe_evsel[] =
  };
  
  /* PAIRED predicates.  */
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -12507,6 +12923,7 @@ static const struct builtin_description bdesc_spe_evsel[] =
  #undef RS6000_BUILTIN_S
  #undef RS6000_BUILTIN_X
  
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_2(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_3(ENUM, NAME, MASK, ATTR, ICODE)
@@ -12528,6 +12945,7 @@ static const struct builtin_description bdesc_paired_preds[] =
  
  /* ABS* operations.  */
  
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -12540,6 +12958,7 @@ static const struct builtin_description bdesc_paired_preds[] =
  #undef RS6000_BUILTIN_S
  #undef RS6000_BUILTIN_X
  
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_2(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_3(ENUM, NAME, MASK, ATTR, ICODE)
@@ -12562,6 +12981,7 @@ static const struct builtin_description bdesc_abs[] =
  /* Simple unary operations: VECb = foo (unsigned literal) or VECb =
     foo (VECa).  */
  
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -12574,6 +12994,7 @@ static const struct builtin_description bdesc_abs[] =
  #undef RS6000_BUILTIN_S
  #undef RS6000_BUILTIN_X
  
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE) \
    { MASK, ICODE, NAME, ENUM },
  
@@ -12593,7 +13014,43 @@ static const struct builtin_description bdesc_1arg[] =
  #include "rs6000-builtin.def"
  };
  
+/* Simple no-argument operations: result = __builtin_darn_32 () */
+
+#undef RS6000_BUILTIN_0
+#undef RS6000_BUILTIN_1
+#undef RS6000_BUILTIN_2
+#undef RS6000_BUILTIN_3
+#undef RS6000_BUILTIN_A
+#undef RS6000_BUILTIN_D
+#undef RS6000_BUILTIN_E
+#undef RS6000_BUILTIN_H
+#undef RS6000_BUILTIN_P
+#undef RS6000_BUILTIN_Q
+#undef RS6000_BUILTIN_S
+#undef RS6000_BUILTIN_X
+
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE) \
+  { MASK, ICODE, NAME, ENUM },
+
+#define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE)
+#define RS6000_BUILTIN_2(ENUM, NAME, MASK, ATTR, ICODE)
+#define RS6000_BUILTIN_3(ENUM, NAME, MASK, ATTR, ICODE)
+#define RS6000_BUILTIN_A(ENUM, NAME, MASK, ATTR, ICODE)
+#define RS6000_BUILTIN_D(ENUM, NAME, MASK, ATTR, ICODE)
+#define RS6000_BUILTIN_E(ENUM, NAME, MASK, ATTR, ICODE)
+#define RS6000_BUILTIN_H(ENUM, NAME, MASK, ATTR, ICODE)
+#define RS6000_BUILTIN_P(ENUM, NAME, MASK, ATTR, ICODE)
+#define RS6000_BUILTIN_Q(ENUM, NAME, MASK, ATTR, ICODE)
+#define RS6000_BUILTIN_S(ENUM, NAME, MASK, ATTR, ICODE)
+#define RS6000_BUILTIN_X(ENUM, NAME, MASK, ATTR, ICODE)
+
+static const struct builtin_description bdesc_0arg[] =
+{
+#include "rs6000-builtin.def"
+};
+
  /* HTM builtins.  */
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -12606,6 +13063,7 @@ static const struct builtin_description bdesc_1arg[] =
  #undef RS6000_BUILTIN_S
  #undef RS6000_BUILTIN_X
  
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_2(ENUM, NAME, MASK, ATTR, ICODE)
  #define RS6000_BUILTIN_3(ENUM, NAME, MASK, ATTR, ICODE)
@@ -12625,6 +13083,7 @@ static const struct builtin_description bdesc_htm[] =
  #include "rs6000-builtin.def"
  };
  
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -14129,6 +14588,47 @@ altivec_expand_builtin (tree exp, rtx target, bool *expandedp)
      case VSX_BUILTIN_STXVW4X_V16QI:
        return altivec_expand_stv_builtin (CODE_FOR_vsx_store_v16qi, exp);
  
+    /* For the following on big endian, it's ok to use any appropriate
+       unaligned-supporting store, so use a generic expander.  For
+       little-endian, the exact element-reversing instruction must
+       be used.  */
+    case VSX_BUILTIN_ST_ELEMREV_V2DF:
+      {
+       enum insn_code code = (BYTES_BIG_ENDIAN ? CODE_FOR_vsx_store_v2df
+                              : CODE_FOR_vsx_st_elemrev_v2df);
+       return altivec_expand_stv_builtin (code, exp);
+      }
+    case VSX_BUILTIN_ST_ELEMREV_V2DI:
+      {
+       enum insn_code code = (BYTES_BIG_ENDIAN ? CODE_FOR_vsx_store_v2di
+                              : CODE_FOR_vsx_st_elemrev_v2di);
+       return altivec_expand_stv_builtin (code, exp);
+      }
+    case VSX_BUILTIN_ST_ELEMREV_V4SF:
+      {
+       enum insn_code code = (BYTES_BIG_ENDIAN ? CODE_FOR_vsx_store_v4sf
+                              : CODE_FOR_vsx_st_elemrev_v4sf);
+       return altivec_expand_stv_builtin (code, exp);
+      }
+    case VSX_BUILTIN_ST_ELEMREV_V4SI:
+      {
+       enum insn_code code = (BYTES_BIG_ENDIAN ? CODE_FOR_vsx_store_v4si
+                              : CODE_FOR_vsx_st_elemrev_v4si);
+       return altivec_expand_stv_builtin (code, exp);
+      }
+    case VSX_BUILTIN_ST_ELEMREV_V8HI:
+      {
+       enum insn_code code = (BYTES_BIG_ENDIAN ? CODE_FOR_vsx_store_v8hi
+                              : CODE_FOR_vsx_st_elemrev_v8hi);
+       return altivec_expand_stv_builtin (code, exp);
+      }
+    case VSX_BUILTIN_ST_ELEMREV_V16QI:
+      {
+       enum insn_code code = (BYTES_BIG_ENDIAN ? CODE_FOR_vsx_store_v16qi
+                              : CODE_FOR_vsx_st_elemrev_v16qi);
+       return altivec_expand_stv_builtin (code, exp);
+      }
+
      case ALTIVEC_BUILTIN_MFVSCR:
        icode = CODE_FOR_altivec_mfvscr;
        tmode = insn_data[icode].operand[0].mode;
@@ -14323,6 +14823,46 @@ altivec_expand_builtin (tree exp, rtx target, bool *expandedp)
      case VSX_BUILTIN_LXVW4X_V16QI:
        return altivec_expand_lv_builtin (CODE_FOR_vsx_load_v16qi,
                                         exp, target, false);
+    /* For the following on big endian, it's ok to use any appropriate
+       unaligned-supporting load, so use a generic expander.  For
+       little-endian, the exact element-reversing instruction must
+       be used.  */
+    case VSX_BUILTIN_LD_ELEMREV_V2DF:
+      {
+       enum insn_code code = (BYTES_BIG_ENDIAN ? CODE_FOR_vsx_load_v2df
+                              : CODE_FOR_vsx_ld_elemrev_v2df);
+       return altivec_expand_lv_builtin (code, exp, target, false);
+      }
+    case VSX_BUILTIN_LD_ELEMREV_V2DI:
+      {
+       enum insn_code code = (BYTES_BIG_ENDIAN ? CODE_FOR_vsx_load_v2di
+                              : CODE_FOR_vsx_ld_elemrev_v2di);
+       return altivec_expand_lv_builtin (code, exp, target, false);
+      }
+    case VSX_BUILTIN_LD_ELEMREV_V4SF:
+      {
+       enum insn_code code = (BYTES_BIG_ENDIAN ? CODE_FOR_vsx_load_v4sf
+                              : CODE_FOR_vsx_ld_elemrev_v4sf);
+       return altivec_expand_lv_builtin (code, exp, target, false);
+      }
+    case VSX_BUILTIN_LD_ELEMREV_V4SI:
+      {
+       enum insn_code code = (BYTES_BIG_ENDIAN ? CODE_FOR_vsx_load_v4si
+                              : CODE_FOR_vsx_ld_elemrev_v4si);
+       return altivec_expand_lv_builtin (code, exp, target, false);
+      }
+    case VSX_BUILTIN_LD_ELEMREV_V8HI:
+      {
+       enum insn_code code = (BYTES_BIG_ENDIAN ? CODE_FOR_vsx_load_v8hi
+                              : CODE_FOR_vsx_ld_elemrev_v8hi);
+       return altivec_expand_lv_builtin (code, exp, target, false);
+      }
+    case VSX_BUILTIN_LD_ELEMREV_V16QI:
+      {
+       enum insn_code code = (BYTES_BIG_ENDIAN ? CODE_FOR_vsx_load_v16qi
+                              : CODE_FOR_vsx_ld_elemrev_v16qi);
+       return altivec_expand_lv_builtin (code, exp, target, false);
+      }
        break;
      default:
        break;
@@ -14792,6 +15332,8 @@ rs6000_invalid_builtin (enum rs6000_builtins fncode)
      error ("Builtin function %s requires the -mhard-dfp option", name);
    else if ((fnmask & RS6000_BTM_P8_VECTOR) != 0)
      error ("Builtin function %s requires the -mpower8-vector option", name);
+  else if ((fnmask & RS6000_BTM_P9_VECTOR) != 0)
+    error ("Builtin function %s requires the -mpower9-vector option", name);
    else if ((fnmask & (RS6000_BTM_HARD_FLOAT | RS6000_BTM_LDBL128))
            == (RS6000_BTM_HARD_FLOAT | RS6000_BTM_LDBL128))
      error ("Builtin function %s requires the -mhard-float and"
@@ -14990,9 +15532,11 @@ rs6000_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
      }  
  
    unsigned attr = rs6000_builtin_info[uns_fcode].attr & RS6000_BTC_TYPE_MASK;
+  /* RS6000_BTC_SPECIAL represents no-operand operators.  */
    gcc_assert (attr == RS6000_BTC_UNARY
               || attr == RS6000_BTC_BINARY
-             || attr == RS6000_BTC_TERNARY);
+             || attr == RS6000_BTC_TERNARY
+             || attr == RS6000_BTC_SPECIAL);
  
    /* Handle simple unary operations.  */
    d = bdesc_1arg;
@@ -15012,6 +15556,12 @@ rs6000_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
      if (d->code == fcode)
        return rs6000_expand_ternop_builtin (d->icode, exp, target);
  
+  /* Handle simple no-argument operations. */
+  d = bdesc_0arg;
+  for (i = 0; i < ARRAY_SIZE (bdesc_0arg); i++, d++)
+    if (d->code == fcode)
+      return rs6000_expand_zeroop_builtin (d->icode, target);
+
    gcc_unreachable ();
  }
  
@@ -15816,10 +16366,44 @@ altivec_init_builtins (void)
                VSX_BUILTIN_STXVW4X_V8HI);
    def_builtin ("__builtin_vsx_stxvw4x_v16qi", void_ftype_v16qi_long_pvoid,
                VSX_BUILTIN_STXVW4X_V16QI);
+
+  def_builtin ("__builtin_vsx_ld_elemrev_v2df", v2df_ftype_long_pcvoid,
+              VSX_BUILTIN_LD_ELEMREV_V2DF);
+  def_builtin ("__builtin_vsx_ld_elemrev_v2di", v2di_ftype_long_pcvoid,
+              VSX_BUILTIN_LD_ELEMREV_V2DI);
+  def_builtin ("__builtin_vsx_ld_elemrev_v4sf", v4sf_ftype_long_pcvoid,
+              VSX_BUILTIN_LD_ELEMREV_V4SF);
+  def_builtin ("__builtin_vsx_ld_elemrev_v4si", v4si_ftype_long_pcvoid,
+              VSX_BUILTIN_LD_ELEMREV_V4SI);
+  def_builtin ("__builtin_vsx_st_elemrev_v2df", void_ftype_v2df_long_pvoid,
+              VSX_BUILTIN_ST_ELEMREV_V2DF);
+  def_builtin ("__builtin_vsx_st_elemrev_v2di", void_ftype_v2di_long_pvoid,
+              VSX_BUILTIN_ST_ELEMREV_V2DI);
+  def_builtin ("__builtin_vsx_st_elemrev_v4sf", void_ftype_v4sf_long_pvoid,
+              VSX_BUILTIN_ST_ELEMREV_V4SF);
+  def_builtin ("__builtin_vsx_st_elemrev_v4si", void_ftype_v4si_long_pvoid,
+              VSX_BUILTIN_ST_ELEMREV_V4SI);
+
+  if (TARGET_P9_VECTOR)
+    {
+      def_builtin ("__builtin_vsx_ld_elemrev_v8hi", v8hi_ftype_long_pcvoid,
+                  VSX_BUILTIN_LD_ELEMREV_V8HI);
+      def_builtin ("__builtin_vsx_ld_elemrev_v16qi", v16qi_ftype_long_pcvoid,
+                  VSX_BUILTIN_LD_ELEMREV_V16QI);
+      def_builtin ("__builtin_vsx_st_elemrev_v8hi",
+                  void_ftype_v8hi_long_pvoid, VSX_BUILTIN_ST_ELEMREV_V8HI);
+      def_builtin ("__builtin_vsx_st_elemrev_v16qi",
+                  void_ftype_v16qi_long_pvoid, VSX_BUILTIN_ST_ELEMREV_V16QI);
+    }
+
    def_builtin ("__builtin_vec_vsx_ld", opaque_ftype_long_pcvoid,
                VSX_BUILTIN_VEC_LD);
    def_builtin ("__builtin_vec_vsx_st", void_ftype_opaque_long_pvoid,
                VSX_BUILTIN_VEC_ST);
+  def_builtin ("__builtin_vec_xl", opaque_ftype_long_pcvoid,
+              VSX_BUILTIN_VEC_XL);
+  def_builtin ("__builtin_vec_xst", void_ftype_opaque_long_pvoid,
+              VSX_BUILTIN_VEC_XST);
  
    def_builtin ("__builtin_vec_step", int_ftype_opaque, ALTIVEC_BUILTIN_VEC_STEP);
    def_builtin ("__builtin_vec_splats", opaque_ftype_opaque, ALTIVEC_BUILTIN_VEC_SPLATS);
@@ -16351,10 +16935,6 @@ builtin_function_type (machine_mode mode_ret, machine_mode mode_arg0,
    while (num_args > 0 && h.mode[num_args] == VOIDmode)
      num_args--;
  
-  if (num_args == 0)
-    fatal_error (input_location,
-                "internal error: builtin function %s had no type", name);
-
    ret_type = builtin_mode_to_type[h.mode[0]][h.uns_p[0]];
    if (!ret_type && h.uns_p[0])
      ret_type = builtin_mode_to_type[h.mode[0]][0];
@@ -16406,6 +16986,7 @@ rs6000_common_init_builtins (void)
    tree opaque_ftype_opaque = NULL_TREE;
    tree opaque_ftype_opaque_opaque = NULL_TREE;
    tree opaque_ftype_opaque_opaque_opaque = NULL_TREE;
+  tree v2si_ftype = NULL_TREE;
    tree v2si_ftype_qi = NULL_TREE;
    tree v2si_ftype_v2si_qi = NULL_TREE;
    tree v2si_ftype_int_qi = NULL_TREE;
@@ -16622,6 +17203,64 @@ rs6000_common_init_builtins (void)
  
        def_builtin (d->name, type, d->code);
      }
+
+  /* Add the simple no-argument operators.  */
+  d = bdesc_0arg;
+  for (i = 0; i < ARRAY_SIZE (bdesc_0arg); i++, d++)
+    {
+      machine_mode mode0;
+      tree type;
+      HOST_WIDE_INT mask = d->mask;
+
+      if ((mask & builtin_mask) != mask)
+       {
+         if (TARGET_DEBUG_BUILTIN)
+           fprintf (stderr, "rs6000_builtin, skip no-argument %s\n", d->name);
+         continue;
+       }
+      if (rs6000_overloaded_builtin_p (d->code))
+       {
+         if (!opaque_ftype_opaque)
+           opaque_ftype_opaque
+             = build_function_type_list (opaque_V4SI_type_node, NULL_TREE);
+         type = opaque_ftype_opaque;
+       }
+      else
+       {
+         enum insn_code icode = d->icode;
+         if (d->name == 0)
+           {
+             if (TARGET_DEBUG_BUILTIN)
+               fprintf (stderr, "rs6000_builtin, bdesc_0arg[%lu] no name\n",
+                        (long unsigned) i);
+             continue;
+           }
+         if (icode == CODE_FOR_nothing)
+           {
+             if (TARGET_DEBUG_BUILTIN)
+               fprintf (stderr,
+                        "rs6000_builtin, skip no-argument %s (no code)\n",
+                        d->name);
+             continue;
+           }
+         mode0 = insn_data[icode].operand[0].mode;
+         if (mode0 == V2SImode)
+           {
+             /* code for SPE */
+             if (! (type = v2si_ftype))
+               {
+                 v2si_ftype
+                   = build_function_type_list (opaque_V2SI_type_node, 
+                                               NULL_TREE);
+                 type = v2si_ftype;
+               }
+           }
+         else
+           type = builtin_function_type (mode0, VOIDmode, VOIDmode, VOIDmode,
+                                         d->code, d->name);
+       }
+      def_builtin (d->name, type, d->code);
+    }
  }
  
  /* Set up AIX/Darwin/64-bit Linux quad floating point routines.  */
@@ -18152,13 +18791,23 @@ rs6000_secondary_reload_memory (rtx addr,
             }
         }
  
+      else if ((addr_mask & RELOAD_REG_QUAD_OFFSET) != 0
+              && CONST_INT_P (plus_arg1))
+       {
+         if (!quad_address_offset_p (INTVAL (plus_arg1)))
+           {
+             extra_cost = 1;
+             type = "vector d-form offset";
+           }
+       }
+
        /* Make sure the register class can handle offset addresses.  */
        else if (rs6000_legitimate_offset_address_p (mode, addr, false, true))
         {
           if ((addr_mask & RELOAD_REG_OFFSET) == 0)
             {
               extra_cost = 1;
-             type = "offset";
+             type = "offset #2";
             }
         }
  
@@ -18171,7 +18820,14 @@ rs6000_secondary_reload_memory (rtx addr,
        break;
  
      case LO_SUM:
-      if (!legitimate_lo_sum_address_p (mode, addr, false))
+      /* Quad offsets are restricted and can't handle normal addresses.  */
+      if ((addr_mask & RELOAD_REG_QUAD_OFFSET) != 0)
+       {
+         extra_cost = -1;
+         type = "vector d-form lo_sum";
+       }
+
+      else if (!legitimate_lo_sum_address_p (mode, addr, false))
         {
           fail_msg = "bad LO_SUM";
           extra_cost = -1;
@@ -18188,8 +18844,17 @@ rs6000_secondary_reload_memory (rtx addr,
      case CONST:
      case SYMBOL_REF:
      case LABEL_REF:
-      type = "address";
-      extra_cost = rs6000_secondary_reload_toc_costs (addr_mask);
+      if ((addr_mask & RELOAD_REG_QUAD_OFFSET) != 0)
+       {
+         extra_cost = -1;
+         type = "vector d-form lo_sum #2";
+       }
+
+      else
+       {
+         type = "address";
+         extra_cost = rs6000_secondary_reload_toc_costs (addr_mask);
+       }
        break;
  
        /* TOC references look like offsetable memory.  */
@@ -18200,6 +18865,12 @@ rs6000_secondary_reload_memory (rtx addr,
           extra_cost = -1;
         }
  
+      else if ((addr_mask & RELOAD_REG_QUAD_OFFSET) != 0)
+       {
+         extra_cost = -1;
+         type = "vector d-form lo_sum #3";
+       }
+
        else if ((addr_mask & RELOAD_REG_OFFSET) == 0)
         {
           extra_cost = 1;
@@ -18827,6 +19498,16 @@ rs6000_secondary_reload_inner (rtx reg, rtx mem, rtx scratch, bool store_p)
             }
         }
  
+      else if (mode_supports_vsx_dform_quad (mode) && CONST_INT_P (op1))
+       {
+         if (((addr_mask & RELOAD_REG_QUAD_OFFSET) == 0)
+             || !quad_address_p (addr, mode, false))
+           {
+             emit_insn (gen_rtx_SET (scratch, addr));
+             new_addr = scratch;
+           }
+       }
+
        /* Make sure the register class can handle offset addresses.  */
        else if (rs6000_legitimate_offset_address_p (mode, addr, false, true))
         {
@@ -18857,6 +19538,13 @@ rs6000_secondary_reload_inner (rtx reg, rtx mem, rtx scratch, bool store_p)
             }
         }
  
+      /* Quad offsets are restricted and can't handle normal addresses.  */
+      else if (mode_supports_vsx_dform_quad (mode))
+       {
+         emit_insn (gen_rtx_SET (scratch, addr));
+         new_addr = scratch;
+       }
+
        /* Make sure the register class can handle offset addresses.  */
        else if (legitimate_lo_sum_address_p (mode, addr, false))
         {
@@ -19067,7 +19755,8 @@ rs6000_preferred_reload_class (rtx x, enum reg_class rclass)
         }
  
        /* D-form addressing can easily reload the value.  */
-      if (mode_supports_vmx_dform (mode))
+      if (mode_supports_vmx_dform (mode)
+         || mode_supports_vsx_dform_quad (mode))
         return rclass;
  
        /* If this is a scalar floating point value and we don't have D-form
@@ -19483,8 +20172,16 @@ rs6000_output_move_128bit (rtx operands[])
  
        else if (TARGET_VSX && dest_vsx_p)
         {
-         if (mode == V16QImode || mode == V8HImode || mode == V4SImode)
+         if (mode_supports_vsx_dform_quad (mode)
+             && quad_address_p (XEXP (src, 0), mode, false))
+           return "lxv %x0,%1";
+
+         else if (TARGET_P9_VECTOR)
+           return "lxvx %x0,%y1";
+
+         else if (mode == V16QImode || mode == V8HImode || mode == V4SImode)
             return "lxvw4x %x0,%y1";
+
           else
             return "lxvd2x %x0,%y1";
         }
@@ -19513,8 +20210,16 @@ rs6000_output_move_128bit (rtx operands[])
  
        else if (TARGET_VSX && src_vsx_p)
         {
-         if (mode == V16QImode || mode == V8HImode || mode == V4SImode)
+         if (mode_supports_vsx_dform_quad (mode)
+             && quad_address_p (XEXP (dest, 0), mode, false))
+           return "stxv %x1,%0";
+
+         else if (TARGET_P9_VECTOR)
+           return "stxvx %x1,%y0";
+
+         else if (mode == V16QImode || mode == V8HImode || mode == V4SImode)
             return "stxvw4x %x1,%y0";
+
           else
             return "stxvd2x %x1,%y0";
         }
@@ -19536,10 +20241,8 @@ rs6000_output_move_128bit (rtx operands[])
        if (dest_gpr_p)
         return "#";
  
-      else if (TARGET_VSX && dest_vsx_p && zero_constant (src, mode))
-       return "xxlxor %x0,%x0,%x0";
-
-      else if (TARGET_ALTIVEC && dest_vmx_p)
+      else if ((dest_vmx_p && TARGET_ALTIVEC)
+              || (dest_vsx_p && TARGET_VSX))
         return output_vec_const_move (operands);
      }
  
@@ -21747,6 +22450,101 @@ rs6000_emit_vector_cond_expr (rtx dest, rtx op_true, rtx op_false,
    return 1;
  }
  
+/* ISA 3.0 (power9) minmax subcase to emit a XSMAXCDP or XSMINCDP instruction
+   for SF/DF scalars.  Move TRUE_COND to DEST if OP of the operands of the last
+   comparison is nonzero/true, FALSE_COND if it is zero/false.  Return 0 if the
+   hardware has no such operation.  */
+
+static int
+rs6000_emit_p9_fp_minmax (rtx dest, rtx op, rtx true_cond, rtx false_cond)
+{
+  enum rtx_code code = GET_CODE (op);
+  rtx op0 = XEXP (op, 0);
+  rtx op1 = XEXP (op, 1);
+  machine_mode compare_mode = GET_MODE (op0);
+  machine_mode result_mode = GET_MODE (dest);
+  bool max_p = false;
+
+  if (result_mode != compare_mode)
+    return 0;
+
+  if (code == GE || code == GT)
+    max_p = true;
+  else if (code == LE || code == LT)
+    max_p = false;
+  else
+    return 0;
+
+  if (rtx_equal_p (op0, true_cond) && rtx_equal_p (op1, false_cond))
+    ;
+
+  else if (rtx_equal_p (op1, true_cond) && rtx_equal_p (op0, false_cond))
+    max_p = !max_p;
+
+  else
+    return 0;
+
+  rs6000_emit_minmax (dest, max_p ? SMAX : SMIN, op0, op1);
+  return 1;
+}
+
+/* ISA 3.0 (power9) conditional move subcase to emit XSCMP{EQ,GE,GT,NE}DP and
+   XXSEL instructions for SF/DF scalars.  Move TRUE_COND to DEST if OP of the
+   operands of the last comparison is nonzero/true, FALSE_COND if it is
+   zero/false.  Return 0 if the hardware has no such operation.  */
+
+static int
+rs6000_emit_p9_fp_cmove (rtx dest, rtx op, rtx true_cond, rtx false_cond)
+{
+  enum rtx_code code = GET_CODE (op);
+  rtx op0 = XEXP (op, 0);
+  rtx op1 = XEXP (op, 1);
+  machine_mode result_mode = GET_MODE (dest);
+  rtx compare_rtx;
+  rtx cmove_rtx;
+  rtx clobber_rtx;
+
+  if (!can_create_pseudo_p ())
+    return 0;
+
+  switch (code)
+    {
+    case EQ:
+    case GE:
+    case GT:
+      break;
+
+    case NE:
+    case LT:
+    case LE:
+      code = swap_condition (code);
+      std::swap (op0, op1);
+      break;
+
+    default:
+      return 0;
+    }
+
+  /* Generate: [(parallel [(set (dest)
+                                (if_then_else (op (cmp1) (cmp2))
+                                              (true)
+                                              (false)))
+                           (clobber (scratch))])].  */
+
+  compare_rtx = gen_rtx_fmt_ee (code, CCFPmode, op0, op1);
+  cmove_rtx = gen_rtx_SET (dest,
+                          gen_rtx_IF_THEN_ELSE (result_mode,
+                                                compare_rtx,
+                                                true_cond,
+                                                false_cond));
+
+  clobber_rtx = gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (V2DImode));
+  emit_insn (gen_rtx_PARALLEL (VOIDmode,
+                              gen_rtvec (2, cmove_rtx, clobber_rtx)));
+
+  return 1;
+}
+
  /* Emit a conditional move: move TRUE_COND to DEST if OP of the
     operands of the last comparison is nonzero/true, FALSE_COND if it
     is zero/false.  Return 0 if the hardware has no such operation.  */
@@ -21773,6 +22571,18 @@ rs6000_emit_cmove (rtx dest, rtx op, rtx true_cond, rtx false_cond)
    if (GET_MODE (false_cond) != result_mode)
      return 0;
  
+  /* See if we can use the ISA 3.0 (power9) min/max/compare functions.  */
+  if (TARGET_P9_MINMAX
+      && (compare_mode == SFmode || compare_mode == DFmode)
+      && (result_mode == SFmode || result_mode == DFmode))
+    {
+      if (rs6000_emit_p9_fp_minmax (dest, op, true_cond, false_cond))
+       return 1;
+
+      if (rs6000_emit_p9_fp_cmove (dest, op, true_cond, false_cond))
+       return 1;
+    }
+
    /* Don't allow using floating point comparisons for integer results for
       now.  */
    if (FLOAT_MODE_P (compare_mode) && !FLOAT_MODE_P (result_mode))
@@ -25949,25 +26759,37 @@ rs6000_emit_prologue (void)
         if (info->vrsave_mask & ALTIVEC_REG_BIT (i))
           {
             rtx areg, savereg, mem;
-           int offset;
+           HOST_WIDE_INT offset;
  
             offset = (info->altivec_save_offset + frame_off
                       + 16 * (i - info->first_altivec_reg_save));
  
             savereg = gen_rtx_REG (V4SImode, i);
  
-           NOT_INUSE (0);
-           areg = gen_rtx_REG (Pmode, 0);
-           emit_move_insn (areg, GEN_INT (offset));
-
-           /* AltiVec addressing mode is [reg+reg].  */
-           mem = gen_frame_mem (V4SImode,
-                                gen_rtx_PLUS (Pmode, frame_reg_rtx, areg));
+           if (TARGET_P9_DFORM_VECTOR && quad_address_offset_p (offset))
+             {
+               mem = gen_frame_mem (V4SImode,
+                                    gen_rtx_PLUS (Pmode, frame_reg_rtx,
+                                                  GEN_INT (offset)));
+               insn = emit_insn (gen_rtx_SET (mem, savereg));
+               areg = NULL_RTX;
+             }
+           else
+             {
+               NOT_INUSE (0);
+               areg = gen_rtx_REG (Pmode, 0);
+               emit_move_insn (areg, GEN_INT (offset));
  
-           /* Rather than emitting a generic move, force use of the stvx
-              instruction, which we always want.  In particular we don't
-              want xxpermdi/stxvd2x for little endian.  */
-           insn = emit_insn (gen_altivec_stvx_v4si_internal (mem, savereg));
+               /* AltiVec addressing mode is [reg+reg].  */
+               mem = gen_frame_mem (V4SImode,
+                                    gen_rtx_PLUS (Pmode, frame_reg_rtx, areg));
+
+               /* Rather than emitting a generic move, force use of the stvx
+                  instruction, which we always want on ISA 2.07 (power8) systems.
+                  In particular we don't want xxpermdi/stxvd2x for little
+                  endian.  */
+               insn = emit_insn (gen_altivec_stvx_v4si_internal (mem, savereg));
+             }
  
             rs6000_frame_related (insn, frame_reg_rtx, sp_off - frame_off,
                                   areg, GEN_INT (offset));
@@ -26687,23 +27509,35 @@ rs6000_emit_epilogue (int sibcall)
           for (i = info->first_altivec_reg_save; i <= LAST_ALTIVEC_REGNO; ++i)
             if (info->vrsave_mask & ALTIVEC_REG_BIT (i))
               {
-               rtx addr, areg, mem, reg;
+               rtx addr, areg, mem, insn;
+               rtx reg = gen_rtx_REG (V4SImode, i);
+               HOST_WIDE_INT offset
+                 = (info->altivec_save_offset + frame_off
+                    + 16 * (i - info->first_altivec_reg_save));
  
-               areg = gen_rtx_REG (Pmode, 0);
-               emit_move_insn
-                 (areg, GEN_INT (info->altivec_save_offset
-                                 + frame_off
-                                 + 16 * (i - info->first_altivec_reg_save)));
+               if (TARGET_P9_DFORM_VECTOR && quad_address_offset_p (offset))
+                 {
+                   mem = gen_frame_mem (V4SImode,
+                                        gen_rtx_PLUS (Pmode, frame_reg_rtx,
+                                                      GEN_INT (offset)));
+                   insn = gen_rtx_SET (reg, mem);
+                 }
+               else
+                 {
+                   areg = gen_rtx_REG (Pmode, 0);
+                   emit_move_insn (areg, GEN_INT (offset));
  
-               /* AltiVec addressing mode is [reg+reg].  */
-               addr = gen_rtx_PLUS (Pmode, frame_reg_rtx, areg);
-               mem = gen_frame_mem (V4SImode, addr);
-
-               reg = gen_rtx_REG (V4SImode, i);
-               /* Rather than emitting a generic move, force use of the
-                  lvx instruction, which we always want.  In particular
-                  we don't want lxvd2x/xxpermdi for little endian.  */
-               (void) emit_insn (gen_altivec_lvx_v4si_internal (reg, mem));
+                   /* AltiVec addressing mode is [reg+reg].  */
+                   addr = gen_rtx_PLUS (Pmode, frame_reg_rtx, areg);
+                   mem = gen_frame_mem (V4SImode, addr);
+
+                   /* Rather than emitting a generic move, force use of the
+                      lvx instruction, which we always want.  In particular we
+                      don't want lxvd2x/xxpermdi for little endian.  */
+                   insn = gen_altivec_lvx_v4si_internal (reg, mem);
+                 }
+
+               (void) emit_insn (insn);
               }
         }
  
@@ -26890,23 +27724,35 @@ rs6000_emit_epilogue (int sibcall)
           for (i = info->first_altivec_reg_save; i <= LAST_ALTIVEC_REGNO; ++i)
             if (info->vrsave_mask & ALTIVEC_REG_BIT (i))
               {
-               rtx addr, areg, mem, reg;
+               rtx addr, areg, mem, insn;
+               rtx reg = gen_rtx_REG (V4SImode, i);
+               HOST_WIDE_INT offset
+                 = (info->altivec_save_offset + frame_off
+                    + 16 * (i - info->first_altivec_reg_save));
  
-               areg = gen_rtx_REG (Pmode, 0);
-               emit_move_insn
-                 (areg, GEN_INT (info->altivec_save_offset
-                                 + frame_off
-                                 + 16 * (i - info->first_altivec_reg_save)));
+               if (TARGET_P9_DFORM_VECTOR && quad_address_offset_p (offset))
+                 {
+                   mem = gen_frame_mem (V4SImode,
+                                        gen_rtx_PLUS (Pmode, frame_reg_rtx,
+                                                      GEN_INT (offset)));
+                   insn = gen_rtx_SET (reg, mem);
+                 }
+               else
+                 {
+                   areg = gen_rtx_REG (Pmode, 0);
+                   emit_move_insn (areg, GEN_INT (offset));
  
-               /* AltiVec addressing mode is [reg+reg].  */
-               addr = gen_rtx_PLUS (Pmode, frame_reg_rtx, areg);
-               mem = gen_frame_mem (V4SImode, addr);
-
-               reg = gen_rtx_REG (V4SImode, i);
-               /* Rather than emitting a generic move, force use of the
-                  lvx instruction, which we always want.  In particular
-                  we don't want lxvd2x/xxpermdi for little endian.  */
-               (void) emit_insn (gen_altivec_lvx_v4si_internal (reg, mem));
+                   /* AltiVec addressing mode is [reg+reg].  */
+                   addr = gen_rtx_PLUS (Pmode, frame_reg_rtx, areg);
+                   mem = gen_frame_mem (V4SImode, addr);
+
+                   /* Rather than emitting a generic move, force use of the
+                      lvx instruction, which we always want.  In particular we
+                      don't want lxvd2x/xxpermdi for little endian.  */
+                   insn = gen_altivec_lvx_v4si_internal (reg, mem);
+                 }
+
+               (void) emit_insn (insn);
               }
         }
  
@@ -27724,6 +28570,11 @@ rs6000_expand_split_stack_prologue (void)
                                    const0_rtx, const0_rtx));
    call_fusage = NULL_RTX;
    use_reg (&call_fusage, r12);
+  /* Say the call uses r0, even though it doesn't, to stop regrename
+     from twiddling with the insns saving lr, trashing args for cfun.
+     The insns restoring lr are similarly protected by making
+     split_stack_return use r0.  */
+  use_reg (&call_fusage, r0);
    add_function_usage_to (insn, call_fusage);
    emit_insn (gen_frame_load (r0, r1, info->lr_save_offset));
    insn = emit_move_insn (lr, r0);
@@ -33448,17 +34299,25 @@ altivec_expand_vec_perm_le (rtx operands[4])
    if (!REG_P (target))
      tmp = gen_reg_rtx (mode);
  
-  /* Invert the selector with a VNAND if available, else a VNOR.
-     The VNAND is preferred for future fusion opportunities.  */
-  notx = gen_rtx_NOT (V16QImode, sel);
-  iorx = (TARGET_P8_VECTOR
-         ? gen_rtx_IOR (V16QImode, notx, notx)
-         : gen_rtx_AND (V16QImode, notx, notx));
-  emit_insn (gen_rtx_SET (norreg, iorx));
+  if (TARGET_P9_VECTOR)
+    {
+      unspec = gen_rtx_UNSPEC (mode, gen_rtvec (3, op0, op1, sel),
+                              UNSPEC_VPERMR);
+    }
+  else
+    {
+      /* Invert the selector with a VNAND if available, else a VNOR.
+        The VNAND is preferred for future fusion opportunities.  */
+      notx = gen_rtx_NOT (V16QImode, sel);
+      iorx = (TARGET_P8_VECTOR
+             ? gen_rtx_IOR (V16QImode, notx, notx)
+             : gen_rtx_AND (V16QImode, notx, notx));
+      emit_insn (gen_rtx_SET (norreg, iorx));
  
-  /* Permute with operands reversed and adjusted selector.  */
-  unspec = gen_rtx_UNSPEC (mode, gen_rtvec (3, op1, op0, norreg),
-                          UNSPEC_VPERM);
+      /* Permute with operands reversed and adjusted selector.  */
+      unspec = gen_rtx_UNSPEC (mode, gen_rtvec (3, op1, op0, norreg),
+                              UNSPEC_VPERM);
+    }
  
    /* Copy into target, possibly by way of a register.  */
    if (!REG_P (target))
@@ -34056,7 +34915,7 @@ rs6000_libcall_value (machine_mode mode)
  static bool
  rs6000_lra_p (void)
  {
-  return rs6000_lra_flag;
+  return TARGET_LRA;
  }
  
  /* Given FROM and TO register numbers, say whether this elimination is allowed.
@@ -34417,7 +35276,8 @@ static struct rs6000_opt_mask const rs6000_opt_masks[] =
    { "power8-fusion",           OPTION_MASK_P8_FUSION,          false, true  },
    { "power8-fusion-sign",      OPTION_MASK_P8_FUSION_SIGN,     false, true  },
    { "power8-vector",           OPTION_MASK_P8_VECTOR,          false, true  },
-  { "power9-dform",            OPTION_MASK_P9_DFORM,           false, true  },
+  { "power9-dform-scalar",     OPTION_MASK_P9_DFORM_SCALAR,    false, true  },
+  { "power9-dform-vector",     OPTION_MASK_P9_DFORM_VECTOR,    false, true  },
    { "power9-fusion",           OPTION_MASK_P9_FUSION,          false, true  },
    { "power9-minmax",           OPTION_MASK_P9_MINMAX,          false, true  },
    { "power9-vector",           OPTION_MASK_P9_VECTOR,          false, true  },
@@ -34474,6 +35334,7 @@ static struct rs6000_opt_mask const rs6000_builtin_mask_names[] =
    { "popcntd",          RS6000_BTM_POPCNTD,    false, false },
    { "cell",             RS6000_BTM_CELL,       false, false },
    { "power8-vector",    RS6000_BTM_P8_VECTOR,  false, false },
+  { "power9-vector",    RS6000_BTM_P9_VECTOR,  false, false },
    { "crypto",           RS6000_BTM_CRYPTO,     false, false },
    { "htm",              RS6000_BTM_HTM,        false, false },
    { "hard-dfp",                 RS6000_BTM_DFP,        false, false },
@@ -35049,7 +35910,9 @@ rs6000_print_options_internal (FILE *file,
    size_t i;
    size_t start_column = 0;
    size_t cur_column;
-  size_t max_column = 76;
+  size_t max_column = 120;
+  size_t prefix_len = strlen (prefix);
+  size_t comma_len = 0;
    const char *comma = "";
  
    if (indent)
@@ -35067,27 +35930,45 @@ rs6000_print_options_internal (FILE *file,
    cur_column = start_column;
    for (i = 0; i < num_elements; i++)
      {
-      if ((flags & opts[i].mask) != 0)
+      bool invert = opts[i].invert;
+      const char *name = opts[i].name;
+      const char *no_str = "";
+      HOST_WIDE_INT mask = opts[i].mask;
+      size_t len = comma_len + prefix_len + strlen (name);
+
+      if (!invert)
         {
-         const char *no_str = rs6000_opt_masks[i].invert ? "no-" : "";
-         size_t len = (strlen (comma)
-                       + strlen (prefix)
-                       + strlen (no_str)
-                       + strlen (rs6000_opt_masks[i].name));
+         if ((flags & mask) == 0)
+           {
+             no_str = "no-";
+             len += sizeof ("no-") - 1;
+           }
+
+         flags &= ~mask;
+       }
  
-         cur_column += len;
-         if (cur_column > max_column)
+      else
+       {
+         if ((flags & mask) != 0)
             {
-             fprintf (stderr, ", \\\n%*s", (int)start_column, "");
-             cur_column = start_column + len;
-             comma = "";
+             no_str = "no-";
+             len += sizeof ("no-") - 1;
             }
  
-         fprintf (file, "%s%s%s%s", comma, prefix, no_str,
-                  rs6000_opt_masks[i].name);
-         flags &= ~ opts[i].mask;
-         comma = ", ";
+         flags |= mask;
         }
+
+      cur_column += len;
+      if (cur_column > max_column)
+       {
+         fprintf (stderr, ", \\\n%*s", (int)start_column, "");
+         cur_column = start_column + len;
+         comma = "";
+       }
+
+      fprintf (file, "%s%s%s%s", comma, prefix, no_str, name);
+      comma = ", ";
+      comma_len = sizeof (", ") - 1;
      }
  
    fputs ("\n", file);
diff --git a/gcc/config/rs6000/rs6000.h b/gcc/config/rs6000/rs6000.h

index 8c6bd07..827b7c9 100644 (file)
--- a/gcc/config/rs6000/rs6000.h
+++ b/gcc/config/rs6000/rs6000.h
@@ -594,6 +594,15 @@ extern int rs6000_vector_align[];
     in the register.  */
  #define TARGET_NO_SDMODE_STACK (TARGET_LFIWZX && TARGET_STFIWX && TARGET_DFP)
  
+/* ISA 3.0 has new min/max functions that don't need fast math that are being
+   phased in.  Min/max using FSEL or XSMAXDP/XSMINDP do not return the correct
+   answers if the arguments are not in the normal range.  */
+#define TARGET_MINMAX_SF       (TARGET_SF_FPR && TARGET_PPC_GFXOPT     \
+                                && (TARGET_P9_MINMAX || !flag_trapping_math))
+
+#define TARGET_MINMAX_DF       (TARGET_DF_FPR && TARGET_PPC_GFXOPT     \
+                                && (TARGET_P9_MINMAX || !flag_trapping_math))
+
  /* In switching from using target_flags to using rs6000_isa_flags, the options
     machinery creates OPTION_MASK_<xxx> instead of MASK_<xxx>.  For now map
     OPTION_MASK_<xxx> back into MASK_<xxx>.  */
@@ -615,6 +624,7 @@ extern int rs6000_vector_align[];
  #define MASK_MULTIPLE                  OPTION_MASK_MULTIPLE
  #define MASK_NO_UPDATE                 OPTION_MASK_NO_UPDATE
  #define MASK_P8_VECTOR                 OPTION_MASK_P8_VECTOR
+#define MASK_P9_VECTOR                 OPTION_MASK_P9_VECTOR
  #define MASK_POPCNTB                   OPTION_MASK_POPCNTB
  #define MASK_POPCNTD                   OPTION_MASK_POPCNTD
  #define MASK_PPC_GFXOPT                        OPTION_MASK_PPC_GFXOPT
@@ -655,6 +665,11 @@ extern int rs6000_vector_align[];
  #define MASK_PROTOTYPE                 OPTION_MASK_PROTOTYPE
  #endif
  
+#ifdef TARGET_MODULO
+#define RS6000_BTM_MODULO              OPTION_MASK_MODULO
+#endif
+
+
  /* For power systems, we want to enable Altivec and VSX builtins even if the
     user did not use -maltivec or -mvsx to allow the builtins to be used inside
     of #pragma GCC target or the target attribute to change the code level for a
@@ -2638,7 +2653,9 @@ extern int frame_pointer_needed;
  
  #define RS6000_BTC_MISC                0x00000000      /* No special attributes.  */
  #define RS6000_BTC_CONST       0x00000100      /* uses no global state.  */
-#define RS6000_BTC_PURE                0x00000200      /* reads global state/mem.  */
+#define RS6000_BTC_PURE                0x00000200      /* reads global
+                                                  state/mem and does
+                                                  not modify global state.  */
  #define RS6000_BTC_FP          0x00000400      /* depends on rounding mode.  */
  #define RS6000_BTC_ATTR_MASK   0x00000700      /* Mask of the attributes.  */
  
@@ -2660,6 +2677,7 @@ extern int frame_pointer_needed;
  #define RS6000_BTM_ALTIVEC     MASK_ALTIVEC    /* VMX/altivec vectors.  */
  #define RS6000_BTM_VSX         MASK_VSX        /* VSX (vector/scalar).  */
  #define RS6000_BTM_P8_VECTOR   MASK_P8_VECTOR  /* ISA 2.07 vector.  */
+#define RS6000_BTM_P9_VECTOR   MASK_P9_VECTOR  /* ISA 3.00 vector.  */
  #define RS6000_BTM_CRYPTO      MASK_CRYPTO     /* crypto funcs.  */
  #define RS6000_BTM_HTM         MASK_HTM        /* hardware TM funcs.  */
  #define RS6000_BTM_SPE         MASK_STRING     /* E500 */
@@ -2673,10 +2691,12 @@ extern int frame_pointer_needed;
  #define RS6000_BTM_DFP         MASK_DFP        /* Decimal floating point.  */
  #define RS6000_BTM_HARD_FLOAT  MASK_SOFT_FLOAT /* Hardware floating point.  */
  #define RS6000_BTM_LDBL128     MASK_MULTIPLE   /* 128-bit long double.  */
+#define RS6000_BTM_64BIT       MASK_64BIT      /* 64-bit addressing.  */
  
  #define RS6000_BTM_COMMON      (RS6000_BTM_ALTIVEC                     \
                                  | RS6000_BTM_VSX                       \
                                  | RS6000_BTM_P8_VECTOR                 \
+                                | RS6000_BTM_P9_VECTOR                 \
                                  | RS6000_BTM_CRYPTO                    \
                                  | RS6000_BTM_FRE                       \
                                  | RS6000_BTM_FRES                      \
@@ -2691,6 +2711,7 @@ extern int frame_pointer_needed;
  
  /* Define builtin enum index.  */
  
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
@@ -2703,6 +2724,7 @@ extern int frame_pointer_needed;
  #undef RS6000_BUILTIN_S
  #undef RS6000_BUILTIN_X
  
+#define RS6000_BUILTIN_0(ENUM, NAME, MASK, ATTR, ICODE) ENUM,
  #define RS6000_BUILTIN_1(ENUM, NAME, MASK, ATTR, ICODE) ENUM,
  #define RS6000_BUILTIN_2(ENUM, NAME, MASK, ATTR, ICODE) ENUM,
  #define RS6000_BUILTIN_3(ENUM, NAME, MASK, ATTR, ICODE) ENUM,
@@ -2722,6 +2744,7 @@ enum rs6000_builtins
    RS6000_BUILTIN_COUNT
  };
  
+#undef RS6000_BUILTIN_0
  #undef RS6000_BUILTIN_1
  #undef RS6000_BUILTIN_2
  #undef RS6000_BUILTIN_3
diff --git a/gcc/config/rs6000/rs6000.md b/gcc/config/rs6000/rs6000.md

index 849b19a..cc5ef2e 100644 (file)
--- a/gcc/config/rs6000/rs6000.md
+++ b/gcc/config/rs6000/rs6000.md
@@ -489,6 +489,10 @@
  ; Iterator for just SF/DF
  (define_mode_iterator SFDF [SF DF])
  
+; Like SFDF, but a different name to match conditional move where the
+; comparison operands may be a different mode than the input operands.
+(define_mode_iterator SFDF2 [SF DF])
+
  ; Iterator for 128-bit floating point that uses the IBM double-double format
  (define_mode_iterator IBM128 [(IF "FLOAT128_IBM_P (IFmode)")
                               (TF "FLOAT128_IBM_P (TFmode)")])
@@ -577,7 +581,9 @@
                       (V16QI "b")
                       (V8HI  "h")
                       (V4SI  "w")
-                     (V2DI  "d")])
+                     (V2DI  "d")
+                     (V1TI  "q")
+                     (TI    "q")])
  
  ;; How many bits in this mode?
  (define_mode_attr bits [(QI "8") (HI "16") (SI "32") (DI "64")])
@@ -698,6 +704,15 @@
  (define_mode_iterator RELOAD [V16QI V8HI V4SI V2DI V4SF V2DF V1TI
                               SF SD SI DF DD DI TI PTI KF IF TF])
  
+;; Iterate over smin, smax
+(define_code_iterator fp_minmax        [smin smax])
+
+(define_code_attr     minmax   [(smin "min")
+                                (smax "max")])
+
+(define_code_attr     SMINMAX  [(smin "SMIN")
+                                (smax "SMAX")])
+
  \f
  ;; Start with fixed-point load and store insns.  Here we put only the more
  ;; complex forms.  Basic data transfer is done later.
@@ -4599,74 +4614,45 @@
  ;; On VSX, we only check for TARGET_VSX instead of checking for a vsx/p8 vector
  ;; to allow either DF/SF to use only traditional registers.
  
-(define_expand "smax<mode>3"
+(define_expand "s<minmax><mode>3"
    [(set (match_operand:SFDF 0 "gpc_reg_operand" "")
-       (if_then_else:SFDF (ge (match_operand:SFDF 1 "gpc_reg_operand" "")
-                              (match_operand:SFDF 2 "gpc_reg_operand" ""))
-                          (match_dup 1)
-                          (match_dup 2)))]
-  "TARGET_<MODE>_FPR && TARGET_PPC_GFXOPT && !flag_trapping_math"
+       (fp_minmax:SFDF (match_operand:SFDF 1 "gpc_reg_operand" "")
+                       (match_operand:SFDF 2 "gpc_reg_operand" "")))]
+  "TARGET_MINMAX_<MODE>"
  {
-  rs6000_emit_minmax (operands[0], SMAX, operands[1], operands[2]);
+  rs6000_emit_minmax (operands[0], <SMINMAX>, operands[1], operands[2]);
    DONE;
  })
  
-(define_insn "*smax<mode>3_vsx"
-  [(set (match_operand:SFDF 0 "gpc_reg_operand" "=<Ff>,<Fv>")
-       (smax:SFDF (match_operand:SFDF 1 "gpc_reg_operand" "%<Ff>,<Fv>")
-                  (match_operand:SFDF 2 "gpc_reg_operand" "<Ff>,<Fv>")))]
-  "TARGET_<MODE>_FPR && TARGET_VSX"
-  "xsmaxdp %x0,%x1,%x2"
-  [(set_attr "type" "fp")])
-
-(define_expand "smin<mode>3"
-  [(set (match_operand:SFDF 0 "gpc_reg_operand" "")
-       (if_then_else:SFDF (ge (match_operand:SFDF 1 "gpc_reg_operand" "")
-                              (match_operand:SFDF 2 "gpc_reg_operand" ""))
-                          (match_dup 2)
-                          (match_dup 1)))]
-  "TARGET_<MODE>_FPR && TARGET_PPC_GFXOPT && !flag_trapping_math"
+(define_insn "*s<minmax><mode>3_vsx"
+  [(set (match_operand:SFDF 0 "vsx_register_operand" "=<Fv>")
+       (fp_minmax:SFDF (match_operand:SFDF 1 "vsx_register_operand" "<Fv>")
+                       (match_operand:SFDF 2 "vsx_register_operand" "<Fv>")))]
+  "TARGET_VSX && TARGET_<MODE>_FPR"
  {
-  rs6000_emit_minmax (operands[0], SMIN, operands[1], operands[2]);
-  DONE;
-})
-
-(define_insn "*smin<mode>3_vsx"
-  [(set (match_operand:SFDF 0 "gpc_reg_operand" "=<Ff>,<Fv>")
-       (smin:SFDF (match_operand:SFDF 1 "gpc_reg_operand" "%<Ff>,<Fv>")
-                  (match_operand:SFDF 2 "gpc_reg_operand" "<Ff>,<Fv>")))]
-  "TARGET_<MODE>_FPR && TARGET_VSX"
-  "xsmindp %x0,%x1,%x2"
+  return (TARGET_P9_MINMAX
+         ? "xs<minmax>cdp %x0,%x1,%x2"
+         : "xs<minmax>dp %x0,%x1,%x2");
+}
    [(set_attr "type" "fp")])
  
-(define_split
+;; The conditional move instructions allow us to perform max and min operations
+;; even when we don't have the appropriate max/min instruction using the FSEL
+;; instruction.
+
+(define_insn_and_split "*s<minmax><mode>3_fpr"
    [(set (match_operand:SFDF 0 "gpc_reg_operand" "")
-       (match_operator:SFDF 3 "min_max_operator"
-        [(match_operand:SFDF 1 "gpc_reg_operand" "")
-         (match_operand:SFDF 2 "gpc_reg_operand" "")]))]
-  "TARGET_<MODE>_FPR && TARGET_PPC_GFXOPT && !flag_trapping_math
-   && !TARGET_VSX"
+       (fp_minmax:SFDF (match_operand:SFDF 1 "gpc_reg_operand" "")
+                       (match_operand:SFDF 2 "gpc_reg_operand" "")))]
+  "!TARGET_VSX && TARGET_MINMAX_<MODE>"
+  "#"
+  "&& 1"
    [(const_int 0)]
  {
-  rs6000_emit_minmax (operands[0], GET_CODE (operands[3]), operands[1],
-                     operands[2]);
+  rs6000_emit_minmax (operands[0], <SMINMAX>, operands[1], operands[2]);
    DONE;
  })
  
-(define_split
-  [(set (match_operand:SF 0 "gpc_reg_operand" "")
-       (match_operator:SF 3 "min_max_operator"
-        [(match_operand:SF 1 "gpc_reg_operand" "")
-         (match_operand:SF 2 "gpc_reg_operand" "")]))]
-  "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS 
-   && TARGET_SINGLE_FLOAT && !flag_trapping_math"
-  [(const_int 0)]
-  "
-{ rs6000_emit_minmax (operands[0], GET_CODE (operands[3]),
-                     operands[1], operands[2]);
-  DONE;
-}")
-
  (define_expand "mov<mode>cc"
     [(set (match_operand:GPR 0 "gpc_reg_operand" "")
          (if_then_else:GPR (match_operand 1 "comparison_operator" "")
@@ -4749,12 +4735,13 @@
    [(set_attr "type" "isel")
     (set_attr "length" "4")])
  
-(define_expand "movsfcc"
-   [(set (match_operand:SF 0 "gpc_reg_operand" "")
-        (if_then_else:SF (match_operand 1 "comparison_operator" "")
-                         (match_operand:SF 2 "gpc_reg_operand" "")
-                         (match_operand:SF 3 "gpc_reg_operand" "")))]
-  "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
+;; Floating point conditional move
+(define_expand "mov<mode>cc"
+   [(set (match_operand:SFDF 0 "gpc_reg_operand" "")
+        (if_then_else:SFDF (match_operand 1 "comparison_operator" "")
+                           (match_operand:SFDF 2 "gpc_reg_operand" "")
+                           (match_operand:SFDF 3 "gpc_reg_operand" "")))]
+  "TARGET_<MODE>_FPR && TARGET_PPC_GFXOPT"
    "
  {
    if (rs6000_emit_cmove (operands[0], operands[1], operands[2], operands[3]))
@@ -4763,76 +4750,70 @@
      FAIL;
  }")
  
-(define_insn "*fselsfsf4"
-  [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
-       (if_then_else:SF (ge (match_operand:SF 1 "gpc_reg_operand" "f")
-                            (match_operand:SF 4 "zero_fp_constant" "F"))
-                        (match_operand:SF 2 "gpc_reg_operand" "f")
-                        (match_operand:SF 3 "gpc_reg_operand" "f")))]
-  "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT"
+(define_insn "*fsel<SFDF:mode><SFDF2:mode>4"
+  [(set (match_operand:SFDF 0 "fpr_reg_operand" "=&<SFDF:rreg2>")
+       (if_then_else:SFDF
+        (ge (match_operand:SFDF2 1 "fpr_reg_operand" "<SFDF2:rreg2>")
+            (match_operand:SFDF2 4 "zero_fp_constant" "F"))
+        (match_operand:SFDF 2 "fpr_reg_operand" "<SFDF:rreg2>")
+        (match_operand:SFDF 3 "fpr_reg_operand" "<SFDF:rreg2>")))]
+  "TARGET_<MODE>_FPR && TARGET_PPC_GFXOPT"
    "fsel %0,%1,%2,%3"
    [(set_attr "type" "fp")])
  
-(define_insn "*fseldfsf4"
-  [(set (match_operand:SF 0 "gpc_reg_operand" "=f")
-       (if_then_else:SF (ge (match_operand:DF 1 "gpc_reg_operand" "d")
-                            (match_operand:DF 4 "zero_fp_constant" "F"))
-                        (match_operand:SF 2 "gpc_reg_operand" "f")
-                        (match_operand:SF 3 "gpc_reg_operand" "f")))]
-  "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && TARGET_SINGLE_FLOAT"
-  "fsel %0,%1,%2,%3"
-  [(set_attr "type" "fp")])
-
-;; The conditional move instructions allow us to perform max and min
-;; operations even when
-
-(define_split
-  [(set (match_operand:DF 0 "gpc_reg_operand" "")
-       (match_operator:DF 3 "min_max_operator"
-        [(match_operand:DF 1 "gpc_reg_operand" "")
-         (match_operand:DF 2 "gpc_reg_operand" "")]))]
-  "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT 
-   && !flag_trapping_math"
-  [(const_int 0)]
-  "
-{ rs6000_emit_minmax (operands[0], GET_CODE (operands[3]),
-                     operands[1], operands[2]);
-  DONE;
-}")
-
-(define_expand "movdfcc"
-   [(set (match_operand:DF 0 "gpc_reg_operand" "")
-        (if_then_else:DF (match_operand 1 "comparison_operator" "")
-                         (match_operand:DF 2 "gpc_reg_operand" "")
-                         (match_operand:DF 3 "gpc_reg_operand" "")))]
-  "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
-  "
+(define_insn_and_split "*mov<SFDF:mode><SFDF2:mode>cc_p9"
+  [(set (match_operand:SFDF 0 "vsx_register_operand" "=&<SFDF:Fv>,<SFDF:Fv>")
+       (if_then_else:SFDF
+        (match_operator:CCFP 1 "fpmask_comparison_operator"
+               [(match_operand:SFDF2 2 "vsx_register_operand" "<SFDF2:Fv>,<SFDF2:Fv>")
+                (match_operand:SFDF2 3 "vsx_register_operand" "<SFDF2:Fv>,<SFDF2:Fv>")])
+        (match_operand:SFDF 4 "vsx_register_operand" "<SFDF:Fv>,<SFDF:Fv>")
+        (match_operand:SFDF 5 "vsx_register_operand" "<SFDF:Fv>,<SFDF:Fv>")))
+   (clobber (match_scratch:V2DI 6 "=0,&wa"))]
+  "TARGET_P9_MINMAX"
+  "#"
+  ""
+  [(set (match_dup 6)
+       (if_then_else:V2DI (match_dup 1)
+                          (match_dup 7)
+                          (match_dup 8)))
+   (set (match_dup 0)
+       (if_then_else:SFDF (ne (match_dup 6)
+                              (match_dup 8))
+                          (match_dup 4)
+                          (match_dup 5)))]
  {
-  if (rs6000_emit_cmove (operands[0], operands[1], operands[2], operands[3]))
-    DONE;
-  else
-    FAIL;
-}")
+  if (GET_CODE (operands[6]) == SCRATCH)
+    operands[6] = gen_reg_rtx (V2DImode);
  
-(define_insn "*fseldfdf4"
-  [(set (match_operand:DF 0 "gpc_reg_operand" "=d")
-       (if_then_else:DF (ge (match_operand:DF 1 "gpc_reg_operand" "d")
-                            (match_operand:DF 4 "zero_fp_constant" "F"))
-                        (match_operand:DF 2 "gpc_reg_operand" "d")
-                        (match_operand:DF 3 "gpc_reg_operand" "d")))]
-  "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT"
-  "fsel %0,%1,%2,%3"
-  [(set_attr "type" "fp")])
+  operands[7] = CONSTM1_RTX (V2DImode);
+  operands[8] = CONST0_RTX (V2DImode);
+}
+ [(set_attr "length" "8")
+  (set_attr "type" "vecperm")])
+
+(define_insn "*fpmask<mode>"
+  [(set (match_operand:V2DI 0 "vsx_register_operand" "=wa")
+       (if_then_else:V2DI
+        (match_operator:CCFP 1 "fpmask_comparison_operator"
+               [(match_operand:SFDF 2 "vsx_register_operand" "<Fv>")
+                (match_operand:SFDF 3 "vsx_register_operand" "<Fv>")])
+        (match_operand:V2DI 4 "all_ones_constant" "")
+        (match_operand:V2DI 5 "zero_constant" "")))]
+  "TARGET_P9_MINMAX"
+  "xscmp%V1dp %x0,%x2,%x3"
+  [(set_attr "type" "fpcompare")])
+
+(define_insn "*xxsel<mode>"
+  [(set (match_operand:SFDF 0 "vsx_register_operand" "=<Fv>")
+       (if_then_else:SFDF (ne (match_operand:V2DI 1 "vsx_register_operand" "wa")
+                              (match_operand:V2DI 2 "zero_constant" ""))
+                          (match_operand:SFDF 3 "vsx_register_operand" "<Fv>")
+                          (match_operand:SFDF 4 "vsx_register_operand" "<Fv>")))]
+  "TARGET_P9_MINMAX"
+  "xxsel %x0,%x1,%x3,%x4"
+  [(set_attr "type" "vecperm")])
  
-(define_insn "*fselsfdf4"
-  [(set (match_operand:DF 0 "gpc_reg_operand" "=d")
-       (if_then_else:DF (ge (match_operand:SF 1 "gpc_reg_operand" "f")
-                            (match_operand:SF 4 "zero_fp_constant" "F"))
-                        (match_operand:DF 2 "gpc_reg_operand" "d")
-                        (match_operand:DF 3 "gpc_reg_operand" "d")))]
-  "TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT && TARGET_SINGLE_FLOAT"
-  "fsel %0,%1,%2,%3"
-  [(set_attr "type" "fp")])
  \f
  ;; Conversions to and from floating-point.
  
@@ -12563,8 +12544,10 @@
     (set_attr "indexed" "no")])
  
  ;; A return instruction which the middle-end doesn't see.
+;; Use r0 to stop regrename twiddling with lr restore insns emitted
+;; after the call to __morestack.
  (define_insn "split_stack_return"
-  [(unspec_volatile [(const_int 0)] UNSPECV_SPLIT_STACK_RETURN)]
+  [(unspec_volatile [(use (reg:SI 0))] UNSPECV_SPLIT_STACK_RETURN)]
    ""
    "blr"
    [(set_attr "type" "jmpreg")])
diff --git a/gcc/config/rs6000/rs6000.opt b/gcc/config/rs6000/rs6000.opt

index 9a155ce..92c5396 100644 (file)
--- a/gcc/config/rs6000/rs6000.opt
+++ b/gcc/config/rs6000/rs6000.opt
@@ -470,8 +470,8 @@ Target RejectNegative Joined UInteger Var(rs6000_long_double_type_size) Save
  -mlong-double-<n>      Specify size of long double (64 or 128 bits).
  
  mlra
-Target Report Var(rs6000_lra_flag) Init(0) Save
-Use LRA instead of reload.
+Target Report Mask(LRA) Var(rs6000_isa_flags)
+Enable Local Register Allocation.
  
  msched-costly-dep=
  Target RejectNegative Joined Var(rs6000_sched_costly_dep_str)
@@ -609,9 +609,17 @@ mpower9-vector
  Target Report Mask(P9_VECTOR) Var(rs6000_isa_flags)
  Use/do not use vector and scalar instructions added in ISA 3.0.
  
+mpower9-dform-scalar
+Target Undocumented Mask(P9_DFORM_SCALAR) Var(rs6000_isa_flags)
+Use/do not use scalar register+offset memory instructions added in ISA 3.0.
+
+mpower9-dform-vector
+Target Undocumented Mask(P9_DFORM_VECTOR) Var(rs6000_isa_flags)
+Use/do not use vector register+offset memory instructions added in ISA 3.0.
+
  mpower9-dform
-Target Undocumented Mask(P9_DFORM) Var(rs6000_isa_flags)
-Use/do not use vector and scalar instructions added in ISA 3.0.
+Target Report Var(TARGET_P9_DFORM_BOTH) Init(-1) Save
+Use/do not use register+offset memory instructions added in ISA 3.0.
  
  mpower9-minmax
  Target Undocumented Mask(P9_MINMAX) Var(rs6000_isa_flags)
diff --git a/gcc/config/rs6000/sysv4.h b/gcc/config/rs6000/sysv4.h

index cbf9097..ba35fd2 100644 (file)
--- a/gcc/config/rs6000/sysv4.h
+++ b/gcc/config/rs6000/sysv4.h
@@ -744,21 +744,32 @@ ENDIAN_SELECT(" -mbig", " -mlittle", DEFAULT_ASM_ENDIAN)
  %{!mnewlib: %{pthread:-lpthread} %{shared:-lc} \
  %{!shared: %{profile:-lc_p} %{!profile:-lc}}}"
  
+#if ENABLE_OFFLOADING == 1
+#define CRTOFFLOADBEGIN "%{fopenacc|fopenmp:crtoffloadbegin%O%s}"
+#define CRTOFFLOADEND "%{fopenacc|fopenmp:crtoffloadend%O%s}"
+#else
+#define CRTOFFLOADBEGIN ""
+#define CRTOFFLOADEND ""
+#endif
+
  #ifdef HAVE_LD_PIE
  #define        STARTFILE_LINUX_SPEC "\
  %{!shared: %{pg|p|profile:gcrt1.o%s;pie:Scrt1.o%s;:crt1.o%s}} \
  %{mnewlib:ecrti.o%s;:crti.o%s} \
-%{static:crtbeginT.o%s;shared|pie:crtbeginS.o%s;:crtbegin.o%s}"
+%{static:crtbeginT.o%s;shared|pie:crtbeginS.o%s;:crtbegin.o%s} \
+" CRTOFFLOADBEGIN
  #else
  #define        STARTFILE_LINUX_SPEC "\
  %{!shared: %{pg|p|profile:gcrt1.o%s;:crt1.o%s}} \
  %{mnewlib:ecrti.o%s;:crti.o%s} \
-%{static:crtbeginT.o%s;shared|pie:crtbeginS.o%s;:crtbegin.o%s}"
+%{static:crtbeginT.o%s;shared|pie:crtbeginS.o%s;:crtbegin.o%s} \
+" CRTOFFLOADBEGIN
  #endif
  
  #define        ENDFILE_LINUX_SPEC "\
  %{shared|pie:crtendS.o%s;:crtend.o%s} \
-%{mnewlib:ecrtn.o%s;:crtn.o%s}"
+%{mnewlib:ecrtn.o%s;:crtn.o%s} \
+" CRTOFFLOADEND
  
  #define LINK_START_LINUX_SPEC ""
  
diff --git a/gcc/config/rs6000/vector.md b/gcc/config/rs6000/vector.md

index 02fb3e3..3983c3b 100644 (file)
--- a/gcc/config/rs6000/vector.md
+++ b/gcc/config/rs6000/vector.md
@@ -26,6 +26,13 @@
  ;; Vector int modes
  (define_mode_iterator VEC_I [V16QI V8HI V4SI V2DI])
  
+;; Vector int modes for parity
+(define_mode_iterator VEC_IP [V8HI
+                             V4SI
+                             V2DI
+                             V1TI
+                             (TI "TARGET_VSX_TIMODE")])
+
  ;; Vector float modes
  (define_mode_iterator VEC_F [V4SF V2DF])
  
@@ -738,12 +745,24 @@
         (clz:VEC_I (match_operand:VEC_I 1 "register_operand" "")))]
    "TARGET_P8_VECTOR")
  
+;; Vector count trailing zeros
+(define_expand "ctz<mode>2"
+  [(set (match_operand:VEC_I 0 "register_operand" "")
+       (ctz:VEC_I (match_operand:VEC_I 1 "register_operand" "")))]
+  "TARGET_P9_VECTOR")
+
  ;; Vector population count
  (define_expand "popcount<mode>2"
    [(set (match_operand:VEC_I 0 "register_operand" "")
          (popcount:VEC_I (match_operand:VEC_I 1 "register_operand" "")))]
    "TARGET_P8_VECTOR")
  
+;; Vector parity
+(define_expand "parity<mode>2"
+  [(set (match_operand:VEC_IP 0 "register_operand" "")
+       (parity:VEC_IP (match_operand:VEC_IP 1 "register_operand" "")))]
+  "TARGET_P9_VECTOR")
+
  \f
  ;; Same size conversions
  (define_expand "float<VEC_int><mode>2"
diff --git a/gcc/config/rs6000/vsx.md b/gcc/config/rs6000/vsx.md

index 45af233..58e1cb5 100644 (file)
--- a/gcc/config/rs6000/vsx.md
+++ b/gcc/config/rs6000/vsx.md
@@ -55,8 +55,7 @@
                              (KF        "FLOAT128_VECTOR_P (KFmode)")
                              (TF        "FLOAT128_VECTOR_P (TFmode)")])
  
-;; Iterator for memory move.  Handle TImode specially to allow
-;; it to use gprs as well as vsx registers.
+;; Iterator for memory moves.
  (define_mode_iterator VSX_M [V16QI
                              V8HI
                              V4SI
@@ -65,18 +64,8 @@
                              V2DF
                              V1TI
                              (KF        "FLOAT128_VECTOR_P (KFmode)")
-                            (TF        "FLOAT128_VECTOR_P (TFmode)")])
-
-(define_mode_iterator VSX_M2 [V16QI
-                             V8HI
-                             V4SI
-                             V2DI
-                             V4SF
-                             V2DF
-                             V1TI
-                             (KF       "FLOAT128_VECTOR_P (KFmode)")
-                             (TF       "FLOAT128_VECTOR_P (TFmode)")
-                             (TI       "TARGET_VSX_TIMODE")])
+                            (TF        "FLOAT128_VECTOR_P (TFmode)")
+                            (TI        "TARGET_VSX_TIMODE")])
  
  ;; Map into the appropriate load/store name based on the type
  (define_mode_attr VSm  [(V16QI "vw4")
@@ -270,6 +259,10 @@
  (define_mode_attr VS_64reg [(V2DF      "ws")
                             (V2DI       "wi")])
  
+;; Iterators for loading constants with xxspltib
+(define_mode_iterator VSINT_84  [V4SI V2DI])
+(define_mode_iterator VSINT_842 [V8HI V4SI V2DI])
+
  ;; Constants for creating unspecs
  (define_c_enum "unspec"
    [UNSPEC_VSX_CONCAT
@@ -299,26 +292,9 @@
     UNSPEC_VSX_XVCVUXDDP
     UNSPEC_VSX_XVCVDPSXDS
     UNSPEC_VSX_XVCVDPUXDS
+   UNSPEC_VSX_SIGN_EXTEND
    ])
  
-;; VSX (P9) moves
-
-(define_insn "*p9_vecload_<mode>"
-  [(set (match_operand:VSX_M2 0 "vsx_register_operand" "=<VSa>")
-        (match_operand:VSX_M2 1 "memory_operand" "Z"))]
-  "TARGET_P9_VECTOR"
-  "lxvx %x0,%y1"
-  [(set_attr "type" "vecload")
-   (set_attr "length" "4")])
-
-(define_insn "*p9_vecstore_<mode>"
-  [(set (match_operand:VSX_M2 0 "memory_operand" "=Z")
-        (match_operand:VSX_M2 1 "vsx_register_operand" "<VSa>"))]
-  "TARGET_P9_VECTOR"
-  "stxvx %x1,%y0"
-  [(set_attr "type" "vecstore")
-   (set_attr "length" "4")])
-
  ;; VSX moves
  
  ;; The patterns for LE permuted loads and stores come before the general
@@ -787,92 +763,141 @@
                            (const_int 64)))]
    "")
  
-(define_insn "*vsx_mov<mode>"
-  [(set (match_operand:VSX_M 0 "nonimmediate_operand" "=Z,<VSr>,<VSr>,?Z,?<VSa>,?<VSa>,r,we,wQ,?&r,??Y,??r,??r,<VSr>,?<VSa>,*r,v,wZ,v")
-       (match_operand:VSX_M 1 "input_operand" "<VSr>,Z,<VSr>,<VSa>,Z,<VSa>,we,b,r,wQ,r,Y,r,j,j,j,W,v,wZ"))]
-  "VECTOR_MEM_VSX_P (<MODE>mode)
-   && (register_operand (operands[0], <MODE>mode) 
-       || register_operand (operands[1], <MODE>mode))"
+;; Vector constants that can be generated with XXSPLTIB that was added in ISA
+;; 3.0.  Both (const_vector [..]) and (vec_duplicate ...) forms are recognized.
+(define_insn "xxspltib_v16qi"
+  [(set (match_operand:V16QI 0 "vsx_register_operand" "=wa")
+       (vec_duplicate:V16QI (match_operand:SI 1 "s8bit_cint_operand" "n")))]
+  "TARGET_P9_VECTOR"
  {
-  return rs6000_output_move_128bit (operands);
+  operands[2] = GEN_INT (INTVAL (operands[1]) & 0xff);
+  return "xxspltib %x0,%2";
  }
-  [(set_attr "type" "vecstore,vecload,vecsimple,vecstore,vecload,vecsimple,mffgpr,mftgpr,load,store,store,load, *,vecsimple,vecsimple,*, *,vecstore,vecload")
-   (set_attr "length" "4,4,4,4,4,4,8,4,12,12,12,12,16,4,4,*,16,4,4")])
-
-;; Unlike other VSX moves, allow the GPRs even for reloading, since a normal
-;; use of TImode is for unions.  However for plain data movement, slightly
-;; favor the vector loads
-(define_insn "*vsx_movti_64bit"
-  [(set (match_operand:TI 0 "nonimmediate_operand" "=Z,wa,wa,wa,r,we,v,v,wZ,wQ,&r,Y,r,r,?r")
-       (match_operand:TI 1 "input_operand" "wa,Z,wa,O,we,b,W,wZ,v,r,wQ,r,Y,r,n"))]
-  "TARGET_POWERPC64 && VECTOR_MEM_VSX_P (TImode)
-   && (register_operand (operands[0], TImode) 
-       || register_operand (operands[1], TImode))"
+  [(set_attr "type" "vecperm")])
+
+(define_insn "xxspltib_<mode>_nosplit"
+  [(set (match_operand:VSINT_842 0 "vsx_register_operand" "=wa,wa")
+       (match_operand:VSINT_842 1 "xxspltib_constant_nosplit" "jwM,wE"))]
+  "TARGET_P9_VECTOR"
  {
-  return rs6000_output_move_128bit (operands);
+  rtx op1 = operands[1];
+  int value = 256;
+  int num_insns = -1;
+
+  if (!xxspltib_constant_p (op1, <MODE>mode, &num_insns, &value)
+      || num_insns != 1)
+    gcc_unreachable ();
+
+  operands[2] = GEN_INT (value & 0xff);
+  return "xxspltib %x0,%2";
  }
-  [(set_attr "type" "vecstore,vecload,vecsimple,vecsimple,mffgpr,mftgpr,vecsimple,vecstore,vecload,store,load,store,load,*,*")
-   (set_attr "length" "4,4,4,4,8,4,16,4,4,8,8,8,8,8,8")])
-
-(define_insn "*vsx_movti_32bit"
-  [(set (match_operand:TI 0 "nonimmediate_operand" "=Z,wa,wa,wa,v, v,wZ,Q,Y,????r,????r,????r,r")
-       (match_operand:TI 1 "input_operand"        "wa, Z,wa, O,W,wZ, v,r,r,    Q,    Y,    r,n"))]
-  "! TARGET_POWERPC64 && VECTOR_MEM_VSX_P (TImode)
-   && (register_operand (operands[0], TImode)
-       || register_operand (operands[1], TImode))"
+  [(set_attr "type" "vecperm")])
+
+(define_insn_and_split "*xxspltib_<mode>_split"
+  [(set (match_operand:VSINT_842 0 "altivec_register_operand" "=v")
+       (match_operand:VSINT_842 1 "xxspltib_constant_split" "wS"))]
+  "TARGET_P9_VECTOR"
+  "#"
+  "&& 1"
+  [(const_int 0)]
  {
-  switch (which_alternative)
-    {
-    case 0:
-      return "stxvd2x %x1,%y0";
+  int value = 256;
+  int num_insns = -1;
+  rtx op0 = operands[0];
+  rtx op1 = operands[1];
+  rtx tmp = ((can_create_pseudo_p ())
+            ? gen_reg_rtx (V16QImode)
+            : gen_lowpart (V16QImode, op0));
+
+  if (!xxspltib_constant_p (op1, <MODE>mode, &num_insns, &value)
+      || num_insns != 2)
+    gcc_unreachable ();
  
-    case 1:
-      return "lxvd2x %x0,%y1";
+  emit_insn (gen_xxspltib_v16qi (tmp, GEN_INT (value)));
  
-    case 2:
-      return "xxlor %x0,%x1,%x1";
+  if (<MODE>mode == V2DImode)
+    emit_insn (gen_vsx_sign_extend_qi_v2di (op0, tmp));
  
-    case 3:
-      return "xxlxor %x0,%x0,%x0";
+  else if (<MODE>mode == V4SImode)
+    emit_insn (gen_vsx_sign_extend_qi_v4si (op0, tmp));
  
-    case 4:
-      return output_vec_const_move (operands);
+  else if (<MODE>mode == V8HImode)
+    emit_insn (gen_altivec_vupkhsb  (op0, tmp));
  
-    case 5:
-      return "stvx %1,%y0";
+  else
+    gcc_unreachable ();
+
+  DONE;
+}
+  [(set_attr "type" "vecperm")
+   (set_attr "length" "8")])
  
-    case 6:
-      return "lvx %0,%y1";
  
-    case 7:
-      if (TARGET_STRING)
-        return \"stswi %1,%P0,16\";
+;; Prefer using vector registers over GPRs.  Prefer using ISA 3.0's XXSPLTISB
+;; or Altivec VSPLITW 0/-1 over XXLXOR/XXLORC to set a register to all 0's or
+;; all 1's, since the machine does not have to wait for the previous
+;; instruction using the register being set (such as a store waiting on a slow
+;; instruction). But generate XXLXOR/XXLORC if it will avoid a register move.
  
-    case 8:
-      return \"#\";
+;;              VSX store  VSX load   VSX move  VSX->GPR   GPR->VSX    LQ (GPR)
+;;              STQ (GPR)  GPR load   GPR store GPR move   XXSPLTIB    VSPLTISW
+;;              VSX 0/-1   GPR 0/-1   VMX const GPR const  LVX (VMX)   STVX (VMX)
+(define_insn "*vsx_mov<mode>_64bit"
+  [(set (match_operand:VSX_M 0 "nonimmediate_operand"
+               "=ZwO,      <VSa>,     <VSa>,     r,         we,        ?wQ,
+                ?&r,       ??r,       ??Y,       ??r,       wo,        v,
+                ?<VSa>,    *r,        v,         ??r,       wZ,        v")
  
-    case 9:
-      /* If the address is not used in the output, we can use lsi.  Otherwise,
-        fall through to generating four loads.  */
-      if (TARGET_STRING
-          && ! reg_overlap_mentioned_p (operands[0], operands[1]))
-       return \"lswi %0,%P1,16\";
-      /* ... fall through ...  */
+       (match_operand:VSX_M 1 "input_operand" 
+               "<VSa>,     ZwO,       <VSa>,     we,        r,         r,
+                wQ,        Y,         r,         r,         wE,        jwM,
+                ?jwM,      jwM,       W,         W,         v,         wZ"))]
  
-    case 10:
-    case 11:
-    case 12:
-      return \"#\";
-    default:
-      gcc_unreachable ();
-    }
+  "TARGET_POWERPC64 && VECTOR_MEM_VSX_P (<MODE>mode)
+   && (register_operand (operands[0], <MODE>mode) 
+       || register_operand (operands[1], <MODE>mode))"
+{
+  return rs6000_output_move_128bit (operands);
+}
+  [(set_attr "type"
+               "vecstore,  vecload,   vecsimple, mffgpr,    mftgpr,    load,
+                store,     load,      store,     *,         vecsimple, vecsimple,
+                vecsimple, *,         *,         *,         vecstore,  vecload")
+
+   (set_attr "length"
+               "4,         4,         4,         8,         4,         8,
+                8,         8,         8,         8,         4,         4,
+                4,         8,         20,        20,        4,         4")])
+
+;;              VSX store  VSX load   VSX move   GPR load   GPR store  GPR move
+;;              XXSPLTIB   VSPLTISW   VSX 0/-1   GPR 0/-1   VMX const  GPR const
+;;              LVX (VMX)  STVX (VMX)
+(define_insn "*vsx_mov<mode>_32bit"
+  [(set (match_operand:VSX_M 0 "nonimmediate_operand"
+               "=ZwO,      <VSa>,     <VSa>,     ??r,       ??Y,       ??r,
+                wo,        v,         ?<VSa>,    *r,        v,         ??r,
+                wZ,        v")
+
+       (match_operand:VSX_M 1 "input_operand" 
+               "<VSa>,     ZwO,       <VSa>,     Y,         r,         r,
+                wE,        jwM,       ?jwM,      jwM,       W,         W,
+                v,         wZ"))]
+
+  "!TARGET_POWERPC64 && VECTOR_MEM_VSX_P (<MODE>mode)
+   && (register_operand (operands[0], <MODE>mode) 
+       || register_operand (operands[1], <MODE>mode))"
+{
+  return rs6000_output_move_128bit (operands);
  }
-  [(set_attr "type" "vecstore,vecload,vecsimple,vecsimple,vecsimple,vecstore,vecload,store,store,load,load, *, *")
-   (set_attr "update" "     *,      *,        *,       *,         *,       *,      *,  yes,  yes, yes, yes, *, *")
-   (set_attr "length" "     4,      4,        4,       4,         8,       4,      4,   16,   16,  16,  16,16,16")
-   (set (attr "cell_micro") (if_then_else (match_test "TARGET_STRING")
-                                         (const_string "always")
-                                         (const_string "conditional")))])
+  [(set_attr "type"
+               "vecstore,  vecload,   vecsimple, load,      store,    *,
+                vecsimple, vecsimple, vecsimple, *,         *,        *,
+                vecstore,  vecload")
+
+   (set_attr "length"
+               "4,         4,         4,         16,        16,        16,
+                4,         4,         4,         16,        20,        32,
+                4,         4")])
  
  ;; Explicit  load/store expanders for the builtin functions
  (define_expand "vsx_load_<mode>"
@@ -887,6 +912,140 @@
    "VECTOR_MEM_VSX_P (<MODE>mode)"
    "")
  
+;; Explicit load/store expanders for the builtin functions for lxvd2x, etc.,
+;; when you really want their element-reversing behavior.
+(define_insn "vsx_ld_elemrev_v2di"
+  [(set (match_operand:V2DI 0 "vsx_register_operand" "=wa")
+        (vec_select:V2DI
+         (match_operand:V2DI 1 "memory_operand" "Z")
+         (parallel [(const_int 1) (const_int 0)])))]
+  "VECTOR_MEM_VSX_P (V2DImode) && !BYTES_BIG_ENDIAN"
+  "lxvd2x %x0,%y1"
+  [(set_attr "type" "vecload")])
+
+(define_insn "vsx_ld_elemrev_v2df"
+  [(set (match_operand:V2DF 0 "vsx_register_operand" "=wa")
+        (vec_select:V2DF
+         (match_operand:V2DF 1 "memory_operand" "Z")
+         (parallel [(const_int 1) (const_int 0)])))]
+  "VECTOR_MEM_VSX_P (V2DFmode) && !BYTES_BIG_ENDIAN"
+  "lxvd2x %x0,%y1"
+  [(set_attr "type" "vecload")])
+
+(define_insn "vsx_ld_elemrev_v4si"
+  [(set (match_operand:V4SI 0 "vsx_register_operand" "=wa")
+        (vec_select:V4SI
+         (match_operand:V4SI 1 "memory_operand" "Z")
+         (parallel [(const_int 3) (const_int 2)
+                    (const_int 1) (const_int 0)])))]
+  "VECTOR_MEM_VSX_P (V4SImode) && !BYTES_BIG_ENDIAN"
+  "lxvw4x %x0,%y1"
+  [(set_attr "type" "vecload")])
+
+(define_insn "vsx_ld_elemrev_v4sf"
+  [(set (match_operand:V4SF 0 "vsx_register_operand" "=wa")
+        (vec_select:V4SF
+         (match_operand:V4SF 1 "memory_operand" "Z")
+         (parallel [(const_int 3) (const_int 2)
+                    (const_int 1) (const_int 0)])))]
+  "VECTOR_MEM_VSX_P (V4SFmode) && !BYTES_BIG_ENDIAN"
+  "lxvw4x %x0,%y1"
+  [(set_attr "type" "vecload")])
+
+(define_insn "vsx_ld_elemrev_v8hi"
+  [(set (match_operand:V8HI 0 "vsx_register_operand" "=wa")
+        (vec_select:V8HI
+         (match_operand:V8HI 1 "memory_operand" "Z")
+         (parallel [(const_int 7) (const_int 6)
+                    (const_int 5) (const_int 4)
+                    (const_int 3) (const_int 2)
+                    (const_int 1) (const_int 0)])))]
+  "VECTOR_MEM_VSX_P (V8HImode) && !BYTES_BIG_ENDIAN && TARGET_P9_VECTOR"
+  "lxvh8x %x0,%y1"
+  [(set_attr "type" "vecload")])
+
+(define_insn "vsx_ld_elemrev_v16qi"
+  [(set (match_operand:V16QI 0 "vsx_register_operand" "=wa")
+        (vec_select:V16QI
+         (match_operand:V16QI 1 "memory_operand" "Z")
+         (parallel [(const_int 15) (const_int 14)
+                    (const_int 13) (const_int 12)
+                    (const_int 11) (const_int 10)
+                    (const_int  9) (const_int  8)
+                    (const_int  7) (const_int  6)
+                    (const_int  5) (const_int  4)
+                    (const_int  3) (const_int  2)
+                    (const_int  1) (const_int  0)])))]
+  "VECTOR_MEM_VSX_P (V16QImode) && !BYTES_BIG_ENDIAN && TARGET_P9_VECTOR"
+  "lxvb16x %x0,%y1"
+  [(set_attr "type" "vecload")])
+
+(define_insn "vsx_st_elemrev_v2df"
+  [(set (match_operand:V2DF 0 "memory_operand" "=Z")
+        (vec_select:V2DF
+         (match_operand:V2DF 1 "vsx_register_operand" "wa")
+         (parallel [(const_int 1) (const_int 0)])))]
+  "VECTOR_MEM_VSX_P (V2DFmode) && !BYTES_BIG_ENDIAN"
+  "stxvd2x %x1,%y0"
+  [(set_attr "type" "vecstore")])
+
+(define_insn "vsx_st_elemrev_v2di"
+  [(set (match_operand:V2DI 0 "memory_operand" "=Z")
+        (vec_select:V2DI
+         (match_operand:V2DI 1 "vsx_register_operand" "wa")
+         (parallel [(const_int 1) (const_int 0)])))]
+  "VECTOR_MEM_VSX_P (V2DImode) && !BYTES_BIG_ENDIAN"
+  "stxvd2x %x1,%y0"
+  [(set_attr "type" "vecstore")])
+
+(define_insn "vsx_st_elemrev_v4sf"
+  [(set (match_operand:V4SF 0 "memory_operand" "=Z")
+        (vec_select:V4SF
+         (match_operand:V4SF 1 "vsx_register_operand" "wa")
+         (parallel [(const_int 3) (const_int 2)
+                    (const_int 1) (const_int 0)])))]
+  "VECTOR_MEM_VSX_P (V4SFmode) && !BYTES_BIG_ENDIAN"
+  "stxvw4x %x1,%y0"
+  [(set_attr "type" "vecstore")])
+
+(define_insn "vsx_st_elemrev_v4si"
+  [(set (match_operand:V4SI 0 "memory_operand" "=Z")
+        (vec_select:V4SI
+         (match_operand:V4SI 1 "vsx_register_operand" "wa")
+         (parallel [(const_int 3) (const_int 2)
+                    (const_int 1) (const_int 0)])))]
+  "VECTOR_MEM_VSX_P (V4SImode) && !BYTES_BIG_ENDIAN"
+  "stxvw4x %x1,%y0"
+  [(set_attr "type" "vecstore")])
+
+(define_insn "vsx_st_elemrev_v8hi"
+  [(set (match_operand:V8HI 0 "memory_operand" "=Z")
+        (vec_select:V8HI
+         (match_operand:V8HI 1 "vsx_register_operand" "wa")
+         (parallel [(const_int 7) (const_int 6)
+                    (const_int 5) (const_int 4)
+                    (const_int 3) (const_int 2)
+                    (const_int 1) (const_int 0)])))]
+  "VECTOR_MEM_VSX_P (V8HImode) && !BYTES_BIG_ENDIAN && TARGET_P9_VECTOR"
+  "stxvh8x %x1,%y0"
+  [(set_attr "type" "vecstore")])
+
+(define_insn "vsx_st_elemrev_v16qi"
+  [(set (match_operand:V16QI 0 "memory_operand" "=Z")
+        (vec_select:V16QI
+         (match_operand:V16QI 1 "vsx_register_operand" "wa")
+         (parallel [(const_int 15) (const_int 14)
+                    (const_int 13) (const_int 12)
+                    (const_int 11) (const_int 10)
+                    (const_int  9) (const_int  8)
+                    (const_int  7) (const_int  6)
+                    (const_int  5) (const_int  4)
+                    (const_int  3) (const_int  2)
+                    (const_int  1) (const_int  0)])))]
+  "VECTOR_MEM_VSX_P (V16QImode) && !BYTES_BIG_ENDIAN && TARGET_P9_VECTOR"
+  "stxvb16x %x1,%y0"
+  [(set_attr "type" "vecstore")])
+
  \f
  ;; VSX vector floating point arithmetic instructions.  The VSX scalar
  ;; instructions are now combined with the insn for the traditional floating
@@ -1583,10 +1742,15 @@
  {
    rtx op0 = operands[0];
    rtx op1 = operands[1];
-  rtx tmp = gen_reg_rtx (V2DFmode);
-  int scale = INTVAL(operands[2]);
-  if (scale != 0)
-    rs6000_scale_v2df (tmp, op1, scale);
+  rtx tmp;
+  int scale = INTVAL (operands[2]);
+  if (scale == 0)
+    tmp = op1;
+  else
+    {
+      tmp  = gen_reg_rtx (V2DFmode);
+      rs6000_scale_v2df (tmp, op1, scale);
+    }
    emit_insn (gen_vsx_xvcvdpsxds (op0, tmp));
    DONE;
  })
@@ -1607,10 +1771,15 @@
  {
    rtx op0 = operands[0];
    rtx op1 = operands[1];
-  rtx tmp = gen_reg_rtx (V2DFmode);
-  int scale = INTVAL(operands[2]);
-  if (scale != 0)
-    rs6000_scale_v2df (tmp, op1, scale);
+  rtx tmp;
+  int scale = INTVAL (operands[2]);
+  if (scale == 0)
+    tmp = op1;
+  else
+    {
+      tmp = gen_reg_rtx (V2DFmode);
+      rs6000_scale_v2df (tmp, op1, scale);
+    }
    emit_insn (gen_vsx_xvcvdpuxds (op0, tmp));
    DONE;
  })
@@ -2215,20 +2384,62 @@
  
  ;; V2DF/V2DI splat
  (define_insn "vsx_splat_<mode>"
-  [(set (match_operand:VSX_D 0 "vsx_register_operand" "=wd,wd,wd,?<VSa>,?<VSa>,?<VSa>")
+  [(set (match_operand:VSX_D 0 "vsx_register_operand" "=<VSa>,<VSa>,we")
         (vec_duplicate:VSX_D
-        (match_operand:<VS_scalar> 1 "splat_input_operand" "<VS_64reg>,f,Z,<VSa>,<VSa>,Z")))]
+        (match_operand:<VS_scalar> 1 "splat_input_operand" "<VS_64reg>,Z,b")))]
    "VECTOR_MEM_VSX_P (<MODE>mode)"
    "@
     xxpermdi %x0,%x1,%x1,0
-   xxpermdi %x0,%x1,%x1,0
     lxvdsx %x0,%y1
-   xxpermdi %x0,%x1,%x1,0
-   xxpermdi %x0,%x1,%x1,0
-   lxvdsx %x0,%y1"
-  [(set_attr "type" "vecperm,vecperm,vecload,vecperm,vecperm,vecload")])
+   mtvsrdd %x0,%1,%1"
+  [(set_attr "type" "vecperm,vecload,mftgpr")])
+
+;; V4SI splat (ISA 3.0)
+;; When SI's are allowed in VSX registers, add XXSPLTW support
+(define_expand "vsx_splat_<mode>"
+  [(set (match_operand:VSX_W 0 "vsx_register_operand" "")
+       (vec_duplicate:VSX_W
+        (match_operand:<VS_scalar> 1 "splat_input_operand" "")))]
+  "TARGET_P9_VECTOR"
+{
+  if (MEM_P (operands[1]))
+    operands[1] = rs6000_address_for_fpconvert (operands[1]);
+  else if (!REG_P (operands[1]))
+    operands[1] = force_reg (<VS_scalar>mode, operands[1]);
+})
+
+(define_insn "*vsx_splat_v4si_internal"
+  [(set (match_operand:V4SI 0 "vsx_register_operand" "=wa,wa")
+       (vec_duplicate:V4SI
+        (match_operand:SI 1 "splat_input_operand" "r,Z")))]
+  "TARGET_P9_VECTOR"
+  "@
+   mtvsrws %x0,%1
+   lxvwsx %x0,%y1"
+  [(set_attr "type" "mftgpr,vecload")])
+
+;; V4SF splat (ISA 3.0)
+(define_insn_and_split "*vsx_splat_v4sf_internal"
+  [(set (match_operand:V4SF 0 "vsx_register_operand" "=wa,wa,wa")
+       (vec_duplicate:V4SF
+        (match_operand:SF 1 "splat_input_operand" "Z,wy,r")))]
+  "TARGET_P9_VECTOR"
+  "@
+   lxvwsx %x0,%y1
+   #
+   mtvsrws %x0,%1"
+  "&& reload_completed && vsx_register_operand (operands[1], SFmode)"
+  [(set (match_dup 0)
+       (unspec:V4SF [(match_dup 1)] UNSPEC_VSX_CVDPSPN))
+   (set (match_dup 0)
+       (vec_duplicate:V4SF
+        (vec_select:SF (match_dup 0)
+                       (parallel [(const_int 0)]))))]
+  ""
+  [(set_attr "type" "vecload,vecperm,mftgpr")
+   (set_attr "length" "4,8,4")])
  
-;; V4SF/V4SI splat
+;; V4SF/V4SI splat from a vector element
  (define_insn "vsx_xxspltw_<mode>"
    [(set (match_operand:VSX_W 0 "vsx_register_operand" "=wf,?<VSa>")
         (vec_duplicate:VSX_W
@@ -2471,21 +2682,50 @@
  (define_peephole
    [(set (match_operand:P 0 "base_reg_operand" "")
         (match_operand:P 1 "short_cint_operand" ""))
-   (set (match_operand:VSX_M2 2 "vsx_register_operand" "")
-       (mem:VSX_M2 (plus:P (match_dup 0)
-                           (match_operand:P 3 "int_reg_operand" ""))))]
+   (set (match_operand:VSX_M 2 "vsx_register_operand" "")
+       (mem:VSX_M (plus:P (match_dup 0)
+                          (match_operand:P 3 "int_reg_operand" ""))))]
    "TARGET_VSX && TARGET_P8_FUSION && !TARGET_P9_VECTOR"
-  "li %0,%1\t\t\t# vector load fusion\;lx<VSX_M2:VSm>x %x2,%0,%3"  
+  "li %0,%1\t\t\t# vector load fusion\;lx<VSX_M:VSm>x %x2,%0,%3"  
    [(set_attr "length" "8")
     (set_attr "type" "vecload")])
  
  (define_peephole
    [(set (match_operand:P 0 "base_reg_operand" "")
         (match_operand:P 1 "short_cint_operand" ""))
-   (set (match_operand:VSX_M2 2 "vsx_register_operand" "")
-       (mem:VSX_M2 (plus:P (match_operand:P 3 "int_reg_operand" "")
-                           (match_dup 0))))]
+   (set (match_operand:VSX_M 2 "vsx_register_operand" "")
+       (mem:VSX_M (plus:P (match_operand:P 3 "int_reg_operand" "")
+                          (match_dup 0))))]
    "TARGET_VSX && TARGET_P8_FUSION && !TARGET_P9_VECTOR"
-  "li %0,%1\t\t\t# vector load fusion\;lx<VSX_M2:VSm>x %x2,%0,%3"  
+  "li %0,%1\t\t\t# vector load fusion\;lx<VSX_M:VSm>x %x2,%0,%3"  
    [(set_attr "length" "8")
     (set_attr "type" "vecload")])
+
+\f
+;; ISA 3.0 vector extend sign support
+
+(define_insn "vsx_sign_extend_qi_<mode>"
+  [(set (match_operand:VSINT_84 0 "vsx_register_operand" "=v")
+       (unspec:VSINT_84
+        [(match_operand:V16QI 1 "vsx_register_operand" "v")]
+        UNSPEC_VSX_SIGN_EXTEND))]
+  "TARGET_P9_VECTOR"
+  "vextsb2<wd> %0,%1"
+  [(set_attr "type" "vecsimple")])
+
+(define_insn "*vsx_sign_extend_hi_<mode>"
+  [(set (match_operand:VSINT_84 0 "vsx_register_operand" "=v")
+       (unspec:VSINT_84
+        [(match_operand:V8HI 1 "vsx_register_operand" "v")]
+        UNSPEC_VSX_SIGN_EXTEND))]
+  "TARGET_P9_VECTOR"
+  "vextsh2<wd> %0,%1"
+  [(set_attr "type" "vecsimple")])
+
+(define_insn "*vsx_sign_extend_si_v2di"
+  [(set (match_operand:V2DI 0 "vsx_register_operand" "=v")
+       (unspec:V2DI [(match_operand:V4SI 1 "vsx_register_operand" "v")]
+                    UNSPEC_VSX_SIGN_EXTEND))]
+  "TARGET_P9_VECTOR"
+  "vextsw2d %0,%1"
+  [(set_attr "type" "vecsimple")])
diff --git a/gcc/config/rtems.h b/gcc/config/rtems.h

index f13f72f..e005547 100644 (file)
--- a/gcc/config/rtems.h
+++ b/gcc/config/rtems.h
@@ -45,6 +45,6 @@ see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
  #define LIB_SPEC "%{!qrtems: " STD_LIB_SPEC "} " \
  "%{!nostdlib: %{qrtems: --start-group \
   -lrtemsbsp -lrtemscpu \
- -lc -lgcc --end-group %{!qnolinkcmds: -T linkcmds%s}}}"
+ -latomic -lc -lgcc --end-group %{!qnolinkcmds: -T linkcmds%s}}}"
  
  #define TARGET_POSIX_IO
diff --git a/gcc/config/s390/s390.c b/gcc/config/s390/s390.c

index a1d0930..50fee7c 100644 (file)
--- a/gcc/config/s390/s390.c
+++ b/gcc/config/s390/s390.c
@@ -791,7 +791,7 @@ s390_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
                      machine_mode mode ATTRIBUTE_UNUSED,
                      int ignore ATTRIBUTE_UNUSED)
  {
-#define MAX_ARGS 5
+#define MAX_ARGS 6
  
    tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
    unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
diff --git a/gcc/config/s390/s390.md b/gcc/config/s390/s390.md

index 2b4e8f4..28e44cf 100644 (file)
--- a/gcc/config/s390/s390.md
+++ b/gcc/config/s390/s390.md
@@ -1295,7 +1295,7 @@
         (compare:VFCMP (match_operand:DF 0 "register_operand" "v")
                        (match_operand:DF 1 "register_operand" "v")))
     (clobber (match_scratch:V2DI 2 "=v"))]
-  "TARGET_Z13 && TARGET_HARD_FLOAT"
+  "TARGET_VX && TARGET_HARD_FLOAT"
    "wfc<asm_fcmp>dbs\t%v2,%v0,%v1"
    [(set_attr "op_type" "VRR")])
  
@@ -4649,7 +4649,7 @@
         (unsigned_fix:DI (match_operand:DF 1 "register_operand"  "f,v")))
     (unspec:DI [(match_operand:DI           2 "immediate_operand" "K,K")] UNSPEC_ROUND)
     (clobber (reg:CC CC_REGNUM))]
-   "TARGET_Z13 && TARGET_HARD_FLOAT"
+   "TARGET_VX && TARGET_HARD_FLOAT"
     "@
      clgdbr\t%0,%h2,%1,0
      wclgdb\t%v0,%v1,0,%h2"
@@ -4664,7 +4664,7 @@
     (unspec:GPR [(match_operand:GPR          2 "immediate_operand" "K")] UNSPEC_ROUND)
     (clobber (reg:CC CC_REGNUM))]
     "TARGET_Z196 && TARGET_HARD_FLOAT
-    && (!TARGET_Z13 || <GPR:MODE>mode != DImode || <FP:MODE>mode != DFmode)"
+    && (!TARGET_VX || <GPR:MODE>mode != DImode || <FP:MODE>mode != DFmode)"
     "cl<GPR:gf><FP:xde><FP:bt>r\t%0,%h2,%1,0"
     [(set_attr "op_type" "RRF")
      (set_attr "type"    "ftoi")])
@@ -4684,7 +4684,7 @@
          (fix:DI (match_operand:DF 1 "register_operand"  "f,v")))
     (unspec:DI [(match_operand:DI  2 "immediate_operand" "K,K")] UNSPEC_ROUND)
     (clobber (reg:CC CC_REGNUM))]
-  "TARGET_Z13 && TARGET_HARD_FLOAT"
+  "TARGET_VX && TARGET_HARD_FLOAT"
    "@
     cgdbr\t%0,%h2,%1
     wcgdb\t%v0,%v1,0,%h2"
@@ -4792,7 +4792,7 @@
  (define_insn "*floatunsdidf2_z13"
    [(set (match_operand:DF                    0 "register_operand" "=f,v")
          (unsigned_float:DF (match_operand:DI 1 "register_operand"  "d,v")))]
-  "TARGET_Z13 && TARGET_HARD_FLOAT"
+  "TARGET_VX && TARGET_HARD_FLOAT"
    "@
     cdlgbr\t%0,0,%1,0
     wcdlgb\t%v0,%v1,0,0"
@@ -4896,7 +4896,7 @@
  (define_insn "*extendsfdf2_z13"
    [(set (match_operand:DF                  0 "register_operand"     "=f,f,v")
          (float_extend:DF (match_operand:SF 1 "nonimmediate_operand"  "f,R,v")))]
-  "TARGET_Z13 && TARGET_HARD_FLOAT"
+  "TARGET_VX && TARGET_HARD_FLOAT"
    "@
     ldebr\t%0,%1
     ldeb\t%0,%1
diff --git a/gcc/config/sparc/driver-sparc.c b/gcc/config/sparc/driver-sparc.c

index 7e9ee24..ea174bf 100644 (file)
--- a/gcc/config/sparc/driver-sparc.c
+++ b/gcc/config/sparc/driver-sparc.c
@@ -75,6 +75,8 @@ static const struct cpu_names {
    { "UltraSparc T4",   "niagara4" },
    { "LEON",            "leon3" },
  #endif
+  { "SPARC-M7",                "niagara7" },
+  { "SPARC-S7",                "niagara7" },
    { NULL,      NULL }
    };
  
diff --git a/gcc/config/sparc/linux64.h b/gcc/config/sparc/linux64.h

index a1ef325..9d53c29 100644 (file)
--- a/gcc/config/sparc/linux64.h
+++ b/gcc/config/sparc/linux64.h
@@ -164,22 +164,42 @@ extern const char *host_detect_local_cpu (int argc, const char **argv);
  #endif
  
  /* Support for a compile-time default CPU, et cetera.  The rules are:
-   --with-cpu is ignored if -mcpu is specified.
-   --with-tune is ignored if -mtune is specified.
+   --with-cpu is ignored if -mcpu is specified; likewise --with-cpu-32
+     and --with-cpu-64.
+   --with-tune is ignored if -mtune is specified; likewise --with-tune-32
+     and --with-tune-64.
     --with-float is ignored if -mhard-float, -msoft-float, -mfpu, or -mno-fpu
       are specified.
     In the SPARC_BI_ARCH compiler we cannot pass %{!mcpu=*:-mcpu=%(VALUE)}
     here, otherwise say -mcpu=v7 would be passed even when -m64.
-   CC1_SPEC above takes care of this instead.  */
+   CC1_SPEC above takes care of this instead.
+
+   Note that the order of the cpu* and tune* options matters: the
+   config.gcc file always sets with_cpu to some value, even if the
+   user didn't use --with-cpu when invoking the configure script.
+   This value is based on the target name.  Therefore we have to make
+   sure that --with-cpu-32 takes precedence to --with-cpu in < v9
+   systems, and that --with-cpu-64 takes precedence to --with-cpu in
+   >= v9 systems.  As for the tune* options, in some platforms
+   config.gcc also sets a default value for it if the user didn't use
+   --with-tune when invoking the configure script.  */
  #undef OPTION_DEFAULT_SPECS
  #if DEFAULT_ARCH32_P
  #define OPTION_DEFAULT_SPECS \
+  {"cpu_32", "%{!m64:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \
+  {"cpu_64", "%{m64:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \
    {"cpu", "%{!m64:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \
+  {"tune_32", "%{!m64:%{!mtune=*:-mtune=%(VALUE)}}" }, \
+  {"tune_64", "%{m64:%{!mtune=*:-mtune=%(VALUE)}}" }, \
    {"tune", "%{!mtune=*:-mtune=%(VALUE)}" }, \
    {"float", "%{!msoft-float:%{!mhard-float:%{!mfpu:%{!mno-fpu:-m%(VALUE)-float}}}}" }
  #else
  #define OPTION_DEFAULT_SPECS \
+  {"cpu_32", "%{m32:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \
+  {"cpu_64", "%{!m32:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \
    {"cpu", "%{!m32:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \
+  {"tune_32", "%{m32:%{!mtune=*:-mtune=%(VALUE)}}" },  \
+  {"tune_64", "%{!m32:%{!mtune=*:-mtune=%(VALUE)}}" }, \
    {"tune", "%{!mtune=*:-mtune=%(VALUE)}" }, \
    {"float", "%{!msoft-float:%{!mhard-float:%{!mfpu:%{!mno-fpu:-m%(VALUE)-float}}}}" }
  #endif
diff --git a/gcc/config/sparc/niagara4.md b/gcc/config/sparc/niagara4.md

index a826fb4..925fc6c 100644 (file)
--- a/gcc/config/sparc/niagara4.md
+++ b/gcc/config/sparc/niagara4.md
@@ -75,6 +75,13 @@
        (eq_attr "fptype" "double")))
    "n4_slot1")
  
+;; The latency numbers for VIS instructions in the reservations below
+;; reflect empirical results, and don't match with the documented
+;; latency numbers in the T4 Processor Supplement.  This is because
+;; the HW chaps didn't feel it necessary to document the complexity in
+;; the PRM, and just assigned a latency of 11 to all/most of the VIS
+;; instructions.
+
  (define_insn_reservation "n4_vis_move_11cycle" 11
    (and (eq_attr "cpu" "niagara4")
      (and (eq_attr "type" "vismv")
diff --git a/gcc/config/sparc/niagara7.md b/gcc/config/sparc/niagara7.md

new file mode 100644 (file)

index 0000000..56a4edb
--- /dev/null
+++ b/gcc/config/sparc/niagara7.md
@@ -0,0 +1,136 @@
+;; Scheduling description for Niagara-7
+;;   Copyright (C) 2016 Free Software Foundation, Inc.
+;;
+;; This file is part of GCC.
+;;
+;; GCC is free software; you can redistribute it and/or modify
+;; it under the terms of the GNU General Public License as published by
+;; the Free Software Foundation; either version 3, or (at your option)
+;; any later version.
+;;
+;; GCC is distributed in the hope that it will be useful,
+;; but WITHOUT ANY WARRANTY; without even the implied warranty of
+;; MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+;; GNU General Public License for more details.
+;;
+;; You should have received a copy of the GNU General Public License
+;; along with GCC; see the file COPYING3.  If not see
+;; <http://www.gnu.org/licenses/>.
+
+(define_automaton "niagara7_0")
+
+(define_cpu_unit "n7_slot0,n7_slot1,n7_slot2" "niagara7_0")
+(define_reservation "n7_single_issue" "n7_slot0 + n7_slot1 + n7_slot2")
+
+(define_cpu_unit "n7_load_store" "niagara7_0")
+
+(define_insn_reservation "n7_single" 1
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "multi,savew,flushw,trap"))
+  "n7_single_issue")
+
+(define_insn_reservation "n7_iflush" 27
+  (and (eq_attr "cpu" "niagara7")
+       (eq_attr "type" "iflush"))
+  "(n7_slot0 | n7_slot1), nothing*26")
+
+(define_insn_reservation "n7_integer" 1
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "ialu,ialuX,shift,cmove,compare"))
+  "(n7_slot0 | n7_slot1)")
+
+(define_insn_reservation "n7_imul" 12
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "imul"))
+  "n7_slot1, nothing*11")
+
+(define_insn_reservation "n7_idiv" 35
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "idiv"))
+  "n7_slot1, nothing*34")
+
+(define_insn_reservation "n7_load" 5
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "load,fpload,sload"))
+  "(n7_slot0 + n7_load_store), nothing*4")
+
+(define_insn_reservation "n7_store" 1
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "store,fpstore"))
+  "(n7_slot0 | n7_slot2) + n7_load_store")
+
+(define_insn_reservation "n7_cti" 1
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "cbcond,uncond_cbcond,branch,call,sibcall,call_no_delay_slot,uncond_branch,return"))
+  "n7_slot1")
+
+(define_insn_reservation "n7_fp" 11
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "fpmove,fpcmove,fpcrmove,fp,fpcmp,fpmul"))
+  "n7_slot1, nothing*10")
+
+(define_insn_reservation "n7_array" 12
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "array,edge,edgen"))
+  "n7_slot1, nothing*11")
+
+(define_insn_reservation "n7_fpdivs" 24
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "fpdivs,fpsqrts"))
+  "n7_slot1, nothing*23")
+
+(define_insn_reservation "n7_fpdivd" 37
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "fpdivd,fpsqrtd"))
+  "n7_slot1, nothing*36")
+
+(define_insn_reservation "n7_lzd" 12
+  (and (eq_attr "cpu" "niagara7")
+       (eq_attr "type" "lzd"))
+  "(n7_slot0 | n7_slot1), nothing*11")
+
+;; There is an internal unit called the "V3 pipe", that was originally
+;; intended to process some of the short cryptographic instructions.
+;; However, as soon as in the T4 several of the VIS instructions
+;; (notably non-FP instructions) have been moved to the V3 pipe.
+;; Consequently, these instructions feature a latency of 3 instead of
+;; 11 or 12 cycles, provided their consumers also execute in the V3
+;; pipe.
+;;
+;; This is modelled here with a bypass.
+
+(define_insn_reservation "n7_vis_fga" 11
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "fga,gsr"))
+  "n7_slot1, nothing*10")
+
+(define_insn_reservation "n7_vis_fgm" 11
+  (and (eq_attr "cpu" "niagara7")
+    (eq_attr "type" "fgm_pack,fgm_mul,pdist"))
+  "n7_slot1, nothing*10")
+
+(define_insn_reservation "n7_vis_move_v3pipe" 11
+  (and (eq_attr "cpu" "niagara7")
+    (and (eq_attr "type" "vismv")
+         (eq_attr "v3pipe" "true")))
+  "n7_slot1")
+
+(define_insn_reservation "n7_vis_move_11cycle" 11
+  (and (eq_attr "cpu" "niagara7")
+    (and (eq_attr "type" "vismv")
+         (eq_attr "v3pipe" "false")))
+  "n7_slot1, nothing*10")
+
+(define_insn_reservation "n7_vis_logical_v3pipe" 11
+  (and (eq_attr "cpu" "niagara7")
+    (and (eq_attr "type" "visl,pdistn")
+         (eq_attr "v3pipe" "true")))
+  "n7_slot1, nothing*2")
+
+(define_insn_reservation "n7_vis_logical_11cycle" 11
+  (and (eq_attr "cpu" "niagara7")
+    (and (eq_attr "type" "visl")
+      (eq_attr "v3pipe" "false")))
+  "n7_slot1, nothing*10")
+
+(define_bypass 3 "*_v3pipe" "*_v3pipe")
diff --git a/gcc/config/sparc/sol2.h b/gcc/config/sparc/sol2.h

index 07e6368..2a843c5 100644 (file)
--- a/gcc/config/sparc/sol2.h
+++ b/gcc/config/sparc/sol2.h
@@ -165,13 +165,22 @@ along with GCC; see the file COPYING3.  If not see
  #define ASM_CPU64_DEFAULT_SPEC AS_SPARC64_FLAG AS_NIAGARA4_FLAG
  #endif
  
+#if TARGET_CPU_DEFAULT == TARGET_CPU_niagara7
+#undef CPP_CPU64_DEFAULT_SPEC
+#define CPP_CPU64_DEFAULT_SPEC ""
+#undef ASM_CPU32_DEFAULT_SPEC
+#define ASM_CPU32_DEFAUILT_SPEC AS_SPARC32_FLAG AS_NIAGARA7_FLAG
+#undef ASM_CPU64_DEFAULT_SPEC
+#define ASM_CPU64_DEFAULT_SPEC AS_SPARC64_FLAG AS_NIAGARA7_FLAG
+#endif
+
  #undef CPP_CPU_SPEC
  #define CPP_CPU_SPEC "\
  %{mcpu=sparclet|mcpu=tsc701:-D__sparclet__} \
  %{mcpu=sparclite|mcpu-f930|mcpu=f934:-D__sparclite__} \
  %{mcpu=v8:" DEF_ARCH32_SPEC("-D__sparcv8") "} \
  %{mcpu=supersparc:-D__supersparc__ " DEF_ARCH32_SPEC("-D__sparcv8") "} \
-%{mcpu=v9|mcpu=ultrasparc|mcpu=ultrasparc3|mcpu=niagara|mcpu=niagara2|mcpu=niagara3|mcpu=niagara4:" DEF_ARCH32_SPEC("-D__sparcv8") "} \
+%{mcpu=v9|mcpu=ultrasparc|mcpu=ultrasparc3|mcpu=niagara|mcpu=niagara2|mcpu=niagara3|mcpu=niagara4|mcpu=niagara7:" DEF_ARCH32_SPEC("-D__sparcv8") "} \
  %{!mcpu*:%(cpp_cpu_default)} \
  "
  
@@ -231,22 +240,42 @@ extern const char *host_detect_local_cpu (int argc, const char **argv);
  #endif
  
  /* Support for a compile-time default CPU, et cetera.  The rules are:
-   --with-cpu is ignored if -mcpu is specified.
-   --with-tune is ignored if -mtune is specified.
+   --with-cpu is ignored if -mcpu is specified; likewise --with-cpu-32
+     and --with-cpu-64.
+   --with-tune is ignored if -mtune is specified; likewise --with-tune-32
+     and --with-tune-64.
     --with-float is ignored if -mhard-float, -msoft-float, -mfpu, or -mno-fpu
       are specified.
     In the SPARC_BI_ARCH compiler we cannot pass %{!mcpu=*:-mcpu=%(VALUE)}
     here, otherwise say -mcpu=v7 would be passed even when -m64.
-   CC1_SPEC above takes care of this instead.  */
+   CC1_SPEC above takes care of this instead.
+
+   Note that the order of the cpu* and tune* options matters: the
+   config.gcc file always sets with_cpu to some value, even if the
+   user didn't use --with-cpu when invoking the configure script.
+   This value is based on the target name.  Therefore we have to make
+   sure that --with-cpu-32 takes precedence to --with-cpu in < v9
+   systems, and that --with-cpu-64 takes precedence to --with-cpu in
+   >= v9 systems.  As for the tune* options, in some platforms
+   config.gcc also sets a default value for it if the user didn't use
+   --with-tune when invoking the configure script.  */
  #undef OPTION_DEFAULT_SPECS
  #if DEFAULT_ARCH32_P
  #define OPTION_DEFAULT_SPECS \
+  {"cpu_32", "%{!m64:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \
+  {"cpu_64", "%{m64:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \
    {"cpu", "%{!m64:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \
+  {"tune_32", "%{!m64:%{!mtune=*:-mtune=%(VALUE)}}" }, \
+  {"tune_64", "%{m64:%{!mtune=*:-mtune=%(VALUE)}}" }, \
    {"tune", "%{!mtune=*:-mtune=%(VALUE)}" }, \
    {"float", "%{!msoft-float:%{!mhard-float:%{!mfpu:%{!mno-fpu:-m%(VALUE)-float}}}}" }
  #else
  #define OPTION_DEFAULT_SPECS \
+  {"cpu_32", "%{m32:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \
+  {"cpu_64", "%{!m32:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \
    {"cpu", "%{!m32:%{!mcpu=*:-mcpu=%(VALUE)}}" }, \
+  {"tune_32", "%{m32:%{!mtune=*:-mtune=%(VALUE)}}" },  \
+  {"tune_64", "%{!m32:%{!mtune=*:-mtune=%(VALUE)}}" }, \
    {"tune", "%{!mtune=*:-mtune=%(VALUE)}" }, \
    {"float", "%{!msoft-float:%{!mhard-float:%{!mfpu:%{!mno-fpu:-m%(VALUE)-float}}}}" }
  #endif
@@ -260,7 +289,8 @@ extern const char *host_detect_local_cpu (int argc, const char **argv);
  %{mcpu=niagara2:" DEF_ARCH32_SPEC("-xarch=v8plusb") DEF_ARCH64_SPEC("-xarch=v9b") "} \
  %{mcpu=niagara3:" DEF_ARCH32_SPEC("-xarch=v8plus" AS_NIAGARA3_FLAG) DEF_ARCH64_SPEC("-xarch=v9" AS_NIAGARA3_FLAG) "} \
  %{mcpu=niagara4:" DEF_ARCH32_SPEC(AS_SPARC32_FLAG AS_NIAGARA4_FLAG) DEF_ARCH64_SPEC(AS_SPARC64_FLAG AS_NIAGARA4_FLAG) "} \
-%{!mcpu=niagara4:%{!mcpu=niagara3:%{!mcpu=niagara2:%{!mcpu=niagara:%{!mcpu=ultrasparc3:%{!mcpu=ultrasparc:%{!mcpu=v9:%{mcpu*:" DEF_ARCH32_SPEC("-xarch=v8") DEF_ARCH64_SPEC("-xarch=v9") "}}}}}}}} \
+%{mcpu=niagara7:" DEF_ARCH32_SPEC(AS_SPARC32_FLAG AS_NIAGARA7_FLAG) DEF_ARCH64_SPEC(AS_SPARC64_FLAG AS_NIAGARA7_FLAG) "} \
+%{!mcpu=niagara7:%{!mcpu=niagara4:%{!mcpu=niagara3:%{!mcpu=niagara2:%{!mcpu=niagara:%{!mcpu=ultrasparc3:%{!mcpu=ultrasparc:%{!mcpu=v9:%{mcpu*:" DEF_ARCH32_SPEC("-xarch=v8") DEF_ARCH64_SPEC("-xarch=v9") "}}}}}}}}} \
  %{!mcpu*:%(asm_cpu_default)} \
  "
  
diff --git a/gcc/config/sparc/sparc-c.c b/gcc/config/sparc/sparc-c.c

index d3fd60e..d9f9c15 100644 (file)
--- a/gcc/config/sparc/sparc-c.c
+++ b/gcc/config/sparc/sparc-c.c
@@ -40,7 +40,12 @@ sparc_target_macros (void)
        cpp_assert (parse_in, "machine=sparc");
      }
  
-  if (TARGET_VIS3)
+  if (TARGET_VIS4)
+    {
+      cpp_define (parse_in, "__VIS__=0x400");
+      cpp_define (parse_in, "__VIS__=0x400");
+    }
+  else if (TARGET_VIS3)
      {
        cpp_define (parse_in, "__VIS__=0x300");
        cpp_define (parse_in, "__VIS=0x300");
diff --git a/gcc/config/sparc/sparc-opts.h b/gcc/config/sparc/sparc-opts.h

index ce48f18..40d23a2 100644 (file)
--- a/gcc/config/sparc/sparc-opts.h
+++ b/gcc/config/sparc/sparc-opts.h
@@ -45,6 +45,7 @@ enum processor_type {
    PROCESSOR_NIAGARA2,
    PROCESSOR_NIAGARA3,
    PROCESSOR_NIAGARA4,
+  PROCESSOR_NIAGARA7,
    PROCESSOR_NATIVE
  };
  
diff --git a/gcc/config/sparc/sparc.c b/gcc/config/sparc/sparc.c

index 082af3c..1d2ecaa 100644 (file)
--- a/gcc/config/sparc/sparc.c
+++ b/gcc/config/sparc/sparc.c
@@ -423,6 +423,30 @@ struct processor_costs niagara4_costs = {
    0, /* shift penalty */
  };
  
+static const
+struct processor_costs niagara7_costs = {
+  COSTS_N_INSNS (5), /* int load */
+  COSTS_N_INSNS (5), /* int signed load */
+  COSTS_N_INSNS (5), /* int zeroed load */
+  COSTS_N_INSNS (5), /* float load */
+  COSTS_N_INSNS (11), /* fmov, fneg, fabs */
+  COSTS_N_INSNS (11), /* fadd, fsub */
+  COSTS_N_INSNS (11), /* fcmp */
+  COSTS_N_INSNS (11), /* fmov, fmovr */
+  COSTS_N_INSNS (11), /* fmul */
+  COSTS_N_INSNS (24), /* fdivs */
+  COSTS_N_INSNS (37), /* fdivd */
+  COSTS_N_INSNS (24), /* fsqrts */
+  COSTS_N_INSNS (37), /* fsqrtd */
+  COSTS_N_INSNS (12), /* imul */
+  COSTS_N_INSNS (12), /* imulX */
+  0, /* imul bit factor */
+  COSTS_N_INSNS (51), /* idiv, average of 42 - 61 cycle range */
+  COSTS_N_INSNS (35), /* idivX, average of 26 - 44 cycle range */
+  COSTS_N_INSNS (1), /* movcc/movr */
+  0, /* shift penalty */
+};
+
  static const struct processor_costs *sparc_costs = &cypress_costs;
  
  #ifdef HAVE_AS_RELAX_OPTION
@@ -1175,6 +1199,8 @@ dump_target_flag_bits (const int flags)
      fprintf (stderr, "VIS2 ");
    if (flags & MASK_VIS3)
      fprintf (stderr, "VIS3 ");
+  if (flags & MASK_VIS4)
+    fprintf (stderr, "VIS4 ");
    if (flags & MASK_CBCOND)
      fprintf (stderr, "CBCOND ");
    if (flags & MASK_DEPRECATED_V8_INSNS)
@@ -1238,6 +1264,7 @@ sparc_option_override (void)
      { TARGET_CPU_niagara2, PROCESSOR_NIAGARA2 },
      { TARGET_CPU_niagara3, PROCESSOR_NIAGARA3 },
      { TARGET_CPU_niagara4, PROCESSOR_NIAGARA4 },
+    { TARGET_CPU_niagara7, PROCESSOR_NIAGARA7 },
      { -1, PROCESSOR_V7 }
    };
    const struct cpu_default *def;
@@ -1287,6 +1314,9 @@ sparc_option_override (void)
      /* UltraSPARC T4 */
      { "niagara4",      MASK_ISA,
        MASK_V9|MASK_POPC|MASK_VIS2|MASK_VIS3|MASK_FMAF|MASK_CBCOND },
+    /* UltraSPARC M7 */
+    { "niagara7",      MASK_ISA,
+      MASK_V9|MASK_POPC|MASK_VIS2|MASK_VIS3|MASK_VIS4|MASK_FMAF|MASK_CBCOND },
    };
    const struct cpu_table *cpu;
    unsigned int i;
@@ -1416,6 +1446,9 @@ sparc_option_override (void)
  #ifndef HAVE_AS_SPARC4
                    & ~MASK_CBCOND
  #endif
+#ifndef HAVE_AS_SPARC5_VIS4
+                  & ~MASK_VIS4
+#endif
  #ifndef HAVE_AS_LEON
                    & ~(MASK_LEON | MASK_LEON3)
  #endif
@@ -1434,10 +1467,15 @@ sparc_option_override (void)
    if (TARGET_VIS3)
      target_flags |= MASK_VIS2 | MASK_VIS;
  
-  /* Don't allow -mvis, -mvis2, -mvis3, or -mfmaf if FPU is
+  /* -mvis4 implies -mvis3, -mvis2 and -mvis */
+  if (TARGET_VIS4)
+    target_flags |= MASK_VIS3 | MASK_VIS2 | MASK_VIS;
+
+  /* Don't allow -mvis, -mvis2, -mvis3, -mvis4 or -mfmaf if FPU is
       disabled.  */
    if (! TARGET_FPU)
-    target_flags &= ~(MASK_VIS | MASK_VIS2 | MASK_VIS3 | MASK_FMAF);
+    target_flags &= ~(MASK_VIS | MASK_VIS2 | MASK_VIS3 | MASK_VIS4
+                     | MASK_FMAF);
  
    /* -mvis assumes UltraSPARC+, so we are sure v9 instructions
       are available.
@@ -1471,7 +1509,8 @@ sparc_option_override (void)
           || sparc_cpu == PROCESSOR_NIAGARA
           || sparc_cpu == PROCESSOR_NIAGARA2
           || sparc_cpu == PROCESSOR_NIAGARA3
-         || sparc_cpu == PROCESSOR_NIAGARA4))
+         || sparc_cpu == PROCESSOR_NIAGARA4
+         || sparc_cpu == PROCESSOR_NIAGARA7))
      align_functions = 32;
  
    /* Validate PCC_STRUCT_RETURN.  */
@@ -1535,6 +1574,9 @@ sparc_option_override (void)
      case PROCESSOR_NIAGARA4:
        sparc_costs = &niagara4_costs;
        break;
+    case PROCESSOR_NIAGARA7:
+      sparc_costs = &niagara7_costs;
+      break;
      case PROCESSOR_NATIVE:
        gcc_unreachable ();
      };
@@ -1566,6 +1608,29 @@ sparc_option_override (void)
    if (TARGET_DEBUG_OPTIONS)
      dump_target_flags ("Final target_flags", target_flags);
  
+  /* PARAM_SIMULTANEOUS_PREFETCHES is the number of prefetches that
+     can run at the same time.  More important, it is the threshold
+     defining when additional prefetches will be dropped by the
+     hardware.
+
+     The UltraSPARC-III features a documented prefetch queue with a
+     size of 8.  Additional prefetches issued in the cpu are
+     dropped.
+
+     Niagara processors are different.  In these processors prefetches
+     are handled much like regular loads.  The L1 miss buffer is 32
+     entries, but prefetches start getting affected when 30 entries
+     become occupied.  That occupation could be a mix of regular loads
+     and prefetches though.  And that buffer is shared by all threads.
+     Once the threshold is reached, if the core is running a single
+     thread the prefetch will retry.  If more than one thread is
+     running, the prefetch will be dropped.
+
+     All this makes it very difficult to determine how many
+     simultaneous prefetches can be issued simultaneously, even in a
+     single-threaded program.  Experimental results show that setting
+     this parameter to 32 works well when the number of threads is not
+     high.  */
    maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
                          ((sparc_cpu == PROCESSOR_ULTRASPARC
                            || sparc_cpu == PROCESSOR_NIAGARA
@@ -1574,20 +1639,55 @@ sparc_option_override (void)
                            || sparc_cpu == PROCESSOR_NIAGARA4)
                           ? 2
                           : (sparc_cpu == PROCESSOR_ULTRASPARC3
-                            ? 8 : 3)),
+                            ? 8 : (sparc_cpu == PROCESSOR_NIAGARA7
+                                   ? 32 : 3))),
                          global_options.x_param_values,
                          global_options_set.x_param_values);
-  maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE,
+
+  /* For PARAM_L1_CACHE_LINE_SIZE we use the default 32 bytes (see
+     params.def), so no maybe_set_param_value is needed.
+
+     The Oracle SPARC Architecture (previously the UltraSPARC
+     Architecture) specification states that when a PREFETCH[A]
+     instruction is executed an implementation-specific amount of data
+     is prefetched, and that it is at least 64 bytes long (aligned to
+     at least 64 bytes).
+
+     However, this is not correct.  The M7 (and implementations prior
+     to that) does not guarantee a 64B prefetch into a cache if the
+     line size is smaller.  A single cache line is all that is ever
+     prefetched.  So for the M7, where the L1D$ has 32B lines and the
+     L2D$ and L3 have 64B lines, a prefetch will prefetch 64B into the
+     L2 and L3, but only 32B are brought into the L1D$. (Assuming it
+     is a read_n prefetch, which is the only type which allocates to
+     the L1.)  */
+
+  /* PARAM_L1_CACHE_SIZE is the size of the L1D$ (most SPARC chips use
+     Hardvard level-1 caches) in kilobytes.  Both UltraSPARC and
+     Niagara processors feature a L1D$ of 16KB.  */
+  maybe_set_param_value (PARAM_L1_CACHE_SIZE,
                          ((sparc_cpu == PROCESSOR_ULTRASPARC
                            || sparc_cpu == PROCESSOR_ULTRASPARC3
                            || sparc_cpu == PROCESSOR_NIAGARA
                            || sparc_cpu == PROCESSOR_NIAGARA2
                            || sparc_cpu == PROCESSOR_NIAGARA3
-                          || sparc_cpu == PROCESSOR_NIAGARA4)
-                         ? 64 : 32),
+                          || sparc_cpu == PROCESSOR_NIAGARA4
+                          || sparc_cpu == PROCESSOR_NIAGARA7)
+                         ? 16 : 64),
                          global_options.x_param_values,
                          global_options_set.x_param_values);
  
+
+  /* PARAM_L2_CACHE_SIZE is the size fo the L2 in kilobytes.  Note
+     that 512 is the default in params.def.  */
+  maybe_set_param_value (PARAM_L2_CACHE_SIZE,
+                        (sparc_cpu == PROCESSOR_NIAGARA4
+                         ? 128 : (sparc_cpu == PROCESSOR_NIAGARA7
+                                  ? 256 : 512)),
+                        global_options.x_param_values,
+                        global_options_set.x_param_values);
+  
+
    /* Disable save slot sharing for call-clobbered registers by default.
       The IRA sharing algorithm works on single registers only and this
       pessimizes for double floating-point registers.  */
@@ -9178,7 +9278,8 @@ sparc32_initialize_trampoline (rtx m_tramp, rtx fnaddr, rtx cxt)
        && sparc_cpu != PROCESSOR_NIAGARA
        && sparc_cpu != PROCESSOR_NIAGARA2
        && sparc_cpu != PROCESSOR_NIAGARA3
-      && sparc_cpu != PROCESSOR_NIAGARA4)
+      && sparc_cpu != PROCESSOR_NIAGARA4
+      && sparc_cpu != PROCESSOR_NIAGARA7)
      emit_insn (gen_flushsi (validize_mem (adjust_address (m_tramp, SImode, 8))));
  
    /* Call __enable_execute_stack after writing onto the stack to make sure
@@ -9223,7 +9324,8 @@ sparc64_initialize_trampoline (rtx m_tramp, rtx fnaddr, rtx cxt)
        && sparc_cpu != PROCESSOR_NIAGARA
        && sparc_cpu != PROCESSOR_NIAGARA2
        && sparc_cpu != PROCESSOR_NIAGARA3
-      && sparc_cpu != PROCESSOR_NIAGARA4)
+      && sparc_cpu != PROCESSOR_NIAGARA4
+      && sparc_cpu != PROCESSOR_NIAGARA7)
      emit_insn (gen_flushdi (validize_mem (adjust_address (m_tramp, DImode, 8))));
  
    /* Call __enable_execute_stack after writing onto the stack to make sure
@@ -9419,7 +9521,8 @@ sparc_use_sched_lookahead (void)
        || sparc_cpu == PROCESSOR_NIAGARA2
        || sparc_cpu == PROCESSOR_NIAGARA3)
      return 0;
-  if (sparc_cpu == PROCESSOR_NIAGARA4)
+  if (sparc_cpu == PROCESSOR_NIAGARA4
+      || sparc_cpu == PROCESSOR_NIAGARA7)
      return 2;
    if (sparc_cpu == PROCESSOR_ULTRASPARC
        || sparc_cpu == PROCESSOR_ULTRASPARC3)
@@ -9442,6 +9545,7 @@ sparc_issue_rate (void)
      default:
        return 1;
      case PROCESSOR_NIAGARA4:
+    case PROCESSOR_NIAGARA7:
      case PROCESSOR_V9:
        /* Assume V9 processors are capable of at least dual-issue.  */
        return 2;
@@ -10007,6 +10111,34 @@ enum sparc_builtins
    SPARC_BUILTIN_XMULX,
    SPARC_BUILTIN_XMULXHI,
  
+  /* VIS 4.0 builtins.  */
+  SPARC_BUILTIN_FPADD8,
+  SPARC_BUILTIN_FPADDS8,
+  SPARC_BUILTIN_FPADDUS8,
+  SPARC_BUILTIN_FPADDUS16,
+  SPARC_BUILTIN_FPCMPLE8,
+  SPARC_BUILTIN_FPCMPGT8,
+  SPARC_BUILTIN_FPCMPULE16,
+  SPARC_BUILTIN_FPCMPUGT16,
+  SPARC_BUILTIN_FPCMPULE32,
+  SPARC_BUILTIN_FPCMPUGT32,
+  SPARC_BUILTIN_FPMAX8,
+  SPARC_BUILTIN_FPMAX16,
+  SPARC_BUILTIN_FPMAX32,
+  SPARC_BUILTIN_FPMAXU8,
+  SPARC_BUILTIN_FPMAXU16,
+  SPARC_BUILTIN_FPMAXU32,
+  SPARC_BUILTIN_FPMIN8,
+  SPARC_BUILTIN_FPMIN16,
+  SPARC_BUILTIN_FPMIN32,
+  SPARC_BUILTIN_FPMINU8,
+  SPARC_BUILTIN_FPMINU16,
+  SPARC_BUILTIN_FPMINU32,
+  SPARC_BUILTIN_FPSUB8,
+  SPARC_BUILTIN_FPSUBS8,
+  SPARC_BUILTIN_FPSUBUS8,
+  SPARC_BUILTIN_FPSUBUS16,
+  
    SPARC_BUILTIN_MAX
  };
  
@@ -10483,6 +10615,83 @@ sparc_vis_init_builtins (void)
        def_builtin_const ("__builtin_vis_xmulxhi", CODE_FOR_xmulxhi_vis,
                          SPARC_BUILTIN_XMULXHI, di_ftype_di_di);
      }
+
+  if (TARGET_VIS4)
+    {
+      def_builtin_const ("__builtin_vis_fpadd8", CODE_FOR_addv8qi3,
+                        SPARC_BUILTIN_FPADD8, v8qi_ftype_v8qi_v8qi);
+      def_builtin_const ("__builtin_vis_fpadds8", CODE_FOR_ssaddv8qi3,
+                        SPARC_BUILTIN_FPADDS8, v8qi_ftype_v8qi_v8qi);
+      def_builtin_const ("__builtin_vis_fpaddus8", CODE_FOR_usaddv8qi3,
+                        SPARC_BUILTIN_FPADDUS8, v8qi_ftype_v8qi_v8qi);
+      def_builtin_const ("__builtin_vis_fpaddus16", CODE_FOR_usaddv4hi3,
+                        SPARC_BUILTIN_FPADDUS16, v4hi_ftype_v4hi_v4hi);
+
+
+      if (TARGET_ARCH64)
+       {
+         def_builtin_const ("__builtin_vis_fpcmple8", CODE_FOR_fpcmple8di_vis,
+                            SPARC_BUILTIN_FPCMPLE8, di_ftype_v8qi_v8qi);
+         def_builtin_const ("__builtin_vis_fpcmpgt8", CODE_FOR_fpcmpgt8di_vis,
+                            SPARC_BUILTIN_FPCMPGT8, di_ftype_v8qi_v8qi);
+         def_builtin_const ("__builtin_vis_fpcmpule16", CODE_FOR_fpcmpule16di_vis,
+                            SPARC_BUILTIN_FPCMPULE16, di_ftype_v4hi_v4hi);
+         def_builtin_const ("__builtin_vis_fpcmpugt16", CODE_FOR_fpcmpugt16di_vis,
+                            SPARC_BUILTIN_FPCMPUGT16, di_ftype_v4hi_v4hi);
+         def_builtin_const ("__builtin_vis_fpcmpule32", CODE_FOR_fpcmpule32di_vis,
+                            SPARC_BUILTIN_FPCMPULE32, di_ftype_v2si_v2si);
+         def_builtin_const ("__builtin_vis_fpcmpugt32", CODE_FOR_fpcmpugt32di_vis,
+                            SPARC_BUILTIN_FPCMPUGT32, di_ftype_v2si_v2si);
+       }
+      else
+       {
+         def_builtin_const ("__builtin_vis_fpcmple8", CODE_FOR_fpcmple8si_vis,
+                            SPARC_BUILTIN_FPCMPLE8, si_ftype_v8qi_v8qi);
+         def_builtin_const ("__builtin_vis_fpcmpgt8", CODE_FOR_fpcmpgt8si_vis,
+                            SPARC_BUILTIN_FPCMPGT8, si_ftype_v8qi_v8qi);
+         def_builtin_const ("__builtin_vis_fpcmpule16", CODE_FOR_fpcmpule16si_vis,
+                            SPARC_BUILTIN_FPCMPULE16, si_ftype_v4hi_v4hi);
+         def_builtin_const ("__builtin_vis_fpcmpugt16", CODE_FOR_fpcmpugt16si_vis,
+                            SPARC_BUILTIN_FPCMPUGT16, si_ftype_v4hi_v4hi);
+         def_builtin_const ("__builtin_vis_fpcmpule32", CODE_FOR_fpcmpule32si_vis,
+                            SPARC_BUILTIN_FPCMPULE32, di_ftype_v2si_v2si);
+         def_builtin_const ("__builtin_vis_fpcmpugt32", CODE_FOR_fpcmpugt32si_vis,
+                            SPARC_BUILTIN_FPCMPUGT32, di_ftype_v2si_v2si);
+       }
+      
+      def_builtin_const ("__builtin_vis_fpmax8", CODE_FOR_maxv8qi3,
+                        SPARC_BUILTIN_FPMAX8, v8qi_ftype_v8qi_v8qi);
+      def_builtin_const ("__builtin_vis_fpmax16", CODE_FOR_maxv4hi3,
+                        SPARC_BUILTIN_FPMAX16, v4hi_ftype_v4hi_v4hi);
+      def_builtin_const ("__builtin_vis_fpmax32", CODE_FOR_maxv2si3,
+                        SPARC_BUILTIN_FPMAX32, v2si_ftype_v2si_v2si);
+      def_builtin_const ("__builtin_vis_fpmaxu8", CODE_FOR_maxuv8qi3,
+                        SPARC_BUILTIN_FPMAXU8, v8qi_ftype_v8qi_v8qi);
+      def_builtin_const ("__builtin_vis_fpmaxu16", CODE_FOR_maxuv4hi3,
+                        SPARC_BUILTIN_FPMAXU16, v4hi_ftype_v4hi_v4hi);
+      def_builtin_const ("__builtin_vis_fpmaxu32", CODE_FOR_maxuv2si3,
+                        SPARC_BUILTIN_FPMAXU32, v2si_ftype_v2si_v2si);
+      def_builtin_const ("__builtin_vis_fpmin8", CODE_FOR_minv8qi3,
+                        SPARC_BUILTIN_FPMIN8, v8qi_ftype_v8qi_v8qi);
+      def_builtin_const ("__builtin_vis_fpmin16", CODE_FOR_minv4hi3,
+                        SPARC_BUILTIN_FPMIN16, v4hi_ftype_v4hi_v4hi);
+      def_builtin_const ("__builtin_vis_fpmin32", CODE_FOR_minv2si3,
+                        SPARC_BUILTIN_FPMIN32, v2si_ftype_v2si_v2si);
+      def_builtin_const ("__builtin_vis_fpminu8", CODE_FOR_minuv8qi3,
+                        SPARC_BUILTIN_FPMINU8, v8qi_ftype_v8qi_v8qi);
+      def_builtin_const ("__builtin_vis_fpminu16", CODE_FOR_minuv4hi3,
+                        SPARC_BUILTIN_FPMINU16, v4hi_ftype_v4hi_v4hi);
+      def_builtin_const ("__builtin_vis_fpminu32", CODE_FOR_minuv2si3,
+                        SPARC_BUILTIN_FPMINU32, v2si_ftype_v2si_v2si);
+      def_builtin_const ("__builtin_vis_fpsub8", CODE_FOR_subv8qi3,
+                        SPARC_BUILTIN_FPSUB8, v8qi_ftype_v8qi_v8qi);
+      def_builtin_const ("__builtin_vis_fpsubs8", CODE_FOR_sssubv8qi3,
+                        SPARC_BUILTIN_FPSUBS8, v8qi_ftype_v8qi_v8qi);
+      def_builtin_const ("__builtin_vis_fpsubus8", CODE_FOR_ussubv8qi3,
+                        SPARC_BUILTIN_FPSUBUS8, v8qi_ftype_v8qi_v8qi);
+      def_builtin_const ("__builtin_vis_fpsubus16", CODE_FOR_ussubv4hi3,
+                        SPARC_BUILTIN_FPSUBUS16, v4hi_ftype_v4hi_v4hi);
+    }
  }
  
  /* Implement TARGET_BUILTIN_DECL hook.  */
@@ -11042,7 +11251,8 @@ sparc_register_move_cost (machine_mode mode ATTRIBUTE_UNUSED,
           || sparc_cpu == PROCESSOR_NIAGARA
           || sparc_cpu == PROCESSOR_NIAGARA2
           || sparc_cpu == PROCESSOR_NIAGARA3
-         || sparc_cpu == PROCESSOR_NIAGARA4)
+         || sparc_cpu == PROCESSOR_NIAGARA4
+         || sparc_cpu == PROCESSOR_NIAGARA7)
         return 12;
  
        return 6;
diff --git a/gcc/config/sparc/sparc.h b/gcc/config/sparc/sparc.h

index ebfe87d..d91496a 100644 (file)
--- a/gcc/config/sparc/sparc.h
+++ b/gcc/config/sparc/sparc.h
@@ -142,6 +142,7 @@ extern enum cmodel sparc_cmodel;
  #define TARGET_CPU_niagara2    14
  #define TARGET_CPU_niagara3    15
  #define TARGET_CPU_niagara4    16
+#define TARGET_CPU_niagara7    19
  
  #if TARGET_CPU_DEFAULT == TARGET_CPU_v9 \
   || TARGET_CPU_DEFAULT == TARGET_CPU_ultrasparc \
@@ -149,7 +150,8 @@ extern enum cmodel sparc_cmodel;
   || TARGET_CPU_DEFAULT == TARGET_CPU_niagara \
   || TARGET_CPU_DEFAULT == TARGET_CPU_niagara2 \
   || TARGET_CPU_DEFAULT == TARGET_CPU_niagara3 \
- || TARGET_CPU_DEFAULT == TARGET_CPU_niagara4
+ || TARGET_CPU_DEFAULT == TARGET_CPU_niagara4 \
+ || TARGET_CPU_DEFAULT == TARGET_CPU_niagara7
  
  #define CPP_CPU32_DEFAULT_SPEC ""
  #define ASM_CPU32_DEFAULT_SPEC ""
@@ -186,6 +188,10 @@ extern enum cmodel sparc_cmodel;
  #define CPP_CPU64_DEFAULT_SPEC "-D__sparc_v9__"
  #define ASM_CPU64_DEFAULT_SPEC AS_NIAGARA4_FLAG
  #endif
+#if TARGET_CPU_DEFAULT == TARGET_CPU_niagara7
+#define CPP_CPU64_DEFAULT_SPEC "-D__sparc_v9__"
+#define ASM_CPU64_DEFAULT_SPEC AS_NIAGARA7_FLAG
+#endif
  
  #else
  
@@ -288,6 +294,7 @@ extern enum cmodel sparc_cmodel;
  %{mcpu=niagara2:-D__sparc_v9__} \
  %{mcpu=niagara3:-D__sparc_v9__} \
  %{mcpu=niagara4:-D__sparc_v9__} \
+%{mcpu=niagara7:-D__sparc_v9__} \
  %{!mcpu*:%(cpp_cpu_default)} \
  "
  #define CPP_ARCH32_SPEC ""
@@ -339,6 +346,7 @@ extern enum cmodel sparc_cmodel;
  %{mcpu=niagara2:%{!mv8plus:-Av9b}} \
  %{mcpu=niagara3:%{!mv8plus:-Av9" AS_NIAGARA3_FLAG "}} \
  %{mcpu=niagara4:%{!mv8plus:" AS_NIAGARA4_FLAG "}} \
+%{mcpu=niagara7:%{!mv8plus:" AS_NIAGARA7_FLAG "}} \
  %{!mcpu*:%(asm_cpu_default)} \
  "
  
@@ -1777,6 +1785,12 @@ extern int sparc_indent_opcode;
  #define AS_NIAGARA4_FLAG "-Av9" AS_NIAGARA3_FLAG
  #endif
  
+#ifdef HAVE_AS_SPARC5_VIS4
+#define AS_NIAGARA7_FLAG "-xarch=sparc5"
+#else
+#define AS_NIAGARA7_FLAG AS_NIAGARA4_FLAG
+#endif
+
  #ifdef HAVE_AS_LEON
  #define AS_LEON_FLAG "-Aleon"
  #define AS_LEONV7_FLAG "-Aleon"
diff --git a/gcc/config/sparc/sparc.md b/gcc/config/sparc/sparc.md

index 56d4f63..29e4966 100644 (file)
--- a/gcc/config/sparc/sparc.md
+++ b/gcc/config/sparc/sparc.md
@@ -234,7 +234,8 @@
     niagara,
     niagara2,
     niagara3,
-   niagara4"
+   niagara4,
+   niagara7"
    (const (symbol_ref "sparc_cpu_attr")))
  
  ;; Attribute for the instruction set.
@@ -247,7 +248,7 @@
          (symbol_ref "TARGET_SPARCLET") (const_string "sparclet")]
         (const_string "v7"))))
  
-(define_attr "cpu_feature" "none,fpu,fpunotv9,v9,vis,vis3" (const_string "none"))
+(define_attr "cpu_feature" "none,fpu,fpunotv9,v9,vis,vis3,vis4" (const_string "none"))
  
  (define_attr "enabled" ""
    (cond [(eq_attr "cpu_feature" "none") (const_int 1)
@@ -255,7 +256,8 @@
          (eq_attr "cpu_feature" "fpunotv9") (symbol_ref "TARGET_FPU && ! TARGET_V9")
           (eq_attr "cpu_feature" "v9") (symbol_ref "TARGET_V9")
           (eq_attr "cpu_feature" "vis") (symbol_ref "TARGET_VIS")
-         (eq_attr "cpu_feature" "vis3") (symbol_ref "TARGET_VIS3")]
+         (eq_attr "cpu_feature" "vis3") (symbol_ref "TARGET_VIS3")
+         (eq_attr "cpu_feature" "vis4") (symbol_ref "TARGET_VIS4")]
          (const_int 0)))
  
  ;; Insn type.
@@ -274,7 +276,7 @@
     fga,visl,vismv,fgm_pack,fgm_mul,pdist,pdistn,edge,edgen,gsr,array,
     cmove,
     ialuX,
-   multi,savew,flushw,iflush,trap"
+   multi,savew,flushw,iflush,trap,lzd"
    (const_string "ialu"))
  
  ;; True if branch/call has empty delay slot and will emit a nop in it
@@ -476,6 +478,10 @@
            (const_string "true")
         ] (const_string "false")))
  
+;; True if the instruction executes in the V3 pipeline, in M7 and
+;; later processors.
+(define_attr "v3pipe" "false,true" (const_string "false"))
+
  (define_delay (eq_attr "type" "call")
    [(eq_attr "in_call_delay" "true") (nil) (nil)])
  
@@ -504,6 +510,7 @@
  (include "niagara.md")
  (include "niagara2.md")
  (include "niagara4.md")
+(include "niagara7.md")
  
  
  ;; Operand and operator predicates and constraints
@@ -1457,6 +1464,7 @@
     fzeros\t%0
     fones\t%0"
    [(set_attr "type" "*,*,load,store,vismv,vismv,fpmove,fpload,fpstore,visl,visl")
+   (set_attr "v3pipe" "*,*,*,*,true,true,*,*,*,true,true")
     (set_attr "cpu_feature" "*,*,*,*,vis3,vis3,*,*,*,vis,vis")])
  
  (define_insn "*movsi_lo_sum"
@@ -1622,6 +1630,7 @@
     fzero\t%0
     fone\t%0"
    [(set_attr "type" "store,store,store,load,*,*,*,*,fpstore,fpload,*,*,fpmove,*,*,*,fpload,fpstore,visl,visl")
+   (set_attr "v3pipe" "false, false, false, false,false,false,false,false,false,false,false,false,false,false,false,false,false,false, true, true")
     (set_attr "length" "*,2,*,*,2,2,2,2,*,*,2,2,*,2,2,2,*,*,*,*")
     (set_attr "fptype" "*,*,*,*,*,*,*,*,*,*,*,*,double,*,*,*,*,*,double,double")
     (set_attr "cpu_feature" "v9,*,*,*,*,*,*,*,fpu,fpu,fpu,fpu,v9,fpunotv9,vis3,vis3,fpu,fpu,vis,vis")])
@@ -1645,6 +1654,7 @@
     fzero\t%0
     fone\t%0"
    [(set_attr "type" "*,*,load,store,vismv,vismv,fpmove,fpload,fpstore,visl,visl")
+   (set_attr "v3pipe" "*, *, *, *, *, *, *, *, *, true, true")
     (set_attr "fptype" "*,*,*,*,*,*,double,*,*,double,double")
     (set_attr "cpu_feature" "*,*,*,*,vis3,vis3,*,*,*,vis,vis")])
  
@@ -2208,6 +2218,7 @@
      }
  }
    [(set_attr "type" "visl,visl,fpmove,*,*,*,vismv,vismv,fpload,load,fpstore,store")
+   (set_attr "v3pipe" "true, true, *, *, *, *, true, true, *, *, *, *")
     (set_attr "cpu_feature" "vis,vis,fpu,*,*,*,vis3,vis3,fpu,*,fpu,*")])
  
  ;; The following 3 patterns build SFmode constants in integer registers.
@@ -2276,6 +2287,7 @@
    #
    #"
    [(set_attr "type" "visl,visl,fpmove,*,*,*,fpload,store,fpstore,load,store,*,*,*,*")
+   (set_attr "v3pipe" "true, true, *, *, *, *, *, *, *, *, *, *, *, *, *")
     (set_attr "length" "*,*,*,2,2,2,*,*,*,*,*,2,2,2,2")
     (set_attr "fptype" "double,double,double,*,*,*,*,*,*,*,*,*,*,*,*")
     (set_attr "cpu_feature" "vis,vis,v9,fpunotv9,vis3,vis3,fpu,v9,fpu,*,*,fpu,*,*,fpu")])
@@ -2299,6 +2311,7 @@
    stx\t%r1, %0
    #"
    [(set_attr "type" "visl,visl,fpmove,vismv,vismv,load,store,*,load,store,*")
+   (set_attr "v3pipe" "true, true, *, *, *, *, *, *, *, *, *")
     (set_attr "length" "*,*,*,*,*,*,*,*,*,*,2")
     (set_attr "fptype" "double,double,double,double,double,*,*,*,*,*,*")
     (set_attr "cpu_feature" "vis,vis,fpu,vis3,vis3,fpu,fpu,*,*,*,*")])
@@ -2980,6 +2993,7 @@
     lduw\t%1, %0
     movstouw\t%1, %0"
    [(set_attr "type" "shift,load,*")
+   (set_attr "v3pipe" "*,*,true")
     (set_attr "cpu_feature" "*,*,vis3")])
  
  (define_insn_and_split "*zero_extendsidi2_insn_sp32"
@@ -3294,6 +3308,7 @@
    ldsw\t%1, %0
    movstosw\t%1, %0"
    [(set_attr "type" "shift,sload,*")
+   (set_attr "v3pipe" "*,*,true")
     (set_attr "us3load_type" "*,3cycle,*")
     (set_attr "cpu_feature" "*,*,vis3")])
  
@@ -6770,7 +6785,8 @@
    [(set (match_operand:DI 0 "register_operand" "=r")
          (clz:DI (match_operand:DI 1 "register_operand" "r")))]
    "TARGET_VIS3 && TARGET_ARCH64"
-  "lzd\t%1, %0")
+  "lzd\t%1, %0"
+  [(set_attr "type" "lzd")])
  
  (define_insn "clzdi_v8plus"
    [(set (match_operand:DI 0 "register_operand" "=r")
@@ -6811,7 +6827,8 @@
          (truncate:SI
            (clz:DI (match_operand:DI 1 "register_operand" "r"))))]
    "TARGET_VIS3 && TARGET_ARCH64"
-  "lzd\t%1, %0")
+  "lzd\t%1, %0"
+  [(set_attr "type" "lzd")])
  
  (define_insn "clzsi_v8plus"
    [(set (match_operand:SI 0 "register_operand" "=r")
@@ -7777,7 +7794,7 @@
  (define_mode_iterator VM64 [V1DI V2SI V4HI V8QI])
  (define_mode_iterator VMALL [V1SI V2HI V4QI V1DI V2SI V4HI V8QI])
  
-(define_mode_attr vbits [(V2SI "32") (V4HI "16") (V1SI "32s") (V2HI "16s")])
+(define_mode_attr vbits [(V2SI "32") (V4HI "16") (V1SI "32s") (V2HI "16s") (V8QI "8")])
  (define_mode_attr vconstr [(V1SI "f") (V2HI "f") (V4QI "f")
                            (V1DI "e") (V2SI "e") (V4HI "e") (V8QI "e")])
  (define_mode_attr vfptype [(V1SI "single") (V2HI "single") (V4QI "single")
@@ -7812,6 +7829,7 @@
    movstouw\t%1, %0
    movwtos\t%1, %0"
    [(set_attr "type" "visl,visl,vismv,fpload,fpstore,store,load,store,*,vismv,vismv")
+   (set_attr "v3pipe" "true,true,true,false,false,false,false,false,false,true,true")
     (set_attr "cpu_feature" "vis,vis,vis,*,*,*,*,*,*,vis3,vis3")])
  
  (define_insn "*mov<VM64:mode>_insn_sp64"
@@ -7834,6 +7852,7 @@
    movxtod\t%1, %0
    mov\t%1, %0"
    [(set_attr "type" "visl,visl,vismv,fpload,fpstore,store,load,store,vismv,vismv,*")
+   (set_attr "v3pipe" "true, true, true, false, false, false, false, false, false, false, false")
     (set_attr "cpu_feature" "vis,vis,vis,*,*,*,*,*,vis3,vis3,*")])
  
  (define_insn "*mov<VM64:mode>_insn_sp32"
@@ -7857,6 +7876,7 @@
    #
    #"
    [(set_attr "type" "visl,visl,vismv,*,*,fpload,fpstore,store,load,store,*,*")
+   (set_attr "v3pipe" "true, true, true, false, false, false, false, false, false, false, false, false")
     (set_attr "length" "*,*,*,2,2,*,*,*,*,*,2,2")
     (set_attr "cpu_feature" "vis,vis,vis,vis3,vis3,*,*,*,*,*,*,*")])
  
@@ -7936,7 +7956,8 @@
    "TARGET_VIS"
    "fp<plusminus_insn><vbits>\t%1, %2, %0"
    [(set_attr "type" "fga")
-   (set_attr "fptype" "<vfptype>")])
+   (set_attr "fptype" "<vfptype>")
+   (set_attr "v3pipe" "true")])
  
  (define_mode_iterator VL [V1SI V2HI V4QI V1DI V2SI V4HI V8QI])
  (define_mode_attr vlsuf [(V1SI "s") (V2HI "s") (V4QI "s")
@@ -7952,6 +7973,7 @@
    "TARGET_VIS"
    "f<vlinsn><vlsuf>\t%1, %2, %0"
    [(set_attr "type" "visl")
+   (set_attr "v3pipe" "true")
     (set_attr "fptype" "<vfptype>")])
  
  (define_insn "*not_<code><mode>3"
@@ -7961,6 +7983,7 @@
    "TARGET_VIS"
    "f<vlninsn><vlsuf>\t%1, %2, %0"
    [(set_attr "type" "visl")
+   (set_attr "v3pipe" "true")
     (set_attr "fptype" "<vfptype>")])
  
  ;; (ior (not (op1)) (not (op2))) is the canonical form of NAND.
@@ -7971,6 +7994,7 @@
    "TARGET_VIS"
    "fnand<vlsuf>\t%1, %2, %0"
    [(set_attr "type" "visl")
+   (set_attr "v3pipe" "true")
     (set_attr "fptype" "<vfptype>")])
  
  (define_code_iterator vlnotop [ior and])
@@ -7982,6 +8006,7 @@
    "TARGET_VIS"
    "f<vlinsn>not1<vlsuf>\t%1, %2, %0"
    [(set_attr "type" "visl")
+   (set_attr "v3pipe" "true")
     (set_attr "fptype" "<vfptype>")])
  
  (define_insn "*<code>_not2<mode>_vis"
@@ -7991,6 +8016,7 @@
    "TARGET_VIS"
    "f<vlinsn>not2<vlsuf>\t%1, %2, %0"
    [(set_attr "type" "visl")
+   (set_attr "v3pipe" "true")
     (set_attr "fptype" "<vfptype>")])
  
  (define_insn "one_cmpl<mode>2"
@@ -7999,6 +8025,7 @@
    "TARGET_VIS"
    "fnot1<vlsuf>\t%1, %0"
    [(set_attr "type" "visl")
+   (set_attr "v3pipe" "true")
     (set_attr "fptype" "<vfptype>")])
  
  ;; Hard to generate VIS instructions.  We have builtins for these.
@@ -8225,7 +8252,8 @@
    "TARGET_VIS"
    "faligndata\t%1, %2, %0"
    [(set_attr "type" "fga")
-   (set_attr "fptype" "double")])
+   (set_attr "fptype" "double")
+   (set_attr "v3pipe" "true")])
  
  (define_insn "alignaddrsi_vis"
    [(set (match_operand:SI 0 "register_operand" "=r")
@@ -8235,7 +8263,8 @@
          (zero_extend:DI (plus:SI (match_dup 1) (match_dup 2))))]
    "TARGET_VIS"
    "alignaddr\t%r1, %r2, %0"
-  [(set_attr "type" "gsr")])
+  [(set_attr "type" "gsr")
+   (set_attr "v3pipe" "true")])
  
  (define_insn "alignaddrdi_vis"
    [(set (match_operand:DI 0 "register_operand" "=r")
@@ -8245,7 +8274,8 @@
          (plus:DI (match_dup 1) (match_dup 2)))]
    "TARGET_VIS"
    "alignaddr\t%r1, %r2, %0"
-  [(set_attr "type" "gsr")])
+  [(set_attr "type" "gsr")
+   (set_attr "v3pipe" "true")])
  
  (define_insn "alignaddrlsi_vis"
    [(set (match_operand:SI 0 "register_operand" "=r")
@@ -8256,7 +8286,8 @@
                  (const_int 7)))]
    "TARGET_VIS"
    "alignaddrl\t%r1, %r2, %0"
-  [(set_attr "type" "gsr")])
+  [(set_attr "type" "gsr")
+   (set_attr "v3pipe" "true")])
  
  (define_insn "alignaddrldi_vis"
    [(set (match_operand:DI 0 "register_operand" "=r")
@@ -8267,7 +8298,8 @@
                  (const_int 7)))]
    "TARGET_VIS"
    "alignaddrl\t%r1, %r2, %0"
-  [(set_attr "type" "gsr")])
+  [(set_attr "type" "gsr")
+   (set_attr "v3pipe" "true")])
  
  (define_insn "pdist_vis"
    [(set (match_operand:DI 0 "register_operand" "=e")
@@ -8360,6 +8392,17 @@
    "TARGET_VIS"
    "fcmp<code><GCM:gcm_name>\t%1, %2, %0"
    [(set_attr "type" "visl")
+   (set_attr "v3pipe" "true")
+   (set_attr "fptype" "double")])
+
+(define_insn "fpcmp<code>8<P:mode>_vis"
+  [(set (match_operand:P 0 "register_operand" "=r")
+       (unspec:P [(gcond:V8QI (match_operand:V8QI 1 "register_operand" "e")
+                              (match_operand:V8QI 2 "register_operand" "e"))]
+        UNSPEC_FCMP))]
+  "TARGET_VIS4"
+  "fpcmp<code>8\t%1, %2, %0"
+  [(set_attr "type" "visl")
     (set_attr "fptype" "double")])
  
  (define_expand "vcond<mode><mode>"
@@ -8427,7 +8470,8 @@
          (plus:DI (match_dup 1) (match_dup 2)))]
    "TARGET_VIS2"
    "bmask\t%r1, %r2, %0"
-  [(set_attr "type" "array")])
+  [(set_attr "type" "array")
+   (set_attr "v3pipe" "true")])
  
  (define_insn "bmasksi_vis"
    [(set (match_operand:SI 0 "register_operand" "=r")
@@ -8437,7 +8481,8 @@
          (zero_extend:DI (plus:SI (match_dup 1) (match_dup 2))))]
    "TARGET_VIS2"
    "bmask\t%r1, %r2, %0"
-  [(set_attr "type" "array")])
+  [(set_attr "type" "array")
+   (set_attr "v3pipe" "true")])
  
  (define_insn "bshuffle<VM64:mode>_vis"
    [(set (match_operand:VM64 0 "register_operand" "=e")
@@ -8448,7 +8493,8 @@
    "TARGET_VIS2"
    "bshuffle\t%1, %2, %0"
    [(set_attr "type" "fga")
-   (set_attr "fptype" "double")])
+   (set_attr "fptype" "double")
+   (set_attr "v3pipe" "true")])
  
  ;; The rtl expanders will happily convert constant permutations on other
  ;; modes down to V8QI.  Rely on this to avoid the complexity of the byte
@@ -8550,7 +8596,8 @@
                     UNSPEC_CMASK8))]
    "TARGET_VIS3"
    "cmask8\t%r0"
-  [(set_attr "type" "fga")])
+  [(set_attr "type" "fga")
+   (set_attr "v3pipe" "true")])
  
  (define_insn "cmask16<P:mode>_vis"
    [(set (reg:DI GSR_REG)
@@ -8559,7 +8606,8 @@
                     UNSPEC_CMASK16))]
    "TARGET_VIS3"
    "cmask16\t%r0"
-  [(set_attr "type" "fga")])
+  [(set_attr "type" "fga")
+   (set_attr "v3pipe" "true")])
  
  (define_insn "cmask32<P:mode>_vis"
    [(set (reg:DI GSR_REG)
@@ -8568,7 +8616,8 @@
                     UNSPEC_CMASK32))]
    "TARGET_VIS3"
    "cmask32\t%r0"
-  [(set_attr "type" "fga")])
+  [(set_attr "type" "fga")
+   (set_attr "v3pipe" "true")])
  
  (define_insn "fchksm16_vis"
    [(set (match_operand:V4HI 0 "register_operand" "=e")
@@ -8601,6 +8650,7 @@
    "TARGET_VIS3"
    "pdistn\t%1, %2, %0"
    [(set_attr "type" "pdistn")
+   (set_attr "v3pipe" "true")
     (set_attr "fptype" "double")])
  
  (define_insn "fmean16_vis"
@@ -8628,6 +8678,14 @@
    "fp<plusminus_insn>64\t%1, %2, %0"
    [(set_attr "type" "fga")])
  
+(define_insn "<plusminus_insn>v8qi3"
+  [(set (match_operand:V8QI 0 "register_operand" "=e")
+        (plusminus:V8QI (match_operand:V8QI 1 "register_operand" "e")
+                        (match_operand:V8QI 2 "register_operand" "e")))]
+  "TARGET_VIS4"
+  "fp<plusminus_insn>8\t%1, %2, %0"
+  [(set_attr "type" "fga")])
+
  (define_mode_iterator VASS [V4HI V2SI V2HI V1SI])
  (define_code_iterator vis3_addsub_ss [ss_plus ss_minus])
  (define_code_attr vis3_addsub_ss_insn
@@ -8641,8 +8699,63 @@
                               (match_operand:VASS 2 "register_operand" "<vconstr>")))]
    "TARGET_VIS3"
    "<vis3_addsub_ss_insn><vbits>\t%1, %2, %0"
+  [(set_attr "type" "fga")
+   (set_attr "v3pipe" "true")])
+
+(define_mode_iterator VMMAX [V8QI V4HI V2SI])
+(define_code_iterator vis4_minmax [smin smax])
+(define_code_attr vis4_minmax_insn
+  [(smin "fpmin") (smax "fpmax")])
+(define_code_attr vis4_minmax_patname
+  [(smin "min") (smax "max")])
+
+(define_insn "<vis4_minmax_patname><mode>3"
+  [(set (match_operand:VMMAX 0 "register_operand" "=<vconstr>")
+        (vis4_minmax:VMMAX (match_operand:VMMAX 1 "register_operand" "<vconstr>")
+                           (match_operand:VMMAX 2 "register_operand" "<vconstr>")))]
+  "TARGET_VIS4"
+  "<vis4_minmax_insn><vbits>\t%1, %2, %0"
+  [(set_attr "type" "fga")])
+
+(define_code_iterator vis4_uminmax [umin umax])
+(define_code_attr vis4_uminmax_insn
+  [(umin "fpminu") (umax "fpmaxu")])
+(define_code_attr vis4_uminmax_patname
+ [(umin "minu") (umax "maxu")])
+
+(define_insn "<vis4_uminmax_patname><mode>3"
+  [(set (match_operand:VMMAX 0 "register_operand" "=<vconstr>")
+        (vis4_uminmax:VMMAX (match_operand:VMMAX 1 "register_operand" "<vconstr>")
+                            (match_operand:VMMAX 2 "register_operand" "<vconstr>")))]
+  "TARGET_VIS4"
+  "<vis4_uminmax_insn><vbits>\t%1, %2, %0"
    [(set_attr "type" "fga")])
  
+;; The use of vis3_addsub_ss_patname in the VIS4 instruction below is
+;; intended.
+(define_insn "<vis3_addsub_ss_patname>v8qi3"
+  [(set (match_operand:V8QI 0 "register_operand" "=e")
+        (vis3_addsub_ss:V8QI (match_operand:V8QI 1 "register_operand" "e")
+                             (match_operand:V8QI 2 "register_operand" "e")))]
+  "TARGET_VIS4"
+  "<vis3_addsub_ss_insn>8\t%1, %2, %0"
+  [(set_attr "type" "fga")])
+
+(define_mode_iterator VAUS [V4HI V8QI])
+(define_code_iterator vis4_addsub_us [us_plus us_minus])
+(define_code_attr vis4_addsub_us_insn
+  [(us_plus "fpaddus") (us_minus "fpsubus")])
+(define_code_attr vis4_addsub_us_patname
+  [(us_plus "usadd") (us_minus "ussub")])
+
+(define_insn "<vis4_addsub_us_patname><mode>3"
+ [(set (match_operand:VAUS 0 "register_operand" "=<vconstr>")
+       (vis4_addsub_us:VAUS (match_operand:VAUS 1 "register_operand" "<vconstr>")
+                            (match_operand:VAUS 2 "register_operand" "<vconstr>")))]
+ "TARGET_VIS4"
+ "<vis4_addsub_us_insn><vbits>\t%1, %2, %0"
+ [(set_attr "type" "fga")])
+
  (define_insn "fucmp<code>8<P:mode>_vis"
    [(set (match_operand:P 0 "register_operand" "=r")
         (unspec:P [(gcond:V8QI (match_operand:V8QI 1 "register_operand" "e")
@@ -8650,7 +8763,18 @@
          UNSPEC_FUCMP))]
    "TARGET_VIS3"
    "fucmp<code>8\t%1, %2, %0"
-  [(set_attr "type" "visl")])
+  [(set_attr "type" "visl")
+   (set_attr "v3pipe" "true")])
+
+(define_insn "fpcmpu<code><GCM:gcm_name><P:mode>_vis"
+  [(set (match_operand:P 0 "register_operand" "=r")
+       (unspec:P [(gcond:GCM (match_operand:GCM 1 "register_operand" "e")
+                             (match_operand:GCM 2 "register_operand" "e"))]
+        UNSPEC_FUCMP))]
+  "TARGET_VIS4"
+  "fpcmpu<code><GCM:gcm_name>\t%1, %2, %0"
+  [(set_attr "type" "visl")
+   (set_attr "fptype" "double")])
  
  (define_insn "*naddsf3"
    [(set (match_operand:SF 0 "register_operand" "=f")
diff --git a/gcc/config/sparc/sparc.opt b/gcc/config/sparc/sparc.opt

index 25eaa1a..13d4151 100644 (file)
--- a/gcc/config/sparc/sparc.opt
+++ b/gcc/config/sparc/sparc.opt
@@ -73,6 +73,10 @@ mvis3
  Target Report Mask(VIS3)
  Use UltraSPARC Visual Instruction Set version 3.0 extensions.
  
+mvis4
+Target Report Mask(VIS4)
+Use UltraSPARC Visual Instruction Set version 4.0 extensions.
+
  mcbcond
  Target Report Mask(CBCOND)
  Use UltraSPARC Compare-and-Branch extensions.
@@ -194,6 +198,9 @@ Enum(sparc_processor_type) String(niagara3) Value(PROCESSOR_NIAGARA3)
  EnumValue
  Enum(sparc_processor_type) String(niagara4) Value(PROCESSOR_NIAGARA4)
  
+EnumValue
+Enum(sparc_processor_type) String(niagara7) Value(PROCESSOR_NIAGARA7)
+
  mcmodel=
  Target RejectNegative Joined Var(sparc_cmodel_string)
  Use given SPARC-V9 code model.
diff --git a/gcc/config/sparc/visintrin.h b/gcc/config/sparc/visintrin.h

index 51ef739..8b80cc1 100644 (file)
--- a/gcc/config/sparc/visintrin.h
+++ b/gcc/config/sparc/visintrin.h
@@ -704,6 +704,192 @@ __vis_xmulxhi (__i64 __A, __i64 __B)
  
  #endif /* __VIS__ >= 0x300 */
  
+#if __VIS__ >= 0x400
+
+extern __inline __v8qi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpadd8 (__v8qi __A, __v8qi __B)
+{
+  return __builtin_vis_fpadd8 (__A, __B);
+}
+
+extern __inline __v8qi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpadds8 (__v8qi __A, __v8qi __B)
+{
+  return __builtin_vis_fpadds8 (__A, __B);
+}
+
+extern __inline __v8qi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpaddus8 (__v8qi __A, __v8qi __B)
+{
+  return __builtin_vis_fpaddus8 (__A, __B);
+}
+
+extern __inline __v4hi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpaddus16 (__v4hi __A, __v4hi __B)
+{
+  return __builtin_vis_fpaddus16 (__A, __B);
+}
+
+extern __inline long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpcmple8 (__v8qi __A, __v8qi __B)
+{
+  return __builtin_vis_fpcmple8 (__A, __B);
+}
+
+extern __inline long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpcmpgt8 (__v8qi __A, __v8qi __B)
+{
+  return __builtin_vis_fpcmpgt8 (__A, __B);
+}
+
+extern __inline long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpcmpule16 (__v4hi __A, __v4hi __B)
+{
+  return __builtin_vis_fpcmpule16 (__A, __B);
+}
+
+extern __inline long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpcmpugt16 (__v4hi __A, __v4hi __B)
+{
+  return __builtin_vis_fpcmpugt16 (__A, __B);
+}
+
+extern __inline long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpcmpule32 (__v2si __A, __v2si __B)
+{
+  return __builtin_vis_fpcmpule32 (__A, __B);
+}
+
+extern __inline long
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpcmpugt32 (__v2si __A, __v2si __B)
+{
+  return __builtin_vis_fpcmpugt32 (__A, __B);
+}
+
+extern __inline __v8qi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpmax8 (__v8qi __A, __v8qi __B)
+{
+  return __builtin_vis_fpmax8 (__A, __B);
+}
+
+extern __inline __v4hi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpmax16 (__v4hi __A, __v4hi __B)
+{
+  return __builtin_vis_fpmax16 (__A, __B);
+}
+
+extern __inline __v2si
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpmax32 (__v2si __A, __v2si __B)
+{
+  return __builtin_vis_fpmax32 (__A, __B);
+}
+
+extern __inline __v8qi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpmaxu8 (__v8qi __A, __v8qi __B)
+{
+  return __builtin_vis_fpmaxu8 (__A, __B);
+}
+
+extern __inline __v4hi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpmaxu16 (__v4hi __A, __v4hi __B)
+{
+  return __builtin_vis_fpmaxu16 (__A, __B);
+}
+
+extern __inline __v2si
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpmaxu32 (__v2si __A, __v2si __B)
+{
+  return __builtin_vis_fpmaxu32 (__A, __B);
+}
+
+extern __inline __v8qi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpmin8 (__v8qi __A, __v8qi __B)
+{
+  return __builtin_vis_fpmin8 (__A, __B);
+}
+
+extern __inline __v4hi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpmin16 (__v4hi __A, __v4hi __B)
+{
+  return __builtin_vis_fpmin16 (__A, __B);
+}
+
+extern __inline __v2si
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpmin32 (__v2si __A, __v2si __B)
+{
+  return __builtin_vis_fpmin32 (__A, __B);
+}
+
+extern __inline __v8qi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpminu8 (__v8qi __A, __v8qi __B)
+{
+  return __builtin_vis_fpminu8 (__A, __B);
+}
+
+extern __inline __v4hi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpminu16 (__v4hi __A, __v4hi __B)
+{
+  return __builtin_vis_fpminu16 (__A, __B);
+}
+
+extern __inline __v2si
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpminu32 (__v2si __A, __v2si __B)
+{
+  return __builtin_vis_fpminu32 (__A, __B);
+}
+
+extern __inline __v8qi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpsub8 (__v8qi __A, __v8qi __B)
+{
+  return __builtin_vis_fpsub8 (__A, __B);
+}
+
+extern __inline __v8qi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpsubs8 (__v8qi __A, __v8qi __B)
+{
+  return __builtin_vis_fpsubs8 (__A, __B);
+}
+
+extern __inline __v8qi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpsubus8 (__v8qi __A, __v8qi __B)
+{
+  return __builtin_vis_fpsubus8 (__A, __B);
+}
+
+extern __inline __v4hi
+__attribute__ ((__gnu_inline__, __always_inline__, __artificial__))
+__vis_fpsubus16 (__v4hi __A, __v4hi __B)
+{
+  return __builtin_vis_fpsubus16 (__A, __B);
+}
+
+#endif /* __VIS__ >= 0x400 */
+
  #endif /* __VIS__ */
  
  #endif  /* _VISINTRIN_H_INCLUDED */
diff --git a/gcc/config/visium/visium-protos.h b/gcc/config/visium/visium-protos.h

index 484d01e..9dcbc67 100644 (file)
--- a/gcc/config/visium/visium-protos.h
+++ b/gcc/config/visium/visium-protos.h
@@ -49,7 +49,8 @@ extern void visium_split_cbranch (enum rtx_code, rtx, rtx, rtx);
  extern const char *output_ubranch (rtx, rtx_insn *);
  extern const char *output_cbranch (rtx, enum rtx_code, enum machine_mode, int,
                                    rtx_insn *);
-extern void split_double_move (rtx *, enum machine_mode);
+extern void visium_split_double_move (rtx *, enum machine_mode);
+extern void visium_split_double_add (enum rtx_code, rtx, rtx, rtx);
  extern void visium_expand_copysign (rtx *, enum machine_mode);
  extern void visium_expand_int_cstore (rtx *, enum machine_mode);
  extern void visium_expand_fp_cstore (rtx *, enum machine_mode);
diff --git a/gcc/config/visium/visium.c b/gcc/config/visium/visium.c

index cd28f9b..6712fed 100644 (file)
--- a/gcc/config/visium/visium.c
+++ b/gcc/config/visium/visium.c
@@ -2026,7 +2026,7 @@ visium_rtx_costs (rtx x, machine_mode mode, int outer_code ATTRIBUTE_UNUSED,
  /* Split a double move of OPERANDS in MODE.  */
  
  void
-split_double_move (rtx *operands, enum machine_mode mode)
+visium_split_double_move (rtx *operands, enum machine_mode mode)
  {
    bool swap = false;
  
@@ -2076,14 +2076,74 @@ split_double_move (rtx *operands, enum machine_mode mode)
      }
  }
  
+/* Split a double addition or subtraction of operands.  */
+
+void
+visium_split_double_add (enum rtx_code code, rtx op0, rtx op1, rtx op2)
+{
+  rtx op3 = gen_lowpart (SImode, op0);
+  rtx op4 = gen_lowpart (SImode, op1);
+  rtx op5;
+  rtx op6 = gen_highpart (SImode, op0);
+  rtx op7 = (op1 == const0_rtx ? op1 : gen_highpart (SImode, op1));
+  rtx op8;
+  rtx x, pat, flags;
+
+  /* If operand #2 is a small constant, then its high part is null.  */
+  if (CONST_INT_P (op2))
+    {
+      HOST_WIDE_INT val = INTVAL (op2);
+
+      if (val < 0)
+       {
+         code = (code == MINUS ? PLUS : MINUS);
+         val = -val;
+       }
+
+      op5 = gen_int_mode (val, SImode);
+      op8 = const0_rtx;
+    }
+  else
+    {
+      op5 = gen_lowpart (SImode, op2);
+      op8 = gen_highpart (SImode, op2);
+    }
+
+  /* This is the {add,sub,neg}si3_insn_set_flags pattern.  */
+  if (op4 == const0_rtx)
+    x = gen_rtx_NEG (SImode, op5);
+  else
+    x = gen_rtx_fmt_ee (code, SImode, op4, op5);
+  pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
+  XVECEXP (pat, 0, 0) = gen_rtx_SET (op3, x);
+  flags = gen_rtx_REG (CC_NOOVmode, FLAGS_REGNUM);
+  x = gen_rtx_COMPARE (CC_NOOVmode, shallow_copy_rtx (x), const0_rtx);
+  XVECEXP (pat, 0, 1) = gen_rtx_SET (flags, x);
+  emit_insn (pat);
+
+  /* This is the plus_[plus_]sltu_flags or minus_[minus_]sltu_flags pattern.  */
+  if (op8 == const0_rtx)
+    x = op7;
+  else
+    x = gen_rtx_fmt_ee (code, SImode, op7, op8);
+  x = gen_rtx_fmt_ee (code, SImode, x, gen_rtx_LTU (SImode, flags, const0_rtx));
+  pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (2));
+  XVECEXP (pat, 0, 0) = gen_rtx_SET (op6, x);
+  flags = gen_rtx_REG (CCmode, FLAGS_REGNUM);
+  XVECEXP (pat, 0, 1) = gen_rtx_CLOBBER (VOIDmode, flags);
+  emit_insn (pat);
+
+  visium_flags_exposed = true;
+}
+
  /* Expand a copysign of OPERANDS in MODE.  */
  
  void
  visium_expand_copysign (rtx *operands, enum machine_mode mode)
  {
-  rtx dest = operands[0];
-  rtx op0 = operands[1];
-  rtx op1 = operands[2];
+  rtx op0 = operands[0];
+  rtx op1 = operands[1];
+  rtx op2 = operands[2];
    rtx mask = force_reg (SImode, GEN_INT (0x7fffffff));
    rtx x;
  
@@ -2091,37 +2151,37 @@ visium_expand_copysign (rtx *operands, enum machine_mode mode)
       the FPU on the MCM have a non-standard behavior wrt NaNs.  */
    gcc_assert (mode == SFmode);
  
-  /* First get all the non-sign bits of OP0.  */
-  if (GET_CODE (op0) == CONST_DOUBLE)
+  /* First get all the non-sign bits of op1.  */
+  if (GET_CODE (op1) == CONST_DOUBLE)
      {
-      if (real_isneg (CONST_DOUBLE_REAL_VALUE (op0)))
-       op0 = simplify_unary_operation (ABS, mode, op0, mode);
-      if (op0 != CONST0_RTX (mode))
+      if (real_isneg (CONST_DOUBLE_REAL_VALUE (op1)))
+       op1 = simplify_unary_operation (ABS, mode, op1, mode);
+      if (op1 != CONST0_RTX (mode))
         {
           long l;
-         REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op0), l);
-         op0 = force_reg (SImode, GEN_INT (trunc_int_for_mode (l, SImode)));
+         REAL_VALUE_TO_TARGET_SINGLE (*CONST_DOUBLE_REAL_VALUE (op1), l);
+         op1 = force_reg (SImode, gen_int_mode (l, SImode));
         }
      }
    else
      {
-      op0 = copy_to_mode_reg (SImode, gen_lowpart (SImode, op0));
-      op0 = force_reg (SImode, gen_rtx_AND (SImode, op0, mask));
+      op1 = copy_to_mode_reg (SImode, gen_lowpart (SImode, op1));
+      op1 = force_reg (SImode, gen_rtx_AND (SImode, op1, mask));
      }
  
-  /* Then get the sign bit of OP1.  */
+  /* Then get the sign bit of op2.  */
    mask = force_reg (SImode, gen_rtx_NOT (SImode, mask));
-  op1 = copy_to_mode_reg (SImode, gen_lowpart (SImode, op1));
-  op1 = force_reg (SImode, gen_rtx_AND (SImode, op1, mask));
+  op2 = copy_to_mode_reg (SImode, gen_lowpart (SImode, op2));
+  op2 = force_reg (SImode, gen_rtx_AND (SImode, op2, mask));
  
    /* Finally OR the two values.  */
-  if (op0 == CONST0_RTX (SFmode))
-    x = op1;
+  if (op1 == CONST0_RTX (SFmode))
+    x = op2;
    else
-    x = force_reg (SImode, gen_rtx_IOR (SImode, op0, op1));
+    x = force_reg (SImode, gen_rtx_IOR (SImode, op1, op2));
  
    /* And move the result to the destination.  */
-  emit_insn (gen_rtx_SET (dest, gen_lowpart (SFmode, x)));
+  emit_insn (gen_rtx_SET (op0, gen_lowpart (SFmode, x)));
  }
  
  /* Expand a cstore of OPERANDS in MODE for EQ/NE/LTU/GTU/GEU/LEU.  We generate
@@ -3537,18 +3597,15 @@ visium_compute_frame_size (int size)
  int
  visium_initial_elimination_offset (int from, int to ATTRIBUTE_UNUSED)
  {
-  const int frame_size = visium_compute_frame_size (get_frame_size ());
    const int save_fp = current_frame_info.save_fp;
    const int save_lr = current_frame_info.save_lr;
    const int lr_slot = current_frame_info.lr_slot;
-  const int local_frame_offset
-    = (save_fp + save_lr + lr_slot) * UNITS_PER_WORD;
    int offset;
  
    if (from == FRAME_POINTER_REGNUM)
-    offset = local_frame_offset;
+    offset = (save_fp + save_lr + lr_slot) * UNITS_PER_WORD;
    else if (from == ARG_POINTER_REGNUM)
-    offset = frame_size;
+    offset = visium_compute_frame_size (get_frame_size ());
    else
      gcc_unreachable ();
  
diff --git a/gcc/config/visium/visium.md b/gcc/config/visium/visium.md

index 09d136f..41e3e5c 100644 (file)
--- a/gcc/config/visium/visium.md
+++ b/gcc/config/visium/visium.md
@@ -627,7 +627,7 @@
    [(set (match_dup 2) (match_dup 3))
     (set (match_dup 4) (match_dup 5))]
  {
-  split_double_move (operands, DImode);
+  visium_split_double_move (operands, DImode);
  })
  
  ;;
@@ -726,7 +726,7 @@
    [(set (match_dup 2) (match_dup 3))
     (set (match_dup 4) (match_dup 5))]
  {
-  split_double_move (operands, DFmode);
+  visium_split_double_move (operands, DFmode);
  })
  
  ;;
@@ -815,31 +815,20 @@
                  (match_operand:DI 2 "add_operand" "")))]
    "")
  
+; Disfavour the use of add.l because of the early clobber.
+
  (define_insn_and_split "*addi3_insn"
    [(set (match_operand:DI 0 "register_operand"          "=r,r,&r")
         (plus:DI (match_operand:DI 1 "register_operand" "%0,0, r")
-                (match_operand:DI 2 "add_operand"      " J,L, r")))]
+                (match_operand:DI 2 "add_operand"      " L,J, r")))]
    "ok_for_simple_arith_logic_operands (operands, DImode)"
    "#"
    "reload_completed"
-  [(parallel [(set (match_dup 0)
-                  (plus:DI (match_dup 1) (match_dup 2)))
-             (clobber (reg:CC R_FLAGS))])]
-  ""
-  [(set_attr "type" "arith2")])
-
-; Disfavour the use of add.l because of the early clobber.
-
-(define_insn "*adddi3_insn_flags"
-  [(set (match_operand:DI 0 "register_operand"          "=r,r,&r")
-       (plus:DI (match_operand:DI 1 "register_operand" "%0,0, r")
-                (match_operand:DI 2 "add_operand"      " J,L, r")))
-   (clobber (reg:CC R_FLAGS))]
-  "reload_completed"
-  "@
-    addi    %d0,%2\n\tadc.l   %0,%0,r0
-    subi    %d0,%n2\n\tsubc.l  %0,%0,r0
-    add.l   %d0,%d1,%d2\n\tadc.l   %0,%1,%2"
+  [(const_int 0)]
+{
+  visium_split_double_add (PLUS, operands[0], operands[1], operands[2]);
+  DONE;
+}
    [(set_attr "type" "arith2")])
  
  ;;
@@ -847,7 +836,7 @@
  ;;
  ;; Integer Add with Carry
  ;;
-;; Only SI mode is supported as slt[u] for the sake of cstore.
+;; Only SI mode is supported.
  ;;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;
@@ -869,6 +858,16 @@
    "adc.l   %0,%1,r0"
    [(set_attr "type" "arith")])
  
+(define_insn "*plus_plus_sltu<subst_arith>"
+  [(set (match_operand:SI 0 "register_operand" "=r")
+       (plus:SI (plus:SI (match_operand:SI 1 "register_operand" "r")
+                         (match_operand:SI 2 "register_operand" "r"))
+                (ltu:SI (reg R_FLAGS) (const_int 0))))
+   (clobber (reg:CC R_FLAGS))]
+  "reload_completed"
+  "adc.l   %0,%1,%2"
+  [(set_attr "type" "arith")])
+
  ;;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;
@@ -955,31 +954,20 @@
                   (match_operand:DI 2 "add_operand" "")))]
    "")
  
+; Disfavour the use of the sub.l because of the early clobber.
+
  (define_insn_and_split "*subdi3_insn"
    [(set (match_operand:DI 0 "register_operand"           "=r,r,&r")
         (minus:DI (match_operand:DI 1 "register_operand" " 0,0, r")
-                 (match_operand:DI 2 "add_operand"      " J,L, r")))]
+                 (match_operand:DI 2 "add_operand"      " L,J, r")))]
    "ok_for_simple_arith_logic_operands (operands, DImode)"
    "#"
    "reload_completed"
-  [(parallel [(set (match_dup 0)
-                  (minus:DI (match_dup 1) (match_dup 2)))
-             (clobber (reg:CC R_FLAGS))])]
- ""
-  [(set_attr "type" "arith2")])
-
-; Disfavour the use of the sub.l because of the early clobber.
-
-(define_insn "*subdi3_insn_flags"
-  [(set (match_operand:DI 0 "register_operand"           "=r,r,&r")
-       (minus:DI (match_operand:DI 1 "register_operand" " 0,0, r")
-                 (match_operand:DI 2 "add_operand"      " J,L, r")))
-   (clobber (reg:CC R_FLAGS))]
-  "reload_completed"
-  "@
-    subi    %d0,%2\n\tsubc.l  %0,%0,r0
-    addi    %d0,%n2\n\tadc.l   %0,%0,r0
-    sub.l   %d0,%d1,%d2\n\tsubc.l  %0,%1,%2"
+  [(const_int 0)]
+{
+  visium_split_double_add (MINUS, operands[0], operands[1], operands[2]);
+  DONE;
+}
    [(set_attr "type" "arith2")])
  
  ;;
@@ -987,7 +975,7 @@
  ;;
  ;; Integer Subtract with Carry
  ;;
-;; Only SI mode is supported as neg<slt[u]> for the sake of cstore.
+;; Only SI mode is supported.
  ;;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;
@@ -1009,6 +997,16 @@
    "subc.l  %0,%1,r0"
    [(set_attr "type" "arith")])
  
+(define_insn "*minus_minus_sltu<subst_arith>"
+  [(set (match_operand:SI 0 "register_operand" "=r")
+       (minus:SI (minus:SI (match_operand:SI 1 "reg_or_0_operand" "rO")
+                           (match_operand:SI 2 "register_operand" "r"))
+                 (ltu:SI (reg R_FLAGS) (const_int 0))))
+   (clobber (reg:CC R_FLAGS))]
+  "reload_completed"
+  "subc.l  %0,%r1,%2"
+  [(set_attr "type" "arith")])
+
  ;;
  ;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;
  ;;
@@ -1054,17 +1052,11 @@
    "ok_for_simple_arith_logic_operands (operands, DImode)"
    "#"
    "reload_completed"
-  [(parallel [(set (match_dup 0) (neg:DI (match_dup 1)))
-             (clobber (reg:CC R_FLAGS))])]
-  ""
-  [(set_attr "type" "arith2")])
-
-(define_insn "*negdi2_insn_flags"
-  [(set (match_operand:DI 0 "register_operand" "=&r")
-       (neg:DI (match_operand:DI 1 "register_operand" "r")))
-   (clobber (reg:CC R_FLAGS))]
-  "reload_completed"
-  "sub.l   %d0,r0,%d1\n\tsubc.l  %0,r0,%1"
+  [(const_int 0)]
+{
+  visium_split_double_add (MINUS, operands[0], const0_rtx, operands[1]);
+  DONE;
+}
    [(set_attr "type" "arith2")])
  
  ;;
diff --git a/gcc/configure b/gcc/configure

index 938bd23..371acc6 100755 (executable)
--- a/gcc/configure
+++ b/gcc/configure
@@ -25093,6 +25093,42 @@ $as_echo "#define HAVE_AS_SPARC4 1" >>confdefs.h
  
  fi
  
+    { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for SPARC5 and VIS 4.0 instructions" >&5
+$as_echo_n "checking assembler for SPARC5 and VIS 4.0 instructions... " >&6; }
+if test "${gcc_cv_as_sparc_sparc5+set}" = set; then :
+  $as_echo_n "(cached) " >&6
+else
+  gcc_cv_as_sparc_sparc5=no
+  if test x$gcc_cv_as != x; then
+    $as_echo '.text
+       .register %g2, #scratch
+       .register %g3, #scratch
+       .align 4
+       subxc %g1, %g2, %g3
+       fpadd8 %f0, %f2, %f4' > conftest.s
+    if { ac_try='$gcc_cv_as $gcc_cv_as_flags -xarch=sparc5 -o conftest.o conftest.s >&5'
+  { { eval echo "\"\$as_me\":${as_lineno-$LINENO}: \"$ac_try\""; } >&5
+  (eval $ac_try) 2>&5
+  ac_status=$?
+  $as_echo "$as_me:${as_lineno-$LINENO}: \$? = $ac_status" >&5
+  test $ac_status = 0; }; }
+    then
+       gcc_cv_as_sparc_sparc5=yes
+    else
+      echo "configure: failed program was" >&5
+      cat conftest.s >&5
+    fi
+    rm -f conftest.o conftest.s
+  fi
+fi
+{ $as_echo "$as_me:${as_lineno-$LINENO}: result: $gcc_cv_as_sparc_sparc5" >&5
+$as_echo "$gcc_cv_as_sparc_sparc5" >&6; }
+if test $gcc_cv_as_sparc_sparc5 = yes; then
+
+$as_echo "#define HAVE_AS_SPARC5_VIS4 1" >>confdefs.h
+
+fi
+
      { $as_echo "$as_me:${as_lineno-$LINENO}: checking assembler for LEON instructions" >&5
  $as_echo_n "checking assembler for LEON instructions... " >&6; }
  if test "${gcc_cv_as_sparc_leon+set}" = set; then :
diff --git a/gcc/configure.ac b/gcc/configure.ac

index 808109e..4584964 100644 (file)
--- a/gcc/configure.ac
+++ b/gcc/configure.ac
@@ -3906,6 +3906,18 @@ foo:
        [AC_DEFINE(HAVE_AS_SPARC4, 1,
                  [Define if your assembler supports SPARC4 instructions.])])
  
+    gcc_GAS_CHECK_FEATURE([SPARC5 and VIS 4.0 instructions],
+      gcc_cv_as_sparc_sparc5,,
+      [-xarch=sparc5],
+      [.text
+       .register %g2, #scratch
+       .register %g3, #scratch
+       .align 4
+       subxc %g1, %g2, %g3
+       fpadd8 %f0, %f2, %f4],,
+      [AC_DEFINE(HAVE_AS_SPARC5_VIS4, 1,
+                [Define if your assembler supports SPARC5 and VIS 4.0 instructions.])])
+
      gcc_GAS_CHECK_FEATURE([LEON instructions],
        gcc_cv_as_sparc_leon,,
        [-Aleon],
diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog

index b0f9d42..2537e00 100644 (file)
--- a/gcc/cp/ChangeLog
+++ b/gcc/cp/ChangeLog
@@ -1,3 +1,162 @@
+2016-06-14  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/70572
+       * decl.c (cp_finish_decl): Check do_auto_deduction return value
+       and return immediately in case of erroneous code.
+
+2016-06-14  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71516
+       * decl.c (complete_vars): Handle gracefully type == error_mark_node.
+
+2016-06-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+       PR c/71381
+       Backport from trunk r237290:
+       * parser.c (cp_parser_omp_var_list_no_open) <OMP_CLAUSE__CACHE_>:
+       Loosen checking.
+
+2016-06-08  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71442
+       * pt.c (tsubst_copy): Only set TREE_USED on DECLs.
+
+2016-06-06  Jakub Jelinek  <jakub@redhat.com>
+           Patrick Palka  <ppalka@gcc.gnu.org>
+
+       PR c++/70847
+       PR c++/71330
+       PR c++/71393
+       * cp-gimplify.c (cp_fold_r): Set *walk_subtrees = 0 and return NULL
+       right after cp_fold call if cp_fold has returned the same stmt
+       already in some earlier cp_fold_r call.
+       (cp_fold_function): Add pset automatic variable, pass its address
+       to cp_walk_tree.
+
+2016-06-02  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71372
+       * cp-gimplify.c (cp_fold): For INDIRECT_REF, if the folded expression
+       is INDIRECT_REF or MEM_REF, copy over TREE_READONLY, TREE_SIDE_EFFECTS
+       and TREE_THIS_VOLATILE flags.  For ARRAY_REF and ARRAY_RANGE_REF, copy
+       over TREE_READONLY, TREE_SIDE_EFFECTS and TREE_THIS_VOLATILE flags
+       to the newly built tree.
+
+2016-06-02  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/70972
+       * method.c (forward_parm): Use cp_build_reference_type.
+
+2016-05-31  Jason Merrill  <jason@redhat.com>
+
+       PR c++/71166
+       * decl2.c (c_parse_final_cleanups): Don't call fini_constexpr.
+
+       PR c++/71227
+       * pt.c (check_explicit_specialization): Give better diagnostic about
+       specializing a hidden friend.
+
+       PR c++/60095
+       PR c++/69515
+       PR c++/69009
+       * pt.c (instantiate_template_1): Don't put the partial
+       specialization in DECL_TI_TEMPLATE.
+       (partial_specialization_p, impartial_args): Remove.
+       (regenerate_decl_from_template): Add args parm.
+       (instantiate_decl): Look up the partial specialization again.
+
+       PR c++/71173
+       PR c++/70522
+       * cp-tree.h (enum tag_types): Add scope_type.
+       * parser.c (cp_parser_class_name): Use scope_type.
+       (prefer_type_arg): Handle scope_type.
+       (cp_parser_lookup_name): Use prefer_type_arg.
+       * name-lookup.c (lookup_qualified_name): Change bool is_type_p to
+       int prefer_type, use lookup_flags.
+       * name-lookup.h: Adjust.
+
+       PR c++/70584
+       * cp-gimplify.c (cp_fold_maybe_rvalue): Loop in case cp_fold
+       returns a decl.
+       (cp_fold) [INDIRECT_REF]: Call maybe_undo_parenthesized_ref.
+
+       PR c++/70735
+       * pt.c (tsubst_copy): Just return a local variable from
+       non-template context.  Don't call rest_of_decl_compilation for
+       duplicated static locals.
+       (tsubst_decl): Set DECL_CONTEXT of local static from another
+       function.
+
+2016-05-31  Martin Sebor  <msebor@redhat.com>
+
+       PR c++/71306
+       * init.c (warn_placement_new_too_small): Handle placement new arguments
+       that are elements of arrays more carefully.  Remove a pointless loop.
+
+2016-05-30  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71349
+       * parser.c (cp_parser_omp_for): Don't disallow nowait clause
+       when combined with target construct.
+       (cp_parser_omp_parallel): Pass cclauses == NULL as last argument
+       to cp_parser_omp_all_clauses.
+
+2016-05-29  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/71105
+       * lambda.c (maybe_add_lambda_conv_op): Early return also when
+       LAMBDA_EXPR_DEFAULT_CAPTURE_MODE != CPLD_NONE.
+
+2016-05-24  Martin Sebor  <msebor@redhat.com>
+
+       PR c++/71147
+       * decl.c (layout_var_decl, grokdeclarator): Use
+       complete_or_array_type_p.
+       * pt.c (instantiate_class_template_1): Try to complete the element
+       type of a flexible array member.
+       (can_complete_type_without_circularity): Handle arrays of unknown bound.
+       * typeck.c (complete_type): Also complete the type of the elements of
+       arrays with an unspecified bound.
+
+2016-05-24  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/69872
+       * typeck2.c (check_narrowing): Check pedwarn return value.
+
+2016-05-24  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71257
+       * semantics.c (finish_omp_clauses) <case OMP_CLAUSE_LINEAR>:
+       For OMP_CLAUSE_LINEAR_REF don't require type to be
+       integral or pointer.
+
+2016-05-23  Jason Merrill  <jason@redhat.com>
+
+       PR c++/70344
+       * constexpr.c (cxx_eval_call_expression): Check for
+       fun == current_function_decl again.
+
+2016-05-19  David Malcolm  <dmalcolm@redhat.com>
+
+       Backport from trunk r236483.
+       PR c++/71184
+       * parser.c (cp_parser_operator): For array new/delete, check that
+       cp_parser_require returned a non-NULL token before dereferencing
+       it.
+
+2016-05-19  Bernd Edlinger  <bernd.edlinger@hotmail.de>
+
+       Backport from mainline
+       2016-05-19  Bernd Edlinger  <bernd.edlinger@hotmail.de>
+
+       * decl.c (finish_enum_value_list): Use the specified mode.
+
+2016-05-18  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/70466
+       * call.c (convert_like_real): Check that we are actually converting
+       from an init list.
+
  2016-04-29  Cesar Philippidis  <cesar@codesourcery.com>
  
         PR middle-end/70626
diff --git a/gcc/cp/call.c b/gcc/cp/call.c

index ed23490..34a8840 100644 (file)
--- a/gcc/cp/call.c
+++ b/gcc/cp/call.c
@@ -6360,8 +6360,9 @@ convert_like_real (conversion *convs, tree expr, tree fn, int argnum,
         /* When converting from an init list we consider explicit
            constructors, but actually trying to call one is an error.  */
         if (DECL_NONCONVERTING_P (convfn) && DECL_CONSTRUCTOR_P (convfn)
+           && BRACE_ENCLOSED_INITIALIZER_P (expr)
             /* Unless this is for direct-list-initialization.  */
-           && !DIRECT_LIST_INIT_P (expr)
+           && !CONSTRUCTOR_IS_DIRECT_INIT (expr)
             /* And in C++98 a default constructor can't be explicit.  */
             && cxx_dialect >= cxx11)
           {
diff --git a/gcc/cp/constexpr.c b/gcc/cp/constexpr.c

index d508660..55b05e7 100644 (file)
--- a/gcc/cp/constexpr.c
+++ b/gcc/cp/constexpr.c
@@ -1371,11 +1371,17 @@ cxx_eval_call_expression (const constexpr_ctx *ctx, tree t,
    else
      {
        new_call.fundef = retrieve_constexpr_fundef (fun);
-      if (new_call.fundef == NULL || new_call.fundef->body == NULL)
+      if (new_call.fundef == NULL || new_call.fundef->body == NULL
+         || fun == current_function_decl)
          {
           if (!ctx->quiet)
             {
-             if (DECL_INITIAL (fun) == error_mark_node)
+             /* We need to check for current_function_decl here in case we're
+                being called during cp_fold_function, because at that point
+                DECL_INITIAL is set properly and we have a fundef but we
+                haven't lowered invisirefs yet (c++/70344).  */
+             if (DECL_INITIAL (fun) == error_mark_node
+                 || fun == current_function_decl)
                 error_at (loc, "%qD called in a constant expression before its "
                           "definition is complete", fun);
               else if (DECL_INITIAL (fun))
diff --git a/gcc/cp/cp-gimplify.c b/gcc/cp/cp-gimplify.c

index 30ac660..5c815d9 100644 (file)
--- a/gcc/cp/cp-gimplify.c
+++ b/gcc/cp/cp-gimplify.c
@@ -939,6 +939,17 @@ cp_fold_r (tree *stmt_p, int *walk_subtrees, void *data)
  
    *stmt_p = stmt = cp_fold (*stmt_p);
  
+  if (((hash_set<tree> *) data)->add (stmt))
+    {
+      /* Don't walk subtrees of stmts we've already walked once, otherwise
+        we can have exponential complexity with e.g. lots of nested
+        SAVE_EXPRs or TARGET_EXPRs.  cp_fold uses a cache and will return
+        always the same tree, which the first time cp_fold_r has been
+        called on it had the subtrees walked.  */
+      *walk_subtrees = 0;
+      return NULL;
+    }
+
    code = TREE_CODE (stmt);
    if (code == OMP_FOR || code == OMP_SIMD || code == OMP_DISTRIBUTE
        || code == OMP_TASKLOOP || code == CILK_FOR || code == CILK_SIMD
@@ -996,7 +1007,8 @@ cp_fold_r (tree *stmt_p, int *walk_subtrees, void *data)
  void
  cp_fold_function (tree fndecl)
  {
-  cp_walk_tree (&DECL_SAVED_TREE (fndecl), cp_fold_r, NULL, NULL);
+  hash_set<tree> pset;
+  cp_walk_tree (&DECL_SAVED_TREE (fndecl), cp_fold_r, &pset, NULL);
  }
  
  /* Perform any pre-gimplification lowering of C++ front end trees to
@@ -1877,13 +1889,21 @@ cp_fully_fold (tree x)
  static tree
  cp_fold_maybe_rvalue (tree x, bool rval)
  {
-  if (rval && DECL_P (x))
+  while (true)
      {
-      tree v = decl_constant_value (x);
-      if (v != error_mark_node)
-       x = v;
+      x = cp_fold (x);
+      if (rval && DECL_P (x))
+       {
+         tree v = decl_constant_value (x);
+         if (v != x && v != error_mark_node)
+           {
+             x = v;
+             continue;
+           }
+       }
+      break;
      }
-  return cp_fold (x);
+  return x;
  }
  
  /* Fold expression X which is used as an rvalue.  */
@@ -1995,6 +2015,15 @@ cp_fold (tree x)
  
        break;
  
+    case INDIRECT_REF:
+      /* We don't need the decltype(auto) obfuscation anymore.  */
+      if (REF_PARENTHESIZED_P (x))
+       {
+         tree p = maybe_undo_parenthesized_ref (x);
+         return cp_fold (p);
+       }
+      goto unary;
+
      case ADDR_EXPR:
      case REALPART_EXPR:
      case IMAGPART_EXPR:
@@ -2007,7 +2036,7 @@ cp_fold (tree x)
      case BIT_NOT_EXPR:
      case TRUTH_NOT_EXPR:
      case FIXED_CONVERT_EXPR:
-    case INDIRECT_REF:
+    unary:
  
        loc = EXPR_LOCATION (x);
        op0 = cp_fold_maybe_rvalue (TREE_OPERAND (x, 0), rval_ops);
@@ -2017,7 +2046,16 @@ cp_fold (tree x)
           if (op0 == error_mark_node)
             x = error_mark_node;
           else
-           x = fold_build1_loc (loc, code, TREE_TYPE (x), op0);
+           {
+             x = fold_build1_loc (loc, code, TREE_TYPE (x), op0);
+             if (code == INDIRECT_REF
+                 && (INDIRECT_REF_P (x) || TREE_CODE (x) == MEM_REF))
+               {
+                 TREE_READONLY (x) = TREE_READONLY (org_x);
+                 TREE_SIDE_EFFECTS (x) = TREE_SIDE_EFFECTS (org_x);
+                 TREE_THIS_VOLATILE (x) = TREE_THIS_VOLATILE (org_x);
+               }
+           }
         }
        else
         x = fold (x);
@@ -2294,7 +2332,12 @@ cp_fold (tree x)
               || op3 == error_mark_node)
             x = error_mark_node;
           else
-           x = build4_loc (loc, code, TREE_TYPE (x), op0, op1, op2, op3);
+           {
+             x = build4_loc (loc, code, TREE_TYPE (x), op0, op1, op2, op3);
+             TREE_READONLY (x) = TREE_READONLY (org_x);
+             TREE_SIDE_EFFECTS (x) = TREE_SIDE_EFFECTS (org_x);
+             TREE_THIS_VOLATILE (x) = TREE_THIS_VOLATILE (org_x);
+           }
         }
  
        x = fold (x);
diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h

index 0df8470..5f8af13 100644 (file)
--- a/gcc/cp/cp-tree.h
+++ b/gcc/cp/cp-tree.h
@@ -4601,7 +4601,8 @@ enum tag_types {
    class_type,    /* "class" types.  */
    union_type,    /* "union" types.  */
    enum_type,     /* "enum" types.  */
-  typename_type  /* "typename" types.  */
+  typename_type, /* "typename" types.  */
+  scope_type    /* namespace or tagged type name followed by :: */
  };
  
  /* The various kinds of lvalues we distinguish.  */
diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c

index 38e6bd8..fdbefdc 100644 (file)
--- a/gcc/cp/decl.c
+++ b/gcc/cp/decl.c
@@ -5329,10 +5329,7 @@ layout_var_decl (tree decl)
      complete_type (type);
    if (!DECL_SIZE (decl)
        && TREE_TYPE (decl) != error_mark_node
-      && (COMPLETE_TYPE_P (type)
-         || (TREE_CODE (type) == ARRAY_TYPE
-             && !TYPE_DOMAIN (type)
-             && COMPLETE_TYPE_P (TREE_TYPE (type)))))
+      && complete_or_array_type_p (type))
      layout_decl (decl, 0);
  
    if (!DECL_EXTERNAL (decl) && DECL_SIZE (decl) == NULL_TREE)
@@ -6633,6 +6630,13 @@ cp_finish_decl (tree decl, tree init, bool init_const_expr_p,
                                                     adc_variable_type);
        if (type == error_mark_node)
         return;
+      if (TREE_CODE (type) == FUNCTION_TYPE)
+       {
+         error ("initializer for %<decltype(auto) %D%> has function type "
+                "(did you forget the %<()%> ?)", decl);
+         TREE_TYPE (decl) = error_mark_node;
+         return;
+       }
        cp_apply_type_quals_to_decl (cp_type_quals (type), decl);
      }
  
@@ -11186,8 +11190,7 @@ grokdeclarator (const cp_declarator *declarator,
           }
         else if (!staticp && !dependent_type_p (type)
                  && !COMPLETE_TYPE_P (complete_type (type))
-                && (TREE_CODE (type) != ARRAY_TYPE
-                    || !COMPLETE_TYPE_P (TREE_TYPE (type))
+                && (!complete_or_array_type_p (type)
                      || initialized == 0))
           {
             if (TREE_CODE (type) != ARRAY_TYPE
@@ -13382,6 +13385,19 @@ finish_enum_value_list (tree enumtype)
        use_short_enum = flag_short_enums
          || lookup_attribute ("packed", TYPE_ATTRIBUTES (enumtype));
  
+      /* If the precision of the type was specified with an attribute and it
+        was too small, give an error.  Otherwise, use it.  */
+      if (TYPE_PRECISION (enumtype))
+       {
+         if (precision > TYPE_PRECISION (enumtype))
+           error ("specified mode too small for enumeral values");
+         else
+           {
+             use_short_enum = true;
+             precision = TYPE_PRECISION (enumtype);
+           }
+       }
+
        for (itk = (use_short_enum ? itk_char : itk_int);
             itk != itk_none;
             itk++)
@@ -14999,8 +15015,9 @@ complete_vars (tree type)
           tree var = iv->decl;
           tree type = TREE_TYPE (var);
  
-         if (TYPE_MAIN_VARIANT (strip_array_types (type))
-             == iv->incomplete_type)
+         if (type != error_mark_node
+             && (TYPE_MAIN_VARIANT (strip_array_types (type))
+                 == iv->incomplete_type))
             {
               /* Complete the type of the variable.  The VAR_DECL itself
                  will be laid out in expand_expr.  */
diff --git a/gcc/cp/decl2.c b/gcc/cp/decl2.c

index 0ea326d..b3cc99a 100644 (file)
--- a/gcc/cp/decl2.c
+++ b/gcc/cp/decl2.c
@@ -4904,8 +4904,6 @@ c_parse_final_cleanups (void)
  
    finish_repo ();
  
-  fini_constexpr ();
-
    /* The entire file is now complete.  If requested, dump everything
       to a file.  */
    dump_tu ();
diff --git a/gcc/cp/init.c b/gcc/cp/init.c

index 5997d53..5e2393b 100644 (file)
--- a/gcc/cp/init.c
+++ b/gcc/cp/init.c
@@ -2375,7 +2375,8 @@ warn_placement_new_too_small (tree type, tree nelts, tree size, tree oper)
  
    STRIP_NOPS (oper);
  
-  if (TREE_CODE (oper) == ARRAY_REF)
+  if (TREE_CODE (oper) == ARRAY_REF
+      && (addr_expr || TREE_CODE (TREE_TYPE (oper)) == ARRAY_TYPE))
      {
        /* Similar to the offset computed above, see if the array index
          is a compile-time constant.  If so, and unless the offset was
@@ -2404,8 +2405,8 @@ warn_placement_new_too_small (tree type, tree nelts, tree size, tree oper)
    bool compref = TREE_CODE (oper) == COMPONENT_REF;
  
    /* Descend into a struct or union to find the member whose address
-     is being used as the agument.  */
-  while (TREE_CODE (oper) == COMPONENT_REF)
+     is being used as the argument.  */
+  if (TREE_CODE (oper) == COMPONENT_REF)
      {
        tree op0 = oper;
        while (TREE_CODE (op0 = TREE_OPERAND (op0, 0)) == COMPONENT_REF);
diff --git a/gcc/cp/lambda.c b/gcc/cp/lambda.c

index cdc11fe..539a01a 100644 (file)
--- a/gcc/cp/lambda.c
+++ b/gcc/cp/lambda.c
@@ -871,8 +871,10 @@ maybe_add_lambda_conv_op (tree type)
    bool nested = (cfun != NULL);
    bool nested_def = decl_function_context (TYPE_MAIN_DECL (type));
    tree callop = lambda_function (type);
+  tree lam = CLASSTYPE_LAMBDA_EXPR (type);
  
-  if (LAMBDA_EXPR_CAPTURE_LIST (CLASSTYPE_LAMBDA_EXPR (type)) != NULL_TREE)
+  if (LAMBDA_EXPR_CAPTURE_LIST (lam) != NULL_TREE
+      || LAMBDA_EXPR_DEFAULT_CAPTURE_MODE (lam) != CPLD_NONE)
      return;
  
    if (processing_template_decl)
diff --git a/gcc/cp/method.c b/gcc/cp/method.c

index 38f2a54..6920fbb 100644 (file)
--- a/gcc/cp/method.c
+++ b/gcc/cp/method.c
@@ -484,6 +484,8 @@ forward_parm (tree parm)
    tree type = TREE_TYPE (parm);
    if (DECL_PACK_P (parm))
      type = PACK_EXPANSION_PATTERN (type);
+  if (TREE_CODE (type) != REFERENCE_TYPE)
+    type = cp_build_reference_type (type, /*rval=*/true);
    exp = build_static_cast (type, exp, tf_warning_or_error);
    if (DECL_PACK_P (parm))
      exp = make_pack_expansion (exp);
diff --git a/gcc/cp/name-lookup.c b/gcc/cp/name-lookup.c

index b3828c0..7c0394e 100644 (file)
--- a/gcc/cp/name-lookup.c
+++ b/gcc/cp/name-lookup.c
@@ -4518,8 +4518,10 @@ unqualified_namespace_lookup (tree name, int flags)
  }
  
  /* Look up NAME (an IDENTIFIER_NODE) in SCOPE (either a NAMESPACE_DECL
-   or a class TYPE).  If IS_TYPE_P is TRUE, then ignore non-type
-   bindings.
+   or a class TYPE).
+
+   If PREFER_TYPE is > 0, we only return TYPE_DECLs or namespaces.
+   If PREFER_TYPE is > 1, we only return TYPE_DECLs.
  
     Returns a DECL (or OVERLOAD, or BASELINK) representing the
     declaration found.  If no suitable declaration can be found,
@@ -4527,28 +4529,25 @@ unqualified_namespace_lookup (tree name, int flags)
     neither a class-type nor a namespace a diagnostic is issued.  */
  
  tree
-lookup_qualified_name (tree scope, tree name, bool is_type_p, bool complain,
+lookup_qualified_name (tree scope, tree name, int prefer_type, bool complain,
                        bool find_hidden)
  {
-  int flags = 0;
    tree t = NULL_TREE;
  
-  if (find_hidden)
-    flags |= LOOKUP_HIDDEN;
-
    if (TREE_CODE (scope) == NAMESPACE_DECL)
      {
        struct scope_binding binding = EMPTY_SCOPE_BINDING;
  
-      if (is_type_p)
-       flags |= LOOKUP_PREFER_TYPES;
+      int flags = lookup_flags (prefer_type, /*namespaces_only*/false);
+      if (find_hidden)
+       flags |= LOOKUP_HIDDEN;
        if (qualified_lookup_using_namespace (name, scope, &binding, flags))
         t = binding.value;
      }
    else if (cxx_dialect != cxx98 && TREE_CODE (scope) == ENUMERAL_TYPE)
      t = lookup_enumerator (scope, name);
    else if (is_class_type (scope, complain))
-    t = lookup_member (scope, name, 2, is_type_p, tf_warning_or_error);
+    t = lookup_member (scope, name, 2, prefer_type, tf_warning_or_error);
  
    if (!t)
      return error_mark_node;
diff --git a/gcc/cp/name-lookup.h b/gcc/cp/name-lookup.h

index 7e39b6c..2f8447a 100644 (file)
--- a/gcc/cp/name-lookup.h
+++ b/gcc/cp/name-lookup.h
@@ -327,7 +327,7 @@ extern tree namespace_binding (tree, tree);
  extern void set_namespace_binding (tree, tree, tree);
  extern bool hidden_name_p (tree);
  extern tree remove_hidden_names (tree);
-extern tree lookup_qualified_name (tree, tree, bool, bool, /*hidden*/bool = false);
+extern tree lookup_qualified_name (tree, tree, int, bool, /*hidden*/bool = false);
  extern tree lookup_name_nonclass (tree);
  extern tree lookup_name_innermost_nonclass_level (tree);
  extern bool is_local_extern (tree);
diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c

index c1ed5ef..f59b03a 100644 (file)
--- a/gcc/cp/parser.c
+++ b/gcc/cp/parser.c
@@ -13793,8 +13793,9 @@ cp_parser_operator (cp_parser* parser)
             /* Consume the `[' token.  */
             cp_lexer_consume_token (parser->lexer);
             /* Look for the `]' token.  */
-           end_loc = cp_parser_require (parser, CPP_CLOSE_SQUARE,
-                                         RT_CLOSE_SQUARE)->location;
+           if (cp_token *close_token
+               = cp_parser_require (parser, CPP_CLOSE_SQUARE, RT_CLOSE_SQUARE))
+             end_loc = close_token->location;
             id = ansi_opname (op == NEW_EXPR
                               ? VEC_NEW_EXPR : VEC_DELETE_EXPR);
           }
@@ -21178,7 +21179,7 @@ cp_parser_class_name (cp_parser *parser,
              resolution operator, object, function, and enumerator
              names are ignored.  */
           if (cp_lexer_next_token_is (parser->lexer, CPP_SCOPE))
-           tag_type = typename_type;
+           tag_type = scope_type;
           /* Look up the name.  */
           decl = cp_parser_lookup_name (parser, identifier,
                                         tag_type,
@@ -24569,6 +24570,20 @@ cp_parser_nested_requirement (cp_parser *parser)
  
  /* Support Functions */
  
+/* Return the appropriate prefer_type argument for lookup_name_real based on
+   tag_type.  */
+
+static inline int
+prefer_type_arg (tag_types tag_type)
+{
+  switch (tag_type)
+    {
+    case none_type:  return 0; // No preference.
+    case scope_type: return 1; // Type or namespace.
+    default:         return 2; // Type only.
+    }
+}
+
  /* Looks up NAME in the current scope, as given by PARSER->SCOPE.
     NAME should have one of the representations used for an
     id-expression.  If NAME is the ERROR_MARK_NODE, the ERROR_MARK_NODE
@@ -24705,7 +24720,7 @@ cp_parser_lookup_name (cp_parser *parser, tree name,
              errors may be issued.  Even if we rollback the current
              tentative parse, those errors are valid.  */
           decl = lookup_qualified_name (parser->scope, name,
-                                       tag_type != none_type,
+                                       prefer_type_arg (tag_type),
                                         /*complain=*/true);
  
           /* 3.4.3.1: In a lookup in which the constructor is an acceptable
@@ -24726,7 +24741,7 @@ cp_parser_lookup_name (cp_parser *parser, tree name,
               && DECL_SELF_REFERENCE_P (decl)
               && same_type_p (DECL_CONTEXT (decl), parser->scope))
             decl = lookup_qualified_name (parser->scope, ctor_identifier,
-                                         tag_type != none_type,
+                                         prefer_type_arg (tag_type),
                                           /*complain=*/true);
  
           /* If we have a single function from a using decl, pull it out.  */
@@ -24782,7 +24797,7 @@ cp_parser_lookup_name (cp_parser *parser, tree name,
         decl = lookup_member (object_type,
                               name,
                               /*protect=*/0,
-                             tag_type != none_type,
+                             prefer_type_arg (tag_type),
                               tf_warning_or_error);
        else
         decl = NULL_TREE;
@@ -24790,7 +24805,7 @@ cp_parser_lookup_name (cp_parser *parser, tree name,
        if (!decl)
         {
           /* Look it up in the enclosing context.  */
-         decl = lookup_name_real (name, tag_type != none_type,
+         decl = lookup_name_real (name, prefer_type_arg (tag_type),
                                    /*nonclass=*/0,
                                    /*block_p=*/true, is_namespace, 0);
           /* DR 141 says when looking for a template-name after -> or ., only
@@ -24815,7 +24830,7 @@ cp_parser_lookup_name (cp_parser *parser, tree name,
      }
    else
      {
-      decl = lookup_name_real (name, tag_type != none_type,
+      decl = lookup_name_real (name, prefer_type_arg (tag_type),
                                /*nonclass=*/0,
                                /*block_p=*/true, is_namespace, 0);
        parser->qualifying_scope = NULL_TREE;
@@ -29949,6 +29964,8 @@ cp_parser_omp_var_list_no_open (cp_parser *parser, enum omp_clause_code kind,
           switch (kind)
             {
             case OMP_CLAUSE__CACHE_:
+             /* The OpenACC cache directive explicitly only allows "array
+                elements or subarrays".  */
               if (cp_lexer_peek_token (parser->lexer)->type != CPP_OPEN_SQUARE)
                 {
                   error_at (token->location, "expected %<[%>");
@@ -30000,25 +30017,6 @@ cp_parser_omp_var_list_no_open (cp_parser *parser, enum omp_clause_code kind,
                                           RT_CLOSE_SQUARE))
                     goto skip_comma;
  
-                 if (kind == OMP_CLAUSE__CACHE_)
-                   {
-                     if (TREE_CODE (low_bound) != INTEGER_CST
-                         && !TREE_READONLY (low_bound))
-                       {
-                         error_at (token->location,
-                                   "%qD is not a constant", low_bound);
-                         decl = error_mark_node;
-                       }
-
-                     if (TREE_CODE (length) != INTEGER_CST
-                         && !TREE_READONLY (length))
-                       {
-                         error_at (token->location,
-                                   "%qD is not a constant", length);
-                         decl = error_mark_node;
-                       }
-                   }
-
                   decl = tree_cons (low_bound, length, decl);
                 }
               break;
@@ -33884,7 +33882,9 @@ cp_parser_omp_for (cp_parser *parser, cp_token *pragma_tok,
  
    strcat (p_name, " for");
    mask |= OMP_FOR_CLAUSE_MASK;
-  if (cclauses)
+  /* parallel for{, simd} disallows nowait clause, but for
+     target {teams distribute ,}parallel for{, simd} it should be accepted.  */
+  if (cclauses && (mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_MAP)) == 0)
      mask &= ~(OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_NOWAIT);
    /* Composite distribute parallel for{, simd} disallows ordered clause.  */
    if ((mask & (OMP_CLAUSE_MASK_1 << PRAGMA_OMP_CLAUSE_DIST_SCHEDULE)) != 0)
@@ -34223,7 +34223,8 @@ cp_parser_omp_parallel (cp_parser *parser, cp_token *pragma_tok,
         }
      }
  
-  clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok);
+  clauses = cp_parser_omp_all_clauses (parser, mask, p_name, pragma_tok,
+                                      cclauses == NULL);
    if (cclauses)
      {
        cp_omp_split_clauses (loc, OMP_PARALLEL, mask, clauses, cclauses);
diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c

index f258e97..166aef2 100644 (file)
--- a/gcc/cp/pt.c
+++ b/gcc/cp/pt.c
@@ -182,7 +182,6 @@ static tree copy_template_args (tree);
  static tree tsubst_template_arg (tree, tree, tsubst_flags_t, tree);
  static tree tsubst_template_args (tree, tree, tsubst_flags_t, tree);
  static tree tsubst_template_parms (tree, tree, tsubst_flags_t);
-static void regenerate_decl_from_template (tree, tree);
  static tree most_specialized_partial_spec (tree, tsubst_flags_t);
  static tree tsubst_aggr_type (tree, tree, tsubst_flags_t, tree, int);
  static tree tsubst_arg_types (tree, tree, tree, tsubst_flags_t, tree);
@@ -2808,6 +2807,13 @@ check_explicit_specialization (tree declarator,
                  context.  */
               fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
                                            false, true);
+             if (fns == error_mark_node)
+               /* If lookup fails, look for a friend declaration so we can
+                  give a better diagnostic.  */
+               fns = lookup_qualified_name (CP_DECL_CONTEXT (decl), dname,
+                                            /*type*/false, /*complain*/true,
+                                            /*hidden*/true);
+
               if (fns == error_mark_node || !is_overloaded_fn (fns))
                 {
                   error ("%qD is not a template function", dname);
@@ -2953,6 +2959,15 @@ check_explicit_specialization (tree declarator,
                                            CP_DECL_CONTEXT (tmpl)))
             error ("%qD is not declared in %qD",
                    tmpl, current_namespace);
+         else if (TREE_CODE (decl) == FUNCTION_DECL
+                  && DECL_HIDDEN_FRIEND_P (tmpl))
+           {
+             if (pedwarn (DECL_SOURCE_LOCATION (decl), 0,
+                          "friend declaration %qD is not visible to "
+                          "explicit specialization", tmpl))
+               inform (DECL_SOURCE_LOCATION (tmpl),
+                       "friend declaration here");
+           }
  
           tree gen_tmpl = most_general_template (tmpl);
  
@@ -9554,7 +9569,7 @@ can_complete_type_without_circularity (tree type)
      return 0;
    else if (COMPLETE_TYPE_P (type))
      return 1;
-  else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
+  else if (TREE_CODE (type) == ARRAY_TYPE)
      return can_complete_type_without_circularity (TREE_TYPE (type));
    else if (CLASS_TYPE_P (type)
            && TYPE_BEING_DEFINED (TYPE_MAIN_VARIANT (type)))
@@ -10118,17 +10133,12 @@ instantiate_class_template_1 (tree type)
                           if (can_complete_type_without_circularity (rtype))
                             complete_type (rtype);
  
-                          if (TREE_CODE (r) == FIELD_DECL
-                              && TREE_CODE (rtype) == ARRAY_TYPE
-                              && COMPLETE_TYPE_P (TREE_TYPE (rtype))
-                              && !COMPLETE_TYPE_P (rtype))
-                            {
-                              /* Flexible array mmembers of elements
-                                 of complete type have an incomplete type
-                                 and that's okay.  */
-                            }
-                          else if (!COMPLETE_TYPE_P (rtype))
+                         if (!complete_or_array_type_p (rtype))
                             {
+                             /* If R's type couldn't be completed and
+                                it isn't a flexible array member (whose
+                                type is incomplete by definition) give
+                                an error.  */
                               cxx_incomplete_type_error (r, rtype);
                               TREE_TYPE (r) = error_mark_node;
                             }
@@ -12285,6 +12295,14 @@ tsubst_decl (tree t, tree args, tsubst_flags_t complain)
             local_p = true;
             /* Subsequent calls to pushdecl will fill this in.  */
             ctx = NULL_TREE;
+           /* Unless this is a reference to a static variable from an
+              enclosing function, in which case we need to fill it in now.  */
+           if (TREE_STATIC (t))
+             {
+               tree fn = tsubst (DECL_CONTEXT (t), args, complain, in_decl);
+               if (fn != current_function_decl)
+                 ctx = fn;
+             }
             spec = retrieve_local_specialization (t);
           }
         /* If we already have the specialization we need, there is
@@ -13996,7 +14014,8 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
      case FUNCTION_DECL:
        if (DECL_LANG_SPECIFIC (t) && DECL_TEMPLATE_INFO (t))
         r = tsubst (t, args, complain, in_decl);
-      else if (local_variable_p (t))
+      else if (local_variable_p (t)
+              && uses_template_parms (DECL_CONTEXT (t)))
         {
           r = retrieve_local_specialization (t);
           if (r == NULL_TREE)
@@ -14040,14 +14059,9 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
                   gcc_assert (cp_unevaluated_operand || TREE_STATIC (r)
                               || decl_constant_var_p (r)
                               || errorcount || sorrycount);
-                 if (!processing_template_decl)
-                   {
-                     if (TREE_STATIC (r))
-                       rest_of_decl_compilation (r, toplevel_bindings_p (),
-                                                 at_eof);
-                     else
-                       r = process_outer_var_ref (r, complain);
-                   }
+                 if (!processing_template_decl
+                     && !TREE_STATIC (r))
+                   r = process_outer_var_ref (r, complain);
                 }
               /* Remember this for subsequent uses.  */
               if (local_specializations)
@@ -14145,7 +14159,8 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl)
               len = TREE_VEC_LENGTH (expanded);
               /* Set TREE_USED for the benefit of -Wunused.  */
               for (int i = 0; i < len; i++)
-               TREE_USED (TREE_VEC_ELT (expanded, i)) = true;
+               if (DECL_P (TREE_VEC_ELT (expanded, i)))
+                 TREE_USED (TREE_VEC_ELT (expanded, i)) = true;
             }
  
           if (expanded == error_mark_node)
@@ -17376,6 +17391,7 @@ instantiate_template_1 (tree tmpl, tree orig_args, tsubst_flags_t complain)
  
    tree pattern = DECL_TEMPLATE_RESULT (gen_tmpl);
  
+  fndecl = NULL_TREE;
    if (VAR_P (pattern))
      {
        /* We need to determine if we're using a partial or explicit
@@ -17387,14 +17403,16 @@ instantiate_template_1 (tree tmpl, tree orig_args, tsubst_flags_t complain)
         pattern = error_mark_node;
        else if (elt)
         {
-         tmpl = TREE_VALUE (elt);
-         pattern = DECL_TEMPLATE_RESULT (tmpl);
-         targ_ptr = TREE_PURPOSE (elt);
+         tree partial_tmpl = TREE_VALUE (elt);
+         tree partial_args = TREE_PURPOSE (elt);
+         tree partial_pat = DECL_TEMPLATE_RESULT (partial_tmpl);
+         fndecl = tsubst (partial_pat, partial_args, complain, gen_tmpl);
         }
      }
  
    /* Substitute template parameters to obtain the specialization.  */
-  fndecl = tsubst (pattern, targ_ptr, complain, gen_tmpl);
+  if (fndecl == NULL_TREE)
+    fndecl = tsubst (pattern, targ_ptr, complain, gen_tmpl);
    if (DECL_CLASS_SCOPE_P (gen_tmpl))
      pop_nested_class ();
    pop_from_top_level ();
@@ -20848,36 +20866,6 @@ most_general_template (tree decl)
    return decl;
  }
  
-/* True iff the TEMPLATE_DECL tmpl is a partial specialization.  */
-
-static bool
-partial_specialization_p (tree tmpl)
-{
-  /* Any specialization has DECL_TEMPLATE_SPECIALIZATION.  */
-  if (!DECL_TEMPLATE_SPECIALIZATION (tmpl))
-    return false;
-  tree t = DECL_TI_TEMPLATE (tmpl);
-  /* A specialization that fully specializes one of the containing classes is
-     not a partial specialization.  */
-  return (list_length (DECL_TEMPLATE_PARMS (tmpl))
-         == list_length (DECL_TEMPLATE_PARMS (t)));
-}
-
-/* If TMPL is a partial specialization, return the arguments for its primary
-   template.  */
-
-static tree
-impartial_args (tree tmpl, tree args)
-{
-  if (!partial_specialization_p (tmpl))
-    return args;
-
-  /* If TMPL is a partial specialization, we need to substitute to get
-     the args for the primary template.  */
-  return tsubst_template_args (DECL_TI_ARGS (tmpl), args,
-                              tf_warning_or_error, tmpl);
-}
-
  /* Return the most specialized of the template partial specializations
     which can produce TARGET, a specialization of some class or variable
     template.  The value returned is actually a TREE_LIST; the TREE_VALUE is
@@ -21379,14 +21367,12 @@ do_type_instantiation (tree t, tree storage, tsubst_flags_t complain)
     to instantiate the DECL, we regenerate it.  */
  
  static void
-regenerate_decl_from_template (tree decl, tree tmpl)
+regenerate_decl_from_template (tree decl, tree tmpl, tree args)
  {
    /* The arguments used to instantiate DECL, from the most general
       template.  */
-  tree args;
    tree code_pattern;
  
-  args = DECL_TI_ARGS (decl);
    code_pattern = DECL_TEMPLATE_RESULT (tmpl);
  
    /* Make sure that we can see identifiers, and compute access
@@ -21702,7 +21688,7 @@ instantiate_decl (tree d, int defer_ok,
      return d;
  
    gen_tmpl = most_general_template (tmpl);
-  gen_args = impartial_args (tmpl, DECL_TI_ARGS (d));
+  gen_args = DECL_TI_ARGS (d);
  
    if (tmpl != gen_tmpl)
      /* We should already have the extra args.  */
@@ -21721,6 +21707,20 @@ instantiate_decl (tree d, int defer_ok,
    /* Set TD to the template whose DECL_TEMPLATE_RESULT is the pattern
       for the instantiation.  */
    td = template_for_substitution (d);
+  args = gen_args;
+
+  if (VAR_P (d))
+    {
+      /* Look up an explicit specialization, if any.  */
+      tree tid = lookup_template_variable (gen_tmpl, gen_args);
+      tree elt = most_specialized_partial_spec (tid, tf_warning_or_error);
+      if (elt && elt != error_mark_node)
+       {
+         td = TREE_VALUE (elt);
+         args = TREE_PURPOSE (elt);
+       }
+    }
+
    code_pattern = DECL_TEMPLATE_RESULT (td);
  
    /* We should never be trying to instantiate a member of a class
@@ -21733,9 +21733,7 @@ instantiate_decl (tree d, int defer_ok,
         outside the class, we may have too many arguments.  Drop the
         ones we don't need.  The same is true for specializations.  */
      args = get_innermost_template_args
-      (gen_args, TMPL_PARMS_DEPTH  (DECL_TEMPLATE_PARMS (td)));
-  else
-    args = gen_args;
+      (args, TMPL_PARMS_DEPTH (DECL_TEMPLATE_PARMS (td)));
  
    if (TREE_CODE (d) == FUNCTION_DECL)
      {
@@ -21901,7 +21899,7 @@ instantiate_decl (tree d, int defer_ok,
  
    /* Regenerate the declaration in case the template has been modified
       by a subsequent redeclaration.  */
-  regenerate_decl_from_template (d, td);
+  regenerate_decl_from_template (d, td, args);
  
    /* We already set the file and line above.  Reset them now in case
       they changed as a result of calling regenerate_decl_from_template.  */
diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c

index e59b3c5..ae409e6 100644 (file)
--- a/gcc/cp/semantics.c
+++ b/gcc/cp/semantics.c
@@ -5884,7 +5884,8 @@ finish_omp_clauses (tree clauses, bool allow_fields, bool declare_simd)
                 }
               if (TREE_CODE (type) == REFERENCE_TYPE)
                 type = TREE_TYPE (type);
-             if (!INTEGRAL_TYPE_P (type)
+             if (OMP_CLAUSE_LINEAR_KIND (c) != OMP_CLAUSE_LINEAR_REF
+                 && !INTEGRAL_TYPE_P (type)
                   && TREE_CODE (type) != POINTER_TYPE)
                 {
                   error ("linear clause applied to non-integral non-pointer "
diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c

index cef5604..24bfed7 100644 (file)
--- a/gcc/cp/typeck.c
+++ b/gcc/cp/typeck.c
@@ -111,7 +111,7 @@ complete_type (tree type)
  
    if (type == error_mark_node || COMPLETE_TYPE_P (type))
      ;
-  else if (TREE_CODE (type) == ARRAY_TYPE && TYPE_DOMAIN (type))
+  else if (TREE_CODE (type) == ARRAY_TYPE)
      {
        tree t = complete_type (TREE_TYPE (type));
        unsigned int needs_constructing, has_nontrivial_dtor;
diff --git a/gcc/cp/typeck2.c b/gcc/cp/typeck2.c

index e59ad51..3645571 100644 (file)
--- a/gcc/cp/typeck2.c
+++ b/gcc/cp/typeck2.c
@@ -951,10 +951,12 @@ check_narrowing (tree type, tree init, tsubst_flags_t complain)
         {
           if (complain & tf_warning_or_error)
             {
-             if (!almost_ok || pedantic)
-               pedwarn (loc, OPT_Wnarrowing, "narrowing conversion of %qE "
-                        "from %qT to %qT inside { }", init, ftype, type);
-             if (pedantic && almost_ok)
+             if ((!almost_ok || pedantic)
+                 && pedwarn (loc, OPT_Wnarrowing,
+                             "narrowing conversion of %qE "
+                             "from %qT to %qT inside { }",
+                             init, ftype, type)
+                 && almost_ok)
                 inform (loc, " the expression has a constant value but is not "
                         "a C++ constant-expression");
               ok = true;
diff --git a/gcc/doc/extend.texi b/gcc/doc/extend.texi

index a5a8b23..211f2c8 100644 (file)
--- a/gcc/doc/extend.texi
+++ b/gcc/doc/extend.texi
@@ -13863,6 +13863,23 @@ The @code{__builtin_divde}, @code{__builtin_divdeo},
  64-bit environment support ISA 2.06 or later.
  
  The following built-in functions are available for the PowerPC family
+of processors, starting with ISA 3.0 or later (@option{-mcpu=power9}
+or @option{-mmodulo}):
+@smallexample
+long long __builtin_darn (void);
+long long __builtin_darn_raw (void);
+int __builtin_darn_32 (void);
+@end smallexample
+
+The @code{__builtin_darn} and @code{__builtin_darn_raw}
+functions require a
+64-bit environment supporting ISA 3.0 or later.
+The @code{__builtin_darn} function provides a 64-bit conditioned
+random number.  The @code{__builtin_darn_raw} function provides a
+64-bit raw random number.  The @code{__builtin_darn_32} function
+provides a 32-bit random number.
+
+The following built-in functions are available for the PowerPC family
  of processors when hardware decimal floating point
  (@option{-mhard-dfp}) is available:
  @smallexample
@@ -15932,6 +15949,18 @@ void vec_st (vector double, int, vector double *);
  void vec_st (vector double, int, double *);
  vector double vec_sub (vector double, vector double);
  vector double vec_trunc (vector double);
+vector double vec_xl (int, vector double *);
+vector double vec_xl (int, double *);
+vector long long vec_xl (int, vector long long *);
+vector long long vec_xl (int, long long *);
+vector unsigned long long vec_xl (int, vector unsigned long long *);
+vector unsigned long long vec_xl (int, unsigned long long *);
+vector float vec_xl (int, vector float *);
+vector float vec_xl (int, float *);
+vector int vec_xl (int, vector int *);
+vector int vec_xl (int, int *);
+vector unsigned int vec_xl (int, vector unsigned int *);
+vector unsigned int vec_xl (int, unsigned int *);
  vector double vec_xor (vector double, vector double);
  vector double vec_xor (vector double, vector bool long);
  vector double vec_xor (vector bool long, vector double);
@@ -15941,6 +15970,18 @@ vector long vec_xor (vector bool long, vector long);
  vector unsigned long vec_xor (vector unsigned long, vector unsigned long);
  vector unsigned long vec_xor (vector unsigned long, vector bool long);
  vector unsigned long vec_xor (vector bool long, vector unsigned long);
+void vec_xst (vector double, int, vector double *);
+void vec_xst (vector double, int, double *);
+void vec_xst (vector long long, int, vector long long *);
+void vec_xst (vector long long, int, long long *);
+void vec_xst (vector unsigned long long, int, vector unsigned long long *);
+void vec_xst (vector unsigned long long, int, unsigned long long *);
+void vec_xst (vector float, int, vector float *);
+void vec_xst (vector float, int, float *);
+void vec_xst (vector int, int, vector int *);
+void vec_xst (vector int, int, int *);
+void vec_xst (vector unsigned int, int, vector unsigned int *);
+void vec_xst (vector unsigned int, int, unsigned int *);
  int vec_all_eq (vector double, vector double);
  int vec_all_ge (vector double, vector double);
  int vec_all_gt (vector double, vector double);
@@ -16055,7 +16096,7 @@ if the VSX instruction set is available.  The @samp{vec_vsx_ld} and
  @samp{LXVW4X}, @samp{STXVD2X}, and @samp{STXVW4X} instructions.
  
  If the ISA 2.07 additions to the vector/scalar (power8-vector)
-instruction set is available, the following additional functions are
+instruction set are available, the following additional functions are
  available for both 32-bit and 64-bit targets.  For 64-bit targets, you
  can use @var{vector long} instead of @var{vector long long},
  @var{vector bool long} instead of @var{vector bool long long}, and
@@ -16368,7 +16409,7 @@ vector unsigned long long vec_vupklsw (vector int);
  @end smallexample
  
  If the ISA 2.07 additions to the vector/scalar (power8-vector)
-instruction set is available, the following additional functions are
+instruction set are available, the following additional functions are
  available for 64-bit targets.  New vector types
  (@var{vector __int128_t} and @var{vector __uint128_t}) are available
  to hold the @var{__int128_t} and @var{__uint128_t} types to use these
@@ -16423,6 +16464,60 @@ int __builtin_bcdsub_gt (vector __int128_t, vector__int128_t);
  int __builtin_bcdsub_ov (vector __int128_t, vector__int128_t);
  @end smallexample
  
+If the ISA 3.00 additions to the vector/scalar (power9-vector)
+instruction set are available:
+
+@smallexample
+vector long long vec_vctz (vector long long);
+vector unsigned long long vec_vctz (vector unsigned long long);
+vector int vec_vctz (vector int);
+vector unsigned int vec_vctz (vector int);
+vector short vec_vctz (vector short);
+vector unsigned short vec_vctz (vector unsigned short);
+vector signed char vec_vctz (vector signed char);
+vector unsigned char vec_vctz (vector unsigned char);
+
+vector signed char vec_vctzb (vector signed char);
+vector unsigned char vec_vctzb (vector unsigned char);
+
+vector long long vec_vctzd (vector long long);
+vector unsigned long long vec_vctzd (vector unsigned long long);
+
+vector short vec_vctzh (vector short);
+vector unsigned short vec_vctzh (vector unsigned short);
+
+vector int vec_vctzw (vector int);
+vector unsigned int vec_vctzw (vector int);
+
+vector int vec_vprtyb (vector int);
+vector unsigned int vec_vprtyb (vector unsigned int);
+vector long long vec_vprtyb (vector long long);
+vector unsigned long long vec_vprtyb (vector unsigned long long);
+
+vector int vec_vprtybw (vector int);
+vector unsigned int vec_vprtybw (vector unsigned int);
+
+vector long long vec_vprtybd (vector long long);
+vector unsigned long long vec_vprtybd (vector unsigned long long);
+@end smallexample
+
+
+If the ISA 3.00 additions to the vector/scalar (power9-vector)
+instruction set are available for 64-bit targets:
+
+@smallexample
+vector long vec_vprtyb (vector long);
+vector unsigned long vec_vprtyb (vector unsigned long);
+vector __int128_t vec_vprtyb (vector __int128_t);
+vector __uint128_t vec_vprtyb (vector __uint128_t);
+
+vector long vec_vprtybd (vector long);
+vector unsigned long vec_vprtybd (vector unsigned long);
+
+vector __int128_t vec_vprtybq (vector __int128_t);
+vector __uint128_t vec_vprtybd (vector __uint128_t);
+@end smallexample
+
  If the cryptographic instructions are enabled (@option{-mcrypto} or
  @option{-mcpu=power8}), the following builtins are enabled.
  
@@ -16483,6 +16578,28 @@ The second argument to the @var{__builtin_crypto_vshasigmad} and
  integer that is 0 or 1.  The third argument to these builtin functions
  must be a constant integer in the range of 0 to 15.
  
+If the ISA 3.00 additions to the vector/scalar (power9-vector)
+instruction set are available, the following additional functions are
+available for both 32-bit and 64-bit targets.
+
+vector short vec_xl (int, vector short *);
+vector short vec_xl (int, short *);
+vector unsigned short vec_xl (int, vector unsigned short *);
+vector unsigned short vec_xl (int, unsigned short *);
+vector char vec_xl (int, vector char *);
+vector char vec_xl (int, char *);
+vector unsigned char vec_xl (int, vector unsigned char *);
+vector unsigned char vec_xl (int, unsigned char *);
+
+void vec_xst (vector short, int, vector short *);
+void vec_xst (vector short, int, short *);
+void vec_xst (vector unsigned short, int, vector unsigned short *);
+void vec_xst (vector unsigned short, int, unsigned short *);
+void vec_xst (vector char, int, vector char *);
+void vec_xst (vector char, int, char *);
+void vec_xst (vector unsigned char, int, vector unsigned char *);
+void vec_xst (vector unsigned char, int, unsigned char *);
+
  @node PowerPC Hardware Transactional Memory Built-in Functions
  @subsection PowerPC Hardware Transactional Memory Built-in Functions
  GCC provides two interfaces for accessing the Hardware Transactional
@@ -17116,6 +17233,45 @@ int64_t __builtin_vis_xmulx (int64_t, int64_t);
  int64_t __builtin_vis_xmulxhi (int64_t, int64_t);
  @end smallexample
  
+When you use the @option{-mvis4} switch, the VIS version 4.0 built-in
+functions also become available:
+
+@smallexample
+v8qi __builtin_vis_fpadd8 (v8qi, v8qi);
+v8qi __builtin_vis_fpadds8 (v8qi, v8qi);
+v8qi __builtin_vis_fpaddus8 (v8qi, v8qi);
+v4hi __builtin_vis_fpaddus16 (v4hi, v4hi);
+
+v8qi __builtin_vis_fpsub8 (v8qi, v8qi);
+v8qi __builtin_vis_fpsubs8 (v8qi, v8qi);
+v8qi __builtin_vis_fpsubus8 (v8qi, v8qi);
+v4hi __builtin_vis_fpsubus16 (v4hi, v4hi);
+
+long __builtin_vis_fpcmple8 (v8qi, v8qi);
+long __builtin_vis_fpcmpgt8 (v8qi, v8qi);
+long __builtin_vis_fpcmpule16 (v4hi, v4hi);
+long __builtin_vis_fpcmpugt16 (v4hi, v4hi);
+long __builtin_vis_fpcmpule32 (v2si, v2si);
+long __builtin_vis_fpcmpugt32 (v2si, v2si);
+
+v8qi __builtin_vis_fpmax8 (v8qi, v8qi);
+v4hi __builtin_vis_fpmax16 (v4hi, v4hi);
+v2si __builtin_vis_fpmax32 (v2si, v2si);
+
+v8qi __builtin_vis_fpmaxu8 (v8qi, v8qi);
+v4hi __builtin_vis_fpmaxu16 (v4hi, v4hi);
+v2si __builtin_vis_fpmaxu32 (v2si, v2si);
+
+
+v8qi __builtin_vis_fpmin8 (v8qi, v8qi);
+v4hi __builtin_vis_fpmin16 (v4hi, v4hi);
+v2si __builtin_vis_fpmin32 (v2si, v2si);
+
+v8qi __builtin_vis_fpminu8 (v8qi, v8qi);
+v4hi __builtin_vis_fpminu16 (v4hi, v4hi);
+v2si __builtin_vis_fpminu32 (v2si, v2si);
+@end smallexample
+
  @node SPU Built-in Functions
  @subsection SPU Built-in Functions
  
diff --git a/gcc/doc/install.texi b/gcc/doc/install.texi

index 4268036..84c028f 100644 (file)
--- a/gcc/doc/install.texi
+++ b/gcc/doc/install.texi
@@ -1241,7 +1241,7 @@ This option is only supported on some targets, including ARC, ARM, i386, M68k,
  PowerPC, and SPARC@.  It is mandatory for ARC@.  The @option{--with-cpu-32} and
  @option{--with-cpu-64} options specify separate default CPUs for
  32-bit and 64-bit modes; these options are only supported for i386,
-x86-64 and PowerPC.
+x86-64, PowerPC, and SPARC@.
  
  @item --with-schedule=@var{cpu}
  @itemx --with-arch=@var{cpu}
diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi

index 2ad3e9a..dc9be94 100644 (file)
--- a/gcc/doc/invoke.texi
+++ b/gcc/doc/invoke.texi
@@ -996,14 +996,15 @@ See RS/6000 and PowerPC Options.
  -mpointers-to-nested-functions -mno-pointers-to-nested-functions @gol
  -msave-toc-indirect -mno-save-toc-indirect @gol
  -mpower8-fusion -mno-mpower8-fusion -mpower8-vector -mno-power8-vector @gol
--mcrypto -mno-crypto -mdirect-move -mno-direct-move @gol
+-mcrypto -mno-crypto -mhtm -mno-htm -mdirect-move -mno-direct-move @gol
  -mquad-memory -mno-quad-memory @gol
  -mquad-memory-atomic -mno-quad-memory-atomic @gol
  -mcompat-align-parm -mno-compat-align-parm @gol
  -mupper-regs-df -mno-upper-regs-df -mupper-regs-sf -mno-upper-regs-sf @gol
  -mupper-regs -mno-upper-regs -mmodulo -mno-modulo @gol
  -mfloat128 -mno-float128 -mfloat128-hardware -mno-float128-hardware @gol
--mpower9-fusion -mno-mpower9-fusion -mpower9-vector -mno-power9-vector}
+-mpower9-fusion -mno-mpower9-fusion -mpower9-vector -mno-power9-vector @gol
+-mpower9-dform -mno-power9-dform -mlra -mno-lra}
  
  @emph{RX Options}
  @gccoptlist{-m64bit-doubles  -m32bit-doubles  -fpu  -nofpu@gol
@@ -13666,7 +13667,6 @@ Enable the use of indexed loads.  This can be problematic because some
  optimizers then assume that indexed stores exist, which is not
  the case.
  
-@item -mlra
  @opindex mlra
  Enable Local Register Allocation.  This is still experimental for ARC,
  so by default the compiler uses standard reload
@@ -19876,9 +19876,9 @@ following options:
  -mpopcntb -mpopcntd  -mpowerpc64 @gol
  -mpowerpc-gpopt  -mpowerpc-gfxopt  -msingle-float -mdouble-float @gol
  -msimple-fpu -mstring  -mmulhw  -mdlmzb  -mmfpgpr -mvsx @gol
--mcrypto -mdirect-move -mpower8-fusion -mpower8-vector @gol
+-mcrypto -mdirect-move -mhtm -mpower8-fusion -mpower8-vector @gol
  -mquad-memory -mquad-memory-atomic -mmodulo -mfloat128 -mfloat128-hardware @gol
--mpower9-fusion -mpower9-vector}
+-mpower9-fusion -mpower9-vector -mpower9-dform}
  
  The particular options set for any particular CPU varies between
  compiler versions, depending on what setting seems to produce optimal
@@ -20002,6 +20002,12 @@ This switch enables or disables the generation of ISEL instructions.
  This switch has been deprecated.  Use @option{-misel} and
  @option{-mno-isel} instead.
  
+@item -mlra
+@opindex mlra
+Enable Local Register Allocation.  This is still experimental for PowerPC,
+so by default the compiler uses standard reload
+(i.e. @option{-mno-lra}).
+
  @item -mspe
  @itemx -mno-spe
  @opindex mspe
@@ -20044,6 +20050,14 @@ Generate code that uses (does not use) the instructions to move data
  between the general purpose registers and the vector/scalar (VSX)
  registers that were added in version 2.07 of the PowerPC ISA.
  
+@item -mhtm
+@itemx -mno-htm
+@opindex mhtm
+@opindex mno-htm
+Enable (disable) the use of the built-in functions that allow direct
+access to the Hardware Transactional Memory (HTM) instructions that
+were added in version 2.07 of the PowerPC ISA.
+
  @item -mpower8-fusion
  @itemx -mno-power8-fusion
  @opindex mpower8-fusion
@@ -20151,10 +20165,19 @@ processors.
  @opindex mpower9-vector
  @opindex mno-power9-vector
  Generate code that uses (does not use) the vector and scalar
-instructions that were added in version 2.07 of the PowerPC ISA.  Also
+instructions that were added in version 3.0 of the PowerPC ISA.  Also
  enable the use of built-in functions that allow more direct access to
  the vector instructions.
  
+@item -mpower9-dform
+@itemx -mno-power9-dform
+@opindex mpower9-dform
+@opindex mno-power9-dform
+Enable (disable) scalar d-form (register + offset) memory instructions
+to load/store traditional Altivec registers. If the @var{LRA} register
+allocator is enabled, also enable (disable) vector d-form memory
+instructions.
+
  @item -mfloat-gprs=@var{yes/single/double/no}
  @itemx -mfloat-gprs
  @opindex mfloat-gprs
@@ -22067,7 +22090,7 @@ for machine type @var{cpu_type}.  Supported values for @var{cpu_type} are
  @samp{leon}, @samp{leon3}, @samp{leon3v7}, @samp{sparclite}, @samp{f930},
  @samp{f934}, @samp{sparclite86x}, @samp{sparclet}, @samp{tsc701}, @samp{v9},
  @samp{ultrasparc}, @samp{ultrasparc3}, @samp{niagara}, @samp{niagara2},
-@samp{niagara3} and @samp{niagara4}.
+@samp{niagara3}, @samp{niagara4} and @samp{niagara7}.
  
  Native Solaris and GNU/Linux toolchains also support the value @samp{native},
  which selects the best architecture option for the host processor.
@@ -22095,7 +22118,7 @@ f930, f934, sparclite86x
  tsc701
  
  @item v9
-ultrasparc, ultrasparc3, niagara, niagara2, niagara3, niagara4
+ultrasparc, ultrasparc3, niagara, niagara2, niagara3, niagara4, niagara7
  @end table
  
  By default (unless configured otherwise), GCC generates code for the V7
@@ -22137,7 +22160,9 @@ Sun UltraSPARC T1 chips.  With @option{-mcpu=niagara2}, the compiler
  additionally optimizes it for Sun UltraSPARC T2 chips. With
  @option{-mcpu=niagara3}, the compiler additionally optimizes it for Sun
  UltraSPARC T3 chips.  With @option{-mcpu=niagara4}, the compiler
-additionally optimizes it for Sun UltraSPARC T4 chips.
+additionally optimizes it for Sun UltraSPARC T4 chips.  With
+@option{-mcpu=niagara7}, the compiler additionally optimizes it for
+Oracle SPARC M7 chips.
  
  @item -mtune=@var{cpu_type}
  @opindex mtune
@@ -22147,12 +22172,13 @@ option @option{-mcpu=@var{cpu_type}} does.
  
  The same values for @option{-mcpu=@var{cpu_type}} can be used for
  @option{-mtune=@var{cpu_type}}, but the only useful values are those
-that select a particular CPU implementation.  Those are @samp{cypress},
-@samp{supersparc}, @samp{hypersparc}, @samp{leon}, @samp{leon3},
-@samp{leon3v7}, @samp{f930}, @samp{f934}, @samp{sparclite86x}, @samp{tsc701},
-@samp{ultrasparc}, @samp{ultrasparc3}, @samp{niagara}, @samp{niagara2},
-@samp{niagara3} and @samp{niagara4}.  With native Solaris and GNU/Linux
-toolchains, @samp{native} can also be used.
+that select a particular CPU implementation.  Those are
+@samp{cypress}, @samp{supersparc}, @samp{hypersparc}, @samp{leon},
+@samp{leon3}, @samp{leon3v7}, @samp{f930}, @samp{f934},
+@samp{sparclite86x}, @samp{tsc701}, @samp{ultrasparc},
+@samp{ultrasparc3}, @samp{niagara}, @samp{niagara2}, @samp{niagara3},
+@samp{niagara4} and @samp{niagara7}.  With native Solaris and
+GNU/Linux toolchains, @samp{native} can also be used.
  
  @item -mv8plus
  @itemx -mno-v8plus
@@ -22190,6 +22216,16 @@ default is @option{-mvis3} when targeting a cpu that supports such
  instructions, such as niagara-3 and later.  Setting @option{-mvis3}
  also sets @option{-mvis2} and @option{-mvis}.
  
+@item -mvis4
+@itemx -mno-vis4
+@opindex mvis4
+@opindex mno-vis4
+With @option{-mvis4}, GCC generates code that takes advantage of
+version 4.0 of the UltraSPARC Visual Instruction Set extensions.  The
+default is @option{-mvis4} when targeting a cpu that supports such
+instructions, such as niagara-7 and later.  Setting @option{-mvis4}
+also sets @option{-mvis3}, @option{-mvis2} and @option{-mvis}.
+
  @item -mcbcond
  @itemx -mno-cbcond
  @opindex mcbcond
diff --git a/gcc/doc/md.texi b/gcc/doc/md.texi

index e3844ac..c5917d1 100644 (file)
--- a/gcc/doc/md.texi
+++ b/gcc/doc/md.texi
@@ -3214,6 +3214,9 @@ Floating point register if the LFIWZX instruction is enabled or NO_REGS.
  @item wD
  Int constant that is the element number of the 64-bit scalar in a vector.
  
+@item wE
+Vector constant that can be loaded with the XXSPLTIB instruction.
+
  @item wF
  Memory operand suitable for power9 fusion load/stores.
  
@@ -3221,13 +3224,22 @@ Memory operand suitable for power9 fusion load/stores.
  Memory operand suitable for TOC fusion memory references.
  
  @item wL
-Int constant that is the element number that the MFVSRLD instruction
+Int constant that is the element number that the MFVSRLD instruction.
  targets.
  
+@item wM
+Match vector constant with all 1's if the XXLORC instruction is available.
+
+@item wO
+A memory operand suitable for the ISA 3.0 vector d-form instructions.
+
  @item wQ
  A memory address that will work with the @code{lq} and @code{stq}
  instructions.
  
+@item wS
+Vector constant that can be loaded with XXSPLTIB & sign extension.
+
  @item h
  @samp{MQ}, @samp{CTR}, or @samp{LINK} register
  
diff --git a/gcc/dwarf2out.c b/gcc/dwarf2out.c

index 80f2df5..f01c15b 100644 (file)
--- a/gcc/dwarf2out.c
+++ b/gcc/dwarf2out.c
@@ -17805,7 +17805,7 @@ native_encode_initializer (tree init, unsigned char *array, int size)
               fieldsize = tree_to_shwi (DECL_SIZE_UNIT (field));
               pos = int_byte_position (field);
               gcc_assert (pos + fieldsize <= size);
-             if (val
+             if (val && fieldsize != 0
                   && !native_encode_initializer (val, array + pos, fieldsize))
                 return false;
             }
@@ -19401,11 +19401,13 @@ gen_entry_point_die (tree decl, dw_die_ref context_die)
  static void
  retry_incomplete_types (void)
  {
+  set_early_dwarf s;
    int i;
  
    for (i = vec_safe_length (incomplete_types) - 1; i >= 0; i--)
      if (should_emit_struct_debug ((*incomplete_types)[i], DINFO_USAGE_DIR_USE))
        gen_type_die ((*incomplete_types)[i], comp_unit_die ());
+  vec_safe_truncate (incomplete_types, 0);
  }
  
  /* Determine what tag to use for a record type.  */
@@ -27382,10 +27384,6 @@ dwarf2out_finish (const char *filename)
    resolve_addr (comp_unit_die ());
    move_marked_base_types ();
  
-  /* Walk through the list of incomplete types again, trying once more to
-     emit full debugging info for them.  */
-  retry_incomplete_types ();
-
    if (flag_eliminate_unused_debug_types)
      prune_unused_types ();
  
@@ -27686,6 +27684,10 @@ dwarf2out_finish (const char *filename)
  static void
  dwarf2out_early_finish (void)
  {
+  /* Walk through the list of incomplete types again, trying once more to
+     emit full debugging info for them.  */
+  retry_incomplete_types ();
+
    /* The point here is to flush out the limbo list so that it is empty
       and we don't need to stream it for LTO.  */
    flush_limbo_die_list ();
diff --git a/gcc/fold-const.c b/gcc/fold-const.c

index bb4a556..cd75f2f 100644 (file)
--- a/gcc/fold-const.c
+++ b/gcc/fold-const.c
@@ -117,14 +117,8 @@ static enum tree_code compcode_to_comparison (enum comparison_code);
  static int operand_equal_for_comparison_p (tree, tree, tree);
  static int twoval_comparison_p (tree, tree *, tree *, int *);
  static tree eval_subst (location_t, tree, tree, tree, tree, tree);
-static tree make_bit_field_ref (location_t, tree, tree,
-                               HOST_WIDE_INT, HOST_WIDE_INT, int, int);
  static tree optimize_bit_field_compare (location_t, enum tree_code,
                                         tree, tree, tree);
-static tree decode_field_reference (location_t, tree, HOST_WIDE_INT *,
-                                   HOST_WIDE_INT *,
-                                   machine_mode *, int *, int *, int *,
-                                   tree *, tree *);
  static int simple_operand_p (const_tree);
  static bool simple_operand_p_2 (tree);
  static tree range_binop (enum tree_code, tree, tree, int, tree, int);
@@ -836,11 +830,10 @@ split_tree (location_t loc, tree in, tree type, enum tree_code code,
         *minus_litp = *litp, *litp = 0;
        if (neg_conp_p)
         *conp = negate_expr (*conp);
-      if (neg_var_p)
+      if (neg_var_p && var)
         {
-         /* Convert to TYPE before negating a pointer type expr.  */
-         if (var && POINTER_TYPE_P (TREE_TYPE (var)))
-           var = fold_convert_loc (loc, type, var);
+         /* Convert to TYPE before negating.  */
+         var = fold_convert_loc (loc, type, var);
           var = negate_expr (var);
         }
      }
@@ -863,10 +856,12 @@ split_tree (location_t loc, tree in, tree type, enum tree_code code,
        else if (*minus_litp)
         *litp = *minus_litp, *minus_litp = 0;
        *conp = negate_expr (*conp);
-      /* Convert to TYPE before negating a pointer type expr.  */
-      if (var && POINTER_TYPE_P (TREE_TYPE (var)))
-       var = fold_convert_loc (loc, type, var);
-      var = negate_expr (var);
+      if (var)
+       {
+         /* Convert to TYPE before negating.  */
+         var = fold_convert_loc (loc, type, var);
+         var = negate_expr (var);
+       }
      }
  
    return var;
@@ -3781,15 +3776,23 @@ distribute_real_division (location_t loc, enum tree_code code, tree type,
  \f
  /* Return a BIT_FIELD_REF of type TYPE to refer to BITSIZE bits of INNER
     starting at BITPOS.  The field is unsigned if UNSIGNEDP is nonzero
-   and uses reverse storage order if REVERSEP is nonzero.  */
+   and uses reverse storage order if REVERSEP is nonzero.  ORIG_INNER
+   is the original memory reference used to preserve the alias set of
+   the access.  */
  
  static tree
-make_bit_field_ref (location_t loc, tree inner, tree type,
+make_bit_field_ref (location_t loc, tree inner, tree orig_inner, tree type,
                     HOST_WIDE_INT bitsize, HOST_WIDE_INT bitpos,
                     int unsignedp, int reversep)
  {
    tree result, bftype;
  
+  if (get_alias_set (inner) != get_alias_set (orig_inner))
+    inner = fold_build2 (MEM_REF, TREE_TYPE (inner),
+                        build_fold_addr_expr (inner),
+                        build_int_cst
+                         (reference_alias_ptr_type (orig_inner), 0));
+
    if (bitpos == 0 && !reversep)
      {
        tree size = TYPE_SIZE (TREE_TYPE (inner));
@@ -3915,13 +3918,13 @@ optimize_bit_field_compare (location_t loc, enum tree_code code,
         and return.  */
      return fold_build2_loc (loc, code, compare_type,
                         fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
-                                    make_bit_field_ref (loc, linner,
+                                    make_bit_field_ref (loc, linner, lhs,
                                                          unsigned_type,
                                                          nbitsize, nbitpos,
                                                          1, lreversep),
                                      mask),
                         fold_build2_loc (loc, BIT_AND_EXPR, unsigned_type,
-                                    make_bit_field_ref (loc, rinner,
+                                    make_bit_field_ref (loc, rinner, rhs,
                                                          unsigned_type,
                                                          nbitsize, nbitpos,
                                                          1, rreversep),
@@ -3966,8 +3969,8 @@ optimize_bit_field_compare (location_t loc, enum tree_code code,
    /* Make a new bitfield reference, shift the constant over the
       appropriate number of bits and mask it with the computed mask
       (in case this was a signed field).  If we changed it, make a new one.  */
-  lhs = make_bit_field_ref (loc, linner, unsigned_type, nbitsize, nbitpos, 1,
-                           lreversep);
+  lhs = make_bit_field_ref (loc, linner, lhs, unsigned_type,
+                           nbitsize, nbitpos, 1, lreversep);
  
    rhs = const_binop (BIT_AND_EXPR,
                      const_binop (LSHIFT_EXPR,
@@ -4006,11 +4009,12 @@ optimize_bit_field_compare (location_t loc, enum tree_code code,
     do anything with.  */
  
  static tree
-decode_field_reference (location_t loc, tree exp, HOST_WIDE_INT *pbitsize,
+decode_field_reference (location_t loc, tree *exp_, HOST_WIDE_INT *pbitsize,
                         HOST_WIDE_INT *pbitpos, machine_mode *pmode,
                         int *punsignedp, int *preversep, int *pvolatilep,
                         tree *pmask, tree *pand_mask)
  {
+  tree exp = *exp_;
    tree outer_type = 0;
    tree and_mask = 0;
    tree mask, inner, offset;
@@ -4047,6 +4051,8 @@ decode_field_reference (location_t loc, tree exp, HOST_WIDE_INT *pbitsize,
        || TREE_CODE (inner) == PLACEHOLDER_EXPR)
      return 0;
  
+  *exp_ = exp;
+
    /* If the number of bits in the reference is the same as the bitsize of
       the outer type, then the outer type gives the signedness. Otherwise
       (in case of a small bitfield) the signedness is unchanged.  */
@@ -5655,19 +5661,19 @@ fold_truth_andor_1 (location_t loc, enum tree_code code, tree truth_type,
  
    ll_reversep = lr_reversep = rl_reversep = rr_reversep = 0;
    volatilep = 0;
-  ll_inner = decode_field_reference (loc, ll_arg,
+  ll_inner = decode_field_reference (loc, &ll_arg,
                                      &ll_bitsize, &ll_bitpos, &ll_mode,
                                      &ll_unsignedp, &ll_reversep, &volatilep,
                                      &ll_mask, &ll_and_mask);
-  lr_inner = decode_field_reference (loc, lr_arg,
+  lr_inner = decode_field_reference (loc, &lr_arg,
                                      &lr_bitsize, &lr_bitpos, &lr_mode,
                                      &lr_unsignedp, &lr_reversep, &volatilep,
                                      &lr_mask, &lr_and_mask);
-  rl_inner = decode_field_reference (loc, rl_arg,
+  rl_inner = decode_field_reference (loc, &rl_arg,
                                      &rl_bitsize, &rl_bitpos, &rl_mode,
                                      &rl_unsignedp, &rl_reversep, &volatilep,
                                      &rl_mask, &rl_and_mask);
-  rr_inner = decode_field_reference (loc, rr_arg,
+  rr_inner = decode_field_reference (loc, &rr_arg,
                                      &rr_bitsize, &rr_bitpos, &rr_mode,
                                      &rr_unsignedp, &rr_reversep, &volatilep,
                                      &rr_mask, &rr_and_mask);
@@ -5829,12 +5835,14 @@ fold_truth_andor_1 (location_t loc, enum tree_code code, tree truth_type,
        lr_mask = const_binop (BIT_IOR_EXPR, lr_mask, rr_mask);
        if (lnbitsize == rnbitsize && xll_bitpos == xlr_bitpos)
         {
-         lhs = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
+         lhs = make_bit_field_ref (loc, ll_inner, ll_arg,
+                                   lntype, lnbitsize, lnbitpos,
                                     ll_unsignedp || rl_unsignedp, ll_reversep);
           if (! all_ones_mask_p (ll_mask, lnbitsize))
             lhs = build2 (BIT_AND_EXPR, lntype, lhs, ll_mask);
  
-         rhs = make_bit_field_ref (loc, lr_inner, rntype, rnbitsize, rnbitpos,
+         rhs = make_bit_field_ref (loc, lr_inner, lr_arg,
+                                   rntype, rnbitsize, rnbitpos,
                                     lr_unsignedp || rr_unsignedp, lr_reversep);
           if (! all_ones_mask_p (lr_mask, rnbitsize))
             rhs = build2 (BIT_AND_EXPR, rntype, rhs, lr_mask);
@@ -5856,11 +5864,11 @@ fold_truth_andor_1 (location_t loc, enum tree_code code, tree truth_type,
         {
           tree type;
  
-         lhs = make_bit_field_ref (loc, ll_inner, lntype,
+         lhs = make_bit_field_ref (loc, ll_inner, ll_arg, lntype,
                                     ll_bitsize + rl_bitsize,
                                     MIN (ll_bitpos, rl_bitpos),
                                     ll_unsignedp, ll_reversep);
-         rhs = make_bit_field_ref (loc, lr_inner, rntype,
+         rhs = make_bit_field_ref (loc, lr_inner, lr_arg, rntype,
                                     lr_bitsize + rr_bitsize,
                                     MIN (lr_bitpos, rr_bitpos),
                                     lr_unsignedp, lr_reversep);
@@ -5925,7 +5933,8 @@ fold_truth_andor_1 (location_t loc, enum tree_code code, tree truth_type,
       reference we will make.  Unless the mask is all ones the width of
       that field, perform the mask operation.  Then compare with the
       merged constant.  */
-  result = make_bit_field_ref (loc, ll_inner, lntype, lnbitsize, lnbitpos,
+  result = make_bit_field_ref (loc, ll_inner, ll_arg,
+                              lntype, lnbitsize, lnbitpos,
                                ll_unsignedp || rl_unsignedp, ll_reversep);
  
    ll_mask = const_binop (BIT_IOR_EXPR, ll_mask, rl_mask);
@@ -8566,9 +8575,9 @@ fold_comparison (location_t loc, enum tree_code code, tree type,
           if ((offset0 == offset1
                || (offset0 && offset1
                    && operand_equal_p (offset0, offset1, 0)))
-             && (code == EQ_EXPR
-                 || code == NE_EXPR
-                 || (indirect_base0 && DECL_P (base0))
+             && (equality_code
+                 || (indirect_base0
+                     && (DECL_P (base0) || CONSTANT_CLASS_P (base0)))
                   || POINTER_TYPE_OVERFLOW_UNDEFINED))
  
             {
@@ -8607,7 +8616,8 @@ fold_comparison (location_t loc, enum tree_code code, tree type,
              6.5.6/8 and /9 with respect to the signed ptrdiff_t.  */
           else if (bitpos0 == bitpos1
                    && (equality_code
-                      || (indirect_base0 && DECL_P (base0))
+                      || (indirect_base0
+                          && (DECL_P (base0) || CONSTANT_CLASS_P (base0)))
                        || POINTER_TYPE_OVERFLOW_UNDEFINED))
             {
               /* By converting to signed sizetype we cover middle-end pointer
@@ -11631,9 +11641,9 @@ fold_ternary_loc (location_t loc, enum tree_code code, tree type,
        /* Convert A ? 0 : 1 to !A.  This prefers the use of NOT_EXPR
          over COND_EXPR in cases such as floating point comparisons.  */
        if (integer_zerop (op1)
-         && (code == VEC_COND_EXPR ? integer_all_onesp (op2)
-                                   : (integer_onep (op2)
-                                      && !VECTOR_TYPE_P (type)))
+         && code == COND_EXPR
+         && integer_onep (op2)
+         && !VECTOR_TYPE_P (type)
           && truth_value_p (TREE_CODE (arg0)))
         return pedantic_non_lvalue_loc (loc,
                                     fold_convert_loc (loc, type,
@@ -12305,7 +12315,8 @@ fold_checksum_tree (const_tree expr, struct md5_ctx *ctx,
                || TYPE_REFERENCE_TO (expr)
                || TYPE_CACHED_VALUES_P (expr)
                || TYPE_CONTAINS_PLACEHOLDER_INTERNAL (expr)
-              || TYPE_NEXT_VARIANT (expr)))
+              || TYPE_NEXT_VARIANT (expr)
+              || TYPE_ALIAS_SET_KNOWN_P (expr)))
      {
        /* Allow these fields to be modified.  */
        tree tmp;
@@ -12315,6 +12326,7 @@ fold_checksum_tree (const_tree expr, struct md5_ctx *ctx,
        TYPE_POINTER_TO (tmp) = NULL;
        TYPE_REFERENCE_TO (tmp) = NULL;
        TYPE_NEXT_VARIANT (tmp) = NULL;
+      TYPE_ALIAS_SET (tmp) = -1;
        if (TYPE_CACHED_VALUES_P (tmp))
         {
           TYPE_CACHED_VALUES_P (tmp) = 0;
diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog

index 386ac03..3b33827 100644 (file)
--- a/gcc/fortran/ChangeLog
+++ b/gcc/fortran/ChangeLog
@@ -1,3 +1,154 @@
+2016-06-12  Dominique d'Humieres  <dominiq@lps.ens.fr>
+
+       PR fortran/60751
+       * io.c (gfc_resolve_dt): Replace GFC_STD_GNU with GFC_STD_LEGACY.
+
+2016-06-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+       PR c/71381
+       Backport from trunk r237290:
+       * openmp.c (gfc_match_oacc_cache): Add comment.
+
+2016-06-05  Andre Vehreschild  <vehre@gcc.gnu.org>
+
+       PR fortran/69659
+       * trans-array.c (gfc_trans_dummy_array_bias): For class arrays use
+       the address of the _data component to reference the arrays data
+       component.
+
+2016-06-01  Paul Thomas  <pault@gcc.gnu.org>
+
+       PR fortran/71156
+       * decl.c (copy_prefix): Add checks that the module procedure
+       declaration prefixes are compliant with the interface. Invert
+       order of existing elemental and pure checks.
+       * resolve.c (resolve_fl_procedure): Invert order of elemental
+       and pure errors.
+
+2016-06-01  Jakub Jelinek  <jakub@redhat.com>
+
+       * parse.c (case_decl): Move ST_OMP_* to ...
+       (case_omp_decl): ... here, new macro.
+       (verify_st_order): For case_omp_decl, complain about
+       p->state >= ORDER_EXEC, but don't change p->state otherwise.
+
+2016-05-26  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+       Backport from trunk.
+       PR fortran/66461
+       * scanner.c (gfc_next_char_literal): Clear end_flag when adjusting
+       current locus back to old_locus.
+
+2016-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+       PR fortran/71204
+       * frontend-passes.c (realloc_string_callback): Clear inserted_block
+       and changed_statement before calling create_var.
+
+2016-05-15  Harald Anlauf  <anlauf@gmx.de>
+
+       PR fortran/69603
+       * interface.c (compare_parameter): Check for non-NULL pointer.
+
+2016-05-14  Fritz Reese  <fritzoreese@gmail.com>
+
+       Backport from trunk: r236242
+       * gfortran.texi: Update example of DEC UNION extension.
+
+       Backport from trunk: r236241
+       PR fortran/71047
+       * expr.c (gfc_default_initializer): Avoid extra component refs in
+       constructors for derived types and classes.
+
+       Backport from trunk: r235999
+       PR fortran/56226
+       * module.c (dt_upper_string): Rename to gfc_dt_upper_string
+       (dt_lower_string): Likewise.
+       * gfortran.h: Make new gfc_dt_upper/lower_string global.
+       * class.c: Use gfc_dt_upper_string.
+       * decl.c: Likewise.
+       * symbol.c: Likewise.
+       * resolve.c (resolve_component): New function.
+       (resolve_fl_derived0): Move component loop code to resolve_component.
+       * parse.c (check_component): New function.
+       (parse_derived): Move loop code to check_component.
+       * lang.opt, invoke.texi, options.c : New option -fdec-structure.
+       * libgfortran.h (bt): New basic type BT_UNION.
+       * gfortran.h (gfc_option): New option -fdec-structure.
+       (gfc_get_union_type, gfc_compare_union_types): New prototypes.
+       (gfc_bt_struct, gfc_fl_struct, case_bt_struct, case_fl_struct): New
+       macros.
+       (gfc_find_component): Change prototype.
+       * match.h (gfc_match_member_sep, gfc_match_map, gfc_match_union,
+       gfc_match_structure_decl): New prototypes.
+       * parse.h (gfc_comp_struct): New macro.
+       * symbol.c (gfc_find_component): Search for components in nested unions
+       * class.c (insert_component_ref, gfc_add_component_ref, add_proc_comp,
+       copy_vtab_proc_comps): Update calls to gfc_find_component.
+       * primary.c (gfc_convert_to_structure_constructor): Likewise.
+       * symbol.c (gfc_add_component): Likewise.
+       * resolve.c (resolve_typebound_function, resolve_typebound_subroutine,
+       resolve_typebound_procedure, resolve_component, resolve_fl_derived):
+       Likewise.
+       * expr.c (get_union_init, component_init): New functions.
+       * decl.c (match_clist_expr, match_record_decl, get_struct_decl,
+       gfc_match_map, gfc_match_union, gfc_match_structure_decl): Likewise.
+       * interface.c (compare_components, gfc_compare_union_types): Likewise.
+       * match.c (gfc_match_member_sep): Likewise.
+       * parse.c (check_component, parse_union, parse_struct_map): Likewise.
+       * resolve.c (resolve_fl_struct): Likewise.
+       * symbol.c (find_union_component): Likewise.
+       * trans-types.c (gfc_get_union_type): Likewise.
+       * parse.c (parse_derived): Use new functions.
+       * interface.c (gfc_compare_derived_types, gfc_compare_types): Likewise.
+       * expr.c (gfc_default_initializer): Likewise.
+       * gfortran.texi: Support for DEC structures, unions, and maps.
+       * gfortran.h (gfc_statement, sym_flavor): Likewise.
+       * check.c (gfc_check_kill_sub): Likewise.
+       * expr.c (gfc_copy_expr, simplify_const_ref,
+       gfc_has_default_initializer): Likewise.
+       * decl.c (build_sym, match_data_constant, add_init_expr_to_sym,
+       match_pointer_init, build_struct, variable_decl,
+       gfc_match_decl_type_spec, gfc_mach_data-decl, gfc_match_entry,
+       gfc_match_end, gfc_match_derived_decl): Likewise.
+       * interface.c (check_interface0, check_interface1,
+       gfc_search_interface): Likewise.
+       * misc.c (gfc_basic_typename, gfc_typename): Likewise.
+       * module.c (add_true_name, build_tnt, bt_types, mio_typespec,
+       fix_mio_expr, load_needed, mio_symbol, read_module, write_symbol,
+       gfc_get_module_backend_decl): Likewise.
+       * parse.h (gfc_compile_state): Likewise.
+       * parse.c (decode_specification_statement, decode_statement,
+       gfc_ascii_statement, verify_st_order, parse_spec): Likewise.
+       * primary.c (gfc_match_varspec, gfc_match_structure_constructor,
+       gfc_match_rvalue, match_variable): Likewise.
+       * resolve.c (find_arglists, resolve_structure_cons,
+       is_illegal_recursion, resolve_generic_f, get_declared_from_expr,
+       resolve_typebound_subroutine, resolve_allocate_expr,
+       nonscalar_typebound_assign, generate_component_assignments,
+       resolve_fl_variable_derived, check_defined_assignments,
+       resolve_component, resolve_symbol, resolve_equivalence_derived):
+       Likewise.
+       * symbol.c (flavors, check_conflict, gfc_add_flavor, gfc_use_derived,
+       gfc_restore_last_undo_checkpoint, gfc_type_compatible,
+       gfc_find_dt_in_generic): Likewise.
+       * trans-decl.c (gfc_get_module_backend_decl, create_function_arglist,
+       gfc_create_module_variable, check_constant_initializer): Likewise.
+       * trans-expr.c (gfc_conv_component_ref, gfc_conv_initializer,
+       gfc_trans_alloc_subarray_assign, gfc_trans_subcomponent_assign,
+       gfc_conv_structure, gfc_trans_scalar_assign, copyable_array_p):
+       Likewise.
+       * trans-io.c (transfer_namelist_element, transfer_expr,
+       gfc_trans_transfer): Likewise.
+       * trans-stmt.c (gfc_trans_deallocate): Likewise.
+       * trans-types.c (gfc_typenode_for_spec, gfc_copy_dt_decls_ifequal,
+       gfc_get_derived_type): Likewise.
+
+2016-05-11  Jakub Jelinek  <jakub@redhat.com>
+
+       PR fortran/70855
+       * frontend-passes.c (inline_matmul_assign): Disable in !$omp workshare.
+
  2016-04-29  Cesar Philippidis  <cesar@codesourcery.com>
  
         PR middle-end/70626
diff --git a/gcc/fortran/check.c b/gcc/fortran/check.c

index 05133c3..d26e45e 100644 (file)
--- a/gcc/fortran/check.c
+++ b/gcc/fortran/check.c
@@ -2592,7 +2592,7 @@ gfc_check_kill_sub (gfc_expr *pid, gfc_expr *sig, gfc_expr *status)
  bool
  gfc_check_kind (gfc_expr *x)
  {
-  if (x->ts.type == BT_DERIVED || x->ts.type == BT_CLASS)
+  if (gfc_bt_struct (x->ts.type) || x->ts.type == BT_CLASS)
      {
        gfc_error ("%qs argument of %qs intrinsic at %L must be of "
                  "intrinsic type", gfc_current_intrinsic_arg[0]->name,
diff --git a/gcc/fortran/class.c b/gcc/fortran/class.c

index 6a7339f..3627828 100644 (file)
--- a/gcc/fortran/class.c
+++ b/gcc/fortran/class.c
@@ -78,12 +78,11 @@ insert_component_ref (gfc_typespec *ts, gfc_ref **ref, const char * const name)
    gcc_assert (ts->type == BT_DERIVED || ts->type == BT_CLASS);
    type_sym = ts->u.derived;
  
-  new_ref = gfc_get_ref ();
-  new_ref->type = REF_COMPONENT;
-  new_ref->next = *ref;
-  new_ref->u.c.sym = type_sym;
-  new_ref->u.c.component = gfc_find_component (type_sym, name, true, true);
+  gfc_find_component (type_sym, name, true, true, &new_ref);
    gcc_assert (new_ref->u.c.component);
+  while (new_ref->next)
+    new_ref = new_ref->next;
+  new_ref->next = *ref;
  
    if (new_ref->next)
      {
@@ -206,8 +205,9 @@ gfc_fix_class_refs (gfc_expr *e)
  void
  gfc_add_component_ref (gfc_expr *e, const char *name)
  {
+  gfc_component *c;
    gfc_ref **tail = &(e->ref);
-  gfc_ref *next = NULL;
+  gfc_ref *ref, *next = NULL;
    gfc_symbol *derived = e->symtree->n.sym->ts.u.derived;
    while (*tail != NULL)
      {
@@ -237,14 +237,13 @@ gfc_add_component_ref (gfc_expr *e, const char *name)
    else
      /* Avoid losing memory.  */
      gfc_free_ref_list (*tail);
-  (*tail) = gfc_get_ref();
-  (*tail)->next = next;
-  (*tail)->type = REF_COMPONENT;
-  (*tail)->u.c.sym = derived;
-  (*tail)->u.c.component = gfc_find_component (derived, name, true, true);
-  gcc_assert((*tail)->u.c.component);
+  c = gfc_find_component (derived, name, true, true, tail);
+  gcc_assert (c);
+  for (ref = *tail; ref->next; ref = ref->next)
+    ;
+  ref->next = next;
    if (!next)
-    e->ts = (*tail)->u.c.component->ts;
+    e->ts = c->ts;
  }
  
  
@@ -477,8 +476,7 @@ get_unique_type_string (char *string, gfc_symbol *derived)
    if (derived->attr.unlimited_polymorphic)
      strcpy (dt_name, "STAR");
    else
-    strcpy (dt_name, derived->name);
-  dt_name[0] = TOUPPER (dt_name[0]);
+    strcpy (dt_name, gfc_dt_upper_string (derived->name));
    if (derived->attr.unlimited_polymorphic)
      sprintf (string, "_%s", dt_name);
    else if (derived->module)
@@ -751,7 +749,7 @@ add_proc_comp (gfc_symbol *vtype, const char *name, gfc_typebound_proc *tb)
    if (tb->non_overridable)
      return;
  
-  c = gfc_find_component (vtype, name, true, true);
+  c = gfc_find_component (vtype, name, true, true, NULL);
  
    if (c == NULL)
      {
@@ -820,7 +818,7 @@ copy_vtab_proc_comps (gfc_symbol *declared, gfc_symbol *vtype)
  
    for (cmp = vtab->ts.u.derived->components; cmp; cmp = cmp->next)
      {
-      if (gfc_find_component (vtype, cmp->name, true, true))
+      if (gfc_find_component (vtype, cmp->name, true, true, NULL))
         continue;
  
        add_proc_comp (vtype, cmp->name, cmp->tb);
diff --git a/gcc/fortran/decl.c b/gcc/fortran/decl.c

index 80ec39c..da33b22 100644 (file)
--- a/gcc/fortran/decl.c
+++ b/gcc/fortran/decl.c
@@ -391,13 +391,13 @@ match_data_constant (gfc_expr **result)
  
    if (sym == NULL
        || (sym->attr.flavor != FL_PARAMETER
-         && (!dt_sym || dt_sym->attr.flavor != FL_DERIVED)))
+         && (!dt_sym || !gfc_fl_struct (dt_sym->attr.flavor))))
      {
        gfc_error ("Symbol %qs must be a PARAMETER in DATA statement at %C",
                  name);
        return MATCH_ERROR;
      }
-  else if (dt_sym && dt_sym->attr.flavor == FL_DERIVED)
+  else if (dt_sym && gfc_fl_struct (dt_sym->attr.flavor))
      return gfc_match_structure_constructor (dt_sym, result);
  
    /* Check to see if the value is an initialization array expression.  */
@@ -606,6 +606,161 @@ cleanup:
  /************************ Declaration statements *********************/
  
  
+/* Like gfc_match_init_expr, but matches a 'clist' (old-style initialization
+   list). The difference here is the expression is a list of constants
+   and is surrounded by '/'. 
+   The typespec ts must match the typespec of the variable which the
+   clist is initializing.
+   The arrayspec tells whether this should match a list of constants 
+   corresponding to array elements or a scalar (as == NULL).  */
+
+static match
+match_clist_expr (gfc_expr **result, gfc_typespec *ts, gfc_array_spec *as)
+{
+  gfc_constructor_base array_head = NULL;
+  gfc_expr *expr = NULL;
+  match m;
+  locus where;
+  mpz_t repeat, size;
+  bool scalar;
+  int cmp;
+
+  gcc_assert (ts);
+
+  mpz_init_set_ui (repeat, 0);
+  mpz_init (size);
+  scalar = !as || !as->rank;
+
+  /* We have already matched '/' - now look for a constant list, as with
+     top_val_list from decl.c, but append the result to an array.  */
+  if (gfc_match ("/") == MATCH_YES)
+    {
+      gfc_error ("Empty old style initializer list at %C");
+      goto cleanup;
+    }
+
+  where = gfc_current_locus;
+  for (;;)
+    {
+      m = match_data_constant (&expr);
+      if (m != MATCH_YES)
+        expr = NULL; /* match_data_constant may set expr to garbage */
+      if (m == MATCH_NO)
+        goto syntax;
+      if (m == MATCH_ERROR)
+        goto cleanup;
+
+      /* Found r in repeat spec r*c; look for the constant to repeat.  */
+      if ( gfc_match_char ('*') == MATCH_YES)
+        {
+          if (scalar)
+            {
+              gfc_error ("Repeat spec invalid in scalar initializer at %C");
+              goto cleanup;
+            }
+          if (expr->ts.type != BT_INTEGER)
+            {
+              gfc_error ("Repeat spec must be an integer at %C");
+              goto cleanup;
+            }
+          mpz_set (repeat, expr->value.integer);
+          gfc_free_expr (expr);
+          expr = NULL;
+
+          m = match_data_constant (&expr);
+          if (m == MATCH_NO)
+            gfc_error ("Expected data constant after repeat spec at %C");
+          if (m != MATCH_YES)
+            goto cleanup;
+        }
+      /* No repeat spec, we matched the data constant itself. */
+      else
+        mpz_set_ui (repeat, 1);
+
+      if (!scalar)
+        {
+          /* Add the constant initializer as many times as repeated. */
+          for (; mpz_cmp_ui (repeat, 0) > 0; mpz_sub_ui (repeat, repeat, 1))
+            {
+              /* Make sure types of elements match */
+              if(ts && !gfc_compare_types (&expr->ts, ts)
+                    && !gfc_convert_type (expr, ts, 1))
+                goto cleanup;
+
+              gfc_constructor_append_expr (&array_head,
+                  gfc_copy_expr (expr), &gfc_current_locus);
+            }
+
+          gfc_free_expr (expr);
+          expr = NULL;
+        }
+
+      /* For scalar initializers quit after one element.  */
+      else
+        {
+          if(gfc_match_char ('/') != MATCH_YES)
+            {
+              gfc_error ("End of scalar initializer expected at %C");
+              goto cleanup;
+            }
+          break;
+        }
+
+      if (gfc_match_char ('/') == MATCH_YES)
+        break;
+      if (gfc_match_char (',') == MATCH_NO)
+        goto syntax;
+    }
+
+  /* Set up expr as an array constructor. */
+  if (!scalar)
+    {
+      expr = gfc_get_array_expr (ts->type, ts->kind, &where);
+      expr->ts = *ts;
+      expr->value.constructor = array_head;
+
+      expr->rank = as->rank;
+      expr->shape = gfc_get_shape (expr->rank);
+
+      /* Validate sizes. */
+      gcc_assert (gfc_array_size (expr, &size));
+      gcc_assert (spec_size (as, &repeat));
+      cmp = mpz_cmp (size, repeat);
+      if (cmp < 0)
+        gfc_error ("Not enough elements in array initializer at %C");
+      else if (cmp > 0)
+        gfc_error ("Too many elements in array initializer at %C");
+      if (cmp)
+        goto cleanup;
+    }
+
+  /* Make sure scalar types match. */
+  else if (!gfc_compare_types (&expr->ts, ts)
+           && !gfc_convert_type (expr, ts, 1))
+    goto cleanup;
+
+  if (expr->ts.u.cl)
+    expr->ts.u.cl->length_from_typespec = 1;
+
+  *result = expr;
+  mpz_clear (size);
+  mpz_clear (repeat);
+  return MATCH_YES;
+
+syntax:
+  gfc_error ("Syntax error in old style initializer list at %C");
+
+cleanup:
+  if (expr)
+    expr->value.constructor = NULL;
+  gfc_free_expr (expr);
+  gfc_constructor_free (array_head);
+  mpz_clear (size);
+  mpz_clear (repeat);
+  return MATCH_ERROR;
+}
+
+
  /* Auxiliary function to merge DIMENSION and CODIMENSION array specs.  */
  
  static bool
@@ -1239,7 +1394,8 @@ build_sym (const char *name, gfc_charlen *cl, bool cl_deferred,
  
        st = gfc_find_symtree (gfc_current_ns->sym_root, u_name);
  
-      if (st != 0)
+      /* STRUCTURE types can alias symbol names */
+      if (st != 0 && st->n.sym->attr.flavor != FL_STRUCT)
         {
           gfc_error ("Symbol %qs at %C also declared as a type at %L", name,
                      &st->n.sym->declared_at);
@@ -1469,7 +1625,7 @@ add_init_expr_to_sym (const char *name, gfc_expr **initp, locus *var_locus)
  
        /* Check if the assignment can happen. This has to be put off
          until later for derived type variables and procedure pointers.  */
-      if (sym->ts.type != BT_DERIVED && init->ts.type != BT_DERIVED
+      if (!gfc_bt_struct (sym->ts.type) && !gfc_bt_struct (init->ts.type)
           && sym->ts.type != BT_CLASS && init->ts.type != BT_CLASS
           && !sym->attr.proc_pointer
           && !gfc_check_assign_symbol (sym, NULL, init))
@@ -1608,7 +1764,7 @@ add_init_expr_to_sym (const char *name, gfc_expr **initp, locus *var_locus)
          If we mark my_int as iso_c (since we can see it's value
          is equal to one of the named constants), then my_int_2
          will be considered C interoperable.  */
-      if (sym->ts.type != BT_CHARACTER && sym->ts.type != BT_DERIVED)
+      if (sym->ts.type != BT_CHARACTER && !gfc_bt_struct (sym->ts.type))
         {
           sym->ts.is_iso_c |= init->ts.is_iso_c;
           sym->ts.is_c_interop |= init->ts.is_c_interop;
@@ -1666,6 +1822,7 @@ static bool
  build_struct (const char *name, gfc_charlen *cl, gfc_expr **init,
               gfc_array_spec **as)
  {
+  gfc_state_data *s;
    gfc_component *c;
    bool t = true;
  
@@ -1689,6 +1846,35 @@ build_struct (const char *name, gfc_charlen *cl, gfc_expr **init,
         }
      }
  
+  /* If we are in a nested union/map definition, gfc_add_component will not
+     properly find repeated components because:
+       (i) gfc_add_component does a flat search, where components of unions 
+           and maps are implicity chained so nested components may conflict.
+      (ii) Unions and maps are not linked as components of their parent
+           structures until after they are parsed.
+     For (i) we use gfc_find_component which searches recursively, and for (ii)
+     we search each block directly from the parse stack until we find the top
+     level structure.  */
+
+  s = gfc_state_stack;
+  if (s->state == COMP_UNION || s->state == COMP_MAP)
+    {
+      while (s->state == COMP_UNION || gfc_comp_struct (s->state))
+        {
+          c = gfc_find_component (s->sym, name, true, true, NULL);
+          if (c != NULL)
+            {
+              gfc_error_now ("Component '%s' at %C already declared at %L",
+                             name, &c->loc);
+              return false;
+            }
+          /* Break after we've searched the entire chain.  */
+          if (s->state == COMP_DERIVED || s->state == COMP_STRUCTURE)
+            break;
+          s = s->previous;
+        }
+    }
+
    if (!gfc_add_component (gfc_current_block(), name, &c))
      return false;
  
@@ -1868,7 +2054,7 @@ match_pointer_init (gfc_expr **init, int procptr)
  {
    match m;
  
-  if (gfc_pure (NULL) && gfc_state_stack->state != COMP_DERIVED)
+  if (gfc_pure (NULL) && !gfc_comp_struct (gfc_state_stack->state))
      {
        gfc_error ("Initialization of pointer at %C is not allowed in "
                  "a PURE procedure");
@@ -2062,7 +2248,7 @@ variable_decl (int elem)
    /*  If this symbol has already shown up in a Cray Pointer declaration,
        and this is not a component declaration,
        then we want to set the type & bail out.  */
-  if (flag_cray_pointer && gfc_current_state () != COMP_DERIVED)
+  if (flag_cray_pointer && !gfc_comp_struct (gfc_current_state ()))
      {
        gfc_find_symbol (name, gfc_current_ns, 1, &sym);
        if (sym != NULL && sym->attr.cray_pointee)
@@ -2127,7 +2313,7 @@ variable_decl (int elem)
       For components of derived types, it is not true, so we don't
       create a symbol for those yet.  If we fail to create the symbol,
       bail out.  */
-  if (gfc_current_state () != COMP_DERIVED
+  if (!gfc_comp_struct (gfc_current_state ())
        && !build_sym (name, cl, cl_deferred, &as, &var_locus))
      {
        m = MATCH_ERROR;
@@ -2154,6 +2340,9 @@ variable_decl (int elem)
        if (!gfc_notify_std (GFC_STD_GNU, "Old-style "
                            "initialization at %C"))
         return MATCH_ERROR;
+
+      /* Allow old style initializations for components of STRUCTUREs and MAPs
+         but not components of derived types.  */
        else if (gfc_current_state () == COMP_DERIVED)
         {
           gfc_error ("Invalid old style initialization for derived type "
@@ -2162,7 +2351,23 @@ variable_decl (int elem)
           goto cleanup;
         }
  
-      return match_old_style_init (name);
+      /* For structure components, read the initializer as a special
+         expression and let the rest of this function apply the initializer
+         as usual.  */
+      else if (gfc_comp_struct (gfc_current_state ()))
+        {
+          m = match_clist_expr (&initializer, &current_ts, as);
+          if (m == MATCH_NO)
+            gfc_error ("Syntax error in old style initialization of %s at %C",
+                       name);
+          if (m != MATCH_YES)
+            goto cleanup;
+        }
+
+      /* Otherwise we treat the old style initialization just like a
+         DATA declaration for the current variable.  */
+      else
+        return match_old_style_init (name);
      }
  
    /* The double colon must be present in order to have initializers.
@@ -2200,7 +2405,7 @@ variable_decl (int elem)
             }
  
           if (current_attr.flavor != FL_PARAMETER && gfc_pure (NULL)
-             && gfc_state_stack->state != COMP_DERIVED)
+             && !gfc_comp_struct (gfc_state_stack->state))
             {
               gfc_error ("Initialization of variable at %C is not allowed in "
                          "a PURE procedure");
@@ -2208,7 +2413,7 @@ variable_decl (int elem)
             }
  
           if (current_attr.flavor != FL_PARAMETER
-             && gfc_state_stack->state != COMP_DERIVED)
+             && !gfc_comp_struct (gfc_state_stack->state))
             gfc_unset_implicit_pure (gfc_current_ns->proc_name);
  
           if (m != MATCH_YES)
@@ -2217,7 +2422,7 @@ variable_decl (int elem)
      }
  
    if (initializer != NULL && current_attr.allocatable
-       && gfc_current_state () == COMP_DERIVED)
+       && gfc_comp_struct (gfc_current_state ()))
      {
        gfc_error ("Initialization of allocatable component at %C is not "
                  "allowed");
@@ -2228,7 +2433,7 @@ variable_decl (int elem)
    /* Add the initializer.  Note that it is fine if initializer is
       NULL here, because we sometimes also need to check if a
       declaration *must* have an initialization expression.  */
-  if (gfc_current_state () != COMP_DERIVED)
+  if (!gfc_comp_struct (gfc_current_state ()))
      t = add_init_expr_to_sym (name, &initializer, &var_locus);
    else
      {
@@ -2236,6 +2441,12 @@ variable_decl (int elem)
           && !current_attr.pointer && !initializer)
         initializer = gfc_default_initializer (&current_ts);
        t = build_struct (name, cl, &initializer, &as);
+
+      /* If we match a nested structure definition we expect to see the
+       * body even if the variable declarations blow up, so we need to keep
+       * the structure declaration around.  */
+      if (gfc_new_block && gfc_new_block->attr.flavor == FL_STRUCT)
+        gfc_commit_symbol (gfc_new_block);
      }
  
    m = (t) ? MATCH_YES : MATCH_ERROR;
@@ -2724,6 +2935,36 @@ done:
  }
  
  
+/* Matches a RECORD declaration. */
+
+static match
+match_record_decl (const char *name)
+{
+    locus old_loc;
+    old_loc = gfc_current_locus;
+
+    if (gfc_match (" record") == MATCH_YES)
+      {
+          if (!gfc_option.flag_dec_structure)
+            {
+                gfc_current_locus = old_loc;
+                gfc_error ("RECORD at %C is an extension, enable it with "
+                           "-fdec-structure");
+                return MATCH_ERROR;
+            }
+          if (gfc_match (" /%n/", name) != MATCH_YES)
+            {
+                gfc_error ("Structure name expected after RECORD at %C");
+                gfc_current_locus = old_loc;
+                return MATCH_ERROR;
+            }
+          return MATCH_YES;
+      }
+
+    gfc_current_locus = old_loc;
+    return MATCH_NO;
+}
+
  /* Matches a declaration-type-spec (F03:R502).  If successful, sets the ts
     structure to the matched specification.  This is necessary for FUNCTION and
     IMPLICIT statements.
@@ -2781,7 +3022,7 @@ gfc_match_decl_type_spec (gfc_typespec *ts, int implicit_flag)
         {
           if ((m = gfc_match ("*)")) != MATCH_YES)
             return m;
-         if (gfc_current_state () == COMP_DERIVED)
+         if (gfc_comp_struct (gfc_current_state ()))
             {
               gfc_error ("Assumed type at %C is not allowed for components");
               return MATCH_ERROR;
@@ -2892,10 +3133,51 @@ gfc_match_decl_type_spec (gfc_typespec *ts, int implicit_flag)
    if (matched_type)
      m = gfc_match_char (')');
  
-  if (m == MATCH_YES)
-    ts->type = BT_DERIVED;
+  if (m != MATCH_YES)
+    m = match_record_decl (name);
+
+  if (matched_type || m == MATCH_YES)
+    {
+      ts->type = BT_DERIVED;
+      /* We accept record/s/ or type(s) where s is a structure, but we
+       * don't need all the extra derived-type stuff for structures.  */
+      if (gfc_find_symbol (gfc_dt_upper_string (name), NULL, 1, &sym))
+        {
+          gfc_error ("Type name '%s' at %C is ambiguous", name);
+          return MATCH_ERROR;
+        }
+      if (sym && sym->attr.flavor == FL_STRUCT)
+        {
+          ts->u.derived = sym;
+          return MATCH_YES;
+        }
+      /* Actually a derived type.  */
+    }
+
    else
      {
+      /* Match nested STRUCTURE declarations; only valid within another
+         structure declaration.  */
+      m = gfc_match (" structure");
+      if (m == MATCH_ERROR)
+        return MATCH_ERROR;
+      else if (m == MATCH_YES)
+        {
+          if (   gfc_current_state () != COMP_STRUCTURE
+              && gfc_current_state () != COMP_MAP)
+              return MATCH_ERROR;
+
+          m = gfc_match_structure_decl ();
+          if (m == MATCH_YES)
+            {
+              /* gfc_new_block is updated by match_structure_decl.  */
+              ts->type = BT_DERIVED;
+              ts->u.derived = gfc_new_block;
+              return MATCH_YES;
+            }
+          return MATCH_ERROR;
+        }
+
        /* Match CLASS declarations.  */
        m = gfc_match (" class ( * )");
        if (m == MATCH_ERROR)
@@ -2964,9 +3246,7 @@ gfc_match_decl_type_spec (gfc_typespec *ts, int implicit_flag)
       stored in a symtree with the first letter of the name capitalized; the
       symtree with the all lower-case name contains the associated
       generic function.  */
-  dt_name = gfc_get_string ("%c%s",
-                           (char) TOUPPER ((unsigned char) name[0]),
-                           (const char*)&name[1]);
+  dt_name = gfc_dt_upper_string (name);
    sym = NULL;
    dt_sym = NULL;
    if (ts->kind != -1)
@@ -2998,7 +3278,7 @@ gfc_match_decl_type_spec (gfc_typespec *ts, int implicit_flag)
         return MATCH_NO;
      }
  
-  if ((sym->attr.flavor != FL_UNKNOWN
+  if ((sym->attr.flavor != FL_UNKNOWN && sym->attr.flavor != FL_STRUCT
         && !(sym->attr.flavor == FL_PROCEDURE && sym->attr.generic))
        || sym->attr.subroutine)
      {
@@ -3038,7 +3318,7 @@ gfc_match_decl_type_spec (gfc_typespec *ts, int implicit_flag)
  
    gfc_set_sym_referenced (dt_sym);
  
-  if (dt_sym->attr.flavor != FL_DERIVED
+  if (dt_sym->attr.flavor != FL_DERIVED && dt_sym->attr.flavor != FL_STRUCT
        && !gfc_add_flavor (&dt_sym->attr, FL_DERIVED, sym->name, NULL))
      return MATCH_ERROR;
  
@@ -3480,9 +3760,7 @@ gfc_match_import (void)
                  letter of the name capitalized; the symtree with the all
                  lower-case name contains the associated generic function.  */
               st = gfc_new_symtree (&gfc_current_ns->sym_root,
-                       gfc_get_string ("%c%s",
-                               (char) TOUPPER ((unsigned char) name[0]),
-                               &name[1]));
+                                    gfc_dt_upper_string (name));
               st->n.sym = sym;
               sym->refs++;
               sym->attr.imported = 1;
@@ -4497,7 +4775,7 @@ gfc_match_data_decl (void)
      return m;
  
    if ((current_ts.type == BT_DERIVED || current_ts.type == BT_CLASS)
-       && gfc_current_state () != COMP_DERIVED)
+       && !gfc_comp_struct (gfc_current_state ()))
      {
        sym = gfc_use_derived (current_ts.u.derived);
  
@@ -4526,17 +4804,19 @@ gfc_match_data_decl (void)
        && !current_ts.u.derived->attr.zero_comp)
      {
  
-      if (current_attr.pointer && gfc_current_state () == COMP_DERIVED)
+      if (current_attr.pointer && gfc_comp_struct (gfc_current_state ()))
         goto ok;
  
        gfc_find_symbol (current_ts.u.derived->name,
                        current_ts.u.derived->ns, 1, &sym);
  
        /* Any symbol that we find had better be a type definition
-        which has its components defined.  */
-      if (sym != NULL && sym->attr.flavor == FL_DERIVED
+        which has its components defined, or be a structure definition
+         actively being parsed.  */
+      if (sym != NULL && gfc_fl_struct (sym->attr.flavor)
           && (current_ts.u.derived->components != NULL
-             || current_ts.u.derived->attr.zero_comp))
+             || current_ts.u.derived->attr.zero_comp
+             || current_ts.u.derived == gfc_new_block))
         goto ok;
  
        gfc_error ("Derived type at %C has not been previously defined "
@@ -4698,12 +4978,51 @@ error:
  static bool
  copy_prefix (symbol_attribute *dest, locus *where)
  {
-  if (current_attr.pure && !gfc_add_pure (dest, where))
+  if (dest->module_procedure)
+    {
+      if (current_attr.elemental)
+       dest->elemental = 1;
+
+      if (current_attr.pure)
+       dest->pure = 1;
+
+      if (current_attr.recursive)
+       dest->recursive = 1;
+
+      /* Module procedures are unusual in that the 'dest' is copied from
+        the interface declaration. However, this is an oportunity to
+        check that the submodule declaration is compliant with the
+        interface.  */
+      if (dest->elemental && !current_attr.elemental)
+       {
+         gfc_error ("ELEMENTAL prefix in MODULE PROCEDURE interface is "
+                    "missing at %L", where);
      return false;
+       }
+
+      if (dest->pure && !current_attr.pure)
+       {
+         gfc_error ("PURE prefix in MODULE PROCEDURE interface is "
+                    "missing at %L", where);
+         return false;
+       }
+
+      if (dest->recursive && !current_attr.recursive)
+       {
+         gfc_error ("RECURSIVE prefix in MODULE PROCEDURE interface is "
+                    "missing at %L", where);
+         return false;
+       }
+
+      return true;
+    }
  
    if (current_attr.elemental && !gfc_add_elemental (dest, where))
      return false;
  
+  if (current_attr.pure && !gfc_add_pure (dest, where))
+    return false;
+
    if (current_attr.recursive && !gfc_add_recursive (dest, where))
      return false;
  
@@ -5791,6 +6110,10 @@ gfc_match_entry (void)
             gfc_error ("ENTRY statement at %C cannot appear within "
                        "an INTERFACE");
             break;
+          case COMP_STRUCTURE:
+            gfc_error ("ENTRY statement at %C cannot appear within "
+                       "a STRUCTURE block");
+            break;
           case COMP_DERIVED:
             gfc_error ("ENTRY statement at %C cannot appear within "
                        "a DERIVED TYPE block");
@@ -6450,6 +6773,24 @@ gfc_match_end (gfc_statement *st)
        eos_ok = 0;
        break;
  
+    case COMP_MAP:
+      *st = ST_END_MAP;
+      target = " map";
+      eos_ok = 0;
+      break;
+
+    case COMP_UNION:
+      *st = ST_END_UNION;
+      target = " union";
+      eos_ok = 0;
+      break;
+
+    case COMP_STRUCTURE:
+      *st = ST_END_STRUCTURE;
+      target = " structure";
+      eos_ok = 0;
+      break;
+
      case COMP_DERIVED:
      case COMP_DERIVED_CONTAINS:
        *st = ST_END_TYPE;
@@ -8020,6 +8361,208 @@ gfc_get_type_attr_spec (symbol_attribute *attr, char *name)
  }
  
  
+/* Common function for type declaration blocks similar to derived types, such
+   as STRUCTURES and MAPs. Unlike derived types, a structure type
+   does NOT have a generic symbol matching the name given by the user.
+   STRUCTUREs can share names with variables and PARAMETERs so we must allow
+   for the creation of an independent symbol.
+   Other parameters are a message to prefix errors with, the name of the new 
+   type to be created, and the flavor to add to the resulting symbol. */
+
+static bool
+get_struct_decl (const char *name, sym_flavor fl, locus *decl,
+                 gfc_symbol **result)
+{
+  gfc_symbol *sym;
+  locus where;
+
+  gcc_assert (name[0] == (char) TOUPPER (name[0]));
+
+  if (decl)
+    where = *decl;
+  else
+    where = gfc_current_locus;
+
+  if (gfc_get_symbol (name, NULL, &sym))
+    return false;
+
+  if (!sym)
+    {
+      gfc_internal_error ("Failed to create structure type '%s' at %C", name);
+      return false;
+    }
+
+  if (sym->components != NULL || sym->attr.zero_comp)
+    {
+      gfc_error ("Type definition of '%s' at %C was already defined at %L", 
+                 sym->name, &sym->declared_at);
+      return false;
+    }
+
+  sym->declared_at = where;
+
+  if (sym->attr.flavor != fl
+      && !gfc_add_flavor (&sym->attr, fl, sym->name, NULL))
+    return false;
+
+  if (!sym->hash_value)
+      /* Set the hash for the compound name for this type.  */
+    sym->hash_value = gfc_hash_value (sym);
+
+  /* Normally the type is expected to have been completely parsed by the time
+     a field declaration with this type is seen. For unions, maps, and nested
+     structure declarations, we need to indicate that it is okay that we
+     haven't seen any components yet. This will be updated after the structure
+     is fully parsed. */
+  sym->attr.zero_comp = 0;
+
+  /* Structures always act like derived-types with the SEQUENCE attribute */
+  gfc_add_sequence (&sym->attr, sym->name, NULL);
+
+  if (result) *result = sym;
+
+  return true;
+}
+
+
+/* Match the opening of a MAP block. Like a struct within a union in C;
+   behaves identical to STRUCTURE blocks.  */
+
+match
+gfc_match_map (void)
+{
+    /* Counter used to give unique internal names to map structures. */
+    static unsigned int gfc_map_id = 0;
+    char name[GFC_MAX_SYMBOL_LEN + 1];
+    gfc_symbol *sym;
+    locus old_loc;
+
+    old_loc = gfc_current_locus;
+
+    if (gfc_match_eos () != MATCH_YES)
+      {
+          gfc_error ("Junk after MAP statement at %C");
+          gfc_current_locus = old_loc;
+          return MATCH_ERROR;
+      }
+
+    /* Map blocks are anonymous so we make up unique names for the symbol table
+       which are invalid Fortran identifiers.  */
+    snprintf (name, GFC_MAX_SYMBOL_LEN + 1, "MM$%u", gfc_map_id++);
+
+    if (!get_struct_decl (name, FL_STRUCT, &old_loc, &sym))
+      return MATCH_ERROR;
+
+    gfc_new_block = sym;
+
+    return MATCH_YES;
+}
+
+
+/* Match the opening of a UNION block.  */
+
+match
+gfc_match_union (void)
+{
+    /* Counter used to give unique internal names to union types. */
+    static unsigned int gfc_union_id = 0;
+    char name[GFC_MAX_SYMBOL_LEN + 1];
+    gfc_symbol *sym;
+    locus old_loc;
+
+    old_loc = gfc_current_locus;
+
+    if (gfc_match_eos () != MATCH_YES)
+      {
+          gfc_error ("Junk after UNION statement at %C");
+          gfc_current_locus = old_loc;
+          return MATCH_ERROR;
+      }
+
+    /* Unions are anonymous so we make up unique names for the symbol table
+       which are invalid Fortran identifiers.  */
+    snprintf (name, GFC_MAX_SYMBOL_LEN + 1, "UU$%u", gfc_union_id++);
+
+    if (!get_struct_decl (name, FL_UNION, &old_loc, &sym))
+      return MATCH_ERROR;
+
+    gfc_new_block = sym;
+
+    return MATCH_YES;
+}
+
+
+/* Match the beginning of a STRUCTURE declaration. This is similar to
+   matching the beginning of a derived type declaration with a few
+   twists. The resulting type symbol has no access control or other
+   interesting attributes.  */
+
+match
+gfc_match_structure_decl (void)
+{
+    /* Counter used to give unique internal names to anonymous structures.  */
+    int gfc_structure_id = 0;
+    char name[GFC_MAX_SYMBOL_LEN + 1];
+    gfc_symbol *sym;
+    match m;
+    locus where;
+
+    if(!gfc_option.flag_dec_structure)
+      {
+          gfc_error ("STRUCTURE at %C is a DEC extension, enable with "
+                     "-fdec-structure");
+          return MATCH_ERROR;
+      }
+
+    name[0] = '\0';
+
+    m = gfc_match (" /%n/", name);
+    if (m != MATCH_YES)
+      {
+          /* Non-nested structure declarations require a structure name.  */
+          if (!gfc_comp_struct (gfc_current_state ()))
+            {
+                gfc_error ("Structure name expected in non-nested structure "
+                           "declaration at %C");
+                return MATCH_ERROR;
+            }
+          /* This is an anonymous structure; make up a unique name for it
+             (upper-case letters never make it to symbol names from the source).
+             The important thing is initializing the type variable
+             and setting gfc_new_symbol, which is immediately used by
+             parse_structure () and variable_decl () to add components of
+             this type.  */
+          snprintf (name, GFC_MAX_SYMBOL_LEN + 1, "SS$%u", gfc_structure_id++);
+      }
+
+    where = gfc_current_locus;
+    /* No field list allowed after non-nested structure declaration.  */
+    if (!gfc_comp_struct (gfc_current_state ())
+        && gfc_match_eos () != MATCH_YES)
+      {
+          gfc_error ("Junk after non-nested STRUCTURE statement at %C");
+          return MATCH_ERROR;
+      }
+
+    /* Make sure the name is not the name of an intrinsic type.  */
+    if (gfc_is_intrinsic_typename (name))
+      {
+        gfc_error ("Structure name '%s' at %C cannot be the same as an"
+                   " intrinsic type", name);
+        return MATCH_ERROR;
+      }
+
+    /* Store the actual type symbol for the structure with an upper-case first
+       letter (an invalid Fortran identifier).  */
+
+    sprintf (name, gfc_dt_upper_string (name));
+    if (!get_struct_decl (name, FL_STRUCT, &where, &sym))
+      return MATCH_ERROR;
+
+    gfc_new_block = sym;
+    return MATCH_YES;
+}
+
  /* Match the beginning of a derived type declaration.  If a type name
     was the result of a function, then it is possible to have a symbol
     already to be known as a derived type yet have no components.  */
@@ -8037,7 +8580,7 @@ gfc_match_derived_decl (void)
    bool seen_attr = false;
    gfc_interface *intr = NULL, *head;
  
-  if (gfc_current_state () == COMP_DERIVED)
+  if (gfc_comp_struct (gfc_current_state ()))
      return MATCH_NO;
  
    name[0] = '\0';
@@ -8111,9 +8654,7 @@ gfc_match_derived_decl (void)
    if (!sym)
      {
        /* Use upper case to save the actual derived-type symbol.  */
-      gfc_get_symbol (gfc_get_string ("%c%s",
-                       (char) TOUPPER ((unsigned char) gensym->name[0]),
-                       &gensym->name[1]), NULL, &sym);
+      gfc_get_symbol (gfc_dt_upper_string (gensym->name), NULL, &sym);
        sym->name = gfc_get_string (gensym->name);
        head = gensym->generic;
        intr = gfc_get_interface ();
diff --git a/gcc/fortran/dump-parse-tree.c b/gcc/fortran/dump-parse-tree.c

index 8d50d75..f507434 100644 (file)
--- a/gcc/fortran/dump-parse-tree.c
+++ b/gcc/fortran/dump-parse-tree.c
@@ -106,6 +106,7 @@ show_typespec (gfc_typespec *ts)
      {
      case BT_DERIVED:
      case BT_CLASS:
+    case BT_UNION:
        fprintf (dumpfile, "%s", ts->u.derived->name);
        break;
  
diff --git a/gcc/fortran/expr.c b/gcc/fortran/expr.c

index 1e8be6e..d1258cd 100644 (file)
--- a/gcc/fortran/expr.c
+++ b/gcc/fortran/expr.c
@@ -335,7 +335,7 @@ gfc_copy_expr (gfc_expr *p)
  
         case BT_HOLLERITH:
         case BT_LOGICAL:
-       case BT_DERIVED:
+       case_bt_struct:
         case BT_CLASS:
         case BT_ASSUMED:
           break;                /* Already done.  */
@@ -1279,7 +1279,7 @@ find_component_ref (gfc_constructor_base base, gfc_ref *ref)
    /* For extended types, check if the desired component is in one of the
     * parent types.  */
    while (ext > 0 && gfc_find_component (dt->components->ts.u.derived,
-                                       pick->name, true, true))
+                                       pick->name, true, true, NULL))
      {
        dt = dt->components->ts.u.derived;
        c = gfc_constructor_first (c->expr->value.constructor);
@@ -1649,7 +1649,7 @@ simplify_const_ref (gfc_expr *p)
  
             case AR_FULL:
               if (p->ref->next != NULL
-                 && (p->ts.type == BT_CHARACTER || p->ts.type == BT_DERIVED))
+                 && (p->ts.type == BT_CHARACTER || gfc_bt_struct (p->ts.type)))
                 {
                   for (c = gfc_constructor_first (p->value.constructor);
                        c; c = gfc_constructor_next (c))
@@ -1659,7 +1659,7 @@ simplify_const_ref (gfc_expr *p)
                         return false;
                     }
  
-                 if (p->ts.type == BT_DERIVED
+                 if (gfc_bt_struct (p->ts.type)
                         && p->ref->next
                         && (c = gfc_constructor_first (p->value.constructor)))
                     {
@@ -3926,9 +3926,9 @@ gfc_has_default_initializer (gfc_symbol *der)
  {
    gfc_component *c;
  
-  gcc_assert (der->attr.flavor == FL_DERIVED);
+  gcc_assert (gfc_fl_struct (der->attr.flavor));
    for (c = der->components; c; c = c->next)
-    if (c->ts.type == BT_DERIVED)
+    if (gfc_bt_struct (c->ts.type))
        {
          if (!c->attr.pointer && !c->attr.proc_pointer
              && gfc_has_default_initializer (c->ts.u.derived))
@@ -3975,6 +3975,10 @@ gfc_default_initializer (gfc_typespec *ts)
  
        if (comp->initializer)
         {
+         /* Save the component ref for STRUCTUREs and UNIONs.  */
+         if (ts->u.derived->attr.flavor == FL_STRUCT
+             || ts->u.derived->attr.flavor == FL_UNION)
+           ctor->n.component = comp;
           ctor->expr = gfc_copy_expr (comp->initializer);
           if ((comp->ts.type != comp->initializer->ts.type
                || comp->ts.kind != comp->initializer->ts.kind)
diff --git a/gcc/fortran/frontend-passes.c b/gcc/fortran/frontend-passes.c

index 7eeb5a6..37c42bb 100644 (file)
--- a/gcc/fortran/frontend-passes.c
+++ b/gcc/fortran/frontend-passes.c
@@ -174,8 +174,10 @@ realloc_string_callback (gfc_code **c, int *walk_subtrees ATTRIBUTE_UNUSED,
  
    if (!gfc_check_dependency (expr1, expr2, true))
      return 0;
-  
+
    current_code = c;
+  inserted_block = NULL;
+  changed_statement = NULL;
    n = create_var (expr2, "trim");
    co->expr2 = n;
    return 0;
@@ -2812,6 +2814,12 @@ inline_matmul_assign (gfc_code **c, int *walk_subtrees,
    if (in_where)
      return 0;
  
+  /* For now don't do anything in OpenMP workshare, it confuses
+     its translation, which expects only the allowed statements in there.
+     We should figure out how to parallelize this eventually.  */
+  if (in_omp_workshare)
+    return 0;
+
    expr1 = co->expr1;
    expr2 = co->expr2;
    if (expr2->expr_type != EXPR_FUNCTION
diff --git a/gcc/fortran/gfortran.h b/gcc/fortran/gfortran.h

index a0fb5fd..0bb71cb 100644 (file)
--- a/gcc/fortran/gfortran.h
+++ b/gcc/fortran/gfortran.h
@@ -62,6 +62,15 @@ not after.
  
  #define gfc_is_whitespace(c) ((c==' ') || (c=='\t'))
  
+/* Macros to check for groups of structure-like types and flavors since
+   derived types, structures, maps, unions are often treated similarly. */
+#define gfc_bt_struct(t) \
+  ((t) == BT_DERIVED || (t) == BT_UNION)
+#define gfc_fl_struct(f) \
+  ((f) == FL_DERIVED || (f) == FL_UNION || (f) == FL_STRUCT)
+#define case_bt_struct case BT_DERIVED: case BT_UNION
+#define case_fl_struct case FL_DERIVED: case FL_UNION: case FL_STRUCT
+
  /* Stringization.  */
  #define stringize(x) expand_macro(x)
  #define expand_macro(x) # x
@@ -203,6 +212,8 @@ enum gfc_statement
    ST_POINTER_ASSIGNMENT, ST_SELECT_CASE, ST_SEQUENCE, ST_SIMPLE_IF,
    ST_STATEMENT_FUNCTION, ST_DERIVED_DECL, ST_LABEL_ASSIGNMENT, ST_ENUM,
    ST_ENUMERATOR, ST_END_ENUM, ST_SELECT_TYPE, ST_TYPE_IS, ST_CLASS_IS,
+  ST_STRUCTURE_DECL, ST_END_STRUCTURE,
+  ST_UNION, ST_END_UNION, ST_MAP, ST_END_MAP,
    ST_OACC_PARALLEL_LOOP, ST_OACC_END_PARALLEL_LOOP, ST_OACC_PARALLEL,
    ST_OACC_END_PARALLEL, ST_OACC_KERNELS, ST_OACC_END_KERNELS, ST_OACC_DATA,
    ST_OACC_END_DATA, ST_OACC_HOST_DATA, ST_OACC_END_HOST_DATA, ST_OACC_LOOP,
@@ -254,12 +265,12 @@ enum interface_type
  };
  
  /* Symbol flavors: these are all mutually exclusive.
-   10 elements = 4 bits.  */
+   12 elements = 4 bits.  */
  enum sym_flavor
  {
    FL_UNKNOWN = 0, FL_PROGRAM, FL_BLOCK_DATA, FL_MODULE, FL_VARIABLE,
    FL_PARAMETER, FL_LABEL, FL_PROCEDURE, FL_DERIVED, FL_NAMELIST,
-  FL_VOID
+  FL_UNION, FL_STRUCT, FL_VOID
  };
  
  /* Procedure types.  7 elements = 3 bits.  */
@@ -2523,6 +2534,8 @@ typedef struct
    int flag_init_character;
    char flag_init_character_value;
  
+  int flag_dec_structure;
+
    int fpe;
    int fpe_summary;
    int rtcheck;
@@ -2743,6 +2756,7 @@ bool gfc_check_any_c_kind (gfc_typespec *);
  int gfc_validate_kind (bt, int, bool);
  int gfc_get_int_kind_from_width_isofortranenv (int size);
  int gfc_get_real_kind_from_width_isofortranenv (int size);
+tree gfc_get_union_type (gfc_symbol *);
  tree gfc_get_derived_type (gfc_symbol * derived);
  extern int gfc_index_integer_kind;
  extern int gfc_default_integer_kind;
@@ -2831,7 +2845,8 @@ int gfc_copy_dummy_sym (gfc_symbol **, gfc_symbol *, int);
  bool gfc_add_component (gfc_symbol *, const char *, gfc_component **);
  gfc_symbol *gfc_use_derived (gfc_symbol *);
  gfc_symtree *gfc_use_derived_tree (gfc_symtree *);
-gfc_component *gfc_find_component (gfc_symbol *, const char *, bool, bool);
+gfc_component *gfc_find_component (gfc_symbol *, const char *, bool, bool,
+                                   gfc_ref **);
  
  gfc_st_label *gfc_get_st_label (int);
  void gfc_free_st_label (gfc_st_label *);
@@ -3174,6 +3189,8 @@ void gfc_module_done_2 (void);
  void gfc_dump_module (const char *, int);
  bool gfc_check_symbol_access (gfc_symbol *);
  void gfc_free_use_stmts (gfc_use_list *);
+const char *gfc_dt_lower_string (const char *);
+const char *gfc_dt_upper_string (const char *);
  
  /* primary.c */
  symbol_attribute gfc_variable_attr (gfc_expr *, gfc_typespec *);
diff --git a/gcc/fortran/gfortran.texi b/gcc/fortran/gfortran.texi

index 2704bc5..4d288ba 100644 (file)
--- a/gcc/fortran/gfortran.texi
+++ b/gcc/fortran/gfortran.texi
@@ -474,9 +474,9 @@ The GNU Fortran compiler is able to compile nearly all
  standard-compliant Fortran 95, Fortran 90, and Fortran 77 programs,
  including a number of standard and non-standard extensions, and can be
  used on real-world programs.  In particular, the supported extensions
-include OpenMP, Cray-style pointers, and several Fortran 2003 and Fortran
-2008 features, including TR 15581.  However, it is still under
-development and has a few remaining rough edges.
+include OpenMP, Cray-style pointers, some old vendor extensions, and several
+Fortran 2003 and Fortran 2008 features, including TR 15581.  However, it is
+still under development and has a few remaining rough edges.
  There also is initial support for OpenACC.
  Note that this is an experimental feature, incomplete, and subject to
  change in future versions of GCC.  See
@@ -1459,6 +1459,8 @@ without warning.
  * OpenACC::
  * Argument list functions::
  * Read/Write after EOF marker::
+* STRUCTURE and RECORD::
+* UNION and MAP::
  @end menu
  
  @node Old-style kind specifications
@@ -2117,40 +2119,6 @@ consider @code{BACKSPACE} or @code{REWIND} to properly position
  the file before the EOF marker.  As an extension, the run-time error may
  be disabled using -std=legacy.
  
-@node Extensions not implemented in GNU Fortran
-@section Extensions not implemented in GNU Fortran
-@cindex extensions, not implemented
-
-The long history of the Fortran language, its wide use and broad
-userbase, the large number of different compiler vendors and the lack of
-some features crucial to users in the first standards have lead to the
-existence of a number of important extensions to the language.  While
-some of the most useful or popular extensions are supported by the GNU
-Fortran compiler, not all existing extensions are supported.  This section
-aims at listing these extensions and offering advice on how best make
-code that uses them running with the GNU Fortran compiler.
-
-@c More can be found here:
-@c   -- https://gcc.gnu.org/onlinedocs/gcc-3.4.6/g77/Missing-Features.html
-@c   -- the list of Fortran and libgfortran bugs closed as WONTFIX:
-@c      http://tinyurl.com/2u4h5y
-
-@menu
-* STRUCTURE and RECORD::
-@c * UNION and MAP::
-* ENCODE and DECODE statements::
-* Variable FORMAT expressions::
-@c * Q edit descriptor::
-@c * AUTOMATIC statement::
-@c * TYPE and ACCEPT I/O Statements::
-@c * .XOR. operator::
-@c * CARRIAGECONTROL, DEFAULTFILE, DISPOSE and RECORDTYPE I/O specifiers::
-@c * Omitted arguments in procedure call::
-* Alternate complex function syntax::
-* Volatile COMMON blocks::
-* OPEN( ... NAME=)::
-@end menu
-
  
  @node STRUCTURE and RECORD
  @subsection @code{STRUCTURE} and @code{RECORD}
@@ -2226,16 +2194,211 @@ store_catalog(12) = pear
  print *, store_catalog(12)
  @end example
  
+@noindent
+GNU Fortran implements STRUCTURES like derived types with the following
+rules and exceptions:
+
+@itemize @bullet
+@item Structures act like derived types with the @code{SEQUENCE} attribute.
+Otherwise they may contain no specifiers.
+
+@item Structures may share names with other symbols. For example, the following
+is invalid for derived types, but valid for structures:
+
+@smallexample
+structure /header/
+  ! ...
+end structure
+record /header/ header
+@end smallexample
+
+@item Structure types may be declared nested within another parent structure.
+The syntax is:
+@smallexample
+structure /type-name/
+    ...
+    structure [/<type-name>/] <field-list>
+...
+@end smallexample
+
+The type name may be ommitted, in which case the structure type itself is
+anonymous, and other structures of the same type cannot be instantiated. The
+following shows some examples:
+
+@example
+structure /appointment/
+  ! nested structure definition: app_time is an array of two 'time'
+  structure /time/ app_time (2) 
+    integer(1) hour, minute
+  end structure
+  character(10) memo
+end structure
+
+! The 'time' structure is still usable
+record /time/ now
+now = time(5, 30)
+
+...
+
+structure /appointment/
+  ! anonymous nested structure definition
+  structure start, end
+    integer(1) hour, minute
+  end structure
+  character(10) memo
+end structure
+@end example
+
+@item Structures may contain @code{UNION} blocks. For more detail see the
+section on @ref{UNION and MAP}.
  
-@c @node UNION and MAP
-@c @subsection @code{UNION} and @code{MAP}
-@c @cindex @code{UNION}
-@c @cindex @code{MAP}
-@c
-@c For help writing this one, see
-@c http://www.eng.umd.edu/~nsw/ench250/fortran1.htm#UNION and
-@c http://www.tacc.utexas.edu/services/userguides/pgi/pgiws_ug/pgi32u06.htm
+@item Structures support old-style initialization of components, like
+those described in @ref{Old-style variable initialization}. For array
+initializers, an initializer may contain a repeat specification of the form
+@code{<literal-integer> * <constant-initializer>}. The value of the integer
+indicates the number of times to repeat the constant initializer when expanding
+the initializer list.
+@end itemize
+
+@node UNION and MAP
+@subsection @code{UNION} and @code{MAP}
+@cindex @code{UNION}
+@cindex @code{MAP}
+
+Unions are an old vendor extension which were commonly used with the
+non-standard @ref{STRUCTURE and RECORD} extensions. Use of @code{UNION} and
+@code{MAP} is automatically enabled with @option{-fdec-structure}.
+
+A @code{UNION} declaration occurs within a structure; within the definition of
+each union is a number of @code{MAP} blocks. Each @code{MAP} shares storage
+with its sibling maps (in the same union), and the size of the union is the
+size of the largest map within it, just as with unions in C. The major
+difference is that component references do not indicate which union or map the
+component is in (the compiler gets to figure that out).
+
+Here is a small example:
+@smallexample
+structure /myunion/
+union
+  map
+    character(2) w0, w1, w2
+  end map
+  map
+    character(6) long
+  end map
+end union
+end structure
+
+record /myunion/ rec
+! After this assignment...
+rec.long = 'hello!'
+
+! The following is true:
+! rec.w0 === 'he'
+! rec.w1 === 'll'
+! rec.w2 === 'o!'
+@end smallexample
+
+The two maps share memory, and the size of the union is ultimately six bytes:
+
+@example
+0    1    2    3    4   5   6     Byte offset
+-------------------------------
+|    |    |    |    |    |    |
+-------------------------------
+
+^    W0   ^    W1   ^    W2   ^
+ \-------/ \-------/ \-------/
+
+^             LONG            ^
+ \---------------------------/
+@end example
+
+Following is an example mirroring the layout of an Intel x86_64 register:
+
+@example
+structure /reg/
+  union ! U0                ! rax
+    map
+      character(16) rx
+    end map
+    map
+      character(8) rh         ! rah
+      union ! U1
+        map
+          character(8) rl     ! ral
+        end map
+        map
+          character(8) ex     ! eax
+        end map
+        map
+          character(4) eh     ! eah
+          union ! U2
+            map
+              character(4) el ! eal
+            end map
+            map
+              character(4) x  ! ax
+            end map
+            map
+              character(2) h  ! ah
+              character(2) l  ! al
+            end map
+          end union
+        end map
+      end union
+    end map
+  end union
+end structure
+record /reg/ a
+
+! After this assignment...
+a.rx     =     'AAAAAAAA.BBB.C.D'
+
+! The following is true:
+a.rx === 'AAAAAAAA.BBB.C.D'
+a.rh === 'AAAAAAAA'
+a.rl ===         '.BBB.C.D'
+a.ex ===         '.BBB.C.D'
+a.eh ===         '.BBB'
+a.el ===             '.C.D'
+a.x  ===             '.C.D'
+a.h  ===             '.C'
+a.l  ===               '.D'
+@end example
+
+
+@node Extensions not implemented in GNU Fortran
+@section Extensions not implemented in GNU Fortran
+@cindex extensions, not implemented
+
+The long history of the Fortran language, its wide use and broad
+userbase, the large number of different compiler vendors and the lack of
+some features crucial to users in the first standards have lead to the
+existence of a number of important extensions to the language.  While
+some of the most useful or popular extensions are supported by the GNU
+Fortran compiler, not all existing extensions are supported.  This section
+aims at listing these extensions and offering advice on how best make
+code that uses them running with the GNU Fortran compiler.
  
+@c More can be found here:
+@c   -- https://gcc.gnu.org/onlinedocs/gcc-3.4.6/g77/Missing-Features.html
+@c   -- the list of Fortran and libgfortran bugs closed as WONTFIX:
+@c      http://tinyurl.com/2u4h5y
+
+@menu
+* ENCODE and DECODE statements::
+* Variable FORMAT expressions::
+@c * Q edit descriptor::
+@c * AUTOMATIC statement::
+@c * TYPE and ACCEPT I/O Statements::
+@c * .XOR. operator::
+@c * CARRIAGECONTROL, DEFAULTFILE, DISPOSE and RECORDTYPE I/O specifiers::
+@c * Omitted arguments in procedure call::
+* Alternate complex function syntax::
+* Volatile COMMON blocks::
+* OPEN( ... NAME=)::
+@end menu
  
  @node ENCODE and DECODE statements
  @subsection @code{ENCODE} and @code{DECODE} statements
@@ -2355,7 +2518,6 @@ invalid standard Fortran syntax and is not supported by
  @code{VOLATILE} variables in @code{COMMON} blocks since revision 4.3.
  
  
-
  @node OPEN( ... NAME=)
  @subsection @code{OPEN( ... NAME=)}
  @cindex @code{NAM}
diff --git a/gcc/fortran/interface.c b/gcc/fortran/interface.c

index 5c66c6e..5bd1279 100644 (file)
--- a/gcc/fortran/interface.c
+++ b/gcc/fortran/interface.c
@@ -387,19 +387,147 @@ gfc_match_end_interface (void)
  }
  
  
+/* Compare components according to 4.4.2 of the Fortran standard.  */
+
+static int
+compare_components (gfc_component *cmp1, gfc_component *cmp2,
+    gfc_symbol *derived1, gfc_symbol *derived2)
+{
+  gfc_symbol *d1, *d2;
+  bool anonymous = false;
+
+  /* Unions, maps, and anonymous structures all have names like "[xX]X$\d+"
+     which should not be compared.  */
+  d1 = cmp1->ts.u.derived;
+  d2 = cmp2->ts.u.derived;
+  if (   (d1 && (d1->attr.flavor == FL_STRUCT || d1->attr.flavor == FL_UNION)
+          && ISUPPER (cmp1->name[1]))
+      || (d2 && (d2->attr.flavor == FL_STRUCT || d2->attr.flavor == FL_UNION)
+          && ISUPPER (cmp1->name[1])))
+    anonymous = true;
+
+  if (!anonymous && strcmp (cmp1->name, cmp2->name) != 0)
+    return 0;
+
+  if (cmp1->attr.access != cmp2->attr.access)
+    return 0;
+
+  if (cmp1->attr.pointer != cmp2->attr.pointer)
+    return 0;
+
+  if (cmp1->attr.dimension != cmp2->attr.dimension)
+    return 0;
+
+  if (cmp1->attr.allocatable != cmp2->attr.allocatable)
+    return 0;
+
+  if (cmp1->attr.dimension && gfc_compare_array_spec (cmp1->as, cmp2->as) == 0)
+    return 0;
+
+  /* Make sure that link lists do not put this function into an
+     endless recursive loop!  */
+  if (!(cmp1->ts.type == BT_DERIVED && derived1 == cmp1->ts.u.derived)
+      && !(cmp2->ts.type == BT_DERIVED && derived2 == cmp2->ts.u.derived)
+      && gfc_compare_types (&cmp1->ts, &cmp2->ts) == 0)
+    return 0;
+
+  else if ( (cmp1->ts.type == BT_DERIVED && derived1 == cmp1->ts.u.derived)
+        && !(cmp2->ts.type == BT_DERIVED && derived2 == cmp2->ts.u.derived))
+    return 0;
+
+  else if (!(cmp1->ts.type == BT_DERIVED && derived1 == cmp1->ts.u.derived)
+        &&  (cmp2->ts.type == BT_DERIVED && derived2 == cmp2->ts.u.derived))
+    return 0;
+
+  return 1;
+}
+
+
+/* Compare two union types by comparing the components of their maps.
+   Because unions and maps are anonymous their types get special internal
+   names; therefore the usual derived type comparison will fail on them.
+
+   Returns nonzero if equal, as with gfc_compare_derived_types. Also as with
+   gfc_compare_derived_types, 'equal' is closer to meaning 'duplicate
+   definitions' than 'equivalent structure'. */
+
+int
+gfc_compare_union_types (gfc_symbol *un1, gfc_symbol *un2)
+{
+  gfc_component *map1, *map2, *cmp1, *cmp2;
+
+  if (un1->attr.flavor != FL_UNION || un2->attr.flavor != FL_UNION)
+    return 0;
+
+  map1 = un1->components;
+  map2 = un2->components;
+
+  /* In terms of 'equality' here we are worried about types which are
+     declared the same in two places, not types that represent equivalent
+     structures. (This is common because of FORTRAN's weird scoping rules.)
+     Though two unions with their maps in different orders could be equivalent,
+     we will say they are not equal for the purposes of this test; therefore
+     we compare the maps sequentially. */
+  for (;;)
+  {
+    cmp1 = map1->ts.u.derived->components;
+    cmp2 = map2->ts.u.derived->components;
+    for (;;)
+    {
+      /* No two fields will ever point to the same map type unless they are
+         the same component, because one map field is created with its type
+         declaration. Therefore don't worry about recursion here. */
+      /* TODO: worry about recursion into parent types of the unions? */
+      if (compare_components (cmp1, cmp2,
+            map1->ts.u.derived, map2->ts.u.derived) == 0)
+        return 0;
+
+      cmp1 = cmp1->next;
+      cmp2 = cmp2->next;
+
+      if (cmp1 == NULL && cmp2 == NULL)
+        break;
+      if (cmp1 == NULL || cmp2 == NULL)
+        return 0;
+    }
+
+    map1 = map1->next;
+    map2 = map2->next;
+
+    if (map1 == NULL && map2 == NULL)
+      break;
+    if (map1 == NULL || map2 == NULL)
+      return 0;
+  }
+
+  return 1;
+}
+
+
+
  /* Compare two derived types using the criteria in 4.4.2 of the standard,
     recursing through gfc_compare_types for the components.  */
  
  int
  gfc_compare_derived_types (gfc_symbol *derived1, gfc_symbol *derived2)
  {
-  gfc_component *dt1, *dt2;
+  gfc_component *cmp1, *cmp2;
+  bool anonymous = false;
  
    if (derived1 == derived2)
      return 1;
  
    gcc_assert (derived1 && derived2);
  
+  /* MAP and anonymous STRUCTURE types have internal names of the form
+     mM* and sS* (we can get away this this because source names are converted
+     to lowerase). Compare anonymous type names specially because each
+     gets a unique name when it is declared. */
+  anonymous = (derived1->name[0] == derived2->name[0]
+      && derived1->name[1] && derived2->name[1] && derived2->name[2]
+      && derived1->name[1] == (char) TOUPPER (derived1->name[0])
+      && derived2->name[2] == (char) TOUPPER (derived2->name[0]));
+
    /* Special case for comparing derived types across namespaces.  If the
       true names and module names are the same and the module name is
       nonnull, then they are equal.  */
@@ -409,9 +537,11 @@ gfc_compare_derived_types (gfc_symbol *derived1, gfc_symbol *derived2)
      return 1;
  
    /* Compare type via the rules of the standard.  Both types must have
-     the SEQUENCE or BIND(C) attribute to be equal.  */
+     the SEQUENCE or BIND(C) attribute to be equal. STRUCTUREs are special
+     because they can be anonymous; therefore two structures with different
+     names may be equal.  */
  
-  if (strcmp (derived1->name, derived2->name))
+  if (strcmp (derived1->name, derived2->name) != 0 && !anonymous)
      return 0;
  
    if (derived1->component_access == ACCESS_PRIVATE
@@ -422,53 +552,30 @@ gfc_compare_derived_types (gfc_symbol *derived1, gfc_symbol *derived2)
        && !(derived1->attr.is_bind_c && derived2->attr.is_bind_c))
      return 0;
  
-  dt1 = derived1->components;
-  dt2 = derived2->components;
+  /* Protect against null components.  */
+  if (derived1->attr.zero_comp != derived2->attr.zero_comp)
+    return 0;
+
+  if (derived1->attr.zero_comp)
+    return 1;
+
+  cmp1 = derived1->components;
+  cmp2 = derived2->components;
  
    /* Since subtypes of SEQUENCE types must be SEQUENCE types as well, a
       simple test can speed things up.  Otherwise, lots of things have to
       match.  */
    for (;;)
      {
-      if (strcmp (dt1->name, dt2->name) != 0)
-       return 0;
-
-      if (dt1->attr.access != dt2->attr.access)
-       return 0;
-
-      if (dt1->attr.pointer != dt2->attr.pointer)
-       return 0;
-
-      if (dt1->attr.dimension != dt2->attr.dimension)
-       return 0;
+      if (!compare_components (cmp1, cmp2, derived1, derived2))
+        return 0;
  
-     if (dt1->attr.allocatable != dt2->attr.allocatable)
-       return 0;
-
-      if (dt1->attr.dimension && gfc_compare_array_spec (dt1->as, dt2->as) == 0)
-       return 0;
-
-      /* Make sure that link lists do not put this function into an
-        endless recursive loop!  */
-      if (!(dt1->ts.type == BT_DERIVED && derived1 == dt1->ts.u.derived)
-           && !(dt2->ts.type == BT_DERIVED && derived2 == dt2->ts.u.derived)
-           && gfc_compare_types (&dt1->ts, &dt2->ts) == 0)
-       return 0;
+      cmp1 = cmp1->next;
+      cmp2 = cmp2->next;
  
-      else if ((dt1->ts.type == BT_DERIVED && derived1 == dt1->ts.u.derived)
-               && !(dt1->ts.type == BT_DERIVED && derived1 == dt1->ts.u.derived))
-       return 0;
-
-      else if (!(dt1->ts.type == BT_DERIVED && derived1 == dt1->ts.u.derived)
-               && (dt1->ts.type == BT_DERIVED && derived1 == dt1->ts.u.derived))
-       return 0;
-
-      dt1 = dt1->next;
-      dt2 = dt2->next;
-
-      if (dt1 == NULL && dt2 == NULL)
+      if (cmp1 == NULL && cmp2 == NULL)
         break;
-      if (dt1 == NULL || dt2 == NULL)
+      if (cmp1 == NULL || cmp2 == NULL)
         return 0;
      }
  
@@ -509,18 +616,18 @@ gfc_compare_types (gfc_typespec *ts1, gfc_typespec *ts2)
        && (ts1->u.derived->attr.sequence || ts1->u.derived->attr.is_bind_c))
      return 1;
  
+  if (ts1->type == BT_UNION && ts2->type == BT_UNION)
+    return gfc_compare_union_types (ts1->u.derived, ts2->u.derived);
+
    if (ts1->type != ts2->type
-      && ((ts1->type != BT_DERIVED && ts1->type != BT_CLASS)
-         || (ts2->type != BT_DERIVED && ts2->type != BT_CLASS)))
+      && ((!gfc_bt_struct (ts1->type) && ts1->type != BT_CLASS)
+         || (!gfc_bt_struct (ts2->type) && ts2->type != BT_CLASS)))
      return 0;
    if (ts1->type != BT_DERIVED && ts1->type != BT_CLASS)
      return (ts1->kind == ts2->kind);
  
    /* Compare derived types.  */
-  if (gfc_type_compatible (ts1, ts2))
-    return 1;
-
-  return gfc_compare_derived_types (ts1->u.derived ,ts2->u.derived);
+  return gfc_type_compatible (ts1, ts2);
  }
  
  
@@ -1585,7 +1692,7 @@ check_interface0 (gfc_interface *p, const char *interface_name)
          functions or subroutines.  */
        if (((!p->sym->attr.function && !p->sym->attr.subroutine)
            || !p->sym->attr.if_source)
-         && p->sym->attr.flavor != FL_DERIVED)
+         && !gfc_fl_struct (p->sym->attr.flavor))
         {
           if (p->sym->attr.external)
             gfc_error ("Procedure %qs in %s at %L has no explicit interface",
@@ -1599,14 +1706,14 @@ check_interface0 (gfc_interface *p, const char *interface_name)
  
        /* Verify that procedures are either all SUBROUTINEs or all FUNCTIONs.  */
        if ((psave->sym->attr.function && !p->sym->attr.function
-          && p->sym->attr.flavor != FL_DERIVED)
+          && !gfc_fl_struct (p->sym->attr.flavor))
           || (psave->sym->attr.subroutine && !p->sym->attr.subroutine))
         {
-         if (p->sym->attr.flavor != FL_DERIVED)
+         if (!gfc_fl_struct (p->sym->attr.flavor))
             gfc_error ("In %s at %L procedures must be either all SUBROUTINEs"
                        " or all FUNCTIONs", interface_name,
                        &p->sym->declared_at);
-         else
+         else if (p->sym->attr.flavor == FL_DERIVED)
             gfc_error ("In %s at %L procedures must be all FUNCTIONs as the "
                        "generic name is also the name of a derived type",
                        interface_name, &p->sym->declared_at);
@@ -1666,8 +1773,8 @@ check_interface1 (gfc_interface *p, gfc_interface *q0,
         if (p->sym->name == q->sym->name && p->sym->module == q->sym->module)
           continue;
  
-       if (p->sym->attr.flavor != FL_DERIVED
-           && q->sym->attr.flavor != FL_DERIVED
+       if (!gfc_fl_struct (p->sym->attr.flavor)
+           && !gfc_fl_struct (q->sym->attr.flavor)
             && gfc_compare_interfaces (p->sym, q->sym, q->sym->name,
                                        generic_flag, 0, NULL, 0, NULL, NULL))
           {
@@ -2006,7 +2113,7 @@ compare_parameter (gfc_symbol *formal, gfc_expr *actual,
      }
  
    ppc = gfc_get_proc_ptr_comp (actual);
-  if (ppc)
+  if (ppc && ppc->ts.interface)
      {
        if (!gfc_compare_interfaces (formal, ppc->ts.interface, ppc->name, 0, 1,
                                    err, sizeof(err), NULL, NULL))
@@ -3550,7 +3657,7 @@ gfc_search_interface (gfc_interface *intr, int sub_flag,
  
    for (; intr; intr = intr->next)
      {
-      if (intr->sym->attr.flavor == FL_DERIVED)
+      if (gfc_fl_struct (intr->sym->attr.flavor))
         continue;
        if (sub_flag && intr->sym->attr.function)
         continue;
diff --git a/gcc/fortran/invoke.texi b/gcc/fortran/invoke.texi

index e90656e..e8b8409 100644 (file)
--- a/gcc/fortran/invoke.texi
+++ b/gcc/fortran/invoke.texi
@@ -115,7 +115,8 @@ by type.  Explanations are in the following sections.
  @item Fortran Language Options
  @xref{Fortran Dialect Options,,Options controlling Fortran dialect}.
  @gccoptlist{-fall-intrinsics -fbackslash -fcray-pointer -fd-lines-as-code @gol
--fd-lines-as-comments -fdefault-double-8 -fdefault-integer-8 @gol
+-fd-lines-as-comments @gol
+-fdec -fdec-structure -fdefault-double-8 -fdefault-integer-8 @gol
  -fdefault-real-8 -fdollar-ok -ffixed-line-length-@var{n} @gol
  -ffixed-line-length-none -ffree-form -ffree-line-length-@var{n} @gol
  -ffree-line-length-none -fimplicit-none -finteger-4-integer-8 @gol
@@ -228,6 +229,24 @@ given they are treated as if the first column contained a blank.  If the
  @option{-fd-lines-as-comments} option is given, they are treated as
  comment lines.
  
+@item -fdec
+@opindex @code{fdec}
+DEC compatibility mode. Enables extensions and other features that mimic
+the default behavior of older compilers (such as DEC).
+These features are non-standard and should be avoided at all costs.
+For details on GNU Fortran's implementation of these extensions see the 
+full documentation.
+
+Other flags enabled by this switch are:
+@option{-fdollar-ok} @option{-fcray-pointer} @option{-fdec-structure}
+
+@item -fdec-structure
+@opindex @code{fdec-structure}
+Enable DEC @code{STRUCTURE} and @code{RECORD} as well as @code{UNION},
+@code{MAP}, and dot ('.') as a member separator (in addition to '%'). This is
+provided for compatibility only; Fortran 90 derived types should be used
+instead where possible.
+
  @item -fdollar-ok
  @opindex @code{fdollar-ok}
  @cindex @code{$}
diff --git a/gcc/fortran/io.c b/gcc/fortran/io.c

index da0e1c5..6a4515d 100644 (file)
--- a/gcc/fortran/io.c
+++ b/gcc/fortran/io.c
@@ -3007,7 +3007,7 @@ gfc_resolve_dt (gfc_dt *dt, locus *loc)
      }
  
    if (dt->extra_comma
-      && !gfc_notify_std (GFC_STD_GNU, "Comma before i/o item list at %L", 
+      && !gfc_notify_std (GFC_STD_LEGACY, "Comma before i/o item list at %L", 
                           &dt->extra_comma->where))
      return false;
  
diff --git a/gcc/fortran/lang.opt b/gcc/fortran/lang.opt

index 45428d8..bdf5fa5 100644 (file)
--- a/gcc/fortran/lang.opt
+++ b/gcc/fortran/lang.opt
@@ -416,6 +416,14 @@ fd-lines-as-comments
  Fortran RejectNegative
  Treat lines with 'D' in column one as comments.
  
+fdec
+Fortran
+Enable all DEC language extensions.
+
+fdec-structure
+Fortran
+Enable support for DEC STRUCTURE/RECORD.
+
  fdefault-double-8
  Fortran Var(flag_default_double)
  Set the default double precision kind to an 8 byte wide type.
diff --git a/gcc/fortran/libgfortran.h b/gcc/fortran/libgfortran.h

index 96063f7..e913250 100644 (file)
--- a/gcc/fortran/libgfortran.h
+++ b/gcc/fortran/libgfortran.h
@@ -164,6 +164,6 @@ typedef enum
  typedef enum
  { BT_UNKNOWN = 0, BT_INTEGER, BT_LOGICAL, BT_REAL, BT_COMPLEX,
    BT_DERIVED, BT_CHARACTER, BT_CLASS, BT_PROCEDURE, BT_HOLLERITH, BT_VOID,
-  BT_ASSUMED
+  BT_ASSUMED, BT_UNION
  }
  bt;
diff --git a/gcc/fortran/match.c b/gcc/fortran/match.c

index 2490f85..f3a4a43 100644 (file)
--- a/gcc/fortran/match.c
+++ b/gcc/fortran/match.c
@@ -113,6 +113,128 @@ gfc_op2string (gfc_intrinsic_op op)
  
  /******************** Generic matching subroutines ************************/
  
+/* Matches a member separator. With standard FORTRAN this is '%', but with
+   DEC structures we must carefully match dot ('.').
+   Because operators are spelled ".op.", a dotted string such as "x.y.z..."
+   can be either a component reference chain or a combination of binary
+   operations.
+   There is no real way to win because the string may be grammatically
+   ambiguous. The following rules help avoid ambiguities - they match
+   some behavior of other (older) compilers. If the rules here are changed
+   the test cases should be updated. If the user has problems with these rules
+   they probably deserve the consequences. Consider "x.y.z":
+     (1) If any user defined operator ".y." exists, this is always y(x,z)
+         (even if ".y." is the wrong type and/or x has a member y).
+     (2) Otherwise if x has a member y, and y is itself a derived type,
+         this is (x->y)->z, even if an intrinsic operator exists which 
+         can handle (x,z). 
+     (3) If x has no member y or (x->y) is not a derived type but ".y." 
+         is an intrinsic operator (such as ".eq."), this is y(x,z).
+     (4) Lastly if there is no operator ".y." and x has no member "y", it is an
+         error.  
+   It is worth noting that the logic here does not support mixed use of member
+   accessors within a single string. That is, even if x has component y and y
+   has component z, the following are all syntax errors:
+         "x%y.z"  "x.y%z" "(x.y).z"  "(x%y)%z"
+ */
+
+match
+gfc_match_member_sep(gfc_symbol *sym)
+{
+  char name[GFC_MAX_SYMBOL_LEN + 1];
+  locus dot_loc, start_loc;
+  gfc_intrinsic_op iop;
+  match m;
+  gfc_symbol *tsym;
+  gfc_component *c = NULL;
+
+  /* What a relief: '%' is an unambiguous member separator.  */
+  if (gfc_match_char ('%') == MATCH_YES)
+    return MATCH_YES;
+
+  /* Beware ye who enter here.  */
+  if (!gfc_option.flag_dec_structure || !sym)
+    return MATCH_NO;
+
+  tsym = NULL;
+
+  /* We may be given either a derived type variable or the derived type
+    declaration itself (which actually contains the components); 
+    we need the latter to search for components.  */
+  if (gfc_fl_struct (sym->attr.flavor))
+    tsym = sym;
+  else if (gfc_bt_struct (sym->ts.type))
+    tsym = sym->ts.u.derived;
+
+  iop = INTRINSIC_NONE;
+  name[0] = '\0';
+  m = MATCH_NO;
+
+  /* If we have to reject come back here later.  */
+  start_loc = gfc_current_locus;
+
+  /* Look for a component access next.  */
+  if (gfc_match_char ('.') != MATCH_YES)
+    return MATCH_NO;
+
+  /* If we accept, come back here.  */
+  dot_loc = gfc_current_locus;
+
+  /* Try to match a symbol name following the dot.  */
+  if (gfc_match_name (name) != MATCH_YES)
+    {
+      gfc_error ("Expected structure component or operator name "
+                 "after '.' at %C");
+      goto error;
+    }
+
+  /* If no dot follows we have "x.y" which should be a component access.  */
+  if (gfc_match_char ('.') != MATCH_YES)
+    goto yes;
+
+  /* Now we have a string "x.y.z" which could be a nested member access
+    (x->y)->z or a binary operation y on x and z.  */
+
+  /* First use any user-defined operators ".y."  */
+  if (gfc_find_uop (name, sym->ns) != NULL)
+    goto no;
+
+  /* Match accesses to existing derived-type components for 
+    derived-type vars: "x.y.z" = (x->y)->z  */
+  c = gfc_find_component(tsym, name, false, true, NULL);
+  if (c && (gfc_bt_struct (c->ts.type) || c->ts.type == BT_CLASS))
+    goto yes;
+
+  /* If y is not a component or has no members, try intrinsic operators.  */
+  gfc_current_locus = start_loc;
+  if (gfc_match_intrinsic_op (&iop) != MATCH_YES)
+    {
+      /* If ".y." is not an intrinsic operator but y was a valid non-
+        structure component, match and leave the trailing dot to be 
+        dealt with later.  */
+      if (c)
+        goto yes;
+
+      gfc_error ("'%s' is neither a defined operator nor a "
+                 "structure component in dotted string at %C", name);
+      goto error;
+    }
+
+  /* .y. is an intrinsic operator, overriding any possible member access.  */
+  goto no;
+
+  /* Return keeping the current locus consistent with the match result.  */
+error:
+  m = MATCH_ERROR;
+no:
+  gfc_current_locus = start_loc;
+  return m;
+yes:
+  gfc_current_locus = dot_loc;
+  return MATCH_YES;
+}
+
+
  /* This function scans the current statement counting the opened and closed
     parenthesis to make sure they are balanced.  */
  
diff --git a/gcc/fortran/match.h b/gcc/fortran/match.h

index c3033ad..348ca70 100644 (file)
--- a/gcc/fortran/match.h
+++ b/gcc/fortran/match.h
@@ -60,6 +60,7 @@ match gfc_match (const char *, ...);
  match gfc_match_iterator (gfc_iterator *, int);
  match gfc_match_parens (void);
  match gfc_match_type_spec (gfc_typespec *);
+match gfc_match_member_sep(gfc_symbol *);
  
  
  /* Statement matchers.  */
@@ -208,6 +209,9 @@ match gfc_match_function_decl (void);
  match gfc_match_entry (void);
  match gfc_match_subroutine (void);
  match gfc_match_submod_proc (void);
+match gfc_match_map (void);
+match gfc_match_union (void);
+match gfc_match_structure_decl (void);
  match gfc_match_derived_decl (void);
  match gfc_match_final_decl (void);
  
diff --git a/gcc/fortran/misc.c b/gcc/fortran/misc.c

index 405bae0..1747ff2 100644 (file)
--- a/gcc/fortran/misc.c
+++ b/gcc/fortran/misc.c
@@ -83,6 +83,9 @@ gfc_basic_typename (bt type)
      case BT_HOLLERITH:
        p = "HOLLERITH";
        break;
+    case BT_UNION:
+      p = "UNION";
+      break;
      case BT_DERIVED:
        p = "DERIVED";
        break;
@@ -144,6 +147,9 @@ gfc_typename (gfc_typespec *ts)
      case BT_HOLLERITH:
        sprintf (buffer, "HOLLERITH");
        break;
+    case BT_UNION:
+      sprintf (buffer, "UNION(%s)", ts->u.derived->name);
+      break;
      case BT_DERIVED:
        sprintf (buffer, "TYPE(%s)", ts->u.derived->name);
        break;
diff --git a/gcc/fortran/module.c b/gcc/fortran/module.c

index 32ee526..6d3860e 100644 (file)
--- a/gcc/fortran/module.c
+++ b/gcc/fortran/module.c
@@ -422,8 +422,8 @@ resolve_fixups (fixup_t *f, void *gp)
     to convert the symtree name of a derived-type to the symbol name or to
     the name of the associated generic function.  */
  
-static const char *
-dt_lower_string (const char *name)
+const char *
+gfc_dt_lower_string (const char *name)
  {
    if (name[0] != (char) TOLOWER ((unsigned char) name[0]))
      return gfc_get_string ("%c%s", (char) TOLOWER ((unsigned char) name[0]),
@@ -437,8 +437,8 @@ dt_lower_string (const char *name)
     symtree/symbol name of the associated generic function start with a lower-
     case character.  */
  
-static const char *
-dt_upper_string (const char *name)
+const char *
+gfc_dt_upper_string (const char *name)
  {
    if (name[0] != (char) TOUPPER ((unsigned char) name[0]))
      return gfc_get_string ("%c%s", (char) TOUPPER ((unsigned char) name[0]),
@@ -832,7 +832,7 @@ find_use_name_n (const char *name, int *inst, bool interface)
  
    /* For derived types.  */
    if (name[0] != (char) TOLOWER ((unsigned char) name[0]))
-    low_name = dt_lower_string (name);
+    low_name = gfc_dt_lower_string (name);
  
    i = 0;
    for (u = gfc_rename_list; u; u = u->next)
@@ -861,7 +861,7 @@ find_use_name_n (const char *name, int *inst, bool interface)
      {
        if (u->local_name[0] == '\0')
         return name;
-      return dt_upper_string (u->local_name);
+      return gfc_dt_upper_string (u->local_name);
      }
  
    return (u->local_name[0] != '\0') ? u->local_name : name;
@@ -989,8 +989,8 @@ add_true_name (gfc_symbol *sym)
  
    t = XCNEW (true_name);
    t->sym = sym;
-  if (sym->attr.flavor == FL_DERIVED)
-    t->name = dt_upper_string (sym->name);
+  if (gfc_fl_struct (sym->attr.flavor))
+    t->name = gfc_dt_upper_string (sym->name);
    else
      t->name = sym->name;
  
@@ -1011,8 +1011,8 @@ build_tnt (gfc_symtree *st)
    build_tnt (st->left);
    build_tnt (st->right);
  
-  if (st->n.sym->attr.flavor == FL_DERIVED)
-    name = dt_upper_string (st->n.sym->name);
+  if (gfc_fl_struct (st->n.sym->attr.flavor))
+    name = gfc_dt_upper_string (st->n.sym->name);
    else
      name = st->n.sym->name;
  
@@ -2452,6 +2452,7 @@ static const mstring bt_types[] = {
      minit ("COMPLEX", BT_COMPLEX),
      minit ("LOGICAL", BT_LOGICAL),
      minit ("CHARACTER", BT_CHARACTER),
+    minit ("UNION", BT_UNION),
      minit ("DERIVED", BT_DERIVED),
      minit ("CLASS", BT_CLASS),
      minit ("PROCEDURE", BT_PROCEDURE),
@@ -2505,7 +2506,7 @@ mio_typespec (gfc_typespec *ts)
  
    ts->type = MIO_NAME (bt) (ts->type, bt_types);
  
-  if (ts->type != BT_DERIVED && ts->type != BT_CLASS)
+  if (!gfc_bt_struct (ts->type) && ts->type != BT_CLASS)
      mio_integer (&ts->kind);
    else
      mio_symbol_ref (&ts->u.derived);
@@ -3322,8 +3323,8 @@ fix_mio_expr (gfc_expr *e)
        if (e->symtree->n.sym && check_unique_name (e->symtree->name))
         {
            const char *name = e->symtree->n.sym->name;
-         if (e->symtree->n.sym->attr.flavor == FL_DERIVED)
-           name = dt_upper_string (name);
+         if (gfc_fl_struct (e->symtree->n.sym->attr.flavor))
+           name = gfc_dt_upper_string (name);
           ns_st = gfc_find_symtree (gfc_current_ns->sym_root, name);
         }
  
@@ -4265,7 +4266,7 @@ mio_symbol (gfc_symbol *sym)
  
    mio_integer (&(sym->intmod_sym_id));
  
-  if (sym->attr.flavor == FL_DERIVED)
+  if (gfc_fl_struct (sym->attr.flavor))
      mio_integer (&(sym->hash_value));
  
    if (sym->formal_ns
@@ -4845,7 +4846,7 @@ load_needed (pointer_info *p)
                                  1, &ns->proc_name);
  
        sym = gfc_new_symbol (p->u.rsym.true_name, ns);
-      sym->name = dt_lower_string (p->u.rsym.true_name);
+      sym->name = gfc_dt_lower_string (p->u.rsym.true_name);
        sym->module = gfc_get_string (p->u.rsym.module);
        if (p->u.rsym.binding_label)
         sym->binding_label = IDENTIFIER_POINTER (get_identifier
@@ -4857,6 +4858,12 @@ load_needed (pointer_info *p)
    mio_symbol (sym);
    sym->attr.use_assoc = 1;
  
+  /* Unliked derived types, a STRUCTURE may share names with other symbols.
+     We greedily converted the the symbol name to lowercase before we knew its
+     type, so now we must fix it. */
+  if (sym->attr.flavor == FL_STRUCT)
+    sym->name = gfc_dt_upper_string (sym->name);
+
    /* Mark as only or rename for later diagnosis for explicitly imported
       but not used warnings; don't mark internal symbols such as __vtab,
       __def_init etc. Only mark them if they have been explicitly loaded.  */
@@ -5059,7 +5066,7 @@ read_module (void)
          can be used in expressions in the module.  To avoid the module loading
          failing, we need to associate the module's component pointer indexes
          with the existing symbol's component pointers.  */
-      if (sym->attr.flavor == FL_DERIVED)
+      if (gfc_fl_struct (sym->attr.flavor))
         {
           gfc_component *c;
  
@@ -5213,7 +5220,7 @@ read_module (void)
                 {
                   info->u.rsym.sym = gfc_new_symbol (info->u.rsym.true_name,
                                                      gfc_current_ns);
-                 info->u.rsym.sym->name = dt_lower_string (info->u.rsym.true_name);
+                 info->u.rsym.sym->name = gfc_dt_lower_string (info->u.rsym.true_name);
                   sym = info->u.rsym.sym;
                   sym->module = gfc_get_string (info->u.rsym.module);
  
@@ -5557,10 +5564,10 @@ write_symbol (int n, gfc_symbol *sym)
  
    mio_integer (&n);
  
-  if (sym->attr.flavor == FL_DERIVED)
+  if (gfc_fl_struct (sym->attr.flavor))
      {
        const char *name;
-      name = dt_upper_string (sym->name);
+      name = gfc_dt_upper_string (sym->name);
        mio_pool_string (&name);
      }
    else
@@ -6568,7 +6575,7 @@ create_derived_type (const char *name, const char *modname,
    sym->attr.function = 1;
    sym->attr.generic = 1;
  
-  gfc_get_sym_tree (dt_upper_string (sym->name),
+  gfc_get_sym_tree (gfc_dt_upper_string (sym->name),
                     gfc_current_ns, &tmp_symtree, false);
    dt_sym = tmp_symtree->n.sym;
    dt_sym->name = gfc_get_string (sym->name);
diff --git a/gcc/fortran/openmp.c b/gcc/fortran/openmp.c

index 0dd1a92..be70318 100644 (file)
--- a/gcc/fortran/openmp.c
+++ b/gcc/fortran/openmp.c
@@ -1623,6 +1623,10 @@ match
  gfc_match_oacc_cache (void)
  {
    gfc_omp_clauses *c = gfc_get_omp_clauses ();
+  /* The OpenACC cache directive explicitly only allows "array elements or
+     subarrays", which we're currently not checking here.  Either check this
+     after the call of gfc_match_omp_variable_list, or add something like a
+     only_sections variant next to its allow_sections parameter.  */
    match m = gfc_match_omp_variable_list (" (",
                                          &c->lists[OMP_LIST_CACHE], true,
                                          NULL, NULL, true);
diff --git a/gcc/fortran/options.c b/gcc/fortran/options.c

index 0fcda1d..5a91ec1 100644 (file)
--- a/gcc/fortran/options.c
+++ b/gcc/fortran/options.c
@@ -47,6 +47,15 @@ set_default_std_flags (void)
  }
  
  
+/* Set all the DEC extension flags. */
+
+static void
+set_dec_flags (int value)
+{
+    gfc_option.flag_dec_structure  = value;
+}
+
+
  /* Return language mask for Fortran options.  */
  
  unsigned int
@@ -102,6 +111,8 @@ gfc_init_options (unsigned int decoded_options_count,
    if (!global_options_set.x_cpp_warn_missing_include_dirs)
      global_options.x_cpp_warn_missing_include_dirs = 1;
  
+  set_dec_flags (0);
+
    set_default_std_flags ();
  
    /* Initialize cpp-related options.  */
@@ -709,6 +720,15 @@ gfc_handle_option (size_t scode, const char *arg, int value,
      case OPT_fcheck_:
        gfc_handle_runtime_check_option (arg);
        break;
+
+    case OPT_fdec:
+      /* Enable all DEC extensions.  */
+      set_dec_flags (1);
+      break;
+
+    case OPT_fdec_structure:
+      gfc_option.flag_dec_structure = 1;
+      break;
      }
  
    Fortran_handle_option_auto (&global_options, &global_options_set, 
diff --git a/gcc/fortran/parse.c b/gcc/fortran/parse.c

index 7bce47f..1081b2e 100644 (file)
--- a/gcc/fortran/parse.c
+++ b/gcc/fortran/parse.c
@@ -256,6 +256,7 @@ decode_specification_statement (void)
  
      case 's':
        match ("save", gfc_match_save, ST_ATTR_DECL);
+      match ("structure", gfc_match_structure_decl, ST_STRUCTURE_DECL);
        break;
  
      case 't':
@@ -507,6 +508,7 @@ decode_statement (void)
        break;
  
      case 'm':
+      match ("map", gfc_match_map, ST_MAP);
        match ("module% procedure", gfc_match_modproc, ST_MODULE_PROC);
        match ("module", gfc_match_module, ST_MODULE);
        break;
@@ -542,6 +544,7 @@ decode_statement (void)
        break;
  
      case 's':
+      match ("structure", gfc_match_structure_decl, ST_STRUCTURE_DECL);
        match ("sequence", gfc_match_eos, ST_SEQUENCE);
        match ("stop", gfc_match_stop, ST_STOP);
        match ("save", gfc_match_save, ST_ATTR_DECL);
@@ -558,6 +561,7 @@ decode_statement (void)
        break;
  
      case 'u':
+      match ("union", gfc_match_union, ST_UNION);
        match ("unlock", gfc_match_unlock, ST_UNLOCK);
        break;
  
@@ -1386,9 +1390,13 @@ next_statement (void)
  
  #define case_decl case ST_ATTR_DECL: case ST_COMMON: case ST_DATA_DECL: \
    case ST_EQUIVALENCE: case ST_NAMELIST: case ST_STATEMENT_FUNCTION: \
-  case ST_TYPE: case ST_INTERFACE: case ST_OMP_THREADPRIVATE: \
-  case ST_PROCEDURE: case ST_OMP_DECLARE_SIMD: case ST_OMP_DECLARE_REDUCTION: \
-  case ST_OMP_DECLARE_TARGET: case ST_OACC_ROUTINE: case ST_OACC_DECLARE
+  case ST_TYPE: case ST_INTERFACE: case ST_PROCEDURE: case ST_OACC_ROUTINE: \
+  case ST_OACC_DECLARE
+
+/* OpenMP declaration statements.  */
+
+#define case_omp_decl case ST_OMP_THREADPRIVATE: case ST_OMP_DECLARE_SIMD: \
+  case ST_OMP_DECLARE_TARGET: case ST_OMP_DECLARE_REDUCTION
  
  /* Block end statements.  Errors associated with interchanging these
     are detected in gfc_match_end().  */
@@ -1642,6 +1650,15 @@ gfc_ascii_statement (gfc_statement st)
      case ST_DEALLOCATE:
        p = "DEALLOCATE";
        break;
+    case ST_MAP:
+      p = "MAP";
+      break;
+    case ST_UNION:
+      p = "UNION";
+      break;
+    case ST_STRUCTURE_DECL:
+      p = "STRUCTURE";
+      break;
      case ST_DERIVED_DECL:
        p = _("derived type declaration");
        break;
@@ -1711,6 +1728,15 @@ gfc_ascii_statement (gfc_statement st)
      case ST_END_WHERE:
        p = "END WHERE";
        break;
+    case ST_END_STRUCTURE:
+      p = "END STRUCTURE";
+      break;
+    case ST_END_UNION:
+      p = "END UNION";
+      break;
+    case ST_END_MAP:
+      p = "END MAP";
+      break;
      case ST_END_TYPE:
        p = "END TYPE";
        break;
@@ -2457,6 +2483,7 @@ verify_st_order (st_state *p, gfc_statement st, bool silent)
  
      case ST_PUBLIC:
      case ST_PRIVATE:
+    case ST_STRUCTURE_DECL:
      case ST_DERIVED_DECL:
      case_decl:
        if (p->state >= ORDER_EXEC)
@@ -2465,6 +2492,14 @@ verify_st_order (st_state *p, gfc_statement st, bool silent)
         p->state = ORDER_SPEC;
        break;
  
+    case_omp_decl:
+      /* The OpenMP directives have to be somewhere in the specification
+        part, but there are no further requirements on their ordering.
+        Thus don't adjust p->state, just ignore them.  */
+      if (p->state >= ORDER_EXEC)
+       goto order;
+      break;
+
      case_executable:
      case_exec_markers:
        if (p->state < ORDER_EXEC)
@@ -2646,6 +2681,358 @@ error:
  }
  
  
+/* Set attributes for the parent symbol based on the attributes of a component
+   and raise errors if conflicting attributes are found for the component.  */
+
+static void
+check_component (gfc_symbol *sym, gfc_component *c, gfc_component **lockp,
+    gfc_component **eventp)
+{
+  bool coarray, lock_type, event_type, allocatable, pointer;
+  coarray = lock_type = event_type = allocatable = pointer = false;
+  gfc_component *lock_comp = NULL, *event_comp = NULL;
+
+  if (lockp) lock_comp = *lockp;
+  if (eventp) event_comp = *eventp;
+
+  /* Look for allocatable components.  */
+  if (c->attr.allocatable
+      || (c->ts.type == BT_CLASS && c->attr.class_ok
+          && CLASS_DATA (c)->attr.allocatable)
+      || (c->ts.type == BT_DERIVED && !c->attr.pointer
+          && c->ts.u.derived->attr.alloc_comp))
+    {
+      allocatable = true;
+      sym->attr.alloc_comp = 1;
+    }
+
+  /* Look for pointer components.  */
+  if (c->attr.pointer
+      || (c->ts.type == BT_CLASS && c->attr.class_ok
+          && CLASS_DATA (c)->attr.class_pointer)
+      || (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.pointer_comp))
+    {
+      pointer = true;
+      sym->attr.pointer_comp = 1;
+    }
+
+  /* Look for procedure pointer components.  */
+  if (c->attr.proc_pointer
+      || (c->ts.type == BT_DERIVED
+          && c->ts.u.derived->attr.proc_pointer_comp))
+    sym->attr.proc_pointer_comp = 1;
+
+  /* Looking for coarray components.  */
+  if (c->attr.codimension
+      || (c->ts.type == BT_CLASS && c->attr.class_ok
+          && CLASS_DATA (c)->attr.codimension))
+    {
+      coarray = true;
+      sym->attr.coarray_comp = 1;
+    }
+ 
+  if (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.coarray_comp
+      && !c->attr.pointer)
+    {
+      coarray = true;
+      sym->attr.coarray_comp = 1;
+    }
+
+  /* Looking for lock_type components.  */
+  if ((c->ts.type == BT_DERIVED
+          && c->ts.u.derived->from_intmod == INTMOD_ISO_FORTRAN_ENV
+          && c->ts.u.derived->intmod_sym_id == ISOFORTRAN_LOCK_TYPE)
+      || (c->ts.type == BT_CLASS && c->attr.class_ok
+          && CLASS_DATA (c)->ts.u.derived->from_intmod
+             == INTMOD_ISO_FORTRAN_ENV
+          && CLASS_DATA (c)->ts.u.derived->intmod_sym_id
+             == ISOFORTRAN_LOCK_TYPE)
+      || (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.lock_comp
+          && !allocatable && !pointer))
+    {
+      lock_type = 1;
+      lock_comp = c;
+      sym->attr.lock_comp = 1;
+    }
+
+    /* Looking for event_type components.  */
+    if ((c->ts.type == BT_DERIVED
+            && c->ts.u.derived->from_intmod == INTMOD_ISO_FORTRAN_ENV
+            && c->ts.u.derived->intmod_sym_id == ISOFORTRAN_EVENT_TYPE)
+        || (c->ts.type == BT_CLASS && c->attr.class_ok
+            && CLASS_DATA (c)->ts.u.derived->from_intmod
+               == INTMOD_ISO_FORTRAN_ENV
+            && CLASS_DATA (c)->ts.u.derived->intmod_sym_id
+               == ISOFORTRAN_EVENT_TYPE)
+        || (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.event_comp
+            && !allocatable && !pointer))
+      {
+        event_type = 1;
+        event_comp = c;
+        sym->attr.event_comp = 1;
+      }
+
+  /* Check for F2008, C1302 - and recall that pointers may not be coarrays
+     (5.3.14) and that subobjects of coarray are coarray themselves (2.4.7),
+     unless there are nondirect [allocatable or pointer] components
+     involved (cf. 1.3.33.1 and 1.3.33.3).  */
+
+  if (pointer && !coarray && lock_type)
+    gfc_error ("Component %s at %L of type LOCK_TYPE must have a "
+               "codimension or be a subcomponent of a coarray, "
+               "which is not possible as the component has the "
+               "pointer attribute", c->name, &c->loc);
+  else if (pointer && !coarray && c->ts.type == BT_DERIVED
+           && c->ts.u.derived->attr.lock_comp)
+    gfc_error ("Pointer component %s at %L has a noncoarray subcomponent "
+               "of type LOCK_TYPE, which must have a codimension or be a "
+               "subcomponent of a coarray", c->name, &c->loc);
+
+  if (lock_type && allocatable && !coarray)
+    gfc_error ("Allocatable component %s at %L of type LOCK_TYPE must have "
+               "a codimension", c->name, &c->loc);
+  else if (lock_type && allocatable && c->ts.type == BT_DERIVED
+           && c->ts.u.derived->attr.lock_comp)
+    gfc_error ("Allocatable component %s at %L must have a codimension as "
+               "it has a noncoarray subcomponent of type LOCK_TYPE",
+               c->name, &c->loc);
+
+  if (sym->attr.coarray_comp && !coarray && lock_type)
+    gfc_error ("Noncoarray component %s at %L of type LOCK_TYPE or with "
+               "subcomponent of type LOCK_TYPE must have a codimension or "
+               "be a subcomponent of a coarray. (Variables of type %s may "
+               "not have a codimension as already a coarray "
+               "subcomponent exists)", c->name, &c->loc, sym->name);
+
+  if (sym->attr.lock_comp && coarray && !lock_type)
+    gfc_error ("Noncoarray component %s at %L of type LOCK_TYPE or with "
+               "subcomponent of type LOCK_TYPE must have a codimension or "
+               "be a subcomponent of a coarray. (Variables of type %s may "
+               "not have a codimension as %s at %L has a codimension or a "
+               "coarray subcomponent)", lock_comp->name, &lock_comp->loc,
+               sym->name, c->name, &c->loc);
+
+  /* Similarly for EVENT TYPE.  */
+
+  if (pointer && !coarray && event_type)
+    gfc_error ("Component %s at %L of type EVENT_TYPE must have a "
+               "codimension or be a subcomponent of a coarray, "
+               "which is not possible as the component has the "
+               "pointer attribute", c->name, &c->loc);
+  else if (pointer && !coarray && c->ts.type == BT_DERIVED
+           && c->ts.u.derived->attr.event_comp)
+    gfc_error ("Pointer component %s at %L has a noncoarray subcomponent "
+               "of type EVENT_TYPE, which must have a codimension or be a "
+               "subcomponent of a coarray", c->name, &c->loc);
+
+  if (event_type && allocatable && !coarray)
+    gfc_error ("Allocatable component %s at %L of type EVENT_TYPE must have "
+               "a codimension", c->name, &c->loc);
+  else if (event_type && allocatable && c->ts.type == BT_DERIVED
+           && c->ts.u.derived->attr.event_comp)
+    gfc_error ("Allocatable component %s at %L must have a codimension as "
+               "it has a noncoarray subcomponent of type EVENT_TYPE",
+               c->name, &c->loc);
+
+  if (sym->attr.coarray_comp && !coarray && event_type)
+    gfc_error ("Noncoarray component %s at %L of type EVENT_TYPE or with "
+               "subcomponent of type EVENT_TYPE must have a codimension or "
+               "be a subcomponent of a coarray. (Variables of type %s may "
+               "not have a codimension as already a coarray "
+               "subcomponent exists)", c->name, &c->loc, sym->name);
+
+  if (sym->attr.event_comp && coarray && !event_type)
+    gfc_error ("Noncoarray component %s at %L of type EVENT_TYPE or with "
+               "subcomponent of type EVENT_TYPE must have a codimension or "
+               "be a subcomponent of a coarray. (Variables of type %s may "
+               "not have a codimension as %s at %L has a codimension or a "
+               "coarray subcomponent)", event_comp->name, &event_comp->loc,
+               sym->name, c->name, &c->loc);
+
+  /* Look for private components.  */
+  if (sym->component_access == ACCESS_PRIVATE
+      || c->attr.access == ACCESS_PRIVATE
+      || (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.private_comp))
+    sym->attr.private_comp = 1;
+
+  if (lockp) *lockp = lock_comp;
+  if (eventp) *eventp = event_comp;
+}
+
+
+static void parse_struct_map (gfc_statement);
+
+/* Parse a union component definition within a structure definition.  */
+
+static void
+parse_union (void)
+{
+  int compiling;
+  gfc_statement st;
+  gfc_state_data s;
+  gfc_component *c, *lock_comp = NULL, *event_comp = NULL;
+  gfc_symbol *un;
+
+  accept_statement(ST_UNION);
+  push_state (&s, COMP_UNION, gfc_new_block);
+  un = gfc_new_block;
+
+  compiling = 1;
+
+  while (compiling)
+    {
+      st = next_statement ();
+      /* Only MAP declarations valid within a union. */
+      switch (st)
+        {
+        case ST_NONE:
+          unexpected_eof ();
+
+        case ST_MAP:
+          accept_statement (ST_MAP);
+          parse_struct_map (ST_MAP);
+          /* Add a component to the union for each map. */
+          if (!gfc_add_component (un, gfc_new_block->name, &c))
+            {
+              gfc_internal_error ("failed to create map component '%s'", 
+                  gfc_new_block->name);
+              reject_statement ();
+              return;
+            }
+          c->ts.type = BT_DERIVED;
+          c->ts.u.derived = gfc_new_block;
+          /* Normally components get their initialization expressions when they
+             are created in decl.c (build_struct) so we can look through the
+             flat component list for initializers during resolution. Unions and
+             maps create components along with their type definitions so we
+             have to generate initializers here. */
+          c->initializer = gfc_default_initializer (&c->ts);
+          break;
+
+        case ST_END_UNION:
+          compiling = 0;
+          accept_statement (ST_END_UNION);
+          break;
+
+        default:
+          unexpected_statement (st);
+          break;
+        }
+    }
+
+  for (c = un->components; c; c = c->next)
+    check_component (un, c, &lock_comp, &event_comp);
+
+  /* Add the union as a component in its parent structure.  */
+  pop_state ();
+  if (!gfc_add_component (gfc_current_block (), un->name, &c))
+    {
+      gfc_internal_error ("failed to create union component '%s'", un->name);
+      reject_statement ();
+      return;
+    }
+  c->ts.type = BT_UNION;
+  c->ts.u.derived = un;
+  c->initializer = gfc_default_initializer (&c->ts);
+
+  un->attr.zero_comp = un->components == NULL;
+}
+
+
+/* Parse a STRUCTURE or MAP.  */
+
+static void
+parse_struct_map (gfc_statement block)
+{
+  int compiling_type;
+  gfc_statement st;
+  gfc_state_data s;
+  gfc_symbol *sym;
+  gfc_component *c, *lock_comp = NULL, *event_comp = NULL;
+  gfc_compile_state comp;
+  gfc_statement ends;
+
+  if (block == ST_STRUCTURE_DECL)
+    {
+      comp = COMP_STRUCTURE;
+      ends = ST_END_STRUCTURE;
+    }
+  else
+    {
+      gcc_assert (block == ST_MAP);
+      comp = COMP_MAP;
+      ends = ST_END_MAP;
+    }
+
+  accept_statement(block);
+  push_state (&s, comp, gfc_new_block);
+
+  gfc_new_block->component_access = ACCESS_PUBLIC;
+  compiling_type = 1;
+
+  while (compiling_type)
+    {
+      st = next_statement ();
+      switch (st)
+        {
+        case ST_NONE:
+          unexpected_eof ();
+
+        /* Nested structure declarations will be captured as ST_DATA_DECL.  */
+        case ST_STRUCTURE_DECL:
+          /* Let a more specific error make it to decode_statement().  */
+          if (gfc_error_check () == 0)
+            gfc_error ("Syntax error in nested structure declaration at %C");
+          reject_statement ();
+          /* Skip the rest of this statement.  */
+          gfc_error_recovery ();
+          break;
+
+        case ST_UNION:
+          accept_statement (ST_UNION);
+          parse_union ();
+          break;
+
+        case ST_DATA_DECL:
+          /* The data declaration was a nested/ad-hoc STRUCTURE field.  */
+          accept_statement (ST_DATA_DECL);
+          if (gfc_new_block && gfc_new_block != gfc_current_block ()
+                            && gfc_new_block->attr.flavor == FL_STRUCT)
+              parse_struct_map (ST_STRUCTURE_DECL);
+          break;
+
+        case ST_END_STRUCTURE:
+        case ST_END_MAP:
+          if (st == ends)
+            {
+              accept_statement (st);
+              compiling_type = 0;
+            }
+          else
+            unexpected_statement (st);
+          break;
+
+        default:
+          unexpected_statement (st);
+          break;
+        }
+    }
+
+  /* Validate each component.  */
+  sym = gfc_current_block ();
+  for (c = sym->components; c; c = c->next)
+    check_component (sym, c, &lock_comp, &event_comp);
+
+  sym->attr.zero_comp = (sym->components == NULL);
+
+  /* Allow parse_union to find this structure to add to its list of maps.  */
+  if (block == ST_MAP)
+    gfc_new_block = gfc_current_block ();
+
+  pop_state ();
+}
+
+
  /* Parse a derived type.  */
  
  static void
@@ -2762,170 +3149,7 @@ endType:
     */
    sym = gfc_current_block ();
    for (c = sym->components; c; c = c->next)
-    {
-      bool coarray, lock_type, event_type, allocatable, pointer;
-      coarray = lock_type = event_type = allocatable = pointer = false;
-
-      /* Look for allocatable components.  */
-      if (c->attr.allocatable
-         || (c->ts.type == BT_CLASS && c->attr.class_ok
-             && CLASS_DATA (c)->attr.allocatable)
-         || (c->ts.type == BT_DERIVED && !c->attr.pointer
-             && c->ts.u.derived->attr.alloc_comp))
-       {
-         allocatable = true;
-         sym->attr.alloc_comp = 1;
-       }
-
-      /* Look for pointer components.  */
-      if (c->attr.pointer
-         || (c->ts.type == BT_CLASS && c->attr.class_ok
-             && CLASS_DATA (c)->attr.class_pointer)
-         || (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.pointer_comp))
-       {
-         pointer = true;
-         sym->attr.pointer_comp = 1;
-       }
-
-      /* Look for procedure pointer components.  */
-      if (c->attr.proc_pointer
-         || (c->ts.type == BT_DERIVED
-             && c->ts.u.derived->attr.proc_pointer_comp))
-       sym->attr.proc_pointer_comp = 1;
-
-      /* Looking for coarray components.  */
-      if (c->attr.codimension
-         || (c->ts.type == BT_CLASS && c->attr.class_ok
-             && CLASS_DATA (c)->attr.codimension))
-       {
-         coarray = true;
-         sym->attr.coarray_comp = 1;
-       }
-
-      if (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.coarray_comp
-         && !c->attr.pointer)
-       {
-         coarray = true;
-         sym->attr.coarray_comp = 1;
-       }
-
-      /* Looking for lock_type components.  */
-      if ((c->ts.type == BT_DERIVED
-             && c->ts.u.derived->from_intmod == INTMOD_ISO_FORTRAN_ENV
-             && c->ts.u.derived->intmod_sym_id == ISOFORTRAN_LOCK_TYPE)
-         || (c->ts.type == BT_CLASS && c->attr.class_ok
-             && CLASS_DATA (c)->ts.u.derived->from_intmod
-                == INTMOD_ISO_FORTRAN_ENV
-             && CLASS_DATA (c)->ts.u.derived->intmod_sym_id
-                == ISOFORTRAN_LOCK_TYPE)
-         || (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.lock_comp
-             && !allocatable && !pointer))
-       {
-         lock_type = 1;
-         lock_comp = c;
-         sym->attr.lock_comp = 1;
-       }
-
-      /* Looking for event_type components.  */
-      if ((c->ts.type == BT_DERIVED
-             && c->ts.u.derived->from_intmod == INTMOD_ISO_FORTRAN_ENV
-             && c->ts.u.derived->intmod_sym_id == ISOFORTRAN_EVENT_TYPE)
-         || (c->ts.type == BT_CLASS && c->attr.class_ok
-             && CLASS_DATA (c)->ts.u.derived->from_intmod
-                == INTMOD_ISO_FORTRAN_ENV
-             && CLASS_DATA (c)->ts.u.derived->intmod_sym_id
-                == ISOFORTRAN_EVENT_TYPE)
-         || (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.event_comp
-             && !allocatable && !pointer))
-       {
-         event_type = 1;
-         event_comp = c;
-         sym->attr.event_comp = 1;
-       }
-
-      /* Check for F2008, C1302 - and recall that pointers may not be coarrays
-        (5.3.14) and that subobjects of coarray are coarray themselves (2.4.7),
-        unless there are nondirect [allocatable or pointer] components
-        involved (cf. 1.3.33.1 and 1.3.33.3).  */
-
-      if (pointer && !coarray && lock_type)
-       gfc_error ("Component %s at %L of type LOCK_TYPE must have a "
-                  "codimension or be a subcomponent of a coarray, "
-                  "which is not possible as the component has the "
-                  "pointer attribute", c->name, &c->loc);
-      else if (pointer && !coarray && c->ts.type == BT_DERIVED
-              && c->ts.u.derived->attr.lock_comp)
-       gfc_error ("Pointer component %s at %L has a noncoarray subcomponent "
-                  "of type LOCK_TYPE, which must have a codimension or be a "
-                  "subcomponent of a coarray", c->name, &c->loc);
-
-      if (lock_type && allocatable && !coarray)
-       gfc_error ("Allocatable component %s at %L of type LOCK_TYPE must have "
-                  "a codimension", c->name, &c->loc);
-      else if (lock_type && allocatable && c->ts.type == BT_DERIVED
-              && c->ts.u.derived->attr.lock_comp)
-       gfc_error ("Allocatable component %s at %L must have a codimension as "
-                  "it has a noncoarray subcomponent of type LOCK_TYPE",
-                  c->name, &c->loc);
-
-      if (sym->attr.coarray_comp && !coarray && lock_type)
-       gfc_error ("Noncoarray component %s at %L of type LOCK_TYPE or with "
-                  "subcomponent of type LOCK_TYPE must have a codimension or "
-                  "be a subcomponent of a coarray. (Variables of type %s may "
-                  "not have a codimension as already a coarray "
-                  "subcomponent exists)", c->name, &c->loc, sym->name);
-
-      if (sym->attr.lock_comp && coarray && !lock_type)
-       gfc_error ("Noncoarray component %s at %L of type LOCK_TYPE or with "
-                  "subcomponent of type LOCK_TYPE must have a codimension or "
-                  "be a subcomponent of a coarray. (Variables of type %s may "
-                  "not have a codimension as %s at %L has a codimension or a "
-                  "coarray subcomponent)", lock_comp->name, &lock_comp->loc,
-                  sym->name, c->name, &c->loc);
-
-      /* Similarly for EVENT TYPE.  */
-
-      if (pointer && !coarray && event_type)
-       gfc_error ("Component %s at %L of type EVENT_TYPE must have a "
-                  "codimension or be a subcomponent of a coarray, "
-                  "which is not possible as the component has the "
-                  "pointer attribute", c->name, &c->loc);
-      else if (pointer && !coarray && c->ts.type == BT_DERIVED
-              && c->ts.u.derived->attr.event_comp)
-       gfc_error ("Pointer component %s at %L has a noncoarray subcomponent "
-                  "of type EVENT_TYPE, which must have a codimension or be a "
-                  "subcomponent of a coarray", c->name, &c->loc);
-
-      if (event_type && allocatable && !coarray)
-       gfc_error ("Allocatable component %s at %L of type EVENT_TYPE must have "
-                  "a codimension", c->name, &c->loc);
-      else if (event_type && allocatable && c->ts.type == BT_DERIVED
-              && c->ts.u.derived->attr.event_comp)
-       gfc_error ("Allocatable component %s at %L must have a codimension as "
-                  "it has a noncoarray subcomponent of type EVENT_TYPE",
-                  c->name, &c->loc);
-
-      if (sym->attr.coarray_comp && !coarray && event_type)
-       gfc_error ("Noncoarray component %s at %L of type EVENT_TYPE or with "
-                  "subcomponent of type EVENT_TYPE must have a codimension or "
-                  "be a subcomponent of a coarray. (Variables of type %s may "
-                  "not have a codimension as already a coarray "
-                  "subcomponent exists)", c->name, &c->loc, sym->name);
-
-      if (sym->attr.event_comp && coarray && !event_type)
-       gfc_error ("Noncoarray component %s at %L of type EVENT_TYPE or with "
-                  "subcomponent of type EVENT_TYPE must have a codimension or "
-                  "be a subcomponent of a coarray. (Variables of type %s may "
-                  "not have a codimension as %s at %L has a codimension or a "
-                  "coarray subcomponent)", event_comp->name, &event_comp->loc,
-                  sym->name, c->name, &c->loc);
-
-      /* Look for private components.  */
-      if (sym->component_access == ACCESS_PRIVATE
-         || c->attr.access == ACCESS_PRIVATE
-         || (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.private_comp))
-       sym->attr.private_comp = 1;
-    }
+    check_component (sym, c, &lock_comp, &event_comp);
  
    if (!seen_component)
      sym->attr.zero_comp = 1;
@@ -3348,8 +3572,10 @@ loop:
      case ST_PARAMETER:
      case ST_PUBLIC:
      case ST_PRIVATE:
+    case ST_STRUCTURE_DECL:
      case ST_DERIVED_DECL:
      case_decl:
+    case_omp_decl:
  declSt:
        if (!verify_st_order (&ss, st, false))
         {
@@ -3364,6 +3590,10 @@ declSt:
           parse_interface ();
           break;
  
+        case ST_STRUCTURE_DECL:
+          parse_struct_map (ST_STRUCTURE_DECL);
+          break;
+
         case ST_DERIVED_DECL:
           parse_derived ();
           break;
diff --git a/gcc/fortran/parse.h b/gcc/fortran/parse.h

index f12fd5e..e8f71cf 100644 (file)
--- a/gcc/fortran/parse.h
+++ b/gcc/fortran/parse.h
@@ -28,6 +28,7 @@ enum gfc_compile_state
    COMP_NONE, COMP_PROGRAM, COMP_MODULE, COMP_SUBMODULE, COMP_SUBROUTINE,
    COMP_FUNCTION, COMP_BLOCK_DATA, COMP_INTERFACE, COMP_DERIVED,
    COMP_DERIVED_CONTAINS, COMP_BLOCK, COMP_ASSOCIATE, COMP_IF,
+  COMP_STRUCTURE, COMP_UNION, COMP_MAP,
    COMP_DO, COMP_SELECT, COMP_FORALL, COMP_WHERE, COMP_CONTAINS, COMP_ENUM,
    COMP_SELECT_TYPE, COMP_OMP_STRUCTURED_BLOCK, COMP_CRITICAL, COMP_DO_CONCURRENT
  };
@@ -58,6 +59,8 @@ extern gfc_state_data *gfc_state_stack;
  
  #define gfc_current_block() (gfc_state_stack->sym)
  #define gfc_current_state() (gfc_state_stack->state)
+#define gfc_comp_struct(s) \
+  ((s) == COMP_DERIVED || (s) == COMP_STRUCTURE || (s) == COMP_MAP)
  
  int gfc_check_do_variable (gfc_symtree *);
  bool gfc_find_state (gfc_compile_state);
diff --git a/gcc/fortran/primary.c b/gcc/fortran/primary.c

index d25d3de..c2faa0f 100644 (file)
--- a/gcc/fortran/primary.c
+++ b/gcc/fortran/primary.c
@@ -1883,11 +1883,12 @@ gfc_match_varspec (gfc_expr *primary, int equiv_flag, bool sub_flag,
                    bool ppc_arg)
  {
    char name[GFC_MAX_SYMBOL_LEN + 1];
-  gfc_ref *substring, *tail;
+  gfc_ref *substring, *tail, *tmp;
    gfc_component *component;
    gfc_symbol *sym = primary->symtree->n.sym;
    match m;
    bool unknown;
+  char sep;
  
    tail = NULL;
  
@@ -1972,25 +1973,31 @@ gfc_match_varspec (gfc_expr *primary, int equiv_flag, bool sub_flag,
    if (equiv_flag)
      return MATCH_YES;
  
-  if (sym->ts.type == BT_UNKNOWN && gfc_peek_ascii_char () == '%'
+  /* With DEC extensions, member separator may be '.' or '%'.  */
+  sep = gfc_peek_ascii_char ();
+  m = gfc_match_member_sep (sym);
+  if (m == MATCH_ERROR)
+    return MATCH_ERROR;
+
+  if (sym->ts.type == BT_UNKNOWN && m == MATCH_YES
        && gfc_get_default_type (sym->name, sym->ns)->type == BT_DERIVED)
      gfc_set_default_type (sym, 0, sym->ns);
  
-  if (sym->ts.type == BT_UNKNOWN && gfc_match_char ('%') == MATCH_YES)
+  if (sym->ts.type == BT_UNKNOWN && m == MATCH_YES)
      {
        gfc_error ("Symbol %qs at %C has no IMPLICIT type", sym->name);
        return MATCH_ERROR;
      }
    else if ((sym->ts.type != BT_DERIVED && sym->ts.type != BT_CLASS)
-          && gfc_match_char ('%') == MATCH_YES)
+           && m == MATCH_YES)
      {
-      gfc_error ("Unexpected %<%%%> for nonderived-type variable %qs at %C",
-                sym->name);
+      gfc_error ("Unexpected %<%c%> for nonderived-type variable %qs at %C",
+                sep, sym->name);
        return MATCH_ERROR;
      }
  
    if ((sym->ts.type != BT_DERIVED && sym->ts.type != BT_CLASS)
-      || gfc_match_char ('%') != MATCH_YES)
+      || m != MATCH_YES)
      goto check_substring;
  
    sym = sym->ts.u.derived;
@@ -2061,15 +2068,24 @@ gfc_match_varspec (gfc_expr *primary, int equiv_flag, bool sub_flag,
           break;
         }
  
-      component = gfc_find_component (sym, name, false, false);
+      component = gfc_find_component (sym, name, false, false, &tmp);
        if (component == NULL)
         return MATCH_ERROR;
  
-      tail = extend_ref (primary, tail);
-      tail->type = REF_COMPONENT;
+      /* Extend the reference chain determined by gfc_find_component.  */
+      if (primary->ref == NULL)
+        primary->ref = tmp;
+      else
+        {
+          /* Set by the for loop below for the last component ref.  */
+          gcc_assert (tail != NULL);
+          tail->next = tmp;
+        }
  
-      tail->u.c.component = component;
-      tail->u.c.sym = sym;
+      /* The reference chain may be longer than one hop for union
+         subcomponents; find the new tail.  */
+      for (tail = tmp; tail->next; tail = tail->next)
+        ;
  
        primary->ts = component->ts;
  
@@ -2119,7 +2135,7 @@ gfc_match_varspec (gfc_expr *primary, int equiv_flag, bool sub_flag,
         }
  
        if ((component->ts.type != BT_DERIVED && component->ts.type != BT_CLASS)
-         || gfc_match_char ('%') != MATCH_YES)
+         || gfc_match_member_sep (component->ts.u.derived) != MATCH_YES)
         break;
  
        sym = component->ts.u.derived;
@@ -2127,7 +2143,7 @@ gfc_match_varspec (gfc_expr *primary, int equiv_flag, bool sub_flag,
  
  check_substring:
    unknown = false;
-  if (primary->ts.type == BT_UNKNOWN && sym->attr.flavor != FL_DERIVED)
+  if (primary->ts.type == BT_UNKNOWN && !gfc_fl_struct (sym->attr.flavor))
      {
        if (gfc_get_default_type (sym->name, sym->ns)->type == BT_CHARACTER)
         {
@@ -2548,11 +2564,11 @@ gfc_convert_to_structure_constructor (gfc_expr *e, gfc_symbol *sym, gfc_expr **c
        /* Find the current component in the structure definition and check
              its access is not private.  */
        if (comp)
-       this_comp = gfc_find_component (sym, comp->name, false, false);
+       this_comp = gfc_find_component (sym, comp->name, false, false, NULL);
        else
         {
           this_comp = gfc_find_component (sym, (const char *)comp_tail->name,
-                                         false, false);
+                                         false, false, NULL);
           comp = NULL; /* Reset needed!  */
         }
  
@@ -2596,7 +2612,7 @@ gfc_convert_to_structure_constructor (gfc_expr *e, gfc_symbol *sym, gfc_expr **c
            if (comp && comp == sym->components
                  && sym->attr.extension
                 && comp_tail->val
-                && (comp_tail->val->ts.type != BT_DERIVED
+                && (!gfc_bt_struct (comp_tail->val->ts.type)
                        ||
                      comp_tail->val->ts.u.derived != this_comp->ts.u.derived))
              {
@@ -2697,7 +2713,7 @@ gfc_match_structure_constructor (gfc_symbol *sym, gfc_expr **result)
    e->symtree = symtree;
    e->expr_type = EXPR_FUNCTION;
  
-  gcc_assert (sym->attr.flavor == FL_DERIVED
+  gcc_assert (gfc_fl_struct (sym->attr.flavor)
               && symtree->n.sym->attr.flavor == FL_PROCEDURE);
    e->value.function.esym = sym;
    e->symtree->n.sym->attr.generic = 1;
@@ -2795,15 +2811,29 @@ gfc_match_rvalue (gfc_expr **result)
    if (m != MATCH_YES)
      return m;
  
-  if (gfc_find_state (COMP_INTERFACE)
-      && !gfc_current_ns->has_import_set)
-    i = gfc_get_sym_tree (name, NULL, &symtree, false);
-  else
-    i = gfc_get_ha_sym_tree (name, &symtree);
-
-  if (i)
+  /* Check if the symbol exists.  */
+  if (gfc_find_sym_tree (name, NULL, 1, &symtree))
      return MATCH_ERROR;
  
+  /* If the symbol doesn't exist, create it unless the name matches a FL_STRUCT
+     type. For derived types we create a generic symbol which links to the
+     derived type symbol; STRUCTUREs are simpler and must not conflict with
+     variables.  */
+  if (!symtree)
+    if (gfc_find_sym_tree (gfc_dt_upper_string (name), NULL, 1, &symtree))
+      return MATCH_ERROR;
+  if (!symtree || symtree->n.sym->attr.flavor != FL_STRUCT)
+    {
+      if (gfc_find_state (COMP_INTERFACE)
+          && !gfc_current_ns->has_import_set)
+        i = gfc_get_sym_tree (name, NULL, &symtree, false);
+      else
+        i = gfc_get_ha_sym_tree (name, &symtree);
+      if (i)
+        return MATCH_ERROR;
+    }
+
+
    sym = symtree->n.sym;
    e = NULL;
    where = gfc_current_locus;
@@ -2914,6 +2944,7 @@ gfc_match_rvalue (gfc_expr **result)
  
        break;
  
+    case FL_STRUCT:
      case FL_DERIVED:
        sym = gfc_use_derived (sym);
        if (sym == NULL)
@@ -3054,10 +3085,12 @@ gfc_match_rvalue (gfc_expr **result)
          via an IMPLICIT statement.  This can't wait for the
          resolution phase.  */
  
-      if (gfc_peek_ascii_char () == '%'
+      old_loc = gfc_current_locus;
+      if (gfc_match_member_sep (sym) == MATCH_YES
           && sym->ts.type == BT_UNKNOWN
           && gfc_get_default_type (sym->name, sym->ns)->type == BT_DERIVED)
         gfc_set_default_type (sym, 0, sym->ns);
+      gfc_current_locus = old_loc;
  
        /* If the symbol has a (co)dimension attribute, the expression is a
          variable.  */
@@ -3210,13 +3243,19 @@ gfc_match_rvalue (gfc_expr **result)
        break;
  
      generic_function:
-      gfc_get_sym_tree (name, NULL, &symtree, false);  /* Can't fail */
+      /* Look for symbol first; if not found, look for STRUCTURE type symbol
+         specially. Creates a generic symbol for derived types.  */
+      gfc_find_sym_tree (name, NULL, 1, &symtree);
+      if (!symtree)
+        gfc_find_sym_tree (gfc_dt_upper_string (name), NULL, 1, &symtree);
+      if (!symtree || symtree->n.sym->attr.flavor != FL_STRUCT)
+        gfc_get_sym_tree (name, NULL, &symtree, false); /* Can't fail */
  
        e = gfc_get_expr ();
        e->symtree = symtree;
        e->expr_type = EXPR_FUNCTION;
  
-      if (sym->attr.flavor == FL_DERIVED)
+      if (gfc_fl_struct (sym->attr.flavor))
         {
           e->value.function.esym = sym;
           e->symtree->n.sym->attr.generic = 1;
@@ -3260,10 +3299,10 @@ gfc_match_rvalue (gfc_expr **result)
  static match
  match_variable (gfc_expr **result, int equiv_flag, int host_flag)
  {
-  gfc_symbol *sym;
+  gfc_symbol *sym, *dt_sym;
    gfc_symtree *st;
    gfc_expr *expr;
-  locus where;
+  locus where, old_loc;
    match m;
  
    /* Since nothing has any business being an lvalue in a module
@@ -3294,6 +3333,17 @@ match_variable (gfc_expr **result, int equiv_flag, int host_flag)
    sym->attr.implied_index = 0;
  
    gfc_set_sym_referenced (sym);
+
+  /* STRUCTUREs may share names with variables, but derived types may not.  */
+  if (sym->attr.flavor == FL_PROCEDURE && sym->generic
+      && (dt_sym = gfc_find_dt_in_generic (sym)))
+    {
+      if (dt_sym->attr.flavor == FL_DERIVED)
+        gfc_error ("Derived type '%s' cannot be used as a variable at %C",
+                   sym->name);
+      return MATCH_ERROR;
+    }
+
    switch (sym->attr.flavor)
      {
      case FL_VARIABLE:
@@ -3379,11 +3429,13 @@ match_variable (gfc_expr **result, int equiv_flag, int host_flag)
         implicit_ns = gfc_current_ns;
        else
         implicit_ns = sym->ns;
-
-      if (gfc_peek_ascii_char () == '%'
+       
+      old_loc = gfc_current_locus;
+      if (gfc_match_member_sep (sym) == MATCH_YES
           && sym->ts.type == BT_UNKNOWN
           && gfc_get_default_type (sym->name, implicit_ns)->type == BT_DERIVED)
         gfc_set_default_type (sym, 0, implicit_ns);
+      gfc_current_locus = old_loc;
      }
  
    expr = gfc_get_expr ();
diff --git a/gcc/fortran/resolve.c b/gcc/fortran/resolve.c

index f5cd588..77f8c10 100644 (file)
--- a/gcc/fortran/resolve.c
+++ b/gcc/fortran/resolve.c
@@ -535,7 +535,7 @@ static void
  find_arglists (gfc_symbol *sym)
  {
    if (sym->attr.if_source == IFSRC_UNKNOWN || sym->ns != gfc_current_ns
-      || sym->attr.flavor == FL_DERIVED || sym->attr.intrinsic)
+      || gfc_fl_struct (sym->attr.flavor) || sym->attr.intrinsic)
      return;
  
    resolve_formal_arglist (sym);
@@ -1116,6 +1116,7 @@ resolve_contained_functions (gfc_namespace *ns)
  
  
  static bool resolve_fl_derived0 (gfc_symbol *sym);
+static bool resolve_fl_struct (gfc_symbol *sym);
  
  
  /* Resolve all of the elements of a structure constructor and make sure that
@@ -1132,8 +1133,13 @@ resolve_structure_cons (gfc_expr *expr, int init)
  
    t = true;
  
-  if (expr->ts.type == BT_DERIVED)
-    resolve_fl_derived0 (expr->ts.u.derived);
+  if (expr->ts.type == BT_DERIVED || expr->ts.type == BT_UNION)
+    {
+      if (expr->ts.u.derived->attr.flavor == FL_DERIVED)
+        resolve_fl_derived0 (expr->ts.u.derived);
+      else
+        resolve_fl_struct (expr->ts.u.derived);
+    }
  
    cons = gfc_constructor_first (expr->value.constructor);
  
@@ -1561,7 +1567,7 @@ is_illegal_recursion (gfc_symbol* sym, gfc_namespace* context)
    gfc_namespace* real_context;
  
    if (sym->attr.flavor == FL_PROGRAM
-      || sym->attr.flavor == FL_DERIVED)
+      || gfc_fl_struct (sym->attr.flavor))
      return false;
  
    gcc_assert (sym->attr.flavor == FL_PROCEDURE);
@@ -2548,7 +2554,7 @@ resolve_generic_f (gfc_expr *expr)
  generic:
        if (!intr)
         for (intr = sym->generic; intr; intr = intr->next)
-         if (intr->sym->attr.flavor == FL_DERIVED)
+         if (gfc_fl_struct (intr->sym->attr.flavor))
             break;
  
        if (sym->ns->parent == NULL)
@@ -5715,7 +5721,7 @@ get_declared_from_expr (gfc_ref **class_ref, gfc_ref **new_ref,
         continue;
  
        if ((ref->u.c.component->ts.type == BT_CLASS
-            || (check_types && ref->u.c.component->ts.type == BT_DERIVED))
+            || (check_types && gfc_bt_struct (ref->u.c.component->ts.type)))
           && ref->u.c.component->attr.flavor != FL_PROCEDURE)
         {
           declared = ref->u.c.component->ts.u.derived;
@@ -5978,7 +5984,7 @@ resolve_typebound_function (gfc_expr* e)
          is present.  */
        ts = expr->ts;
        declared = ts.u.derived;
-      c = gfc_find_component (declared, "_vptr", true, true);
+      c = gfc_find_component (declared, "_vptr", true, true, NULL);
        if (c->ts.u.derived == NULL)
         c->ts.u.derived = gfc_find_derived_vtab (declared);
  
@@ -6025,14 +6031,14 @@ resolve_typebound_function (gfc_expr* e)
      return false;
  
    /* Weed out cases of the ultimate component being a derived type.  */
-  if ((class_ref && class_ref->u.c.component->ts.type == BT_DERIVED)
+  if ((class_ref && gfc_bt_struct (class_ref->u.c.component->ts.type))
          || (!class_ref && st->n.sym->ts.type != BT_CLASS))
      {
        gfc_free_ref_list (new_ref);
        return resolve_compcall (e, NULL);
      }
  
-  c = gfc_find_component (declared, "_data", true, true);
+  c = gfc_find_component (declared, "_data", true, true, NULL);
    declared = c->ts.u.derived;
  
    /* Treat the call as if it is a typebound procedure, in order to roll
@@ -6111,7 +6117,7 @@ resolve_typebound_subroutine (gfc_code *code)
          that any delays in resolution are corrected and that the vtab
          is present.  */
        declared = expr->ts.u.derived;
-      c = gfc_find_component (declared, "_vptr", true, true);
+      c = gfc_find_component (declared, "_vptr", true, true, NULL);
        if (c->ts.u.derived == NULL)
         c->ts.u.derived = gfc_find_derived_vtab (declared);
  
@@ -6156,7 +6162,7 @@ resolve_typebound_subroutine (gfc_code *code)
    get_declared_from_expr (&class_ref, &new_ref, code->expr1, true);
  
    /* Weed out cases of the ultimate component being a derived type.  */
-  if ((class_ref && class_ref->u.c.component->ts.type == BT_DERIVED)
+  if ((class_ref && gfc_bt_struct (class_ref->u.c.component->ts.type))
          || (!class_ref && st->n.sym->ts.type != BT_CLASS))
      {
        gfc_free_ref_list (new_ref);
@@ -7140,7 +7146,7 @@ resolve_allocate_expr (gfc_expr *e, gfc_code *code, bool *array_alloc_wo_spec)
        gfc_typespec ts;
        gfc_expr *init_e;
  
-      if (code->ext.alloc.ts.type == BT_DERIVED)
+      if (gfc_bt_struct (code->ext.alloc.ts.type))
         ts = code->ext.alloc.ts;
        else
         ts = e->ts;
@@ -7148,7 +7154,7 @@ resolve_allocate_expr (gfc_expr *e, gfc_code *code, bool *array_alloc_wo_spec)
        if (ts.type == BT_CLASS)
         ts = ts.u.derived->components->ts;
  
-      if (ts.type == BT_DERIVED && (init_e = gfc_default_initializer (&ts)))
+      if (gfc_bt_struct (ts.type) && (init_e = gfc_default_initializer (&ts)))
         {
           gfc_code *init_st = gfc_get_code (EXEC_INIT_ASSIGN);
           init_st->loc = code->loc;
@@ -7282,7 +7288,7 @@ check_symbols:
           sym = a->expr->symtree->n.sym;
  
           /* TODO - check derived type components.  */
-         if (sym->ts.type == BT_DERIVED || sym->ts.type == BT_CLASS)
+         if (gfc_bt_struct (sym->ts.type) || sym->ts.type == BT_CLASS)
             continue;
  
           if ((ar->start[i] != NULL
@@ -8220,7 +8226,7 @@ resolve_assoc_var (gfc_symbol* sym, bool resolve_target)
           if (!gfc_build_class_symbol (&sym->ts, &attr, &as))
             gcc_unreachable ();
           /* Make sure the _vptr is set.  */
-         c = gfc_find_component (sym->ts.u.derived, "_vptr", true, true);
+         c = gfc_find_component (sym->ts.u.derived, "_vptr", true, true, NULL);
           if (c->ts.u.derived == NULL)
             c->ts.u.derived = gfc_find_derived_vtab (sym->ts.u.derived);
           CLASS_DATA (sym)->attr.pointer = 1;
@@ -9911,7 +9917,7 @@ nonscalar_typebound_assign (gfc_symbol *derived, int depth)
  
    for (c= derived->components; c; c = c->next)
      {
-      if ((c->ts.type != BT_DERIVED
+      if ((!gfc_bt_struct (c->ts.type)
             || c->attr.pointer
             || c->attr.allocatable
             || c->attr.proc_pointer_comp
@@ -10051,7 +10057,7 @@ generate_component_assignments (gfc_code **code, gfc_namespace *ns)
  
        /* The intrinsic assignment does the right thing for pointers
          of all kinds and allocatable components.  */
-      if (comp1->ts.type != BT_DERIVED
+      if (!gfc_bt_struct (comp1->ts.type)
           || comp1->attr.pointer
           || comp1->attr.allocatable
           || comp1->attr.proc_pointer_comp
@@ -11433,7 +11439,7 @@ resolve_fl_variable_derived (gfc_symbol *sym, int no_init_flag)
        gfc_find_symbol (sym->ts.u.derived->name, sym->ns, 0, &s);
        if (s && s->attr.generic)
         s = gfc_find_dt_in_generic (s);
-      if (s && s->attr.flavor != FL_DERIVED)
+      if (s && !gfc_fl_struct (s->attr.flavor))
         {
           gfc_error ("The type %qs cannot be host associated at %L "
                      "because it is blocked by an incompatible object "
@@ -11959,17 +11965,17 @@ resolve_fl_procedure (gfc_symbol *sym, int mp_flag)
         goto check_formal;
  
        /* Check the procedure characteristics.  */
-      if (sym->attr.pure != iface->attr.pure)
+      if (sym->attr.elemental != iface->attr.elemental)
         {
-         gfc_error ("Mismatch in PURE attribute between MODULE "
+         gfc_error ("Mismatch in ELEMENTAL attribute between MODULE "
                      "PROCEDURE at %L and its interface in %s",
                      &sym->declared_at, module_name);
           return false;
         }
  
-      if (sym->attr.elemental != iface->attr.elemental)
+      if (sym->attr.pure != iface->attr.pure)
         {
-         gfc_error ("Mismatch in ELEMENTAL attribute between MODULE "
+         gfc_error ("Mismatch in PURE attribute between MODULE "
                      "PROCEDURE at %L and its interface in %s",
                      &sym->declared_at, module_name);
           return false;
@@ -12733,7 +12739,8 @@ resolve_typebound_procedure (gfc_symtree* stree)
        }
  
    /* Try to find a name collision with an inherited component.  */
-  if (super_type && gfc_find_component (super_type, stree->name, true, true))
+  if (super_type && gfc_find_component (super_type, stree->name, true, true,
+                                        NULL))
      {
        gfc_error ("Procedure %qs at %L has the same name as an inherited"
                  " component of %qs",
@@ -12881,7 +12888,7 @@ check_defined_assignments (gfc_symbol *derived)
  
    for (c = derived->components; c; c = c->next)
      {
-      if (c->ts.type != BT_DERIVED
+      if (!gfc_bt_struct (c->ts.type)
           || c->attr.pointer
           || c->attr.allocatable
           || c->attr.proc_pointer_comp
@@ -12907,435 +12914,498 @@ check_defined_assignments (gfc_symbol *derived)
  }
  
  
-/* Resolve the components of a derived type. This does not have to wait until
-   resolution stage, but can be done as soon as the dt declaration has been
-   parsed.  */
+/* Resolve a single component of a derived type or structure.  */
  
  static bool
-resolve_fl_derived0 (gfc_symbol *sym)
+resolve_component (gfc_component *c, gfc_symbol *sym)
  {
-  gfc_symbol* super_type;
-  gfc_component *c;
+  gfc_symbol *super_type;
  
-  if (sym->attr.unlimited_polymorphic)
+  if (c->attr.artificial)
      return true;
  
-  super_type = gfc_get_derived_super_type (sym);
+  /* F2008, C442.  */
+  if ((!sym->attr.is_class || c != sym->components)
+      && c->attr.codimension
+      && (!c->attr.allocatable || (c->as && c->as->type != AS_DEFERRED)))
+    {
+      gfc_error ("Coarray component %qs at %L must be allocatable with "
+                 "deferred shape", c->name, &c->loc);
+      return false;
+    }
  
-  /* F2008, C432.  */
-  if (super_type && sym->attr.coarray_comp && !super_type->attr.coarray_comp)
+  /* F2008, C443.  */
+  if (c->attr.codimension && c->ts.type == BT_DERIVED
+      && c->ts.u.derived->ts.is_iso_c)
      {
-      gfc_error ("As extending type %qs at %L has a coarray component, "
-                "parent type %qs shall also have one", sym->name,
-                &sym->declared_at, super_type->name);
+      gfc_error ("Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) "
+                 "shall not be a coarray", c->name, &c->loc);
        return false;
      }
  
-  /* Ensure the extended type gets resolved before we do.  */
-  if (super_type && !resolve_fl_derived0 (super_type))
-    return false;
+  /* F2008, C444.  */
+  if (gfc_bt_struct (c->ts.type) && c->ts.u.derived->attr.coarray_comp
+      && (c->attr.codimension || c->attr.pointer || c->attr.dimension
+          || c->attr.allocatable))
+    {
+      gfc_error ("Component %qs at %L with coarray component "
+                 "shall be a nonpointer, nonallocatable scalar",
+                 c->name, &c->loc);
+      return false;
+    }
  
-  /* An ABSTRACT type must be extensible.  */
-  if (sym->attr.abstract && !gfc_type_is_extensible (sym))
+  /* F2008, C448.  */
+  if (c->attr.contiguous && (!c->attr.dimension || !c->attr.pointer))
      {
-      gfc_error ("Non-extensible derived-type %qs at %L must not be ABSTRACT",
-                sym->name, &sym->declared_at);
+      gfc_error ("Component %qs at %L has the CONTIGUOUS attribute but "
+                 "is not an array pointer", c->name, &c->loc);
        return false;
      }
  
-  c = (sym->attr.is_class) ? sym->components->ts.u.derived->components
-                          : sym->components;
+  if (c->attr.proc_pointer && c->ts.interface)
+    {
+      gfc_symbol *ifc = c->ts.interface;
  
-  bool success = true;
+      if (!sym->attr.vtype && !check_proc_interface (ifc, &c->loc))
+        {
+          c->tb->error = 1;
+          return false;
+        }
  
-  for ( ; c != NULL; c = c->next)
+      if (ifc->attr.if_source || ifc->attr.intrinsic)
+        {
+          /* Resolve interface and copy attributes.  */
+          if (ifc->formal && !ifc->formal_ns)
+            resolve_symbol (ifc);
+          if (ifc->attr.intrinsic)
+            gfc_resolve_intrinsic (ifc, &ifc->declared_at);
+
+          if (ifc->result)
+            {
+              c->ts = ifc->result->ts;
+              c->attr.allocatable = ifc->result->attr.allocatable;
+              c->attr.pointer = ifc->result->attr.pointer;
+              c->attr.dimension = ifc->result->attr.dimension;
+              c->as = gfc_copy_array_spec (ifc->result->as);
+              c->attr.class_ok = ifc->result->attr.class_ok;
+            }
+          else
+            {
+              c->ts = ifc->ts;
+              c->attr.allocatable = ifc->attr.allocatable;
+              c->attr.pointer = ifc->attr.pointer;
+              c->attr.dimension = ifc->attr.dimension;
+              c->as = gfc_copy_array_spec (ifc->as);
+              c->attr.class_ok = ifc->attr.class_ok;
+            }
+          c->ts.interface = ifc;
+          c->attr.function = ifc->attr.function;
+          c->attr.subroutine = ifc->attr.subroutine;
+
+          c->attr.pure = ifc->attr.pure;
+          c->attr.elemental = ifc->attr.elemental;
+          c->attr.recursive = ifc->attr.recursive;
+          c->attr.always_explicit = ifc->attr.always_explicit;
+          c->attr.ext_attr |= ifc->attr.ext_attr;
+          /* Copy char length.  */
+          if (ifc->ts.type == BT_CHARACTER && ifc->ts.u.cl)
+            {
+              gfc_charlen *cl = gfc_new_charlen (sym->ns, ifc->ts.u.cl);
+              if (cl->length && !cl->resolved
+                  && !gfc_resolve_expr (cl->length))
+                {
+                  c->tb->error = 1;
+                  return false;
+                }
+              c->ts.u.cl = cl;
+            }
+        }
+    }
+  else if (c->attr.proc_pointer && c->ts.type == BT_UNKNOWN)
      {
-      if (c->attr.artificial)
-       continue;
+      /* Since PPCs are not implicitly typed, a PPC without an explicit
+         interface must be a subroutine.  */
+      gfc_add_subroutine (&c->attr, c->name, &c->loc);
+    }
  
-      /* F2008, C442.  */
-      if ((!sym->attr.is_class || c != sym->components)
-         && c->attr.codimension
-         && (!c->attr.allocatable || (c->as && c->as->type != AS_DEFERRED)))
-       {
-         gfc_error ("Coarray component %qs at %L must be allocatable with "
-                    "deferred shape", c->name, &c->loc);
-         success = false;
-         continue;
-       }
+  /* Procedure pointer components: Check PASS arg.  */
+  if (c->attr.proc_pointer && !c->tb->nopass && c->tb->pass_arg_num == 0
+      && !sym->attr.vtype)
+    {
+      gfc_symbol* me_arg;
  
-      /* F2008, C443.  */
-      if (c->attr.codimension && c->ts.type == BT_DERIVED
-         && c->ts.u.derived->ts.is_iso_c)
-       {
-         gfc_error ("Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) "
-                    "shall not be a coarray", c->name, &c->loc);
-         success = false;
-         continue;
-       }
+      if (c->tb->pass_arg)
+        {
+          gfc_formal_arglist* i;
  
-      /* F2008, C444.  */
-      if (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.coarray_comp
-         && (c->attr.codimension || c->attr.pointer || c->attr.dimension
-             || c->attr.allocatable))
-       {
-         gfc_error ("Component %qs at %L with coarray component "
-                    "shall be a nonpointer, nonallocatable scalar",
-                    c->name, &c->loc);
-         success = false;
-         continue;
-       }
+          /* If an explicit passing argument name is given, walk the arg-list
+            and look for it.  */
  
-      /* F2008, C448.  */
-      if (c->attr.contiguous && (!c->attr.dimension || !c->attr.pointer))
-       {
-         gfc_error ("Component %qs at %L has the CONTIGUOUS attribute but "
-                    "is not an array pointer", c->name, &c->loc);
-         success = false;
-         continue;
-       }
+          me_arg = NULL;
+          c->tb->pass_arg_num = 1;
+          for (i = c->ts.interface->formal; i; i = i->next)
+            {
+              if (!strcmp (i->sym->name, c->tb->pass_arg))
+                {
+                  me_arg = i->sym;
+                  break;
+                }
+              c->tb->pass_arg_num++;
+            }
  
-      if (c->attr.proc_pointer && c->ts.interface)
-       {
-         gfc_symbol *ifc = c->ts.interface;
+          if (!me_arg)
+            {
+              gfc_error ("Procedure pointer component %qs with PASS(%s) "
+                         "at %L has no argument %qs", c->name,
+                         c->tb->pass_arg, &c->loc, c->tb->pass_arg);
+              c->tb->error = 1;
+              return false;
+            }
+        }
+      else
+        {
+          /* Otherwise, take the first one; there should in fact be at least
+            one.  */
+          c->tb->pass_arg_num = 1;
+          if (!c->ts.interface->formal)
+            {
+              gfc_error ("Procedure pointer component %qs with PASS at %L "
+                         "must have at least one argument",
+                         c->name, &c->loc);
+              c->tb->error = 1;
+              return false;
+            }
+          me_arg = c->ts.interface->formal->sym;
+        }
  
-         if (!sym->attr.vtype && !check_proc_interface (ifc, &c->loc))
-           {
-             c->tb->error = 1;
-             success = false;
-             continue;
-           }
+      /* Now check that the argument-type matches.  */
+      gcc_assert (me_arg);
+      if ((me_arg->ts.type != BT_DERIVED && me_arg->ts.type != BT_CLASS)
+          || (me_arg->ts.type == BT_DERIVED && me_arg->ts.u.derived != sym)
+          || (me_arg->ts.type == BT_CLASS
+              && CLASS_DATA (me_arg)->ts.u.derived != sym))
+        {
+          gfc_error ("Argument %qs of %qs with PASS(%s) at %L must be of"
+                     " the derived type %qs", me_arg->name, c->name,
+                     me_arg->name, &c->loc, sym->name);
+          c->tb->error = 1;
+          return false;
+        }
  
-         if (ifc->attr.if_source || ifc->attr.intrinsic)
-           {
-             /* Resolve interface and copy attributes.  */
-             if (ifc->formal && !ifc->formal_ns)
-               resolve_symbol (ifc);
-             if (ifc->attr.intrinsic)
-               gfc_resolve_intrinsic (ifc, &ifc->declared_at);
+      /* Check for C453.  */
+      if (me_arg->attr.dimension)
+        {
+          gfc_error ("Argument %qs of %qs with PASS(%s) at %L "
+                     "must be scalar", me_arg->name, c->name, me_arg->name,
+                     &c->loc);
+          c->tb->error = 1;
+          return false;
+        }
  
-             if (ifc->result)
-               {
-                 c->ts = ifc->result->ts;
-                 c->attr.allocatable = ifc->result->attr.allocatable;
-                 c->attr.pointer = ifc->result->attr.pointer;
-                 c->attr.dimension = ifc->result->attr.dimension;
-                 c->as = gfc_copy_array_spec (ifc->result->as);
-                 c->attr.class_ok = ifc->result->attr.class_ok;
-               }
-             else
-               {
-                 c->ts = ifc->ts;
-                 c->attr.allocatable = ifc->attr.allocatable;
-                 c->attr.pointer = ifc->attr.pointer;
-                 c->attr.dimension = ifc->attr.dimension;
-                 c->as = gfc_copy_array_spec (ifc->as);
-                 c->attr.class_ok = ifc->attr.class_ok;
-               }
-             c->ts.interface = ifc;
-             c->attr.function = ifc->attr.function;
-             c->attr.subroutine = ifc->attr.subroutine;
-
-             c->attr.pure = ifc->attr.pure;
-             c->attr.elemental = ifc->attr.elemental;
-             c->attr.recursive = ifc->attr.recursive;
-             c->attr.always_explicit = ifc->attr.always_explicit;
-             c->attr.ext_attr |= ifc->attr.ext_attr;
-             /* Copy char length.  */
-             if (ifc->ts.type == BT_CHARACTER && ifc->ts.u.cl)
-               {
-                 gfc_charlen *cl = gfc_new_charlen (sym->ns, ifc->ts.u.cl);
-                 if (cl->length && !cl->resolved
-                     && !gfc_resolve_expr (cl->length))
-                   {
-                     c->tb->error = 1;
-                     success = false;
-                     continue;
-                   }
-                 c->ts.u.cl = cl;
-               }
-           }
-       }
-      else if (c->attr.proc_pointer && c->ts.type == BT_UNKNOWN)
-       {
-         /* Since PPCs are not implicitly typed, a PPC without an explicit
-            interface must be a subroutine.  */
-         gfc_add_subroutine (&c->attr, c->name, &c->loc);
-       }
+      if (me_arg->attr.pointer)
+        {
+          gfc_error ("Argument %qs of %qs with PASS(%s) at %L "
+                     "may not have the POINTER attribute", me_arg->name,
+                     c->name, me_arg->name, &c->loc);
+          c->tb->error = 1;
+          return false;
+        }
  
-      /* Procedure pointer components: Check PASS arg.  */
-      if (c->attr.proc_pointer && !c->tb->nopass && c->tb->pass_arg_num == 0
-         && !sym->attr.vtype)
-       {
-         gfc_symbol* me_arg;
+      if (me_arg->attr.allocatable)
+        {
+          gfc_error ("Argument %qs of %qs with PASS(%s) at %L "
+                     "may not be ALLOCATABLE", me_arg->name, c->name,
+                     me_arg->name, &c->loc);
+          c->tb->error = 1;
+          return false;
+        }
  
-         if (c->tb->pass_arg)
-           {
-             gfc_formal_arglist* i;
+      if (gfc_type_is_extensible (sym) && me_arg->ts.type != BT_CLASS)
+        {
+          gfc_error ("Non-polymorphic passed-object dummy argument of %qs"
+                     " at %L", c->name, &c->loc);
+          return false;
+        }
  
-             /* If an explicit passing argument name is given, walk the arg-list
-               and look for it.  */
+    }
  
-             me_arg = NULL;
-             c->tb->pass_arg_num = 1;
-             for (i = c->ts.interface->formal; i; i = i->next)
-               {
-                 if (!strcmp (i->sym->name, c->tb->pass_arg))
-                   {
-                     me_arg = i->sym;
-                     break;
-                   }
-                 c->tb->pass_arg_num++;
-               }
+  /* Check type-spec if this is not the parent-type component.  */
+  if (((sym->attr.is_class
+        && (!sym->components->ts.u.derived->attr.extension
+            || c != sym->components->ts.u.derived->components))
+       || (!sym->attr.is_class
+           && (!sym->attr.extension || c != sym->components)))
+      && !sym->attr.vtype
+      && !resolve_typespec_used (&c->ts, &c->loc, c->name))
+    return false;
  
-             if (!me_arg)
-               {
-                 gfc_error ("Procedure pointer component %qs with PASS(%s) "
-                            "at %L has no argument %qs", c->name,
-                            c->tb->pass_arg, &c->loc, c->tb->pass_arg);
-                 c->tb->error = 1;
-                 success = false;
-                 continue;
-               }
-           }
-         else
-           {
-             /* Otherwise, take the first one; there should in fact be at least
-               one.  */
-             c->tb->pass_arg_num = 1;
-             if (!c->ts.interface->formal)
-               {
-                 gfc_error ("Procedure pointer component %qs with PASS at %L "
-                            "must have at least one argument",
-                            c->name, &c->loc);
-                 c->tb->error = 1;
-                 success = false;
-                 continue;
-               }
-             me_arg = c->ts.interface->formal->sym;
-           }
+  super_type = gfc_get_derived_super_type (sym);
  
-         /* Now check that the argument-type matches.  */
-         gcc_assert (me_arg);
-         if ((me_arg->ts.type != BT_DERIVED && me_arg->ts.type != BT_CLASS)
-             || (me_arg->ts.type == BT_DERIVED && me_arg->ts.u.derived != sym)
-             || (me_arg->ts.type == BT_CLASS
-                 && CLASS_DATA (me_arg)->ts.u.derived != sym))
-           {
-             gfc_error ("Argument %qs of %qs with PASS(%s) at %L must be of"
-                        " the derived type %qs", me_arg->name, c->name,
-                        me_arg->name, &c->loc, sym->name);
-             c->tb->error = 1;
-             success = false;
-             continue;
-           }
+  /* If this type is an extension, set the accessibility of the parent
+     component.  */
+  if (super_type
+      && ((sym->attr.is_class
+           && c == sym->components->ts.u.derived->components)
+          || (!sym->attr.is_class && c == sym->components))
+      && strcmp (super_type->name, c->name) == 0)
+    c->attr.access = super_type->attr.access;
+
+  /* If this type is an extension, see if this component has the same name
+     as an inherited type-bound procedure.  */
+  if (super_type && !sym->attr.is_class
+      && gfc_find_typebound_proc (super_type, NULL, c->name, true, NULL))
+    {
+      gfc_error ("Component %qs of %qs at %L has the same name as an"
+                 " inherited type-bound procedure",
+                 c->name, sym->name, &c->loc);
+      return false;
+    }
  
-         /* Check for C453.  */
-         if (me_arg->attr.dimension)
-           {
-             gfc_error ("Argument %qs of %qs with PASS(%s) at %L "
-                        "must be scalar", me_arg->name, c->name, me_arg->name,
-                        &c->loc);
-             c->tb->error = 1;
-             success = false;
-             continue;
-           }
+  if (c->ts.type == BT_CHARACTER && !c->attr.proc_pointer
+        && !c->ts.deferred)
+    {
+     if (c->ts.u.cl->length == NULL
+         || (!resolve_charlen(c->ts.u.cl))
+         || !gfc_is_constant_expr (c->ts.u.cl->length))
+       {
+         gfc_error ("Character length of component %qs needs to "
+                    "be a constant specification expression at %L",
+                    c->name,
+                    c->ts.u.cl->length ? &c->ts.u.cl->length->where : &c->loc);
+         return false;
+       }
+    }
  
-         if (me_arg->attr.pointer)
-           {
-             gfc_error ("Argument %qs of %qs with PASS(%s) at %L "
-                        "may not have the POINTER attribute", me_arg->name,
-                        c->name, me_arg->name, &c->loc);
-             c->tb->error = 1;
-             success = false;
-             continue;
-           }
+  if (c->ts.type == BT_CHARACTER && c->ts.deferred
+      && !c->attr.pointer && !c->attr.allocatable)
+    {
+      gfc_error ("Character component %qs of %qs at %L with deferred "
+                 "length must be a POINTER or ALLOCATABLE",
+                 c->name, sym->name, &c->loc);
+      return false;
+    }
  
-         if (me_arg->attr.allocatable)
-           {
-             gfc_error ("Argument %qs of %qs with PASS(%s) at %L "
-                        "may not be ALLOCATABLE", me_arg->name, c->name,
-                        me_arg->name, &c->loc);
-             c->tb->error = 1;
-             success = false;
-             continue;
-           }
+  /* Add the hidden deferred length field.  */
+  if (c->ts.type == BT_CHARACTER && c->ts.deferred && !c->attr.function
+      && !sym->attr.is_class)
+    {
+      char name[GFC_MAX_SYMBOL_LEN+9];
+      gfc_component *strlen;
+      sprintf (name, "_%s_length", c->name);
+      strlen = gfc_find_component (sym, name, true, true, NULL);
+      if (strlen == NULL)
+        {
+          if (!gfc_add_component (sym, name, &strlen))
+            return false;
+          strlen->ts.type = BT_INTEGER;
+          strlen->ts.kind = gfc_charlen_int_kind;
+          strlen->attr.access = ACCESS_PRIVATE;
+          strlen->attr.artificial = 1;
+        }
+    }
  
-         if (gfc_type_is_extensible (sym) && me_arg->ts.type != BT_CLASS)
-           {
-             gfc_error ("Non-polymorphic passed-object dummy argument of %qs"
-                        " at %L", c->name, &c->loc);
-             success = false;
-             continue;
-           }
+  if (c->ts.type == BT_DERIVED
+      && sym->component_access != ACCESS_PRIVATE
+      && gfc_check_symbol_access (sym)
+      && !is_sym_host_assoc (c->ts.u.derived, sym->ns)
+      && !c->ts.u.derived->attr.use_assoc
+      && !gfc_check_symbol_access (c->ts.u.derived)
+      && !gfc_notify_std (GFC_STD_F2003, "the component %qs is a "
+                          "PRIVATE type and cannot be a component of "
+                          "%qs, which is PUBLIC at %L", c->name,
+                          sym->name, &sym->declared_at))
+    return false;
  
-       }
+  if ((sym->attr.sequence || sym->attr.is_bind_c) && c->ts.type == BT_CLASS)
+    {
+      gfc_error ("Polymorphic component %s at %L in SEQUENCE or BIND(C) "
+                 "type %s", c->name, &c->loc, sym->name);
+      return false;
+    }
  
-      /* Check type-spec if this is not the parent-type component.  */
-      if (((sym->attr.is_class
-           && (!sym->components->ts.u.derived->attr.extension
-               || c != sym->components->ts.u.derived->components))
-          || (!sym->attr.is_class
-              && (!sym->attr.extension || c != sym->components)))
-         && !sym->attr.vtype
-         && !resolve_typespec_used (&c->ts, &c->loc, c->name))
-       return false;
+  if (sym->attr.sequence)
+    {
+      if (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.sequence == 0)
+        {
+          gfc_error ("Component %s of SEQUENCE type declared at %L does "
+                     "not have the SEQUENCE attribute",
+                     c->ts.u.derived->name, &sym->declared_at);
+          return false;
+        }
+    }
  
-      /* If this type is an extension, set the accessibility of the parent
-        component.  */
-      if (super_type
-         && ((sym->attr.is_class
-              && c == sym->components->ts.u.derived->components)
-             || (!sym->attr.is_class && c == sym->components))
-         && strcmp (super_type->name, c->name) == 0)
-       c->attr.access = super_type->attr.access;
-
-      /* If this type is an extension, see if this component has the same name
-        as an inherited type-bound procedure.  */
-      if (super_type && !sym->attr.is_class
-         && gfc_find_typebound_proc (super_type, NULL, c->name, true, NULL))
-       {
-         gfc_error ("Component %qs of %qs at %L has the same name as an"
-                    " inherited type-bound procedure",
-                    c->name, sym->name, &c->loc);
-         return false;
-       }
+  if (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.generic)
+    c->ts.u.derived = gfc_find_dt_in_generic (c->ts.u.derived);
+  else if (c->ts.type == BT_CLASS && c->attr.class_ok
+           && CLASS_DATA (c)->ts.u.derived->attr.generic)
+    CLASS_DATA (c)->ts.u.derived
+                    = gfc_find_dt_in_generic (CLASS_DATA (c)->ts.u.derived);
  
-      if (c->ts.type == BT_CHARACTER && !c->attr.proc_pointer
-           && !c->ts.deferred)
-       {
-        if (c->ts.u.cl->length == NULL
-            || (!resolve_charlen(c->ts.u.cl))
-            || !gfc_is_constant_expr (c->ts.u.cl->length))
-          {
-            gfc_error ("Character length of component %qs needs to "
-                       "be a constant specification expression at %L",
-                       c->name,
-                       c->ts.u.cl->length ? &c->ts.u.cl->length->where : &c->loc);
-            return false;
-          }
-       }
+  if (!sym->attr.is_class && c->ts.type == BT_DERIVED && !sym->attr.vtype
+      && c->attr.pointer && c->ts.u.derived->components == NULL
+      && !c->ts.u.derived->attr.zero_comp)
+    {
+      gfc_error ("The pointer component %qs of %qs at %L is a type "
+                 "that has not been declared", c->name, sym->name,
+                 &c->loc);
+      return false;
+    }
  
-      if (c->ts.type == BT_CHARACTER && c->ts.deferred
-         && !c->attr.pointer && !c->attr.allocatable)
-       {
-         gfc_error ("Character component %qs of %qs at %L with deferred "
-                    "length must be a POINTER or ALLOCATABLE",
-                    c->name, sym->name, &c->loc);
-         return false;
-       }
+  if (c->ts.type == BT_CLASS && c->attr.class_ok
+      && CLASS_DATA (c)->attr.class_pointer
+      && CLASS_DATA (c)->ts.u.derived->components == NULL
+      && !CLASS_DATA (c)->ts.u.derived->attr.zero_comp
+      && !UNLIMITED_POLY (c))
+    {
+      gfc_error ("The pointer component %qs of %qs at %L is a type "
+                 "that has not been declared", c->name, sym->name,
+                 &c->loc);
+      return false;
+    }
  
-      /* Add the hidden deferred length field.  */
-      if (c->ts.type == BT_CHARACTER && c->ts.deferred && !c->attr.function
-         && !sym->attr.is_class)
-       {
-         char name[GFC_MAX_SYMBOL_LEN+9];
-         gfc_component *strlen;
-         sprintf (name, "_%s_length", c->name);
-         strlen = gfc_find_component (sym, name, true, true);
-         if (strlen == NULL)
-           {
-             if (!gfc_add_component (sym, name, &strlen))
-               return false;
-             strlen->ts.type = BT_INTEGER;
-             strlen->ts.kind = gfc_charlen_int_kind;
-             strlen->attr.access = ACCESS_PRIVATE;
-             strlen->attr.artificial = 1;
-           }
-       }
+  /* C437.  */
+  if (c->ts.type == BT_CLASS && c->attr.flavor != FL_PROCEDURE
+      && (!c->attr.class_ok
+          || !(CLASS_DATA (c)->attr.class_pointer
+               || CLASS_DATA (c)->attr.allocatable)))
+    {
+      gfc_error ("Component %qs with CLASS at %L must be allocatable "
+                 "or pointer", c->name, &c->loc);
+      /* Prevent a recurrence of the error.  */
+      c->ts.type = BT_UNKNOWN;
+      return false;
+    }
  
-      if (c->ts.type == BT_DERIVED
-         && sym->component_access != ACCESS_PRIVATE
-         && gfc_check_symbol_access (sym)
-         && !is_sym_host_assoc (c->ts.u.derived, sym->ns)
-         && !c->ts.u.derived->attr.use_assoc
-         && !gfc_check_symbol_access (c->ts.u.derived)
-         && !gfc_notify_std (GFC_STD_F2003, "the component %qs is a "
-                             "PRIVATE type and cannot be a component of "
-                             "%qs, which is PUBLIC at %L", c->name,
-                             sym->name, &sym->declared_at))
-       return false;
+  /* Ensure that all the derived type components are put on the
+     derived type list; even in formal namespaces, where derived type
+     pointer components might not have been declared.  */
+  if (c->ts.type == BT_DERIVED
+        && c->ts.u.derived
+        && c->ts.u.derived->components
+        && c->attr.pointer
+        && sym != c->ts.u.derived)
+    add_dt_to_dt_list (c->ts.u.derived);
  
-      if ((sym->attr.sequence || sym->attr.is_bind_c) && c->ts.type == BT_CLASS)
-       {
-         gfc_error ("Polymorphic component %s at %L in SEQUENCE or BIND(C) "
-                    "type %s", c->name, &c->loc, sym->name);
-         return false;
-       }
+  if (!gfc_resolve_array_spec (c->as,
+                               !(c->attr.pointer || c->attr.proc_pointer
+                                 || c->attr.allocatable)))
+    return false;
  
-      if (sym->attr.sequence)
-       {
-         if (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.sequence == 0)
-           {
-             gfc_error ("Component %s of SEQUENCE type declared at %L does "
-                        "not have the SEQUENCE attribute",
-                        c->ts.u.derived->name, &sym->declared_at);
-             return false;
-           }
-       }
+  if (c->initializer && !sym->attr.vtype
+      && !gfc_check_assign_symbol (sym, c, c->initializer))
+    return false;
  
-      if (c->ts.type == BT_DERIVED && c->ts.u.derived->attr.generic)
-       c->ts.u.derived = gfc_find_dt_in_generic (c->ts.u.derived);
-      else if (c->ts.type == BT_CLASS && c->attr.class_ok
-              && CLASS_DATA (c)->ts.u.derived->attr.generic)
-       CLASS_DATA (c)->ts.u.derived
-                       = gfc_find_dt_in_generic (CLASS_DATA (c)->ts.u.derived);
+  return true;
+}
  
-      if (!sym->attr.is_class && c->ts.type == BT_DERIVED && !sym->attr.vtype
-         && c->attr.pointer && c->ts.u.derived->components == NULL
-         && !c->ts.u.derived->attr.zero_comp)
-       {
-         gfc_error ("The pointer component %qs of %qs at %L is a type "
-                    "that has not been declared", c->name, sym->name,
-                    &c->loc);
-         return false;
-       }
  
-      if (c->ts.type == BT_CLASS && c->attr.class_ok
-         && CLASS_DATA (c)->attr.class_pointer
-         && CLASS_DATA (c)->ts.u.derived->components == NULL
-         && !CLASS_DATA (c)->ts.u.derived->attr.zero_comp
-         && !UNLIMITED_POLY (c))
-       {
-         gfc_error ("The pointer component %qs of %qs at %L is a type "
-                    "that has not been declared", c->name, sym->name,
-                    &c->loc);
-         return false;
-       }
+/* Be nice about the locus for a structure expression - show the locus of the
+   first non-null sub-expression if we can.  */
  
-      /* C437.  */
-      if (c->ts.type == BT_CLASS && c->attr.flavor != FL_PROCEDURE
-         && (!c->attr.class_ok
-             || !(CLASS_DATA (c)->attr.class_pointer
-                  || CLASS_DATA (c)->attr.allocatable)))
-       {
-         gfc_error ("Component %qs with CLASS at %L must be allocatable "
-                    "or pointer", c->name, &c->loc);
-         /* Prevent a recurrence of the error.  */
-         c->ts.type = BT_UNKNOWN;
-         return false;
-       }
+static locus *
+cons_where (gfc_expr *struct_expr)
+{
+  gfc_constructor *cons;
  
-      /* Ensure that all the derived type components are put on the
-        derived type list; even in formal namespaces, where derived type
-        pointer components might not have been declared.  */
-      if (c->ts.type == BT_DERIVED
-           && c->ts.u.derived
-           && c->ts.u.derived->components
-           && c->attr.pointer
-           && sym != c->ts.u.derived)
-       add_dt_to_dt_list (c->ts.u.derived);
+  gcc_assert (struct_expr && struct_expr->expr_type == EXPR_STRUCTURE);
  
-      if (!gfc_resolve_array_spec (c->as,
-                                  !(c->attr.pointer || c->attr.proc_pointer
-                                    || c->attr.allocatable)))
-       return false;
+  cons = gfc_constructor_first (struct_expr->value.constructor);
+  for (; cons; cons = gfc_constructor_next (cons))
+    {
+      if (cons->expr && cons->expr->expr_type != EXPR_NULL)
+        return &cons->expr->where;
+    }
  
-      if (c->initializer && !sym->attr.vtype
-         && !gfc_check_assign_symbol (sym, c, c->initializer))
-       return false;
+  return &struct_expr->where;
+}
+
+/* Resolve the components of a structure type. Much less work than derived
+   types.  */
+
+static bool
+resolve_fl_struct (gfc_symbol *sym)
+{
+  gfc_component *c;
+  gfc_expr *init = NULL;
+  bool success;
+
+  /* Make sure UNIONs do not have overlapping initializers.  */
+  if (sym->attr.flavor == FL_UNION)
+    {
+      for (c = sym->components; c; c = c->next)
+        {
+          if (init && c->initializer)
+            {
+              gfc_error ("Conflicting initializers in union at %L and %L",
+                         cons_where (init), cons_where (c->initializer));
+              gfc_free_expr (c->initializer);
+              c->initializer = NULL;
+            }
+          if (init == NULL)
+            init = c->initializer;
+        }
      }
  
+  success = true;
+  for (c = sym->components; c; c = c->next)
+    if (!resolve_component (c, sym))
+      success = false;
+
+  if (!success)
+    return false;
+
+  if (sym->components)
+    add_dt_to_dt_list (sym);
+
+  return true;
+}
+
+
+/* Resolve the components of a derived type. This does not have to wait until
+   resolution stage, but can be done as soon as the dt declaration has been
+   parsed.  */
+
+static bool
+resolve_fl_derived0 (gfc_symbol *sym)
+{
+  gfc_symbol* super_type;
+  gfc_component *c;
+  bool success;
+
+  if (sym->attr.unlimited_polymorphic)
+    return true;
+
+  super_type = gfc_get_derived_super_type (sym);
+
+  /* F2008, C432.  */
+  if (super_type && sym->attr.coarray_comp && !super_type->attr.coarray_comp)
+    {
+      gfc_error ("As extending type %qs at %L has a coarray component, "
+                "parent type %qs shall also have one", sym->name,
+                &sym->declared_at, super_type->name);
+      return false;
+    }
+
+  /* Ensure the extended type gets resolved before we do.  */
+  if (super_type && !resolve_fl_derived0 (super_type))
+    return false;
+
+  /* An ABSTRACT type must be extensible.  */
+  if (sym->attr.abstract && !gfc_type_is_extensible (sym))
+    {
+      gfc_error ("Non-extensible derived-type %qs at %L must not be ABSTRACT",
+                sym->name, &sym->declared_at);
+      return false;
+    }
+
+  c = (sym->attr.is_class) ? sym->components->ts.u.derived->components
+                          : sym->components;
+
+  success = true;
+  for ( ; c != NULL; c = c->next)
+    if (!resolve_component (c, sym))
+      success = false;
+
    if (!success)
      return false;
  
@@ -13396,8 +13466,8 @@ resolve_fl_derived (gfc_symbol *sym)
    if (sym->attr.is_class && sym->ts.u.derived == NULL)
      {
        /* Fix up incomplete CLASS symbols.  */
-      gfc_component *data = gfc_find_component (sym, "_data", true, true);
-      gfc_component *vptr = gfc_find_component (sym, "_vptr", true, true);
+      gfc_component *data = gfc_find_component (sym, "_data", true, true, NULL);
+      gfc_component *vptr = gfc_find_component (sym, "_vptr", true, true, NULL);
  
        /* Nothing more to do for unlimited polymorphic entities.  */
        if (data->ts.u.derived->attr.unlimited_polymorphic)
@@ -13616,6 +13686,11 @@ resolve_symbol (gfc_symbol *sym)
      return;
    sym->resolved = 1;
  
+  /* No symbol will ever have union type; only components can be unions.
+     Union type declaration symbols have type BT_UNKNOWN but flavor FL_UNION
+     (just like derived type declaration symbols have flavor FL_DERIVED). */
+  gcc_assert (sym->ts.type != BT_UNION);
+
    if (sym->attr.artificial)
      return;
  
@@ -13687,6 +13762,10 @@ resolve_symbol (gfc_symbol *sym)
    if (sym->attr.flavor == FL_DERIVED && !resolve_fl_derived (sym))
      return;
  
+  else if ((sym->attr.flavor == FL_STRUCT || sym->attr.flavor == FL_UNION)
+           && !resolve_fl_struct (sym))
+    return;
+
    /* Symbols that are module procedures with results (functions) have
       the types and array specification copied for type checking in
       procedures that call them, as well as for saving to a module
@@ -15030,7 +15109,7 @@ resolve_equivalence_derived (gfc_symbol *derived, gfc_symbol *sym, gfc_expr *e)
  
    for (; c ; c = c->next)
      {
-      if (c->ts.type == BT_DERIVED
+      if (gfc_bt_struct (c->ts.type)
           && (!resolve_equivalence_derived(c->ts.u.derived, sym, e)))
         return false;
  
diff --git a/gcc/fortran/scanner.c b/gcc/fortran/scanner.c

index f4dedd6..6a7a5b6 100644 (file)
--- a/gcc/fortran/scanner.c
+++ b/gcc/fortran/scanner.c
@@ -1556,6 +1556,7 @@ restart:
  not_continuation:
    c = '\n';
    gfc_current_locus = old_loc;
+  end_flag = 0;
  
  done:
    if (c == '\n')
diff --git a/gcc/fortran/symbol.c b/gcc/fortran/symbol.c

index 8efd12c..0ee7dec 100644 (file)
--- a/gcc/fortran/symbol.c
+++ b/gcc/fortran/symbol.c
@@ -40,6 +40,7 @@ const mstring flavors[] =
    minit ("VARIABLE", FL_VARIABLE), minit ("PARAMETER", FL_PARAMETER),
    minit ("LABEL", FL_LABEL), minit ("PROCEDURE", FL_PROCEDURE),
    minit ("DERIVED", FL_DERIVED), minit ("NAMELIST", FL_NAMELIST),
+  minit ("UNION", FL_UNION), minit ("STRUCTURE", FL_STRUCT),
    minit (NULL, -1)
  };
  
@@ -444,7 +445,7 @@ check_conflict (symbol_attribute *attr, const char *name, locus *where)
           case FL_BLOCK_DATA:
           case FL_MODULE:
           case FL_LABEL:
-         case FL_DERIVED:
+         case_fl_struct:
           case FL_PARAMETER:
              a1 = gfc_code2string (flavors, attr->flavor);
              a2 = save;
@@ -740,7 +741,7 @@ check_conflict (symbol_attribute *attr, const char *name, locus *where)
  
        break;
  
-    case FL_DERIVED:
+    case_fl_struct:
        conf2 (dummy);
        conf2 (pointer);
        conf2 (target);
@@ -1579,7 +1580,7 @@ gfc_add_flavor (symbol_attribute *attr, sym_flavor f, const char *name,
  {
  
    if ((f == FL_PROGRAM || f == FL_BLOCK_DATA || f == FL_MODULE
-       || f == FL_PARAMETER || f == FL_LABEL || f == FL_DERIVED
+       || f == FL_PARAMETER || f == FL_LABEL || gfc_fl_struct(f)
         || f == FL_NAMELIST) && check_used (attr, name, where))
      return false;
  
@@ -2048,6 +2049,11 @@ gfc_add_component (gfc_symbol *sym, const char *name,
  {
    gfc_component *p, *tail;
  
+  /* Check for existing components with the same name, but not for union
+     components or containers. Unions and maps are anonymous so they have
+     unique internal names which will never conflict.
+     Don't use gfc_find_component here because it calls gfc_use_derived,
+     but the derived type may not be fully defined yet. */
    tail = NULL;
  
    for (p = sym->components; p; p = p->next)
@@ -2063,7 +2069,8 @@ gfc_add_component (gfc_symbol *sym, const char *name,
      }
  
    if (sym->attr.extension
-       && gfc_find_component (sym->components->ts.u.derived, name, true, true))
+       && gfc_find_component (sym->components->ts.u.derived,
+                               name, true, true, NULL))
      {
        gfc_error ("Component %qs at %C already in the parent type "
                  "at %L", name, &sym->components->ts.u.derived->declared_at);
@@ -2154,7 +2161,7 @@ gfc_use_derived (gfc_symbol *sym)
        return NULL;
      }
  
-  if (s == NULL || s->attr.flavor != FL_DERIVED)
+  if (s == NULL || !gfc_fl_struct (s->attr.flavor))
      goto bad;
  
    /* Get rid of symbol sym, translating all references to s.  */
@@ -2188,28 +2195,113 @@ bad:
  }
  
  
+/* Find the component with the given name in the union type symbol.
+   If ref is not NULL it will be set to the chain of components through which
+   the component can actually be accessed. This is necessary for unions because
+   intermediate structures may be maps, nested structures, or other unions,
+   all of which may (or must) be 'anonymous' to user code.  */
+
+static gfc_component *
+find_union_component (gfc_symbol *un, const char *name,
+                      bool noaccess, gfc_ref **ref)
+{
+  gfc_component *m, *check;
+  gfc_ref *sref, *tmp;
+
+  for (m = un->components; m; m = m->next)
+    {
+      check = gfc_find_component (m->ts.u.derived, name, noaccess, true, &tmp);
+      if (check == NULL)
+        continue;
+
+      /* Found component somewhere in m; chain the refs together.  */
+      if (ref)
+        {
+          /* Map ref. */
+          sref = gfc_get_ref ();
+          sref->type = REF_COMPONENT;
+          sref->u.c.component = m;
+          sref->u.c.sym = m->ts.u.derived;
+          sref->next = tmp;
+
+          *ref = sref;
+        }
+      /* Other checks (such as access) were done in the recursive calls.  */
+      return check;
+    }
+  return NULL;
+}
+
+
  /* Given a derived type node and a component name, try to locate the
     component structure.  Returns the NULL pointer if the component is
     not found or the components are private.  If noaccess is set, no access
-   checks are done.  */
+   checks are done.  If silent is set, an error will not be generated if
+   the component cannot be found or accessed.
+   
+   If ref is not NULL, *ref is set to represent the chain of components
+   required to get to the ultimate component.
+
+   If the component is simply a direct subcomponent, or is inherited from a
+   parent derived type in the given derived type, this is a single ref with its
+   component set to the returned component.
+
+   Otherwise, *ref is constructed as a chain of subcomponents. This occurs
+   when the component is found through an implicit chain of nested union and
+   map components. Unions and maps are "anonymous" substructures in FORTRAN
+   which cannot be explicitly referenced, but the reference chain must be
+   considered as in C for backend translation to correctly compute layouts.
+   (For example, x.a may refer to x->(UNION)->(MAP)->(UNION)->(MAP)->a).  */
  
  gfc_component *
  gfc_find_component (gfc_symbol *sym, const char *name,
-                   bool noaccess, bool silent)
+                   bool noaccess, bool silent, gfc_ref **ref)
  {
-  gfc_component *p;
+  gfc_component *p, *check;
+  gfc_ref *sref = NULL, *tmp = NULL;
  
    if (name == NULL || sym == NULL)
      return NULL;
  
-  sym = gfc_use_derived (sym);
+  if (sym->attr.flavor == FL_DERIVED)
+    sym = gfc_use_derived (sym);
+  else
+    gcc_assert (gfc_fl_struct (sym->attr.flavor));
  
    if (sym == NULL)
      return NULL;
  
+  /* Handle UNIONs specially - mutually recursive with gfc_find_component. */
+  if (sym->attr.flavor == FL_UNION)
+    return find_union_component (sym, name, noaccess, ref);
+
+  if (ref) *ref = NULL;
    for (p = sym->components; p; p = p->next)
-    if (strcmp (p->name, name) == 0)
-      break;
+    {
+      /* Nest search into union's maps. */
+      if (p->ts.type == BT_UNION)
+        {
+          check = find_union_component (p->ts.u.derived, name, noaccess, &tmp);
+          if (check != NULL)
+            {
+              /* Union ref. */
+              if (ref)
+                {
+                  sref = gfc_get_ref ();
+                  sref->type = REF_COMPONENT;
+                  sref->u.c.component = p;
+                  sref->u.c.sym = p->ts.u.derived;
+                  sref->next = tmp;
+                  *ref = sref;
+                }
+              return check;
+            }
+        }
+      else if (strcmp (p->name, name) == 0)
+        break;
+
+      continue;
+    }
  
    if (p && sym->attr.use_assoc && !noaccess)
      {
@@ -2231,7 +2323,7 @@ gfc_find_component (gfc_symbol *sym, const char *name,
         && sym->components->ts.type == BT_DERIVED)
      {
        p = gfc_find_component (sym->components->ts.u.derived, name,
-                             noaccess, silent);
+                             noaccess, silent, ref);
        /* Do not overwrite the error.  */
        if (p == NULL)
         return p;
@@ -2241,6 +2333,25 @@ gfc_find_component (gfc_symbol *sym, const char *name,
      gfc_error ("%qs at %C is not a member of the %qs structure",
                name, sym->name);
  
+  /* Component was found; build the ultimate component reference. */
+  if (p != NULL && ref)
+    {
+      tmp = gfc_get_ref ();
+      tmp->type = REF_COMPONENT;
+      tmp->u.c.component = p;
+      tmp->u.c.sym = sym;
+      /* Link the final component ref to the end of the chain of subrefs. */
+      if (sref)
+        {
+          *ref = sref;
+          for (; sref->next; sref = sref->next)
+            ;
+          sref->next = tmp;
+        }
+      else
+        *ref = tmp;
+    }
+
    return p;
  }
  
@@ -3338,11 +3449,9 @@ gfc_restore_last_undo_checkpoint (void)
           /* The derived type is saved in the symtree with the first
              letter capitalized; the all lower-case version to the
              derived type contains its associated generic function.  */
-         if (p->attr.flavor == FL_DERIVED)
-           gfc_delete_symtree (&p->ns->sym_root, gfc_get_string ("%c%s",
-                        (char) TOUPPER ((unsigned char) p->name[0]),
-                        &p->name[1]));
-         else
+         if (gfc_fl_struct (p->attr.flavor))
+           gfc_delete_symtree (&p->ns->sym_root,gfc_dt_upper_string (p->name));
+          else
             gfc_delete_symtree (&p->ns->sym_root, p->name);
  
           gfc_release_symbol (p);
@@ -4526,10 +4635,7 @@ generate_isocbinding_symbol (const char *mod_name, iso_c_binding_symbol s,
               const char *hidden_name;
               gfc_interface *intr, *head;
  
-             hidden_name = gfc_get_string ("%c%s",
-                                           (char) TOUPPER ((unsigned char)
-                                                             tmp_sym->name[0]),
-                                           &tmp_sym->name[1]);
+             hidden_name = gfc_dt_upper_string (tmp_sym->name);
               tmp_symtree = gfc_find_symtree (gfc_current_ns->sym_root,
                                               hidden_name);
               gcc_assert (tmp_symtree == NULL);
@@ -4740,6 +4846,8 @@ gfc_type_compatible (gfc_typespec *ts1, gfc_typespec *ts2)
    bool is_class2 = (ts2->type == BT_CLASS);
    bool is_derived1 = (ts1->type == BT_DERIVED);
    bool is_derived2 = (ts2->type == BT_DERIVED);
+  bool is_union1 = (ts1->type == BT_UNION);
+  bool is_union2 = (ts2->type == BT_UNION);
  
    if (is_class1
        && ts1->u.derived->components
@@ -4749,10 +4857,11 @@ gfc_type_compatible (gfc_typespec *ts1, gfc_typespec *ts2)
           || ts1->u.derived->attr.unlimited_polymorphic))
      return 1;
  
-  if (!is_derived1 && !is_derived2 && !is_class1 && !is_class2)
+  if (!is_derived1 && !is_derived2 && !is_class1 && !is_class2
+      && !is_union1 && !is_union2)
      return (ts1->type == ts2->type);
  
-  if (is_derived1 && is_derived2)
+  if ((is_derived1 && is_derived2) || (is_union1 && is_union1))
      return gfc_compare_derived_types (ts1->u.derived, ts2->u.derived);
  
    if (is_derived1 && is_class2)
@@ -4821,12 +4930,12 @@ gfc_find_dt_in_generic (gfc_symbol *sym)
  {
    gfc_interface *intr = NULL;
  
-  if (!sym || sym->attr.flavor == FL_DERIVED)
+  if (!sym || gfc_fl_struct (sym->attr.flavor))
      return sym;
  
    if (sym->attr.generic)
      for (intr = sym->generic; intr; intr = intr->next)
-      if (intr->sym->attr.flavor == FL_DERIVED)
+      if (gfc_fl_struct (intr->sym->attr.flavor))
          break;
    return intr ? intr->sym : NULL;
  }
diff --git a/gcc/fortran/trans-array.c b/gcc/fortran/trans-array.c

index 825dfb8..6a642ac 100644 (file)
--- a/gcc/fortran/trans-array.c
+++ b/gcc/fortran/trans-array.c
@@ -6376,7 +6376,12 @@ gfc_trans_dummy_array_bias (gfc_symbol * sym, tree tmpdesc,
        stmtCleanup = gfc_finish_block (&cleanup);
  
        /* Only do the cleanup if the array was repacked.  */
-      tmp = build_fold_indirect_ref_loc (input_location, dumdesc);
+      if (is_classarray)
+       /* For a class array the dummy array descriptor is in the _class
+          component.  */
+       tmp = gfc_class_data_get (dumdesc);
+      else
+       tmp = build_fold_indirect_ref_loc (input_location, dumdesc);
        tmp = gfc_conv_descriptor_data_get (tmp);
        tmp = fold_build2_loc (input_location, NE_EXPR, boolean_type_node,
                              tmp, tmpdesc);
diff --git a/gcc/fortran/trans-decl.c b/gcc/fortran/trans-decl.c

index 309baf1..d4ea6c8 100644 (file)
--- a/gcc/fortran/trans-decl.c
+++ b/gcc/fortran/trans-decl.c
@@ -732,6 +732,7 @@ gfc_get_module_backend_decl (gfc_symbol *sym)
        st = NULL;
        s = NULL;
  
+      /* Check for a symbol with the same name. */
        if (gsym)
         gfc_find_symbol (sym->name, gsym->ns, 0, &s);
  
@@ -748,22 +749,37 @@ gfc_get_module_backend_decl (gfc_symbol *sym)
           st->n.sym = sym;
           sym->refs++;
         }
-      else if (sym->attr.flavor == FL_DERIVED)
+      else if (gfc_fl_struct (sym->attr.flavor))
         {
           if (s && s->attr.flavor == FL_PROCEDURE)
             {
               gfc_interface *intr;
               gcc_assert (s->attr.generic);
               for (intr = s->generic; intr; intr = intr->next)
-               if (intr->sym->attr.flavor == FL_DERIVED)
+               if (gfc_fl_struct (intr->sym->attr.flavor))
                   {
                     s = intr->sym;
                     break;
                   }
             }
  
-         if (!s->backend_decl)
-           s->backend_decl = gfc_get_derived_type (s);
+          /* Normally we can assume that s is a derived-type symbol since it
+             shares a name with the derived-type sym. However if sym is a
+             STRUCTURE, it may in fact share a name with any other basic type
+             variable. If s is in fact of derived type then we can continue
+             looking for a duplicate type declaration.  */
+          if (sym->attr.flavor == FL_STRUCT && s->ts.type == BT_DERIVED)
+            {
+              s = s->ts.u.derived;
+            }
+
+         if (gfc_fl_struct (s->attr.flavor) && !s->backend_decl)
+            {
+              if (s->attr.flavor == FL_UNION)
+                s->backend_decl = gfc_get_union_type (s);
+              else
+                s->backend_decl = gfc_get_derived_type (s);
+            }
           gfc_copy_dt_decls_ifequal (s, sym, true);
           return true;
         }
@@ -2384,7 +2400,7 @@ create_function_arglist (gfc_symbol * sym)
          Thus, we will use a hidden argument in that case.  */
        else if (f->sym->attr.optional && f->sym->attr.value
                && !f->sym->attr.dimension && f->sym->ts.type != BT_CLASS
-              && f->sym->ts.type != BT_DERIVED)
+              && !gfc_bt_struct (f->sym->ts.type))
         {
            tree tmp;
            strcpy (&name[1], f->sym->name);
@@ -4596,7 +4612,7 @@ gfc_create_module_variable (gfc_symbol * sym)
        && sym->ts.type == BT_DERIVED)
      sym->backend_decl = gfc_typenode_for_spec (&(sym->ts));
  
-  if (sym->attr.flavor == FL_DERIVED
+  if (gfc_fl_struct (sym->attr.flavor)
        && sym->backend_decl
        && TREE_CODE (sym->backend_decl) == RECORD_TYPE)
      {
@@ -4839,7 +4855,7 @@ check_constant_initializer (gfc_expr *expr, gfc_typespec *ts, bool array,
      }
    else switch (ts->type)
      {
-    case BT_DERIVED:
+    case_bt_struct:
        if (expr->expr_type != EXPR_STRUCTURE)
         return false;
        cm = expr->ts.u.derived->components;
diff --git a/gcc/fortran/trans-expr.c b/gcc/fortran/trans-expr.c

index 8d039a6..8f84712 100644 (file)
--- a/gcc/fortran/trans-expr.c
+++ b/gcc/fortran/trans-expr.c
@@ -2297,6 +2297,7 @@ gfc_conv_component_ref (gfc_se * se, gfc_ref * ref)
    tree tmp;
    tree decl;
    tree field;
+  tree context;
  
    c = ref->u.c.component;
  
@@ -2307,15 +2308,20 @@ gfc_conv_component_ref (gfc_se * se, gfc_ref * ref)
    field = c->backend_decl;
    gcc_assert (field && TREE_CODE (field) == FIELD_DECL);
    decl = se->expr;
+  context = DECL_FIELD_CONTEXT (field);
  
    /* Components can correspond to fields of different containing
       types, as components are created without context, whereas
       a concrete use of a component has the type of decl as context.
       So, if the type doesn't match, we search the corresponding
       FIELD_DECL in the parent type.  To not waste too much time
-     we cache this result in norestrict_decl.  */
+     we cache this result in norestrict_decl.
+     On the other hand, if the context is a UNION or a MAP (a
+     RECORD_TYPE within a UNION_TYPE) always use the given FIELD_DECL.  */
  
-  if (DECL_FIELD_CONTEXT (field) != TREE_TYPE (decl))
+  if (context != TREE_TYPE (decl) 
+      && !(   TREE_CODE (TREE_TYPE (field)) == UNION_TYPE /* Field is union */
+           || TREE_CODE (context) == UNION_TYPE))         /* Field is map */
      {
        tree f2 = c->norestrict_decl;
        if (!f2 || DECL_FIELD_CONTEXT (f2) != TREE_TYPE (decl))
@@ -6715,7 +6721,7 @@ gfc_conv_initializer (gfc_expr * expr, gfc_typespec * ts, tree type,
      {
        switch (ts->type)
         {
-       case BT_DERIVED:
+       case_bt_struct:
         case BT_CLASS:
           gfc_init_se (&se, NULL);
           if (ts->type == BT_CLASS && expr->expr_type == EXPR_NULL)
@@ -6860,7 +6866,7 @@ gfc_trans_alloc_subarray_assign (tree dest, gfc_component * cm,
    gfc_add_modify (&block, dest, se.expr);
  
    /* Deal with arrays of derived types with allocatable components.  */
-  if (cm->ts.type == BT_DERIVED
+  if (gfc_bt_struct (cm->ts.type)
         && cm->ts.u.derived->attr.alloc_comp)
      tmp = gfc_copy_alloc_comp (cm->ts.u.derived,
                                se.expr, dest,
@@ -7033,7 +7039,7 @@ alloc_scalar_allocatable_for_subcomponent_assignment (stmtblock_t *block,
        /* Ensure that cm->ts.u.cl->backend_decl is a componentref to _%s_length
          component.  */
        sprintf (name, "_%s_length", cm->name);
-      strlen = gfc_find_component (sym, name, true, true);
+      strlen = gfc_find_component (sym, name, true, true, NULL);
        lhs_cl_size = fold_build3_loc (input_location, COMPONENT_REF,
                                      gfc_charlen_type_node,
                                      TREE_OPERAND (comp, 0),
@@ -7245,7 +7251,7 @@ gfc_trans_subcomponent_assign (tree dest, gfc_component * cm, gfc_expr * expr,
                         fold_convert (TREE_TYPE (tmp), se.expr));
        gfc_add_block_to_block (&block, &se.post);
      }
-  else if (expr->ts.type == BT_DERIVED && expr->ts.f90_type != BT_VOID)
+  else if (gfc_bt_struct (expr->ts.type) && expr->ts.f90_type != BT_VOID)
      {
        if (expr->expr_type != EXPR_STRUCTURE)
         {
@@ -7416,6 +7422,24 @@ gfc_conv_structure (gfc_se * se, gfc_expr * expr, int init)
        return;
      }
  
+  /* Though unions appear to have multiple map components, they must only
+     have a single initializer since each map overlaps. TODO: squash map
+     constructors?  */
+  if (expr->ts.type == BT_UNION)
+    {
+      c = gfc_constructor_first (expr->value.constructor);
+      cm = c->n.component;
+      val = gfc_conv_initializer (c->expr, &expr->ts,
+                                  TREE_TYPE (cm->backend_decl),
+                                  cm->attr.dimension, cm->attr.pointer,
+                                  cm->attr.proc_pointer);
+      val = unshare_expr_without_location (val);
+
+      /* Append it to the constructor list.  */
+      CONSTRUCTOR_APPEND_ELT (v, cm->backend_decl, val);
+      goto finish;
+    }
+
    cm = expr->ts.u.derived->components;
  
    for (c = gfc_constructor_first (expr->value.constructor);
@@ -7462,6 +7486,7 @@ gfc_conv_structure (gfc_se * se, gfc_expr * expr, int init)
           CONSTRUCTOR_APPEND_ELT (v, cm->backend_decl, val);
         }
      }
+finish:
    se->expr = build_constructor (type, v);
    if (init)
      TREE_CONSTANT (se->expr) = 1;
@@ -8246,7 +8271,7 @@ gfc_trans_scalar_assign (gfc_se * lse, gfc_se * rse, gfc_typespec ts,
        gfc_trans_string_copy (&block, llen, lse->expr, ts.kind, rlen,
                              rse->expr, ts.kind);
      }
-  else if (ts.type == BT_DERIVED && ts.u.derived->attr.alloc_comp)
+  else if (gfc_bt_struct (ts.type) && ts.u.derived->attr.alloc_comp)
      {
        tree tmp_var = NULL_TREE;
        cond = NULL_TREE;
@@ -8299,7 +8324,7 @@ gfc_trans_scalar_assign (gfc_se * lse, gfc_se * rse, gfc_typespec ts,
           gfc_add_expr_to_block (&block, tmp);
         }
      }
-  else if (ts.type == BT_DERIVED || ts.type == BT_CLASS)
+  else if (gfc_bt_struct (ts.type) || ts.type == BT_CLASS)
      {
        gfc_add_block_to_block (&block, &lse->pre);
        gfc_add_block_to_block (&block, &rse->pre);
@@ -9503,7 +9528,7 @@ copyable_array_p (gfc_expr * expr)
      case BT_CHARACTER:
        return false;
  
-    case BT_DERIVED:
+    case_bt_struct:
        return !expr->ts.u.derived->attr.alloc_comp;
  
      default:
diff --git a/gcc/fortran/trans-io.c b/gcc/fortran/trans-io.c

index 23080f0..125f45c 100644 (file)
--- a/gcc/fortran/trans-io.c
+++ b/gcc/fortran/trans-io.c
@@ -1685,7 +1685,7 @@ transfer_namelist_element (stmtblock_t * block, const char * var_name,
        gfc_add_expr_to_block (block, tmp);
      }
  
-  if (ts->type == BT_DERIVED && ts->u.derived->components)
+  if (gfc_bt_struct (ts->type) && ts->u.derived->components)
      {
        gfc_component *cmp;
  
@@ -2211,7 +2211,7 @@ transfer_expr (gfc_se * se, gfc_typespec * ts, tree addr_expr, gfc_code * code)
  
        break;
  
-    case BT_DERIVED:
+    case_bt_struct:
        if (ts->u.derived->components == NULL)
         return;
  
@@ -2330,7 +2330,7 @@ gfc_trans_transfer (gfc_code * code)
           gcc_assert (ref && ref->type == REF_ARRAY);
         }
  
-      if (expr->ts.type != BT_DERIVED
+      if (!gfc_bt_struct (expr->ts.type)
             && ref && ref->next == NULL
             && !is_subref_array (expr))
         {
diff --git a/gcc/fortran/trans-stmt.c b/gcc/fortran/trans-stmt.c

index 2fc43ed..7d3cf8c 100644 (file)
--- a/gcc/fortran/trans-stmt.c
+++ b/gcc/fortran/trans-stmt.c
@@ -6275,7 +6275,7 @@ gfc_trans_deallocate (gfc_code *code)
         {
           gfc_ref *ref;
  
-         if (expr->ts.type == BT_DERIVED && expr->ts.u.derived->attr.alloc_comp
+         if (gfc_bt_struct (expr->ts.type) && expr->ts.u.derived->attr.alloc_comp
               && !gfc_is_finalizable (expr->ts.u.derived, NULL))
             {
               gfc_ref *last = NULL;
diff --git a/gcc/fortran/trans-types.c b/gcc/fortran/trans-types.c

index a71cf0b..831c84f 100644 (file)
--- a/gcc/fortran/trans-types.c
+++ b/gcc/fortran/trans-types.c
@@ -1101,6 +1101,10 @@ gfc_typenode_for_spec (gfc_typespec * spec)
                                              gfc_index_one_node);
        break;
  
+    case BT_UNION:
+      basetype = gfc_get_union_type (spec->u.derived);
+      break;
+
      case BT_DERIVED:
      case BT_CLASS:
        basetype = gfc_get_derived_type (spec->u.derived);
@@ -2314,7 +2318,9 @@ gfc_copy_dt_decls_ifequal (gfc_symbol *from, gfc_symbol *to,
    for (; to_cm; to_cm = to_cm->next, from_cm = from_cm->next)
      {
        to_cm->backend_decl = from_cm->backend_decl;
-      if (from_cm->ts.type == BT_DERIVED
+      if (from_cm->ts.type == BT_UNION)
+        gfc_get_union_type (to_cm->ts.u.derived);
+      else if (from_cm->ts.type == BT_DERIVED
           && (!from_cm->attr.pointer || from_gsym))
         gfc_get_derived_type (to_cm->ts.u.derived);
        else if (from_cm->ts.type == BT_CLASS
@@ -2349,6 +2355,62 @@ gfc_get_ppc_type (gfc_component* c)
  }
  
  
+/* Build a tree node for a union type. Requires building each map
+   structure which is an element of the union. */
+
+tree
+gfc_get_union_type (gfc_symbol *un)
+{
+    gfc_component *map = NULL;
+    tree typenode = NULL, map_type = NULL, map_field = NULL;
+    tree *chain = NULL;
+
+    if (un->backend_decl)
+      {
+        if (TYPE_FIELDS (un->backend_decl) || un->attr.proc_pointer_comp)
+          return un->backend_decl;
+        else
+          typenode = un->backend_decl;
+      }
+    else
+      {
+        typenode = make_node (UNION_TYPE);
+        TYPE_NAME (typenode) = get_identifier (un->name);
+      }
+
+    /* Add each contained MAP as a field. */
+    for (map = un->components; map; map = map->next)
+      {
+        gcc_assert (map->ts.type == BT_DERIVED);
+
+        /* The map's type node, which is defined within this union's context. */
+        map_type = gfc_get_derived_type (map->ts.u.derived);
+        TYPE_CONTEXT (map_type) = typenode;
+
+        /* The map field's declaration. */
+        map_field = gfc_add_field_to_struct(typenode, get_identifier(map->name),
+                                            map_type, &chain);
+        if (map->loc.lb)
+          gfc_set_decl_location (map_field, &map->loc);
+        else if (un->declared_at.lb)
+          gfc_set_decl_location (map_field, &un->declared_at);
+
+        DECL_PACKED (map_field) |= TYPE_PACKED (typenode);
+        DECL_NAMELESS(map_field) = true;
+
+        /* We should never clobber another backend declaration for this map,
+           because each map component is unique. */
+        if (!map->backend_decl)
+          map->backend_decl = map_field;
+      }
+
+    un->backend_decl = typenode;
+    gfc_finish_type (typenode);
+
+    return typenode;
+}
+
+
  /* Build a tree node for a derived type.  If there are equal
     derived types, with different local names, these are built
     at the same time.  If an equal derived type has been built
@@ -2491,6 +2553,9 @@ gfc_get_derived_type (gfc_symbol * derived)
       will be built and so we can return the type.  */
    for (c = derived->components; c; c = c->next)
      {
+      if (c->ts.type == BT_UNION && c->ts.u.derived->backend_decl == NULL)
+        c->ts.u.derived->backend_decl = gfc_get_union_type (c->ts.u.derived);
+
        if (c->ts.type != BT_DERIVED && c->ts.type != BT_CLASS)
         continue;
  
@@ -2520,7 +2585,10 @@ gfc_get_derived_type (gfc_symbol * derived)
      return derived->backend_decl;
  
    /* Build the type member list. Install the newly created RECORD_TYPE
-     node as DECL_CONTEXT of each FIELD_DECL.  */
+     node as DECL_CONTEXT of each FIELD_DECL. In this case we must go
+     through only the top-level linked list of components so we correctly
+     build UNION_TYPE nodes for BT_UNION components. MAPs and other nested
+     types are built as part of gfc_get_union_type.  */
    for (c = derived->components; c; c = c->next)
      {
        /* Prevent infinite recursion, when the procedure pointer type is
diff --git a/gcc/gimple-fold.c b/gcc/gimple-fold.c

index eb130d0..fa98f2c 100644 (file)
--- a/gcc/gimple-fold.c
+++ b/gcc/gimple-fold.c
@@ -3039,10 +3039,25 @@ gimple_fold_call (gimple_stmt_iterator *gsi, bool inplace)
                 }
               if (targets.length () == 1)
                 {
-                 gimple_call_set_fndecl (stmt, targets[0]->decl);
+                 tree fndecl = targets[0]->decl;
+                 gimple_call_set_fndecl (stmt, fndecl);
                   changed = true;
+                 /* If changing the call to __cxa_pure_virtual
+                    or similar noreturn function, adjust gimple_call_fntype
+                    too.  */
+                 if ((gimple_call_flags (stmt) & ECF_NORETURN)
+                     && VOID_TYPE_P (TREE_TYPE (TREE_TYPE (fndecl)))
+                     && TYPE_ARG_TYPES (TREE_TYPE (fndecl))
+                     && (TREE_VALUE (TYPE_ARG_TYPES (TREE_TYPE (fndecl)))
+                         == void_type_node))
+                   gimple_call_set_fntype (stmt, TREE_TYPE (fndecl));
                   /* If the call becomes noreturn, remove the lhs.  */
-                 if (lhs && (gimple_call_flags (stmt) & ECF_NORETURN))
+                 if (lhs
+                     && (gimple_call_flags (stmt) & ECF_NORETURN)
+                     && (VOID_TYPE_P (TREE_TYPE (gimple_call_fntype (stmt)))
+                         || ((TREE_CODE (TYPE_SIZE_UNIT (TREE_TYPE (lhs)))
+                              == INTEGER_CST)
+                             && !TREE_ADDRESSABLE (TREE_TYPE (lhs)))))
                     {
                       if (TREE_CODE (lhs) == SSA_NAME)
                         {
diff --git a/gcc/gimple.c b/gcc/gimple.c

index b0e19d5..b06e62c 100644 (file)
--- a/gcc/gimple.c
+++ b/gcc/gimple.c
@@ -1355,7 +1355,8 @@ gimple_call_same_target_p (const gimple *c1, const gimple *c2)
    if (gimple_call_internal_p (c1))
      return (gimple_call_internal_p (c2)
             && gimple_call_internal_fn (c1) == gimple_call_internal_fn (c2)
-           && !gimple_call_internal_unique_p (as_a <const gcall *> (c1)));
+           && (!gimple_call_internal_unique_p (as_a <const gcall *> (c1))
+               || c1 == c2));
    else
      return (gimple_call_fn (c1) == gimple_call_fn (c2)
             || (gimple_call_fndecl (c1)
diff --git a/gcc/gimplify.c b/gcc/gimplify.c

index e223e59..846a75a 100644 (file)
--- a/gcc/gimplify.c
+++ b/gcc/gimplify.c
@@ -8224,7 +8224,13 @@ gimplify_adjust_omp_clauses (gimple_seq *pre_p, gimple_seq body, tree *list_p,
         case OMP_CLAUSE_VECTOR:
         case OMP_CLAUSE_AUTO:
         case OMP_CLAUSE_SEQ:
+         break;
+
         case OMP_CLAUSE_TILE:
+         /* We're not yet making use of the information provided by OpenACC
+            tile clauses.  Discard these here, to simplify later middle end
+            processing.  */
+         remove = true;
           break;
  
         default:
@@ -8952,7 +8958,12 @@ gimplify_omp_for (tree *expr_p, gimple_seq *pre_p)
                || (ort == ORT_SIMD
                    && TREE_VEC_LENGTH (OMP_FOR_INIT (for_stmt)) > 1))
         {
+         struct gimplify_omp_ctx *ctx = gimplify_omp_ctxp;
+         /* Make sure omp_add_variable is not called on it prematurely.
+            We call it ourselves a few lines later.  */
+         gimplify_omp_ctxp = NULL;
           var = create_tmp_var (TREE_TYPE (decl), get_name (decl));
+         gimplify_omp_ctxp = ctx;
           TREE_OPERAND (t, 0) = var;
  
           gimplify_seq_add_stmt (&for_body, gimple_build_assign (decl, var));
diff --git a/gcc/graphite-isl-ast-to-gimple.c b/gcc/graphite-isl-ast-to-gimple.c

index 049a4c5..fb9c846 100644 (file)
--- a/gcc/graphite-isl-ast-to-gimple.c
+++ b/gcc/graphite-isl-ast-to-gimple.c
@@ -1075,9 +1075,7 @@ bb_contains_loop_close_phi_nodes (basic_block bb)
  static bool
  bb_contains_loop_phi_nodes (basic_block bb)
  {
-  gcc_assert (EDGE_COUNT (bb->preds) <= 2);
-
-  if (bb->preds->length () == 1)
+  if (EDGE_COUNT (bb->preds) != 2)
      return false;
  
    unsigned depth = loop_depth (bb->loop_father);
@@ -1792,7 +1790,6 @@ get_def_bb_for_const (basic_block bb, basic_block old_bb) const
         b1 = b2;
      }
  
-  gcc_assert (b1);
    return b1;
  }
  
@@ -2481,13 +2478,14 @@ copy_cond_phi_nodes (basic_block bb, basic_block new_bb, vec<tree> iv_map)
  
    gcc_assert (!bb_contains_loop_close_phi_nodes (bb));
  
+  /* TODO: Handle cond phi nodes with more than 2 predecessors.  */
+  if (EDGE_COUNT (bb->preds) != 2)
+    return false;
+
    if (dump_file)
      fprintf (dump_file, "[codegen] copying cond phi nodes in bb_%d.\n",
              new_bb->index);
  
-  /* Cond phi nodes should have exactly two arguments.  */
-  gcc_assert (2 == EDGE_COUNT (bb->preds));
-
    for (gphi_iterator psi = gsi_start_phis (bb); !gsi_end_p (psi);
         gsi_next (&psi))
      {
diff --git a/gcc/hsa-gen.c b/gcc/hsa-gen.c

index 5baf607..cf7d434 100644 (file)
--- a/gcc/hsa-gen.c
+++ b/gcc/hsa-gen.c
@@ -203,9 +203,13 @@ hsa_symbol::fillup_for_decl (tree decl)
  {
    m_decl = decl;
    m_type = hsa_type_for_tree_type (TREE_TYPE (decl), &m_dim, false);
-
    if (hsa_seen_error ())
-    m_seen_error = true;
+    {
+      m_seen_error = true;
+      return;
+    }
+
+  m_align = MAX (m_align, hsa_natural_alignment (m_type));
  }
  
  /* Constructor of class representing global HSA function/kernel information and
@@ -929,6 +933,14 @@ get_symbol_for_decl (tree decl)
                                 BRIG_LINKAGE_PROGRAM, true,
                                 BRIG_ALLOCATION_PROGRAM, align);
           hsa_cfun->m_global_symbols.safe_push (sym);
+         sym->fillup_for_decl (decl);
+         if (sym->m_align > align)
+           {
+             sym->m_seen_error = true;
+             HSA_SORRY_ATV (EXPR_LOCATION (decl),
+                            "HSA specification requires that %E is at least "
+                            "naturally aligned", decl);
+           }
         }
        else
         {
@@ -944,12 +956,11 @@ get_symbol_for_decl (tree decl)
           sym = new hsa_symbol (BRIG_TYPE_NONE, BRIG_SEGMENT_PRIVATE,
                                 BRIG_LINKAGE_FUNCTION);
           sym->m_align = align;
+         sym->fillup_for_decl (decl);
           hsa_cfun->m_private_variables.safe_push (sym);
         }
  
-      sym->fillup_for_decl (decl);
        sym->m_name = hsa_get_declaration_name (decl);
-
        *slot = sym;
        return sym;
      }
@@ -3471,6 +3482,12 @@ gen_hsa_insns_for_switch_stmt (gswitch *s, hsa_bb *hbb)
    basic_block default_label_bb = label_to_block_fn (func,
                                                     CASE_LABEL (default_label));
  
+  if (!gimple_seq_empty_p (phi_nodes (default_label_bb)))
+    {
+      default_label_bb = split_edge (find_edge (e->dest, default_label_bb));
+      hsa_init_new_bb (default_label_bb);
+    }
+
    make_edge (e->src, default_label_bb, EDGE_FALSE_VALUE);
  
    hsa_cfun->m_modified_cfg = true;
diff --git a/gcc/ipa-icf.c b/gcc/ipa-icf.c

index dda5cac..3c04b5a 100644 (file)
--- a/gcc/ipa-icf.c
+++ b/gcc/ipa-icf.c
@@ -2258,6 +2258,8 @@ sem_variable::merge (sem_item *alias_item)
  
        varpool_node::create_alias (alias_var->decl, decl);
        alias->resolve_alias (original);
+      if (DECL_PT_UID_SET_P (original->decl))
+       SET_DECL_PT_UID (alias->decl, DECL_PT_UID (original->decl));
  
        if (dump_file)
         fprintf (dump_file, "Unified; Variable alias has been created.\n\n");
diff --git a/gcc/ipa-inline-analysis.c b/gcc/ipa-inline-analysis.c

index f8ca825..824e5a9 100644 (file)
--- a/gcc/ipa-inline-analysis.c
+++ b/gcc/ipa-inline-analysis.c
@@ -216,13 +216,14 @@ struct agg_position_info
    bool by_ref;
  };
  
-/* Add condition to condition list CONDS.  AGGPOS describes whether the used
-   oprand is loaded from an aggregate and where in the aggregate it is.  It can
-   be NULL, which means this not a load from an aggregate.  */
+/* Add condition to condition list SUMMARY. OPERAND_NUM, SIZE, CODE and VAL
+   correspond to fields of condition structure.  AGGPOS describes whether the
+   used operand is loaded from an aggregate and where in the aggregate it is.
+   It can be NULL, which means this not a load from an aggregate.  */
  
  static struct predicate
  add_condition (struct inline_summary *summary, int operand_num,
-              struct agg_position_info *aggpos,
+              HOST_WIDE_INT size, struct agg_position_info *aggpos,
                enum tree_code code, tree val)
  {
    int i;
@@ -248,6 +249,7 @@ add_condition (struct inline_summary *summary, int operand_num,
    for (i = 0; vec_safe_iterate (summary->conds, i, &c); i++)
      {
        if (c->operand_num == operand_num
+         && c->size == size
           && c->code == code
           && c->val == val
           && c->agg_contents == agg_contents
@@ -264,6 +266,7 @@ add_condition (struct inline_summary *summary, int operand_num,
    new_cond.agg_contents = agg_contents;
    new_cond.by_ref = by_ref;
    new_cond.offset = offset;
+  new_cond.size = size;
    vec_safe_push (summary->conds, new_cond);
    return single_cond_predicate (i + predicate_first_dynamic_condition);
  }
@@ -867,21 +870,25 @@ evaluate_conditions_for_known_args (struct cgraph_node *node,
           clause |= 1 << (i + predicate_first_dynamic_condition);
           continue;
         }
-      if (c->code == IS_NOT_CONSTANT || c->code == CHANGED)
+      if (c->code == CHANGED)
         continue;
  
-      if (operand_equal_p (TYPE_SIZE (TREE_TYPE (c->val)),
-                          TYPE_SIZE (TREE_TYPE (val)), 0))
+      if (tree_to_shwi (TYPE_SIZE (TREE_TYPE (val))) != c->size)
         {
-         val = fold_unary (VIEW_CONVERT_EXPR, TREE_TYPE (c->val), val);
+         clause |= 1 << (i + predicate_first_dynamic_condition);
+         continue;
+       }
+      if (c->code == IS_NOT_CONSTANT)
+       continue;
  
-         res = val
-           ? fold_binary_to_constant (c->code, boolean_type_node, val, c->val)
-           : NULL;
+      val = fold_unary (VIEW_CONVERT_EXPR, TREE_TYPE (c->val), val);
+      res = val
+       ? fold_binary_to_constant (c->code, boolean_type_node, val, c->val)
+       : NULL;
+
+      if (res && integer_zerop (res))
+       continue;
  
-         if (res && integer_zerop (res))
-           continue;
-       }
        clause |= 1 << (i + predicate_first_dynamic_condition);
      }
    return clause;
@@ -1515,16 +1522,21 @@ mark_modified (ao_ref *ao ATTRIBUTE_UNUSED, tree vdef ATTRIBUTE_UNUSED,
  }
  
  /* If OP refers to value of function parameter, return the corresponding
-   parameter.  */
+   parameter.  If non-NULL, the size of the memory load (or the SSA_NAME of the
+   PARM_DECL) will be stored to *SIZE_P in that case too.  */
  
  static tree
-unmodified_parm_1 (gimple *stmt, tree op)
+unmodified_parm_1 (gimple *stmt, tree op, HOST_WIDE_INT *size_p)
  {
    /* SSA_NAME referring to parm default def?  */
    if (TREE_CODE (op) == SSA_NAME
        && SSA_NAME_IS_DEFAULT_DEF (op)
        && TREE_CODE (SSA_NAME_VAR (op)) == PARM_DECL)
-    return SSA_NAME_VAR (op);
+    {
+      if (size_p)
+       *size_p = tree_to_shwi (TYPE_SIZE (TREE_TYPE (op)));
+      return SSA_NAME_VAR (op);
+    }
    /* Non-SSA parm reference?  */
    if (TREE_CODE (op) == PARM_DECL)
      {
@@ -1535,18 +1547,24 @@ unmodified_parm_1 (gimple *stmt, tree op)
        walk_aliased_vdefs (&refd, gimple_vuse (stmt), mark_modified, &modified,
                           NULL);
        if (!modified)
-       return op;
+       {
+         if (size_p)
+           *size_p = tree_to_shwi (TYPE_SIZE (TREE_TYPE (op)));
+         return op;
+       }
      }
    return NULL_TREE;
  }
  
  /* If OP refers to value of function parameter, return the corresponding
-   parameter.  Also traverse chains of SSA register assignments.  */
+   parameter.  Also traverse chains of SSA register assignments.  If non-NULL,
+   the size of the memory load (or the SSA_NAME of the PARM_DECL) will be
+   stored to *SIZE_P in that case too.  */
  
  static tree
-unmodified_parm (gimple *stmt, tree op)
+unmodified_parm (gimple *stmt, tree op, HOST_WIDE_INT *size_p)
  {
-  tree res = unmodified_parm_1 (stmt, op);
+  tree res = unmodified_parm_1 (stmt, op, size_p);
    if (res)
      return res;
  
@@ -1554,23 +1572,25 @@ unmodified_parm (gimple *stmt, tree op)
        && !SSA_NAME_IS_DEFAULT_DEF (op)
        && gimple_assign_single_p (SSA_NAME_DEF_STMT (op)))
      return unmodified_parm (SSA_NAME_DEF_STMT (op),
-                           gimple_assign_rhs1 (SSA_NAME_DEF_STMT (op)));
+                           gimple_assign_rhs1 (SSA_NAME_DEF_STMT (op)),
+                           size_p);
    return NULL_TREE;
  }
  
  /* If OP refers to a value of a function parameter or value loaded from an
     aggregate passed to a parameter (either by value or reference), return TRUE
-   and store the number of the parameter to *INDEX_P and information whether
-   and how it has been loaded from an aggregate into *AGGPOS.  INFO describes
-   the function parameters, STMT is the statement in which OP is used or
-   loaded.  */
+   and store the number of the parameter to *INDEX_P, the access size into
+   *SIZE_P, and information whether and how it has been loaded from an
+   aggregate into *AGGPOS.  INFO describes the function parameters, STMT is the
+   statement in which OP is used or loaded.  */
  
  static bool
  unmodified_parm_or_parm_agg_item (struct ipa_func_body_info *fbi,
                                   gimple *stmt, tree op, int *index_p,
+                                 HOST_WIDE_INT *size_p,
                                   struct agg_position_info *aggpos)
  {
-  tree res = unmodified_parm_1 (stmt, op);
+  tree res = unmodified_parm_1 (stmt, op, size_p);
  
    gcc_checking_assert (aggpos);
    if (res)
@@ -1591,14 +1611,14 @@ unmodified_parm_or_parm_agg_item (struct ipa_func_body_info *fbi,
        stmt = SSA_NAME_DEF_STMT (op);
        op = gimple_assign_rhs1 (stmt);
        if (!REFERENCE_CLASS_P (op))
-       return unmodified_parm_or_parm_agg_item (fbi, stmt, op, index_p,
+       return unmodified_parm_or_parm_agg_item (fbi, stmt, op, index_p, size_p,
                                                  aggpos);
      }
  
    aggpos->agg_contents = true;
    return ipa_load_from_parm_agg (fbi, fbi->info->descriptors,
                                  stmt, op, index_p, &aggpos->offset,
-                                NULL, &aggpos->by_ref);
+                                size_p, &aggpos->by_ref);
  }
  
  /* See if statement might disappear after inlining.
@@ -1649,7 +1669,7 @@ eliminated_by_inlining_prob (gimple *stmt)
             inner_lhs = lhs;
  
           /* Reads of parameter are expected to be free.  */
-         if (unmodified_parm (stmt, inner_rhs))
+         if (unmodified_parm (stmt, inner_rhs, NULL))
             rhs_free = true;
           /* Match expressions of form &this->field. Those will most likely
              combine with something upstream after inlining.  */
@@ -1659,7 +1679,7 @@ eliminated_by_inlining_prob (gimple *stmt)
               if (TREE_CODE (op) == PARM_DECL)
                 rhs_free = true;
               else if (TREE_CODE (op) == MEM_REF
-                      && unmodified_parm (stmt, TREE_OPERAND (op, 0)))
+                      && unmodified_parm (stmt, TREE_OPERAND (op, 0), NULL))
                 rhs_free = true;
             }
  
@@ -1672,7 +1692,7 @@ eliminated_by_inlining_prob (gimple *stmt)
           /* Reads of parameters passed by reference
              expected to be free (i.e. optimized out after inlining).  */
           if (TREE_CODE (inner_rhs) == MEM_REF
-             && unmodified_parm (stmt, TREE_OPERAND (inner_rhs, 0)))
+             && unmodified_parm (stmt, TREE_OPERAND (inner_rhs, 0), NULL))
             rhs_free = true;
  
           /* Copying parameter passed by reference into gimple register is
@@ -1713,7 +1733,7 @@ eliminated_by_inlining_prob (gimple *stmt)
           if (TREE_CODE (inner_lhs) == PARM_DECL
               || TREE_CODE (inner_lhs) == RESULT_DECL
               || (TREE_CODE (inner_lhs) == MEM_REF
-                 && (unmodified_parm (stmt, TREE_OPERAND (inner_lhs, 0))
+                 && (unmodified_parm (stmt, TREE_OPERAND (inner_lhs, 0), NULL)
                       || (TREE_CODE (TREE_OPERAND (inner_lhs, 0)) == SSA_NAME
                           && SSA_NAME_VAR (TREE_OPERAND (inner_lhs, 0))
                           && TREE_CODE (SSA_NAME_VAR (TREE_OPERAND
@@ -1744,6 +1764,7 @@ set_cond_stmt_execution_predicate (struct ipa_func_body_info *fbi,
    gimple *last;
    tree op;
    int index;
+  HOST_WIDE_INT size;
    struct agg_position_info aggpos;
    enum tree_code code, inverted_code;
    edge e;
@@ -1760,7 +1781,7 @@ set_cond_stmt_execution_predicate (struct ipa_func_body_info *fbi,
    /* TODO: handle conditionals like
       var = op0 < 4;
       if (var != 0).  */
-  if (unmodified_parm_or_parm_agg_item (fbi, last, op, &index, &aggpos))
+  if (unmodified_parm_or_parm_agg_item (fbi, last, op, &index, &size, &aggpos))
      {
        code = gimple_cond_code (last);
        inverted_code = invert_tree_comparison (code, HONOR_NANS (op));
@@ -1774,9 +1795,10 @@ set_cond_stmt_execution_predicate (struct ipa_func_body_info *fbi,
              unordered one.  Be sure it is not confused with NON_CONSTANT.  */
           if (this_code != ERROR_MARK)
             {
-             struct predicate p = add_condition
-                (summary, index, &aggpos, this_code,
-                 unshare_expr_without_location (gimple_cond_rhs (last)));
+             struct predicate p
+               = add_condition (summary, index, size, &aggpos, this_code,
+                                unshare_expr_without_location
+                                (gimple_cond_rhs (last)));
               e->aux = edge_predicate_pool.allocate ();
               *(struct predicate *) e->aux = p;
             }
@@ -1803,11 +1825,12 @@ set_cond_stmt_execution_predicate (struct ipa_func_body_info *fbi,
        || gimple_call_num_args (set_stmt) != 1)
      return;
    op2 = gimple_call_arg (set_stmt, 0);
-  if (!unmodified_parm_or_parm_agg_item (fbi, set_stmt, op2, &index, &aggpos))
+  if (!unmodified_parm_or_parm_agg_item (fbi, set_stmt, op2, &index, &size,
+                                        &aggpos))
      return;
    FOR_EACH_EDGE (e, ei, bb->succs) if (e->flags & EDGE_FALSE_VALUE)
      {
-      struct predicate p = add_condition (summary, index, &aggpos,
+      struct predicate p = add_condition (summary, index, size, &aggpos,
                                           IS_NOT_CONSTANT, NULL_TREE);
        e->aux = edge_predicate_pool.allocate ();
        *(struct predicate *) e->aux = p;
@@ -1826,6 +1849,7 @@ set_switch_stmt_execution_predicate (struct ipa_func_body_info *fbi,
    gimple *lastg;
    tree op;
    int index;
+  HOST_WIDE_INT size;
    struct agg_position_info aggpos;
    edge e;
    edge_iterator ei;
@@ -1837,7 +1861,7 @@ set_switch_stmt_execution_predicate (struct ipa_func_body_info *fbi,
      return;
    gswitch *last = as_a <gswitch *> (lastg);
    op = gimple_switch_index (last);
-  if (!unmodified_parm_or_parm_agg_item (fbi, last, op, &index, &aggpos))
+  if (!unmodified_parm_or_parm_agg_item (fbi, last, op, &index, &size, &aggpos))
      return;
  
    FOR_EACH_EDGE (e, ei, bb->succs)
@@ -1862,14 +1886,14 @@ set_switch_stmt_execution_predicate (struct ipa_func_body_info *fbi,
        if (!min && !max)
         p = true_predicate ();
        else if (!max)
-       p = add_condition (summary, index, &aggpos, EQ_EXPR,
+       p = add_condition (summary, index, size, &aggpos, EQ_EXPR,
                            unshare_expr_without_location (min));
        else
         {
           struct predicate p1, p2;
-         p1 = add_condition (summary, index, &aggpos, GE_EXPR,
+         p1 = add_condition (summary, index, size, &aggpos, GE_EXPR,
                               unshare_expr_without_location (min));
-         p2 = add_condition (summary, index, &aggpos, LE_EXPR,
+         p2 = add_condition (summary, index, size, &aggpos, LE_EXPR,
                               unshare_expr_without_location (max));
           p = and_predicates (summary->conds, &p1, &p2);
         }
@@ -1970,13 +1994,14 @@ will_be_nonconstant_expr_predicate (struct ipa_node_params *info,
  {
    tree parm;
    int index;
+  HOST_WIDE_INT size;
  
    while (UNARY_CLASS_P (expr))
      expr = TREE_OPERAND (expr, 0);
  
-  parm = unmodified_parm (NULL, expr);
+  parm = unmodified_parm (NULL, expr, &size);
    if (parm && (index = ipa_get_param_decl_index (info, parm)) >= 0)
-    return add_condition (summary, index, NULL, CHANGED, NULL_TREE);
+    return add_condition (summary, index, size, NULL, CHANGED, NULL_TREE);
    if (is_gimple_min_invariant (expr))
      return false_predicate ();
    if (TREE_CODE (expr) == SSA_NAME)
@@ -2037,6 +2062,7 @@ will_be_nonconstant_predicate (struct ipa_func_body_info *fbi,
    struct predicate op_non_const;
    bool is_load;
    int base_index;
+  HOST_WIDE_INT size;
    struct agg_position_info aggpos;
  
    /* What statments might be optimized away
@@ -2060,7 +2086,7 @@ will_be_nonconstant_predicate (struct ipa_func_body_info *fbi,
        tree op;
        gcc_assert (gimple_assign_single_p (stmt));
        op = gimple_assign_rhs1 (stmt);
-      if (!unmodified_parm_or_parm_agg_item (fbi, stmt, op, &base_index,
+      if (!unmodified_parm_or_parm_agg_item (fbi, stmt, op, &base_index, &size,
                                              &aggpos))
         return p;
      }
@@ -2071,7 +2097,7 @@ will_be_nonconstant_predicate (struct ipa_func_body_info *fbi,
       adding conditionals.  */
    FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
      {
-      tree parm = unmodified_parm (stmt, use);
+      tree parm = unmodified_parm (stmt, use, NULL);
        /* For arguments we can build a condition.  */
        if (parm && ipa_get_param_decl_index (fbi->info, parm) >= 0)
         continue;
@@ -2086,18 +2112,19 @@ will_be_nonconstant_predicate (struct ipa_func_body_info *fbi,
  
    if (is_load)
      op_non_const =
-      add_condition (summary, base_index, &aggpos, CHANGED, NULL);
+      add_condition (summary, base_index, size, &aggpos, CHANGED, NULL);
    else
      op_non_const = false_predicate ();
    FOR_EACH_SSA_TREE_OPERAND (use, stmt, iter, SSA_OP_USE)
      {
-      tree parm = unmodified_parm (stmt, use);
+      HOST_WIDE_INT size;
+      tree parm = unmodified_parm (stmt, use, &size);
        int index;
  
        if (parm && (index = ipa_get_param_decl_index (fbi->info, parm)) >= 0)
         {
           if (index != base_index)
-           p = add_condition (summary, index, NULL, CHANGED, NULL_TREE);
+           p = add_condition (summary, index, size, NULL, CHANGED, NULL_TREE);
           else
             continue;
         }
@@ -3377,7 +3404,8 @@ remap_predicate (struct inline_summary *info,
                     ap.by_ref = c->by_ref;
                     cond_predicate = add_condition (info,
                                                     operand_map[c->operand_num],
-                                                   &ap, c->code, c->val);
+                                                   c->size, &ap, c->code,
+                                                   c->val);
                   }
               }
             /* Fixed conditions remains same, construct single
@@ -4236,6 +4264,7 @@ inline_read_section (struct lto_file_decl_data *file_data, const char *data,
         {
           struct condition c;
           c.operand_num = streamer_read_uhwi (&ib);
+         c.size = streamer_read_uhwi (&ib);
           c.code = (enum tree_code) streamer_read_uhwi (&ib);
           c.val = stream_read_tree (&ib, data_in);
           bp = streamer_read_bitpack (&ib);
@@ -4400,6 +4429,7 @@ inline_write_summary (void)
           for (i = 0; vec_safe_iterate (info->conds, i, &c); i++)
             {
               streamer_write_uhwi (ob, c->operand_num);
+             streamer_write_uhwi (ob, c->size);
               streamer_write_uhwi (ob, c->code);
               stream_write_tree (ob, c->val, true);
               bp = bitpack_create (ob->main_stream);
diff --git a/gcc/ipa-inline.h b/gcc/ipa-inline.h

index 4bf0024..91ecf3c 100644 (file)
--- a/gcc/ipa-inline.h
+++ b/gcc/ipa-inline.h
@@ -34,6 +34,8 @@ struct GTY(()) condition
    /* If agg_contents is set, this is the offset from which the used data was
       loaded.  */
    HOST_WIDE_INT offset;
+  /* Size of the access reading the data (or the PARM_DECL SSA_NAME).  */
+  HOST_WIDE_INT size;
    tree val;
    int operand_num;
    ENUM_BITFIELD(tree_code) code : 16;
diff --git a/gcc/ipa-prop.c b/gcc/ipa-prop.c

index 65482ba..f02ec47 100644 (file)
--- a/gcc/ipa-prop.c
+++ b/gcc/ipa-prop.c
@@ -1414,6 +1414,9 @@ determine_locally_known_aggregate_parts (gcall *call, tree arg,
    bool check_ref, by_ref;
    ao_ref r;
  
+  if (PARAM_VALUE (PARAM_IPA_MAX_AGG_ITEMS) == 0)
+    return;
+
    /* The function operates in three stages.  First, we prepare check_ref, r,
       arg_base and arg_offset based on what is actually passed as an actual
       argument.  */
diff --git a/gcc/lto-streamer.h b/gcc/lto-streamer.h

index f391161..7374b4e 100644 (file)
--- a/gcc/lto-streamer.h
+++ b/gcc/lto-streamer.h
@@ -129,7 +129,7 @@ along with GCC; see the file COPYING3.  If not see
       form followed by the data for the string.  */
  
  #define LTO_major_version 5
-#define LTO_minor_version 0
+#define LTO_minor_version 1
  
  typedef unsigned char  lto_decl_flags_t;
  
diff --git a/gcc/omp-low.c b/gcc/omp-low.c

index 7282cc8..5f1e6aa 100644 (file)
--- a/gcc/omp-low.c
+++ b/gcc/omp-low.c
@@ -2186,7 +2186,6 @@ scan_sharing_clauses (tree clauses, omp_context *ctx,
         case OMP_CLAUSE_GANG:
         case OMP_CLAUSE_WORKER:
         case OMP_CLAUSE_VECTOR:
-       case OMP_CLAUSE_TILE:
         case OMP_CLAUSE_INDEPENDENT:
         case OMP_CLAUSE_AUTO:
         case OMP_CLAUSE_SEQ:
@@ -2200,10 +2199,8 @@ scan_sharing_clauses (tree clauses, omp_context *ctx,
           break;
  
         case OMP_CLAUSE_DEVICE_RESIDENT:
+       case OMP_CLAUSE_TILE:
         case OMP_CLAUSE__CACHE_:
-         sorry ("Clause not supported yet");
-         break;
-
         default:
           gcc_unreachable ();
         }
@@ -2360,7 +2357,6 @@ scan_sharing_clauses (tree clauses, omp_context *ctx,
         case OMP_CLAUSE_GANG:
         case OMP_CLAUSE_WORKER:
         case OMP_CLAUSE_VECTOR:
-       case OMP_CLAUSE_TILE:
         case OMP_CLAUSE_INDEPENDENT:
         case OMP_CLAUSE_AUTO:
         case OMP_CLAUSE_SEQ:
@@ -2368,10 +2364,8 @@ scan_sharing_clauses (tree clauses, omp_context *ctx,
           break;
  
         case OMP_CLAUSE_DEVICE_RESIDENT:
+       case OMP_CLAUSE_TILE:
         case OMP_CLAUSE__CACHE_:
-         sorry ("Clause not supported yet");
-         break;
-
         default:
           gcc_unreachable ();
         }
@@ -13680,6 +13674,9 @@ grid_expand_target_grid_body (struct omp_region *target)
    tree new_parm_decl = copy_node (DECL_ARGUMENTS (kern_fndecl));
    DECL_CONTEXT (new_parm_decl) = kern_fndecl;
    DECL_ARGUMENTS (kern_fndecl) = new_parm_decl;
+  gcc_assert (VOID_TYPE_P (TREE_TYPE (DECL_RESULT (kern_fndecl))));
+  DECL_RESULT (kern_fndecl) = copy_node (DECL_RESULT (kern_fndecl));
+  DECL_CONTEXT (DECL_RESULT (kern_fndecl)) = kern_fndecl;
    struct function *kern_cfun = DECL_STRUCT_FUNCTION (kern_fndecl);
    kern_cfun->curr_properties = cfun->curr_properties;
  
diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog

index cd977a2..7380984 100644 (file)
--- a/gcc/po/ChangeLog
+++ b/gcc/po/ChangeLog
@@ -1,3 +1,23 @@
+2016-06-06  Joseph Myers  <joseph@codesourcery.com>
+
+       * fr.po: Update.
+
+2016-05-25  Joseph Myers  <joseph@codesourcery.com>
+
+       * ru.po: Update.
+
+2016-05-25  Joseph Myers  <joseph@codesourcery.com>
+
+       * ru.po: Update.
+
+2016-05-18  Joseph Myers  <joseph@codesourcery.com>
+
+       * da.po, sv.po: Update.
+
+2016-05-09  Joseph Myers  <joseph@codesourcery.com>
+
+       * sv.po: Update.
+
  2016-05-02  Joseph Myers  <joseph@codesourcery.com>
  
         * sv.po, zh_CN.po: Update.
diff --git a/gcc/po/da.po b/gcc/po/da.po

index 67aa380..b55d220 100644 (file)
--- a/gcc/po/da.po
+++ b/gcc/po/da.po
@@ -1,8 +1,8 @@
  # Danish version of GCC strings.
-# Copyright (C) 2015 Free Software Foundation, Inc.
+# Copyright (C) 2016 Free Software Foundation, Inc.
  # This file is distributed under the same license as the gcc package.
  # Ole Laursen <olau@hardworking.dk>, 2001, 02, 03, 04.
-# Joe Hansen <joedalton2@yahoo.dk>, 2015.
+# Joe Hansen <joedalton2@yahoo.dk>, 2015, 2016.
  #
  # Konventioner:
  #
@@ -30,6 +30,7 @@
  # declared -> erklæret
  # defaults to -> antages at være
  # dereference -> følge
+# directory -> mappe
  # discard -> fjerne
  # discard -> kassere
  # divide -> division
@@ -133,10 +134,10 @@
  #
  msgid ""
  msgstr ""
-"Project-Id-Version: gcc 5.2.0\n"
+"Project-Id-Version: gcc 6.1.0\n"
  "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n"
  "POT-Creation-Date: 2016-04-21 15:24+0000\n"
-"PO-Revision-Date: 2015-08-16 18:00+0200\n"
+"PO-Revision-Date: 2016-05-16 18:00+0200\n"
  "Last-Translator: Joe Hansen <joedalton2@yahoo.dk>\n"
  "Language-Team: Danish <dansk@dansk-gruppen.dk>\n"
  "Language: da\n"
@@ -400,282 +401,196 @@ msgid "Options:\n"
  msgstr "Tilvalg:\n"
  
  #: gcc.c:3384
-#, fuzzy
-#| msgid "  -pass-exit-codes         Exit with highest error code from a phase\n"
  msgid "  -pass-exit-codes         Exit with highest error code from a phase.\n"
-msgstr "  -pass-exit-codes         Afslut med den højeste fejlkode fra en fase\n"
+msgstr "  -pass-exit-codes         Afslut med den højeste fejlkode fra en fase.\n"
  
  #: gcc.c:3385
-#, fuzzy
-#| msgid "  --help                   Display this information\n"
  msgid "  --help                   Display this information.\n"
-msgstr "  --help                   Vis disse oplysninger\n"
+msgstr "  --help                   Vis disse oplysninger.\n"
  
  #: gcc.c:3386
-#, fuzzy
-#| msgid "  --target-help            Display target specific command line options\n"
  msgid "  --target-help            Display target specific command line options.\n"
-msgstr "  --target-help            Vis målspecifikke kommandolinjetilvalg\n"
+msgstr "  --target-help            Vis målspecifikke kommandolinjetilvalg.\n"
  
  #: gcc.c:3387
  msgid "  --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"
  msgstr ""
  
  #: gcc.c:3388
-#, fuzzy
-#| msgid "                           Display specific types of command line options\n"
  msgid "                           Display specific types of command line options.\n"
-msgstr "                           Vis specifikke typer af tilvalg for kommandolinjen\n"
+msgstr "                           Vis specifikke typer af tilvalg for kommandolinjen.\n"
  
  #: gcc.c:3390
-#, fuzzy
-#| msgid "  (Use '-v --help' to display command line options of sub-processes)\n"
  msgid "  (Use '-v --help' to display command line options of sub-processes).\n"
-msgstr "  (benyt »-v --help« for at vise kommandolinjetilvalg for underprocesser)\n"
+msgstr "  (benyt »-v --help« for at vise kommandolinjetilvalg for underprocesser).\n"
  
  #: gcc.c:3391
-#, fuzzy
-#| msgid "  --version                Display compiler version information\n"
  msgid "  --version                Display compiler version information.\n"
-msgstr "  --version                Udskriv oversætterens version\n"
+msgstr "  --version                Udskriv oversætterens version.\n"
  
  #: gcc.c:3392
-#, fuzzy
-#| msgid "  -dumpspecs               Display all of the built in spec strings\n"
  msgid "  -dumpspecs               Display all of the built in spec strings.\n"
-msgstr "  -dumpspecs               Vis alle de indbyggede specifikationsstrenge\n"
+msgstr "  -dumpspecs               Vis alle de indbyggede specifikationsstrenge.\n"
  
  #: gcc.c:3393
-#, fuzzy
-#| msgid "  -dumpversion             Display the version of the compiler\n"
  msgid "  -dumpversion             Display the version of the compiler.\n"
-msgstr "  -dumpversion             Vis oversætterens versionsnummer\n"
+msgstr "  -dumpversion             Vis oversætterens versionsnummer.\n"
  
  #: gcc.c:3394
-#, fuzzy
-#| msgid "  -dumpmachine             Display the compiler's target processor\n"
  msgid "  -dumpmachine             Display the compiler's target processor.\n"
-msgstr "  -dumpmachine             Vis oversætterens målprocessor\n"
+msgstr "  -dumpmachine             Vis oversætterens målprocessor.\n"
  
  #: gcc.c:3395
-#, fuzzy
-#| msgid "  -print-search-dirs       Display the directories in the compiler's search path\n"
  msgid "  -print-search-dirs       Display the directories in the compiler's search path.\n"
-msgstr "  -print-search-dirs       Vis katalogerne i oversætterens søgesti\n"
+msgstr "  -print-search-dirs       Vis mapperne i oversætterens søgesti.\n"
  
  #: gcc.c:3396
-#, fuzzy
-#| msgid "  -print-libgcc-file-name  Display the name of the compiler's companion library\n"
  msgid "  -print-libgcc-file-name  Display the name of the compiler's companion library.\n"
-msgstr "  -print-libgcc-file-name  Vis navnet på oversætterens tilhørende bibliotek\n"
+msgstr "  -print-libgcc-file-name  Vis navnet på oversætterens tilhørende bibliotek.\n"
  
  #: gcc.c:3397
-#, fuzzy
-#| msgid "  -print-file-name=<lib>   Display the full path to library <lib>\n"
  msgid "  -print-file-name=<lib>   Display the full path to library <lib>.\n"
-msgstr "  -print-file-name=<bibl>  Vis den komplette sti til biblioteket <bibl>\n"
+msgstr "  -print-file-name=<bibl>  Vis den komplette sti til biblioteket <bibl>.\n"
  
  #: gcc.c:3398
-#, fuzzy
-#| msgid "  -print-prog-name=<prog>  Display the full path to compiler component <prog>\n"
  msgid "  -print-prog-name=<prog>  Display the full path to compiler component <prog>.\n"
-msgstr "  -print-prog-name=<prog>  Vis den komplette sti til oversætterkomponenten <prog>\n"
+msgstr "  -print-prog-name=<prog>  Vis den komplette sti til oversætterkomponenten <prog>.\n"
  
  #: gcc.c:3399
-#, fuzzy
-#| msgid ""
-#| "  -print-multiarch         Display the target's normalized GNU triplet, used as\n"
-#| "                           a component in the library path\n"
  msgid ""
  "  -print-multiarch         Display the target's normalized GNU triplet, used as\n"
  "                           a component in the library path.\n"
  msgstr ""
  "  -print-multi-lib         Vis målets normaliseret GNU-triplet, brugt som\n"
-"                           en komponent i bibioteksstien\n"
+"                           en komponent i bibioteksstien.\n"
  
  #: gcc.c:3402
-#, fuzzy
-#| msgid "  -print-multi-directory   Display the root directory for versions of libgcc\n"
  msgid "  -print-multi-directory   Display the root directory for versions of libgcc.\n"
-msgstr "  -print-multi-directory   Vis rodkataloget for versioner af libgcc\n"
+msgstr "  -print-multi-directory   Vis rodmappen for versioner af libgcc.\n"
  
  #: gcc.c:3403
-#, fuzzy
-#| msgid ""
-#| "  -print-multi-lib         Display the mapping between command line options and\n"
-#| "                           multiple library search directories\n"
  msgid ""
  "  -print-multi-lib         Display the mapping between command line options and\n"
  "                           multiple library search directories.\n"
  msgstr ""
  "  -print-multi-lib         Vis afbildningen mellem kommandolinjetilvalg og\n"
-"                           flere bibliotekssøgekataloger\n"
+"                           flere bibliotekssøgemapper.\n"
  
  #: gcc.c:3406
-#, fuzzy
-#| msgid "  -print-multi-os-directory Display the relative path to OS libraries\n"
  msgid "  -print-multi-os-directory Display the relative path to OS libraries.\n"
-msgstr "  -print-multi-os-directory Vis den relative sti for OS-biblioteker\n"
+msgstr "  -print-multi-os-directory Vis den relative sti for OS-biblioteker.\n"
  
  #: gcc.c:3407
-#, fuzzy
-#| msgid "  -print-sysroot           Display the target libraries directory\n"
  msgid "  -print-sysroot           Display the target libraries directory.\n"
-msgstr "  -print-sysroot           Vis mappen for målets biblioteker\n"
+msgstr "  -print-sysroot           Vis mappen for målets biblioteker.\n"
  
  #: gcc.c:3408
-#, fuzzy
-#| msgid "  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n"
  msgid "  -print-sysroot-headers-suffix Display the sysroot suffix used to find headers.\n"
-msgstr "  -print-sysroot-headers-suffix Vis sysroot-suffikset brugt til at finde teksthoveder\n"
+msgstr "  -print-sysroot-headers-suffix Vis sysroot-suffikset brugt til at finde teksthoveder.\n"
  
  #: gcc.c:3409
-#, fuzzy
-#| msgid "  -Wa,<options>            Pass comma-separated <options> on to the assembler\n"
  msgid "  -Wa,<options>            Pass comma-separated <options> on to the assembler.\n"
-msgstr "  -Wa,<tilvalg>            Videregiv komma-adskilte <tilvalg> til maskinkodeoversætteren\n"
+msgstr "  -Wa,<tilvalg>            Videregiv komma-adskilte <tilvalg> til maskinkodeoversætteren.\n"
  
  #: gcc.c:3410
-#, fuzzy
-#| msgid "  -Wp,<options>            Pass comma-separated <options> on to the preprocessor\n"
  msgid "  -Wp,<options>            Pass comma-separated <options> on to the preprocessor.\n"
-msgstr "  -Wp,<tilvalg>            Videregiv komma-adskilte <tilvalg> til præprocessoren\n"
+msgstr "  -Wp,<tilvalg>            Videregiv komma-adskilte <tilvalg> til forbrænderen.\n"
  
  #: gcc.c:3411
-#, fuzzy
-#| msgid "  -Wl,<options>            Pass comma-separated <options> on to the linker\n"
  msgid "  -Wl,<options>            Pass comma-separated <options> on to the linker.\n"
-msgstr "  -Wl,<tilvalg>            Videregiv komma-adskilte <tilvalg> til sammenkæderen\n"
+msgstr "  -Wl,<tilvalg>            Videregiv komma-adskilte <tilvalg> til sammenkæderen.\n"
  
  #: gcc.c:3412
-#, fuzzy
-#| msgid "  -Xassembler <arg>        Pass <arg> on to the assembler\n"
  msgid "  -Xassembler <arg>        Pass <arg> on to the assembler.\n"
-msgstr "  -Xassembler <para>       Videregiv <para> til maskinkodeoversætteren\n"
+msgstr "  -Xassembler <para>       Videregiv <para> til maskinkodeoversætteren.\n"
  
  #: gcc.c:3413
-#, fuzzy
-#| msgid "  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor\n"
  msgid "  -Xpreprocessor <arg>     Pass <arg> on to the preprocessor.\n"
-msgstr "  -Xpreprocessor <para>    Videregiv <para> til forbrænderen\n"
+msgstr "  -Xpreprocessor <para>    Videregiv <para> til forbrænderen.\n"
  
  #: gcc.c:3414
-#, fuzzy
-#| msgid "  -Xlinker <arg>           Pass <arg> on to the linker\n"
  msgid "  -Xlinker <arg>           Pass <arg> on to the linker.\n"
-msgstr "  -Xlinker <para>          Videregiv <para> til sammenkæderen\n"
+msgstr "  -Xlinker <para>          Videregiv <para> til sammenkæderen.\n"
  
  #: gcc.c:3415
-#, fuzzy
-#| msgid "  -save-temps              Do not delete intermediate files\n"
  msgid "  -save-temps              Do not delete intermediate files.\n"
-msgstr "  -save-temps              Slet ikke midlertidige filer\n"
+msgstr "  -save-temps              Slet ikke midlertidige filer.\n"
  
  #: gcc.c:3416
-#, fuzzy
-#| msgid "  -save-temps=<arg>        Do not delete intermediate files\n"
  msgid "  -save-temps=<arg>        Do not delete intermediate files.\n"
-msgstr "  -save-temps=<para>       Slet ikke midlertidige filer\n"
+msgstr "  -save-temps=<para>       Slet ikke midlertidige filer.\n"
  
  #: gcc.c:3417
  msgid ""
  "  -no-canonical-prefixes   Do not canonicalize paths when building relative\n"
  "                           prefixes to other gcc components.\n"
  msgstr ""
+"  -no-canonical-prefixes   Normaliser ikke stier når der bygges relative\n"
+"                           præfiks til andre gcc-komponenter.\n"
  
  #: gcc.c:3420
-#, fuzzy
-#| msgid "  -pipe                    Use pipes rather than intermediate files\n"
  msgid "  -pipe                    Use pipes rather than intermediate files.\n"
-msgstr "  -pipe                    Brug datakanaler i stedet for midlertidige filer\n"
+msgstr "  -pipe                    Brug datakanaler i stedet for midlertidige filer.\n"
  
  #: gcc.c:3421
-#, fuzzy
-#| msgid "  -time                    Time the execution of each subprocess\n"
  msgid "  -time                    Time the execution of each subprocess.\n"
-msgstr "  -time                    Tag tid på udførslen af hver underproces\n"
+msgstr "  -time                    Tag tid på udførslen af hver underproces.\n"
  
  #: gcc.c:3422
-#, fuzzy
-#| msgid "  -specs=<file>            Override built-in specs with the contents of <file>\n"
  msgid "  -specs=<file>            Override built-in specs with the contents of <file>.\n"
-msgstr "  -specs=<fil>             Overskriv indbyggede specifikationer med indholdet af <fil>\n"
+msgstr "  -specs=<fil>             Overskriv indbyggede specifikationer med indholdet af <fil>.\n"
  
  #: gcc.c:3423
-#, fuzzy
-#| msgid "  -std=<standard>          Assume that the input sources are for <standard>\n"
  msgid "  -std=<standard>          Assume that the input sources are for <standard>.\n"
-msgstr "  -std=<standard>          Antag at inddatakildekoden er skrevet til <standard>\n"
+msgstr "  -std=<standard>          Antag at inddatakildekoden er skrevet til <standard>.\n"
  
  #: gcc.c:3424
  msgid ""
  "  --sysroot=<directory>    Use <directory> as the root directory for headers\n"
  "                           and libraries.\n"
  msgstr ""
+"  --sysroot=<mappe>    Brug <mappe> som rodmappen for teksthoveder\n"
+"                       og biblioteker.\n"
  
  #: gcc.c:3427
-#, fuzzy
-#| msgid "  -B <directory>           Add <directory> to the compiler's search paths\n"
  msgid "  -B <directory>           Add <directory> to the compiler's search paths.\n"
-msgstr "  -B <katalog>             Tilføj katalog til oversætterens søgestier\n"
+msgstr "  -B <mappe>               Tilføj mappe til oversætterens søgestier.\n"
  
  #: gcc.c:3428
-#, fuzzy
-#| msgid "  -v                       Display the programs invoked by the compiler\n"
  msgid "  -v                       Display the programs invoked by the compiler.\n"
-msgstr "  -v                       Vis de programmer der startes af oversætteren\n"
+msgstr "  -v                       Vis de programmer der startes af oversætteren.\n"
  
  #: gcc.c:3429
-#, fuzzy
-#| msgid "  -###                     Like -v but options quoted and commands not executed\n"
  msgid "  -###                     Like -v but options quoted and commands not executed.\n"
  msgstr ""
  "  -###                     Som '-v', men tilvalg anbringes i anførselstegn\n"
-"                           og kommandoerne udføres ikke\n"
+"                           og kommandoerne udføres ikke.\n"
  
  #: gcc.c:3430
-#, fuzzy
-#| msgid "  -E                       Preprocess only; do not compile, assemble or link\n"
  msgid "  -E                       Preprocess only; do not compile, assemble or link.\n"
-msgstr "  -E                       Forbehandl kun; oversæt og sammenkæd ikke\n"
+msgstr "  -E                       Forbehandl kun; oversæt, maskinkodeoversæt og sammenkæd ikke.\n"
  
  #: gcc.c:3431
-#, fuzzy
-#| msgid "  -S                       Compile only; do not assemble or link\n"
  msgid "  -S                       Compile only; do not assemble or link.\n"
-msgstr "  -S                       Oversæt kun; maskinekodeoversæt og sammenkæd ikke\n"
+msgstr "  -S                       Oversæt kun; maskinekodeoversæt og sammenkæd ikke.\n"
  
  #: gcc.c:3432
-#, fuzzy
-#| msgid "  -c                       Compile and assemble, but do not link\n"
  msgid "  -c                       Compile and assemble, but do not link.\n"
-msgstr "  -c                       Oversæt, også til maskinkode, men sammenkæd ikke\n"
+msgstr "  -c                       Oversæt, også til maskinkode, men sammenkæd ikke.\n"
  
  #: gcc.c:3433
-#, fuzzy
-#| msgid "  -o <file>                Place the output into <file>\n"
  msgid "  -o <file>                Place the output into <file>.\n"
-msgstr "  -o <fil>                 Anbring uddataene i <fil>\n"
+msgstr "  -o <fil>                 Anbring uddataene i <fil>.\n"
  
  #: gcc.c:3434
-#, fuzzy
-#| msgid "  -pie                     Create a position independent executable\n"
  msgid "  -pie                     Create a position independent executable.\n"
-msgstr "  -pie                     Opret en positionsuafhængig kørbar fil\n"
+msgstr "  -pie                     Opret en positionsuafhængig kørbar fil.\n"
  
  #: gcc.c:3435
-#, fuzzy
-#| msgid "  -shared                  Create a shared library\n"
  msgid "  -shared                  Create a shared library.\n"
-msgstr "  -shared                  Opret et delt bibliotek\n"
+msgstr "  -shared                  Opret et delt bibliotek.\n"
  
  #: gcc.c:3436
-#, fuzzy
-#| msgid ""
-#| "  -x <language>            Specify the language of the following input files\n"
-#| "                           Permissible languages include: c c++ assembler none\n"
-#| "                           'none' means revert to the default behavior of\n"
-#| "                           guessing the language based on the file's extension\n"
  msgid ""
  "  -x <language>            Specify the language of the following input files.\n"
  "                           Permissible languages include: c c++ assembler none\n"
@@ -684,8 +599,8 @@ msgid ""
  msgstr ""
  "  -x <sprog>               Angiv sproget for de følgende inddatafiler.\n"
  "                           Tilladte sprog inkluderer: c c++ assembler none\n"
-"                           'none' betyder at standardopførslen med at gætte\n"
-"                           sproget på filendelsen udføres\n"
+"                           »none« betyder at standardopførslen med at gætte\n"
+"                           sproget på filendelsen udføres.\n"
  
  #: gcc.c:3443
  #, c-format
@@ -699,7 +614,7 @@ msgstr ""
  "Tilvalg der begynder med -g, -f, -m, -O, -W eller --param bliver automatisk\n"
  " givet videre til de forskellige underprocesser som %s starter. For at\n"
  " videregive andre indstillinger til disse processer kan tilvalg på formen\n"
-" '-W<bogstav>' bruges.\n"
+" »-W<bogstav>« bruges.\n"
  
  #: gcc.c:5876
  #, c-format
@@ -734,12 +649,12 @@ msgstr "gcc-styringsprogram version %s %skører gcc-version %s\n"
  #: gcc.c:6682 gcc.c:6894
  #, c-format
  msgid "The bug is not reproducible, so it is likely a hardware or OS problem.\n"
-msgstr ""
+msgstr "Fejlen kan ikke genskabes, så det er sandsynligvis et udstyrsproblem eller et problem med operativsystemet.\n"
  
  #: gcc.c:6818
  #, c-format
  msgid "Preprocessed source stored into %s file, please attach this to your bugreport.\n"
-msgstr ""
+msgstr "Forbrændt kilde lagret i %s-filen, vedhæft venligst den til din fejlrapport.\n"
  
  #: gcc.c:7757
  #, c-format
@@ -793,6 +708,10 @@ msgid ""
  "==============\n"
  "\n"
  msgstr ""
+"\n"
+"Tilvalg for sammenkæder\n"
+"==============\n"
+"\n"
  
  #: gcc.c:8205
  #, c-format
@@ -800,6 +719,8 @@ msgid ""
  "Use \"-Wl,OPTION\" to pass \"OPTION\" to the linker.\n"
  "\n"
  msgstr ""
+"Brug »-Wl,TILVALG« for at sende »TILVALG« til sammenkæderen.\n"
+"\n"
  
  #: gcc.c:9497
  #, c-format
@@ -808,6 +729,9 @@ msgid ""
  "=================\n"
  "\n"
  msgstr ""
+"Tilvalg for maskinkodeoversætteren\n"
+"=================\n"
+"\n"
  
  #: gcc.c:9498
  #, c-format
@@ -815,11 +739,13 @@ msgid ""
  "Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n"
  "\n"
  msgstr ""
+"Brug »-Wa,TILVALG« til at sende »TILVALG« til maskinkodeoversætteren.\n"
+"\n"
  
  #: gcov-tool.c:166
  #, c-format
  msgid "  merge [options] <dir1> <dir2>         Merge coverage file contents\n"
-msgstr ""
+msgstr "  merge [tilvalg] <map1> <map2>         Sammenføj dækningsfilindhold\n"
  
  #: gcov-tool.c:167 gcov-tool.c:261 gcov-tool.c:417
  #, c-format
@@ -827,10 +753,9 @@ msgid "    -v, --verbose                       Verbose mode\n"
  msgstr "    -v, --verbose                       Uddybende tilstand\n"
  
  #: gcov-tool.c:168 gcov-tool.c:262
-#, fuzzy, c-format
-#| msgid "  -n, --no-output                 Do not create an output file\n"
+#, c-format
  msgid "    -o, --output <dir>                  Output directory\n"
-msgstr "  -n, --no-output                 Opret ikke en uddatafil\n"
+msgstr "    -o, --output <map>                  Vis mappe\n"
  
  #: gcov-tool.c:169
  #, c-format
@@ -840,12 +765,12 @@ msgstr ""
  #: gcov-tool.c:185
  #, c-format
  msgid "Merge subcomand usage:"
-msgstr ""
+msgstr "Sammenføj brug af underkommando:"
  
  #: gcov-tool.c:260
  #, c-format
  msgid "  rewrite [options] <dir>               Rewrite coverage file contents\n"
-msgstr ""
+msgstr "  rewrite [tilvalg] <map>               Genskriv dækningsfilindhold\n"
  
  #: gcov-tool.c:263
  #, c-format
@@ -875,46 +800,42 @@ msgstr ""
  #: gcov-tool.c:359
  #, c-format
  msgid "normalization cannot co-exist with scaling\n"
-msgstr ""
+msgstr "normalisering kan ikke sameksistere med skalering\n"
  
  #: gcov-tool.c:416
  #, c-format
  msgid "  overlap [options] <dir1> <dir2>       Compute the overlap of two profiles\n"
-msgstr ""
+msgstr "  overlap [tilvalg] <map1> <map2>       Beregn overlap for to profiler\n"
  
  #: gcov-tool.c:418
-#, fuzzy, c-format
-#| msgid "  -h, --help                      Print this help, then exit\n"
+#, c-format
  msgid "    -h, --hotonly                       Only print info for hot objects/functions\n"
-msgstr "  -h, --help                      Udskriv denne hjælp og afslut\n"
+msgstr "    -h, --hotonly                       Udskriv kun info for varme objekter/funktioner\n"
  
  #: gcov-tool.c:419
-#, fuzzy, c-format
-#| msgid "  -p                      Enable function profiling\n"
+#, c-format
  msgid "    -f, --function                      Print function level info\n"
-msgstr "  -p                      Aktivér funktionsprofilering\n"
+msgstr "    -f, --function                      Udskriv info om funktionsniveau\n"
  
  #: gcov-tool.c:420
-#, fuzzy, c-format
-#| msgid "  -h, --help                      Print this help, then exit\n"
+#, c-format
  msgid "    -F, --fullname                      Print full filename\n"
-msgstr "  -h, --help                      Udskriv denne hjælp og afslut\n"
+msgstr "    -F, --fullname                      Udskriv fuldt filnavn\n"
  
  #: gcov-tool.c:421
-#, fuzzy, c-format
-#| msgid "  -h, --help                      Print this help, then exit\n"
+#, c-format
  msgid "    -o, --object                        Print object level info\n"
-msgstr "  -h, --help                      Udskriv denne hjælp og afslut\n"
+msgstr "    -o, --object                        Udskriv info på objektniveau\n"
  
  #: gcov-tool.c:422
  #, c-format
  msgid "    -t <float>, --hot_threshold <float> Set the threshold for hotness\n"
-msgstr ""
+msgstr "    -t <float>, --hot_threshold <float> Angiv tærskel for varme\n"
  
  #: gcov-tool.c:442
  #, c-format
  msgid "Overlap subcomand usage:"
-msgstr ""
+msgstr "Overlap brug af underkommando:"
  
  #: gcov-tool.c:508
  #, c-format
@@ -956,21 +877,22 @@ msgstr ""
  "%s.\n"
  
  #: gcov-tool.c:526
-#, fuzzy, c-format
-#| msgid "Copyright %s 2014-2015 Free Software Foundation, Inc.\n"
+#, c-format
  msgid "Copyright %s 2014-2016 Free Software Foundation, Inc.\n"
-msgstr "Ophavsret %s 2014-2015 Free Software Foundation, Inc.\n"
+msgstr "Ophavsret %s 2014-2016 Free Software Foundation, Inc.\n"
  
  #: gcov-tool.c:529 gcov.c:506
-#, fuzzy, c-format
+#, c-format
  msgid ""
  "This is free software; see the source for copying conditions.\n"
  "There is NO warranty; not even for MERCHANTABILITY or \n"
  "FITNESS FOR A PARTICULAR PURPOSE.\n"
  "\n"
  msgstr ""
-"Dette er et frit program; se kildekoden for kopieringsbetingelser. Der er\n"
-"INGEN garanti; ikke engang for SALGBARHED eller BRUGBARHED TIL NOGET FORMÅL.\n"
+"Dette er et frit program; se kildekoden for kopieringsbetingelser.\n"
+"Der er INGEN garanti; ikke engang for SALGBARHED eller\n"
+"BRUGBARHED TIL NOGET FORMÅL.\n"
+"\n"
  
  #: gcov.c:472
  #, c-format
@@ -1015,10 +937,9 @@ msgstr ""
  "                                    for procenter\n"
  
  #: gcov.c:479
-#, fuzzy, c-format
-#| msgid "  --help                   Display this information\n"
+#, c-format
  msgid "  -d, --display-progress          Display progress information\n"
-msgstr "  --help                   Vis disse oplysninger\n"
+msgstr "  -d, --display-progress          Vis statusinformation\n"
  
  #: gcov.c:480
  #, c-format
@@ -1028,14 +949,16 @@ msgstr "  -f, --function-summaries        Udskriv sammendrag for hver funktion\n
  #: gcov.c:481
  #, c-format
  msgid "  -i, --intermediate-format       Output .gcov file in intermediate text format\n"
-msgstr ""
+msgstr "  -i, --intermediate-format       Vis .gcov-filen i melleliggende tekstformat\n"
  
  #: gcov.c:482
  #, c-format
  msgid ""
  "  -l, --long-file-names           Use long output file names for included\n"
  "                                    source files\n"
-msgstr "  -l, --long-file-names           Brug lange filnavne til inkluderede kildefiler\n"
+msgstr ""
+"  -l, --long-file-names           Brug lange filnavne til inkluderede\n"
+"                                    kildefiler\n"
  
  #: gcov.c:484
  #, c-format
@@ -1058,10 +981,9 @@ msgid "  -p, --preserve-paths            Preserve all pathname components\n"
  msgstr "  -p, --preserve-paths            Bevar alle stinavnskomponenter\n"
  
  #: gcov.c:488
-#, fuzzy, c-format
-#| msgid "  -a, --all-blocks                Show information for every basic block\n"
+#, c-format
  msgid "  -r, --relative-only             Only show data for relative sources\n"
-msgstr "  -a, --all-blocks                Vis oplysninger for alle basisblokke\n"
+msgstr "  -r, --relative-only             Vis kun data for relative kilder\n"
  
  #: gcov.c:489
  #, c-format
@@ -1119,10 +1041,9 @@ msgid "%s:source file is newer than notes file '%s'\n"
  msgstr "%s: kildefil er nyere end notefil »%s«\n"
  
  #: gcov.c:1144
-#, fuzzy, c-format
-#| msgid "(the message is only displayed one per source file)\n"
+#, c-format
  msgid "(the message is displayed only once per source file)\n"
-msgstr "(beskeden er kun vist en per kildefil)\n"
+msgstr "(beskeden er kun vist en gang per kildefil)\n"
  
  #: gcov.c:1169
  #, c-format
@@ -1180,19 +1101,19 @@ msgid "%s:unknown function '%u'\n"
  msgstr "%s:ukendt funktion »%u«\n"
  
  #: gcov.c:1466
-#, fuzzy, c-format
+#, c-format
  msgid "%s:profile mismatch for '%s'\n"
-msgstr "%s før '%s'"
+msgstr "%s:forskelige profiler for »%s«\n"
  
  #: gcov.c:1485
-#, fuzzy, c-format
+#, c-format
  msgid "%s:overflowed\n"
-msgstr "%s: overløbsintervalfejl"
+msgstr "%s: overløb\n"
  
  #: gcov.c:1531
  #, c-format
  msgid "%s:'%s' lacks entry and/or exit blocks\n"
-msgstr ""
+msgstr "%s:»%s« mangler indgangs- og/eller afslutningsblokke\n"
  
  #: gcov.c:1536
  #, c-format
@@ -1205,9 +1126,9 @@ msgid "%s:'%s' has arcs from exit block\n"
  msgstr ""
  
  #: gcov.c:1752
-#, fuzzy, c-format
+#, c-format
  msgid "%s:graph is unsolvable for '%s'\n"
-msgstr "%s før '%s'"
+msgstr "%s:graf kan ikke løses for »%s«\n"
  
  #: gcov.c:1860
  #, c-format
@@ -1310,17 +1231,17 @@ msgstr "funktion kan returnere adressen på en lokal variabel"
  #: incpath.c:72
  #, c-format
  msgid "ignoring duplicate directory \"%s\"\n"
-msgstr "ignorerer mere end én angivelse af kataloget \"%s\"\n"
+msgstr "ignorerer mere end en angivelse af mappen »%s«\n"
  
  #: incpath.c:75
  #, c-format
  msgid "  as it is a non-system directory that duplicates a system directory\n"
-msgstr "  da det er et ikke-systemkatalog som dublerer et systemkatalog\n"
+msgstr "  da det ikke er en systemmappe, som dublerer en systemmappe\n"
  
  #: incpath.c:79
  #, c-format
  msgid "ignoring nonexistent directory \"%s\"\n"
-msgstr "ignorerer det ikke-eksisterende katalog \"%s\"\n"
+msgstr "ignorerer den ikkeeksisterende mappe »%s«\n"
  
  #: incpath.c:373
  #, c-format
@@ -1348,64 +1269,55 @@ msgid "'"
  msgstr "«"
  
  #: ipa-pure-const.c:187
-#, fuzzy
-#| msgid "function might be possible candidate for attribute `noreturn'"
  msgid "function might be candidate for attribute %<%s%>"
-msgstr "funktion er muligvis en kandidat til egenskaben 'noreturn'"
+msgstr "funktion er muligvis en kandidat til egenskaben %<%s%>"
  
  #: ipa-pure-const.c:188
-#, fuzzy
-#| msgid "function might be possible candidate for attribute `noreturn'"
  msgid "function might be candidate for attribute %<%s%> if it is known to return normally"
-msgstr "funktion er muligvis en kandidat til egenskaben 'noreturn'"
+msgstr "funktion er muligvis en kandidat til egenskaben %<%s%>, hvis den vides at returnere normalt"
  
  #: langhooks.c:373
  msgid "At top level:"
  msgstr "Ved øverste niveau:"
  
  #: langhooks.c:393 cp/error.c:3299
-#, fuzzy, c-format
-#| msgid "In member function `%s':"
+#, c-format
  msgid "In member function %qs"
-msgstr "I medlemsfunktionen '%s':"
+msgstr "I medlemsfunktionen %qs"
  
  #: langhooks.c:397 cp/error.c:3302
-#, fuzzy, c-format
-#| msgid "In function `%s':"
+#, c-format
  msgid "In function %qs"
-msgstr "I funktionen '%s':"
+msgstr "I funktionen %qs"
  
  #: langhooks.c:448 cp/error.c:3252
  msgid "    inlined from %qs at %r%s:%d:%d%R"
-msgstr ""
+msgstr "    indlejret fra %qs ved %r%s:%d:%d%R"
  
  #: langhooks.c:453 cp/error.c:3257
-#, fuzzy
-#| msgid "In file included from %s:%d"
  msgid "    inlined from %qs at %r%s:%d%R"
-msgstr "I filen inkluderet af %s:%d"
+msgstr "    indlejret fra %qs ved %r%s:%d%R"
  
  #: langhooks.c:459 cp/error.c:3263
-#, fuzzy, c-format
-#| msgid "In file included from %s:%u"
+#, c-format
  msgid "    inlined from %qs"
-msgstr "I filen inkluderet af %s:%u"
+msgstr "    indlejret fra %qs"
  
  #: loop-iv.c:3041 tree-ssa-loop-niter.c:2319
  msgid "assuming that the loop is not infinite"
-msgstr ""
+msgstr "antager at loopet ikke er uendeligt"
  
  #: loop-iv.c:3042 tree-ssa-loop-niter.c:2320
  msgid "cannot optimize possibly infinite loops"
-msgstr ""
+msgstr "kan ikke opitmere eventuelle uendelige loop"
  
  #: loop-iv.c:3050 tree-ssa-loop-niter.c:2324
  msgid "assuming that the loop counter does not overflow"
-msgstr ""
+msgstr "antager at looptælleren ikke løber over"
  
  #: loop-iv.c:3051 tree-ssa-loop-niter.c:2325
  msgid "cannot optimize loop, the loop counter may overflow"
-msgstr ""
+msgstr "kan ikke optimere loop, looptælleren kan løbe over"
  
  #: lra-assigns.c:1417 reload1.c:2089
  msgid "this is the insn:"
@@ -1417,53 +1329,49 @@ msgstr "kunne ikke generere genindlæsninger for:"
  
  #. What to print when a switch has no documentation.
  #: opts.c:184
-#, fuzzy
-#| msgid "This switch lacks documentation"
  msgid "This option lacks documentation."
-msgstr "Denne switch mangler dokumentation"
+msgstr "Dette tilvalg mangler dokumentation."
  
  #: opts.c:185
  msgid "Uses of this option are diagnosed."
-msgstr ""
+msgstr "Brug af dette tilvalg diagnosticeres."
  
  #: opts.c:1061
  #, c-format
  msgid "default %d minimum %d maximum %d"
-msgstr ""
+msgstr "standard %d minimum %d maksimum %d"
  
  #: opts.c:1128
  #, c-format
  msgid "Same as %s.  Use the latter option instead."
-msgstr ""
+msgstr "Samme som %s. Brug det sidste tilvalg i stedet."
  
  #: opts.c:1136
  #, c-format
  msgid "%s  Same as %s."
-msgstr ""
+msgstr "%s Samme som %s."
  
  #: opts.c:1207
  msgid "[default]"
-msgstr ""
+msgstr "[standard]"
  
  #: opts.c:1218
  msgid "[enabled]"
-msgstr ""
+msgstr "[aktiveret]"
  
  #: opts.c:1218
-#, fuzzy
-#| msgid "GCSE disabled"
  msgid "[disabled]"
-msgstr "GCSE deaktiveret"
+msgstr "[deaktiveret]"
  
  #: opts.c:1237
  #, c-format
  msgid " No options with the desired characteristics were found\n"
-msgstr ""
+msgstr " Ingen tilvalg med de ønskede karakteristika blev fundet\n"
  
  #: opts.c:1246
  #, c-format
  msgid " None found.  Use --help=%s to show *all* the options supported by the %s front-end.\n"
-msgstr ""
+msgstr " Ingen fundet. Brug --help=%s for at vise *alle* tilvalgene understøttet af brugerfladen %s.\n"
  
  #: opts.c:1252
  #, c-format
@@ -1479,21 +1387,16 @@ msgid "The following options control compiler warning messages"
  msgstr "De følgende tilvalg kontrollerer advarselsbeskeder for oversætteren"
  
  #: opts.c:1343
-#, fuzzy
  msgid "The following options control optimizations"
-msgstr "Udfør løkkeoptimeringerne"
+msgstr "De følgende tilvalg kontrollerer optimeringer"
  
  #: opts.c:1346 opts.c:1385
-#, fuzzy
-#| msgid "The following options are language-independent:\n"
  msgid "The following options are language-independent"
-msgstr "De følgende tilvalg er sproguafhængige:\n"
+msgstr "De følgende tilvalg er sproguafhængige"
  
  #: opts.c:1349
-#, fuzzy
-#| msgid "The --param option recognizes the following as parameters:\n"
  msgid "The --param option recognizes the following as parameters"
-msgstr "Tilvalget --param genkender følgende som parametre:\n"
+msgstr "Tilvalget --param genkender følgende som parametre"
  
  #: opts.c:1355
  msgid "The following options are specific to just the language "
@@ -1508,16 +1411,12 @@ msgid "The following options are not documented"
  msgstr "De følgende tilvalg er ikke dokumenterede"
  
  #: opts.c:1370
-#, fuzzy
-#| msgid "The following options are language-independent:\n"
  msgid "The following options take separate arguments"
-msgstr "De følgende tilvalg er sproguafhængige:\n"
+msgstr "De følgende tilvalg anvender forskellige parametre"
  
  #: opts.c:1372
-#, fuzzy
-#| msgid "The following options are language-independent:\n"
  msgid "The following options take joined arguments"
-msgstr "De følgende tilvalg er sproguafhængige:\n"
+msgstr "De følgende tilvalg anvender fælles parametre"
  
  #: opts.c:1383
  msgid "The following options are language-related"
@@ -1534,7 +1433,7 @@ msgstr "Udvidelsesmoduler"
  #: plugin.c:828
  #, c-format
  msgid "*** WARNING *** there are active plugins, do not report this as a bug unless you can reproduce it without enabling any plugins.\n"
-msgstr ""
+msgstr "*** ADVARSEL *** der er aktive udvidelsesmoduler, rapporter ikke dette som en fejl med mindre, at du kan genskabe det uden at udvidelsesmoduler er aktiveret.\n"
  
  #. It's the compiler's fault.
  #: reload1.c:6113
@@ -1593,39 +1492,33 @@ msgid "collect: relinking\n"
  msgstr "collect: kæder sammen igen\n"
  
  #: toplev.c:331
-#, fuzzy, c-format
-#| msgid "internal error"
+#, c-format
  msgid "unrecoverable error"
-msgstr "intern fejl"
+msgstr "uoprettelig fejl"
  
  #: toplev.c:640
-#, fuzzy, c-format
-#| msgid ""
-#| "%s%s%s version %s (%s)\n"
-#| "%s\tcompiled by GNU C version %s.\n"
-#| "%s%s%s version %s (%s) compiled by CC.\n"
+#, c-format
  msgid ""
  "%s%s%s %sversion %s (%s)\n"
  "%s\tcompiled by GNU C version %s, "
  msgstr ""
-"%s%s%s version %s (%s)\n"
-"%s\toversat af GNU C version %s.\n"
-"%s%s%s version %s (%s) oversat af CC.\n"
+"%s%s%s %sversion %s (%s)\n"
+"%s\toversat af GNU C version %s, "
  
  #: toplev.c:642
  #, c-format
  msgid "%s%s%s %sversion %s (%s) compiled by CC, "
-msgstr ""
+msgstr "%s%s%s %sversion %s (%s) oversat af CC, "
  
  #: toplev.c:646
  #, c-format
  msgid "GMP version %s, MPFR version %s, MPC version %s, isl version %s\n"
-msgstr ""
+msgstr "GMP-version %s, MPFR-version %s, MPC-version %s, isl-version %s\n"
  
  #: toplev.c:648
  #, c-format
  msgid "%s%swarning: %s header version %s differs from library version %s.\n"
-msgstr ""
+msgstr "%s%sadvarsel: %s teksthovedversion %s svarer ikke til biblioteksversion %s.\n"
  
  #: toplev.c:650
  #, c-format
@@ -1647,63 +1540,56 @@ msgid "<anonymous>"
  msgstr "<anonym>"
  
  #: cif-code.def:39
-#, fuzzy
  msgid "function not considered for inlining"
-msgstr "funktion kan ikke indbygges"
+msgstr "funktion overvejes ikke for indbygning"
  
  #: cif-code.def:43
  msgid "caller is not optimized"
-msgstr ""
+msgstr "kalder er ikke optimeret"
  
  #: cif-code.def:47
-#, fuzzy
  msgid "function body not available"
-msgstr "funktion kan ikke indbygges"
+msgstr "funktionskrop er ikke tilgængelig"
  
  #: cif-code.def:51
-#, fuzzy
  msgid "redefined extern inline functions are not considered for inlining"
-msgstr "Advar når en inline funktion ikke kan indbygges"
+msgstr "omdefinerede eksterne indbyggede funktioner overvejes ikke for indlejring"
  
  #: cif-code.def:56
-#, fuzzy
  msgid "function not inlinable"
  msgstr "funktion kan ikke indbygges"
  
  #: cif-code.def:60
-#, fuzzy
-#| msgid "function cannot be inline"
  msgid "function body can be overwritten at link time"
-msgstr "funktion kan ikke indbygges"
+msgstr "funktionskrop kan ikke overskrives på sammenkædningstidspunktet"
  
  #: cif-code.def:64
-#, fuzzy
  msgid "function not inline candidate"
-msgstr "funktion kan ikke indbygges"
+msgstr "funktion er ikke en indbygningskandidat"
  
  #: cif-code.def:68
  msgid "--param large-function-growth limit reached"
-msgstr ""
+msgstr "--param large-function-growth grænse nået"
  
  #: cif-code.def:70
  msgid "--param large-stack-frame-growth limit reached"
-msgstr ""
+msgstr "--param large-stack-frame-growth grænse nået"
  
  #: cif-code.def:72
  msgid "--param max-inline-insns-single limit reached"
-msgstr ""
+msgstr "--param max-inline-insns-single grænse nået"
  
  #: cif-code.def:74
  msgid "--param max-inline-insns-auto limit reached"
-msgstr ""
+msgstr "--param max-inline-insns-auto grænse nået"
  
  #: cif-code.def:76
  msgid "--param inline-unit-growth limit reached"
-msgstr ""
+msgstr "--param inline-unit-growth grænse nået"
  
  #: cif-code.def:80
  msgid "recursive inlining"
-msgstr ""
+msgstr "rekursiv indbygning"
  
  #: cif-code.def:84
  msgid "call is unlikely and code size would grow"
@@ -1760,7 +1646,7 @@ msgstr ""
  
  #: cif-code.def:125
  msgid "function attribute mismatch"
-msgstr ""
+msgstr "forskellige funktionsattributter"
  
  #: cif-code.def:129
  #, fuzzy
@@ -1770,7 +1656,7 @@ msgstr "funktion der bruger alloca, kan ikke indbygges"
  
  #: cif-code.def:133
  msgid "unreachable"
-msgstr ""
+msgstr "kan ikke nås"
  
  #. The remainder are real diagnostic types.
  #: diagnostic.def:33
@@ -1830,10 +1716,9 @@ msgid "The minimal estimated speedup allowing inliner to ignore inline-insns-sin
  msgstr ""
  
  #: params.def:71
-#, fuzzy, no-c-format
-#| msgid "The maximum number of instructions in a single function eligible for inlining"
+#, no-c-format
  msgid "The maximum number of instructions in a single function eligible for inlining."
-msgstr "Det maksimale antal instruktioner i en enkelt funktion der må indbygges"
+msgstr "Det maksimale antal instruktioner i en enkelt funktion der må indbygges."
  
  #: params.def:83
  #, fuzzy, no-c-format
@@ -6049,10 +5934,9 @@ msgid "  --classpath PATH        Set path to find .class files\n"
  msgstr ""
  
  #: java/jcf-dump.c:1211
-#, fuzzy, c-format
-#| msgid "  -B <directory>           Add <directory> to the compiler's search paths\n"
+#, c-format
  msgid "  -IDIR                   Append directory to class path\n"
-msgstr "  -B <katalog>             Tilføj katalog til oversætterens søgestier\n"
+msgstr "  -IDIR                   Tilføj mappe til klassesti\n"
  
  #: java/jcf-dump.c:1212
  #, c-format
@@ -18938,16 +18822,14 @@ msgid "Cannot read string table from %s."
  msgstr ""
  
  #: auto-profile.c:912
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "cannot find file for class %s"
+#, gcc-internal-format, gfc-internal-format
  msgid "Cannot read function profile from %s."
-msgstr "kan ikke finde filen for klassen %s"
+msgstr "kan ikke læse funktionsprofil fra %s."
  
  #: auto-profile.c:919
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%s: cannot get working directory: %s\n"
+#, gcc-internal-format, gfc-internal-format
  msgid "Cannot read working set from %s."
-msgstr "%s: kan ikke få fat i arbejdskataloget: %s\n"
+msgstr "Kan ikke læse arbejdssæt fra %s."
  
  #: bt-load.c:1566
  #, gcc-internal-format
@@ -21159,20 +21041,19 @@ msgid "error in removing %s\n"
  msgstr "fejl ved skrivning til %s"
  
  #: gcov-tool.c:103
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Cannot make directory %s"
-msgstr "kan ikke oprette kataloget %s"
+msgstr "Kan ikke oprette mappen %s"
  
  #: gcov-tool.c:111
-#, fuzzy, gcc-internal-format
-#| msgid "can't get current directory"
+#, gcc-internal-format
  msgid "Cannot get current directory name"
-msgstr "kan ikke få fat i det aktuelle katalog"
+msgstr "Kan ikke få fat i det aktuelle mappenavn"
  
  #: gcov-tool.c:115 gcov-tool.c:121
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Cannot change directory to %s"
-msgstr "kan ikke oprette kataloget %s"
+msgstr "Kan ikke ændre mappen til %s"
  
  #: gcov-tool.c:214
  #, gcc-internal-format
@@ -21205,10 +21086,9 @@ msgid "DEF_INTERNAL_INT_FN (%s) has no associated built-in functions"
  msgstr ""
  
  #: gentarget-def.c:126
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "invalid operand code `%c'"
+#, gcc-internal-format, gfc-internal-format
  msgid "invalid prototype for '%s'"
-msgstr "ugyldig operandkode '%c'"
+msgstr "ugyldig prototype for »%s«"
  
  #: gentarget-def.c:131
  #, gcc-internal-format, gfc-internal-format
@@ -22149,10 +22029,9 @@ msgid "Reference statement index not found"
  msgstr "Advar hvis forældede tomme sætninger bliver fundet"
  
  #: lto-streamer-in.c:1513
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%s: cannot get working directory: %s\n"
+#, gcc-internal-format, gfc-internal-format
  msgid "cannot read LTO mode table from %s"
-msgstr "%s: kan ikke få fat i arbejdskataloget: %s\n"
+msgstr "kan ikke læse LTO-tilstandstabel fra %s"
  
  #: lto-streamer-in.c:1611
  #, fuzzy, gcc-internal-format, gfc-internal-format
@@ -28174,9 +28053,9 @@ msgid "too late for # directive to set debug directory"
  msgstr ""
  
  #: c-family/c-pch.c:110
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t create precompiled header %s: %m"
-msgstr "kan ikke oprette kataloget %s"
+msgstr "kan ikke oprette prækompileret teksthoved %s: %m"
  
  #: c-family/c-pch.c:133
  #, fuzzy, gcc-internal-format
@@ -62004,21 +61883,19 @@ msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
  msgstr ""
  
  #: fortran/scanner.c:330
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "Include directory %qs: %s"
-msgstr "kan ikke oprette kataloget %s"
+msgstr "Inkluder mappe %qs: %s"
  
  #: fortran/scanner.c:334
-#, fuzzy, gcc-internal-format
-#| msgid "ignoring nonexistent directory \"%s\"\n"
+#, gcc-internal-format
  msgid "Nonexistent include directory %qs"
-msgstr "ignorerer det ikke-eksisterende katalog \"%s\"\n"
+msgstr "Ikkeeksisterende include-mappe %qs"
  
  #: fortran/scanner.c:339
-#, fuzzy, gcc-internal-format
-#| msgid "%s: Not a directory"
+#, gcc-internal-format
  msgid "%qs is not a directory"
-msgstr "%s: ikke et katalog"
+msgstr "%qs er ikke en mappe"
  
  #: fortran/scanner.c:742
  #, gcc-internal-format, gfc-internal-format
@@ -66051,18 +65928,12 @@ msgstr "opretter vælger for ikke-eksisterende metode '%s'"
  #~ msgid "%s: usage '%s [ -VqfnkN ] [ -i <istring> ] [ filename ... ]'\n"
  #~ msgstr "%s: brug '%s [ -VqfnkN ] [ -i <istreng> ] [ filenavn ... ]'\n"
  
-#~ msgid "%s: usage '%s [ -VqfnkNlgC ] [ -B <dirname> ] [ filename ... ]'\n"
-#~ msgstr "%s: brug '%s [ -VqfnkNlgC ] [ -B <katalognavn> ] [ filnavn ... ]'\n"
-
  #~ msgid "%s: warning: no read access for file `%s'\n"
  #~ msgstr "%s: advarsel: ingen læseadgang til filen '%s'\n"
  
  #~ msgid "%s: warning: no write access for file `%s'\n"
  #~ msgstr "%s: advarsel: ingen skriveadgang til filen '%s'\n"
  
-#~ msgid "%s: warning: no write access for dir containing `%s'\n"
-#~ msgstr "%s: advarsel: ingen skriveadgang til kataloget der indeholder '%s'\n"
-
  #~ msgid "%s: invalid file name: %s\n"
  #~ msgstr "%s: ugyldigt filnavn: %s\n"
  
@@ -69189,23 +69060,6 @@ msgstr "opretter vælger for ikke-eksisterende metode '%s'"
  #~ "  -isystem <ktlg>           Føj <ktlg> til begyndelsen af systeminkluderingsstien\n"
  
  #~ msgid ""
-#~ "  -idirafter <dir>          Add <dir> to the end of the system include path\n"
-#~ "  -I <dir>                  Add <dir> to the end of the main include path\n"
-#~ "  -I-                       Fine-grained include path control; see info docs\n"
-#~ "  -nostdinc                 Do not search system include directories\n"
-#~ "                             (dirs specified with -isystem will still be used)\n"
-#~ "  -nostdinc++               Do not search system include directories for C++\n"
-#~ "  -o <file>                 Put output into <file>\n"
-#~ msgstr ""
-#~ "  -idirafter <ktlg>         Føj <ktlg> til slutningen af systeminkluderingsstien\n"
-#~ "  -I <ktlg>                 Føj <ktlg> til slutningen af den alm. inkluderingssti\n"
-#~ "  -I-                       Nøje kontrolleret inkluderingssti; se info-hjælpen\n"
-#~ "  -nostdinc                 Søg ikke i systeminkluderingskataloger\n"
-#~ "                             (kataloger angivet med -isystem søges dog stadig)\n"
-#~ "  -nostdinc++               Søg ikke i systeminkluderingskataloger til C++\n"
-#~ "  -o <fil>                  Send uddata til <fil>\n"
-
-#~ msgid ""
  #~ "  -trigraphs                Support ISO C trigraphs\n"
  #~ "  -std=<std name>           Specify the conformance standard; one of:\n"
  #~ "                            gnu89, gnu99, c89, c99, iso9899:1990,\n"
@@ -69404,9 +69258,6 @@ msgstr "opretter vælger for ikke-eksisterende metode '%s'"
  #~ msgid "absolute file name in remap_filename"
  #~ msgstr "absolut filnavn i remap_filename"
  
-#~ msgid "directory name missing after %s"
-#~ msgstr "et katalognavn mangler efter %s"
-
  #~ msgid "file name missing after %s"
  #~ msgstr "et filnavn mangler efter %s"
  
@@ -70178,9 +70029,6 @@ msgstr "opretter vælger for ikke-eksisterende metode '%s'"
  #~ msgid "Don't announce deprecation of compiler features"
  #~ msgstr "Annoncér ikke forældelse af oversætterfaciliteter"
  
-#~ msgid "directory name must immediately follow -I"
-#~ msgstr "et katalognavn skal følge umiddelbart efter -I"
-
  #~ msgid "Program does not use Unix-f77 dialectal features"
  #~ msgstr "Program benytter ikke Unix f77-dialektiske faciliteter"
  
@@ -70190,9 +70038,6 @@ msgstr "opretter vælger for ikke-eksisterende metode '%s'"
  #~ msgid "Fortran-specific form of -fbounds-check"
  #~ msgstr "Fortran-specifik form for -fbounds-check"
  
-#~ msgid "Add a directory for INCLUDE searching"
-#~ msgstr "Tilføj et katalog til INCLUDE-søgning"
-
  #~ msgid "Set the maximum line length"
  #~ msgstr "Angiv den maksimale linjelængde"
  
@@ -70208,12 +70053,6 @@ msgstr "opretter vælger for ikke-eksisterende metode '%s'"
  #~ msgid "Choose class whose main method should be used"
  #~ msgstr "Vælg klasse hvis main-metode skal bruges"
  
-#~ msgid "Add directory to class path"
-#~ msgstr "Tilføj katalog til klassesti"
-
-#~ msgid "Directory where class files should be written"
-#~ msgstr "Katalog som klassefiler skrives i"
-
  #~ msgid "`%s' cannot be statically allocated"
  #~ msgstr "'%s' kan ikke allokeres statisk"
  
@@ -70412,21 +70251,6 @@ msgstr "opretter vælger for ikke-eksisterende metode '%s'"
  #~ msgid "operator '%s' has no left operand"
  #~ msgstr "operatoren '%s' har ikke nogen venstre operand"
  
-#~ msgid "changing search order for system directory \"%s\""
-#~ msgstr "skifter søgeorden for systemkataloget \"%s\""
-
-#~ msgid "  as it is the same as non-system directory \"%s\""
-#~ msgstr "  da det er det samme som ikke-system-kataloget \"%s\""
-
-#~ msgid "  as it has already been specified as a non-system directory"
-#~ msgstr "  da det allerede er blevet angivet som et ikke-system-katalog"
-
-#~ msgid "I/O error on output"
-#~ msgstr "I/O-fejl på uddata"
-
-#~ msgid "number missing after %s"
-#~ msgstr "et tal mangler efter %s"
-
  #~ msgid "GNU CPP version %s (cpplib)"
  #~ msgstr "GNU CPP version %s (cpplib)"
  
@@ -70623,9 +70447,6 @@ msgstr "opretter vælger for ikke-eksisterende metode '%s'"
  #~ msgid "-trigraphs and -traditional are mutually exclusive"
  #~ msgstr "-trigraphs og -traditional er indbyrdes uforenelige"
  
-#~ msgid "directory name missing after -I option"
-#~ msgstr "et katalognavn mangler efter '-I'-tilvalg"
-
  #~ msgid "`/*' within comment"
  #~ msgstr "'/*' i en kommentar"
  
@@ -71367,9 +71188,6 @@ msgstr "opretter vælger for ikke-eksisterende metode '%s'"
  #~ "  -idirafter <ktlg>         Føj <ktlg> til slutningen af systeminkluderingsstien\n"
  #~ "  -I <ktlg>                 Føj <ktlg> til slutningen af den alm. inkluderingssti\n"
  #~ "  -I-                       Nøje kontrolleret inkluderingssti; se info-hjælpen\n"
-#~ "  -nostdinc                 Søg ikke i systeminkluderingskataloger\n"
-#~ "                             (kataloger angivet med -isystem søges dog stadig)\n"
-#~ "  -nostdinc++               Søg ikke i systeminkluderingskataloger til C++\n"
  #~ "  -o <fil>                  Send uddata til <fil>\n"
  #~ "  -pedantic                 Fremkom med alle advarsler påkrævet for nøje ISO C\n"
  #~ "  -pedantic-errors          Behandl '-pedantic'-advarsler som fejl\n"
diff --git a/gcc/po/fr.po b/gcc/po/fr.po

index 372552a..b56d975 100644 (file)
--- a/gcc/po/fr.po
+++ b/gcc/po/fr.po
@@ -122,10 +122,10 @@
  #
  msgid ""
  msgstr ""
-"Project-Id-Version: gcc 6.1-b20160131\n"
+"Project-Id-Version: gcc 6.1.0\n"
  "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n"
  "POT-Creation-Date: 2016-04-21 15:24+0000\n"
-"PO-Revision-Date: 2016-03-17 00:28+0100\n"
+"PO-Revision-Date: 2016-06-02 00:10+0200\n"
  "Last-Translator: Stéphane Aulery <lkppo@free.fr>\n"
  "Language-Team: French <traduc@traduc.org>\n"
  "Language: fr\n"
@@ -1203,10 +1203,9 @@ msgid "function returns address of local variable"
  msgstr "cette fonction retourne l'adresse d'une variable locale"
  
  #: gimple-ssa-isolate-paths.c:442 gimple-ssa-isolate-paths.c:287
-#, fuzzy, gcc-internal-format
-#| msgid "function returns address of local variable"
+#, gcc-internal-format
  msgid "function may return address of local variable"
-msgstr "cette fonction retourne l'adresse d'une variable locale"
+msgstr "cette fonction peut retourner l'adresse d'une variable locale"
  
  #: incpath.c:72
  #, c-format
@@ -1253,10 +1252,8 @@ msgid "function might be candidate for attribute %<%s%>"
  msgstr "fonction peut être une candidate pour l'attribut %<%s%>"
  
  #: ipa-pure-const.c:188
-#, fuzzy
-#| msgid "function might be possible candidate for attribute `noreturn'"
  msgid "function might be candidate for attribute %<%s%> if it is known to return normally"
-msgstr "fonction peut être une possible candidate pour l'attribut « norreturn »"
+msgstr "fonction peut être une candidate possible pour l'attribut %<%s%> si elle connue pour returner normallement"
  
  #: langhooks.c:373
  msgid "At top level:"
@@ -1542,16 +1539,12 @@ msgid "function not inlinable"
  msgstr "fonction ne peut être enligne"
  
  #: cif-code.def:60
-#, fuzzy
-#| msgid "function cannot be inline"
  msgid "function body can be overwritten at link time"
-msgstr "fonction ne pas pas être enligne"
+msgstr "le corps de la fonction peut être remplacé durant l’édition de liaison"
  
  #: cif-code.def:64
-#, fuzzy
-#| msgid "function not inlinable"
  msgid "function not inline candidate"
-msgstr "fonction ne peut être enligne"
+msgstr "la fonction n’est pas une candidate à l'enlignage"
  
  #: cif-code.def:68
  msgid "--param large-function-growth limit reached"
@@ -1610,18 +1603,12 @@ msgid "non-call exception handling mismatch"
  msgstr "Autoriser le traitement des exceptions"
  
  #: cif-code.def:113
-#, fuzzy
-#| msgid ""
-#| "\n"
-#| "Target specific options:\n"
  msgid "target specific option mismatch"
-msgstr "Options spécifiques à la cible:\n"
+msgstr "option spécifique de cible incohérente"
  
  #: cif-code.def:117
-#, fuzzy
-#| msgid "optimization level restored"
  msgid "optimization level attribute mismatch"
-msgstr "niveau d'optimisation restauré"
+msgstr "attribut de niveau d’optimisation incohérent"
  
  #: cif-code.def:121
  msgid "callee refers to comdat-local symbols"
@@ -1629,7 +1616,7 @@ msgstr ""
  
  #: cif-code.def:125
  msgid "function attribute mismatch"
-msgstr ""
+msgstr "attribut de fonction incohérent"
  
  #: cif-code.def:129
  #, fuzzy
@@ -1650,7 +1637,7 @@ msgstr "erreur fatale : "
  #. when reporting fatal signal in the compiler.
  #: diagnostic.def:34 diagnostic.def:50
  msgid "internal compiler error: "
-msgstr "erreur interne du compilateur: "
+msgstr "erreur interne du compilateur : "
  
  #. This one is just for counting DK_WARNING promoted to DK_ERROR
  #. due to -Werror and -Werror=warning.
@@ -1660,7 +1647,7 @@ msgstr "erreur : "
  
  #: diagnostic.def:36
  msgid "sorry, unimplemented: "
-msgstr "désolé, pas implanté: "
+msgstr "désolé, pas implanté : "
  
  #: diagnostic.def:37
  msgid "warning: "
@@ -1794,10 +1781,9 @@ msgid "Maximal growth due to inlining of large function (in percent)."
  msgstr "Croissance maximal en raison de l'enlignage d'une grande fonction (en pourcentage)."
  
  #: params.def:193
-#, fuzzy, no-c-format
-#| msgid "The size of function body to be considered large"
+#, no-c-format
  msgid "The size of translation unit to be considered large."
-msgstr "La taille du corps de la fonction est considéré comme étant grande"
+msgstr "La taille de l’unité de traduction considérée comme étant grande."
  
  #: params.def:197
  #, no-c-format
@@ -1987,10 +1973,9 @@ msgid "Loops iterating at least selected number of iterations will get loop alig
  msgstr ""
  
  #: params.def:417
-#, fuzzy, no-c-format
-#| msgid "The maximum number of instructions when automatically inlining"
+#, no-c-format
  msgid "The maximum number of loop iterations we predict statically."
-msgstr "Le nombre maximum d'instructions lorsqu'automatiquement de type enligne"
+msgstr "Le nombre maximum d’itérations de boucle à prédire statiquement."
  
  #: params.def:430
  #, no-c-format
@@ -2044,10 +2029,9 @@ msgid "The maximum expansion factor when copying basic blocks."
  msgstr ""
  
  #: params.def:478
-#, fuzzy, no-c-format
-#| msgid "The maximum number of insns of an unswitched loop"
+#, no-c-format
  msgid "The maximum number of insns to duplicate when unfactoring computed gotos."
-msgstr "Le nombre maximum d'insns d'une boucle sans branchement"
+msgstr "Le nombre maximum d'insns à dupliquer lors des supressions de goto."
  
  #: params.def:484
  #, no-c-format
@@ -2055,10 +2039,9 @@ msgid "The maximum length of path considered in cse."
  msgstr "La longueur maximale des chemins considérés dans cse."
  
  #: params.def:488
-#, fuzzy, no-c-format
-#| msgid "The maximum number of instructions for the RTL inliner"
+#, no-c-format
  msgid "The maximum instructions CSE process before flushing."
-msgstr "Le nombre maximum d'instructions pour la fonction d'enlignage RTL"
+msgstr "Le nombre maximum d'instructions de processus CSE avant vidage du buffer."
  
  #: params.def:495
  #, no-c-format
@@ -2133,10 +2116,9 @@ msgid "Target block's relative execution frequency (as a percentage) required to
  msgstr ""
  
  #: params.def:586 params.def:596
-#, fuzzy, no-c-format
-#| msgid "The maximum number of incoming edges to consider for crossjumping"
+#, no-c-format
  msgid "The maximum number of blocks in a region to be considered for interblock scheduling."
-msgstr "Le nombre maximum de bordures à considérer pour les sauts croisés"
+msgstr "Le nombre maximum de blocs dans une région à considérer pour la gestion des interblocages."
  
  #: params.def:591 params.def:601
  #, fuzzy, no-c-format
@@ -2329,10 +2311,9 @@ msgid "size of tiles for loop blocking."
  msgstr ""
  
  #: params.def:842
-#, fuzzy, no-c-format
-#| msgid "The maximum number of peelings of a single loop"
+#, no-c-format
  msgid "maximum number of parameters in a SCoP."
-msgstr "Le nombre maximum de passes de réduction d'une boucle simple"
+msgstr "Le nombre maximum de paramètres dans un scope."
  
  #: params.def:849
  #, no-c-format
@@ -2340,10 +2321,9 @@ msgid "maximum number of basic blocks per function to be analyzed by Graphite."
  msgstr ""
  
  #: params.def:856
-#, fuzzy, no-c-format
-#| msgid "The maximum number of peelings of a single loop"
+#, no-c-format
  msgid "maximum number of arrays per scop."
-msgstr "Le nombre maximum de passes de réduction d'une boucle simple"
+msgstr "Le nombre maximum de tableaux par scope."
  
  #: params.def:863
  #, no-c-format
@@ -2351,10 +2331,9 @@ msgid "minimal number of loops per function to be analyzed by Graphite."
  msgstr ""
  
  #: params.def:868
-#, fuzzy, no-c-format
-#| msgid "The maximum number of insns of an unswitched loop"
+#, no-c-format
  msgid "maximum number of isl operations, 0 means unlimited"
-msgstr "Le nombre maximum d'insns d'une boucle sans branchement"
+msgstr "Le nombre maximum d'opérations isl, 0 pour illimité"
  
  #: params.def:874
  #, no-c-format
@@ -2536,16 +2515,14 @@ msgid "Maximum length of candidate scans for straight-line strength reduction."
  msgstr "Exécuter un réduction en force des optimisations"
  
  #: params.def:1102
-#, fuzzy, no-c-format
-#| msgid "Enable stack probing"
+#, no-c-format
  msgid "Enable asan stack protection."
-msgstr "Autoriser le sondage de la pile"
+msgstr "Autoriser la protection de pile asan"
  
  #: params.def:1107
-#, fuzzy, no-c-format
-#| msgid "Enable parallel instructions"
+#, no-c-format
  msgid "Enable asan globals protection."
-msgstr "Autoriser les instructions parallèles"
+msgstr "Autoriser la protection des constantes asan."
  
  #: params.def:1112
  #, fuzzy, no-c-format
diff --git a/gcc/po/ru.po b/gcc/po/ru.po

index cdcacf6..e894d2f 100644 (file)
--- a/gcc/po/ru.po
+++ b/gcc/po/ru.po
@@ -2,25 +2,26 @@
  # Copyright (C) 2006 Free Software Foundation, Inc.
  # This file is distributed under the same license as the gcc package.
  #
-# Nadezhda Vyukova <niva@niisi.msk.ru>, 2006.
+# Nadezhda Vyukova <qniva@yandex.ru>, 2006, 2014.
  # Nickolay V. Shmyrev <nshmyrev@yandex.ru>, 2008.
  # Pavel Maryanov <acid_jack@ukr.net>, 2006, 2008.
  # Yuri Kozlov <yuray@komyakino.ru>, 2011.
-# Pavel Maryanov <acid@jack.kiev.ua>, 2012, 2013.
+# Pavel Maryanov <acid@jack.kiev.ua>, 2012.
+# Vladimir Galatenko <galat@niisi.msk.ru>, 2016.
  msgid ""
  msgstr ""
-"Project-Id-Version: gcc 4.8.0\n"
+"Project-Id-Version: gcc 6.1.0\n"
  "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n"
  "POT-Creation-Date: 2016-04-21 15:24+0000\n"
-"PO-Revision-Date: 2013-07-02 16:00+0200\n"
+"PO-Revision-Date: 2016-05-25 15:46+0300\n"
  "Last-Translator: Pavel Maryanov <acid@jack.kiev.ua>\n"
-"Language-Team: Russian <gnu@mx.ru>\n"
+"Language-Team: Russian <gnu@d07.ru>\n"
  "Language: ru\n"
  "MIME-Version: 1.0\n"
  "Content-Type: text/plain; charset=UTF-8\n"
  "Content-Transfer-Encoding: 8bit\n"
  "Plural-Forms: nplurals=3; plural=(n%10==1 && n%100!=11 ? 0 : n%10>=2 && n%10<=4 && (n%100<10 || n%100>=20) ? 1 : 2);\n"
-"X-Generator: Poedit 1.5.5\n"
+"X-Generator: Poedit 1.8.7.1\n"
  
  #: cfgrtl.c:2654
  msgid "flow control insn inside a basic block"
@@ -44,9 +45,9 @@ msgid "[cannot find %s]"
  msgstr "[не найдена программа %s]"
  
  #: collect2.c:1557
-#, fuzzy, c-format
+#, c-format
  msgid "collect2 version %s\n"
-msgstr "collect2 версия %s"
+msgstr "collect2 версия %s\n"
  
  #: collect2.c:1664
  #, c-format
@@ -96,19 +97,18 @@ msgstr ""
  "вывод ldd с конструкторами/деструкторами.\n"
  
  #: cprop.c:1738
-#, fuzzy
  msgid "const/copy propagation disabled"
-msgstr "ÐºÐ»Ñ\8eÑ\87 -g Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð¾Ñ\82ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¾ Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82 Ð¸ ÐºÐ¾Ð¿Ð¸Ð¹"
  
  #: diagnostic.c:212
-#, fuzzy, c-format
+#, c-format
  msgid "%s: all warnings being treated as errors"
-msgstr "%s: Ð²Ñ\81Ðµ Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ñ\8f Ñ\81Ñ\87Ð¸Ñ\82Ð°Ñ\82Ñ\8c Ð¾Ñ\88Ð¸Ð±ÐºÐ°Ð¼Ð¸\n"
+msgstr "%s: Ð²Ñ\81Ðµ Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ñ\8f Ñ\81Ñ\87Ð¸Ñ\82Ð°Ñ\8eÑ\82Ñ\81Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ°Ð¼Ð¸"
  
  #: diagnostic.c:217
-#, fuzzy, c-format
+#, c-format
  msgid "%s: some warnings being treated as errors"
-msgstr "%s: Ð½ÐµÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐµ Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ñ\8f Ñ\81Ñ\87Ð¸Ñ\82Ð°Ñ\82Ñ\8c Ð¾Ñ\88Ð¸Ð±ÐºÐ°Ð¼Ð¸\n"
+msgstr "%s: Ð½ÐµÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐµ Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ñ\8f Ñ\81Ñ\87Ð¸Ñ\82Ð°Ñ\8eÑ\82Ñ\81Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ°Ð¼Ð¸"
  
  #: diagnostic.c:292 input.c:169 c-family/c-opts.c:1310 cp/error.c:1193
  #: fortran/cpp.c:576 fortran/error.c:998 fortran/error.c:1018
@@ -127,6 +127,10 @@ msgstr "компиляция прервана из-за -fmax-errors=%u.\n"
  
  #: diagnostic.c:483
  #, fuzzy, c-format
+#| msgid ""
+#| "Please submit a full bug report,\n"
+#| "with preprocessed source if appropriate.\n"
+#| "See %s for instructions.\n"
  msgid ""
  "Please submit a full bug report,\n"
  "with preprocessed source if appropriate.\n"
@@ -137,6 +141,7 @@ msgstr ""
  
  #: diagnostic.c:489
  #, fuzzy, c-format
+#| msgid "Use fp double instructions"
  msgid "See %s for instructions.\n"
  msgstr "Использовать инструкции двойной точности плавающих вычислений"
  
@@ -302,8 +307,9 @@ msgstr "  --target-help            Показать специфические 
  
  #: gcc.c:3387
  #, fuzzy
+#| msgid "  --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n"
  msgid "  --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...].\n"
-msgstr "  --help={target|optimizers|warnings|params|[^]{joined|separate|undocumented}}[,...]\n"
+msgstr "  --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n"
  
  #: gcc.c:3388
  #, fuzzy
@@ -367,12 +373,15 @@ msgstr "  -print-prog-name=<прог>  Показать полное имя ко
  
  #: gcc.c:3399
  #, fuzzy
+#| msgid ""
+#| "  -print-multiarch         Display the target's normalized GNU triplet, used as\n"
+#| "                           a component in the library path\n"
  msgid ""
  "  -print-multiarch         Display the target's normalized GNU triplet, used as\n"
  "                           a component in the library path.\n"
  msgstr ""
-"  -print-multi-lib         Показать соответствие между ключами и каталогами\n"
-"                           Ð¿Ð¾Ð¸Ñ\81ÐºÐ° библиотек\n"
+"  -print-multiarch         Показать триплет GNU, используемый как компонент маршрутных\n"
+"                           Ð¸Ð¼ÐµÐ½ библиотек\n"
  
  #: gcc.c:3402
  #, fuzzy
@@ -554,13 +563,15 @@ msgstr "  -o <файл>                Записать результат в <
  
  #: gcc.c:3434
  #, fuzzy
+#| msgid "  -pie                     Create a position independent executable\n"
  msgid "  -pie                     Create a position independent executable.\n"
-msgstr "Генерировать позиционно-независимый код для выполняемых модулей, если возможно (режим large)"
+msgstr "  -pie                     Генерировать позиционно-независимый код для выполняемых модулей\n"
  
  #: gcc.c:3435
  #, fuzzy
+#| msgid "  -shared                  Create a shared library\n"
  msgid "  -shared                  Create a shared library.\n"
-msgstr "  --javap\t\t  Вывести результат в формате 'javap'\n"
+msgstr "  -shared                  Создать разделяемую библиотеку\n"
  
  #: gcc.c:3436
  #, fuzzy
@@ -593,9 +604,9 @@ msgstr ""
  "передаются процессам, запускаемым %s. Для передачи ключей этим процессам, используйте ключи -W<буква>.\n"
  
  #: gcc.c:5876
-#, fuzzy, c-format
+#, c-format
  msgid "Processing spec (%s), which is '%s'\n"
-msgstr "Обработка спецификации %c%s%c, т.е. '%s'\n"
+msgstr "Обработка спецификации (%s), т.е. '%s'\n"
  
  #: gcc.c:6580
  #, c-format
@@ -878,12 +889,12 @@ msgstr ""
  "\n"
  
  #: gcov.c:472
-#, fuzzy, c-format
+#, c-format
  msgid ""
  "Usage: gcov [OPTION]... SOURCE|OBJ...\n"
  "\n"
  msgstr ""
-"Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ: gcov [Ð\9aÐ\9bÐ®Ð§]... Ð\92Ð¥Ð\9eÐ\94Ð\9dÐ\9eÐ\99_ФАЙЛ...\n"
+"Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ: gcov [Ð\9aÐ\9bÐ®Ð§]... Ð\98Ð¡Ð¥Ð\9eÐ\94Ð\9dÐ«Ð\99/Ð\9eÐ\91ÐªÐ\95Ð\9aÐ¢Ð\9dÐ«Ð\99 ФАЙЛ...\n"
  "\n"
  
  #: gcov.c:473
@@ -969,14 +980,16 @@ msgid "  -p, --preserve-paths            Preserve all pathname components\n"
  msgstr "  -p, --preserve-paths            Сохранить все компоненты полного имени\n"
  
  #: gcov.c:488
-#, fuzzy, c-format
+#, c-format
  msgid "  -r, --relative-only             Only show data for relative sources\n"
-msgstr "  -a, --all-blocks                Показать сведения для всех блоков\n"
+msgstr ""
+"  -r, --relative-only             Показать данные только для исходных текстов\n"
+"                                    с относительными маршрутами\n"
  
  #: gcov.c:489
  #, c-format
  msgid "  -s, --source-prefix DIR         Source prefix to elide\n"
-msgstr ""
+msgstr "  -s, --source-prefix КАТАЛОГ     Префикс исходных текстов\n"
  
  #: gcov.c:490
  #, c-format
@@ -994,24 +1007,24 @@ msgid "gcov %s%s\n"
  msgstr "gcov %s%s\n"
  
  #: gcov.c:794
-#, fuzzy, c-format
+#, c-format
  msgid "Creating '%s'\n"
-msgstr "%s:создание '%s'\n"
+msgstr "Создание '%s'\n"
  
  #: gcov.c:797
-#, fuzzy, c-format
+#, c-format
  msgid "Error writing output file '%s'\n"
-msgstr "%s:ошибка записи в выходной файл '%s'\n"
+msgstr "Ошибка записи в выходной файл '%s'\n"
  
  #: gcov.c:801
-#, fuzzy, c-format
+#, c-format
  msgid "Could not open output file '%s'\n"
-msgstr "%s:ошибка открытия выходного файла '%s'\n"
+msgstr "Ошибка открытия выходного файла '%s'\n"
  
  #: gcov.c:806
-#, fuzzy, c-format
+#, c-format
  msgid "Removing '%s'\n"
-msgstr "[Выход из %s]\n"
+msgstr "Удаление '%s'\n"
  
  #: gcov.c:834 gcov.c:890
  #, c-format
@@ -1026,6 +1039,7 @@ msgstr "%s: Ошибка открытия выходного файла: %s\n"
  
  #: gcov.c:1139
  #, fuzzy, c-format
+#| msgid "%s:source file is newer than graph file '%s'\n"
  msgid "%s:source file is newer than notes file '%s'\n"
  msgstr "%s:исходный файл новее чем файл графа '%s'\n"
  
@@ -1037,11 +1051,13 @@ msgstr "(для каждого файла исходных текстов соо
  
  #: gcov.c:1169
  #, fuzzy, c-format
+#| msgid "%s:cannot open graph file\n"
  msgid "%s:cannot open notes file\n"
  msgstr "%s:ошибка открытия графического файла\n"
  
  #: gcov.c:1175
  #, fuzzy, c-format
+#| msgid "%s:not a gcov data file\n"
  msgid "%s:not a gcov notes file\n"
  msgstr "%s:не файл данных gcov\n"
  
@@ -1082,6 +1098,7 @@ msgstr "%s:версия '%.4s', предпочтительна версия '%.4
  
  #: gcov.c:1417
  #, fuzzy, c-format
+#| msgid "%s:stamp mismatch with graph file\n"
  msgid "%s:stamp mismatch with notes file\n"
  msgstr "%s:штамп не соответствует графическому файлу\n"
  
@@ -1196,9 +1213,9 @@ msgid "unconditional %2d never executed\n"
  msgstr "безусловный переход %2d ни разу не выполнялся\n"
  
  #: gcov.c:2424
-#, fuzzy, c-format
+#, c-format
  msgid "Cannot open source file %s\n"
-msgstr "%s:ошибка открытия исходного файла\n"
+msgstr "Ошибка открытия исходного файла %s\n"
  
  #: gcse.c:2567
  msgid "PRE disabled"
@@ -1260,14 +1277,12 @@ msgid "'"
  msgstr "»"
  
  #: ipa-pure-const.c:187
-#, fuzzy
  msgid "function might be candidate for attribute %<%s%>"
-msgstr "%Jфункции, возможно, следует задать атрибут %<noreturn%>"
+msgstr "функции, возможно, следует задать атрибут %<%s%>"
  
  #: ipa-pure-const.c:188
-#, fuzzy
  msgid "function might be candidate for attribute %<%s%> if it is known to return normally"
-msgstr "%Jфункции, возможно, следует задать атрибут %<noreturn%>"
+msgstr "функции, возможно, следует задать атрибут %<%s%>, если она нормально возвращает управление"
  
  #: langhooks.c:373
  msgid "At top level:"
@@ -1345,10 +1360,12 @@ msgstr ""
  msgid "Same as %s.  Use the latter option instead."
  msgstr ""
  
+#
  #: opts.c:1136
  #, fuzzy, c-format
+#| msgid "(%s %s %s %s %s"
  msgid "%s  Same as %s."
-msgstr "(%s %s %s %s"
+msgstr "(%s %s %s %s %s"
  
  #: opts.c:1207
  msgid "[default]"
@@ -1368,9 +1385,10 @@ msgid " No options with the desired characteristics were found\n"
  msgstr " Не найдено ключей с требуемыми характеристиками\n"
  
  #: opts.c:1246
-#, c-format
+#, fuzzy, c-format
+#| msgid " None found.  Use --help=%s to show *all* the options supported by the %s front-end\n"
  msgid " None found.  Use --help=%s to show *all* the options supported by the %s front-end.\n"
-msgstr ""
+msgstr " Не найдено.  Задайте --help=%s для вывода *всех* ключей, поддерживаемых для языка %s\n"
  
  #: opts.c:1252
  #, c-format
@@ -1379,7 +1397,7 @@ msgstr " Все ключи с требуемыми характеристика
  
  #: opts.c:1337
  msgid "The following options are target specific"
-msgstr "Следующие ключи зависят от целевой архитектуры"
+msgstr "Ð¡Ð»ÐµÐ´Ñ\83Ñ\8eÑ\89Ð¸Ðµ ÐºÐ»Ñ\8eÑ\87Ð¸ Ð½Ðµ Ð·Ð°Ð²Ð¸Ñ\81Ñ\8fÑ\82 Ð¾Ñ\82 Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð¹ Ð°Ñ\80Ñ\85Ð¸Ñ\82ÐµÐºÑ\82Ñ\83Ñ\80Ñ\8b"
  
  #: opts.c:1340
  msgid "The following options control compiler warning messages"
@@ -1410,14 +1428,12 @@ msgid "The following options are not documented"
  msgstr "Следующие ключи не документированы"
  
  #: opts.c:1370
-#, fuzzy
  msgid "The following options take separate arguments"
-msgstr "Ð¡Ð»ÐµÐ´Ñ\83Ñ\8eÑ\89Ð¸Ðµ ÐºÐ»Ñ\8eÑ\87Ð¸ Ð½Ðµ Ð´Ð¾ÐºÑ\83Ð¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ð½ы"
+msgstr "Ð¡Ð»ÐµÐ´Ñ\83Ñ\8eÑ\89Ð¸Ðµ ÐºÐ»Ñ\8eÑ\87Ð¸ Ð¿Ñ\80Ð¸Ð½Ð¸Ð¼Ð°Ñ\8eÑ\82 Ñ\80Ð°Ð·Ð´ÐµÐ»Ñ\8cÐ½Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82ы"
  
  #: opts.c:1372
-#, fuzzy
  msgid "The following options take joined arguments"
-msgstr "Ð¡Ð»ÐµÐ´Ñ\83Ñ\8eÑ\89Ð¸Ðµ ÐºÐ»Ñ\8eÑ\87Ð¸ Ð½Ðµ Ð´Ð¾ÐºÑ\83Ð¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ð½ы"
+msgstr "Ð¡Ð»ÐµÐ´Ñ\83Ñ\8eÑ\89Ð¸Ðµ ÐºÐ»Ñ\8eÑ\87Ð¸ Ð¿Ñ\80Ð¸Ð½Ð¸Ð¼Ð°Ñ\8eÑ\82 Ð¾Ð±Ñ\8aÐµÐ´Ð¸Ð½ÐµÐ½Ð½Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82ы"
  
  #: opts.c:1383
  msgid "The following options are language-related"
@@ -1434,7 +1450,7 @@ msgstr "Модули"
  #: plugin.c:828
  #, c-format
  msgid "*** WARNING *** there are active plugins, do not report this as a bug unless you can reproduce it without enabling any plugins.\n"
-msgstr ""
+msgstr "*** ПРЕДУПРЕЖДЕНИЕ *** имеются активные плагины, сообщайте о данной ошибке, только если вы можете воспроизвести ее без включения каких-либо плагинов.\n"
  
  #. It's the compiler's fault.
  #: reload1.c:6113
@@ -1447,9 +1463,8 @@ msgid "VOIDmode on an output"
  msgstr "режим VOID выходного потока"
  
  #: reload1.c:8770
-#, fuzzy
  msgid "failure trying to reload:"
-msgstr "Ð\9eÑ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80Ð¸ Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð¾Ð¹ Ð¿Ð¾Ð¿Ñ\8bÑ\82ÐºÐµ Ð·Ð°Ð³Ñ\80Ñ\83Ð·ÐºÐ¸:"
+msgstr "Ð\9eÑ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80Ð¸ Ð¿ÐµÑ\80ÐµÐ·Ð°Ð³Ñ\80Ñ\83Ð·ÐºÐµ (reload):"
  
  #: rtl-error.c:116
  msgid "unrecognizable insn:"
@@ -1485,7 +1500,7 @@ msgstr "collect: перекомпиляция %s\n"
  #: tlink.c:627
  #, c-format
  msgid "collect: tweaking %s in %s\n"
-msgstr ""
+msgstr "collect: подбор %s в %s\n"
  
  #: tlink.c:844
  #, c-format
@@ -1547,8 +1562,9 @@ msgstr "функция не подлежит inline-подстановке"
  
  #: cif-code.def:43
  #, fuzzy
+#| msgid "%qE is not initialized"
  msgid "caller is not optimized"
-msgstr "параметр %qD инициализирован"
+msgstr "%qE не инициализирован"
  
  #: cif-code.def:47
  msgid "function body not available"
@@ -1563,14 +1579,12 @@ msgid "function not inlinable"
  msgstr "inline-подстановка функции невозможна"
  
  #: cif-code.def:60
-#, fuzzy
  msgid "function body can be overwritten at link time"
-msgstr "Ñ\82ÐµÐ»Ð¾ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð½ÐµÐ´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð¾"
+msgstr "Ñ\82ÐµÐ»Ð¾ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¿ÐµÑ\80ÐµÐ¿Ð¸Ñ\81Ð°Ð½Ð¾ Ð²Ð¾ Ð²Ñ\80ÐµÐ¼Ñ\8f ÐºÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²ÐºÐ¸"
  
  #: cif-code.def:64
-#, fuzzy
  msgid "function not inline candidate"
-msgstr "inline-подстановка функции невозможна"
+msgstr "функция не является кандидатом для inline-подстановки"
  
  #: cif-code.def:68
  msgid "--param large-function-growth limit reached"
@@ -1614,27 +1628,23 @@ msgstr "inline-функции, переопределённые как extern, 
  
  #: cif-code.def:100
  msgid "indirect function call with a yet undetermined callee"
-msgstr ""
+msgstr "косвенный вызов функции с неопределённой вызываемой функцией"
  
  #: cif-code.def:104
  msgid "exception handling personality mismatch"
-msgstr ""
+msgstr "несоответствие программ индивидуальности при обработке исключений"
  
  #: cif-code.def:109
-#, fuzzy
  msgid "non-call exception handling mismatch"
-msgstr "Ð\90ÐºÑ\82Ð¸Ð²Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82ÐºÑ\83 исключительных ситуаций"
+msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ð² Ð¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82ÐºÐµ non-call исключительных ситуаций"
  
  #: cif-code.def:113
-#, fuzzy
  msgid "target specific option mismatch"
-msgstr ""
-"\n"
-"Ключи, специфические для целевой платформы:\n"
+msgstr "несовпадение ключей, специфических для целевой платформы"
  
  #: cif-code.def:117
  msgid "optimization level attribute mismatch"
-msgstr ""
+msgstr "несовпадение атрибута уровня оптимизации"
  
  #: cif-code.def:121
  msgid "callee refers to comdat-local symbols"
@@ -1642,14 +1652,16 @@ msgstr ""
  
  #: cif-code.def:125
  #, fuzzy
-#| msgid "multiple function type attributes specified"
+#| msgid "optimization level attribute mismatch"
  msgid "function attribute mismatch"
-msgstr "Ð·Ð°Ð´Ð°Ð½Ð¾ Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ñ\82Ð¸Ð¿Ð° Ñ\84Ñ\83Ð½Ðºции"
+msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¿Ð°Ð´ÐµÐ½Ð¸Ðµ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° Ñ\83Ñ\80Ð¾Ð²Ð½Ñ\8f Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°ции"
  
+#
  #: cif-code.def:129
  #, fuzzy
+#| msgid "invalid function in call statement"
  msgid "caller function contains cilk spawn"
-msgstr "некорректный знак %qc в ограничителе"
+msgstr "некорректная функция в операторе вызова"
  
  #: cif-code.def:133
  #, fuzzy
@@ -1705,9 +1717,10 @@ msgid "permerror: "
  msgstr "permerror: "
  
  #: params.def:49
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximal estimated outcome of branch considered predictable"
  msgid "Maximal estimated outcome of branch considered predictable."
-msgstr ""
+msgstr "Максимальная оценка перехода по ветвлению, которое считается предсказанным"
  
  #: params.def:54
  #, no-c-format
@@ -1758,18 +1771,21 @@ msgstr "Выполнять рекурсивную inline-подстановку,
  
  #: params.def:116
  #, fuzzy, no-c-format
+#| msgid "The maximum number of nested indirect inlining performed by early inliner"
  msgid "The maximum number of nested indirect inlining performed by early inliner."
-msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ ÐºÐ¾Ð¼Ð°Ð½Ð´ Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸, Ð¿Ñ\80Ð¸Ð³Ð¾Ð´Ð½Ð¾Ð¹ Ð´Ð»Ñ\8f inline-Ð¿Ð¾Ð´Ñ\81Ñ\82Ð°Ð½Ð¾Ð²ÐºÐ¸"
+msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð²Ð»Ð¾Ð¶ÐµÐ½Ð½Ñ\8bÑ\85 ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ñ\8bÑ\85 inline-Ð¿Ð¾Ð´Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¾Ðº, Ð²Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÐµÐ¼Ñ\8bÑ\85 Ð¿Ñ\80Ð¸ Ð¿ÐµÑ\80Ð²Ð¾Ð¼ Ð¿Ñ\80Ð¾Ñ\85Ð¾Ð´Ðµ Ð¿Ð¾Ð´Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¾Ðº"
  
  #: params.def:122
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Probability that COMDAT function will be shared with different compilation unit"
  msgid "Probability that COMDAT function will be shared with different compilation unit."
-msgstr ""
+msgstr "Вероятность того, что функция COMDAT будет разделена с другой единицей компиляции"
  
  #: params.def:128
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen"
  msgid "Maximum probability of the entry BB of split region (in percent relative to entry BB of the function) to make partial inlining happen."
-msgstr ""
+msgstr "Максимальная вероятность входного базового блока разбиваемого региона (в процентах по отношению к входному блоку функции) для выполнения частичной inline-подстановки"
  
  #: params.def:135
  #, fuzzy, no-c-format
@@ -1778,9 +1794,10 @@ msgid "If -fvariable-expansion-in-unroller is used, the maximum number of times
  msgstr "При использовании -fvariable-expansion-in-unroller - максимальное число копий каждой переменной, которое может быть создано при развертке цикла"
  
  #: params.def:141
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization"
  msgid "If -ftree-vectorize is used, the minimal loop bound of a loop to be considered for vectorization."
-msgstr ""
+msgstr "При включенном -ftree-vectorize, минимальное число итераций цикла, пригодного для векторизации"
  
  #: params.def:152
  #, fuzzy, no-c-format
@@ -1802,8 +1819,9 @@ msgstr "Максимальный размер списка ждущих опер
  
  #: params.def:180
  #, fuzzy, no-c-format
+#| msgid "The maximum number of backtrack attempts the scheduler should make when modulo scheduling a loop"
  msgid "The maximum number of backtrack attempts the scheduler should make when modulo scheduling a loop."
-msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð² Ñ\80Ð°Ð·Ð²ÐµÑ\80Ð½Ñ\83Ñ\82Ð¾Ð¼ Ñ\86Ð¸ÐºÐ»Ðµ"
+msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¿Ð¾Ð¿Ñ\8bÑ\82Ð¾Ðº Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð¿Ñ\80Ð¸ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ð½Ð¾Ð¹ ÐºÐ¾Ð½Ð²ÐµÐ¹ÐµÑ\80Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ (Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ð¿Ð¾ Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8e) Ñ\86Ð¸ÐºÐ»Ð°"
  
  #: params.def:185
  #, fuzzy, no-c-format
@@ -1825,18 +1843,21 @@ msgstr "Размер тела \"большой\" функции"
  
  #: params.def:197
  #, fuzzy, no-c-format
+#| msgid "How much can given compilation unit grow because of the inlining (in percent)"
  msgid "How much can given compilation unit grow because of the inlining (in percent)."
  msgstr "Максимальный рост объема кода для единицы компиляции в результате inline-подстановок (в процентах)"
  
  #: params.def:201
  #, fuzzy, no-c-format
+#| msgid "How much can given compilation unit grow because of the interprocedural constant propagation (in percent)"
  msgid "How much can given compilation unit grow because of the interprocedural constant propagation (in percent)."
-msgstr "Максимальный рост объема кода для единицы компиляции в результате inline-подстановок (в процентах)"
+msgstr "Максимальный рост объема кода для единицы компиляции в результате межпроцедурного распространения констант (в процентах)"
  
  #: params.def:205
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximal estimated growth of function body caused by early inlining of single call"
  msgid "Maximal estimated growth of function body caused by early inlining of single call."
-msgstr ""
+msgstr "Максимальная оценка роста тела функции в результате ранней inline-подстановки одного вызова"
  
  #: params.def:209
  #, fuzzy, no-c-format
@@ -1858,8 +1879,9 @@ msgstr "Максимальный объем памяти для работы GCS
  
  #: params.def:227
  #, fuzzy, no-c-format
+#| msgid "The maximum ratio of insertions to deletions of expressions in GCSE"
  msgid "The maximum ratio of insertions to deletions of expressions in GCSE."
-msgstr "Максимальное число инструкций в развернутом цикле"
+msgstr "Максимальное отношение числа вставок к числу удалений выражений при глобальном исключении общих подвыражений (GCSE)"
  
  #: params.def:238
  #, fuzzy, no-c-format
@@ -1874,19 +1896,22 @@ msgid "The threshold ratio of critical edges execution count that permit perform
  msgstr "Пороговое соотношение счётчиков выполнения критических дуг, при котором после прохода reload может выполняться частичное удаление избыточных операций"
  
  #: params.def:253
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations"
  msgid "Scaling factor in calculation of maximum distance an expression can be moved by GCSE optimizations."
-msgstr ""
+msgstr "Масштабирующий множитель при вычислении максимального расстояния, на которое выражение может быть смещено при GCSE"
  
  #: params.def:259
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Cost at which GCSE optimizations will not constraint the distance an expression can travel"
  msgid "Cost at which GCSE optimizations will not constraint the distance an expression can travel."
-msgstr ""
+msgstr "Стоимость, при которой в GCSE не будет ограничиваться расстояние перемещения выражений"
  
  #: params.def:267
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximum depth of search in the dominator tree for expressions to hoist"
  msgid "Maximum depth of search in the dominator tree for expressions to hoist."
-msgstr ""
+msgstr "Максимальная глубина поиска в дереве доминаторов для поднятия выражения"
  
  #: params.def:275
  #, no-c-format
@@ -1925,8 +1950,9 @@ msgstr "Максимальный коэффициент раскатки цик
  
  #: params.def:313
  #, fuzzy, no-c-format
+#| msgid "The maximum number of iterations through CFG to extend regions"
  msgid "The maximum number of branches on the path through the peeled sequence."
-msgstr "Ð\97Ð°Ð´Ð°Ñ\82Ñ\8c Ð¼Ð°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ñ\82ÐµÑ\80Ð°Ñ\86Ð¸Ð¹ Ð´Ð»Ñ\8f RPTS"
+msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ñ\82ÐµÑ\80Ð°Ñ\86Ð¸Ð¹ Ð¿Ð¾ CFG Ð´Ð»Ñ\8f Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ñ\8f Ñ\80ÐµÐ³Ð¸Ð¾Ð½Ð¾Ð²"
  
  #: params.def:318
  #, fuzzy, no-c-format
@@ -1948,8 +1974,9 @@ msgstr "Максимальное число инструкций в раскат
  
  #: params.def:333
  #, fuzzy, no-c-format
+#| msgid "The maximum depth of a loop nest we completely peel"
  msgid "The maximum depth of a loop nest we completely peel."
-msgstr "Максимальное число инструкций в полностью раскатанном цикле"
+msgstr "Максимальное число инструкций в цикле, который полностью раскатывается"
  
  #: params.def:339
  #, fuzzy, no-c-format
@@ -1961,7 +1988,7 @@ msgstr "Максимальное число инструкций в разомк
  #, fuzzy, no-c-format
  #| msgid "The maximum number of unswitchings in a single loop"
  msgid "The maximum number of unswitchings in a single loop."
-msgstr "Максимальный коэффициент размыкания цикла"
+msgstr "Максимальный число размыканий одного цикла"
  
  #: params.def:351
  #, fuzzy, no-c-format
@@ -1984,7 +2011,7 @@ msgstr "Множитель для настройки верхней границ
  #: params.def:368
  #, no-c-format
  msgid "The minimum value of stage count that swing modulo scheduler will generate."
-msgstr ""
+msgstr "Минимальное число стадий в конвейеризованном цикле при планировании методом swing modulo scheduling"
  
  #: params.def:372
  #, fuzzy, no-c-format
@@ -2141,18 +2168,21 @@ msgstr "Верхняя граница размера выражений при 
  
  #: params.def:530
  #, fuzzy, no-c-format
+#| msgid "Bound on the complexity of the expressions in the scalar evolutions analyzer"
  msgid "Bound on the complexity of the expressions in the scalar evolutions analyzer."
-msgstr "Ð\92ÐµÑ\80Ñ\85Ð½Ñ\8fÑ\8f Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ð° Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° выражений при анализе эволюции скалярных значений в циклах"
+msgstr "Ð\92ÐµÑ\80Ñ\85Ð½Ñ\8fÑ\8f Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ð° Ñ\81Ð»Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ð¸ выражений при анализе эволюции скалярных значений в циклах"
  
  #: params.def:535
  #, fuzzy, no-c-format
+#| msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check"
  msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alignment check."
-msgstr "Максимальное число проверок времени выполнения, добавляемых в код при векторизации циклов"
+msgstr "Максимальное число проверок времени выполнения, добавляемых в код при векторизации циклов для проверки выравнивания"
  
  #: params.def:540
  #, fuzzy, no-c-format
+#| msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check"
  msgid "Bound on number of runtime checks inserted by the vectorizer's loop versioning for alias check."
-msgstr "Максимальное число проверок времени выполнения, добавляемых в код при векторизации циклов"
+msgstr "Максимальное число проверок времени выполнения, добавляемых в код при векторизации циклов для проверки алиасов"
  
  #: params.def:545
  #, no-c-format
@@ -2184,9 +2214,10 @@ msgid "The maximum number of instructions to search backward when looking for eq
  msgstr "Максимальное число инструкций для обратного просмотра при поиске эквивалентной загрузки в регистр"
  
  #: params.def:581
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Target block's relative execution frequency (as a percentage) required to sink a statement"
  msgid "Target block's relative execution frequency (as a percentage) required to sink a statement."
-msgstr ""
+msgstr "Относительная частота выполнения целевого блока (в процентах), необходимая для погружения инструкции"
  
  #: params.def:586 params.def:596
  #, fuzzy, no-c-format
@@ -2208,18 +2239,20 @@ msgstr "Минимальная вероятность достижения бл
  
  #: params.def:611
  #, fuzzy, no-c-format
+#| msgid "The maximum number of iterations through CFG to extend regions"
  msgid "The maximum number of iterations through CFG to extend regions."
-msgstr "Ð\97Ð°Ð´Ð°Ñ\82Ñ\8c Ð¼Ð°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ñ\82ÐµÑ\80Ð°Ñ\86Ð¸Ð¹ Ð´Ð»Ñ\8f RPTS"
+msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ñ\82ÐµÑ\80Ð°Ñ\86Ð¸Ð¹ Ð¿Ð¾ CFG Ð´Ð»Ñ\8f Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ñ\8f Ñ\80ÐµÐ³Ð¸Ð¾Ð½Ð¾Ð²"
  
  #: params.def:616
  #, fuzzy, no-c-format
+#| msgid "The maximum conflict delay for an insn to be considered for speculative motion"
  msgid "The maximum conflict delay for an insn to be considered for speculative motion."
-msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð² Ð¾Ñ\82Ñ\80ÐµÐ·ÐºÐµ Ð´Ð»Ñ\8f Ð¼ÐµÐ¶Ð´Ñ\83Ð±Ð»Ð¾Ñ\87Ð½Ð¾Ð³Ð¾ Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ð¾Ð²Ð°ния"
+msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð°Ñ\8f Ð¾Ñ\82Ñ\81Ñ\80Ð¾Ñ\87ÐºÐ° ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ð° Ð´Ð»Ñ\8f ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b, Ñ\80Ð°Ñ\81Ñ\81Ð¼Ð°Ñ\82Ñ\80Ð¸Ð²Ð°ÐµÐ¼Ð¾Ð¹ ÐºÐ°Ðº ÐºÐ°Ð½Ð´Ð¸Ð´Ð°Ñ\82 Ð´Ð»Ñ\8f Ñ\81Ð¿ÐµÐºÑ\83Ð»Ñ\8fÑ\82Ð¸Ð²Ð½Ð¾Ð³Ð¾ Ð¿ÐµÑ\80ÐµÐ¼ÐµÑ\89Ðµния"
  
  #: params.def:621
-#, fuzzy, no-c-format
+#, no-c-format
  msgid "The minimal probability of speculation success (in percents), so that speculative insn will be scheduled."
-msgstr "Минимальная вероятность достижения блока для спекулятивного междублочного планирования"
+msgstr "Минимальная вероятность успеха при спекулятивном доступе (в процентах) для планирования спекулятивной команды"
  
  #: params.def:626
  #, no-c-format
@@ -2227,24 +2260,28 @@ msgid "The minimum probability an edge must have for the scheduler to save its s
  msgstr ""
  
  #: params.def:631
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "The maximum size of the lookahead window of selective scheduling"
  msgid "The maximum size of the lookahead window of selective scheduling."
-msgstr ""
+msgstr "Максимальный размер окна при селективном планировании"
  
  #: params.def:636
  #, fuzzy, no-c-format
+#| msgid "Maximum number of times that an insn could be scheduled"
  msgid "Maximum number of times that an insn could be scheduled."
-msgstr "Ð§Ð¸Ñ\81Ð»Ð¾ Ð¾Ñ\82Ð»Ð¾Ð¶ÐµÐ½Ð½Ñ\8bÑ\85 ÐºÐ¾Ð¼Ð°Ð½Ð´, Ð¿Ð¾Ð´Ð»ÐµÐ¶Ð°Ñ\89Ð¸Ñ\85 Ð¿Ñ\80ÐµÐ´Ð²Ð°Ñ\80Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð¼Ñ\83 Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8e"
+msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ðµ ÐºÐ¾Ð»Ð¸Ñ\87ÐµÑ\81Ñ\82Ð²Ð¾ Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ñ\83ÐµÐ¼Ñ\8bÑ\85 Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ð¹ ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b"
  
  #: params.def:641
  #, fuzzy, no-c-format
+#| msgid "Maximum number of instructions in the ready list that are considered eligible for renaming"
  msgid "Maximum number of instructions in the ready list that are considered eligible for renaming."
-msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ ÐºÐ¾Ð¼Ð°Ð½Ð´ Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸, Ð¿Ñ\80Ð¸Ð³Ð¾Ð´Ð½Ð¾Ð¹ Ð´Ð»Ñ\8f inline-Ð¿Ð¾Ð´Ñ\81Ñ\82Ð°Ð½Ð¾Ð²ÐºÐ¸"
+msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ ÐºÐ¾Ð¼Ð°Ð½Ð´ Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð³Ð¾Ñ\82Ð¾Ð²Ñ\8bÑ\85, ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ñ\80Ð°Ñ\81Ñ\81Ð¼Ð°Ñ\82Ñ\80Ð¸Ð²Ð°Ñ\82Ñ\8cÑ\81Ñ\8f ÐºÐ°Ðº ÐºÐ°Ð½Ð´Ð¸Ð´Ð°Ñ\82Ñ\8b Ð½Ð° Ð¿ÐµÑ\80ÐµÐ¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð¸Ðµ"
  
  #: params.def:646
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Minimal distance between possibly conflicting store and load"
  msgid "Minimal distance between possibly conflicting store and load."
-msgstr ""
+msgstr "Минимальная дистанция между возможно конфликтующими записью и чтением"
  
  #: params.def:651
  #, no-c-format
@@ -2294,23 +2331,27 @@ msgstr "Если число  полей в структуре больше да
  
  #: params.def:713
  #, fuzzy, no-c-format
+#| msgid "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass"
  msgid "The maximum number of instructions ready to be issued to be considered by the scheduler during the first scheduling pass."
-msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð² Ð¾Ñ\82Ñ\80ÐµÐ·ÐºÐµ Ð´Ð»Ñ\8f Ð¼ÐµÐ¶Ð´Ñ\83Ð±Ð»Ð¾Ñ\87Ð½Ð¾Ð³Ð¾ планирования"
+msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð³Ð¾Ñ\82Ð¾Ð²Ñ\8bÑ\85 Ðº Ð¸Ñ\81Ð¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8e Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹, Ñ\80Ð°Ñ\81Ñ\81Ð¼Ð°Ñ\82Ñ\80Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÑ\85 Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ð¾Ð²Ñ\89Ð¸ÐºÐ¾Ð¼ Ð½Ð° Ð¿ÐµÑ\80Ð²Ð¾Ð¼ Ð¿Ñ\80Ð¾Ñ\85Ð¾Ð´Ðµ планирования"
  
  #: params.def:719
  #, fuzzy, no-c-format
+#| msgid "Maximum number of active local stores in RTL dead store elimination"
  msgid "Maximum number of active local stores in RTL dead store elimination."
-msgstr "Ð§Ð¸Ñ\81Ð»Ð¾ Ð¾Ñ\82Ð»Ð¾Ð¶ÐµÐ½Ð½Ñ\8bÑ\85 ÐºÐ¾Ð¼Ð°Ð½Ð´, Ð¿Ð¾Ð´Ð»ÐµÐ¶Ð°Ñ\89Ð¸Ñ\85 Ð¿Ñ\80ÐµÐ´Ð²Ð°Ñ\80Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð¼Ñ\83 Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8e"
+msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð°ÐºÑ\82Ð¸Ð²Ð½Ñ\8bÑ\85 Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ð·Ð°Ð¿Ð¸Ñ\81ÐµÐ¹ Ð¿Ñ\80Ð¸ Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ð¸ Ð¼ÐµÑ\80Ñ\82Ð²Ñ\8bÑ\85 Ð·Ð°Ð¿Ð¸Ñ\81ÐµÐ¹ Ð½Ð° RTL-Ð¿Ñ\80ÐµÐ´Ñ\81Ñ\82Ð°Ð²Ð»ÐµÐ½Ð¸Ð¸"
  
  #: params.def:729
  #, fuzzy, no-c-format
+#| msgid "The number of insns executed before prefetch is completed"
  msgid "The number of insns executed before prefetch is completed."
-msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ ÐºÐ¾Ñ\8dÑ\84Ñ\84Ð¸Ñ\86Ð¸ÐµÐ½Ñ\82 Ñ\80Ð°Ð·Ð²ÐµÑ\80Ñ\82ÐºÐ¸ Ñ\86Ð¸ÐºÐ»Ð°"
+msgstr "Ð§Ð¸Ñ\81Ð»Ð¾ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹, Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð½Ñ\8bÑ\85 Ð´Ð¾ Ð·Ð°Ð²ÐµÑ\80Ñ\88ÐµÐ½Ð¸Ñ\8f Ð¿Ñ\80ÐµÐ´Ð²Ñ\8bÐ±Ð¾Ñ\80ÐºÐ¸"
  
  #: params.def:736
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "The number of prefetches that can run at the same time"
  msgid "The number of prefetches that can run at the same time."
-msgstr ""
+msgstr "Число предвыборок, которые могут выполняться одновременно"
  
  #: params.def:743
  #, fuzzy, no-c-format
@@ -2337,34 +2378,39 @@ msgid "Whether to use canonical types."
  msgstr "Использовать ли канонические типы"
  
  #: params.def:773
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximum length of partial antic set when performing tree pre optimization"
  msgid "Maximum length of partial antic set when performing tree pre optimization."
-msgstr ""
+msgstr "Максимальная длина частичного antic-множества при выполнении предоптимизации древовидного представления"
  
  #: params.def:783
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximum size of a SCC before SCCVN stops processing a function"
  msgid "Maximum size of a SCC before SCCVN stops processing a function."
-msgstr ""
+msgstr "Максимальный размер SCC (сильносвязанной компоненты), при котором алгоритм перечисления значений SCCVN завершает обработку функции"
  
  #: params.def:794
-#, fuzzy, no-c-format
+#, no-c-format
  msgid "Maximum number of disambiguations to perform per memory access."
-msgstr "Число отложенных команд, подлежащих предварительному планированию"
+msgstr ""
  
  #: params.def:799
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Max loops number for regional RA"
  msgid "Max loops number for regional RA."
-msgstr ""
+msgstr "Максимальное число циклов для использования распределения регистров по регионам"
  
  #: params.def:804
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Max size of conflict table in MB"
  msgid "Max size of conflict table in MB."
-msgstr ""
+msgstr "Максимальный размер таблицы конфликтов в мегабайтах"
  
  #: params.def:809
  #, fuzzy, no-c-format
+#| msgid "The number of registers in each class kept unused by loop invariant motion"
  msgid "The number of registers in each class kept unused by loop invariant motion."
-msgstr "Ð\9fÑ\80Ð¸ Ð²Ñ\8bÐ½ÐµÑ\81ÐµÐ½Ð¸Ð¸ Ð¸Ð½Ð²Ð°Ñ\80Ð¸Ð°Ð½Ñ\82Ð¾Ð² Ñ\86Ð¸ÐºÐ»Ð° - Ð¼Ð¸Ð½Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð°Ñ\8f Ñ\86ÐµÐ½Ð° Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f, Ñ\80Ð°Ñ\81Ñ\81Ð¼Ð°Ñ\82Ñ\80Ð¸Ð²Ð°ÐµÐ¼Ð¾Ð³Ð¾ ÐºÐ°Ðº Ð´Ð¾Ñ\80Ð¾Ð³Ð¾Ñ\81Ñ\82Ð¾Ñ\8fÑ\89ÐµÐµ "
+msgstr "Ð§Ð¸Ñ\81Ð»Ð¾ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð² Ð² ÐºÐ°Ð¶Ð´Ð¾Ð¼ ÐºÐ»Ð°Ñ\81Ñ\81Ðµ, Ð¾Ñ\81Ñ\82Ð°Ð²Ð»Ñ\8fÐµÐ¼Ñ\8bÑ\85 Ð½ÐµÐ¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÐ¼Ð¸ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÐ½ÐµÑ\81ÐµÐ½Ð¸Ð¸ Ð¸Ð½Ð²Ð°Ñ\80Ð¸Ð°Ð½Ñ\82Ð¾Ð² Ñ\86Ð¸ÐºÐ»Ð°"
  
  #: params.def:814
  #, no-c-format
@@ -2377,34 +2423,40 @@ msgid "Minimal fall-through edge probability in percentage used to add BB to inh
  msgstr ""
  
  #: params.def:827
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "The maximum ratio between array size and switch branches for a switch conversion to take place"
  msgid "The maximum ratio between array size and switch branches for a switch conversion to take place."
-msgstr ""
+msgstr "Максимальное отношение между размером массива и числом веток в переключателе, при котором будет выполнена трансформация переключателя в таблицу"
  
  #: params.def:835
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "size of tiles for loop blocking"
  msgid "size of tiles for loop blocking."
-msgstr ""
+msgstr "размер полос для блочной трансформации циклов"
  
  #: params.def:842
  #, fuzzy, no-c-format
+#| msgid "maximum number of parameters in a SCoP"
  msgid "maximum number of parameters in a SCoP."
-msgstr "максимальное значение параметра %qs равно %u"
+msgstr "максимальное число параметров в SCoP"
  
  #: params.def:849
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "maximum number of basic blocks per function to be analyzed by Graphite"
  msgid "maximum number of basic blocks per function to be analyzed by Graphite."
-msgstr ""
+msgstr "максимальное число базовых блоков в функции, при котором применяются средства Graphite"
  
  #: params.def:856
  #, fuzzy, no-c-format
+#| msgid "maximum number of parameters in a SCoP"
  msgid "maximum number of arrays per scop."
-msgstr "максимальное значение параметра %qs равно %u"
+msgstr "максимальное число параметров в SCoP"
  
  #: params.def:863
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "maximum number of basic blocks per function to be analyzed by Graphite"
  msgid "minimal number of loops per function to be analyzed by Graphite."
-msgstr ""
+msgstr "максимальное число базовых блоков в функции, при котором применяются средства Graphite"
  
  #: params.def:868
  #, fuzzy, no-c-format
@@ -2413,14 +2465,16 @@ msgid "maximum number of isl operations, 0 means unlimited"
  msgstr "Максимальное число инструкций в разомкнутом (unswitched) цикле"
  
  #: params.def:874
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximum number of datarefs in loop for building loop data dependencies"
  msgid "Maximum number of datarefs in loop for building loop data dependencies."
-msgstr ""
+msgstr "максимальное число ссылок на данные для построения циклических зависимостей по данным"
  
  #: params.def:881
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Max basic blocks number in loop for loop invariant motion"
  msgid "Max basic blocks number in loop for loop invariant motion."
-msgstr ""
+msgstr "максимальное число базовых блоков в цикле для вынесения инвариантов цикла"
  
  #: params.def:889
  #, no-c-format
@@ -2434,28 +2488,33 @@ msgstr ""
  
  #: params.def:903
  #, fuzzy, no-c-format
+#| msgid "Maximum number of instructions in basic block to be considered for SLP vectorization"
  msgid "Maximum number of instructions in basic block to be considered for SLP vectorization."
-msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð² Ð¾Ñ\82Ñ\80ÐµÐ·ÐºÐµ Ð´Ð»Ñ\8f Ð¼ÐµÐ¶Ð±Ð»Ð¾Ñ\87Ð½Ð¾Ð³Ð¾ Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f"
+msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð² Ð±Ð°Ð·Ð¾Ð²Ð¾Ð¼ Ð±Ð»Ð¾ÐºÐµ Ð´Ð»Ñ\8f ÐµÐ³Ð¾ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð¸Ð·Ð°Ñ\86Ð¸Ð¸"
  
  #: params.def:908
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Min. ratio of insns to prefetches to enable prefetching for a loop with an unknown trip count"
  msgid "Min. ratio of insns to prefetches to enable prefetching for a loop with an unknown trip count."
-msgstr ""
+msgstr "Минимальное отношение числа инструкций к числу предвыборок для включения предвыборок в циклах с неизвестным числом итераций"
  
  #: params.def:914
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Min. ratio of insns to mem ops to enable prefetching in a loop"
  msgid "Min. ratio of insns to mem ops to enable prefetching in a loop."
-msgstr ""
+msgstr "Минимальное отношение числа инструкций к числу операций с памятью для включения предвыборок в цикле"
  
  #: params.def:921
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Max. size of var tracking hash tables"
  msgid "Max. size of var tracking hash tables."
-msgstr ""
+msgstr "Максимальный размер хеш-таблиц для отслеживания переменных"
  
  #: params.def:929
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Max. recursion depth for expanding var tracking expressions"
  msgid "Max. recursion depth for expanding var tracking expressions."
-msgstr ""
+msgstr "Максимальная глубина рекурсии в раскрытии выражений при отслеживании переменных"
  
  #: params.def:937
  #, no-c-format
@@ -2463,19 +2522,22 @@ msgid "Max. size of loc list for which reverse ops should be added."
  msgstr ""
  
  #: params.def:944
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "The minimum UID to be used for a nondebug insn"
  msgid "The minimum UID to be used for a nondebug insn."
-msgstr ""
+msgstr "Минимальный идентификатор (UID), используемый для неотладочных инструкций"
  
  #: params.def:949
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximum allowed growth of size of new parameters ipa-sra replaces a pointer to an aggregate with"
  msgid "Maximum allowed growth of size of new parameters ipa-sra replaces a pointer to an aggregate with."
-msgstr ""
+msgstr "Максимальный допустимый размер новых параметров, при котором выполняется замена указателя на агрегат при -ftree-sra"
  
  #: params.def:955
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Size in bytes after which thread-local aggregates should be instrumented with the logging functions instead of save/restore pairs"
  msgid "Size in bytes after which thread-local aggregates should be instrumented with the logging functions instead of save/restore pairs."
-msgstr ""
+msgstr "Размер в байтах при превышении которого локальные для потоков агрегаты будут инструментированы функциями журналирования вместо команд сохранения/восстановления"
  
  #: params.def:962
  #, no-c-format
@@ -2488,14 +2550,16 @@ msgid "Maximum size, in storage units, of an aggregate which should be considere
  msgstr ""
  
  #: params.def:974
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximum size of a list of values associated with each parameter for interprocedural constant propagation"
  msgid "Maximum size of a list of values associated with each parameter for interprocedural constant propagation."
-msgstr ""
+msgstr "Максимальный размер списка значений, ассоциированных с каждым параметром, при межпроцедурном распространении констант"
  
  #: params.def:980
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Threshold ipa-cp opportunity evaluation that is still considered beneficial to clone."
  msgid "Threshold ipa-cp opportunity evaluation that is still considered beneficial to clone.."
-msgstr ""
+msgstr "Пороговое значение оценки целесообразности клонирования при выполнении межпроцедурного распространения констант"
  
  #: params.def:986
  #, no-c-format
@@ -2528,54 +2592,64 @@ msgid "Maximum number of statements that will be visited by IPA formal parameter
  msgstr ""
  
  #: params.def:1024
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Number of partitions the program should be split to"
  msgid "Number of partitions the program should be split to."
-msgstr ""
+msgstr "Число партиций для разбиения программы"
  
  #: params.def:1029
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Minimal size of a partition for LTO (in estimated instructions)"
  msgid "Minimal size of a partition for LTO (in estimated instructions)."
-msgstr ""
+msgstr "Минимальный размер (число инструкций в) партиции при разбиении программы во время LTO"
  
  #: params.def:1036
  #, fuzzy, no-c-format
+#| msgid "Maximum number of namespaces to search for alternatives when name lookup fails"
  msgid "Maximum number of namespaces to search for alternatives when name lookup fails."
-msgstr "Максимальный коэффициент развертки цикла"
+msgstr "Максимальное число пространств имен для поиска альтернатив при неуспешном поиске имени"
  
  #: params.def:1043
  #, fuzzy, no-c-format
+#| msgid "Maximum number of conditional store pairs that can be sunk"
  msgid "Maximum number of conditional store pairs that can be sunk."
-msgstr "Ð§Ð¸Ñ\81Ð»Ð¾ Ð¾Ñ\82Ð»Ð¾Ð¶ÐµÐ½Ð½Ñ\8bÑ\85 ÐºÐ¾Ð¼Ð°Ð½Ð´, Ð¿Ð¾Ð´Ð»ÐµÐ¶Ð°Ñ\89Ð¸Ñ\85 Ð¿Ñ\80ÐµÐ´Ð²Ð°Ñ\80Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð¼Ñ\83 Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8e"
+msgstr "Ð§Ð¸Ñ\81Ð»Ð¾ Ð¾Ñ\82Ð»Ð¾Ð¶ÐµÐ½Ð½Ñ\8bÑ\85 Ð¿Ð°Ñ\80 Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð¹ Ð·Ð°Ð¿Ð¸Ñ\81Ð¸, ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð±Ñ\8bÑ\82Ñ\8c \"Ñ\83Ñ\82Ð¾Ð¿Ð»ÐµÐ½Ñ\8b\""
  
  #: params.def:1051
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "The smallest number of different values for which it is best to use a jump-table instead of a tree of conditional branches, if 0, use the default for the machine"
  msgid "The smallest number of different values for which it is best to use a jump-table instead of a tree of conditional branches, if 0, use the default for the machine."
-msgstr ""
+msgstr "Максимальное число различных значений, при котором выгоднее использовать таблицу переходов, чем дерево условных ветвлений; при 0 используется умолчание для данной машины"
  
  #: params.def:1059
  #, fuzzy, no-c-format
+#| msgid "Allow new data races on stores to be introduced"
  msgid "Allow new data races on stores to be introduced."
-msgstr "Ð\9aÐ¾Ð¼Ð±Ð¸Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ñ\8bÐµ Ð¿ÐµÑ\80ÐµÑ\85Ð¾Ð´Ñ\8b Ñ\81 Ð´Ñ\80Ñ\83Ð³Ð¸Ð¼Ð¸ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8fÐ¼Ð¸"
+msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ñ\83 Ð´Ð¾Ð±Ð°Ð²Ð»ÐµÐ½Ð¸Ðµ Ð½Ð¾Ð²Ñ\8bÑ\85 Ð³Ð¾Ð½Ð¾Ðº Ð´Ð°Ð½Ð½Ñ\8bÑ\85 Ð¿Ð¾ Ð·Ð°Ð¿Ð¸Ñ\81Ð¸ Ð´Ð°Ð½Ð½Ñ\8bÑ\85"
  
  #: params.def:1065
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Set the maximum number of instructions executed in parallel in reassociated tree. If 0, use the target dependent heuristic."
  msgid "Set the maximum number of instructions executed in parallel in reassociated tree. If 0, use the target dependent heuristic.."
-msgstr ""
+msgstr "Максимальное число параллельно выполняемых инструкций в дереве при реассоциировании ассоциативных операций. При 0 использовать эвристику данной целевой платформы."
  
  #: params.def:1071
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximum amount of similar bbs to compare a bb with"
  msgid "Maximum amount of similar bbs to compare a bb with."
-msgstr ""
+msgstr "Максимальное число похожих базовых блоков, с которыми сравнивается данный блок"
  
  #: params.def:1076
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximum amount of iterations of the pass over a function"
  msgid "Maximum amount of iterations of the pass over a function."
-msgstr ""
+msgstr "Максимальное число итераций обработки каждой функции"
  
  #: params.def:1083
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximum number of strings for which strlen optimization pass will track string lengths"
  msgid "Maximum number of strings for which strlen optimization pass will track string lengths."
-msgstr ""
+msgstr "Максимальное число строк, для которых проход оптимизации strlen будет отслеживать длины"
  
  #: params.def:1090
  #, no-c-format
@@ -2595,23 +2669,27 @@ msgstr "Включить проверку стека зондированием"
  
  #: params.def:1107
  #, fuzzy, no-c-format
+#| msgid "Enable all optional instructions"
  msgid "Enable asan globals protection."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð²Ñ\81Ðµ Ð½ÐµÐ¾Ð±Ñ\8fÐ·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: params.def:1112
  #, fuzzy, no-c-format
+#| msgid "Enable saturation instructions"
  msgid "Enable asan store operations protection."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð½Ð°Ñ\81Ñ\8bÑ\89ÐµÐ½Ð¸Ñ\8f"
  
  #: params.def:1117
  #, fuzzy, no-c-format
+#| msgid "Enable all optional instructions"
  msgid "Enable asan load operations protection."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð²Ñ\81Ðµ Ð½ÐµÐ¾Ð±Ñ\8fÐ·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: params.def:1122
  #, fuzzy, no-c-format
+#| msgid "Enable saturation instructions"
  msgid "Enable asan builtin functions protection."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð½Ð°Ñ\81Ñ\8bÑ\89ÐµÐ½Ð¸Ñ\8f"
  
  #: params.def:1127
  #, no-c-format
@@ -2624,9 +2702,10 @@ msgid "Use callbacks instead of inline code if number of accesses in function be
  msgstr ""
  
  #: params.def:1138
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "Maximum number of namespaces to search for alternatives when name lookup fails"
  msgid "Maximum number of nested calls to search for control dependencies during uninitialized variable analysis."
-msgstr ""
+msgstr "Максимальное число пространств имен для поиска альтернатив при неуспешном поиске имени"
  
  #: params.def:1144
  #, no-c-format
@@ -2654,14 +2733,16 @@ msgid "Maximum number of instructions to copy when duplicating blocks on a finit
  msgstr ""
  
  #: params.def:1170
-#, no-c-format
+#, fuzzy, no-c-format
+#| msgid "maximum number of basic blocks per function to be analyzed by Graphite"
  msgid "Maximum number of basic blocks on a finite state automaton jump thread path."
-msgstr ""
+msgstr "максимальное число базовых блоков в функции, при котором применяются средства Graphite"
  
  #: params.def:1175
  #, fuzzy, no-c-format
+#| msgid "Maximum number of nops to insert for a hint (Default 2)"
  msgid "Maximum number of new jump thread paths to create for a finite state automaton."
-msgstr "Максимальный коэффициент развертки цикла"
+msgstr "Максимальное число nops при вставке для подсказки (По умолчанию 2)"
  
  #: params.def:1180
  #, no-c-format
@@ -2680,8 +2761,9 @@ msgstr ""
  
  #: params.def:1198
  #, fuzzy, no-c-format
+#| msgid "Maximum number of instructions in basic block to be considered for SLP vectorization"
  msgid "Maximum number of insns in a basic block to consider for RTL if-conversion."
-msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð² Ð¾Ñ\82Ñ\80ÐµÐ·ÐºÐµ Ð´Ð»Ñ\8f Ð¼ÐµÐ¶Ð±Ð»Ð¾Ñ\87Ð½Ð¾Ð³Ð¾ Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f"
+msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð² Ð±Ð°Ð·Ð¾Ð²Ð¾Ð¼ Ð±Ð»Ð¾ÐºÐµ Ð´Ð»Ñ\8f ÐµÐ³Ð¾ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð¸Ð·Ð°Ñ\86Ð¸Ð¸"
  
  #: params.def:1204
  #, no-c-format
@@ -2695,15 +2777,13 @@ msgstr ""
  
  #: c-family/c-format.c:417
  msgid "format"
-msgstr ""
+msgstr "формат"
  
  #: c-family/c-format.c:418
-#, fuzzy
  msgid "field width specifier"
  msgstr "ширина поля"
  
  #: c-family/c-format.c:419
-#, fuzzy
  msgid "field precision specifier"
  msgstr "точность поля"
  
@@ -2970,15 +3050,16 @@ msgstr "<command-line>"
  
  #: config/aarch64/aarch64.c:4451 config/arm/arm.c:21954 config/arm/arm.c:21967
  #: config/arm/arm.c:21992 config/nios2/nios2.c:2642
-#, fuzzy, c-format
+#, c-format
  msgid "Unsupported operand for code '%c'"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸мый операнд для кода '%c'"
+msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°Ðµмый операнд для кода '%c'"
  
  #: config/aarch64/aarch64.c:4463 config/aarch64/aarch64.c:4479
  #: config/aarch64/aarch64.c:4492 config/aarch64/aarch64.c:4504
  #: config/aarch64/aarch64.c:4515 config/aarch64/aarch64.c:4538
  #: config/aarch64/aarch64.c:4591 config/aarch64/aarch64.c:4794
  #, fuzzy, c-format
+#| msgid "invalid operand for code '%c'"
  msgid "invalid operand for '%%%c'"
  msgstr "недопустимый операнд для кода '%c'"
  
@@ -2995,16 +3076,19 @@ msgstr "отсутствует операнд"
  
  #: config/aarch64/aarch64.c:4689
  #, fuzzy, c-format
+#| msgid "invalid insn:"
  msgid "invalid constant"
  msgstr "недопустимая инструкция:"
  
  #: config/aarch64/aarch64.c:4692
  #, fuzzy, c-format
+#| msgid "invalid %%d operand"
  msgid "invalid operand"
  msgstr "некорректный операнд для %%d"
  
  #: config/aarch64/aarch64.c:4805
  #, fuzzy, c-format
+#| msgid "invalid operand code '%c'"
  msgid "invalid operand prefix '%%%c'"
  msgstr "некорректный код операнда '%c'"
  
@@ -3012,7 +3096,7 @@ msgstr "некорректный код операнда '%c'"
  #: config/rs6000/rs6000.c:20285 config/sparc/sparc.c:8649
  #, c-format
  msgid "'%%&' used without any local dynamic TLS references"
-msgstr ""
+msgstr "'%%&' использовано без локальной динамической TLS ссылки"
  
  #: config/alpha/alpha.c:5160 config/bfin/bfin.c:1423
  #, c-format
@@ -3095,8 +3179,9 @@ msgstr "некорректный код %%xn"
  
  #: config/alpha/alpha.c:5499
  #, fuzzy, c-format
+#| msgid "invalid address"
  msgid "invalid operand address"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f %%d"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ð´Ñ\80ÐµÑ\81"
  
  #: config/arc/arc.c:2966
  #, fuzzy, c-format
@@ -3194,18 +3279,17 @@ msgstr "инструкция никогда не выполняется"
  #. Former Maverick support, removed after GCC-4.7.
  #: config/arm/arm.c:22194
  #, fuzzy, c-format
+#| msgid "Unsupported operand for code '%c'"
  msgid "obsolete Maverick format code '%c'"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸мый операнд для кода '%c'"
+msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°Ðµмый операнд для кода '%c'"
  
  #: config/arm/arm.c:23613
-#, fuzzy
  msgid "function parameters cannot have __fp16 type"
-msgstr "функция возвращает агрегатное значение"
+msgstr "параметры функции не могут иметь тип __fp16"
  
  #: config/arm/arm.c:23623
-#, fuzzy
  msgid "functions cannot return __fp16 type"
-msgstr "Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÑ\82 Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð½Ðµ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾Ð²Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°Ñ\82Ñ\8c Ñ\82Ð¸Ð¿ __fp16"
  
  #: config/avr/avr.c:2127
  #, c-format
@@ -3213,19 +3297,16 @@ msgid "address operand requires constraint for X, Y, or Z register"
  msgstr "для операнда адреса требуются ограничения одного из регистров X, Y или Z"
  
  #: config/avr/avr.c:2285
-#, fuzzy
  msgid "operands to %T/%t must be reg + const_int:"
-msgstr "Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ %d Ð´Ð¾Ð»Ð¶ÐµÐ½ Ñ\81Ð¾Ð´ÐµÑ\80Ð¶Ð°Ñ\82Ñ\8c Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82ÐµÐ»Ñ\8c %<&%>"
+msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð´Ð»Ñ\8f %T/%t Ð´Ð¾Ð»Ð¶Ð½Ñ\8b Ð±Ñ\8bÑ\82Ñ\8c reg + const_int:"
  
  #: config/avr/avr.c:2335 config/avr/avr.c:2402
-#, fuzzy
  msgid "bad address, not an I/O address:"
-msgstr "некорректный адрес, не (reg+disp)"
+msgstr "некорректный адрес, не I/O адрес:"
  
  #: config/avr/avr.c:2344
-#, fuzzy
  msgid "bad address, not a constant:"
-msgstr "Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ñ\81Ð¼ÐµÑ\89ÐµÐ½Ð¸Ðµ - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð°"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ð´Ñ\80ÐµÑ\81, Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð°:"
  
  #: config/avr/avr.c:2362 config/avr/avr.c:2369
  msgid "bad address, not (reg+disp):"
@@ -3275,15 +3356,17 @@ msgstr "Внутренняя ошибка компилятора: некорре
  
  #: config/avr/avr.c:7978
  #, fuzzy
+#| msgid "invalid types in fixed-point conversion"
  msgid "unsupported fixed-point conversion"
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ñ\81 Ñ\84Ð¸ÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹"
  
  #: config/avr/driver-avr.c:71
  #, fuzzy, c-format
+#| msgid "unknown spec function %qs"
  msgid ""
  "Running spec function '%s' with %d args\n"
  "\n"
-msgstr "неизвестная функция '%s' в спецификации"
+msgstr "неизвестная функция %qs в спецификации"
  
  #: config/avr/driver-avr.c:118
  #, c-format
@@ -3395,9 +3478,8 @@ msgstr "некорректные побочные эффекты в адресе
  
  #. Can't possibly get anything else for a function-call, right?
  #: config/cris/cris.c:3844
-#, fuzzy
  msgid "unidentifiable call op"
-msgstr "Ð\9dÐµÐ¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½ая операция вызова"
+msgstr "Ð½ÐµÐ¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ñ\83ÐµÐ¼ая операция вызова"
  
  #: config/cris/cris.c:3906
  #, c-format
@@ -3535,43 +3617,48 @@ msgstr "некорректный операнд UNSPEC"
  
  #: config/i386/i386.c:16764
  #, fuzzy, c-format
+#| msgid "invalid operand size for operand code '%c'"
  msgid "invalid operand size for operand code 'O'"
-msgstr "недопустимый операнд для кода '%c'"
+msgstr "недопустимый размер операнда для кода '%c'"
  
  #: config/i386/i386.c:16799
  #, fuzzy, c-format
+#| msgid "invalid operand size for operand code '%c'"
  msgid "invalid operand size for operand code 'z'"
-msgstr "недопустимый операнд для кода '%c'"
+msgstr "недопустимый размер операнда для кода '%c'"
  
  #: config/i386/i386.c:16869
  #, fuzzy, c-format
+#| msgid "invalid operand type used with operand code '%c'"
  msgid "invalid operand type used with operand code 'Z'"
-msgstr "недопустимый операнд для кода '%c'"
+msgstr "недопустимый тип операнда для кода '%c'"
  
  #: config/i386/i386.c:16874
  #, fuzzy, c-format
+#| msgid "invalid operand size for operand code '%c'"
  msgid "invalid operand size for operand code 'Z'"
-msgstr "недопустимый операнд для кода '%c'"
+msgstr "недопустимый размер операнда для кода '%c'"
  
  #: config/i386/i386.c:16950
-#, fuzzy, c-format
+#, c-format
  msgid "operand is not a condition code, invalid operand code 'Y'"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹ Ð¸Ð»Ð¸ ÐºÐ¾Ð´Ð¾Ð¼ Ñ\83Ñ\81Ð»Ð¾Ð²Ð¸Ñ\8f, Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ ÐºÐ¾Ð´ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð° 'c'"
+msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð´Ð¾Ð¼ Ñ\83Ñ\81Ð»Ð¾Ð²Ð¸Ñ\8f, Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ ÐºÐ¾Ð´ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð° 'Y'"
  
  #: config/i386/i386.c:17023
-#, fuzzy, c-format
+#, c-format
  msgid "operand is not a condition code, invalid operand code 'D'"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹ Ð¸Ð»Ð¸ ÐºÐ¾Ð´Ð¾Ð¼ Ñ\83Ñ\81Ð»Ð¾Ð²Ð¸Ñ\8f, Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ ÐºÐ¾Ð´ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð° 'c'"
+msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð´Ð¾Ð¼ Ñ\83Ñ\81Ð»Ð¾Ð²Ð¸Ñ\8f, Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ ÐºÐ¾Ð´ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð° 'D'"
  
  #: config/i386/i386.c:17040
  #, fuzzy, c-format
+#| msgid "operand is not a condition code, invalid operand code 'D'"
  msgid "operand is not a condition code, invalid operand code '%c'"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹ Ð¸Ð»Ð¸ ÐºÐ¾Ð´Ð¾Ð¼ Ñ\83Ñ\81Ð»Ð¾Ð²Ð¸Ñ\8f, Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ ÐºÐ¾Ð´ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð° 'c'"
+msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð´Ð¾Ð¼ Ñ\83Ñ\81Ð»Ð¾Ð²Ð¸Ñ\8f, Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ ÐºÐ¾Ð´ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð° 'D'"
  
  #: config/i386/i386.c:17053
-#, fuzzy, c-format
+#, c-format
  msgid "operand is not an offsettable memory reference, invalid operand code 'H'"
-msgstr "операнд не является константой или кодом условия, неверный код операнда 'c'"
+msgstr "операнд не является ссылкой на память со смещением, неверный код операнда 'H'"
  
  #: config/i386/i386.c:17218
  #, c-format
@@ -3598,14 +3685,13 @@ msgid "Use native (MS) bitfield layout"
  msgstr "Использовать размещение битовых полей по соглашениям MS"
  
  #: config/i386/i386-interix.h:78
-#, fuzzy
  msgid "Use gcc default bitfield layout"
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\80Ð°Ð·Ð¼ÐµÑ\89ÐµÐ½Ð¸Ðµ Ð±Ð¸Ñ\82Ð¾Ð²Ñ\8bÑ\85 Ð¿Ð¾Ð»ÐµÐ¹ Ð¿Ð¾ Ñ\81Ð¾Ð³Ð»Ð°Ñ\88ÐµÐ½Ð¸Ñ\8fÐ¼ MS"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\80Ð°Ð·Ð¼ÐµÑ\89ÐµÐ½Ð¸Ðµ Ð±Ð¸Ñ\82Ð¾Ð²Ñ\8bÑ\85 Ð¿Ð¾Ð»ÐµÐ¹ Ð² Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ð¸ Ñ\81 Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8fÐ¼Ð¸ GCC"
  
  #: config/ia64/ia64.c:5364
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%G mode"
-msgstr "недопустимое значение для кода %%j"
+msgstr "недопустимый режим %%G"
  
  #: config/ia64/ia64.c:5534
  #, c-format
@@ -3643,21 +3729,19 @@ msgstr "некорректное использование %%d, %%x или %%X"
  #: config/lm32/lm32.c:507
  #, c-format
  msgid "only 0.0 can be loaded as an immediate"
-msgstr ""
+msgstr "только 0.0 может быть загружено как непосредственное значение"
  
  #: config/lm32/lm32.c:577
-#, fuzzy
  msgid "bad operand"
  msgstr "некорректный операнд"
  
  #: config/lm32/lm32.c:589
  msgid "can't use non gp relative absolute address"
-msgstr ""
+msgstr "невозможно использовать абсолютный адрес, не выраженный как смещение относительно gp"
  
  #: config/lm32/lm32.c:593
-#, fuzzy
  msgid "invalid addressing mode"
-msgstr "некорректный адрес"
+msgstr "некорректный режим адресации"
  
  #: config/m32r/m32r.c:2072
  #, c-format
@@ -3705,34 +3789,33 @@ msgid "lo_sum not of register"
  msgstr "lo_sum не от регистра"
  
  #: config/mep/mep.c:3233
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%L code"
-msgstr "недопустимое значение для кода %%j"
+msgstr "недопустимый код %%L"
  
  #: config/microblaze/microblaze.c:2190
-#, fuzzy, c-format
+#, c-format
  msgid "unknown punctuation '%c'"
-msgstr "неизвестная функция '%s' в спецификации"
+msgstr "неизвестный знак пунктуации '%c'"
  
  #: config/microblaze/microblaze.c:2199
-#, fuzzy, c-format
+#, c-format
  msgid "null pointer"
-msgstr "нулевой указатель в вызове PRINT_OPERAND"
+msgstr "нулевой указатель"
  
  #: config/microblaze/microblaze.c:2234
-#, fuzzy, c-format
+#, c-format
  msgid "PRINT_OPERAND, invalid insn for %%C"
-msgstr "PRINT_OPERAND_ADDRESS: некорректная инструкция #1"
+msgstr "PRINT_OPERAND, некорректная инструкция для %%C"
  
  #: config/microblaze/microblaze.c:2263
-#, fuzzy, c-format
+#, c-format
  msgid "PRINT_OPERAND, invalid insn for %%N"
-msgstr "PRINT_OPERAND_ADDRESS: некорректная инструкция #1"
+msgstr "PRINT_OPERAND, некорректная инструкция для %%N"
  
  #: config/microblaze/microblaze.c:2283 config/microblaze/microblaze.c:2458
-#, fuzzy
  msgid "insn contains an invalid address !"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ð´Ñ\80ÐµÑ\81"
+msgstr "Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8f Ñ\81Ð¾Ð´ÐµÑ\80Ð¶Ð¸Ñ\82 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ð´Ñ\80ÐµÑ\81 !"
  
  #: config/microblaze/microblaze.c:2298 config/microblaze/microblaze.c:2517
  #: config/xtensa/xtensa.c:2454
@@ -3742,12 +3825,12 @@ msgstr "некорректный адрес"
  #: config/microblaze/microblaze.c:2401
  #, c-format
  msgid "letter %c was found & insn was not CONST_INT"
-msgstr ""
+msgstr "обнаружена буква %c & insn не является CONST_INT"
  
  #: config/mips/mips.c:8416 config/mips/mips.c:8443 config/mips/mips.c:8564
  #, c-format
  msgid "'%%%c' is not a valid operand prefix"
-msgstr "'%%%c' не является корректным префиксом оператора"
+msgstr "'%%%c' не является корректным префиксом операнда"
  
  #: config/mips/mips.c:8501 config/mips/mips.c:8508 config/mips/mips.c:8515
  #: config/mips/mips.c:8522 config/mips/mips.c:8582 config/mips/mips.c:8596
@@ -3799,18 +3882,20 @@ msgstr "Внутреннее сообщение MMIX: это не констан
  
  #: config/msp430/msp430.c:3609
  #, fuzzy, c-format
+#| msgid "invalid reference prefix"
  msgid "invalid operand prefix"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ¾Ð´ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð° '%c'"
+msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð¿Ñ\80ÐµÑ\84Ð¸ÐºÑ\81 Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸"
  
  #: config/msp430/msp430.c:3643
  #, fuzzy, c-format
+#| msgid "invalid use of %<restrict%>"
  msgid "invalid zero extract"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f %%d"
+msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾Ðµ Ñ\83Ð¿Ð¾Ñ\82Ñ\80ÐµÐ±Ð»ÐµÐ½Ð¸Ðµ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð° %<restrict%>"
  
  #: config/rl78/rl78.c:1797 config/rl78/rl78.c:1883
  #, c-format
  msgid "q/Q modifiers invalid for symbol references"
-msgstr ""
+msgstr "модификаторы q/Q некорректны для символьной ссылки"
  
  #: config/rs6000/host-darwin.c:94
  #, c-format
@@ -3827,28 +3912,24 @@ msgid "-maltivec=le not allowed for big-endian targets"
  msgstr ""
  
  #: config/rs6000/rs6000.c:3934
-#, fuzzy
  msgid "-mvsx requires hardware floating point"
-msgstr "Использовать аппаратную реализацию плавающей арифметики"
+msgstr "-mvsx требует аппаратной реализации плавающей арифметики"
  
  #: config/rs6000/rs6000.c:3942
-#, fuzzy
  msgid "-mvsx and -mpaired are incompatible"
-msgstr "ключи -f%s и -msdata=%s несовместимы"
+msgstr "ключи -mvsx и -mpaired несовместимы"
  
  #: config/rs6000/rs6000.c:3944
-#, fuzzy
  msgid "-mvsx needs indexed addressing"
-msgstr "Ð\9dÐµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ð´ÐµÐºÑ\81Ð½Ñ\83Ñ\8e Ð°Ð´Ñ\80ÐµÑ\81Ð°Ñ\86Ð¸Ñ\8e"
+msgstr "Ð´Ð»Ñ\8f -mvsx Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¸Ð½Ð´ÐµÐºÑ\81Ð½Ð°Ñ\8f Ð°Ð´Ñ\80ÐµÑ\81Ð°Ñ\86Ð¸Ñ\8f"
  
  #: config/rs6000/rs6000.c:3949
-#, fuzzy
  msgid "-mvsx and -mno-altivec are incompatible"
-msgstr "ключи -f%s и -msdata=%s несовместимы"
+msgstr "ключи -mvsx и -mno-altivec несовместимы"
  
  #: config/rs6000/rs6000.c:3951
  msgid "-mno-altivec disables vsx"
-msgstr ""
+msgstr "-mno-altivec отменяет vsx"
  
  #: config/rs6000/rs6000.c:4091
  #, fuzzy
@@ -3877,9 +3958,8 @@ msgid "-mtoc-fusion requires medium/large code model"
  msgstr ""
  
  #: config/rs6000/rs6000.c:9505
-#, fuzzy
  msgid "bad move"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¿Ñ\80Ð¾Ð²ÐµÑ\80ка"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÑ\81Ñ\8bÐ»ка"
  
  #: config/rs6000/rs6000.c:19546
  msgid "Bad 128-bit move"
@@ -3957,9 +4037,9 @@ msgid "invalid %%x value"
  msgstr "неверное значение для кода %%x"
  
  #: config/rs6000/rs6000.c:20234
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%y value, try using the 'Z' constraint"
-msgstr "некорректный знак %qc в ограничителе"
+msgstr "некорректное значение %%y, попробуйте использовать ограничитель 'Z'"
  
  #: config/rs6000/rs6000.c:20912
  msgid "__float128 and __ibm128 cannot be used in the same expression"
@@ -4020,7 +4100,7 @@ msgstr ""
  #: config/s390/s390.c:7147
  #, c-format
  msgid "symbolic memory references are only supported on z10 or later"
-msgstr ""
+msgstr "символьные ссылки на память поддерживаются только для z10 или более поздних версий"
  
  #: config/s390/s390.c:7158
  #, c-format
@@ -4028,69 +4108,70 @@ msgid "cannot decompose address"
  msgstr "ошибка при декомпозиции адреса"
  
  #: config/s390/s390.c:7227
-#, fuzzy, c-format
+#, c-format
  msgid "invalid comparison operator for 'E' output modifier"
-msgstr "некорректный операнд для модификатора 'b'"
+msgstr "некорректный оператор сравнения для 'E' модификатора вывода"
  
  #: config/s390/s390.c:7250
-#, fuzzy, c-format
+#, c-format
  msgid "invalid reference for 'J' output modifier"
-msgstr "некорректный операнд для модификатора 'b'"
+msgstr "некорректная ссылка для 'J' модификатора вывода"
  
  #: config/s390/s390.c:7268
-#, fuzzy, c-format
+#, c-format
  msgid "invalid address for 'O' output modifier"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð° 'O'"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ð´Ñ\80ÐµÑ\81 Ð´Ð»Ñ\8f 'O' Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð° Ð²Ñ\8bÐ²Ð¾Ð´Ð°"
  
  #: config/s390/s390.c:7290
-#, fuzzy, c-format
+#, c-format
  msgid "invalid address for 'R' output modifier"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð° 'b'"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ð´Ñ\80ÐµÑ\81 Ð´Ð»Ñ\8f 'R' Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð° Ð²Ñ\8bÐ²Ð¾Ð´Ð°"
  
  #: config/s390/s390.c:7308
  #, c-format
  msgid "memory reference expected for 'S' output modifier"
-msgstr ""
+msgstr "ожидалась ссылка на память для 'S' модификатора вывода"
  
  #: config/s390/s390.c:7318
-#, fuzzy, c-format
+#, c-format
  msgid "invalid address for 'S' output modifier"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð° 'b'"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ð´Ñ\80ÐµÑ\81 Ð´Ð»Ñ\8f 'S' Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð° Ð²Ñ\8bÐ²Ð¾Ð´Ð°"
  
  #: config/s390/s390.c:7339
  #, c-format
  msgid "register or memory expression expected for 'N' output modifier"
-msgstr ""
+msgstr "ожидалось выражении из регистров и памяти для 'N' модификатора вывода"
  
  #: config/s390/s390.c:7350
  #, c-format
  msgid "register or memory expression expected for 'M' output modifier"
-msgstr ""
+msgstr "ожидался регистр или выражение памяти для модификатора вывода 'M'"
  
  #: config/s390/s390.c:7435 config/s390/s390.c:7456
-#, fuzzy, c-format
+#, c-format
  msgid "invalid constant for output modifier '%c'"
-msgstr "некорректный операнд для модификатора 'o'"
+msgstr "некорректная константа для модификатора вывода '%c'"
  
  #: config/s390/s390.c:7453
-#, fuzzy, c-format
+#, c-format
  msgid "invalid constant - try using an output modifier"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ ÐºÐ¾Ð´ Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ð½да"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° - Ð¿Ð¾Ð¿Ñ\8bÑ\82Ð°Ð¹Ñ\82ÐµÑ\81Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð²Ñ\8bÐ²Ð¾да"
  
  #: config/s390/s390.c:7494
  #, fuzzy, c-format
+#| msgid "invalid constant for output modifier '%c'"
  msgid "invalid constant vector for output modifier '%c'"
-msgstr "некорректный операнд для модификатора 'o'"
+msgstr "некорректная константа для модификатора вывода '%c'"
  
  #: config/s390/s390.c:7501
-#, fuzzy, c-format
+#, c-format
  msgid "invalid expression - try using an output modifier"
-msgstr "Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð·Ð°Ð´Ð°Ð½Ð¾ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ - Ð¿Ð¾Ð¿Ñ\8bÑ\82Ð°Ð¹Ñ\82ÐµÑ\81Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð²Ñ\8bÐ²Ð¾Ð´Ð°"
  
  #: config/s390/s390.c:7504
-#, fuzzy, c-format
+#, c-format
  msgid "invalid expression for output modifier '%c'"
-msgstr "некорректный операнд для модификатора 'o'"
+msgstr "некорректное выражение для модификатора вывода '%c'"
  
  #: config/s390/s390.c:11356
  #, fuzzy
@@ -4155,14 +4236,14 @@ msgstr "некорректный операнд для %%B"
  
  #: config/sparc/sparc.c:8773 config/tilegx/tilegx.c:5095
  #: config/tilepro/tilepro.c:4510
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%C operand"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%P"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ %%C Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
  
  #: config/sparc/sparc.c:8790 config/tilegx/tilegx.c:5128
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%D operand"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%P"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ %%D Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
  
  #: config/sparc/sparc.c:8806
  #, c-format
@@ -4211,79 +4292,79 @@ msgid "invalid %%d operand"
  msgstr "некорректный операнд для %%d"
  
  #: config/tilegx/tilegx.c:5208
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%H specifier"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%j"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ %%H Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80"
  
  #: config/tilegx/tilegx.c:5250 config/tilepro/tilepro.c:4524
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%h operand"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%P"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ %%h Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
  
  #: config/tilegx/tilegx.c:5262 config/tilepro/tilepro.c:4588
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%I operand"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%P"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ %%I Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
  
  #: config/tilegx/tilegx.c:5274 config/tilepro/tilepro.c:4600
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%i operand"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%P"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ %%i Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
  
  #: config/tilegx/tilegx.c:5295 config/tilepro/tilepro.c:4621
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%j operand"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%P"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ %%j Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
  
  #: config/tilegx/tilegx.c:5326
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%%c operand"
-msgstr "некорректный операнд для %%c"
+msgstr "некорректный операнд для %%%c"
  
  #: config/tilegx/tilegx.c:5341 config/tilepro/tilepro.c:4735
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%N operand"
-msgstr "неверный операнд для кода %%P"
+msgstr "неверный операнд для %%N"
  
  #: config/tilegx/tilegx.c:5385
-#, fuzzy, c-format
+#, c-format
  msgid "invalid operand for 'r' specifier"
-msgstr "некорректный операнд для модификатора 'b'"
+msgstr "некорректный операнд для спецификатора 'r'"
  
  #: config/tilegx/tilegx.c:5409 config/tilepro/tilepro.c:4816
  #, c-format
  msgid "unable to print out operand yet; code == %d (%c)"
-msgstr ""
+msgstr "невозможно напечатать операнд; код == %d (%c)"
  
  #: config/tilepro/tilepro.c:4560
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%H operand"
-msgstr "неверный операнд для кода %%P"
+msgstr "неверный операнд для %%H"
  
  #: config/tilepro/tilepro.c:4660
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%L operand"
-msgstr "неверный операнд для кода %%P"
+msgstr "неверный операнд для %%L"
  
  #: config/tilepro/tilepro.c:4720
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%M operand"
-msgstr "неверный операнд для кода %%P"
+msgstr "неверный операнд для %%M"
  
  #: config/tilepro/tilepro.c:4763
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%t operand"
-msgstr "неверный операнд для кода %%P"
+msgstr "неверный операнд для %%t"
  
  #: config/tilepro/tilepro.c:4770
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%t operand '"
-msgstr "неверный операнд для кода %%P"
+msgstr "неверный операнд для %%t '"
  
  #: config/tilepro/tilepro.c:4791
-#, fuzzy, c-format
+#, c-format
  msgid "invalid %%r operand"
-msgstr "неверный операнд для кода %%P"
+msgstr "неверный операнд для %%r"
  
  #: config/v850/v850.c:293
  msgid "const_double_split got a bad insn:"
@@ -4296,47 +4377,51 @@ msgstr "output_move_single:"
  #: config/vax/vax.c:453
  #, c-format
  msgid "symbol used with both base and indexed registers"
-msgstr ""
+msgstr "символ использован с базовым и индексным регистрами"
  
  #: config/vax/vax.c:462
  #, c-format
  msgid "symbol with offset used in PIC mode"
-msgstr ""
+msgstr "символ со смещением использован в режиме PIC"
  
  #: config/vax/vax.c:550
-#, fuzzy, c-format
+#, c-format
  msgid "symbol used as immediate operand"
-msgstr "константа long long не является корректным непосредственным операндом"
+msgstr "символ использован как непосредственный операнд"
  
  #: config/vax/vax.c:1577
-#, fuzzy
  msgid "illegal operand detected"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð°"
+msgstr "Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶ÐµÐ½ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
  
  #: config/visium/visium.c:3195
  #, fuzzy
+#| msgid "illegal operand detected"
  msgid "illegal operand "
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð°"
+msgstr "Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶ÐµÐ½ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
  
  #: config/visium/visium.c:3246
  #, fuzzy
+#| msgid "illegal operand detected"
  msgid "illegal operand address (1)"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð°"
+msgstr "Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶ÐµÐ½ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
  
  #: config/visium/visium.c:3253
  #, fuzzy
+#| msgid "illegal operand detected"
  msgid "illegal operand address (2)"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð°"
+msgstr "Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶ÐµÐ½ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
  
  #: config/visium/visium.c:3268
  #, fuzzy
+#| msgid "illegal operand detected"
  msgid "illegal operand address (3)"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð°"
+msgstr "Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶ÐµÐ½ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
  
  #: config/visium/visium.c:3276
  #, fuzzy
+#| msgid "illegal operand detected"
  msgid "illegal operand address (4)"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð°"
+msgstr "Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶ÐµÐ½ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
  
  #: config/xtensa/xtensa.c:768 config/xtensa/xtensa.c:800
  #: config/xtensa/xtensa.c:809
@@ -4407,13 +4492,13 @@ msgstr "ожидалось %<;%>"
  #: c/c-parser.c:10986 cp/parser.c:24098 cp/parser.c:26889
  #, gcc-internal-format
  msgid "expected %<(%>"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾сь %<(%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°сь %<(%>"
  
  #: c/c-parser.c:2192 c/c-parser.c:7230 c/c-parser.c:7636 c/c-parser.c:7677
  #: c/c-parser.c:7813 cp/parser.c:26311 cp/parser.c:26904
  #, gcc-internal-format
  msgid "expected %<,%>"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾сь %<,%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°сь %<,%>"
  
  #: c/c-parser.c:2213 c/c-parser.c:2580 c/c-parser.c:2903 c/c-parser.c:3226
  #: c/c-parser.c:3263 c/c-parser.c:3478 c/c-parser.c:3664 c/c-parser.c:3726
@@ -4440,7 +4525,7 @@ msgstr "ожидалось %<,%>"
  #: cp/parser.c:24130 cp/parser.c:26934
  #, gcc-internal-format
  msgid "expected %<)%>"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾сь %<)%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°сь %<)%>"
  
  #: c/c-parser.c:3583 c/c-parser.c:4514 c/c-parser.c:4550 c/c-parser.c:6136
  #: c/c-parser.c:7744 c/c-parser.c:8102 c/c-parser.c:8251 c/c-parser.c:10654
@@ -4448,7 +4533,7 @@ msgstr "ожидалось %<)%>"
  #: cp/parser.c:26898
  #, gcc-internal-format
  msgid "expected %<]%>"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾сь %<]%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°сь %<]%>"
  
  #: c/c-parser.c:3759
  msgid "expected %<;%>, %<,%> or %<)%>"
@@ -4457,13 +4542,13 @@ msgstr "ожидалось %<;%>, %<,%> или %<)%>"
  #: c/c-parser.c:4372 c/c-parser.c:14534 cp/parser.c:26892 cp/parser.c:28814
  #, gcc-internal-format
  msgid "expected %<}%>"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾сь %<}%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°сь %<}%>"
  
  #: c/c-parser.c:4684 c/c-parser.c:9453 c/c-parser.c:15252 c/c-parser.c:2768
  #: c/c-parser.c:2971 c/c-parser.c:9007 cp/parser.c:17140 cp/parser.c:26895
  #, gcc-internal-format
  msgid "expected %<{%>"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾сь %<{%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°сь %<{%>"
  
  #: c/c-parser.c:4917 c/c-parser.c:4926 c/c-parser.c:6043 c/c-parser.c:6385
  #: c/c-parser.c:7278 c/c-parser.c:9218 c/c-parser.c:9601 c/c-parser.c:9662
@@ -4507,7 +4592,7 @@ msgstr ""
  
  #: c/c-parser.c:7497
  msgid "expected %<.%>"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾сь %<.%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°сь %<.%>"
  
  #: c/c-parser.c:8678 c/c-parser.c:8710 c/c-parser.c:8950 cp/parser.c:28599
  #: cp/parser.c:28673
@@ -4523,7 +4608,7 @@ msgstr "ожидалось %<>%>"
  #: c/c-parser.c:12133 c/c-parser.c:12897 cp/parser.c:26937
  #, gcc-internal-format
  msgid "expected %<,%> or %<)%>"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾сь %<,%> или %<)%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°сь %<,%> или %<)%>"
  
  #: c/c-parser.c:14246 c/c-parser.c:14290 c/c-parser.c:14518 c/c-parser.c:14753
  #: c/c-parser.c:16906 c/c-parser.c:17528 c/c-parser.c:4573 cp/parser.c:26916
@@ -4537,9 +4622,9 @@ msgid "expected %<#pragma omp section%> or %<}%>"
  msgstr "ожидалось %<#pragma omp section%> или %<}%>"
  
  #: c/c-parser.c:17690 c/c-parser.c:10600 cp/parser.c:26901 cp/parser.c:29954
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<[%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<[%>"
  
  #: c/c-typeck.c:7400
  msgid "(anonymous)"
@@ -4562,102 +4647,93 @@ msgid "candidate is: %+#D"
  msgstr "претендент: %+#D"
  
  #: cp/error.c:319
-#, fuzzy
  msgid "<missing>"
-msgstr "отсутствует число"
+msgstr "<отсутствует>"
  
  #: cp/error.c:419
-#, fuzzy
  msgid "<brace-enclosed initializer list>"
-msgstr "фигурные скобки вокруг скалярного инициализатора"
+msgstr "<инициализатор в фигурных скобках>"
  
  #: cp/error.c:421
-#, fuzzy
  msgid "<unresolved overloaded function type>"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "<неразрешенный тип перегруженной функции>"
  
  #: cp/error.c:583
-#, fuzzy
  msgid "<type error>"
-msgstr "внутренняя ошибка компилятора: "
+msgstr "<ошибка типа>"
  
  #: cp/error.c:686
-#, fuzzy, c-format
+#, c-format
  msgid "<anonymous %s>"
-msgstr "<anonymous>"
+msgstr "<анонимный %s>"
  
  #. A lambda's "type" is essentially its signature.
  #: cp/error.c:691
  msgid "<lambda"
-msgstr ""
+msgstr "<lambda"
  
  #: cp/error.c:821
  msgid "<typeprefixerror>"
-msgstr ""
+msgstr "<typeprefixerror>"
  
  #: cp/error.c:950
-#, fuzzy, c-format
+#, c-format
  msgid "(static initializers for %s)"
-msgstr "избыточные элементы в инициализаторе для %qT"
+msgstr "(статические инициализаторы для %s)"
  
  #: cp/error.c:952
  #, c-format
  msgid "(static destructors for %s)"
-msgstr ""
+msgstr "(статические деструкторы для %s)"
  
  #: cp/error.c:1060
  msgid "vtable for "
-msgstr ""
+msgstr "vtable для "
  
  #: cp/error.c:1084
  msgid "<return value> "
-msgstr ""
+msgstr "<возвращаемое значение> "
  
  #: cp/error.c:1099
-#, fuzzy
  msgid "{anonymous}"
-msgstr "<anonymous>"
+msgstr "{anonymous}"
  
  #: cp/error.c:1101
  #, fuzzy
+#| msgid "(anonymous)"
  msgid "(anonymous namespace)"
  msgstr "(anonymous)"
  
  #: cp/error.c:1217
-#, fuzzy
  msgid "<template arguments error>"
-msgstr "параметр шаблона `%#D'"
+msgstr "<ошибка параметра шаблона>"
  
  #: cp/error.c:1239
  msgid "<enumerator>"
-msgstr ""
+msgstr "<enumerator>"
  
  #: cp/error.c:1279
-#, fuzzy
  msgid "<declaration error>"
-msgstr "декларация %q#D"
+msgstr "<ошибка декларации>"
  
  #: cp/error.c:1808 cp/error.c:1828
-#, fuzzy
  msgid "<template parameter error>"
-msgstr "параметр шаблона `%#D'"
+msgstr "<ошибка параметра шаблона>"
  
  #: cp/error.c:1958
-#, fuzzy
  msgid "<statement>"
-msgstr "ожидался оператор"
+msgstr "<оператор>"
  
  #: cp/error.c:1985 cp/error.c:3027 c-family/c-pretty-print.c:2182
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "<unknown>"
-msgstr "Неизвестный источник"
+msgstr "<неизвестный>"
  
  #. While waiting for caret diagnostics, avoid printing
  #. __cxa_allocate_exception, __cxa_throw, and the like.
  #: cp/error.c:2003
-#, fuzzy
  msgid "<throw-expression>"
-msgstr "  в throw-выражении"
+msgstr "<throw-выражение>"
  
  #: cp/error.c:2104
  msgid "<ubsan routine call>"
@@ -4665,11 +4741,13 @@ msgstr ""
  
  #: cp/error.c:2561
  msgid "<unparsed>"
-msgstr ""
+msgstr "<unparsed>"
  
  #: cp/error.c:2708
+#, fuzzy
+#| msgid "<lambda"
  msgid "<lambda>"
-msgstr ""
+msgstr "<lambda"
  
  #: cp/error.c:2750
  msgid "*this"
@@ -4677,113 +4755,118 @@ msgstr ""
  
  #: cp/error.c:2760
  msgid "<expression error>"
-msgstr ""
+msgstr "<ошибка выражения>"
  
  #: cp/error.c:2775
-#, fuzzy
  msgid "<unknown operator>"
-msgstr "Неизвестный оператор '%s' в %%L"
+msgstr "<Неизвестный оператор>"
  
  #: cp/error.c:3071
-#, fuzzy
  msgid "{unknown}"
-msgstr "Неизвестный источник"
+msgstr "{неизвестный}"
  
  #: cp/error.c:3183
  msgid "At global scope:"
-msgstr ""
+msgstr "На глобальном уровне:"
  
  #: cp/error.c:3289
-#, fuzzy, c-format
+#, c-format
  msgid "In static member function %qs"
-msgstr "В функции-члене %qs"
+msgstr "Ð\92 Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ñ\87Ð»ÐµÐ½Ðµ %qs"
  
  #: cp/error.c:3291
  #, c-format
  msgid "In copy constructor %qs"
-msgstr ""
+msgstr "В конструкторе копирования %qs"
  
  #: cp/error.c:3293
-#, fuzzy, c-format
+#, c-format
  msgid "In constructor %qs"
-msgstr "В функции %qs"
+msgstr "В конструкторе %qs"
  
  #: cp/error.c:3295
-#, fuzzy, c-format
+#, c-format
  msgid "In destructor %qs"
-msgstr "В функции %qs"
+msgstr "В деструкторе %qs"
  
  #: cp/error.c:3297
-#, fuzzy
  msgid "In lambda function"
-msgstr "В функции-члене %qs"
+msgstr "В lambda функции"
  
  #: cp/error.c:3317
-#, fuzzy, c-format
+#, c-format
  msgid "%s: In substitution of %qS:\n"
-msgstr "  в конкретизации шаблона %qT"
+msgstr "%s: В подстановке %qS:\n"
  
  #: cp/error.c:3318
-#, fuzzy
  msgid "%s: In instantiation of %q#D:\n"
-msgstr "  в конкретизации шаблона %qT"
+msgstr "%s: В конкретизации %q#D:\n"
  
  #: cp/error.c:3343
  #, fuzzy
+#| msgid "%s:%d:%d:   "
  msgid "%r%s:%d:%d:%R   "
-msgstr "%s: %s"
+msgstr "%s:%d:%d"
  
  #: cp/error.c:3346
  #, fuzzy
+#| msgid "%s:%d:   "
  msgid "%r%s:%d:%R   "
-msgstr "%s: %s"
+msgstr "%s:%d:   "
  
  #: cp/error.c:3354
  #, c-format
  msgid "recursively required by substitution of %qS\n"
-msgstr ""
+msgstr "рекурсивно требуемый при подстановке %qS\n"
  
  #: cp/error.c:3355
  #, c-format
  msgid "required by substitution of %qS\n"
-msgstr ""
+msgstr "требуемый при подстановке %qS\n"
  
  #: cp/error.c:3360
  msgid "recursively required from %q#D\n"
-msgstr ""
+msgstr "рекурсивно требуемый из %q#D\n"
  
  #: cp/error.c:3361
-#, fuzzy
  msgid "required from %q#D\n"
-msgstr "задано для %q+D"
+msgstr "требуемый из %q#D\n"
  
  #: cp/error.c:3368
  #, fuzzy
+#| msgid "recursively required from here"
  msgid "recursively required from here\n"
-msgstr "которая вызвана здесь"
+msgstr "рекурсивно требуемый отсюда"
  
  #: cp/error.c:3369
  #, fuzzy
+#| msgid "required from here"
  msgid "required from here\n"
-msgstr "которая вызвана здесь"
+msgstr "требуемый отсюда"
  
  #: cp/error.c:3421
+#, fuzzy
+#| msgid "%s:%d:%d:   [ skipping %d instantiation contexts ]\n"
  msgid "%r%s:%d:%d:%R   [ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
-msgstr ""
+msgstr "%s:%d:%d:   [ пропуск %d контекстов конкретизации ]\n"
  
  #: cp/error.c:3427
+#, fuzzy
+#| msgid "%s:%d:%d:   [ skipping %d instantiation contexts ]\n"
  msgid "%r%s:%d:%R   [ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n"
-msgstr ""
+msgstr "%s:%d:%d:   [ пропуск %d контекстов конкретизации ]\n"
  
  #: cp/error.c:3481
  #, fuzzy
+#| msgid "%s:%d:%d:   in constexpr expansion of %qs"
  msgid "%r%s:%d:%d:%R   in constexpr expansion of %qs"
-msgstr "    включённом из %qs"
+msgstr "%s:%d:%d:   в раскрытии константного выражения %qs"
  
  #: cp/error.c:3485
  #, fuzzy
+#| msgid "%s:%d:   in constexpr expansion of %qs"
  msgid "%r%s:%d:%R   in constexpr expansion of %qs"
-msgstr "    включённом из %qs"
+msgstr "%s:%d:   в раскрытии константного выражения %qs"
  
  #: cp/pt.c:1947 cp/semantics.c:5220
  msgid "candidates are:"
@@ -4792,57 +4875,49 @@ msgstr "претенденты:"
  #: cp/pt.c:21038
  msgid "candidate is:"
  msgid_plural "candidates are:"
-msgstr[0] ""
-msgstr[1] ""
-msgstr[2] ""
+msgstr[0] "кандидат"
+msgstr[1] "кандидаты"
+msgstr[2] "кандидаты"
  
  #: cp/rtti.c:545
-#, fuzzy
  msgid "target is not pointer or reference to class"
-msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ñ\87Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
+msgstr "Ñ\86ÐµÐ»Ñ\8c Ð½Ðµ ÐµÑ\81Ñ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð¸Ð»Ð¸ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ð° ÐºÐ»Ð°Ñ\81Ñ\81"
  
  #: cp/rtti.c:550
-#, fuzzy
  msgid "target is not pointer or reference to complete type"
-msgstr "арифметическая операция над указателем на неполный тип"
+msgstr "цель не есть указатель или ссылка на полный тип"
  
  #: cp/rtti.c:556
-#, fuzzy
  msgid "target is not pointer or reference"
-msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ñ\87Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
+msgstr "Ñ\86ÐµÐ»Ñ\8c Ð½Ðµ ÐµÑ\81Ñ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð¸Ð»Ð¸ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ°"
  
  #: cp/rtti.c:572
-#, fuzzy
  msgid "source is not a pointer"
-msgstr "Ð±Ð°Ð·Ð¾Ð²Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ %<->%> Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼"
+msgstr "Ð¸Ñ\81Ñ\82Ð¾Ñ\87Ð½Ð¸Ðº Ð½Ðµ ÐµÑ\81Ñ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c"
  
  #: cp/rtti.c:577
  msgid "source is not a pointer to class"
-msgstr ""
+msgstr "источник не есть указатель на класс"
  
  #: cp/rtti.c:582
-#, fuzzy
  msgid "source is a pointer to incomplete type"
-msgstr "Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿ Ð¿Ð¾ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8e на неполный тип"
+msgstr "Ð¸Ñ\81Ñ\82Ð¾Ñ\87Ð½Ð¸Ðº ÐµÑ\81Ñ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c на неполный тип"
  
  #: cp/rtti.c:597
-#, fuzzy
  msgid "source is not of class type"
-msgstr "%qE не класс"
+msgstr "источник не имеет тип класса"
  
  #: cp/rtti.c:602
-#, fuzzy
  msgid "source is of incomplete class type"
-msgstr "тип возвращаемого значения не полный"
+msgstr "источник имеет неполный тип класса"
  
  #: cp/rtti.c:611
-#, fuzzy
  msgid "conversion casts away constness"
-msgstr "преобразование из %qT в %qT неоднозначно"
+msgstr "преобразование типа отбрасывает константность"
  
  #: cp/rtti.c:767
  msgid "source type is not polymorphic"
-msgstr ""
+msgstr "тип источника не является полиморфным"
  
  #: cp/typeck.c:5820 c/c-typeck.c:4093
  #, gcc-internal-format
@@ -4870,27 +4945,24 @@ msgid "wrong type argument to conjugation"
  msgstr "неверный тип аргумента для сопряжения"
  
  #: cp/typeck.c:5885
-#, fuzzy
  msgid "in argument to unary !"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° Ð´Ð»Ñ\8f Ñ\83Ð½Ð°Ñ\80Ð½Ð¾Ð³Ð¾ Ð¿Ð»Ñ\8eÑ\81Ð°"
+msgstr "Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ Ñ\83Ð½Ð°Ñ\80Ð½Ð¾Ð³Ð¾ !"
  
  #: cp/typeck.c:5931
-#, fuzzy
  msgid "no pre-increment operator for type"
-msgstr "нельзя %s указатель на неполный тип %qT"
+msgstr "нет преинкрементного оператора для типа"
  
  #: cp/typeck.c:5933
  msgid "no post-increment operator for type"
-msgstr ""
+msgstr "нет постинкрементного оператора для типа"
  
  #: cp/typeck.c:5935
-#, fuzzy
  msgid "no pre-decrement operator for type"
-msgstr "нельзя %s указатель на неполный тип %qT"
+msgstr "нет предекрементного оператора для типа"
  
  #: cp/typeck.c:5937
  msgid "no post-decrement operator for type"
-msgstr ""
+msgstr "нет постдекрементного оператора для типа"
  
  #: fortran/arith.c:95
  msgid "Arithmetic OK at %L"
@@ -4918,32 +4990,32 @@ msgstr "Массивы в операции несоразмерны в %L"
  
  #: fortran/arith.c:114
  msgid "Integer outside symmetric range implied by Standard Fortran at %L"
-msgstr ""
+msgstr "Целое вне симметричного диапазона предписанного Standard Fortran в %L"
  
  #: fortran/arith.c:1370
-#, fuzzy
  msgid "elemental binary operation"
-msgstr "В подпрограмме"
+msgstr "элементная бинарная операция"
  
  #: fortran/check.c:2124 fortran/check.c:3115 fortran/check.c:3169
  #, c-format
  msgid "arguments '%s' and '%s' for intrinsic %s"
-msgstr ""
+msgstr "аргументы '%s' и '%s' для внутренней функции %s"
  
  #: fortran/check.c:2921
  #, c-format
  msgid "arguments 'a%d' and 'a%d' for intrinsic '%s'"
-msgstr ""
+msgstr "аргументы 'a%d' и 'a%d' для внутренней функции '%s'"
  
  #: fortran/check.c:3444 fortran/intrinsic.c:4290
  #, c-format
  msgid "arguments '%s' and '%s' for intrinsic '%s'"
-msgstr ""
+msgstr "аргументы '%s' и '%s' для внутренней функции '%s'"
  
  #: fortran/error.c:873
  #, fuzzy
+#| msgid "Fortran 2008 obsolescent feature: ENTRY statement at %C"
  msgid "Fortran 2008 obsolescent feature:"
-msgstr "Недопустимое число в операторе FORMAT в %0"
+msgstr "Fortran 2008 устаревшая возможность: ENTRY оператор в %C"
  
  #: fortran/error.c:882
  msgid "GNU Extension:"
@@ -4955,13 +5027,15 @@ msgstr ""
  
  #: fortran/error.c:888
  #, fuzzy
+#| msgid "Obsolescent feature: Computed GOTO at %C"
  msgid "Obsolescent feature:"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð°Ñ\8f Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ñ\8c: Ð\92Ñ\8bÑ\87Ð¸Ñ\81Ð»Ñ\8fÐµÐ¼Ñ\8bÐ¹ GOTO Ð² %C"
  
  #: fortran/error.c:891
  #, fuzzy
+#| msgid "expected operator"
  msgid "Deleted feature:"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80"
  
  #: fortran/expr.c:622
  #, c-format
@@ -4979,23 +5053,21 @@ msgid "Integer value too large in expression at %C"
  msgstr "Переполнение при вычислении выражения в %C"
  
  #: fortran/expr.c:3242
-#, fuzzy
  msgid "array assignment"
-msgstr "Ð\9fрисваивание массивов"
+msgstr "Ð¿рисваивание массивов"
  
  #: fortran/gfortranspec.c:425
-#, fuzzy, c-format
+#, c-format
  msgid "Driving:"
-msgstr "Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ðµ:"
+msgstr "Ð\94Ð²Ð¸Ð¶Ñ\83Ñ\89Ð¸Ð¹:"
  
  #: fortran/interface.c:2941 fortran/intrinsic.c:3994
  msgid "actual argument to INTENT = OUT/INOUT"
-msgstr ""
+msgstr "фактический аргумент для INTENT = OUT/INOUT"
  
  #: fortran/io.c:550
-#, fuzzy
  msgid "Positive width required"
-msgstr "Ð¢Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð½ÐµÐ¾Ñ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ð°Ñ\8f Ñ\88Ð¸Ñ\80Ð¸Ð½Ð°"
+msgstr "Ð¨Ð¸Ñ\80Ð¸Ð½Ð° Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ð¾Ð»Ð¾Ð¶Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð°Ñ\8f"
  
  #: fortran/io.c:551
  msgid "Nonnegative width required"
@@ -5003,17 +5075,17 @@ msgstr "Требуется неотрицательная ширина"
  
  #: fortran/io.c:552
  #, fuzzy
+#| msgid "Unexpected element '%c' in format string at %L"
  msgid "Unexpected element %qc in format string at %L"
-msgstr "Неожиданное окончание строки формата"
+msgstr "Неожиданный элемент '%c' в строке формата в %L"
  
  #: fortran/io.c:554
  msgid "Unexpected end of format string"
  msgstr "Неожиданное окончание строки формата"
  
  #: fortran/io.c:555
-#, fuzzy
  msgid "Zero width in format descriptor"
-msgstr "Ð½Ñ\83Ð»ÐµÐ²Ð°Ñ\8f Ñ\88Ð¸Ñ\80Ð¸Ð½Ð° Ð² Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ðµ %s"
+msgstr "Ð\9dÑ\83Ð»ÐµÐ²Ð°Ñ\8f Ñ\88Ð¸Ñ\80Ð¸Ð½Ð° Ð² Ð´ÐµÑ\81ÐºÑ\80Ð¸Ð¿Ñ\82Ð¾Ñ\80Ðµ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
  
  #: fortran/io.c:575
  msgid "Missing leading left parenthesis"
@@ -5021,62 +5093,59 @@ msgstr "Отсутствует открывающая скобка"
  
  #: fortran/io.c:604
  #, fuzzy
-#| msgid "template argument required for %<%s %T%>"
+#| msgid "Left parenthesis required after '*'"
  msgid "Left parenthesis required after %<*%>"
-msgstr "Ð´Ð»Ñ\8f %<%s %T%> Ð½Ñ\83Ð¶ÐµÐ½ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82-Ñ\88Ð°Ð±Ð»Ð¾Ð½"
+msgstr "Ð\9bÐµÐ²Ð°Ñ\8f Ñ\81ÐºÐ¾Ð±ÐºÐ° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ '*'"
  
  #: fortran/io.c:635
  msgid "Expected P edit descriptor"
-msgstr ""
+msgstr "Ожидался P дескриптор редактирования"
  
  #. P requires a prior number.
  #: fortran/io.c:643
  msgid "P descriptor requires leading scale factor"
-msgstr ""
+msgstr "P дескриптор требует предшествующий масштабный множитель"
  
  #: fortran/io.c:736 fortran/io.c:750
  msgid "Comma required after P descriptor"
-msgstr ""
+msgstr "Запятая требуется после P дескриптора"
  
  #: fortran/io.c:764
-#, fuzzy
  msgid "Positive width required with T descriptor"
-msgstr "Ð¢Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð½ÐµÐ¾Ñ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ð°Ñ\8f Ñ\88Ð¸Ñ\80Ð¸Ð½Ð°"
+msgstr "Ð\9fÐ¾Ð»Ð¾Ð¶Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð°Ñ\8f Ñ\88Ð¸Ñ\80Ð¸Ð½Ð° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ñ\81 T Ð´ÐµÑ\81ÐºÑ\80Ð¸Ð¿Ñ\82Ð¾Ñ\80Ð¾Ð¼"
  
  #: fortran/io.c:843
  msgid "E specifier not allowed with g0 descriptor"
-msgstr ""
+msgstr "E спецификатор не допускается с g0 дескриптором"
  
  #: fortran/io.c:913
-#, fuzzy
  msgid "Positive exponent width required"
-msgstr "Ð¢Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð½ÐµÐ¾Ñ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ð°Ñ\8f Ñ\88Ð¸Ñ\80Ð¸Ð½Ð°"
+msgstr "Ð\9fÐ¾Ð»Ð¾Ð¶Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð°Ñ\8f Ñ\88Ð¸Ñ\80Ð¸Ð½Ð° Ñ\8dÐºÑ\81Ð¿Ð¾Ð½ÐµÐ½Ñ\82Ñ\8b Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
  
  #: fortran/io.c:943
-#, fuzzy
  msgid "Period required in format specifier"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 формата"
+msgstr "Ð¢Ð¾Ñ\87ÐºÐ° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð² Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ðµ формата"
  
  #: fortran/io.c:1570
  #, c-format
  msgid "%s tag"
-msgstr ""
+msgstr "%s тег"
  
  #: fortran/io.c:2966
  msgid "internal unit in WRITE"
-msgstr ""
+msgstr "внутреннее устройство в WRITE"
  
  #. 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:4185
  #, c-format
  msgid "%s tag with INQUIRE"
-msgstr ""
+msgstr "%s тег с INQUIRE"
  
  #: fortran/matchexp.c:28
-#, fuzzy, c-format
+#, c-format
  msgid "Syntax error in expression at %C"
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ð² %C"
  
  #: fortran/module.c:1204
  msgid "Unexpected EOF"
@@ -5119,98 +5188,84 @@ msgid "find_enum(): Enum not found"
  msgstr "find_enum(): перечисление не найдено"
  
  #: fortran/module.c:2265
-#, fuzzy
  msgid "Expected attribute bit name"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 packed Ð½Ðµ Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð½Ð¾Ð³Ð¾ Ð±Ð¸Ñ\82Ð°"
  
  #: fortran/module.c:3150
-#, fuzzy
  msgid "Expected integer string"
-msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð¾Ðµ Ð¾ÐºÐ¾Ð½Ñ\87Ð°Ð½Ð¸Ðµ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82а"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c integer Ñ\81Ñ\82Ñ\80Ð¾Ðºа"
  
  #: fortran/module.c:3154
  msgid "Error converting integer"
-msgstr ""
+msgstr "Ошибка при преобразовании целого"
  
  #: fortran/module.c:3176
-#, fuzzy
  msgid "Expected real string"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c real Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
  
  #: fortran/module.c:3400
-#, fuzzy
  msgid "Expected expression type"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ñ\82Ð¸Ð¿ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
  
  #: fortran/module.c:3480
-#, fuzzy
  msgid "Bad operator"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80"
  
  #: fortran/module.c:3595
-#, fuzzy
  msgid "Bad type in constant expression"
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð² ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
  
  #: fortran/module.c:6939
-#, fuzzy
  msgid "Unexpected end of module"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ ÐºÐ¾Ð½ÐµÑ\86 Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8f"
  
  #: fortran/parse.c:1592
  msgid "arithmetic IF"
-msgstr ""
+msgstr "арифметический IF"
  
  #: fortran/parse.c:1601
-#, fuzzy
  msgid "attribute declaration"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð°"
  
  #: fortran/parse.c:1637
-#, fuzzy
  msgid "data declaration"
-msgstr "Ð¿Ñ\83Ñ\81Ñ\82Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð´Ð°Ð½Ð½Ñ\8bÑ\85"
  
  #: fortran/parse.c:1646
-#, fuzzy
  msgid "derived type declaration"
-msgstr "Ð¿Ñ\83Ñ\81Ñ\82Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð¿Ñ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð°"
  
  #: fortran/parse.c:1749
  msgid "block IF"
-msgstr ""
+msgstr "блочный IF"
  
  #: fortran/parse.c:1758
  msgid "implied END DO"
-msgstr ""
+msgstr "предписанный END DO"
  
  #: fortran/parse.c:1852 fortran/resolve.c:10531
  msgid "assignment"
  msgstr "присваивание"
  
  #: fortran/parse.c:1855 fortran/resolve.c:10582 fortran/resolve.c:10585
-#, fuzzy
  msgid "pointer assignment"
-msgstr "присваивание"
+msgstr "присваивание указателя"
  
  #: fortran/parse.c:1873
  msgid "simple IF"
-msgstr ""
+msgstr "простой IF"
  
  #: fortran/resolve.c:606
-#, fuzzy
  msgid "module procedure"
-msgstr "Ð\92 Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ðµ"
+msgstr "Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8f"
  
  #: fortran/resolve.c:607
-#, fuzzy
  msgid "internal function"
-msgstr "%qs объявлена как функция, возвращающая функцию"
+msgstr "внутренняя функция"
  
  #: fortran/resolve.c:2151 fortran/resolve.c:2345
-#, fuzzy
  msgid "elemental procedure"
-msgstr "В подпрограмме"
+msgstr "элементная процедура"
  
  #: fortran/resolve.c:2248
  #, fuzzy
@@ -5220,28 +5275,33 @@ msgstr "отсутствуют аргументы"
  
  #: fortran/resolve.c:2253
  #, fuzzy
+#| msgid "not enough arguments"
  msgid "asynchronous argument"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b"
+msgstr "Ð½ÐµÐ´Ð¾Ñ\81Ñ\82Ð°Ñ\82Ð¾Ñ\87Ð½Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð²"
  
  #: fortran/resolve.c:2258
  #, fuzzy
+#| msgid "invalid PHI argument"
  msgid "optional argument"
-msgstr "некорректный тип аргумента"
+msgstr "некорректный аргумент PHI"
  
  #: fortran/resolve.c:2263
  #, fuzzy
+#| msgid "pointer assignment"
  msgid "pointer argument"
-msgstr "присваивание"
+msgstr "присваивание указателя"
  
  #: fortran/resolve.c:2268
  #, fuzzy
+#| msgid "too many arguments"
  msgid "target argument"
-msgstr "слишком много аргументов для форматирования"
+msgstr "слишком много аргументов"
  
  #: fortran/resolve.c:2273
  #, fuzzy
+#| msgid "invalid PHI argument"
  msgid "value argument"
-msgstr "некорректный тип аргумента"
+msgstr "некорректный аргумент PHI"
  
  #: fortran/resolve.c:2278
  #, fuzzy
@@ -5263,8 +5323,9 @@ msgstr "несовпадающие аргументы"
  
  #: fortran/resolve.c:2293
  #, fuzzy
+#| msgid "array assignment"
  msgid "coarray argument"
-msgstr "Ð\9fрисваивание массивов"
+msgstr "Ð¿рисваивание массивов"
  
  #: fortran/resolve.c:2298
  msgid "parametrized derived type argument"
@@ -5293,63 +5354,70 @@ msgid "array result"
  msgstr ""
  
  #: fortran/resolve.c:2331
+#, fuzzy
+#| msgid "Coindexed allocatable object at %L"
  msgid "pointer or allocatable result"
-msgstr ""
+msgstr "Коиндексированный размещаемый объект в %L"
  
  #: fortran/resolve.c:2338
  #, fuzzy
+#| msgid "COMMON variable '%s' at %L must have constant character length"
  msgid "result with non-constant character length"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "COMMON переменная '%s' в %L должна иметь константную character длину"
  
  #: fortran/resolve.c:2350
  #, fuzzy
+#| msgid "module procedure"
  msgid "bind(c) procedure"
-msgstr "Ð\92 Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ðµ"
+msgstr "Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8f"
  
  #: fortran/resolve.c:3552
  #, c-format
  msgid "Invalid context for NULL() pointer at %%L"
-msgstr ""
+msgstr "Некорректный контекст для NULL() указателя в %%L"
  
  #: fortran/resolve.c:3568
  #, fuzzy, c-format
+#| msgid "Operand of unary numeric operator '%s' at %%L is %s"
  msgid "Operand of unary numeric operator %%<%s%%> at %%L is %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82ÐµÐ»Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ `asm'"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ð½Ð´ Ñ\83Ð½Ð°Ñ\80Ð½Ð¾Ð³Ð¾ Ñ\87Ð¸Ñ\81Ð»Ð¾Ð²Ð¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° '%s' Ð² %%L ÐµÑ\81Ñ\82Ñ\8c %s"
  
  #: fortran/resolve.c:3584
  #, fuzzy, c-format
+#| msgid "Operands of binary numeric operator '%s' at %%L are %s/%s"
  msgid "Operands of binary numeric operator %%<%s%%> at %%L are %s/%s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82ÐµÐ»Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ `asm'"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð³Ð¾ Ñ\87Ð¸Ñ\81Ð»Ð¾Ð²Ð¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° '%s' Ð² %%L ÐµÑ\81Ñ\82Ñ\8c %s/%s"
  
  #: fortran/resolve.c:3599
  #, c-format
  msgid "Operands of string concatenation operator at %%L are %s/%s"
-msgstr ""
+msgstr "Операнды оператора конкатенации строк в %%L есть %s/%s"
  
  #: fortran/resolve.c:3618
  #, fuzzy, c-format
+#| msgid "Operands of logical operator '%s' at %%L are %s/%s"
  msgid "Operands of logical operator %%<%s%%> at %%L are %s/%s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82ÐµÐ»Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ `asm'"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð»Ð¾Ð³Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° '%s' Ð² %%L ÐµÑ\81Ñ\82Ñ\8c %s/%s"
  
  #: fortran/resolve.c:3632
-#, fuzzy, c-format
+#, c-format
  msgid "Operand of .not. operator at %%L is %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82ÐµÐ»Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ `asm'"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ð½Ð´ .not. Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %%L ÐµÑ\81Ñ\82Ñ\8c %s"
  
  #: fortran/resolve.c:3646
-#, fuzzy
  msgid "COMPLEX quantities cannot be compared at %L"
-msgstr "квалификаторы `%V' не могут быть применены к %qT"
+msgstr "COMPLEX величины не могут сравниваться в %L"
  
  #: fortran/resolve.c:3697
  #, c-format
  msgid "Logicals at %%L must be compared with %s instead of %s"
-msgstr ""
+msgstr "Логические в %%L должны сравниваться посредством %s вместо %s"
  
  #: fortran/resolve.c:3703
  #, fuzzy, c-format
+#| msgid "Operands of comparison operator '%s' at %%L are %s/%s"
  msgid "Operands of comparison operator %%<%s%%> at %%L are %s/%s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82ÐµÐ»Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ `asm'"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8f '%s' Ð² %%L ÐµÑ\81Ñ\82Ñ\8c %s/%s"
  
  #: fortran/resolve.c:3711
  #, fuzzy, c-format
@@ -5359,91 +5427,88 @@ msgstr "Неизвестный оператор '%s' в %%L"
  
  #: fortran/resolve.c:3714
  #, fuzzy, c-format
+#| msgid "Operand of user operator '%s' at %%L is %s"
  msgid "Operand of user operator %%<%s%%> at %%L is %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82ÐµÐ»Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ `asm'"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ð½Ð´ Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82ÐµÐ»Ñ\8cÑ\81ÐºÐ¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° '%s' Ð² %%L ÐµÑ\81Ñ\82Ñ\8c %s"
  
  #: fortran/resolve.c:3718
  #, fuzzy, c-format
+#| msgid "Operands of user operator '%s' at %%L are %s/%s"
  msgid "Operands of user operator %%<%s%%> at %%L are %s/%s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82ÐµÐ»Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ `asm'"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82ÐµÐ»Ñ\8cÑ\81ÐºÐ¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° '%s' Ð² %%L ÐµÑ\81Ñ\82Ñ\8c %s/%s"
  
  #: fortran/resolve.c:3806
-#, fuzzy, c-format
+#, c-format
  msgid "Inconsistent ranks for operator at %%L and %%L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82ÐµÐ»Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ `asm'"
+msgstr "Ð\9fÑ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ð²Ñ\8bÐµ Ñ\80Ð°Ð½Ð³Ð¸ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %%L Ð¸ %%L"
  
  #: fortran/resolve.c:6470
  msgid "Loop variable"
-msgstr ""
+msgstr "Переменная цикла"
  
  #: fortran/resolve.c:6474
-#, fuzzy
  msgid "iterator variable"
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¾Ñ\82Ñ\81Ð»ÐµÐ¶Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ð¸Ñ\82ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð°"
  
  #: fortran/resolve.c:6478
  msgid "Start expression in DO loop"
-msgstr ""
+msgstr "Начальное выражение в DO цикле"
  
  #: fortran/resolve.c:6482
-#, fuzzy
  msgid "End expression in DO loop"
-msgstr "Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð·Ð°Ð´Ð°Ð½Ð¾ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸е"
+msgstr "Ð\9aÐ¾Ð½ÐµÑ\87Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² DO Ñ\86Ð¸ÐºÐ»е"
  
  #: fortran/resolve.c:6486
-#, fuzzy
  msgid "Step expression in DO loop"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸е"
+msgstr "Ð¨Ð°Ð³Ð¾Ð²Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² DO Ñ\86Ð¸ÐºÐ»е"
  
  #: fortran/resolve.c:6743 fortran/resolve.c:6746
-#, fuzzy
  msgid "DEALLOCATE object"
-msgstr "DEALLOCATE "
+msgstr "DEALLOCATE объект"
  
  #: fortran/resolve.c:7113 fortran/resolve.c:7116
-#, fuzzy
  msgid "ALLOCATE object"
-msgstr "ALLOCATE "
+msgstr "ALLOCATE объект"
  
  #: fortran/resolve.c:7345 fortran/resolve.c:8792
  msgid "STAT variable"
-msgstr ""
+msgstr "STAT переменная"
  
  #: fortran/resolve.c:7389 fortran/resolve.c:8804
  msgid "ERRMSG variable"
-msgstr ""
+msgstr "ERRMSG переменная"
  
  #: fortran/resolve.c:8634
  msgid "item in READ"
-msgstr ""
+msgstr "элемент в READ"
  
  #: fortran/resolve.c:8816
  msgid "ACQUIRED_LOCK variable"
-msgstr ""
+msgstr "ACQUIRED_LOCK переменная"
  
  #: fortran/trans-array.c:1428
  #, c-format
  msgid "Different CHARACTER lengths (%ld/%ld) in array constructor"
-msgstr ""
+msgstr "Разные CHARACTER длины (%ld/%ld) в конструкторе массива"
  
  #: fortran/trans-array.c:5484
  msgid "Integer overflow when calculating the amount of memory to allocate"
-msgstr ""
+msgstr "Целочисленное переполнение при вычислении объема памяти для размещения"
  
  #: fortran/trans-decl.c:5490
-#, fuzzy, c-format
+#, c-format
  msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð´Ð»Ð¸Ð½Ð° Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð½Ðµ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð¹ Ð´Ð»Ñ\8f Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° '%s' (%ld/%ld)"
  
  #: fortran/trans-decl.c:5498
-#, fuzzy, c-format
+#, c-format
  msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð´Ð»Ð¸Ð½Ð° Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð¼ÐµÐ½Ñ\8cÑ\88Ðµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð¹ Ð´Ð»Ñ\8f Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° '%s' (%ld/%ld)"
  
  #: fortran/trans-expr.c:8140
  #, c-format
  msgid "Target of rank remapping is too small (%ld < %ld)"
-msgstr ""
+msgstr "Цель переотображения ранга слишком мала (%ld < %ld)"
  
  #: fortran/trans-expr.c:9345
  msgid "Assignment of scalar to unallocated array"
@@ -5452,44 +5517,41 @@ msgstr ""
  #: fortran/trans-intrinsic.c:897
  #, c-format
  msgid "Unequal character lengths (%ld/%ld) in %s"
-msgstr ""
+msgstr "Неравные character длины (%ld/%ld) в %s"
  
  #: fortran/trans-intrinsic.c:7002
-#, fuzzy, c-format
+#, c-format
  msgid "Argument NCOPIES of REPEAT intrinsic is negative (its value is %ld)"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 NCOPIES Ð¾Ñ\82 REPEAT Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð¾Ñ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»ÐµÐ½ (ÐµÐ³Ð¾ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ñ\80Ð°Ð²Ð½Ð¾ %ld)"
  
  #: fortran/trans-intrinsic.c:7034
  msgid "Argument NCOPIES of REPEAT intrinsic is too large"
-msgstr ""
+msgstr "Аргумент NCOPIES от REPEAT встроенной функции слишком велик"
  
  #: fortran/trans-io.c:560
-#, fuzzy
  msgid "Unit number in I/O statement too small"
-msgstr "синтаксическая ошибка при разборе `%s'"
+msgstr "Номер устройства в операторе ввода/вывода слишком мал"
  
  #: fortran/trans-io.c:569
-#, fuzzy
  msgid "Unit number in I/O statement too large"
-msgstr "синтаксическая ошибка при разборе `%s'"
+msgstr "Номер устройства в операторе ввода/вывода слишком велик"
  
  #: fortran/trans-stmt.c:156
-#, fuzzy
  msgid "Assigned label is not a target label"
-msgstr "case-метки не отсортированы"
+msgstr "Assigned метка не есть целевая метка"
  
  #: fortran/trans-stmt.c:1101
  #, c-format
  msgid "Invalid image number %d in SYNC IMAGES"
-msgstr ""
+msgstr "Некорректный image номер %d в SYNC IMAGES"
  
  #: fortran/trans-stmt.c:1898 fortran/trans-stmt.c:2183
  msgid "Loop variable has been modified"
-msgstr ""
+msgstr "Переменная цикла изменена"
  
  #: fortran/trans-stmt.c:2038
  msgid "DO step value is zero"
-msgstr ""
+msgstr "Значение DO шага нулевое"
  
  #: fortran/trans.c:47
  msgid "Array reference out of bounds"
@@ -5500,27 +5562,26 @@ msgid "Incorrect function return value"
  msgstr "Некорректной результат функции"
  
  #: fortran/trans.c:607
-#, fuzzy
  msgid "Memory allocation failed"
-msgstr "Ð¡Ð²Ð¾Ð±Ð¾Ð´Ð½Ð°Ñ\8f Ð¿Ð°Ð¼Ñ\8fÑ\82Ñ\8c Ð·Ð°ÐºÐ¾Ð½Ñ\87Ð¸Ð»Ð°Ñ\81Ñ\8c - malloc() Ð·Ð°Ð²ÐµÑ\80Ñ\88Ð¸Ð»Ñ\81Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ¾Ð¹"
+msgstr "Ð\9eÑ\88Ð¸Ð±ÐºÐ° Ð²Ñ\8bÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸"
  
  #: fortran/trans.c:688 fortran/trans.c:1527
  msgid "Allocation would exceed memory limit"
-msgstr ""
+msgstr "Размещение превысит лимит памяти"
  
  #: fortran/trans.c:858
  #, c-format
  msgid "Attempting to allocate already allocated variable '%s'"
-msgstr ""
+msgstr "Попытка разместить уже размещенную переменную '%s'"
  
  #: fortran/trans.c:864
  msgid "Attempting to allocate already allocated variable"
-msgstr ""
+msgstr "Попытка разместить уже размещенную переменную"
  
  #: fortran/trans.c:1274 fortran/trans.c:1428
  #, c-format
  msgid "Attempt to DEALLOCATE unallocated '%s'"
-msgstr ""
+msgstr "Попытка DEALLOCATE неразмещенную '%s'"
  
  #. The remainder are real diagnostic types.
  #: fortran/gfc-diagnostic.def:33
@@ -5597,25 +5658,24 @@ msgstr "ошибка: "
  
  #: go/go-backend.c:171
  msgid "lseek failed while reading export data"
-msgstr ""
+msgstr "ошибка lseek при чтении экспортных данных"
  
  #: go/go-backend.c:178
-#, fuzzy
  msgid "memory allocation failed while reading export data"
-msgstr "Ð¡Ð²Ð¾Ð±Ð¾Ð´Ð½Ð°Ñ\8f Ð¿Ð°Ð¼Ñ\8fÑ\82Ñ\8c Ð·Ð°ÐºÐ¾Ð½Ñ\87Ð¸Ð»Ð°Ñ\81Ñ\8c - malloc() Ð·Ð°Ð²ÐµÑ\80Ñ\88Ð¸Ð»Ñ\81Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ¾Ð¹"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð²Ñ\8bÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸ Ð¿Ñ\80Ð¸ Ñ\87Ñ\82ÐµÐ½Ð¸Ð¸ Ñ\8dÐºÑ\81Ð¿Ð¾Ñ\80Ñ\82Ð½Ñ\8bÑ\85 Ð´Ð°Ð½Ð½Ñ\8bÑ\85"
  
  #: go/go-backend.c:186
  msgid "read failed while reading export data"
-msgstr ""
+msgstr "ошибка чтения при чтении экспортных данных"
  
  #: go/go-backend.c:192
  msgid "short read while reading export data"
-msgstr ""
+msgstr "короткое чтение при чтении экспортных данных"
  
  #: java/jcf-dump.c:1127
  #, c-format
  msgid "Not a valid Java .class file.\n"
-msgstr "Ð½екорректный Java .class файл.\n"
+msgstr "Ð\9dекорректный Java .class файл.\n"
  
  #: java/jcf-dump.c:1133
  #, c-format
@@ -5762,7 +5822,7 @@ msgstr "%s: ошибка закрытия выходного файла %s\n"
  #: objc/objc-act.c:6179 cp/cxx-pretty-print.c:156
  #, gcc-internal-format
  msgid "<unnamed>"
-msgstr ""
+msgstr "<unnamed>"
  
  #: gcc.c:747 gcc.c:751 gcc.c:806
  #, fuzzy
@@ -5772,13 +5832,13 @@ msgstr "-m%s в данной конфигурации не поддержива
  
  #: gcc.c:757 gcc.c:817
  #, fuzzy
+#| msgid "ifunc is not supported in this configuration"
  msgid "-gz=zlib is not supported in this configuration"
-msgstr "-m%s в данной конфигурации не поддерживается"
+msgstr "ifunc в данной конфигурации не поддерживается"
  
  #: gcc.c:961
-#, fuzzy
  msgid "-fuse-linker-plugin is not supported in this configuration"
-msgstr "-m%s в данной конфигурации не поддерживается"
+msgstr "-fuse-linker-plugin в данной конфигурации не поддерживается"
  
  #: gcc.c:976
  msgid "cannot specify -static with -fsanitize=address"
@@ -5793,9 +5853,8 @@ msgid "-pg and -fomit-frame-pointer are incompatible"
  msgstr "-pg и -fomit-frame-pointer несовместимы"
  
  #: gcc.c:1298
-#, fuzzy
  msgid "GNU C no longer supports -traditional without -E"
-msgstr "ключ -C или -CC допустим только с -E"
+msgstr "GNU C больше не поддерживает -traditional без -E"
  
  #: gcc.c:1307
  msgid "-E or -x required when input is from standard input"
@@ -5807,8 +5866,9 @@ msgstr ""
  
  #: config/sol2.h:181
  #, fuzzy
+#| msgid "weakref is not supported in this configuration"
  msgid "-fvtable-verify is not supported in this configuration"
-msgstr "%Jweakref в данной конфигурации не поддерживается"
+msgstr "weakref в данной конфигурации не поддерживается"
  
  #: config/sol2.h:268 config/sol2.h:273
  msgid "does not support multilib"
@@ -5816,8 +5876,9 @@ msgstr "не поддерживает мультибиблиотеку"
  
  #: config/sol2.h:365
  #, fuzzy
+#| msgid "ifunc is not supported in this configuration"
  msgid "-pie is not supported in this configuration"
-msgstr "-m%s в данной конфигурации не поддерживается"
+msgstr "ifunc в данной конфигурации не поддерживается"
  
  #: config/darwin.h:251
  msgid "-current_version only allowed with -dynamiclib"
@@ -5870,15 +5931,15 @@ msgstr "shared и mdll несовместимы"
  #: config/ia64/freebsd.h:26 config/i386/freebsd.h:82
  #: config/i386/freebsd64.h:35 config/sparc/freebsd.h:45
  msgid "consider using '-pg' instead of '-p' with gprof(1)"
-msgstr ""
+msgstr "попробуйте '-pg' вместо '-p' для gprof(1)"
  
  #: objc/lang-specs.h:30 objc/lang-specs.h:41
  msgid "GNU Objective C no longer supports traditional compilation"
-msgstr ""
+msgstr "GNU Objective C больше не поддерживает традиционную компиляцию"
  
  #: objc/lang-specs.h:55
  msgid "objc-cpp-output is deprecated; please use objective-c-cpp-output instead"
-msgstr ""
+msgstr "objc-cpp-output устарел; пожалуйста используйте objective-c-cpp-output взамен"
  
  #: config/tilegx/tilegx.h:546 config/tilegx/tilegx.h:551 config/arm/arm.h:102
  msgid "-mbig-endian and -mlittle-endian may not be used together"
@@ -5895,14 +5956,14 @@ msgid "-c or -S required for Ada"
  msgstr "Для языка Ada нужно передать -c или -S"
  
  #: ada/gcc-interface/lang-specs.h:52
-#, fuzzy
  msgid "-c required for gnat2why"
-msgstr "Для языка Ada нужно передать -c или -S"
+msgstr "-c требуется для gnat2why"
  
  #: ada/gcc-interface/lang-specs.h:65
  #, fuzzy
+#| msgid "-c required for gnat2why"
  msgid "-c required for gnat2scil"
-msgstr "Для языка Ada нужно передать -c или -S"
+msgstr "-c требуется для gnat2why"
  
  #: config/pa/pa-hpux10.h:102 config/pa/pa-hpux10.h:105
  #: config/pa/pa-hpux10.h:113 config/pa/pa-hpux10.h:116
@@ -5910,7 +5971,7 @@ msgstr "Для языка Ada нужно передать -c или -S"
  #: config/pa/pa64-hpux.h:29 config/pa/pa64-hpux.h:32 config/pa/pa64-hpux.h:41
  #: config/pa/pa64-hpux.h:44
  msgid "warning: consider linking with '-static' as system libraries with"
-msgstr ""
+msgstr "предупреждение: рассмотрите линковку с '-static' как системных библиотек с"
  
  #: config/pa/pa-hpux10.h:103 config/pa/pa-hpux10.h:106
  #: config/pa/pa-hpux10.h:114 config/pa/pa-hpux10.h:117
@@ -5918,16 +5979,15 @@ msgstr ""
  #: config/pa/pa64-hpux.h:30 config/pa/pa64-hpux.h:33 config/pa/pa64-hpux.h:42
  #: config/pa/pa64-hpux.h:45
  msgid "  profiling support are only provided in archive format"
-msgstr ""
+msgstr "  поддержка профилирования обеспечивается только в архивном формате"
  
  #: config/vxworks.h:70
  msgid "-Xbind-now and -Xbind-lazy are incompatible"
  msgstr "ключи -Xbind-now и -Xbind-lazy несовместимы"
  
  #: config/cris/cris.h:184
-#, fuzzy
  msgid "do not specify both -march=... and -mcpu=..."
-msgstr "Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f Ð·Ð°Ð´Ð°Ð½Ð¸Ðµ Ð¾Ð´Ð½Ð¾Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð¾ -C Ð¸ -o"
+msgstr "Ð½Ðµ Ð·Ð°Ð´Ð°Ð²Ð°Ð¹Ñ\82Ðµ Ð¾Ð´Ð½Ð¾Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð¾ -march=... Ð¸ -mcpu=..."
  
  #: config/arc/arc.h:142 config/mips/mips.h:1358
  msgid "may not use both -EB and -EL"
@@ -5935,16 +5995,15 @@ msgstr "-EB и -EL несовместимы"
  
  #: objcp/lang-specs.h:58
  msgid "objc++-cpp-output is deprecated; please use objective-c++-cpp-output instead"
-msgstr ""
+msgstr "objc++-cpp-output устарело; пожалуйста используйте objective-c++-cpp-output взамен"
  
  #: config/rs6000/darwin.h:95
  msgid " conflicting code gen style switches are used"
  msgstr " заданы несовместимые ключи генерации кода"
  
  #: fortran/lang-specs.h:54 fortran/lang-specs.h:68
-#, fuzzy
  msgid "gfortran does not support -E without -cpp"
-msgstr "ключ -C или -CC допустим только с -E"
+msgstr "gfortran не поддерживает -E без -cpp"
  
  #: config/sh/sh.h:375 config/sh/sh.h:378
  msgid "SH2a does not support little-endian"
@@ -5952,13 +6011,13 @@ msgstr "SH2a не поддерживает little-endian"
  
  #: config/avr/specs.h:68
  #, fuzzy
+#| msgid "-fpic is not supported"
  msgid "shared is not supported"
-msgstr "ключ -pipe не поддерживается"
+msgstr "ключ -fpic не поддерживается"
  
  #: config/arm/arm.h:100
-#, fuzzy
  msgid "-mfloat-abi=soft and -mfloat-abi=hard may not be used together"
-msgstr "-msoft-float и -mhard_float несовместимы"
+msgstr "-mfloat-abi=soft и -mfloat-abi=hard несовместимы"
  
  #: config/vax/netbsd-elf.h:51
  msgid "the -shared option is not currently supported for VAX ELF"
@@ -5973,13 +6032,12 @@ msgid "-msingle-float and -msoft-float cannot both be specified"
  msgstr "ключи -msingle-float и -msoft-float несовместимы"
  
  #: config/vax/vax.h:46 config/vax/vax.h:47
-#, fuzzy
  msgid "profiling not supported with -mg"
-msgstr "профилирование с -mg не поддерживается\n"
+msgstr "профилирование с -mg не поддерживается"
  
  #: config/rs6000/freebsd64.h:171
  msgid "consider using `-pg' instead of `-p' with gprof(1)"
-msgstr ""
+msgstr "попробуйте `-pg' вместо `-p' для gprof(1)"
  
  #: config/lynx.h:69
  msgid "cannot use mthreads and mlegacy-threads together"
@@ -5990,26 +6048,28 @@ msgid "cannot use mshared and static together"
  msgstr "Недопустимо одновременно использовать mshared и static"
  
  #: config/rx/rx.h:80
-#, fuzzy
  msgid "-mas100-syntax is incompatible with -gdwarf"
-msgstr "ключ -march=%s несовместим с выбранным ABI"
+msgstr "ключ -mas100-syntax несовместим с -gdwarf"
  
  #: config/rx/rx.h:81
+#, fuzzy
+#| msgid "rx200 cpu does not have FPU hardware"
  msgid "rx100 cpu does not have FPU hardware"
-msgstr ""
+msgstr "rx200 cpu не имеет FPU оборудования"
  
  #: config/rx/rx.h:82
  msgid "rx200 cpu does not have FPU hardware"
-msgstr ""
+msgstr "rx200 cpu не имеет FPU оборудования"
  
  #: config/arm/freebsd.h:49
+#, fuzzy
+#| msgid "consider using `-pg' instead of `-p' with gprof(1)"
  msgid "consider using `-pg' instead of `-p' with gprof (1) "
-msgstr ""
+msgstr "попробуйте `-pg' вместо `-p' для gprof(1)"
  
  #: config/bfin/elf.h:55
-#, fuzzy
  msgid "no processor type specified for linking"
-msgstr "Ð² Ñ\84Ð°Ð¹Ð»Ðµ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¹ Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð´Ð»Ñ\8f ÐºÐ¾Ð¼Ð¿Ð¾Ð½овки"
+msgstr "Ð½Ðµ Ð·Ð°Ð´Ð°Ð½ Ñ\82Ð¸Ð¿ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80Ð° Ð´Ð»Ñ\8f Ð»Ð¸Ð½Ðºовки"
  
  #: java/lang-specs.h:32
  msgid "-fjni and -femit-class-files are incompatible"
@@ -6029,27 +6089,33 @@ msgstr "для m210 обратный (little endian) порядок байт н
  
  #: fortran/lang.opt:146
  #, fuzzy
+#| msgid "-J<directory>\tPut MODULE files in 'directory'"
  msgid "-J<directory>\tPut MODULE files in 'directory'."
-msgstr "Помещать файлы MODULE в указанный 'каталог'"
+msgstr "-J<каталог>  \tПомещать файлы MODULE в 'каталог'"
  
  #: fortran/lang.opt:198
  #, fuzzy
+#| msgid "Warn about possible aliasing of dummy arguments"
  msgid "Warn about possible aliasing of dummy arguments."
-msgstr "Предупреждать о возможно отсутствующих скобках"
+msgstr "Предупреждать о возможном перекрытии формальных аргументов"
  
  #: fortran/lang.opt:202
+#, fuzzy
+#| msgid "Warn about alignment of COMMON blocks"
  msgid "Warn about alignment of COMMON blocks."
-msgstr ""
+msgstr "Предупреждать о выравнивании COMMON блоков"
  
  #: fortran/lang.opt:206
  #, fuzzy
+#| msgid "Warn about missing ampersand in continued character constants"
  msgid "Warn about missing ampersand in continued character constants."
-msgstr "Предупреждать о возможно отсутствующих скобках в инициализаторах"
+msgstr "Предупреждать об отсутствующих знаках & в строковых константах с продолжением"
  
  #: fortran/lang.opt:210
  #, fuzzy
+#| msgid "Warn about creation of array temporaries"
  msgid "Warn about creation of array temporaries."
-msgstr "Предупреждать об арифметических действиях над указателями на функции"
+msgstr "Предупреждать о создании временных массивов"
  
  #: fortran/lang.opt:214
  msgid "Warn if the type of a variable might be not interoperable with C."
@@ -6057,8 +6123,9 @@ msgstr ""
  
  #: fortran/lang.opt:222
  #, fuzzy
+#| msgid "Warn about truncated character expressions"
  msgid "Warn about truncated character expressions."
-msgstr "Предупреждать об устаревших возможностях компилятора, которые будут выведены из употребления в последующих версиях"
+msgstr "Предупреждать об усеченных строковых выражениях"
  
  #: fortran/lang.opt:226
  msgid "Warn about equality comparisons involving REAL or COMPLEX expressions."
@@ -6066,23 +6133,27 @@ msgstr ""
  
  #: fortran/lang.opt:234
  #, fuzzy
+#| msgid "Warn about most implicit conversions"
  msgid "Warn about most implicit conversions."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8fÑ\85"
  
  #: fortran/lang.opt:242
  #, fuzzy
+#| msgid "Warn about function call elimination"
  msgid "Warn about function call elimination."
-msgstr "Предупреждать о неявных декларациях функций"
+msgstr "Предупреждать об удалении вызовов функций"
  
  #: fortran/lang.opt:246
  #, fuzzy
+#| msgid "Warn about calls with implicit interface"
  msgid "Warn about calls with implicit interface."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð²Ñ\8bÐ·Ð¾Ð²Ð°Ñ\85 Ñ\81 Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÐ¼ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81Ð¾Ð¼"
  
  #: fortran/lang.opt:250
  #, fuzzy
+#| msgid "Warn about called procedures not explicitly declared"
  msgid "Warn about called procedures not explicitly declared."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð²Ñ\8bÐ·Ð¾Ð²Ð°Ñ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹, Ð½Ðµ Ð¿Ñ\80Ð¾Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÑ\85 Ñ\8fÐ²Ð½Ð¾"
  
  #: fortran/lang.opt:254
  #, fuzzy
@@ -6092,12 +6163,15 @@ msgstr "Предупреждать о целочисленном делении
  
  #: fortran/lang.opt:258
  #, fuzzy
+#| msgid "Warn about truncated source lines"
  msgid "Warn about truncated source lines."
-msgstr "Предупреждать об устаревших возможностях компилятора, которые будут выведены из употребления в последующих версиях"
+msgstr "Предупреждать об усеченных строках исходного кода"
  
  #: fortran/lang.opt:262
+#, fuzzy
+#| msgid "Warn on intrinsics not part of the selected standard"
  msgid "Warn on intrinsics not part of the selected standard."
-msgstr ""
+msgstr "Предупреждать о встроенных функциях, не входящих в заданный стандарт языка"
  
  #: fortran/lang.opt:274
  #, fuzzy
@@ -6106,22 +6180,28 @@ msgid "Warn about USE statements that have no ONLY qualifier."
  msgstr "Предупреждать о форматных строках, не являющихся литералами"
  
  #: fortran/lang.opt:286
+#, fuzzy
+#| msgid "Warn about real-literal-constants with 'q' exponent-letter"
  msgid "Warn about real-literal-constants with 'q' exponent-letter."
-msgstr ""
+msgstr "Предупреждать о вещественных константах с экспонентой, заданной буквой 'q'"
  
  #: fortran/lang.opt:290
  #, fuzzy
+#| msgid "Warn when a register variable is declared volatile"
  msgid "Warn when a left-hand-side array variable is reallocated."
  msgstr "Предупреждать о регистровых переменных, объявленных volatile"
  
  #: fortran/lang.opt:294
  #, fuzzy
+#| msgid "Warn when a register variable is declared volatile"
  msgid "Warn when a left-hand-side variable is reallocated."
  msgstr "Предупреждать о регистровых переменных, объявленных volatile"
  
  #: fortran/lang.opt:298
+#, fuzzy
+#| msgid "Target expression in pointer assignment at %L must deliver a pointer result"
  msgid "Warn if the pointer in a pointer assignment might outlive its target."
-msgstr ""
+msgstr "Целевое выражение в присваивании указателя в %L должна выдавать указательный результат"
  
  #: fortran/lang.opt:306
  #, fuzzy
@@ -6131,22 +6211,25 @@ msgstr "Предупреждать о \"подозрительных\" конс
  
  #: fortran/lang.opt:310
  #, fuzzy
+#| msgid "Permit nonconforming uses of the tab character"
  msgid "Permit nonconforming uses of the tab character."
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð½ÐµÐ¿Ñ\80Ð°Ð²Ð¸Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\83Ð¿Ð¾Ñ\82Ñ\80ÐµÐ±Ð»ÐµÐ½Ð¸Ðµ Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ð¾Ð² Ñ\82Ð°Ð±Ñ\83Ð»Ñ\8fÑ\86Ð¸Ð¸"
  
  #: fortran/lang.opt:314
  #, fuzzy
+#| msgid "Warn about underflow of numerical constant expressions"
  msgid "Warn about underflow of numerical constant expressions."
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÐ´Ð¾Ð¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ð¸ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÑ\85 Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¹"
  
  #: fortran/lang.opt:322
+#, fuzzy
+#| msgid "Warn if a user-procedure has the same name as an intrinsic"
  msgid "Warn if a user-procedure has the same name as an intrinsic."
-msgstr ""
+msgstr "Предупреждать о пользовательских процедурах с именами, совпадающими с именами встроенных процедур"
  
  #: fortran/lang.opt:330
-#, fuzzy
  msgid "Warn about unused dummy arguments."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\89Ð¸Ñ\85 Ñ\81ÐºÐ¾Ð±Ðºах"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÐ¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÑ\85 Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82ах"
  
  #: fortran/lang.opt:334
  #, fuzzy
@@ -6156,45 +6239,63 @@ msgstr "Предупреждать о форматных строках нуле
  
  #: fortran/lang.opt:338
  #, fuzzy
+#| msgid "Enable preprocessing"
  msgid "Enable preprocessing."
-msgstr "Ð¢Ñ\80Ð°Ð´Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾Ðµ препроцессирование"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c препроцессирование"
  
  #: fortran/lang.opt:346
  #, fuzzy
+#| msgid "Disable preprocessing"
  msgid "Disable preprocessing."
-msgstr "Ð\9dÐµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ð´ÐµÐºÑ\81Ð½Ñ\83Ñ\8e Ð°Ð´Ñ\80ÐµÑ\81Ð°Ñ\86Ð¸Ñ\8e"
+msgstr "Ð\9eÑ\82ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¿Ñ\80ÐµÐ¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ"
  
  #: fortran/lang.opt:354
+#, fuzzy
+#| msgid "Eliminate multiple function invokations also for impure functions"
  msgid "Eliminate multiple function invokations also for impure functions."
-msgstr ""
+msgstr "Исключить повторные вызовы также для не-pure функций"
  
  #: fortran/lang.opt:358
+#, fuzzy
+#| msgid "Enable alignment of COMMON blocks"
  msgid "Enable alignment of COMMON blocks."
-msgstr ""
+msgstr "Включить выравнивание COMMON блоков"
  
  #: fortran/lang.opt:362
+#, fuzzy
+#| msgid "All intrinsics procedures are available regardless of selected standard"
  msgid "All intrinsics procedures are available regardless of selected standard."
-msgstr ""
+msgstr "Считать, что доступны все встроенные процедуры, независимо от выбранного стандарта"
  
  #: fortran/lang.opt:370
+#, fuzzy
+#| msgid "Do not treat local variables and COMMON blocks as if they were named in SAVE statements"
  msgid "Do not treat local variables and COMMON blocks as if they were named in SAVE statements."
-msgstr ""
+msgstr "Не трактовать локальные переменные и COMMON блоки как если бы они были перечислены в операторах SAVE"
  
  #: fortran/lang.opt:374
+#, fuzzy
+#| msgid "Specify that backslash in string introduces an escape character"
  msgid "Specify that backslash in string introduces an escape character."
-msgstr ""
+msgstr "Использовать обратный слеш в строках как символ экранирования"
  
  #: fortran/lang.opt:378
+#, fuzzy
+#| msgid "Produce a backtrace when a runtime error is encountered"
  msgid "Produce a backtrace when a runtime error is encountered."
-msgstr ""
+msgstr "При ошибках выполнения выводить последовательность вызовов"
  
  #: fortran/lang.opt:382
+#, fuzzy
+#| msgid "-fblas-matmul-limit=<n>\tSize of the smallest matrix for which matmul will use BLAS"
  msgid "-fblas-matmul-limit=<n>\tSize of the smallest matrix for which matmul will use BLAS."
-msgstr ""
+msgstr "-fblas-matmul-limit=<n>\tРазмер минимальной матрицы, для которой matmul будет использовать BLAS"
  
  #: fortran/lang.opt:386
+#, fuzzy
+#| msgid "Produce a warning at runtime if a array temporary has been created for a procedure argument"
  msgid "Produce a warning at runtime if a array temporary has been created for a procedure argument."
-msgstr ""
+msgstr "Генерировать runtime-предупреждение, если для аргумента процедуры был создан временный массив"
  
  #: fortran/lang.opt:390
  msgid "-fconvert=<big-endian|little-endian|native|swap> The endianness used for unformatted files."
@@ -6202,8 +6303,9 @@ msgstr ""
  
  #: fortran/lang.opt:393
  #, fuzzy, c-format
+#| msgid "Unrecognized option to -finit-real: %s"
  msgid "Unrecognized option to endianess value: %qs"
-msgstr "Ð½ÐµÐ¾Ð¿Ð¾Ð·Ð½Ð°Ð½Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 '-%s'"
+msgstr "Ð\9dÐµÐ¾Ð¿Ð¾Ð·Ð½Ð°Ð½Ð½Ð°Ñ\8f Ð¾Ð¿Ñ\86Ð¸Ñ\8f Ð´Ð»Ñ\8f -finit-real: %s"
  
  #: fortran/lang.opt:409
  #, fuzzy
@@ -6212,254 +6314,337 @@ msgid "Use the Cray Pointer extension."
  msgstr "Использовать расширение указателей Cray"
  
  #: fortran/lang.opt:413
+#, fuzzy
+#| msgid "Ignore 'D' in column one in fixed form"
  msgid "Ignore 'D' in column one in fixed form."
-msgstr ""
+msgstr "Игнорировать 'D' в первой колонке в фиксированном формате"
  
  #: fortran/lang.opt:417
+#, fuzzy
+#| msgid "Treat lines with 'D' in column one as comments"
  msgid "Treat lines with 'D' in column one as comments."
-msgstr ""
+msgstr "Трактовать строки с 'D' в первой колонке как комментарии"
  
  #: fortran/lang.opt:421
+#, fuzzy
+#| msgid "Set the default double precision kind to an 8 byte wide type"
  msgid "Set the default double precision kind to an 8 byte wide type."
-msgstr ""
+msgstr "Установить по умолчанию размер 8 байт для типов double precision"
  
  #: fortran/lang.opt:425
+#, fuzzy
+#| msgid "Set the default integer kind to an 8 byte wide type"
  msgid "Set the default integer kind to an 8 byte wide type."
-msgstr ""
+msgstr "Установить по умолчанию размер 8 байт для целочисленных типов"
  
  #: fortran/lang.opt:429
+#, fuzzy
+#| msgid "Set the default real kind to an 8 byte wide type"
  msgid "Set the default real kind to an 8 byte wide type."
-msgstr ""
+msgstr "Установить по умолчанию размер 8 байт для типов real"
  
  #: fortran/lang.opt:433
+#, fuzzy
+#| msgid "Allow dollar signs in entity names"
  msgid "Allow dollar signs in entity names."
-msgstr ""
+msgstr "Разрешить использование символа $ в именах"
  
  #: fortran/lang.opt:437 config/alpha/alpha.opt:31 common.opt:732
  #: common.opt:920 common.opt:924 common.opt:928 common.opt:932 common.opt:1421
  #: common.opt:1570 common.opt:1574 common.opt:1800 common.opt:1946
  #: common.opt:2598
  msgid "Does nothing. Preserved for backward compatibility."
-msgstr ""
+msgstr "Игнорируется. Сохранен для обратной совместимости."
  
  #: fortran/lang.opt:441
  #, fuzzy
+#| msgid "Display the code tree after parsing"
  msgid "Display the code tree after parsing."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð»Ð½Ñ\83Ñ\8e Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿ÐµÑ\80ÐµÐ¼ÐµÑ\89ÐµÐ½Ð¸Ñ\8f Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²"
+msgstr "Ð\9fÐ¾ÐºÐ°Ð·Ð°Ñ\82Ñ\8c Ð´ÐµÑ\80ÐµÐ²Ð¾ ÐºÐ¾Ð´Ð° Ð¿Ð¾Ñ\81Ð»Ðµ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ñ\80Ð°Ð·Ð±Ð¾Ñ\80Ð°"
  
  #: fortran/lang.opt:445
  #, fuzzy
+#| msgid "Display the code tree after front end optimization"
  msgid "Display the code tree after front end optimization."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð»Ð½Ñ\83Ñ\8e Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿ÐµÑ\80ÐµÐ¼ÐµÑ\89ÐµÐ½Ð¸Ñ\8f Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²"
+msgstr "Ð\9fÐ¾ÐºÐ°Ð·Ð°Ñ\82Ñ\8c Ð´ÐµÑ\80ÐµÐ²Ð¾ ÐºÐ¾Ð´Ð° Ð¿Ð¾Ñ\81Ð»Ðµ front end Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸"
  
  #: fortran/lang.opt:449
  #, fuzzy
+#| msgid "Display the code tree after parsing; deprecated option"
  msgid "Display the code tree after parsing; deprecated option."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð»Ð½Ñ\83Ñ\8e Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿ÐµÑ\80ÐµÐ¼ÐµÑ\89ÐµÐ½Ð¸Ñ\8f Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²"
+msgstr "Ð\9fÐ¾ÐºÐ°Ð·Ð°Ñ\82Ñ\8c Ð´ÐµÑ\80ÐµÐ²Ð¾ ÐºÐ¾Ð´Ð° Ð¿Ð¾Ñ\81Ð»Ðµ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ñ\80Ð°Ð·Ð±Ð¾Ñ\80Ð°; Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð¸Ð¹ ÐºÐ»Ñ\8eÑ\87"
  
  #: fortran/lang.opt:453
+#, fuzzy
+#| msgid "Specify that an external BLAS library should be used for matmul calls on large-size arrays"
  msgid "Specify that an external BLAS library should be used for matmul calls on large-size arrays."
-msgstr ""
+msgstr "Задать использование внешней библиотеки BLAS для вызовов matmul для больших массивов"
  
  #: fortran/lang.opt:457
  #, fuzzy
+#| msgid "Use f2c calling convention"
  msgid "Use f2c calling convention."
-msgstr "Использовать обычные соглашения о вызовах"
+msgstr "Использовать f2c соглашения о вызовах"
  
  #: fortran/lang.opt:461
  #, fuzzy
+#| msgid "Assume that the source file is fixed form"
  msgid "Assume that the source file is fixed form."
-msgstr "Считать, что указатели не могут указывать на общую память"
+msgstr "Считать, что входной файл имеет фиксированный формат"
  
  #: fortran/lang.opt:465
+#, fuzzy
+#| msgid "Interpret any INTEGER(4) as an INTEGER(8)"
  msgid "Interpret any INTEGER(4) as an INTEGER(8)."
-msgstr ""
+msgstr "Трактовать INTEGER(4) как INTEGER(8)"
  
  #: fortran/lang.opt:469 fortran/lang.opt:473
+#, fuzzy
+#| msgid "Specify where to find the compiled intrinsic modules"
  msgid "Specify where to find the compiled intrinsic modules."
-msgstr ""
+msgstr "Указать расположение скомпилированных модулей со встроенными процедурами"
  
  #: fortran/lang.opt:477
  #, fuzzy
+#| msgid "Allow arbitrary character line width in fixed mode"
  msgid "Allow arbitrary character line width in fixed mode."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c n ÐºÐ°Ðº Ñ\88Ð¸Ñ\80Ð¸Ð½Ñ\83 Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð² Ñ\81Ð²Ð¾Ð±Ð¾Ð´Ð½Ð¾Ð¼ Ñ\80ÐµÐ¶Ð¸Ð¼е"
+msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ð¸Ð·Ð²Ð¾Ð»Ñ\8cÐ½Ñ\83Ñ\8e Ñ\88Ð¸Ñ\80Ð¸Ð½Ñ\83 Ñ\81Ñ\82Ñ\80Ð¾Ðº Ð² Ñ\84Ð¸ÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð¼ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82е"
  
  #: fortran/lang.opt:481
  #, fuzzy
+#| msgid "-ffixed-line-length-<n>\tUse n as character line width in fixed mode"
  msgid "-ffixed-line-length-<n>\tUse n as character line width in fixed mode."
-msgstr "Использовать n как ширину строки в свободном режиме"
+msgstr "-ffixed-line-length-<n>\tИспользовать n как ширину строки в фиксированной форме"
  
  #: fortran/lang.opt:485
  #, fuzzy
+#| msgid "-ffpe-trap=[...]\tStop on following floating point exceptions"
  msgid "-ffpe-trap=[...]\tStop on following floating point exceptions."
-msgstr "Задайте yes/no для использования операций с плавающей точкой в GPRs"
+msgstr "-ffpe-trap=[...]\tОстановиться при указанном исключении плавающей арифметики"
  
  #: fortran/lang.opt:489
  #, fuzzy
+#| msgid "-ffpe-trap=[...]\tStop on following floating point exceptions"
  msgid "-ffpe-summary=[...]\tPrint summary of floating point exceptions."
-msgstr "Задайте yes/no для использования операций с плавающей точкой в GPRs"
+msgstr "-ffpe-trap=[...]\tОстановиться при указанном исключении плавающей арифметики"
  
  #: fortran/lang.opt:493
  #, fuzzy
+#| msgid "Assume that the source file is free form"
  msgid "Assume that the source file is free form."
-msgstr "Считать, что указатели не могут указывать на общую память"
+msgstr "Считать, что исходный файл имеет свободную форму"
  
  #: fortran/lang.opt:497
  #, fuzzy
+#| msgid "Allow arbitrary character line width in free mode"
  msgid "Allow arbitrary character line width in free mode."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c n ÐºÐ°Ðº Ñ\88Ð¸Ñ\80Ð¸Ð½Ñ\83 Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð² Ñ\81Ð²Ð¾Ð±Ð¾Ð´Ð½Ð¾Ð¼ Ñ\80ÐµÐ¶Ð¸ме"
+msgstr "Ð\94Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ð¸Ð·Ð²Ð¾Ð»Ñ\8cÐ½Ñ\83Ñ\8e Ñ\88Ð¸Ñ\80Ð¸Ð½Ñ\83 Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð² Ñ\81Ð²Ð¾Ð±Ð¾Ð´Ð½Ð¾Ð¹ Ñ\84Ð¾Ñ\80ме"
  
  #: fortran/lang.opt:501
  #, fuzzy
+#| msgid "-ffree-line-length-<n>\tUse n as character line width in free mode"
  msgid "-ffree-line-length-<n>\tUse n as character line width in free mode."
-msgstr "Использовать n как ширину строки в свободном режиме"
+msgstr "-ffree-line-length-<n>\tИспользовать n как ширину строки в свободной форме"
  
  #: fortran/lang.opt:505
  #, fuzzy
+#| msgid "Enable front end optimization"
  msgid "Enable front end optimization."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²ÐºÐ¸"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð¿ÐµÑ\80ÐµÐ´Ð½ÐµÐ³Ð¾ Ð¿Ð»Ð°Ð½Ð°"
  
  #: fortran/lang.opt:509
+#, fuzzy
+#| msgid "Specify that no implicit typing is allowed, unless overridden by explicit IMPLICIT statements"
  msgid "Specify that no implicit typing is allowed, unless overridden by explicit IMPLICIT statements."
-msgstr ""
+msgstr "Запретить неявное определение типов, если не заданы явно операторы IMPLICIT"
  
  #: fortran/lang.opt:513
+#, fuzzy
+#| msgid "-finit-character=<n>\tInitialize local character variables to ASCII value n"
  msgid "-finit-character=<n>\tInitialize local character variables to ASCII value n."
-msgstr ""
+msgstr "-finit-character=<n>\tИнициализировать локальные символьные переменные ASCII значением n"
  
  #: fortran/lang.opt:517
+#, fuzzy
+#| msgid "-finit-integer=<n>\tInitialize local integer variables to n"
  msgid "-finit-integer=<n>\tInitialize local integer variables to n."
-msgstr ""
+msgstr "-finit-integer=<n>\tИнициализировать локальные целые переменные значением n"
  
  #: fortran/lang.opt:521
+#, fuzzy
+#| msgid "Initialize local variables to zero (from g77)"
  msgid "Initialize local variables to zero (from g77)."
-msgstr ""
+msgstr "Инициализировать локальные переменные нулем (как в g77)"
  
  #: fortran/lang.opt:525
+#, fuzzy
+#| msgid "-finit-logical=<true|false>\tInitialize local logical variables"
  msgid "-finit-logical=<true|false>\tInitialize local logical variables."
-msgstr ""
+msgstr "-finit-logical=<true|false>\tИнициализировать локальные логические переменные"
  
  #: fortran/lang.opt:529
+#, fuzzy
+#| msgid "-finit-real=<zero|nan|inf|-inf>\tInitialize local real variables"
  msgid "-finit-real=<zero|snan|nan|inf|-inf>\tInitialize local real variables."
-msgstr ""
+msgstr "-finit-real=<zero|nan|inf|-inf>\tИнициализировать локальные вещественные переменные"
  
  #: fortran/lang.opt:532
  #, fuzzy, c-format
+#| msgid "Unrecognized option to -finit-real: %s"
  msgid "Unrecognized option to floating-point init value: %qs"
-msgstr "Ð½ÐµÐ¾Ð¿Ð¾Ð·Ð½Ð°Ð½Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 '-%s'"
+msgstr "Ð\9dÐµÐ¾Ð¿Ð¾Ð·Ð½Ð°Ð½Ð½Ð°Ñ\8f Ð¾Ð¿Ñ\86Ð¸Ñ\8f Ð´Ð»Ñ\8f -finit-real: %s"
  
  #: fortran/lang.opt:551
+#, fuzzy
+#| msgid "-fblas-matmul-limit=<n>\tSize of the smallest matrix for which matmul will use BLAS"
  msgid "-finline-matmul-limit=<n>\tSpecify the size of the largest matrix for which matmul will be inlined."
-msgstr ""
+msgstr "-fblas-matmul-limit=<n>\tРазмер минимальной матрицы, для которой matmul будет использовать BLAS"
  
  #: fortran/lang.opt:555
  #, fuzzy
+#| msgid "-fmax-array-constructor=<n>\tMaximum number of objects in an array constructor"
  msgid "-fmax-array-constructor=<n>\tMaximum number of objects in an array constructor."
-msgstr "Максимальный коэффициент развертки цикла"
+msgstr "-fmax-array-constructor=<n>\tМаксимальное число объектов в конструкторе массива"
  
  #: fortran/lang.opt:559
  #, fuzzy
+#| msgid "-fmax-identifier-length=<n>\tMaximum identifier length"
  msgid "-fmax-identifier-length=<n>\tMaximum identifier length."
-msgstr "Отсутствует идентификатор"
+msgstr "-fmax-identifier-length=<n>\tМаксимальная длина идентификатора"
  
  #: fortran/lang.opt:563
  #, fuzzy
+#| msgid "-fmax-subrecord-length=<n>\tMaximum length for subrecords"
  msgid "-fmax-subrecord-length=<n>\tMaximum length for subrecords."
-msgstr "Отсутствует идентификатор"
+msgstr "-fmax-subrecord-length=<n>\tМаксимальная длина субзаписей"
  
  #: fortran/lang.opt:567
+#, fuzzy
+#| msgid "-fmax-stack-var-size=<n>\tSize in bytes of the largest array that will be put on the stack"
  msgid "-fmax-stack-var-size=<n>\tSize in bytes of the largest array that will be put on the stack."
-msgstr ""
+msgstr "-fmax-stack-var-size=<n>\tРазмер в байтах максимального массива, размещаемого в стеке"
  
  #: fortran/lang.opt:571
  msgid "Put all local arrays on stack."
-msgstr ""
+msgstr "Размещать все локальные массивы в стеке"
  
  #: fortran/lang.opt:575
  msgid "Set default accessibility of module entities to PRIVATE."
-msgstr ""
+msgstr "Установить PRIVATE как умолчание для атрибута доступности элементов модуля."
  
  #: fortran/lang.opt:595
+#, fuzzy
+#| msgid "Try to lay out derived types as compactly as possible"
  msgid "Try to lay out derived types as compactly as possible."
-msgstr ""
+msgstr "Использовать наиболее компактное представление производных типов"
  
  #: fortran/lang.opt:603
  #, fuzzy
+#| msgid "Protect parentheses in expressions"
  msgid "Protect parentheses in expressions."
-msgstr "рекомендуется окружать скобками выражение &&, используемое в операнде ||"
+msgstr "Защитить скобки в выражениях"
  
  #: fortran/lang.opt:607
  #, fuzzy
+#| msgid "Enable range checking during compilation"
  msgid "Enable range checking during compilation."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²Ðºи"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ð²ÐµÑ\80ÐºÑ\83 Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð¾Ð² Ð¿Ñ\80Ð¸ ÐºÐ¾Ð¼Ð¿Ð¸Ð»Ñ\8fÑ\86Ð¸и"
  
  #: fortran/lang.opt:611
+#, fuzzy
+#| msgid "Interpret any REAL(4) as a REAL(8)"
  msgid "Interpret any REAL(4) as a REAL(8)."
-msgstr ""
+msgstr "Трактовать REAL(4) как REAL(8)"
  
  #: fortran/lang.opt:615
+#, fuzzy
+#| msgid "Interpret any REAL(4) as a REAL(10)"
  msgid "Interpret any REAL(4) as a REAL(10)."
-msgstr ""
+msgstr "Трактовать REAL(4) как REAL(10)"
  
  #: fortran/lang.opt:619
+#, fuzzy
+#| msgid "Interpret any REAL(4) as a REAL(16)"
  msgid "Interpret any REAL(4) as a REAL(16)."
-msgstr ""
+msgstr "Трактовать REAL(4) как REAL(16)"
  
  #: fortran/lang.opt:623
+#, fuzzy
+#| msgid "Interpret any REAL(8) as a REAL(4)"
  msgid "Interpret any REAL(8) as a REAL(4)."
-msgstr ""
+msgstr "Трактовать REAL(8) как REAL(4)"
  
  #: fortran/lang.opt:627
+#, fuzzy
+#| msgid "Interpret any REAL(8) as a REAL(10)"
  msgid "Interpret any REAL(8) as a REAL(10)."
-msgstr ""
+msgstr "Трактовать REAL(8) как REAL(10)"
  
  #: fortran/lang.opt:631
+#, fuzzy
+#| msgid "Interpret any REAL(8) as a REAL(16)"
  msgid "Interpret any REAL(8) as a REAL(16)."
-msgstr ""
+msgstr "Трактовать REAL(8) как REAL(16)"
  
  #: fortran/lang.opt:635
  #, fuzzy
+#| msgid "Reallocate the LHS in assignments"
  msgid "Reallocate the LHS in assignments."
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸"
+msgstr "Ð\92Ñ\8bÐ´ÐµÐ»Ñ\8fÑ\82Ñ\8c Ð¿Ð°Ð¼Ñ\8fÑ\82Ñ\8c Ð·Ð°Ð½Ð¾Ð²Ð¾ Ð´Ð»Ñ\8f Ð»ÐµÐ²Ñ\8bÑ\85 Ñ\87Ð°Ñ\81Ñ\82ÐµÐ¹ Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¹"
  
  #: fortran/lang.opt:639
  #, fuzzy
+#| msgid "Use a 4-byte record marker for unformatted files"
  msgid "Use a 4-byte record marker for unformatted files."
-msgstr "Использовать прямой (big-endian) порядок байт "
+msgstr "Использовать 4-байтный маркер записей в неформатированных файлах"
  
  #: fortran/lang.opt:643
  #, fuzzy
+#| msgid "Use an 8-byte record marker for unformatted files"
  msgid "Use an 8-byte record marker for unformatted files."
-msgstr "Использовать прямой (big-endian) порядок байт "
+msgstr "Использовать 8-байтный маркер записей в неформатированных файлах"
  
  #: fortran/lang.opt:647
+#, fuzzy
+#| msgid "Allocate local variables on the stack to allow indirect recursion"
  msgid "Allocate local variables on the stack to allow indirect recursion."
-msgstr ""
+msgstr "Размещать локальные переменные в стеке для поддержки неявной рекурсии"
  
  #: fortran/lang.opt:651
+#, fuzzy
+#| msgid "Copy array sections into a contiguous block on procedure entry"
  msgid "Copy array sections into a contiguous block on procedure entry."
-msgstr ""
+msgstr "При входе в процедуру копировать секции массивов в последовательный блок"
  
  #: fortran/lang.opt:655
+#, fuzzy
+#| msgid "-fcoarray=[...]\tSpecify which coarray parallelization should be used"
  msgid "-fcoarray=<none|single|lib>\tSpecify which coarray parallelization should be used."
-msgstr ""
+msgstr "-fcoarray=[...]\tЗадать способ coarray распараллеливания"
  
  #: fortran/lang.opt:658
  #, fuzzy, c-format
+#| msgid "unrecognized option %<-%s%>"
  msgid "Unrecognized option: %qs"
-msgstr "неопознанный ключ '-%s'"
+msgstr "неопознанный ключ %<-%s%>"
  
  #: fortran/lang.opt:671
+#, fuzzy
+#| msgid "-fcheck=[...]\tSpecify which runtime checks are to be performed"
  msgid "-fcheck=[...]\tSpecify which runtime checks are to be performed."
-msgstr ""
+msgstr "-fcheck=[...]\tЗадать набор runtime-проверок"
  
  #: fortran/lang.opt:675
+#, fuzzy
+#| msgid "Append a second underscore if the name already contains an underscore"
  msgid "Append a second underscore if the name already contains an underscore."
-msgstr ""
+msgstr "Добавлять второй символ подчеркивания к именам, уже содержащим подчеркивание"
  
  #: fortran/lang.opt:683
+#, fuzzy
+#| msgid "Apply negative sign to zero values"
  msgid "Apply negative sign to zero values."
-msgstr ""
+msgstr "Применять знак минус к нулевым значениям"
  
  #: fortran/lang.opt:687
  #, fuzzy
@@ -6474,39 +6659,49 @@ msgstr "Добавлять подчёркивания к доступным из
  #: common.opt:2224 common.opt:2306 common.opt:2314 common.opt:2322
  #: common.opt:2330 common.opt:2431 common.opt:2558
  msgid "Does nothing.  Preserved for backward compatibility."
-msgstr ""
+msgstr "Игнорируется. Сохранен для обратной совместимости"
  
  #: fortran/lang.opt:731
+#, fuzzy
+#| msgid "Statically link the GNU Fortran helper library (libgfortran)"
  msgid "Statically link the GNU Fortran helper library (libgfortran)."
-msgstr ""
+msgstr "Выполнить статическую компоновку с библиотекой GNU Fortran (libgfortran)"
  
  #: fortran/lang.opt:735
  #, fuzzy
+#| msgid "Conform to the ISO Fortran 2003 standard"
  msgid "Conform to the ISO Fortran 2003 standard."
-msgstr "Компилировать в соответствии с ISO 1999 C"
+msgstr "Компилировать в соответствии со стандартом ISO Fortran 2003"
  
  #: fortran/lang.opt:739
  #, fuzzy
+#| msgid "Conform to the ISO Fortran 2008 standard"
  msgid "Conform to the ISO Fortran 2008 standard."
-msgstr "Компилировать в соответствии с ISO 1999 C"
+msgstr "Компилировать в соответствии со стандартом ISO Fortran 2008"
  
  #: fortran/lang.opt:743
  #, fuzzy
+#| msgid "Conform to the ISO Fortran 2008 standard including TS 29113"
  msgid "Conform to the ISO Fortran 2008 standard including TS 29113."
-msgstr "Компилировать в соответствии с ISO 1999 C"
+msgstr "Компилировать в соответствии со стандартом ISO Fortran 2008, включая TS 29113"
  
  #: fortran/lang.opt:747
  #, fuzzy
+#| msgid "Conform to the ISO Fortran 95 standard"
  msgid "Conform to the ISO Fortran 95 standard."
-msgstr "Компилировать в соответствии с ISO 1990 C"
+msgstr "Компилировать в соответствии со стандартом ISO Fortran 95"
  
  #: fortran/lang.opt:751
+#, fuzzy
+#| msgid "Conform to nothing in particular"
  msgid "Conform to nothing in particular."
-msgstr ""
+msgstr "Не соответствует ничему конкретному"
  
  #: fortran/lang.opt:755
+#, fuzzy
+#| msgid "Accept extensions to support legacy code"
  msgid "Accept extensions to support legacy code."
-msgstr ""
+msgstr "Принимать расширения для поддержки унаследованного кода"
  
  #: c-family/c.opt:43 c-family/c.opt:46 c-family/c.opt:181
  #, c-format
@@ -6536,6 +6731,7 @@ msgstr "не задан маршрут после %qs"
  
  #: c-family/c.opt:182
  #, fuzzy
+#| msgid "-A<question>=<answer>\tAssert the <answer> to <question>.  Putting '-' before <question> disables the <answer> to <question>"
  msgid "-A<question>=<answer>\tAssert the <answer> to <question>.  Putting '-' before <question> disables the <answer> to <question>."
  msgstr "-A<вопрос>=<ответ>\tЗадать <ответ> на <вопрос>. Добавление '-' перед <вопросом> отменяет <ответ> на <вопрос>"
  
@@ -6553,13 +6749,15 @@ msgstr "Не удалять комментарии при макроподста
  
  #: c-family/c.opt:194
  #, fuzzy
+#| msgid "-D<macro>[=<val>]\tDefine a <macro> with <val> as its value.  If just <macro> is given, <val> is taken to be 1"
  msgid "-D<macro>[=<val>]\tDefine a <macro> with <val> as its value.  If just <macro> is given, <val> is taken to be 1."
-msgstr "Определить <макрос> со значением <знач.>. Если задан только <макрос>, <знач.> считается равным 1"
+msgstr "-D<макрос>[=<знач.>]\tОпределить <макрос> со значением <знач.>. Если задан только <макрос>, <знач.> считается равным 1"
  
  #: c-family/c.opt:201
  #, fuzzy
+#| msgid "-F <dir>\tAdd <dir> to the end of the main framework include path"
  msgid "-F <dir>\tAdd <dir> to the end of the main framework include path."
-msgstr "Добавить <каталог> в конец основного пути поиска включаемых инфраструктур"
+msgstr "-F <каталог>\tДобавить <каталог> в конец основного пути поиска включаемых инфраструктур"
  
  #: c-family/c.opt:205
  #, fuzzy
@@ -6569,8 +6767,9 @@ msgstr "Печатать имена используемых заголовоч
  
  #: c-family/c.opt:209
  #, fuzzy
+#| msgid "-I <dir>\tAdd <dir> to the end of the main include path"
  msgid "-I <dir>\tAdd <dir> to the end of the main include path."
-msgstr "Добавить <каталог> в конец основного пути поиска заголовков"
+msgstr "-I <каталог>\tДобавить <каталог> в конец основного пути поиска заголовков"
  
  #: c-family/c.opt:213
  #, fuzzy
@@ -6586,8 +6785,9 @@ msgstr "Генерировать make-зависимости и компилир
  
  #: c-family/c.opt:221
  #, fuzzy
+#| msgid "-MF <file>\tWrite dependency output to the given file"
  msgid "-MF <file>\tWrite dependency output to the given file."
-msgstr "Вывести зависимости в указанный файл"
+msgstr "-MF <файл>\tВывести зависимости в указанный <файл>"
  
  #: c-family/c.opt:225
  #, fuzzy
@@ -6620,13 +6820,15 @@ msgstr "не задана цель после %qs"
  
  #: c-family/c.opt:241
  #, fuzzy
+#| msgid "-MQ <target>\tAdd a MAKE-quoted target"
  msgid "-MQ <target>\tAdd a MAKE-quoted target."
-msgstr "Добавить экранированную MAKE-цель"
+msgstr "-MQ <цель>\tДобавить экранированную MAKE-цель"
  
  #: c-family/c.opt:245
  #, fuzzy
+#| msgid "-MT <target>\tAdd an unquoted target"
  msgid "-MT <target>\tAdd an unquoted target."
-msgstr "Добавить неэкранированную MAKE-цель"
+msgstr "-MT <цель>\tДобавить неэкранированную MAKE-цель"
  
  #: c-family/c.opt:249
  #, fuzzy
@@ -6636,8 +6838,9 @@ msgstr "Не генерировать директивы #строка"
  
  #: c-family/c.opt:253
  #, fuzzy
+#| msgid "-U<macro>\tUndefine <macro>"
  msgid "-U<macro>\tUndefine <macro>."
-msgstr "Отменить определение макроса"
+msgstr "-U<макрос>\tОтменить определение макроса"
  
  #: c-family/c.opt:257
  #, fuzzy
@@ -6655,8 +6858,9 @@ msgstr ""
  
  #: c-family/c.opt:272
  #, fuzzy
+#| msgid "Warn about suspicious uses of memory addresses"
  msgid "Warn about suspicious uses of memory addresses."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\81Ñ\82Ð°Ð½Ð´Ð°Ñ\80Ñ\82Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ð´Ð»Ñ\8f \"main\""
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð¿Ð¾Ð´Ð¾Ð·Ñ\80Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÑ\85 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ñ\8fÑ\85 Ð°Ð´Ñ\80ÐµÑ\81Ð¾Ð² Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸"
  
  #: c-family/c.opt:276 ada/gcc-interface/lang.opt:57
  #, fuzzy
@@ -6685,8 +6889,10 @@ msgid "Warn when __builtin_frame_address or __builtin_return_address is used uns
  msgstr ""
  
  #: c-family/c.opt:304
+#, fuzzy
+#| msgid "Warn when a built-in preprocessor macro is undefined or redefined"
  msgid "Warn when a built-in preprocessor macro is undefined or redefined."
-msgstr ""
+msgstr "Предупреждать о случаях переопределения или отмены встроенных макросов препроцессора"
  
  #: c-family/c.opt:308
  #, fuzzy
@@ -6708,13 +6914,15 @@ msgstr "Предупреждать о конструкциях C, не явля
  
  #: c-family/c.opt:323
  #, fuzzy
+#| msgid "Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 2011"
  msgid "Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 2011."
-msgstr "Предупреждать о конструкциях C, не являющихся общими для C и C++"
+msgstr "Предупреждать о конструкциях C++, смысл которых различается в ISO C++ 1998 и ISO C++ 2011"
  
  #: c-family/c.opt:327
  #, fuzzy
+#| msgid "Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 2011"
  msgid "Warn about C++ constructs whose meaning differs between ISO C++ 2011 and ISO C++ 2014."
-msgstr "Предупреждать о конструкциях C, не являющихся общими для C и C++"
+msgstr "Предупреждать о конструкциях C++, смысл которых различается в ISO C++ 1998 и ISO C++ 2011"
  
  #: c-family/c.opt:331
  #, fuzzy
@@ -6734,8 +6942,9 @@ msgstr ""
  
  #: c-family/c.opt:343
  #, fuzzy
+#| msgid "Warn about variables that might be changed by \"longjmp\" or \"vfork\""
  msgid "Warn about variables that might be changed by \"longjmp\" or \"vfork\"."
-msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %q+D Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ñ\80Ñ\87ÐµÐ½Ð° Ð²Ñ\8bÐ·Ð¾Ð²Ð°Ð¼Ð¸ %<longjmp%> Ð¸Ð»Ð¸ %<vfork%>"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85, ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ñ\80Ñ\87ÐµÐ½Ñ\8b Ð²Ñ\8bÐ·Ð¾Ð²Ð°Ð¼Ð¸ \"longjmp\" Ð¸Ð»Ð¸ \"vfork\""
  
  #: c-family/c.opt:347
  #, fuzzy
@@ -6755,13 +6964,15 @@ msgstr ""
  
  #: c-family/c.opt:359
  #, fuzzy
+#| msgid "Warn for implicit type conversions that may change a value"
  msgid "Warn for implicit type conversions that may change a value."
-msgstr "сравнение знакового и беззнакового целых выражений"
+msgstr "Предупреждать, если неявное преобразование типа может изменить значение"
  
  #: c-family/c.opt:363
  #, fuzzy
+#| msgid "Warn for converting NULL from/to a non-pointer type"
  msgid "Warn for converting NULL from/to a non-pointer type."
-msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ NULL Ðº Ð½ÐµÑ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð¼Ñ\83 Ñ\82Ð¸Ð¿у"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8fÑ\85 NULL Ðº Ð½ÐµÑ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð¼Ñ\83 Ñ\82Ð¸Ð¿Ñ\83 Ð¸Ð»Ð¸ Ð¸Ð· Ð½ÐµÑ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ Ðº Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð¼у"
  
  #: c-family/c.opt:371
  #, fuzzy
@@ -6787,8 +6998,9 @@ msgstr "доступ по указателю на неполный тип"
  
  #: c-family/c.opt:387
  #, fuzzy
+#| msgid "Warn about deleting polymorphic objects with non-virtual destructors"
  msgid "Warn about deleting polymorphic objects with non-virtual destructors."
-msgstr "Предупреждать о невиртуальных деструкторах"
+msgstr "Предупреждать об уничтожении полиморфных объектов с невиртуальными деструкторами"
  
  #: c-family/c.opt:391
  #, fuzzy
@@ -6808,9 +7020,9 @@ msgstr ""
  
  #: c-family/c.opt:403
  #, fuzzy
-#| msgid "static or type qualifiers in non-parameter array declarator"
+#| msgid "Warn whenever type qualifiers are ignored."
  msgid "Warn if type qualifiers on pointers are discarded."
-msgstr "static или квалификаторы типа в деклараторе массива, не являющегося "
+msgstr "Предупреждать о случаях игнорирования квалификаторов типа."
  
  #: c-family/c.opt:407
  #, fuzzy
@@ -6830,8 +7042,9 @@ msgstr "Предупреждать о отступлениях от стиля E
  
  #: c-family/c.opt:419
  #, fuzzy
+#| msgid "Warn about an empty body in an if or else statement"
  msgid "Warn about an empty body in an if or else statement."
-msgstr "%Hпустая else-часть"
+msgstr "Предупреждать о пустых if- и else-частях условных операторов"
  
  #: c-family/c.opt:423
  #, fuzzy
@@ -6841,18 +7054,21 @@ msgstr "Предупреждать о наличии лишнего текста
  
  #: c-family/c.opt:427
  #, fuzzy
+#| msgid "Warn about comparison of different enum types"
  msgid "Warn about comparison of different enum types."
-msgstr "Предупреждать о отступлениях от стиля Effective C++"
+msgstr "Предупреждать о сравнениях значений разных перечислимых типов"
  
  #: c-family/c.opt:435
  #, fuzzy
+#| msgid "This switch is deprecated; use -Werror=implicit-function-declaration instead"
  msgid "This switch is deprecated; use -Werror=implicit-function-declaration instead."
-msgstr "Этот ключ устарел; используйте -Wextra."
+msgstr "Этот ключ устарел; используйте -Werror=implicit-function-declaration"
  
  #: c-family/c.opt:439
  #, fuzzy
+#| msgid "Warn for implicit type conversions that may change a value"
  msgid "Warn for implicit type conversions that cause loss of floating point precision."
-msgstr "сравнение знакового и беззнакового целых выражений"
+msgstr "Предупреждать, если неявное преобразование типа может изменить значение"
  
  #: c-family/c.opt:443
  #, fuzzy
@@ -6868,8 +7084,9 @@ msgstr "Предупреждать о некорректных форматах
  
  #: c-family/c.opt:451
  #, fuzzy
+#| msgid "Warn about format strings that contain NUL bytes"
  msgid "Warn about format strings that contain NUL bytes."
-msgstr "Предупреждать о форматных строках, не являющихся литералами"
+msgstr "Предупреждать о форматных строках, содержащих нулевые байты"
  
  #: c-family/c.opt:455
  #, fuzzy
@@ -6909,12 +7126,13 @@ msgstr "Предупреждать о форматных строках нуле
  
  #: c-family/c.opt:483
  msgid "Warn whenever type qualifiers are ignored."
-msgstr ""
+msgstr "Предупреждать о случаях игнорирования квалификаторов типа."
  
  #: c-family/c.opt:487
  #, fuzzy
+#| msgid "Warn whenever type qualifiers are ignored."
  msgid "Warn whenever attributes are ignored."
-msgstr "Предупреждать о неиспользуемых переменных"
+msgstr "Предупреждать о случаях игнорирования квалификаторов типа."
  
  #: c-family/c.opt:491
  msgid "Warn when there is a conversion between pointers that have incompatible types."
@@ -6928,13 +7146,15 @@ msgstr "Предупреждать о переменных, в инициали
  
  #: c-family/c.opt:499
  #, fuzzy
+#| msgid "Warn about implicit declarations"
  msgid "Warn about implicit declarations."
-msgstr "Предупреждать о неявных декларациях функций"
+msgstr "Предупреждать о неявных декларациях"
  
  #: c-family/c.opt:503
  #, fuzzy
+#| msgid "Warn about implicit conversions from \"float\" to \"double\""
  msgid "Warn about implicit conversions from \"float\" to \"double\"."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8fÑ\85 \"float\" Ð² \"double\" "
  
  #: c-family/c.opt:507
  #, fuzzy
@@ -6976,16 +7196,19 @@ msgstr "Предупреждать о PCH, которые были найден
  
  #: c-family/c.opt:538
  #, fuzzy
+#| msgid "Warn when a jump misses a variable initialization"
  msgid "Warn when a jump misses a variable initialization."
-msgstr "Предупреждать о регистровых переменных, объявленных volatile"
+msgstr "Предупреждать, если безусловный переход обходит инициализацию переменных"
  
  #: c-family/c.opt:542
  msgid "Warn when a string or character literal is followed by a ud-suffix which does not begin with an underscore."
  msgstr ""
  
  #: c-family/c.opt:546
+#, fuzzy
+#| msgid "Warn when a logical operator is suspiciously always evaluating to true or false"
  msgid "Warn when a logical operator is suspiciously always evaluating to true or false."
-msgstr ""
+msgstr "Предупреждать, если значение логической операции всегда истина или всегда ложь"
  
  #: c-family/c.opt:550
  msgid "Warn when logical not is used on the left hand side operand of a comparison."
@@ -7083,8 +7306,9 @@ msgstr "Предупреждать о переключателях по enum-т
  
  #: c-family/c.opt:627
  #, fuzzy
+#| msgid "Warn about truncated character expressions"
  msgid "Warn about switches with boolean controlling expression."
-msgstr "Предупреждать об устаревших возможностях компилятора, которые будут выведены из употребления в последующих версиях"
+msgstr "Предупреждать об усеченных строковых выражениях"
  
  #: c-family/c.opt:631
  #, fuzzy
@@ -7099,8 +7323,10 @@ msgid "Warn about user-specified include directories that do not exist."
  msgstr "Предупреждать о заданных пользователем, но не существующих каталогах заголовков"
  
  #: c-family/c.opt:643
+#, fuzzy
+#| msgid "Warn about function parameters declared without a type specifier in K&R-style functions"
  msgid "Warn about function parameters declared without a type specifier in K&R-style functions."
-msgstr ""
+msgstr "Предупреждать о параметрах функций, декларированных без типа в функциях, описанных в стиле K&R"
  
  #: c-family/c.opt:647
  #, fuzzy
@@ -7128,8 +7354,9 @@ msgstr "Предупреждать о char-константах, содержа
  
  #: c-family/c.opt:658
  #, fuzzy
+#| msgid "Warn about narrowing conversions within { } that are ill-formed in C++11"
  msgid "Warn about narrowing conversions within { } that are ill-formed in C++11."
-msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ %qE Ð¸Ð· %qT Ð² %qT Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð¾"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ñ\81Ñ\83Ð¶Ð°Ñ\8eÑ\89Ð¸Ñ\85 Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8fÑ\85 Ð² { }, Ñ\8fÐ²Ð»Ñ\8fÑ\8eÑ\89Ð¸Ñ\85Ñ\81Ñ\8f Ð´ÐµÑ\84ÐµÐºÑ\82Ð½Ñ\8bÐ¼Ð¸ Ð² C++11"
  
  #: c-family/c.opt:662
  #, fuzzy
@@ -7138,8 +7365,10 @@ msgid "Warn about \"extern\" declarations not at file scope."
  msgstr "Предупреждать об \"extern\" декларациях не на уровне файла"
  
  #: c-family/c.opt:666
+#, fuzzy
+#| msgid "Warn when a noexcept expression evaluates to false even though the expression can't actually throw"
  msgid "Warn when a noexcept expression evaluates to false even though the expression can't actually throw."
-msgstr ""
+msgstr "Предупреждать, если noexcept-выражение имеет значение false, даже если выражение не может вызвать исключение"
  
  #: c-family/c.opt:670
  #, fuzzy
@@ -7161,8 +7390,9 @@ msgstr "Предупреждать о передаче NULL в качестве
  
  #: c-family/c.opt:694
  #, fuzzy
+#| msgid "-Wnormalized=<id|nfc|nfkc>\tWarn about non-normalised Unicode strings"
  msgid "-Wnormalized=<none|id|nfc|nfkc>\tWarn about non-normalised Unicode strings."
-msgstr "Предупреждать о ненормализованных строках Unicode"
+msgstr "-Wnormalized=<id|nfc|nfkc>\tПредупреждать о ненормализованных строках Unicode"
  
  #: c-family/c.opt:701
  msgid "argument %qs to %<-Wnormalized%> not recognized"
@@ -7176,8 +7406,9 @@ msgstr "Предупреждать об использовании привед
  
  #: c-family/c.opt:721
  #, fuzzy
+#| msgid "Warn for obsolescent usage in a declaration"
  msgid "Warn for obsolescent usage in a declaration."
-msgstr "Предупреждать о неявных декларациях функций"
+msgstr "Предупреждать об использовании устаревшего синтаксиса деклараций"
  
  #: c-family/c.opt:725
  #, fuzzy
@@ -7190,8 +7421,10 @@ msgid "Warn if a simd directive is overridden by the vectorizer cost model."
  msgstr ""
  
  #: c-family/c.opt:733
+#, fuzzy
+#| msgid "Warn if a string is longer than the maximum portable length specified by the standard"
  msgid "Warn if a string is longer than the maximum portable length specified by the standard."
-msgstr ""
+msgstr "Предупреждать, если строка длиннее чем максимальный размер, указанный в стандарте"
  
  #: c-family/c.opt:737
  #, fuzzy
@@ -7201,17 +7434,21 @@ msgstr "Предупреждать о перегруженных именах в
  
  #: c-family/c.opt:741
  #, fuzzy
+#| msgid "Warn about overriding initializers without side effects"
  msgid "Warn about overriding initializers without side effects."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85, Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÑ\85 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¸Ñ\85 Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð¿ÐµÑ\80ÐµÐ¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÑ\85 Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð² Ð±ÐµÐ· Ð¿Ð¾Ð±Ð¾Ñ\87Ð½Ñ\8bÑ\85 Ñ\8dÑ\84Ñ\84ÐµÐºÑ\82Ð¾Ð²"
  
  #: c-family/c.opt:745
  #, fuzzy
+#| msgid "Warn about overriding initializers without side effects"
  msgid "Warn about overriding initializers with side effects."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85, Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÑ\85 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¸Ñ\85 Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð¿ÐµÑ\80ÐµÐ¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÑ\85 Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð² Ð±ÐµÐ· Ð¿Ð¾Ð±Ð¾Ñ\87Ð½Ñ\8bÑ\85 Ñ\8dÑ\84Ñ\84ÐµÐºÑ\82Ð¾Ð²"
  
  #: c-family/c.opt:749
+#, fuzzy
+#| msgid "Warn about packed bit-fields whose offset changed in GCC 4.4"
  msgid "Warn about packed bit-fields whose offset changed in GCC 4.4."
-msgstr ""
+msgstr "Предупреждать об упакованных битовых полях, смещение которых изменено в GCC 4.4"
  
  #: c-family/c.opt:753
  #, fuzzy
@@ -7250,8 +7487,10 @@ msgid "Warn about misuses of pragmas."
  msgstr "Предупреждать о неправильном использовании прагм"
  
  #: c-family/c.opt:781
+#, fuzzy
+#| msgid "Warn if a property for an Objective-C object has no assign semantics specified"
  msgid "Warn if a property for an Objective-C object has no assign semantics specified."
-msgstr ""
+msgstr "Предупреждать, если для свойства объекта Objective-C не задана семантика присваивания"
  
  #: c-family/c.opt:785
  #, fuzzy
@@ -7299,8 +7538,9 @@ msgstr "Предупреждать о возможном нарушении пр
  
  #: c-family/c.opt:821
  #, fuzzy
+#| msgid "local declaration of %qE hides instance variable"
  msgid "Warn if a local declaration hides an instance variable."
-msgstr "Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ð¾Ðµ Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¸Ðµ %qs Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÐ²Ð°ÐµÑ\82 Ð¾Ð´Ð½Ð¾Ð¸Ð¼ÐµÐ½Ð½Ñ\83Ñ\8e переменную"
+msgstr "Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qE Ñ\81ÐºÑ\80Ñ\8bÐ²Ð°ÐµÑ\82 instance переменную"
  
  #: c-family/c.opt:825 c-family/c.opt:829
  msgid "Warn if left shift of a signed value overflows."
@@ -7332,8 +7572,9 @@ msgstr "Предупреждать о сравнениях между signed и
  
  #: c-family/c.opt:853
  #, fuzzy
+#| msgid "Warn for implicit type conversions between signed and unsigned integers"
  msgid "Warn for implicit type conversions between signed and unsigned integers."
-msgstr "сравнение знакового и беззнакового целых выражений"
+msgstr "Предупреждать о неявных преобразованиях между знаковыми и беззнаковыми целыми типами"
  
  #: c-family/c.opt:857
  #, fuzzy
@@ -7360,8 +7601,10 @@ msgid "Warn if type signatures of candidate methods do not match exactly."
  msgstr "Предупреждать о несовпадении сигнатур применимых методов"
  
  #: c-family/c.opt:881
+#, fuzzy
+#| msgid "Warn when __sync_fetch_and_nand and __sync_nand_and_fetch built-in functions are used"
  msgid "Warn when __sync_fetch_and_nand and __sync_nand_and_fetch built-in functions are used."
-msgstr ""
+msgstr "Предупреждать об использовании встроенных функций __sync_fetch_and_nand и __sync_nand_and_fetch"
  
  #: c-family/c.opt:885
  #, fuzzy
@@ -7371,8 +7614,9 @@ msgstr "Устаревший ключ. Игнорируется."
  
  #: c-family/c.opt:893
  #, fuzzy
+#| msgid "Warn when a logical operator is suspiciously always evaluating to true or false"
  msgid "Warn if a comparison always evaluates to true or false."
-msgstr "Ð¸Ð·-Ð·Ð° Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87ÐµÐ½Ð½Ð¾Ñ\81Ñ\82Ð¸ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° Ñ\82Ð¸Ð¿Ð° Ð´Ð°Ð½Ð½Ñ\8bÑ\85, Ñ\80ÐµÐ·Ñ\83Ð»Ñ\8cÑ\82Ð°Ñ\82 Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8f всегда ложь"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c, ÐµÑ\81Ð»Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð»Ð¾Ð³Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ Ð²Ñ\81ÐµÐ³Ð´Ð° Ð¸Ñ\81Ñ\82Ð¸Ð½Ð° Ð¸Ð»Ð¸ всегда ложь"
  
  #: c-family/c.opt:897
  msgid "Warn if a throw expression will always result in a call to terminate()."
@@ -7385,8 +7629,10 @@ msgid "Warn about features not present in traditional C."
  msgstr "Предупреждать об использовании средств, отсутствующих в традиционном C"
  
  #: c-family/c.opt:905
+#, fuzzy
+#| msgid "Warn of prototypes causing type conversions different from what would happen in the absence of prototype"
  msgid "Warn of prototypes causing type conversions different from what would happen in the absence of prototype."
-msgstr ""
+msgstr "Предупреждать о прототипах, приводящих к преобразованиям типа, отличным от преобразований, которые были бы выполнены в отсутствие прототипа"
  
  #: c-family/c.opt:909
  #, fuzzy
@@ -7414,13 +7660,15 @@ msgstr "Предупреждать о наличии неизвестных пр
  
  #: c-family/c.opt:933
  #, fuzzy
+#| msgid "Warn about unsuffixed float constants"
  msgid "Warn about unsuffixed float constants."
-msgstr "Предупреждать о \"подозрительных\" конструкциях"
+msgstr "Предупреждать о плавающих константах без суффиксов"
  
  #: c-family/c.opt:941
  #, fuzzy
+#| msgid "Warn when typedefs locally defined in a function are not used"
  msgid "Warn when typedefs locally defined in a function are not used."
-msgstr "Предупреждать об определенных в основном файле, но неиспользованных макросах"
+msgstr "Предупреждать о неиспользованных typedef-декларациях на уровне функции"
  
  #: c-family/c.opt:945
  #, fuzzy
@@ -7430,8 +7678,9 @@ msgstr "Предупреждать об определенных в основн
  
  #: c-family/c.opt:949
  #, fuzzy
+#| msgid "Warn if a caller of a function, marked with attribute warn_unused_result, does not use its return value"
  msgid "Warn if a caller of a function, marked with attribute warn_unused_result, does not use its return value."
-msgstr "%Hрезультат функции, декларированной с атрибутом warn_unused_result, игнорируется"
+msgstr "Предупреждать, если результат вызова функции, декларированной с атрибутом warn_unused_result, не используется"
  
  #: c-family/c.opt:957 c-family/c.opt:961
  #, fuzzy
@@ -7441,6 +7690,7 @@ msgstr "Предупреждать о неиспользуемых переме
  
  #: c-family/c.opt:965
  #, fuzzy
+#| msgid "Do not warn about using variadic macros when -pedantic"
  msgid "Warn about using variadic macros."
  msgstr "Не предупреждать об использовании макросов с переменным числом аргументов с -pedantic"
  
@@ -7450,8 +7700,9 @@ msgstr ""
  
  #: c-family/c.opt:973
  #, fuzzy
+#| msgid "Warn if a variable length array is used"
  msgid "Warn if a variable length array is used."
-msgstr "Предупреждать о неиспользуемых переменных"
+msgstr "Предупреждать об использовании массивов переменной длины"
  
  #: c-family/c.opt:977
  #, fuzzy
@@ -7464,20 +7715,24 @@ msgid "Warn on direct virtual inheritance."
  msgstr ""
  
  #: c-family/c.opt:985
+#, fuzzy
+#| msgid "%qT has virtual bases, default move assignment operator cannot be generated"
  msgid "Warn if a virtual base has a non-trivial move assignment operator."
-msgstr ""
+msgstr "%qT имеет виртуальные базы, подразумеваемый оператор присваивания с перемещением не может быть сгенерирован"
  
  #: c-family/c.opt:989
  msgid "In C++, nonzero means warn about deprecated conversion from string literals to 'char *'.  In C, similar warning, except that the conversion is of course not deprecated by the ISO C standard."
-msgstr ""
+msgstr "В C++ не 0 означает предупреждать об устаревших преобразованиях из строковых литералов в 'char *'. В C аналогичные предупреждения, с той разницей, что это преобразование допустимо в ISO C."
  
  #: c-family/c.opt:993
  #, fuzzy
+#| msgid "Warn when a literal '0' is used as null pointer"
  msgid "Warn when a literal '0' is used as null pointer."
-msgstr "Предупреждать о неиспользуемых метках"
+msgstr "Предупреждать, если литерал '0' используется как пустой указатель"
  
  #: c-family/c.opt:997
  #, fuzzy
+#| msgid "Warn about misuses of pragmas"
  msgid "Warn about useless casts."
  msgstr "Предупреждать о неправильном использовании прагм"
  
@@ -7506,14 +7761,17 @@ msgid "-fada-spec-parent=unit  Dump Ada specs as child units of given parent."
  msgstr ""
  
  #: c-family/c.opt:1028
+#, fuzzy
+#| msgid "Allow variadic functions without named parameter"
  msgid "Allow variadic functions without named parameter."
-msgstr ""
+msgstr "Разрешить функции с переменным числом аргументов без именованных параметров"
  
  #: c-family/c.opt:1032 c-family/c.opt:1261 c-family/c.opt:1549
  #: c-family/c.opt:1553 c-family/c.opt:1569
  #, fuzzy
+#| msgid "No longer supported"
  msgid "No longer supported."
-msgstr "ÐºÐ»Ñ\8eÑ\87 %qs Ð±ольше не поддерживается"
+msgstr "Ð\91ольше не поддерживается"
  
  #: c-family/c.opt:1036
  #, fuzzy
@@ -7599,13 +7857,15 @@ msgstr "Добавлять фиктивные правила для всех з
  
  #: c-family/c.opt:1125
  #, fuzzy
+#| msgid "Generate call insns as indirect calls"
  msgid "Generate bounds passing for calls."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ñ\8bÐµ Ð²Ñ\8bÐ·Ð¾Ð²Ñ\8b, ÐµÑ\81Ð»Ð¸ Ð½Ñ\83Ð¶Ð½Ð¾"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð²Ñ\8bÐ·Ð¾Ð²Ð° ÐºÐ°Ðº ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ñ\8bÐµ Ð²Ñ\8bÐ·Ð¾Ð²Ñ\8b"
  
  #: c-family/c.opt:1129
  #, fuzzy
+#| msgid "argument of function call might be a candidate for a format attribute"
  msgid "Instrument only functions marked with bnd_instrument attribute."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8fÑ\85, ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐ¼ Ð¼Ð¾Ð¶Ð½Ð¾ Ð½Ð°Ð·Ð½Ð°Ñ\87Ð¸Ñ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 format"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð²Ñ\8bÐ·Ð¾Ð²Ð° Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð¼Ð¾Ð³ Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ°Ð½Ð´Ð¸Ð´Ð°Ñ\82Ð¾Ð¼ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
  
  #: c-family/c.opt:1133
  msgid "Transform instrumented builtin calls into calls to wrappers."
@@ -7617,6 +7877,7 @@ msgstr ""
  
  #: c-family/c.opt:1147
  #, fuzzy
+#| msgid "Enable support for huge objects"
  msgid "Enable support for C++ concepts."
  msgstr "Включить поддержку больших объектов"
  
@@ -7633,22 +7894,27 @@ msgstr "не задано имя класса для %qs"
  
  #: c-family/c.opt:1159
  #, fuzzy
+#| msgid "-fconst-string-class=<name>\tUse class <name> for constant strings"
  msgid "-fconst-string-class=<name>\tUse class <name> for constant strings."
-msgstr "Использовать class <имя> как тип строковых констант"
+msgstr "-fconst-string-class=<имя>\tИспользовать class <имя> как тип строковых констант"
  
  #: c-family/c.opt:1163
  #, fuzzy
+#| msgid "-fconstexpr-depth=<number>\tSpecify maximum constexpr recursion depth"
  msgid "-fconstexpr-depth=<number>\tSpecify maximum constexpr recursion depth."
-msgstr "Глубина конкретизации шаблонов"
+msgstr "-fconstexpr-depth=<number>\tМаксимальная глубина рекурсии константных выражений"
  
  #: c-family/c.opt:1167
  #, fuzzy
+#| msgid "Emit debug annotations during preprocessing"
  msgid "Emit debug annotations during preprocessing."
-msgstr "Ð¢Ñ\80Ð°Ð´Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¾Ñ\82Ð»Ð°Ð´Ð¾Ñ\87Ð½Ñ\8bÐµ Ð°Ð½Ð½Ð¾Ñ\82Ð°Ñ\86Ð¸Ð¸ Ð²Ð¾ Ð²Ñ\80ÐµÐ¼Ñ\8f Ð¿Ñ\80ÐµÐ¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f"
  
  #: c-family/c.opt:1171
+#, fuzzy
+#| msgid "-fdeduce-init-list\tenable deduction of std::initializer_list for a template type parameter from a brace-enclosed initializer-list"
  msgid "-fdeduce-init-list\tenable deduction of std::initializer_list for a template type parameter from a brace-enclosed initializer-list."
-msgstr ""
+msgstr "-fdeduce-init-list\tвключить дедукцию std::initializer_list для параметра с шаблонным типом из списка инициализации в фигурных скобках"
  
  #: c-family/c.opt:1175
  #, fuzzy
@@ -7657,9 +7923,8 @@ msgid "Factor complex constructors and destructors to favor space over speed."
  msgstr "Предупреждать о классах, в которых все конструкторы и деструкторы private"
  
  #: c-family/c.opt:1183
-#, fuzzy
  msgid "Preprocess directives only."
-msgstr "Ð\9eÐ±Ñ\80Ð°Ð±Ð°Ñ\82Ñ\8bÐ²Ð°Ñ\82Ñ\8c Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ñ\8b #ident"
+msgstr "Ð\9fÑ\80ÐµÐ¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ñ\8b"
  
  #: c-family/c.opt:1187
  #, fuzzy
@@ -7683,8 +7948,9 @@ msgstr "Генерировать код для проверки исключит
  
  #: c-family/c.opt:1209
  #, fuzzy
+#| msgid "-fexec-charset=<cset>\tConvert all strings and character constants to character set <cset>"
  msgid "-fexec-charset=<cset>\tConvert all strings and character constants to character set <cset>."
-msgstr "Конвертировать строковые и char-константы в указанную <кодировку>"
+msgstr "-fexec-charset=<кодировка>\tКонвертировать строковые и char-константы в указанную <кодировку>"
  
  #: c-family/c.opt:1213
  #, fuzzy
@@ -7694,8 +7960,9 @@ msgstr "Разрешить универсальные имена литер (\\u
  
  #: c-family/c.opt:1217
  #, fuzzy
+#| msgid "-finput-charset=<cset>\tSpecify the default character set for source files"
  msgid "-finput-charset=<cset>\tSpecify the default character set for source files."
-msgstr "Кодировка исходных файлов по умолчанию"
+msgstr "-finput-charset=<кодировка>\tКодировка исходных файлов по умолчанию"
  
  #: c-family/c.opt:1221
  msgid "Support dynamic initialization of thread-local variables in a different translation unit."
@@ -7727,8 +7994,9 @@ msgstr "Генерировать код для среды выполнения G
  
  #: c-family/c.opt:1244
  #, fuzzy
+#| msgid "Use traditional GNU semantics for inline functions"
  msgid "Use traditional GNU semantics for inline functions."
-msgstr "Ð² Ñ\82Ñ\80Ð°Ð´Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾Ð¼ C Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¾Ð±Ñ\8aÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ð¹ Ð·Ð°Ð¿Ñ\80ÐµÑ\89ÐµÐ½Ð°"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð´Ð»Ñ\8f inline Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹ Ñ\82Ñ\80Ð°Ð´Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ñ\83Ñ\8e Ñ\81ÐµÐ¼Ð°Ð½Ñ\82Ð¸ÐºÑ\83 GNU"
  
  #: c-family/c.opt:1250
  msgid "-fhandle-exceptions has been renamed -fexceptions (and is now on by default)"
@@ -7765,12 +8033,14 @@ msgid "Inject friend functions into enclosing namespace."
  msgstr "Вставлять friend-функции в объемлющие namespace-области"
  
  #: c-family/c.opt:1281
+#, fuzzy
+#| msgid "Don't emit dllexported inline functions unless needed"
  msgid "Don't emit dllexported inline functions unless needed."
-msgstr ""
+msgstr "Не генерировать dll-экспортированные inline функции без необходимости"
  
  #: c-family/c.opt:1288
  msgid "Allow implicit conversions between vectors with differing numbers of subparts and/or differing element types."
-msgstr ""
+msgstr "Разрешить неявные преобразования типов между векторами с разным числом элементов или с разными типами элементов"
  
  #: c-family/c.opt:1292
  #, fuzzy
@@ -7795,25 +8065,32 @@ msgid "Allow access to instance variables as if they were local declarations wit
  msgstr ""
  
  #: c-family/c.opt:1323
+#, fuzzy
+#| msgid "-fvisibility=[default|internal|hidden|protected]\tSet the default symbol visibility"
  msgid "-fvisibility=[private|protected|public|package]\tSet the default symbol visibility."
-msgstr ""
+msgstr "-fvisibility=[default|internal|hidden|protected]\tУстановить атрибут видимости символов по умолчанию"
  
  #: c-family/c.opt:1326
  #, fuzzy, c-format
+#| msgid "unrecognized visibility value %qs"
  msgid "unrecognized ivar visibility value %qs"
-msgstr "некорректный тип видимости \"%s\""
+msgstr "некорректный тип видимости %qs"
  
  #: c-family/c.opt:1348
+#, fuzzy
+#| msgid "Treat a throw() exception specification as noexcept to improve code size"
  msgid "Treat a throw() exception specification as noexcept to improve code size."
-msgstr ""
+msgstr "Трактовать спецификации throw() как noexcept для сокращения размера кода"
  
  #: c-family/c.opt:1352
  msgid "Specify which ABI to use for Objective-C family code and meta-data generation."
-msgstr ""
+msgstr "Задать ABI кода для языков семейства Objective-C и генерации метаданных."
  
  #: c-family/c.opt:1358
+#, fuzzy
+#| msgid "Generate special Objective-C methods to initialize/destroy non-POD C++ ivars, if needed"
  msgid "Generate special Objective-C methods to initialize/destroy non-POD C++ ivars, if needed."
-msgstr ""
+msgstr "Генерировать специальные методы Objective-C для инициации/разрушения не-POD С++ instance-переменных, при необходимости"
  
  #: c-family/c.opt:1362
  #, fuzzy
@@ -7835,7 +8112,7 @@ msgstr "Включить сборку мусора (GC) в программах
  
  #: c-family/c.opt:1376
  msgid "Enable inline checks for nil receivers with the NeXT runtime and ABI version 2."
-msgstr ""
+msgstr "Включить inline проверки нулевых получателей при помощи runtime NeXT и ABI версии 2."
  
  #: c-family/c.opt:1381
  #, fuzzy
@@ -7845,29 +8122,36 @@ msgstr "Подключить поддержку времени выполнен
  
  #: c-family/c.opt:1385
  #, fuzzy
+#| msgid "Conform to the Objective-C 1.0 language as implemented in GCC 4.0"
  msgid "Conform to the Objective-C 1.0 language as implemented in GCC 4.0."
-msgstr "Компилировать в соответствии с ISO 1990 C с дополнениями от 1994"
+msgstr "Компилировать в соответствии со спецификацией языка Objective-C 1.0 в реализации GCC 4.0"
  
+#
  #: c-family/c.opt:1389
  #, fuzzy
+#| msgid "Enable OpenMP"
  msgid "Enable OpenACC."
-msgstr "Включить режим отладки"
+msgstr "Включить OpenMP"
  
  #: c-family/c.opt:1393
  msgid "Specify default OpenACC compute dimensions."
  msgstr ""
  
  #: c-family/c.opt:1397
+#, fuzzy
+#| msgid "Enable OpenMP (implies -frecursive in Fortran)"
  msgid "Enable OpenMP (implies -frecursive in Fortran)."
-msgstr ""
+msgstr "Включить OpenMP (для Фортрана подразумевает -frecursive)"
  
  #: c-family/c.opt:1401
  #, fuzzy
+#| msgid "Unclassifiable OpenMP directive at %C"
  msgid "Enable OpenMP's SIMD directives."
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐºÐ»Ð°Ñ\81Ñ\81Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ñ\83ÐµÐ¼Ð°Ñ\8f OpenMP Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð² %C"
  
  #: c-family/c.opt:1405
  #, fuzzy
+#| msgid "Recognize C++ keywords like \"compl\" and \"xor\""
  msgid "Recognize C++ keywords like \"compl\" and \"xor\"."
  msgstr "Распознавать ключевые слова C++, такие как \"compl\" и \"xor\""
  
@@ -7875,7 +8159,7 @@ msgstr "Распознавать ключевые слова C++, такие к
  #, fuzzy
  #| msgid "Look for and use PCH files even when preprocessing"
  msgid "Look for and use PCH files even when preprocessing."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸ Ð¸Ñ\81ÐºÐ°Ñ\82Ñ\8c Ñ\84Ð°Ð¹Ð»Ñ\8b PCH Ð´Ð°Ð¶Ð¾ во время препроцессирования"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸ Ð¸Ñ\81ÐºÐ°Ñ\82Ñ\8c Ñ\84Ð°Ð¹Ð»Ñ\8b PCH Ð´Ð°Ð¶Ðµ во время препроцессирования"
  
  #: c-family/c.opt:1420
  #, fuzzy
@@ -7896,12 +8180,16 @@ msgid "Treat the input file as already preprocessed."
  msgstr "Считать, что входной файл уже препроцессирован"
  
  #: c-family/c.opt:1436
+#, fuzzy
+#| msgid "-ftrack-macro-expansion=<0|1|2>  Track locations of tokens coming from macro expansion and display them in error messages"
  msgid "-ftrack-macro-expansion=<0|1|2>  Track locations of tokens coming from macro expansion and display them in error messages."
-msgstr ""
+msgstr "-ftrack-macro-expansion=<0|1|2>  Отслеживать позиции элементов из макроподстановок и показывать их в сообщениях об ошибках"
  
  #: c-family/c.opt:1440
+#, fuzzy
+#| msgid "-fno-pretty-templates Do not pretty-print template specializations as the template signature followed by the arguments"
  msgid "-fno-pretty-templates Do not pretty-print template specializations as the template signature followed by the arguments."
-msgstr ""
+msgstr "-fno-pretty-templates Не использовать красивую печать специализаций шаблонов в виде сигнатуры шаблона с последующими аргументами"
  
  #: c-family/c.opt:1444
  #, fuzzy
@@ -7947,8 +8235,9 @@ msgstr "По умолчанию считать тип \"char\" знаковым"
  
  #: c-family/c.opt:1472
  #, fuzzy
+#| msgid "Enable decimal floating point hardware support"
  msgid "Enable C++14 sized deallocation support."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð»Ð¸ Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ñ\83Ñ\80Ñ\83 Ð´Ð»Ñ\8f Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¹ Ñ\81 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\83Ñ\8e Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð´ÐµÑ\81Ñ\8fÑ\82Ð¸Ñ\87Ð½Ð¾Ð¹ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
  
  #: c-family/c.opt:1479
  msgid "-fsso-struct=[big-endian|little-endian]\tSet the default scalar storage order."
@@ -7956,8 +8245,9 @@ msgstr ""
  
  #: c-family/c.opt:1482
  #, fuzzy, c-format
+#| msgid "unrecognized register name %qs"
  msgid "unrecognized scalar storage order value %qs"
-msgstr "некорректное имя регистра \"%s\""
+msgstr "некорректное имя регистра %qs"
  
  #: c-family/c.opt:1492
  #, fuzzy
@@ -7966,28 +8256,34 @@ msgid "Display statistics accumulated during compilation."
  msgstr "Показать статистику компиляции"
  
  #: c-family/c.opt:1496
+#, fuzzy
+#| msgid "Assume that values of enumeration type are always within the minimum range of that type"
  msgid "Assume that values of enumeration type are always within the minimum range of that type."
-msgstr ""
+msgstr "Предполагать, что значения перечислимого типа всегда находятся в минимальном диапазоне этого типа"
  
  #: c-family/c.opt:1503
  #, fuzzy
+#| msgid "-ftabstop=<number>\tDistance between tab stops for column reporting"
  msgid "-ftabstop=<number>\tDistance between tab stops for column reporting."
-msgstr "Интервал табуляции при выдаче сообщений по столбцам"
+msgstr "-ftabstop=<number>\tИнтервал табуляции для правильного определения номера колонки в диагностике"
  
  #: c-family/c.opt:1507
  #, fuzzy
+#| msgid "Set the maximum number of iterations for RPTS to N"
  msgid "Set the maximum number of template instantiation notes for a single warning or error."
  msgstr "Задать максимальное число итераций для RPTS"
  
  #: c-family/c.opt:1514
  #, fuzzy
+#| msgid "-ftemplate-depth=<number>\tSpecify maximum template instantiation depth"
  msgid "-ftemplate-depth=<number>\tSpecify maximum template instantiation depth."
-msgstr "Глубина конкретизации шаблонов"
+msgstr "-ftemplate-depth=<number>\tМаксимальная глубина конкретизации шаблонов"
  
  #: c-family/c.opt:1521
  #, fuzzy
+#| msgid "-fno-threadsafe-statics\tDo not generate thread-safe code for initializing local statics"
  msgid "-fno-threadsafe-statics\tDo not generate thread-safe code for initializing local statics."
-msgstr "Не генерировать поточно-ориентированный код для инициализации локальных статических переменных"
+msgstr "-fno-threadsafe-statics\tНе генерировать поточно-безопасный код для инициализации локальных статических переменных"
  
  #: c-family/c.opt:1525
  #, fuzzy
@@ -8008,17 +8304,22 @@ msgid "Use __cxa_atexit to register destructors."
  msgstr "Использовать __cxa_atexit для регистрации деструкторов"
  
  #: c-family/c.opt:1537
+#, fuzzy
+#| msgid "Use __cxa_get_exception_ptr in exception handling"
  msgid "Use __cxa_get_exception_ptr in exception handling."
-msgstr ""
+msgstr "Использовать __cxa_get_exception_ptr для обработки исключений"
  
  #: c-family/c.opt:1541
  #, fuzzy
+#| msgid "Marks all inlined functions and methods as having hidden visibility"
  msgid "Marks all inlined functions and methods as having hidden visibility."
-msgstr "Отметить область видимости всех встроенных методов как скрытую"
+msgstr "Отметить область видимости всех inline-подставленных функций и методов как hidden"
  
  #: c-family/c.opt:1545
+#, fuzzy
+#| msgid "Changes visibility to match Microsoft Visual Studio by default"
  msgid "Changes visibility to match Microsoft Visual Studio by default."
-msgstr ""
+msgstr "Изменить атрибуты видимости в соответствии с правилами Microsoft Visual Studio"
  
  #: c-family/c.opt:1557
  #, fuzzy
@@ -8028,8 +8329,9 @@ msgstr "common-символы считать слабыми (weak)"
  
  #: c-family/c.opt:1561
  #, fuzzy
+#| msgid "-fwide-exec-charset=<cset>\tConvert all wide strings and character constants to character set <cset>"
  msgid "-fwide-exec-charset=<cset>\tConvert all wide strings and character constants to character set <cset>."
-msgstr "Широкие символы и строки широких символов конвертировать в заданную <кодировку>"
+msgstr "-fwide-exec-charset=<кодировка>\tКонстантные широкие символы и строки широких символов конвертировать в заданную <кодировку>"
  
  #: c-family/c.opt:1565
  #, fuzzy
@@ -8050,16 +8352,22 @@ msgid "Dump declarations to a .decl file."
  msgstr "Вывести декларации в файл .decl"
  
  #: c-family/c.opt:1581
+#, fuzzy
+#| msgid "-femit-struct-debug-baseonly\tAggressive reduced debug info for structs"
  msgid "-femit-struct-debug-baseonly\tAggressive reduced debug info for structs."
-msgstr ""
+msgstr "-femit-struct-debug-baseonly\tСильно сокращать отладочную информацию для структур"
  
  #: c-family/c.opt:1585
+#, fuzzy
+#| msgid "-femit-struct-debug-reduced\tConservative reduced debug info for structs"
  msgid "-femit-struct-debug-reduced\tConservative reduced debug info for structs."
-msgstr ""
+msgstr "-femit-struct-debug-reduced\tУмеренно сокращать отладочную информацию для структур"
  
  #: c-family/c.opt:1589
+#, fuzzy
+#| msgid "-femit-struct-debug-detailed=<spec-list>\tDetailed reduced debug info for structs"
  msgid "-femit-struct-debug-detailed=<spec-list>\tDetailed reduced debug info for structs."
-msgstr ""
+msgstr "-femit-struct-debug-detailed=<spec-list>\tЗадает детальные инструкции по сокращению отладочной информации для структур"
  
  #: c-family/c.opt:1593
  msgid "Interpret imaginary, fixed-point, or other gnu number suffix as the corresponding"
@@ -8067,53 +8375,63 @@ msgstr ""
  
  #: c-family/c.opt:1598
  #, fuzzy
+#| msgid "-idirafter <dir>\tAdd <dir> to the end of the system include path"
  msgid "-idirafter <dir>\tAdd <dir> to the end of the system include path."
-msgstr "Добавить <каталог> в конец пути поиска системных заголовков"
+msgstr "-idirafter <каталог>\tДобавить <каталог> в конец пути поиска системных заголовков"
  
  #: c-family/c.opt:1602
  #, fuzzy
+#| msgid "-imacros <file>\tAccept definition of macros in <file>"
  msgid "-imacros <file>\tAccept definition of macros in <file>."
-msgstr "Использовать макроопределения из <файла>"
+msgstr "-imacros <файл>\tИспользовать макроопределения из <файла>"
  
  #: c-family/c.opt:1606
  #, fuzzy
+#| msgid "-imultilib <dir>\tSet <dir> to be the multilib include subdirectory"
  msgid "-imultilib <dir>\tSet <dir> to be the multilib include subdirectory."
-msgstr "Считать <каталог> корневым каталогом системы"
+msgstr "-imultilib <каталог>\tУстановить <каталог> как подкаталог мультибиблиотеки заголовков"
  
  #: c-family/c.opt:1610
  #, fuzzy
+#| msgid "-include <file>\tInclude the contents of <file> before other files"
  msgid "-include <file>\tInclude the contents of <file> before other files."
-msgstr "Включить содержимое <файла> перед компиляцией других файлов"
+msgstr "-include <файл>\tВключить содержимое <файла> перед компиляцией других файлов"
  
  #: c-family/c.opt:1614
  #, fuzzy
+#| msgid "-iprefix <path>\tSpecify <path> as a prefix for next two options"
  msgid "-iprefix <path>\tSpecify <path> as a prefix for next two options."
-msgstr "Альтернативное имя для секции кода"
+msgstr "-iprefix <префикс>\tЗадает <префикс> для следующих двух ключей"
  
  #: c-family/c.opt:1618
  #, fuzzy
+#| msgid "-isysroot <dir>\tSet <dir> to be the system root directory"
  msgid "-isysroot <dir>\tSet <dir> to be the system root directory."
-msgstr "Считать <каталог> корневым каталогом системы"
+msgstr "-isysroot <каталог>\tСчитать <каталог> корневым каталогом системы"
  
  #: c-family/c.opt:1622
  #, fuzzy
+#| msgid "-isystem <dir>\tAdd <dir> to the start of the system include path"
  msgid "-isystem <dir>\tAdd <dir> to the start of the system include path."
-msgstr "Добавить <каталог> в начало пути поиска системных заголовков"
+msgstr "-isystem <каталог>\tДобавить <каталог> в начало пути поиска системных заголовков"
  
  #: c-family/c.opt:1626
  #, fuzzy
+#| msgid "-iquote <dir>\tAdd <dir> to the end of the quote include path"
  msgid "-iquote <dir>\tAdd <dir> to the end of the quote include path."
-msgstr "Добавить <каталог> в конец пути поиска системных заголовков"
+msgstr "-iquote <каталог>\tДобавить <каталог> в конец пути поиска заголовков \"в кавычках\""
  
  #: c-family/c.opt:1630
  #, fuzzy
+#| msgid "-iwithprefix <dir>\tAdd <dir> to the end of the system include path"
  msgid "-iwithprefix <dir>\tAdd <dir> to the end of the system include path."
-msgstr "Добавить <каталог> в конец пути поиска системных заголовков"
+msgstr "-iwithprefix <каталог>\tДобавить <каталог> в конец пути поиска системных заголовков"
  
  #: c-family/c.opt:1634
  #, fuzzy
+#| msgid "-iwithprefixbefore <dir>\tAdd <dir> to the end of the main include path"
  msgid "-iwithprefixbefore <dir>\tAdd <dir> to the end of the main include path."
-msgstr "Добавить <каталог> в конец основного пути поиска заголовков"
+msgstr "-iwithprefixbefore <каталог>\tДобавить <каталог> в конец основного пути поиска заголовков"
  
  #: c-family/c.opt:1644
  #, fuzzy
@@ -8141,8 +8459,9 @@ msgstr "Преобразовывать имена файлов при включ
  
  #: c-family/c.opt:1668 c-family/c.opt:1672
  #, fuzzy
+#| msgid "Conform to the ISO 1998 C++ standard revised by the 2003 technical corrigendum"
  msgid "Conform to the ISO 1998 C++ standard revised by the 2003 technical corrigendum."
-msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¸Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð² Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ð¸ Ñ\81 ISO 1998 C++ Ñ\81 Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ñ\8fÐ¼Ð¸ GNU"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¸Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð² Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ð¸ Ñ\81 ISO 1998 C++ Ñ\81 Ñ\83Ñ\87ÐµÑ\82Ð¾Ð¼ Ñ\82ÐµÑ\85Ð½Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ñ\85 Ð¿Ð¾Ð¿Ñ\80Ð°Ð²Ð¾Ðº 2003 Ð³Ð¾Ð´Ð°"
  
  #: c-family/c.opt:1676
  #, fuzzy
@@ -8152,13 +8471,15 @@ msgstr "Компилировать в соответствии с ISO 1998 C++"
  
  #: c-family/c.opt:1680
  #, fuzzy
+#| msgid "Deprecated in favor of -std=c++11"
  msgid "Deprecated in favor of -std=c++11."
-msgstr "Не рекомендуется; используйте -std=c99"
+msgstr "Не рекомендуется; используйте -std=c++11"
  
  #: c-family/c.opt:1684
  #, fuzzy
+#| msgid "Deprecated in favor of -std=c++11"
  msgid "Deprecated in favor of -std=c++14."
-msgstr "Не рекомендуется; используйте -std=c99"
+msgstr "Не рекомендуется; используйте -std=c++11"
  
  #: c-family/c.opt:1688
  #, fuzzy
@@ -8168,8 +8489,9 @@ msgstr "Компилировать в соответствии с ISO 1998 C++"
  
  #: c-family/c.opt:1692
  #, fuzzy
+#| msgid "Conform to the ISO 2011 C++ standard (experimental and incomplete support)"
  msgid "Conform to the ISO 2017(?) C++ draft standard (experimental and incomplete support)."
-msgstr "Компилировать в соответствии с ISO 1990 C с дополнениями от 1994"
+msgstr "Компилировать в соответствии со стандартом ISO 2011 C++ (неполная экспериментальная поддержка)"
  
  #: c-family/c.opt:1699 c-family/c.opt:1796
  #, fuzzy
@@ -8179,8 +8501,9 @@ msgstr "Компилировать в соответствии с ISO 1990 C"
  
  #: c-family/c.opt:1703
  #, fuzzy
+#| msgid "Deprecated in favor of -std=c11"
  msgid "Deprecated in favor of -std=c11."
-msgstr "Не рекомендуется; используйте -std=c99"
+msgstr "Не рекомендуется; используйте -std=c11"
  
  #: c-family/c.opt:1707 c-family/c.opt:1711 c-family/c.opt:1780
  #, fuzzy
@@ -8201,9 +8524,8 @@ msgid "Deprecated in favor of -std=c99."
  msgstr "Не рекомендуется; используйте -std=c99"
  
  #: c-family/c.opt:1723 c-family/c.opt:1728
-#, fuzzy
  msgid "Conform to the ISO 1998 C++ standard revised by the 2003 technical"
-msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¸Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð² Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ð¸ Ñ\81 ISO 1998 C++ Ñ\81 Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ñ\8fÐ¼Ð¸ GNU"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¸Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð² Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ð¸ Ñ\81 ISO 1998 C++ Ñ\81 Ñ\83Ñ\87ÐµÑ\82Ð¾Ð¼ Ñ\82ÐµÑ\85Ð½Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ñ\85 Ð¿Ð¾Ð¿Ñ\80Ð°Ð²Ð¾Ðº 2003 Ð³Ð¾Ð´Ð°"
  
  #: c-family/c.opt:1733
  #, fuzzy
@@ -8213,13 +8535,15 @@ msgstr "Компилировать в соответствии с ISO 1990 C с
  
  #: c-family/c.opt:1737
  #, fuzzy
+#| msgid "Deprecated in favor of -std=gnu++11"
  msgid "Deprecated in favor of -std=gnu++11."
-msgstr "Устаревший ключ, теперь следует использовать -std=gnu99"
+msgstr "Устаревший ключ, используйте -std=gnu++11"
  
  #: c-family/c.opt:1741
  #, fuzzy
+#| msgid "Deprecated in favor of -std=gnu++11"
  msgid "Deprecated in favor of -std=gnu++14."
-msgstr "Устаревший ключ, теперь следует использовать -std=gnu99"
+msgstr "Устаревший ключ, используйте -std=gnu++11"
  
  #: c-family/c.opt:1745
  #, fuzzy
@@ -8229,8 +8553,9 @@ msgstr "Компилировать в соответствии с ISO 1990 C с
  
  #: c-family/c.opt:1749
  #, fuzzy
+#| msgid "Conform to the ISO 2011 C++ standard with GNU extensions (experimental and incomplete support)"
  msgid "Conform to the ISO 201z(7?) C++ draft standard with GNU extensions (experimental and incomplete support)."
-msgstr "Компилировать в соответствии с ISO 1998 C++ с расширениями GNU"
+msgstr "Компилировать в соответствии с ISO 2011 C++ с расширениями GNU (неполная экспериментальная поддержка)"
  
  #: c-family/c.opt:1756
  #, fuzzy
@@ -8240,8 +8565,9 @@ msgstr "Компилировать в соответствии с ISO 1990 C с
  
  #: c-family/c.opt:1760
  #, fuzzy
+#| msgid "Deprecated in favor of -std=gnu11"
  msgid "Deprecated in favor of -std=gnu11."
-msgstr "Устаревший ключ, теперь следует использовать -std=gnu99"
+msgstr "Устаревший ключ, используйте -std=gnu11"
  
  #: c-family/c.opt:1764 c-family/c.opt:1768
  #, fuzzy
@@ -8281,8 +8607,9 @@ msgstr "Традиционное препроцессирование"
  
  #: c-family/c.opt:1807
  #, fuzzy
+#| msgid "-trigraphs\tSupport ISO C trigraphs"
  msgid "-trigraphs\tSupport ISO C trigraphs."
-msgstr "Поддержка триграфов, предусмотренных ISO C"
+msgstr "-trigraphs\tПоддержка триграфов, предусмотренных ISO C"
  
  #: c-family/c.opt:1811
  #, fuzzy
@@ -8292,76 +8619,103 @@ msgstr "Не предопределять системные макросы и 
  
  #: ada/gcc-interface/lang.opt:61
  #, fuzzy
+#| msgid "Synonym of -gnatk8"
  msgid "Synonym of -gnatk8."
-msgstr "То же, что -Wcomment"
+msgstr "То же, что -gnatk8"
  
  #: ada/gcc-interface/lang.opt:69
+#, fuzzy
+#| msgid "Do not look for object files in standard path"
  msgid "Do not look for object files in standard path."
-msgstr ""
+msgstr "Не искать объектные файлы по стандартным маршрутам"
  
  #: ada/gcc-interface/lang.opt:73
  #, fuzzy
+#| msgid "Select the runtime"
  msgid "Select the runtime."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81Ñ\80ÐµÐ´Ñ\83 Ð·Ð°Ð¿Ñ\83Ñ\81ÐºÐ° Ñ\81Ð¸Ð¼Ñ\83Ð»Ñ\8fÑ\82Ð¾Ñ\80Ð°"
+msgstr "Ð\92Ñ\8bÐ±Ñ\80Ð°Ñ\82Ñ\8c runtime-Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶ÐºÑ\83"
  
  #: ada/gcc-interface/lang.opt:85
+#, fuzzy
+#| msgid "Catch typos"
  msgid "Catch typos."
-msgstr ""
+msgstr "Ловить опечатки"
  
  #: ada/gcc-interface/lang.opt:89
+#, fuzzy
+#| msgid "Set name of output ALI file (internal switch)"
  msgid "Set name of output ALI file (internal switch)."
-msgstr ""
+msgstr "Задать имя выходного ALI файла (внутренний ключ)"
  
  #: ada/gcc-interface/lang.opt:93
  #, fuzzy
+#| msgid "-gnat<options>\tSpecify options to GNAT"
  msgid "-gnat<options>\tSpecify options to GNAT."
-msgstr "Задать ключи GNAT"
+msgstr "-gnat<options>\tЗадать ключи GNAT"
  
  #: ada/gcc-interface/lang.opt:97
  msgid "Ignored."
  msgstr ""
  
  #: go/lang.opt:42
+#, fuzzy
+#| msgid "Add explicit checks for division by zero"
  msgid "Add explicit checks for division by zero."
-msgstr ""
+msgstr "Включить явные проверки деления на ноль"
  
  #: go/lang.opt:46
+#, fuzzy
+#| msgid "Add explicit checks for division overflow in INT_MIN / -1"
  msgid "Add explicit checks for division overflow in INT_MIN / -1."
-msgstr ""
+msgstr "Включить явные проверки переполнения при делении INT_MIN / -1"
  
  #: go/lang.opt:50
  #, fuzzy
+#| msgid "-fgo-dump-<type>\tDump Go frontend internal information"
  msgid "-fgo-dump-<type>\tDump Go frontend internal information."
-msgstr "Выдать внутреннюю информацию компилятора в файл"
+msgstr "-fgo-dump-<type>\tВыдать дамп внутренней информации компилятора переднего плана Go"
  
  #: go/lang.opt:54
+#, fuzzy
+#| msgid "-fgo-optimize-<type>\tTurn on optimization passes in the frontend"
  msgid "-fgo-optimize-<type>\tTurn on optimization passes in the frontend."
-msgstr ""
+msgstr "-fgo-optimize-<type>\tВключить проходы оптимизации в компиляторе переднего плана"
  
  #: go/lang.opt:58
+#, fuzzy
+#| msgid "-fgo-pkgpath=<string>\tSet Go package path"
  msgid "-fgo-pkgpath=<string>\tSet Go package path."
-msgstr ""
+msgstr "-fgo-pkgpath=<string>\tУказать каталог пакетов Go"
  
  #: go/lang.opt:62
+#, fuzzy
+#| msgid "-fgo-prefix=<string>\tSet package-specific prefix for exported Go names"
  msgid "-fgo-prefix=<string>\tSet package-specific prefix for exported Go names."
-msgstr ""
+msgstr "-fgo-prefix=<string>\tУказать префикс пакетов для экспортируемых имен Go"
  
  #: go/lang.opt:66
+#, fuzzy
+#| msgid "-fgo-relative-import-path=<path> Treat a relative import as relative to path"
  msgid "-fgo-relative-import-path=<path> Treat a relative import as relative to path."
-msgstr ""
+msgstr "-fgo-relative-import-path=<path> Префикс для относительных имен в импорте"
  
  #: go/lang.opt:70
  #, fuzzy
+#| msgid "Functions which return values must end with return statements"
  msgid "Functions which return values must end with return statements."
-msgstr "функция декларированная с атрибутом %<noreturn%> содержит оператор %<return%>"
+msgstr "функция, возвращающая результат, должна заканчиваться выполнением оператора return"
  
  #: config/vms/vms.opt:27
+#, fuzzy
+#| msgid "Malloc data into P2 space"
  msgid "Malloc data into P2 space."
-msgstr ""
+msgstr "Malloc данные в P2 пространство"
  
  #: config/vms/vms.opt:31
+#, fuzzy
+#| msgid "Set name of main routine for the debugger"
  msgid "Set name of main routine for the debugger."
-msgstr ""
+msgstr "Установить имя главной программы для отладчика"
  
  #: config/vms/vms.opt:35
  msgid "Use VMS exit codes instead of posix ones."
@@ -8373,8 +8727,9 @@ msgstr ""
  
  #: config/vms/vms.opt:42
  #, fuzzy, c-format
+#| msgid "unknown TLS model %qs"
  msgid "unknown pointer size model %qs"
-msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¼Ð°Ñ\88Ð¸Ð½Ð½Ñ\8bÐ¹ Ñ\80ÐµÐ¶Ð¸Ð¼ %qs"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¼Ð¾Ð´ÐµÐ»Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ð´Ð° TLS %qs"
  
  #: config/mcore/mcore.opt:23
  msgid "Generate code for the M*Core M210"
@@ -8421,8 +8776,10 @@ msgid "Generate little-endian code."
  msgstr "Генерировать код для обратного порядка байт (little endian)"
  
  #: config/mcore/mcore.opt:56 config/fr30/fr30.opt:27
+#, fuzzy
+#| msgid "Assume that run-time support has been provided, so omit -lsim from the linker command line"
  msgid "Assume that run-time support has been provided, so omit -lsim from the linker command line."
-msgstr ""
+msgstr "Предполагать что предоставляется поддержка времени выполнения, поэтому опустить -lsim в командной строке компоновщика"
  
  #: config/mcore/mcore.opt:60
  #, fuzzy
@@ -8449,9 +8806,8 @@ msgid "Always treat bitfields as int-sized."
  msgstr "Всегда считать, что битовое поле имеет размер int"
  
  #: config/linux-android.opt:23
-#, fuzzy
  msgid "Generate code for the Android platform."
-msgstr "Генерировать код для сборщика мусора Boehm"
+msgstr "Генерировать код для платформы Android"
  
  #: config/mmix/mmix.opt:24
  #, fuzzy
@@ -8556,16 +8912,22 @@ msgid "Set start-address of data."
  msgstr "Стартовый адрес данных"
  
  #: config/darwin.opt:114
+#, fuzzy
+#| msgid "Generate compile-time CFString objects"
  msgid "Generate compile-time CFString objects."
-msgstr ""
+msgstr "Генерировать CFString объекты времени компиляции"
  
  #: config/darwin.opt:211
+#, fuzzy
+#| msgid "Warn if constant CFString objects contain non-portable characters"
  msgid "Warn if constant CFString objects contain non-portable characters."
-msgstr ""
+msgstr "Предупреждать если константный CFString объект содержит непереносимые символы"
  
  #: config/darwin.opt:216
+#, fuzzy
+#| msgid "Generate AT&T-style stubs for Mach-O"
  msgid "Generate AT&T-style stubs for Mach-O."
-msgstr ""
+msgstr "Генерировать суррогаты AT&T стиля для Mach-O"
  
  #: config/darwin.opt:220
  #, fuzzy
@@ -8593,18 +8955,21 @@ msgstr "Установить sizeof(bool) в 1"
  
  #: config/darwin.opt:240
  #, fuzzy
+#| msgid "Generate code for darwin loadable kernel extensions"
  msgid "Generate code for darwin loadable kernel extensions."
-msgstr "Генерировать код для 68040 без новых команд"
+msgstr "Генерировать код для darwin загружаемых расширений ядра"
  
  #: config/darwin.opt:244
  #, fuzzy
+#| msgid "Generate code for the kernel or loadable kernel extensions"
  msgid "Generate code for the kernel or loadable kernel extensions."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð´Ð»Ñ\8f Ñ\83ÐºÐ°Ð·Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80Ð° Ð¸Ð»Ð¸ Ð²ÐµÑ\80Ñ\81Ð¸Ð¸ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾ра"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð´Ð»Ñ\8f Ñ\8fÐ´Ñ\80Ð° Ð¸Ð»Ð¸ Ð·Ð°Ð³Ñ\80Ñ\83Ð¶Ð°ÐµÐ¼Ñ\8bÑ\85 Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ð¹ Ñ\8fÐ´ра"
  
  #: config/darwin.opt:248
  #, fuzzy
+#| msgid "-iframework <dir>\tAdd <dir> to the end of the system framework include path"
  msgid "-iframework <dir>\tAdd <dir> to the end of the system framework include path."
-msgstr "Добавить <каталог> в конец основного пути поиска включаемых инфраструктур"
+msgstr "-iframework <dir>\tДобавить <dir> в конец основного пути поиска включаемых системных инфраструктур"
  
  #: config/bfin/bfin.opt:40 config/msp430/msp430.opt:3 config/c6x/c6x.opt:38
  #: config/mep/mep.opt:143
@@ -8647,7 +9012,7 @@ msgstr "Включить поддержку разделяемых библио
  
  #: config/bfin/bfin.opt:69
  msgid "Generate code that won't be linked against any other ID shared libraries,"
-msgstr ""
+msgstr "Генерировать код который не будет компоноваться с другими ID разделяемыми библиотеками,"
  
  #: config/bfin/bfin.opt:74 config/m68k/m68k.opt:171
  #, fuzzy
@@ -8669,8 +9034,9 @@ msgstr "Избегать генерацию вызовов по смещению
  
  #: config/bfin/bfin.opt:86
  #, fuzzy
+#| msgid "Link with the fast floating-point library"
  msgid "Link with the fast floating-point library."
-msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81 Ð±Ð¸Ð±Ð»Ð¸Ð¾Ñ\82ÐµÐºÐ°Ð¼Ð¸ pic"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81 Ð±Ð¸Ð±Ð»Ð¸Ð¾Ñ\82ÐµÐºÐ¾Ð¹ Ð±Ñ\8bÑ\81Ñ\82Ñ\80Ð¾Ð¹ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
  
  #: config/bfin/bfin.opt:90 config/frv/frv.opt:130
  #, fuzzy
@@ -8685,41 +9051,50 @@ msgid "Enable inlining of PLT in function calls."
  msgstr "Встраивать PLT в вызовы функций"
  
  #: config/bfin/bfin.opt:98
+#, fuzzy
+#| msgid "Do stack checking using bounds in L1 scratch memory"
  msgid "Do stack checking using bounds in L1 scratch memory."
-msgstr ""
+msgstr "Делать проверку стека с использованием границ в L1 scratch памяти"
  
  #: config/bfin/bfin.opt:102
  #, fuzzy
+#| msgid "Enable multicore support"
  msgid "Enable multicore support."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð»Ð¸ Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ñ\83Ñ\80Ñ\83 Ð´Ð»Ñ\8f Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¹ Ñ\81 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶ÐºÑ\83 Ð¼Ð½Ð¾Ð³Ð¾Ñ\8fÐ´ÐµÑ\80Ð½Ð¾Ñ\81Ñ\82Ð¸"
  
  #: config/bfin/bfin.opt:106
+#, fuzzy
+#| msgid "Build for Core A"
  msgid "Build for Core A."
-msgstr ""
+msgstr "Строить для Core A"
  
  #: config/bfin/bfin.opt:110
+#, fuzzy
+#| msgid "Build for Core B"
  msgid "Build for Core B."
-msgstr ""
+msgstr "Строить для Core B"
  
  #: config/bfin/bfin.opt:114
+#, fuzzy
+#| msgid "Build for SDRAM"
  msgid "Build for SDRAM."
-msgstr ""
+msgstr "Строить для SDRAM"
  
  #: config/bfin/bfin.opt:118
  msgid "Assume ICPLBs are enabled at runtime."
-msgstr ""
+msgstr "Предполагать что ICPLBs включены во время выполнения."
  
  #: config/m68k/m68k-tables.opt:25
  msgid "Known M68K CPUs (for use with the -mcpu= option):"
-msgstr ""
+msgstr "Известные M68K CPUs (для использования с опцией -mcpu=):"
  
  #: config/m68k/m68k-tables.opt:365
  msgid "Known M68K microarchitectures (for use with the -mtune= option):"
-msgstr ""
+msgstr "Известные M68K микроархитектуры (для использования с опцией -mtune=):"
  
  #: config/m68k/m68k-tables.opt:411
  msgid "Known M68K ISAs (for use with the -march= option):"
-msgstr ""
+msgstr "Известные M68K ISAs (для использования с опцией -march=):"
  
  #: config/m68k/ieee.opt:24 config/i386/i386.opt:358
  #, fuzzy
@@ -8765,8 +9140,9 @@ msgstr "Генерировать код для 68000"
  
  #: config/m68k/m68k.opt:54
  #, fuzzy
+#| msgid "Generate code for a 68010"
  msgid "Generate code for a 68010."
-msgstr "Генерировать код для 68000"
+msgstr "Генерировать код для 68010"
  
  #: config/m68k/m68k.opt:58 config/m68k/m68k.opt:115
  #, fuzzy
@@ -8849,13 +9225,15 @@ msgstr "Использовать команды работы с битовыми
  
  #: config/m68k/m68k.opt:119
  #, fuzzy
+#| msgid "Generate code for a ColdFire v4e"
  msgid "Generate code for a ColdFire v4e."
-msgstr "Генерировать код для M*Core M340"
+msgstr "Генерировать код для ColdFire v4e"
  
  #: config/m68k/m68k.opt:123
  #, fuzzy
+#| msgid "Specify the target CPU"
  msgid "Specify the target CPU."
-msgstr "Ð\98Ð¼Ñ\8f Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð³Ð¾ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80"
+msgstr "Ð\97Ð°Ð´Ð°Ñ\82Ñ\8c Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð¹ CPU"
  
  #: config/m68k/m68k.opt:127
  #, fuzzy
@@ -8865,18 +9243,21 @@ msgstr "Генерировать код для cpu32"
  
  #: config/m68k/m68k.opt:131
  #, fuzzy
+#| msgid "Use hardware division instructions on ColdFire"
  msgid "Use hardware division instructions on ColdFire."
-msgstr "Использовать аппаратные средства quad-плавающей арифметики"
+msgstr "Использовать аппаратные инструкции деления в ColdFire"
  
  #: config/m68k/m68k.opt:135
  #, fuzzy
+#| msgid "Generate code for a Fido A"
  msgid "Generate code for a Fido A."
-msgstr "Генерировать код для DLL"
+msgstr "Генерировать код для Fido A"
  
  #: config/m68k/m68k.opt:139
  #, fuzzy
+#| msgid "Generate code which uses hardware floating point instructions"
  msgid "Generate code which uses hardware floating point instructions."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ñ\81 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸ÐµÐ¼ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ñ\85 Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ 68881"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ñ\81 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸ÐµÐ¼ Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÑ\85 Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð²ÐµÑ\89ÐµÑ\81Ñ\82Ð²ÐµÐ½Ð½Ð¾Ð¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
  
  #: config/m68k/m68k.opt:143
  #, fuzzy
@@ -8934,55 +9315,65 @@ msgstr "Не использовать невыровненные ссылки н
  
  #: config/m68k/m68k.opt:187
  #, fuzzy
+#| msgid "Tune for the specified target CPU or architecture"
  msgid "Tune for the specified target CPU or architecture."
-msgstr "Ð\98Ð¼Ñ\8f Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð¹ архитектуры"
+msgstr "Ð\9dÐ°Ñ\81Ñ\82Ñ\80Ð¾Ð¸Ñ\82Ñ\8c Ð´Ð»Ñ\8f Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð³Ð¾ CPU Ð¸Ð»Ð¸ архитектуры"
  
  #: config/m68k/m68k.opt:191
+#, fuzzy
+#| msgid "Support more than 8192 GOT entries on ColdFire"
  msgid "Support more than 8192 GOT entries on ColdFire."
-msgstr ""
+msgstr "Поддерживать более чем 8192 GOT входов на ColdFire"
  
  #: config/m68k/m68k.opt:195
+#, fuzzy
+#| msgid "Support TLS segment larger than 64K"
  msgid "Support TLS segment larger than 64K."
-msgstr ""
+msgstr "Поддерживать TLS сегмент больше чем 64K"
  
  #: config/m32c/m32c.opt:23
  #, fuzzy
+#| msgid "-msim\tUse simulator runtime"
  msgid "-msim\tUse simulator runtime."
-msgstr "Использовать среду запуска симулятора"
+msgstr "-msim\tИспользовать симулятор runtime"
  
  #: config/m32c/m32c.opt:27
  #, fuzzy
+#| msgid "-mcpu=r8c\tCompile code for R8C variants"
  msgid "-mcpu=r8c\tCompile code for R8C variants."
-msgstr "Генерировать код для вариантов R8C"
+msgstr "-mcpu=r8c\tКомпилировать код для R8C вариантов"
  
  #: config/m32c/m32c.opt:31
  #, fuzzy
+#| msgid "-mcpu=m16c\tCompile code for M16C variants"
  msgid "-mcpu=m16c\tCompile code for M16C variants."
-msgstr "Генерировать код для вариантов M16C"
+msgstr "-mcpu=m16c\tКомпилировать код для M16C вариантов"
  
  #: config/m32c/m32c.opt:35
  #, fuzzy
+#| msgid "-mcpu=m32cm\tCompile code for M32CM variants"
  msgid "-mcpu=m32cm\tCompile code for M32CM variants."
-msgstr "Генерировать код для вариантов M32CM"
+msgstr "-mcpu=m32c\tКомпилировать код для M32CM вариантов"
  
  #: config/m32c/m32c.opt:39
  #, fuzzy
+#| msgid "-mcpu=m32c\tCompile code for M32C variants"
  msgid "-mcpu=m32c\tCompile code for M32C variants."
-msgstr "Генерировать код для вариантов M32C"
+msgstr "-mcpu=m32c\tКомпилировать код для M32C вариантов"
  
  #: config/m32c/m32c.opt:43
  #, fuzzy
+#| msgid "-memregs=\tNumber of memreg bytes (default: 16, range: 0..16)"
  msgid "-memregs=\tNumber of memreg bytes (default: 16, range: 0..16)."
-msgstr "Число байтов в псевдорегистрах на памяти (по умолчанию: 16, возможные значения: 0..16)"
+msgstr "-memregs=\tЧисло memreg байт (по умолчанию: 16, диапазон: 0..16)"
  
  #: config/msp430/msp430.opt:7
  msgid "Force assembly output to always use hex constants."
  msgstr ""
  
  #: config/msp430/msp430.opt:11
-#, fuzzy
  msgid "Specify the MCU to build for."
-msgstr "Имя целевого процессор"
+msgstr ""
  
  #: config/msp430/msp430.opt:15
  msgid "Warn if an MCU name is unrecognised or conflicts with other options (default: on)."
@@ -9009,12 +9400,16 @@ msgid "Use a minimum runtime (no static initializers or ctors) for memory-constr
  msgstr ""
  
  #: config/msp430/msp430.opt:45
+#, fuzzy
+#| msgid "Select hardware or software multiplication support."
  msgid "Specify the type of hardware multiply to support."
-msgstr ""
+msgstr "Выбрать аппаратную или программную поддержку умножения."
  
  #: config/msp430/msp430.opt:67
+#, fuzzy
+#| msgid "Specifies whether interrupt functions should save and restore the accumulator register."
  msgid "Specify whether functions should be placed into low or high memory."
-msgstr ""
+msgstr "Специфицирует должны ли функции прерываний сохранять и восстанавливать регистр сумматора."
  
  #: config/msp430/msp430.opt:71
  msgid "Specify whether variables should be placed into low or high memory."
@@ -9045,8 +9440,9 @@ msgstr "Считать что процессор имеет прямой пор
  
  #: config/aarch64/aarch64.opt:69
  #, fuzzy
+#| msgid "Generate code which uses hardware floating point instructions"
  msgid "Generate code which uses only the general registers."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ñ\81 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸ÐµÐ¼ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ñ\85 Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ 68881"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ñ\81 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸ÐµÐ¼ Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÑ\85 Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð²ÐµÑ\89ÐµÑ\81Ñ\82Ð²ÐµÐ½Ð½Ð¾Ð¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
  
  #: config/aarch64/aarch64.opt:73
  msgid "Workaround for ARM Cortex-A53 Erratum number 835769."
@@ -9065,8 +9461,9 @@ msgstr "Считать что процессор имеет обратный п
  
  #: config/aarch64/aarch64.opt:85
  #, fuzzy
+#| msgid "Select code model"
  msgid "Specify the code model."
-msgstr "Ð\98Ð¼Ñ\8f Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð³Ð¾ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80"
+msgstr "Ð\92Ñ\8bÐ±Ñ\80Ð°Ñ\82Ñ\8c Ð¼Ð¾Ð´ÐµÐ»Ñ\8c ÐºÐ¾Ð´Ð°"
  
  #: config/aarch64/aarch64.opt:89
  msgid "Don't assume that unaligned accesses are handled by the system."
@@ -9090,23 +9487,25 @@ msgstr "Битовый размер смещений для непосредст
  
  #: config/aarch64/aarch64.opt:120
  #, fuzzy
+#| msgid "-mcpu=CPU\tUse features of and schedule code for given CPU"
  msgid "-march=ARCH\tUse features of architecture ARCH."
-msgstr "Использовать свойства указанного процессора и планировать код для него"
+msgstr "-mcpu=CPU\tИспользовать возможности и планировать код для заданного CPU"
  
  #: config/aarch64/aarch64.opt:124
  #, fuzzy
+#| msgid "-mcpu=CPU\tUse features of and schedule code for given CPU"
  msgid "-mcpu=CPU\tUse features of and optimize for CPU."
-msgstr "Использовать свойства указанного процессора и планировать код для него"
+msgstr "-mcpu=CPU\tИспользовать возможности и планировать код для заданного CPU"
  
  #: config/aarch64/aarch64.opt:128
-#, fuzzy
  msgid "-mtune=CPU\tOptimize for CPU."
-msgstr "Использовать свойства указанного процессора и планировать код для него"
+msgstr ""
  
  #: config/aarch64/aarch64.opt:132
  #, fuzzy
+#| msgid "-mabi=ABI\tGenerate code that conforms to the given ABI"
  msgid "-mabi=ABI\tGenerate code that conforms to the specified ABI."
-msgstr "Генерировать код в соответствии с заданным ABI"
+msgstr "-mabi=ABI\tГенерировать код в соответствии с заданным ABI"
  
  #: config/aarch64/aarch64.opt:136
  msgid "-moverride=STRING\tPower users only! Override CPU optimization parameters."
@@ -9114,8 +9513,9 @@ msgstr ""
  
  #: config/aarch64/aarch64.opt:140
  #, fuzzy
+#| msgid "Known ARM ABIs (for use with the -mabi= option):"
  msgid "Known AArch64 ABIs (for use with the -mabi= option):"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸: -mfpu=%s"
+msgstr "Ð\98Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐµ ARM ABIs (Ð´Ð»Ñ\8f Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ñ\81 -mabi= Ð¾Ð¿Ñ\86Ð¸ÐµÐ¹):"
  
  #: config/aarch64/aarch64.opt:150
  msgid "PC relative literal loads."
@@ -9127,23 +9527,27 @@ msgstr ""
  
  #: config/linux.opt:24
  #, fuzzy
+#| msgid "Use Bionic C library"
  msgid "Use Bionic C library."
-msgstr "Использовать ROM вместо RAM"
+msgstr "Использовать Bionic C библиотеку"
  
  #: config/linux.opt:28
  #, fuzzy
+#| msgid "Use GNU C library"
  msgid "Use GNU C library."
-msgstr "Использовать ROM вместо RAM"
+msgstr "Использовать GNU C библиотеку"
  
  #: config/linux.opt:32
  #, fuzzy
+#| msgid "Use uClibc C library"
  msgid "Use uClibc C library."
-msgstr "Использовать ROM вместо RAM"
+msgstr "Использовать uClibc C библиотеку"
  
  #: config/linux.opt:36
  #, fuzzy
+#| msgid "Use uClibc C library"
  msgid "Use musl C library."
-msgstr "Использовать ROM вместо RAM"
+msgstr "Использовать uClibc C библиотеку"
  
  #: config/ia64/ilp32.opt:3
  #, fuzzy
@@ -9301,133 +9705,169 @@ msgstr "Планировать код для указанного процесс
  
  #: config/ia64/ia64.opt:126
  msgid "Known Itanium CPUs (for use with the -mtune= option):"
-msgstr ""
+msgstr "Известные Itanium CPUs (для использования с опцией -mtune=):"
  
  #: config/ia64/ia64.opt:136
  #, fuzzy
+#| msgid "Use data speculation before reload"
  msgid "Use data speculation before reload."
-msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð±Ð¾Ð»ÐµÐµ Ð°ÐºÑ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÐºÑ\83Ð»Ñ\8fÑ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ð¿ÐµÑ\80ÐµÐ½Ð¾Ñ\81 ÐºÐ¾Ð¼Ð°Ð½Ð´ Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80ÐµÐ´Ð²Ñ\8bÐ±Ð¾Ñ\80ÐºÑ\83 Ð´Ð°Ð½Ð½Ñ\8bÑ\85 Ð¿ÐµÑ\80ÐµÐ´ Ð¿ÐµÑ\80ÐµÐ·Ð°Ð³Ñ\80Ñ\83Ð·ÐºÐ¾Ð¹"
  
  #: config/ia64/ia64.opt:140
  #, fuzzy
+#| msgid "Use data speculation after reload"
  msgid "Use data speculation after reload."
-msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð±Ð¾Ð»ÐµÐµ Ð°ÐºÑ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÐºÑ\83Ð»Ñ\8fÑ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ð¿ÐµÑ\80ÐµÐ½Ð¾Ñ\81 ÐºÐ¾Ð¼Ð°Ð½Ð´ Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80ÐµÐ´Ð²Ñ\8bÐ±Ð¾Ñ\80ÐºÑ\83 Ð´Ð°Ð½Ð½Ñ\8bÑ\85 Ð¿Ð¾Ñ\81Ð»Ðµ Ð¿ÐµÑ\80ÐµÐ·Ð°Ð³Ñ\80Ñ\83Ð·ÐºÐ¸"
  
  #: config/ia64/ia64.opt:144
  #, fuzzy
+#| msgid "Use control speculation"
  msgid "Use control speculation."
-msgstr "Ð¡Ð¾Ð·Ð´Ð°Ñ\82Ñ\8c ÐºÐ¾Ð½Ñ\81Ð¾Ð»Ñ\8cÐ½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð»Ð¾Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80ÐµÐ´Ð²Ñ\8bÐ±Ð¾Ñ\80ÐºÑ\83 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f"
  
  #: config/ia64/ia64.opt:148
  #, fuzzy
+#| msgid "Use in block data speculation before reload"
  msgid "Use in block data speculation before reload."
-msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð±Ð¾Ð»ÐµÐµ Ð°ÐºÑ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÐºÑ\83Ð»Ñ\8fÑ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ð¿ÐµÑ\80ÐµÐ½Ð¾Ñ\81 ÐºÐ¾Ð¼Ð°Ð½Ð´ Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð² Ð±Ð»Ð¾Ñ\87Ð½Ð¾Ð¹ Ð¿Ñ\80ÐµÐ´Ð²Ñ\8bÐ±Ð¾Ñ\80ÐºÐµ Ð´Ð°Ð½Ð½Ñ\8bÑ\85 Ð¿ÐµÑ\80ÐµÐ´ Ð¿ÐµÑ\80ÐµÐ·Ð°Ð³Ñ\80Ñ\83Ð·ÐºÐ¾Ð¹"
  
  #: config/ia64/ia64.opt:152
  #, fuzzy
+#| msgid "Use in block data speculation after reload"
  msgid "Use in block data speculation after reload."
-msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð±Ð¾Ð»ÐµÐµ Ð°ÐºÑ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÐºÑ\83Ð»Ñ\8fÑ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ð¿ÐµÑ\80ÐµÐ½Ð¾Ñ\81 ÐºÐ¾Ð¼Ð°Ð½Ð´ Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð² Ð±Ð»Ð¾Ñ\87Ð½Ð¾Ð¹ Ð¿Ñ\80ÐµÐ´Ð²Ñ\8bÐ±Ð¾Ñ\80ÐºÐµ Ð´Ð°Ð½Ð½Ñ\8bÑ\85 Ð¿Ð¾Ñ\81Ð»Ðµ Ð¿ÐµÑ\80ÐµÐ·Ð°Ð³Ñ\80Ñ\83Ð·ÐºÐ¸"
  
  #: config/ia64/ia64.opt:156
  #, fuzzy
+#| msgid "Use in block control speculation"
  msgid "Use in block control speculation."
-msgstr "Ð¡Ð¾Ð·Ð´Ð°Ñ\82Ñ\8c ÐºÐ¾Ð½Ñ\81Ð¾Ð»Ñ\8cÐ½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð»Ð¾Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð² Ð±Ð»Ð¾Ñ\87Ð½Ð¾Ð¹ Ð¿Ñ\80ÐµÐ´Ð²Ñ\8bÐ±Ð¾Ñ\80ÐºÐµ Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f"
  
  #: config/ia64/ia64.opt:160
  #, fuzzy
+#| msgid "Use simple data speculation check"
  msgid "Use simple data speculation check."
-msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð±Ð¾Ð»ÐµÐµ Ð°ÐºÑ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÐºÑ\83Ð»Ñ\8fÑ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ð¿ÐµÑ\80ÐµÐ½Ð¾Ñ\81 ÐºÐ¾Ð¼Ð°Ð½Ð´ Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\83Ñ\8e Ð¿Ñ\80Ð¾Ð²ÐµÑ\80ÐºÑ\83 Ð¿Ñ\80ÐµÐ´Ð²Ñ\8bÐ±Ð¾Ñ\80ÐºÐ¸ Ð´Ð°Ð½Ð½Ñ\8bÑ\85"
  
  #: config/ia64/ia64.opt:164
  #, fuzzy
+#| msgid "Use simple data speculation check for control speculation"
  msgid "Use simple data speculation check for control speculation."
-msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð±Ð¾Ð»ÐµÐµ Ð°ÐºÑ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÐºÑ\83Ð»Ñ\8fÑ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ð¿ÐµÑ\80ÐµÐ½Ð¾Ñ\81 ÐºÐ¾Ð¼Ð°Ð½Ð´ Ñ\87Ñ\82ения"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\83Ñ\8e Ð¿Ñ\80Ð¾Ð²ÐµÑ\80ÐºÑ\83 Ð¿Ñ\80ÐµÐ´Ð²Ñ\8bÐ±Ð¾Ñ\80ÐºÐ¸ Ð´Ð°Ð½Ð½Ñ\8bÑ\85 Ð´Ð»Ñ\8f Ð¿Ñ\80ÐµÐ´Ð²Ñ\8bÐ±Ð¾Ñ\80ÐºÐ¸ Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ения"
  
  #: config/ia64/ia64.opt:174
+#, fuzzy
+#| msgid "Count speculative dependencies while calculating priority of instructions"
  msgid "Count speculative dependencies while calculating priority of instructions."
-msgstr ""
+msgstr "Учесть зависимости предвыборки при вычислении приоритета инструкций"
  
  #: config/ia64/ia64.opt:178
  #, fuzzy
+#| msgid "Place a stop bit after every cycle when scheduling"
  msgid "Place a stop bit after every cycle when scheduling."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ñ\80Ð°Ð½Ð½ÐµÐµ Ñ\80Ð°Ð·Ð¼ÐµÑ\89ÐµÐ½Ð¸Ðµ stop-Ð±Ð¸Ñ\82Ð¾Ð² Ð´Ð»Ñ\8f Ñ\83Ð»Ñ\83Ñ\87Ñ\88ÐµÐ½Ð¸Ñ\8f Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f"
+msgstr "Ð\9fÐ¾Ð¼ÐµÑ\81Ñ\82Ð¸Ñ\82Ñ\8c stop Ð±Ð¸Ñ\82 Ð¿Ð¾Ñ\81Ð»Ðµ ÐºÐ°Ð¶Ð´Ð¾Ð³Ð¾ Ñ\86Ð¸ÐºÐ»Ð° Ð¿Ñ\80Ð¸ Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ð¸"
  
  #: config/ia64/ia64.opt:182
+#, fuzzy
+#| msgid "Assume that floating-point stores and loads are not likely to cause conflict when placed into one instruction group"
  msgid "Assume that floating-point stores and loads are not likely to cause conflict when placed into one instruction group."
-msgstr ""
+msgstr "Предполагается что плавающие запись и чтение едва ли вызовут конфликт если помещены в одну группу инструкций"
  
  #: config/ia64/ia64.opt:186
+#, fuzzy
+#| msgid "Soft limit on number of memory insns per instruction group, giving lower priority to subsequent memory insns attempting to schedule in the same insn group. Frequently useful to prevent cache bank conflicts.  Default value is 1"
  msgid "Soft limit on number of memory insns per instruction group, giving lower priority to subsequent memory insns attempting to schedule in the same insn group. Frequently useful to prevent cache bank conflicts.  Default value is 1."
-msgstr ""
+msgstr "Мягкий лимит на число инструкций памяти на группу инструкций, давая более низкий приоритет последующим инструкциям памяти для планирования в той же группе. Часто полезно для предотвращения конфликтов банков кэша. Подразумеваемое значение есть 1"
  
  #: config/ia64/ia64.opt:190
+#, fuzzy
+#| msgid "Disallow more than 'msched-max-memory-insns' in instruction group. Otherwise, limit is 'soft' (prefer non-memory operations when limit is reached)"
  msgid "Disallow more than 'msched-max-memory-insns' in instruction group. Otherwise, limit is 'soft' (prefer non-memory operations when limit is reached)."
-msgstr ""
+msgstr "Запрет более чем 'msched-max-memory-insns' в группе инструкций. В противном случае лимит является 'мягким' (предпочитаются операции не с памятью когда лимит достигается)"
  
  #: config/ia64/ia64.opt:194
+#, fuzzy
+#| msgid "Don't generate checks for control speculation in selective scheduling"
  msgid "Don't generate checks for control speculation in selective scheduling."
-msgstr ""
+msgstr "Не генерировать проверки для предвыборки управления в выборочном планировании"
  
  #: config/spu/spu.opt:20
  #, fuzzy
+#| msgid "Emit warnings when run-time relocations are generated"
  msgid "Emit warnings when run-time relocations are generated."
-msgstr "Ð½ÐµÑ\82 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81Ð° Ð´Ð»Ñ\8f %qs"
+msgstr "Ð\92Ñ\8bÐ´Ð°Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ Ð½Ð°Ñ\81Ñ\82Ñ\80Ð¾ÐµÐº Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð¸ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8f"
  
  #: config/spu/spu.opt:24
+#, fuzzy
+#| msgid "Emit errors when run-time relocations are generated"
  msgid "Emit errors when run-time relocations are generated."
-msgstr ""
+msgstr "Выдавать ошибки при генерации настроек времени выполнения"
  
  #: config/spu/spu.opt:28
  #, fuzzy
+#| msgid "Specify cost of branches (Default 20)"
  msgid "Specify cost of branches (Default 20)."
-msgstr "Установить цену переходов"
+msgstr "Установить цену переходов (По умолчанию 20)"
  
  #: config/spu/spu.opt:32
  #, fuzzy
+#| msgid "Make sure loads and stores are not moved past DMA instructions"
  msgid "Make sure loads and stores are not moved past DMA instructions."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f/Ð·Ð°Ð¿Ð¸Ñ\81Ð¸ Ñ\81 Ð¸Ð·Ð¼ÐµÐ½ÐµÐ½Ð¸ÐµÐ¼ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ð³Ð¾ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð°"
+msgstr "Ð\9eÐ±ÐµÑ\81Ð¿ÐµÑ\87Ð¸Ñ\82Ñ\8c Ñ\87Ñ\82Ð¾Ð±Ñ\8b Ð·Ð°Ð³Ñ\80Ñ\83Ð·ÐºÐ¸ Ð¸ Ñ\81Ð¾Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f Ð½Ðµ Ð±Ñ\8bÐ»Ð¸ Ð¿ÐµÑ\80ÐµÐ¼ÐµÑ\89ÐµÐ½Ñ\8b Ð¿Ð¾Ñ\81Ð»Ðµ DMA Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹"
  
  #: config/spu/spu.opt:36
+#, fuzzy
+#| msgid "volatile must be specified on any memory that is effected by DMA"
  msgid "volatile must be specified on any memory that is effected by DMA."
-msgstr ""
+msgstr "volatile должно быть задано на любую память, затрагиваемую DMA"
  
  #: config/spu/spu.opt:40 config/spu/spu.opt:44
+#, fuzzy
+#| msgid "Insert nops when it might improve performance by allowing dual issue (default)"
  msgid "Insert nops when it might improve performance by allowing dual issue (default)."
-msgstr ""
+msgstr "Вставлять nops когда это может повысить производительность путем разрешения двойного запуска (по умолчанию)"
  
  #: config/spu/spu.opt:48
  #, fuzzy
+#| msgid "Use standard main function as entry for startup"
  msgid "Use standard main function as entry for startup."
-msgstr "Использовать jsr и rts для вызовов функций и возвратов"
+msgstr "Использовать стандартную главную функцию как вход для startup"
  
  #: config/spu/spu.opt:52
  #, fuzzy
+#| msgid "Generate branch hints for branches"
  msgid "Generate branch hints for branches."
-msgstr "Генерировать строковые команды для блочных пересылок"
+msgstr "Генерировать подсказки для ветвлений"
  
  #: config/spu/spu.opt:56
  #, fuzzy
+#| msgid "Maximum number of nops to insert for a hint (Default 2)"
  msgid "Maximum number of nops to insert for a hint (Default 2)."
-msgstr "Максимальный коэффициент развертки цикла"
+msgstr "Максимальное число nops при вставке для подсказки (По умолчанию 2)"
  
  #: config/spu/spu.opt:60
  #, fuzzy
+#| msgid "Approximate maximum number of instructions to allow between a hint and its branch [125]"
  msgid "Approximate maximum number of instructions to allow between a hint and its branch [125]."
-msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð² Ñ\80Ð°Ð·Ð²ÐµÑ\80Ð½Ñ\83Ñ\82Ð¾Ð¼ Ñ\86Ð¸ÐºÐ»Ðµ"
+msgstr "Ð\9fÑ\80Ð¸Ð¼ÐµÑ\80Ð½Ð¾Ðµ Ð¼Ð°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8bÑ\85 Ð¼ÐµÐ¶Ð´Ñ\83 Ð¿Ð¾Ð´Ñ\81ÐºÐ°Ð·ÐºÐ¾Ð¹ Ð¸ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\89Ð¸Ð¼ Ð²ÐµÑ\82Ð²Ð»ÐµÐ½Ð¸ÐµÐ¼ [125]"
  
  #: config/spu/spu.opt:64
  #, fuzzy
+#| msgid "Generate code for 18 bit addressing"
  msgid "Generate code for 18 bit addressing."
-msgstr "Генерировать код для прямого (big endian) порядка байт"
+msgstr "Генерировать код для 18-битной адресации"
  
  #: config/spu/spu.opt:68
  #, fuzzy
+#| msgid "Generate code for 32 bit addressing"
  msgid "Generate code for 32 bit addressing."
-msgstr "Генерировать код для прямого (big endian) порядка байт"
+msgstr "Генерировать код для 32-битной адресации"
  
  #: config/spu/spu.opt:76
+#, fuzzy
+#| msgid "Insert hbrp instructions after hinted branch targets to avoid the SPU hang issue"
  msgid "Insert hbrp instructions after hinted branch targets to avoid the SPU hang issue."
-msgstr ""
+msgstr "Вставлять hbrp инструкции после подсказанных целей ветвлений чтобы избежать SPU hang запуска"
  
  #: config/spu/spu.opt:80 config/i386/i386.opt:247 config/s390/s390.opt:56
  #, fuzzy
@@ -9436,108 +9876,128 @@ msgid "Generate code for given CPU."
  msgstr "Генерировать код для указанного процессора"
  
  #: config/spu/spu.opt:88
+#, fuzzy
+#| msgid "Access variables in 32-bit PPU objects (default)"
  msgid "Access variables in 32-bit PPU objects (default)."
-msgstr ""
+msgstr "Обращаться к переменным в 32-битных PPU объектах (по умолчанию)"
  
  #: config/spu/spu.opt:92
+#, fuzzy
+#| msgid "Access variables in 64-bit PPU objects"
  msgid "Access variables in 64-bit PPU objects."
-msgstr ""
+msgstr "Обращаться к переменным в 64-битных PPU объектах"
  
  #: config/spu/spu.opt:96
+#, fuzzy
+#| msgid "Allow conversions between __ea and generic pointers (default)"
  msgid "Allow conversions between __ea and generic pointers (default)."
-msgstr ""
+msgstr "Разрешить преобразования между __ea и generic указателями (по умолчанию)"
  
  #: config/spu/spu.opt:100
+#, fuzzy
+#| msgid "Size (in KB) of software data cache"
  msgid "Size (in KB) of software data cache."
-msgstr ""
+msgstr "Размер (в KB) программного кэша данных"
  
  #: config/spu/spu.opt:104
+#, fuzzy
+#| msgid "Atomically write back software data cache lines (default)"
  msgid "Atomically write back software data cache lines (default)."
-msgstr ""
+msgstr "Автоматически write back строки программного кэша данных (по умолчанию)"
  
  #: config/epiphany/epiphany.opt:24
  msgid "Don't use any of r32..r63."
-msgstr ""
+msgstr "Не использовать r32..r63."
  
  #: config/epiphany/epiphany.opt:28
  msgid "preferentially allocate registers that allow short instruction generation."
-msgstr ""
+msgstr "Предпочтительно выделять регистры которые допускают генерацию коротких инструкций."
  
  #: config/epiphany/epiphany.opt:32
  #, fuzzy
+#| msgid "Set branch cost"
  msgid "Set branch cost."
-msgstr "Ð\9fÐµÑ\80ÐµÑ\85Ð¾Ð´Ð¾Ð² Ð½ÐµÑ\82\n"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\86ÐµÐ½Ñ\83 Ð²ÐµÑ\82Ð²Ð»ÐµÐ½Ð¸Ð¹"
  
  #: config/epiphany/epiphany.opt:36
-#, fuzzy
  msgid "enable conditional move instruction usage."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð²ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð³Ð¾ Ð¿ÐµÑ\80ÐµÐ¼ÐµÑ\89ÐµÐ½Ð¸Ñ\8f."
  
  #: config/epiphany/epiphany.opt:40
  #, fuzzy
+#| msgid "set number of nops to emit before each insn pattern"
  msgid "set number of nops to emit before each insn pattern."
-msgstr "Максимальный коэффициент развертки цикла"
+msgstr "установить максимальное число nops для выдачи перед каждым шаблоном инструкций"
  
  #: config/epiphany/epiphany.opt:52
  #, fuzzy
+#| msgid "Use software floating point comparisons"
  msgid "Use software floating point comparisons."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ð½Ñ\83Ñ\8e Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ð½Ñ\8bÐµ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8f Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ñ\85"
  
  #: config/epiphany/epiphany.opt:56
+#, fuzzy
+#| msgid "Enable split of 32 bit immediate loads into low / high part"
  msgid "Enable split of 32 bit immediate loads into low / high part."
-msgstr ""
+msgstr "Включить расщепление загрузок 32-битных непосредственных на low / high части"
  
  #: config/epiphany/epiphany.opt:60
+#, fuzzy
+#| msgid "Enable use of POST_INC / POST_DEC"
  msgid "Enable use of POST_INC / POST_DEC."
-msgstr ""
+msgstr "Включить использование POST_INC / POST_DEC"
  
  #: config/epiphany/epiphany.opt:64
+#, fuzzy
+#| msgid "Enable use of POST_MODIFY"
  msgid "Enable use of POST_MODIFY."
-msgstr ""
+msgstr "Включить использование POST_MODIFY"
  
  #: config/epiphany/epiphany.opt:68
  msgid "Set number of bytes on the stack preallocated for use by the callee."
-msgstr ""
+msgstr "Установить число байт в стеке заранее выделяемых для использования вызываемой стороной."
  
  #: config/epiphany/epiphany.opt:72
  msgid "Assume round to nearest is selected for purposes of scheduling."
-msgstr ""
+msgstr "Предполагать что выбрано округление до ближайшего для целей планирования."
  
  #: config/epiphany/epiphany.opt:76
  #, fuzzy
+#| msgid "Generate call insns as indirect calls"
  msgid "Generate call insns as indirect calls."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ñ\8bÐµ Ð²Ñ\8bÐ·Ð¾Ð²Ñ\8b, ÐµÑ\81Ð»Ð¸ Ð½Ñ\83Ð¶Ð½Ð¾"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð²Ñ\8bÐ·Ð¾Ð²Ð° ÐºÐ°Ðº ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ñ\8bÐµ Ð²Ñ\8bÐ·Ð¾Ð²Ñ\8b"
  
  #: config/epiphany/epiphany.opt:80
  #, fuzzy
+#| msgid "Generate call insns as direct calls"
  msgid "Generate call insns as direct calls."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ñ\8bÐµ Ð²Ñ\8bÐ·Ð¾Ð²Ñ\8b, ÐµÑ\81Ð»Ð¸ Ð½Ñ\83Ð¶Ð½Ð¾"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð²Ñ\8bÐ·Ð¾Ð²Ð° ÐºÐ°Ðº Ð¿Ñ\80Ñ\8fÐ¼Ñ\8bÐµ Ð²Ñ\8bÐ·Ð¾Ð²Ñ\8b"
  
  #: config/epiphany/epiphany.opt:84
  msgid "Assume labels and symbols can be addressed using 16 bit absolute addresses."
-msgstr ""
+msgstr "Предполагать что метки и символы могут адресоваться с использованием 16-битных абсолютных адресов."
  
  #: config/epiphany/epiphany.opt:108
  msgid "A floatig point to integer truncation may be replaced with rounding to save mode switching."
  msgstr ""
  
  #: config/epiphany/epiphany.opt:112
-#, fuzzy
  msgid "Vectorize for double-word operations."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð±Ð¾Ð»ÐµÐµ Ñ\81Ñ\82Ñ\80Ð¾Ð³Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ñ\83Ñ\80 Ð´Ð»Ñ\8f ÐºÐ¾Ð¿Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð´Ð²Ð¾Ð¹Ð½Ñ\8bÐ¼Ð¸ Ñ\81Ð»Ð¾Ð²Ð°Ð¼Ð¸"
+msgstr "Ð\92ÐµÐºÑ\82Ð¾Ñ\80Ð¸Ð·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð´Ð²Ñ\83Ñ\85Ñ\81Ð»Ð¾Ð²Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸."
  
  #: config/epiphany/epiphany.opt:128
  msgid "Split unaligned 8 byte vector moves before post-modify address generation."
-msgstr ""
+msgstr "Расщеплять невыровненные 8-байтные пересылки векторов перед генерацией post-modify адресов."
  
  #: config/epiphany/epiphany.opt:132
  #, fuzzy
+#| msgid "Use hardware floating point conversion instructions"
  msgid "Use the floating point unit for integer add/subtract."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° paired-single (Ð½Ð°Ð´ Ð¿Ð°Ñ\80Ð°Ð¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸)"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ñ\87Ð¸Ñ\81ÐµÐ» Ñ\81 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹"
  
  #: config/epiphany/epiphany.opt:136
  msgid "Set register to hold -1."
-msgstr ""
+msgstr "Установить регистр чтобы содержать -1."
  
  #: config/ft32/ft32.opt:23
  msgid "target the software simulator."
@@ -9552,8 +10012,9 @@ msgstr "Использовать ROM вместо RAM"
  
  #: config/ft32/ft32.opt:31
  #, fuzzy
+#| msgid "Allow the use of MDMX instructions"
  msgid "Avoid use of the DIV and MOD instructions"
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 DB"
+msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ ÐºÐ¾Ð¼Ð°Ð½Ð´ MDMX"
  
  #: config/h8300/h8300.opt:23
  #, fuzzy
@@ -9734,8 +10195,9 @@ msgstr "Использовать команды CONST16 для загрузки
  
  #: config/xtensa/xtensa.opt:27
  #, fuzzy
+#| msgid "Disable position-independent code (PIC) for use in OS kernel code"
  msgid "Disable position-independent code (PIC) for use in OS kernel code."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾-Ð½ÐµÐ·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ñ\8bÐ¹ ÐºÐ¾Ð´, ÐµÑ\81Ð»Ð¸ Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ (Ñ\80ÐµÐ¶Ð¸Ð¼ large)"
+msgstr "Ð\92Ñ\8bÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾-Ð½ÐµÐ·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ñ\8bÐ¹ ÐºÐ¾Ð´ (PIC) Ð´Ð»Ñ\8f Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð² ÐºÐ¾Ð´Ðµ Ñ\8fÐ´Ñ\80Ð° OS"
  
  #: config/xtensa/xtensa.opt:31
  #, fuzzy
@@ -9760,8 +10222,10 @@ msgid "Relax literals in assembler and place them automatically in the text sect
  msgstr ""
  
  #: config/xtensa/xtensa.opt:47
+#, fuzzy
+#| msgid "-mno-serialize-volatile\tDo not serialize volatile memory references with MEMW instructions"
  msgid "-mno-serialize-volatile\tDo not serialize volatile memory references with MEMW instructions."
-msgstr ""
+msgstr "-mno-serialize-volatile\tНе упорядочивать обращения к volatile памяти с MEMW инструкциями"
  
  #: config/i386/cygming.opt:23
  #, fuzzy
@@ -9800,28 +10264,36 @@ msgid "Create GUI application."
  msgstr "Создать приложение с интерактивным графическим интерфейсом"
  
  #: config/i386/cygming.opt:47 config/i386/interix.opt:32
+#, fuzzy
+#| msgid "Use the GNU extension to the PE format for aligned common data"
  msgid "Use the GNU extension to the PE format for aligned common data."
-msgstr ""
+msgstr "Использовать GNU расширения PE формата для выравненных common данных"
  
  #: config/i386/cygming.opt:51
+#, fuzzy
+#| msgid "Compile code that relies on Cygwin DLL wrappers to support C++ operator new/delete replacement"
  msgid "Compile code that relies on Cygwin DLL wrappers to support C++ operator new/delete replacement."
-msgstr ""
+msgstr "Компилировать код, использующий обертки Cygwin DLL для поддержки замены операторов C++ new/delete"
  
  #: config/i386/cygming.opt:58
  msgid "Put relocated read-only data into .data section."
  msgstr ""
  
  #: config/i386/mingw.opt:29
+#, fuzzy
+#| msgid "Warn about none ISO msvcrt scanf/printf width extensions"
  msgid "Warn about none ISO msvcrt scanf/printf width extensions."
-msgstr ""
+msgstr "Предупреждать об отсутствии расширений ISO msvcrt scanf/printf ширины"
  
  #: config/i386/mingw.opt:33
  msgid "For nested functions on stack executable permission is set."
-msgstr ""
+msgstr "Для вложенных функций установлено право выполнения на стеке."
  
  #: config/i386/mingw-w64.opt:23
+#, fuzzy
+#| msgid "Use unicode startup and define UNICODE macro"
  msgid "Use unicode startup and define UNICODE macro."
-msgstr ""
+msgstr "Использовать инициализацию unicode и определить макрос UNICODE"
  
  #: config/i386/i386.opt:182
  #, fuzzy
@@ -9843,6 +10315,7 @@ msgstr "sizeof(long double) равно 12"
  
  #: config/i386/i386.opt:194
  #, fuzzy
+#| msgid "Use 128-bit long double"
  msgid "Use 80-bit long double."
  msgstr "Использовать 128-битное представление long double"
  
@@ -9904,8 +10377,9 @@ msgstr "Не выравнивать данные, доступные на зап
  
  #: config/i386/i386.opt:234
  #, fuzzy
+#| msgid "Known TLS dialects (for use with the -mtls-dialect= option):"
  msgid "Known data alignment choices (for use with the -malign-data= option):"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸: -mfpu=%s"
+msgstr "Ð\94Ð¸Ð°Ð»ÐµÐºÑ\82Ñ\8b TLS (Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b ÐºÐ»Ñ\8eÑ\87Ð° -mtls-dialect=):"
  
  #: config/i386/i386.opt:251
  #, fuzzy
@@ -9915,7 +10389,7 @@ msgstr "Использовать указанный диалект ассемб
  
  #: config/i386/i386.opt:255
  msgid "Known assembler dialects (for use with the -masm-dialect= option):"
-msgstr ""
+msgstr "Известные диалекты ассемблера (значения ключа -masm-dialect= ):"
  
  #: config/i386/i386.opt:265
  #, fuzzy
@@ -9938,22 +10412,23 @@ msgstr "Использовать указанную модель кода x86-64
  #: config/i386/i386.opt:277 config/rs6000/aix64.opt:36
  #: config/rs6000/linux64.opt:32 config/tilegx/tilegx.opt:57
  msgid "Known code models (for use with the -mcmodel= option):"
-msgstr ""
+msgstr "Известные модели кода (значения ключа -mcmodel= ):"
  
  #: config/i386/i386.opt:296
  #, fuzzy
+#| msgid "Use given x86-64 code model"
  msgid "Use given address mode."
  msgstr "Использовать указанную модель кода x86-64"
  
  #: config/i386/i386.opt:300
  #, fuzzy
+#| msgid "Known code models (for use with the -mcmodel= option):"
  msgid "Known address mode (for use with the -maddress-mode= option):"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸: -mfpu=%s"
+msgstr "Ð\98Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐµ Ð¼Ð¾Ð´ÐµÐ»Ð¸ ÐºÐ¾Ð´Ð° (Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mcmodel= ):"
  
  #: config/i386/i386.opt:309
-#, fuzzy
  msgid "%<-mcpu=%> is deprecated; use %<-mtune=%> or %<-march=%> instead"
-msgstr "ÐÑ\82Ð¾Ñ\82 ÐºÐ»Ñ\8eÑ\87 Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ»; Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -Wextra."
+msgstr "ÐºÐ»Ñ\8eÑ\87 %<-mcpu=%> Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ»; Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ %<-mtune=%> Ð¸Ð»Ð¸ %<-march=%>"
  
  #: config/i386/i386.opt:313
  #, fuzzy
@@ -9962,8 +10437,10 @@ msgid "Generate sin, cos, sqrt for FPU."
  msgstr "Генерировать sin, cos, sqrt для FPU"
  
  #: config/i386/i386.opt:317
+#, fuzzy
+#| msgid "Always use Dynamic Realigned Argument Pointer (DRAP) to realign stack"
  msgid "Always use Dynamic Realigned Argument Pointer (DRAP) to realign stack."
-msgstr ""
+msgstr "Всегда используйте Dynamic Realigned Argument Pointer (DRAP) для выравнивания стека"
  
  #: config/i386/i386.opt:321
  #, fuzzy
@@ -9978,9 +10455,8 @@ msgid "Generate floating point mathematics using given instruction set."
  msgstr "Генерировать код для плавающей арифметики используя заданный набор команд"
  
  #: config/i386/i386.opt:329
-#, fuzzy
  msgid "Valid arguments to -mfpmath=:"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs"
+msgstr "Ð\94Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b -mfpmath=:"
  
  #: config/i386/i386.opt:362
  #, fuzzy
@@ -9989,12 +10465,14 @@ msgid "Inline all known string operations."
  msgstr "Выполнять inline-подстановку всех известных строковых операций"
  
  #: config/i386/i386.opt:366
+#, fuzzy
+#| msgid "Inline memset/memcpy string operations, but perform inline version only for small blocks"
  msgid "Inline memset/memcpy string operations, but perform inline version only for small blocks."
-msgstr ""
+msgstr "Делать inline-подстановки строковых функций memset/memcpy, но выполнять inline-версии только для маленьких блоков памяти"
  
  #: config/i386/i386.opt:369
  msgid "%<-mintel-syntax%> and %<-mno-intel-syntax%> are deprecated; use %<-masm=intel%> and %<-masm=att%> instead"
-msgstr ""
+msgstr "ключи %<-mintel-syntax%> и %<-mno-intel-syntax%> устарели; используйте %<-masm=intel%> и %<-masm=att%>"
  
  #: config/i386/i386.opt:374
  #, fuzzy
@@ -10004,29 +10482,33 @@ msgstr "Использовать размещение битовых полей
  
  #: config/i386/i386.opt:394
  #, fuzzy
+#| msgid "Set 80387 floating-point precision to 32-bit"
  msgid "Set 80387 floating-point precision to 32-bit."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c 32-Ð±Ð¸Ñ\82Ð½Ñ\8bÐµ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ñ\8b Ñ\81Ð¾Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80Ð° плавающей арифметики"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ð´Ð»Ñ\8f 80387 32-Ð±Ð¸Ñ\82Ð½Ñ\83Ñ\8e Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ñ\8c плавающей арифметики"
  
  #: config/i386/i386.opt:398
  #, fuzzy
+#| msgid "Set 80387 floating-point precision to 64-bit"
  msgid "Set 80387 floating-point precision to 64-bit."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c 32-Ð±Ð¸Ñ\82Ð½Ñ\8bÐµ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ñ\8b Ñ\81Ð¾Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80Ð° плавающей арифметики"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ð´Ð»Ñ\8f 80387 64-Ð±Ð¸Ñ\82Ð½Ñ\83Ñ\8e Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ñ\8c плавающей арифметики"
  
  #: config/i386/i386.opt:402
  #, fuzzy
+#| msgid "Set 80387 floating-point precision to 80-bit"
  msgid "Set 80387 floating-point precision to 80-bit."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c 32-Ð±Ð¸Ñ\82Ð½Ñ\8bÐµ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ñ\8b Ñ\81Ð¾Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80Ð° плавающей арифметики"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ð´Ð»Ñ\8f 80387 80-Ð±Ð¸Ñ\82Ð½Ñ\83Ñ\8e Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ñ\8c плавающей арифметики"
  
  #: config/i386/i386.opt:406
  #, fuzzy
  #| msgid "Attempt to keep stack aligned to this power of 2"
  msgid "Attempt to keep stack aligned to this power of 2."
-msgstr "Пытаться Выравнивать стек по адресам, кратным указанной степени числа 2"
+msgstr "Пытаться сохранять выравнивание стека по адресам, кратным указанной степени числа 2"
  
  #: config/i386/i386.opt:410
  #, fuzzy
+#| msgid "Assume incoming stack aligned to this power of 2"
  msgid "Assume incoming stack aligned to this power of 2."
-msgstr "Ð\9fÑ\8bÑ\82Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ð\92Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ñ\82Ñ\8c Ñ\81Ñ\82ÐµÐº Ð¿Ð¾ Ð°Ð´Ñ\80ÐµÑ\81Ð°Ð¼, ÐºÑ\80Ð°Ñ\82Ð½Ñ\8bÐ¼ указанной степени числа 2"
+msgstr "Ð¡Ñ\87Ð¸Ñ\82Ð°Ñ\82Ñ\8c, Ñ\87Ñ\82Ð¾ Ð¿Ñ\80Ð¸ Ð²Ñ\85Ð¾Ð´Ðµ Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8e Ñ\81Ñ\82ÐµÐº Ð²Ñ\8bÑ\80Ð¾Ð²Ð½ÐµÐ½ Ð¿Ð¾ Ð°Ð´Ñ\80ÐµÑ\81Ñ\83, ÐºÑ\80Ð°Ñ\82Ð½Ð¾Ð¼Ñ\83 указанной степени числа 2"
  
  #: config/i386/i386.opt:414
  #, fuzzy
@@ -10065,8 +10547,10 @@ msgid "Use SSE register passing conventions for SF and DF mode."
  msgstr "Использовать соглашения по передаче регистров SSE для режимов SF и DF"
  
  #: config/i386/i386.opt:438
+#, fuzzy
+#| msgid "Realign stack in prologue"
  msgid "Realign stack in prologue."
-msgstr ""
+msgstr "Повторно выравнивать стек в прологе"
  
  #: config/i386/i386.opt:442
  #, fuzzy
@@ -10083,13 +10567,14 @@ msgid "Specify memset expansion strategy when expected size is known."
  msgstr ""
  
  #: config/i386/i386.opt:454
+#, fuzzy
+#| msgid "Chose strategy to generate stringop using"
  msgid "Chose strategy to generate stringop using."
-msgstr ""
+msgstr "Выбрать стратегию генерации строковых операций"
  
  #: config/i386/i386.opt:458
-#, fuzzy
  msgid "Valid arguments to -mstringop-strategy=:"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ (%s) Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mtune="
+msgstr "Ð\94Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b ÐºÐ»Ñ\8eÑ\87Ð° -mstringop-strategy=:"
  
  #: config/i386/i386.opt:486
  #, fuzzy
@@ -10099,7 +10584,7 @@ msgstr "Использовать указанный диалект локаль
  
  #: config/i386/i386.opt:490
  msgid "Known TLS dialects (for use with the -mtls-dialect= option):"
-msgstr ""
+msgstr "Диалекты TLS (возможные аргументы ключа -mtls-dialect=):"
  
  #: config/i386/i386.opt:500
  #, fuzzy, c-format
@@ -10112,9 +10597,8 @@ msgid "Fine grain control of tune features."
  msgstr ""
  
  #: config/i386/i386.opt:512
-#, fuzzy
  msgid "Clear all tune features."
-msgstr "некорректный операнд"
+msgstr ""
  
  #: config/i386/i386.opt:519
  #, fuzzy
@@ -10130,49 +10614,53 @@ msgstr "Генерировать код в соответствии с зада
  
  #: config/i386/i386.opt:527
  msgid "Known ABIs (for use with the -mabi= option):"
-msgstr ""
+msgstr "Допустимые ABI (возможные аргументы ключа -mabi=):"
  
  #: config/i386/i386.opt:537 config/rs6000/rs6000.opt:189
  #, fuzzy
+#| msgid "Vector library ABI to use"
  msgid "Vector library ABI to use."
-msgstr "Использовать указанный ABI"
+msgstr "ABI для библиотеки векторных операций"
  
  #: config/i386/i386.opt:541
  msgid "Known vectorization library ABIs (for use with the -mveclibabi= option):"
-msgstr ""
+msgstr "Допустимые ABI библиотеки векторных операций (возможные аргументы ключа -mveclibabi=):"
  
  #: config/i386/i386.opt:551
+#, fuzzy
+#| msgid "Return 8-byte vectors in memory"
  msgid "Return 8-byte vectors in memory."
-msgstr ""
+msgstr "Возвращать 8-байтные векторы в памяти"
  
  #: config/i386/i386.opt:555
  msgid "Generate reciprocals instead of divss and sqrtss."
-msgstr ""
+msgstr "Генерировать вычисление обратных значений вместо divss и sqrtss."
  
  #: config/i386/i386.opt:559
  msgid "Control generation of reciprocal estimates."
-msgstr ""
+msgstr "Позволяет управлять использованием обратных значений в генерации кода"
  
  #: config/i386/i386.opt:563
-#, fuzzy
  msgid "Generate cld instruction in the function prologue."
-msgstr "Ð\92Ñ\8bÐ´ÐµÐ»Ñ\8fÑ\82Ñ\8c Ð¼ÐµÑ\81Ñ\82Ð¾ Ð´Ð»Ñ\8f Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÐ¼Ñ\8bÑ\85 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² Ð¿Ñ\80Ð¾Ð»Ð¾Ð³Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 cld Ð² Ð¿Ñ\80Ð¾Ð»Ð¾Ð³Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸."
  
  #: config/i386/i386.opt:567
  msgid "Generate vzeroupper instruction before a transfer of control flow out of"
-msgstr ""
+msgstr "Генерировать команду vzeroupper перед выходом из функции"
  
  #: config/i386/i386.opt:572
  msgid "Disable Scalar to Vector optimization pass transforming 64-bit integer"
  msgstr ""
  
  #: config/i386/i386.opt:577
+#, fuzzy
+#| msgid "Do dispatch scheduling if processor is bdver1 or bdver2 and Haifa scheduling is selected."
  msgid "Do dispatch scheduling if processor is bdver1, bdver2, bdver3, bdver4"
-msgstr ""
+msgstr "Выполнять быстрое планирование, если процессор bdver1 или bdver2 и выбран планировщик Haifa"
  
  #: config/i386/i386.opt:582
  msgid "Use 128-bit AVX instructions instead of 256-bit AVX instructions in the auto-vectorizer."
-msgstr ""
+msgstr "Использовать 128-битные инструкций AVX вместо 256-битных при автовекторизации кода."
  
  #: config/i386/i386.opt:588
  #, fuzzy
@@ -10188,8 +10676,9 @@ msgstr "Генерировать 64-битный код x86-64"
  
  #: config/i386/i386.opt:596
  #, fuzzy
+#| msgid "Generate 32bit x86-64 code"
  msgid "Generate 32bit x86-64 code."
-msgstr "Генерировать 64-битный код x86-64"
+msgstr "Генерировать 32-битный код x86-64"
  
  #: config/i386/i386.opt:600
  #, fuzzy
@@ -10211,153 +10700,177 @@ msgstr "Включить поддержку внутренних функций
  
  #: config/i386/i386.opt:612
  #, fuzzy
+#| msgid "Support Athlon 3Dnow! built-in functions"
  msgid "Support Athlon 3Dnow! built-in functions."
-msgstr "Включить поддержку внутренних функций 3DNow!"
+msgstr "Включить поддержку внутренних функций Athlon 3Dnow!"
  
  #: config/i386/i386.opt:616
  #, fuzzy
  #| msgid "Support MMX and SSE built-in functions and code generation"
  msgid "Support MMX and SSE built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд MMX и SSE"
  
  #: config/i386/i386.opt:620
  #, fuzzy
  #| msgid "Support MMX, SSE and SSE2 built-in functions and code generation"
  msgid "Support MMX, SSE and SSE2 built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX, SSE и SSE2  при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд MMX, SSE и SSE2"
  
  #: config/i386/i386.opt:624
  #, fuzzy
  #| msgid "Support MMX, SSE, SSE2 and SSE3 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2 and SSE3 built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3"
  
  #: config/i386/i386.opt:628
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3 and SSSE3 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3 and SSSE3 built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3 и SSSE3"
  
  #: config/i386/i386.opt:632
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3 and SSE4.1 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3 and SSE4.1 built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3 и SSE4.1"
  
  #: config/i386/i386.opt:636 config/i386/i386.opt:640
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 and SSE4.2 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 and SSE4.2 built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1 и SSE4.2"
  
  #: config/i386/i386.opt:644
  #, fuzzy
+#| msgid "Do not support SSE4.1 and SSE4.2 built-in functions and code generation"
  msgid "Do not support SSE4.1 and SSE4.2 built-in functions and code generation."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶ÐºÑ\83 Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ð¸Ñ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹ MMX, SSE Ð¸ SSE2  Ð¿Ñ\80Ð¸ Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\9dÐµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°Ñ\82Ñ\8c Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ð¸Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð¸ ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b SSE4.1 Ð¸ SSE4.2"
  
  #: config/i386/i386.opt:647
  msgid "%<-msse5%> was removed"
-msgstr ""
+msgstr "ключ %<-msse5%> был удален"
  
  #: config/i386/i386.opt:652
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 and AVX built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 and AVX built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2 и AVX"
  
  #: config/i386/i386.opt:656
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX и AVX2"
  
  #: config/i386/i386.opt:660
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX и AVX2"
  
  #: config/i386/i386.opt:664
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512PF built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX и AVX2"
  
  #: config/i386/i386.opt:668
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512ER built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX и AVX2"
  
  #: config/i386/i386.opt:672
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512CD built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX и AVX2"
  
  #: config/i386/i386.opt:676
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512DQ built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX и AVX2"
  
  #: config/i386/i386.opt:680
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512BW built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX и AVX2"
  
  #: config/i386/i386.opt:684
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512VL built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX и AVX2"
  
  #: config/i386/i386.opt:688
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512IFMA built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX и AVX2"
  
  #: config/i386/i386.opt:692
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and AVX2 built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX, AVX2 and AVX512F and AVX512VBMI built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX и AVX2"
  
  #: config/i386/i386.opt:696
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and FMA built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX and FMA built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3, SSSE3, SSE4.1, SSE4.2, AVX и FMA"
  
  #: config/i386/i386.opt:700
  #, fuzzy
+#| msgid "Support MMX, SSE, SSE2, SSE3 and SSE4A built-in functions and code generation"
  msgid "Support MMX, SSE, SSE2, SSE3 and SSE4A built-in functions and code generation."
-msgstr "Включить поддержку встроенных функций MMX, SSE, SSE2, SSE3 при генерации кода"
+msgstr "Включить поддержку встроенных функций и генерацию команд MMX, SSE, SSE2, SSE3 и SSE4A"
  
  #: config/i386/i386.opt:704
  #, fuzzy
+#| msgid "Support FMA4 built-in functions and code generation "
  msgid "Support FMA4 built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд FMA4"
  
  #: config/i386/i386.opt:708
  #, fuzzy
+#| msgid "Support XOP built-in functions and code generation "
  msgid "Support XOP built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд XOP"
  
  #: config/i386/i386.opt:712
  #, fuzzy
+#| msgid "Support LWP built-in functions and code generation "
  msgid "Support LWP built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд LWP"
  
  #: config/i386/i386.opt:716
  msgid "Support code generation of Advanced Bit Manipulation (ABM) instructions."
-msgstr ""
+msgstr "Включить генерацию команд Advanced Bit Manipulation (ABM)"
  
  #: config/i386/i386.opt:720
  msgid "Support code generation of popcnt instruction."
-msgstr ""
+msgstr "Включить генерацию команды popcnt."
  
  #: config/i386/i386.opt:724
  #, fuzzy
+#| msgid "Support BMI built-in functions and code generation"
  msgid "Support BMI built-in functions and code generation."
  msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
  
  #: config/i386/i386.opt:728
  #, fuzzy
+#| msgid "Support BMI2 built-in functions and code generation"
  msgid "Support BMI2 built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд BMI2"
  
  #: config/i386/i386.opt:732
  #, fuzzy
+#| msgid "Support LZCNT built-in function and code generation"
  msgid "Support LZCNT built-in function and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд LZCNT"
  
  #: config/i386/i386.opt:736
  msgid "Support Hardware Lock Elision prefixes."
@@ -10365,124 +10878,135 @@ msgstr ""
  
  #: config/i386/i386.opt:740
  #, fuzzy
+#| msgid "Use SmartMIPS instructions"
  msgid "Support RDSEED instruction."
-msgstr "Использовать команды MIPS-3D"
+msgstr "Использовать команды SmartMIPS"
  
  #: config/i386/i386.opt:744
-#, fuzzy
  msgid "Support PREFETCHW instruction."
-msgstr "Использовать команды MIPS-3D"
+msgstr ""
  
  #: config/i386/i386.opt:748
  #, fuzzy
+#| msgid "Support code generation of crc32 instruction."
  msgid "Support flag-preserving add-carry instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ñ\83Ð¼Ð½Ð¾Ð¶ÐµÐ½Ð¸Ñ\8f Ñ\81Ð¾ Ñ\81Ð»Ð¾Ð¶ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b crc32."
  
  #: config/i386/i386.opt:752
-#, fuzzy
  msgid "Support CLFLUSHOPT instructions."
-msgstr "Включить поддержку внутренних функций MMX"
+msgstr ""
  
  #: config/i386/i386.opt:756
  #, fuzzy
+#| msgid "Pack VLIW instructions"
  msgid "Support CLWB instruction."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b MIPS-3D"
+msgstr "Ð£Ð¿Ð°ÐºÐ¾Ð²Ñ\8bÐ²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ð²Ð¾ VLIW"
  
  #: config/i386/i386.opt:760
  #, fuzzy
+#| msgid "Support MMX built-in functions"
  msgid "Support PCOMMIT instruction."
  msgstr "Включить поддержку внутренних функций MMX"
  
  #: config/i386/i386.opt:764
-#, fuzzy
  msgid "Support FXSAVE and FXRSTOR instructions."
-msgstr "Включить поддержку вызовов между системами команд Thumb и ARM"
+msgstr ""
  
  #: config/i386/i386.opt:768
  #, fuzzy
+#| msgid "Support code generation of movbe instruction."
  msgid "Support XSAVE and XRSTOR instructions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶ÐºÑ\83 Ð²Ñ\8bÐ·Ð¾Ð²Ð¾Ð² Ð¼ÐµÐ¶Ð´Ñ\83 Ñ\81Ð¸Ñ\81Ñ\82ÐµÐ¼Ð°Ð¼Ð¸ ÐºÐ¾Ð¼Ð°Ð½Ð´ Thumb Ð¸ ARM"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b movbe."
  
  #: config/i386/i386.opt:772
  #, fuzzy
+#| msgid "Support MMX built-in functions"
  msgid "Support XSAVEOPT instruction."
  msgstr "Включить поддержку внутренних функций MMX"
  
  #: config/i386/i386.opt:776
  #, fuzzy
+#| msgid "Support MMX built-in functions"
  msgid "Support XSAVEC instructions."
  msgstr "Включить поддержку внутренних функций MMX"
  
  #: config/i386/i386.opt:780
-#, fuzzy
  msgid "Support XSAVES and XRSTORS instructions."
-msgstr "Включить поддержку вызовов между системами команд Thumb и ARM"
+msgstr ""
  
  #: config/i386/i386.opt:784
  #, fuzzy
+#| msgid "Support TBM built-in functions and code generation"
  msgid "Support TBM built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд TBM"
  
  #: config/i386/i386.opt:788
  msgid "Support code generation of cmpxchg16b instruction."
-msgstr ""
+msgstr "Включить генерацию команды cmpxchg16b."
  
  #: config/i386/i386.opt:792
  msgid "Support code generation of sahf instruction in 64bit x86-64 code."
-msgstr ""
+msgstr "Включить генерацию команды sahf в 64-битном коде x86-64."
  
  #: config/i386/i386.opt:796
  msgid "Support code generation of movbe instruction."
-msgstr ""
+msgstr "Включить генерацию команды movbe."
  
  #: config/i386/i386.opt:800
  msgid "Support code generation of crc32 instruction."
-msgstr ""
+msgstr "Включить генерацию команды crc32."
  
  #: config/i386/i386.opt:804
  #, fuzzy
+#| msgid "Support AES built-in functions and code generation"
  msgid "Support AES built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд AES"
  
  #: config/i386/i386.opt:808
  #, fuzzy
  #| msgid "Support MMX and SSE built-in functions and code generation"
  msgid "Support SHA1 and SHA256 built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд MMX и SSE"
  
  #: config/i386/i386.opt:812
  #, fuzzy
+#| msgid "Support PCLMUL built-in functions and code generation"
  msgid "Support PCLMUL built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд PCLMUL"
  
  #: config/i386/i386.opt:816
+#, fuzzy
+#| msgid "Encode SSE instructions with VEX prefix"
  msgid "Encode SSE instructions with VEX prefix."
-msgstr ""
+msgstr "Кодировать команды SSE с префиксом VEX"
  
  #: config/i386/i386.opt:820
  #, fuzzy
+#| msgid "Support FSGSBASE built-in functions and code generation"
  msgid "Support FSGSBASE built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд FSGSBASE"
  
  #: config/i386/i386.opt:824
  #, fuzzy
+#| msgid "Support RDRND built-in functions and code generation"
  msgid "Support RDRND built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд RDRND"
  
  #: config/i386/i386.opt:828
  #, fuzzy
+#| msgid "Support F16C built-in functions and code generation"
  msgid "Support F16C built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд F16C"
  
  #: config/i386/i386.opt:832
  #, fuzzy
+#| msgid "Support F16C built-in functions and code generation"
  msgid "Support PREFETCHWT1 built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд F16C"
  
  #: config/i386/i386.opt:836
-#, fuzzy
  msgid "Emit profiling counter call at function entry before prologue."
-msgstr "Ð\92Ñ\8bÐ·Ñ\8bÐ²Ð°Ñ\82Ñ\8c mcount Ð´Ð»Ñ\8f профилирования перед прологом функции"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð²Ñ\8bÐ·Ð¾Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ñ\81Ñ\87ÐµÑ\82Ñ\87Ð¸ÐºÐ° профилирования перед прологом функции"
  
  #: config/i386/i386.opt:840
  msgid "Generate __mcount_loc section with all mcount or __fentry__ calls."
@@ -10497,42 +11021,52 @@ msgid "Skip setting up RAX register when passing variable arguments."
  msgstr ""
  
  #: config/i386/i386.opt:853
+#, fuzzy
+#| msgid "Expand 32bit/64bit integer divide into 8bit unsigned integer divide with run-time check"
  msgid "Expand 32bit/64bit integer divide into 8bit unsigned integer divide with run-time check."
-msgstr ""
+msgstr "Расширять 32-битное/64-битное целочисленное деление в 8-битное беззнаковое целочисленное деление с проверкой времени выполнения"
  
  #: config/i386/i386.opt:857
+#, fuzzy
+#| msgid "Split 32-byte AVX unaligned load"
  msgid "Split 32-byte AVX unaligned load."
-msgstr ""
+msgstr "Разбивать 32-битные команды невыровненной загрузки AVX"
  
  #: config/i386/i386.opt:861
+#, fuzzy
+#| msgid "Split 32-byte AVX unaligned store"
  msgid "Split 32-byte AVX unaligned store."
-msgstr ""
+msgstr "Разбивать 32-битные команды невыровненной записи AVX"
  
  #: config/i386/i386.opt:865
  #, fuzzy
+#| msgid "Support TBM built-in functions and code generation"
  msgid "Support RTM built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд TBM"
  
  #: config/i386/i386.opt:869
  #, fuzzy
+#| msgid "Support code generation of movbe instruction."
  msgid "Support MPX code generation."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶ÐºÑ\83 Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ð¸Ñ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹ MMX Ð¸ SSE Ð¿Ñ\80Ð¸ Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b movbe."
  
  #: config/i386/i386.opt:873
  #, fuzzy
  #| msgid "Support MMX and SSE built-in functions and code generation"
  msgid "Support MWAITX and MONITORX built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд MMX и SSE"
  
  #: config/i386/i386.opt:877
  #, fuzzy
+#| msgid "Support AES built-in functions and code generation"
  msgid "Support CLZERO built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд AES"
  
  #: config/i386/i386.opt:881
  #, fuzzy
+#| msgid "Support PCLMUL built-in functions and code generation"
  msgid "Support PKU built-in functions and code generation."
-msgstr "Включить поддержку внутренних функций MMX и SSE при генерации кода"
+msgstr "Включить поддержку внутренних функций и генерацию команд PCLMUL"
  
  #: config/i386/i386.opt:885
  msgid "Use given stack-protector guard."
@@ -10540,8 +11074,9 @@ msgstr ""
  
  #: config/i386/i386.opt:889
  #, fuzzy
+#| msgid "Known ARM architectures (for use with the -march= option):"
  msgid "Known stack protector guard (for use with the -mstack-protector-guard= option):"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸: -mfpu=%s"
+msgstr "Ð\98Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐµ ARM Ð°Ñ\80Ñ\85Ð¸Ñ\82ÐµÐºÑ\82Ñ\83Ñ\80Ñ\8b (Ð´Ð»Ñ\8f Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ñ\81 -march= Ð¾Ð¿Ñ\86Ð¸ÐµÐ¹):"
  
  #: config/i386/i386.opt:899
  msgid "Attempt to avoid generating instruction sequences containing ret bytes."
@@ -10700,6 +11235,7 @@ msgstr "Включить отладочную печать"
  
  #: config/v850/v850.opt:41
  #, fuzzy
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the callt instruction (default)."
  msgstr "Не использовать команды callt"
  
@@ -10747,12 +11283,15 @@ msgstr "Максимальный размер данных для размеще
  
  #: config/v850/v850.opt:82
  #, fuzzy
+#| msgid "Do not enforce strict alignment"
  msgid "Do not enforce strict alignment."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·овать строгое выравнивание"
+msgstr "Ð\9dÐµ Ñ\82Ñ\80ÐµÐ±овать строгое выравнивание"
  
  #: config/v850/v850.opt:86
+#, fuzzy
+#| msgid "Put jump tables for switch statements into the .data section rather than the .code section"
  msgid "Put jump tables for switch statements into the .data section rather than the .code section."
-msgstr ""
+msgstr "Помещать таблицу переходов для switch операторов в .data секцию а не в .code секцию"
  
  #: config/v850/v850.opt:93
  #, fuzzy
@@ -10774,28 +11313,33 @@ msgstr "Компилировать для процессора v850e1"
  
  #: config/v850/v850.opt:105
  #, fuzzy
+#| msgid "Compile for the v850es variant of the v850e1"
  msgid "Compile for the v850es variant of the v850e1."
-msgstr "Компилировать для процессора v850e"
+msgstr "Компилировать для v850es варианта v850e1"
  
  #: config/v850/v850.opt:109
  #, fuzzy
+#| msgid "Compile for the v850e2 processor"
  msgid "Compile for the v850e2 processor."
-msgstr "Компилировать для процессора v850e"
+msgstr "Компилировать для процессора v850e2"
  
  #: config/v850/v850.opt:113
  #, fuzzy
+#| msgid "Compile for the v850e2v3 processor"
  msgid "Compile for the v850e2v3 processor."
-msgstr "Компилировать для процессора v850e"
+msgstr "Компилировать для процессора v850e2v3"
  
  #: config/v850/v850.opt:117
  #, fuzzy
+#| msgid "Compile for the v850e processor"
  msgid "Compile for the v850e3v5 processor."
  msgstr "Компилировать для процессора v850e"
  
  #: config/v850/v850.opt:124
  #, fuzzy
+#| msgid "Enable clip instructions"
  msgid "Enable v850e3v5 loop instructions."
-msgstr "Включить генерацию параллельного кода"
+msgstr "Включить clip инструкции"
  
  #: config/v850/v850.opt:128
  #, fuzzy
@@ -10805,31 +11349,37 @@ msgstr "Максимальный размер данных для размеще
  
  #: config/v850/v850.opt:135
  #, fuzzy
+#| msgid "Enable the rank heuristic in the scheduler"
  msgid "Enable relaxing in the assembler."
-msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\83Ñ\80Ð¾Ð²ÐµÐ½Ñ\8c Ð¿Ð¾Ð´Ñ\80Ð¾Ð±Ð½Ð¾Ñ\81Ñ\82Ð¸ Ñ\81Ð¾Ð¾Ð±Ñ\89ÐµÐ½Ð¸Ð¹ Ð¾Ñ\82 планировщика"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\8dÐ²Ñ\80Ð¸Ñ\81Ñ\82Ð¸ÐºÑ\83 Ñ\80Ð°Ð½Ð¶Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð´Ð»Ñ\8f планировщика"
  
  #: config/v850/v850.opt:139
  #, fuzzy
+#| msgid "Prohibit PC relative function calls"
  msgid "Prohibit PC relative jumps."
  msgstr "Запретить вызовы функций относительно PC"
  
  #: config/v850/v850.opt:143
  #, fuzzy
+#| msgid "Prevent the use of all hardware floating-point instructions"
  msgid "Inhibit the use of hardware floating point instructions."
  msgstr "Не использовать аппаратную реализацию плавающих операций"
  
  #: config/v850/v850.opt:147
  #, fuzzy
+#| msgid "Allow the use of hardware floating-point ABI and instructions"
  msgid "Allow the use of hardware floating point instructions for V850E2V3 and up."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐµ ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b для операций с плавающей точкой"
+msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÑ\85 ÐºÐ¾Ð¼Ð°Ð½Ð´ Ð¸ ABI для операций с плавающей точкой"
  
  #: config/v850/v850.opt:151
  #, fuzzy
+#| msgid "Enable the use of RX FPU instructions.  This is the default."
  msgid "Enable support for the RH850 ABI.  This is the default."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b RTPB"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ RX FPU Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹.  ÐÑ\82Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ðµ."
  
  #: config/v850/v850.opt:155
  #, fuzzy
+#| msgid "Enable support for huge objects"
  msgid "Enable support for the old GCC ABI."
  msgstr "Включить поддержку больших объектов"
  
@@ -10839,8 +11389,9 @@ msgstr ""
  
  #: config/g.opt:27
  #, fuzzy
+#| msgid "-G<number>\tPut global and static data smaller than <number> bytes into a special section (on some targets)"
  msgid "-G<number>\tPut global and static data smaller than <number> bytes into a special section (on some targets)."
-msgstr "Размещать глобальные и статические данные меньше заданного <числа> байт в специальных секциях"
+msgstr "-G<number>\tРазмещать глобальные и статические данные меньше заданного <числа> байт в специальных секциях (для некоторых платформ)"
  
  #: config/lynx.opt:23
  #, fuzzy
@@ -10862,13 +11413,15 @@ msgstr "Поддержка многопоточности"
  
  #: config/nvptx/nvptx.opt:22
  #, fuzzy
+#| msgid "Generate code for a Fido A"
  msgid "Generate code for a 32-bit ABI."
-msgstr "Генерировать код для DLL"
+msgstr "Генерировать код для Fido A"
  
  #: config/nvptx/nvptx.opt:26
  #, fuzzy
+#| msgid "Generate code for a Fido A"
  msgid "Generate code for a 64-bit ABI."
-msgstr "Генерировать код для DLL"
+msgstr "Генерировать код для Fido A"
  
  #: config/nvptx/nvptx.opt:30
  msgid "Link in code for a __main kernel."
@@ -10892,13 +11445,15 @@ msgstr "Генерировать код для среды выполнения V
  
  #: config/cr16/cr16.opt:23
  #, fuzzy
+#| msgid "-msim   Use simulator runtime"
  msgid "-msim   Use simulator runtime."
-msgstr "Использовать среду запуска симулятора"
+msgstr "-msim   Использовать поддержку времени выполнения симулятора"
  
  #: config/cr16/cr16.opt:27
  #, fuzzy
+#| msgid "Generate SBIT, CBIT instructions"
  msgid "Generate SBIT, CBIT instructions."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b isel"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ SBIT, CBIT"
  
  #: config/cr16/cr16.opt:31
  #, fuzzy
@@ -10907,28 +11462,32 @@ msgid "Support multiply accumulate instructions."
  msgstr "Использовать команды умножения со сложением"
  
  #: config/cr16/cr16.opt:38
+#, fuzzy
+#| msgid "Treat data references as near, far or medium. medium is default"
  msgid "Treat data references as near, far or medium. medium is default."
-msgstr ""
+msgstr "Трактовать обращения к данным как near, far или medium. medium является подразумеваемым"
  
  #: config/cr16/cr16.opt:42
  #, fuzzy
+#| msgid "Generate code for CR16C architecture"
  msgid "Generate code for CR16C architecture."
-msgstr "Генерировать код для процессора C31"
+msgstr "Генерировать код для CR16C архитектуры"
  
  #: config/cr16/cr16.opt:46
  #, fuzzy
+#| msgid "Generate code for CR16C+ architecture (Default)"
  msgid "Generate code for CR16C+ architecture (Default)."
-msgstr "Генерировать код для GNU-ассемблера (gas)"
+msgstr "Генерировать код для CR16C+ архитектуры (По умолчанию)"
  
  #: config/cr16/cr16.opt:50
-#, fuzzy
  msgid "Treat integers as 32-bit."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ñ\81 32-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8fÐ¼Ð¸"
+msgstr "Ð¢Ñ\80Ð°ÐºÑ\82Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\86ÐµÐ»Ñ\8bÐµ ÐºÐ°Ðº 32-Ð±Ð¸Ñ\82Ð½Ñ\8bÐµ."
  
  #: config/avr/avr.opt:23
  #, fuzzy
+#| msgid "Use subroutines for function prologues and epilogues"
  msgid "Use subroutines for function prologues and epilogues."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ð»Ð¾Ð³Ð¸/Ñ\8dÐ¿Ð¸Ð»Ð¾Ð³Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹ ÐºÐ°Ðº Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b Ð´Ð»Ñ\8f Ð¿Ñ\80Ð¾Ð»Ð¾Ð³Ð¾Ð²/Ñ\8dÐ¿Ð¸Ð»Ð¾Ð³Ð¾Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
  
  #: config/avr/avr.opt:26
  #, fuzzy, c-format
@@ -10938,8 +11497,9 @@ msgstr "не задана цель после %qs"
  
  #: config/avr/avr.opt:27
  #, fuzzy
+#| msgid "-mmcu=MCU\tSelect the target MCU"
  msgid "-mmcu=MCU\tSelect the target MCU."
-msgstr "Имя целевого процессор"
+msgstr "-mmcu=MCU\tВыбрать целевой MCU"
  
  #: config/avr/avr.opt:31
  msgid "Set the number of 64 KiB flash segments."
@@ -10955,8 +11515,9 @@ msgstr ""
  
  #: config/avr/avr.opt:49
  #, fuzzy
+#| msgid "Use an 8-bit 'int' type"
  msgid "Use an 8-bit 'int' type."
-msgstr "Использовать 64-битное представление для типа int"
+msgstr "Использовать 8-битный 'int' тип"
  
  #: config/avr/avr.opt:53
  #, fuzzy
@@ -10966,7 +11527,7 @@ msgstr "Изменять указатель стека без отмены пр
  
  #: config/avr/avr.opt:57
  msgid "Set the branch costs for conditional branch instructions.  Reasonable values are small, non-negative integers.  The default branch cost is 0."
-msgstr ""
+msgstr "Установить цены ветвлений для инструкций условного перехода.  Разумные значения небольшие, неотрицательные целые.  Подразумеваемая цена ветвления есть 0."
  
  #: config/avr/avr.opt:67
  #, fuzzy
@@ -10976,29 +11537,31 @@ msgstr "Изменять только младшие 8 бит указателя
  
  #: config/avr/avr.opt:71
  #, fuzzy
+#| msgid "Relax branches"
  msgid "Relax branches."
-msgstr "Ð\9fÐµÑ\80ÐµÑ\85Ð¾Ð´Ð¾Ð² Ð½ÐµÑ\82\n"
+msgstr "Ð\9eÑ\81Ð»Ð°Ð±Ð¸Ñ\82Ñ\8c Ð²ÐµÑ\82Ð²Ð»ÐµÐ½Ð¸Ñ\8f"
  
  #: config/avr/avr.opt:75
  msgid "Make the linker relaxation machine assume that a program counter wrap-around occurs."
-msgstr ""
+msgstr "Заставить машину ослаблений компоновщика предполагать что произошло переполнение счетчика команд."
  
  #: config/avr/avr.opt:79
  msgid "Accumulate outgoing function arguments and acquire/release the needed stack space for outpoing function arguments in function prologue/epilogue.  Without this option, outgoing arguments are pushed before calling a function and popped afterwards.  This option can lead to reduced code size for functions that call many functions that get their arguments on the stack like, for example printf."
-msgstr ""
+msgstr "Накапливать выходные аргументы функций и взять/отдать требуемое пространство стека для выходных аргументов функций в прологе/эпилоге функции.  Без этой опции выходные аргументы вталкиваются перед вызовом функции и выталкиваются после.  Эта опция может уменьшить размер кода для функций которые вызывают много функций которые получают свои аргументы на стеке как, например printf."
  
  #: config/avr/avr.opt:83
  msgid "When accessing RAM, use X as imposed by the hardware, i.e. just use pre-decrement, post-increment and indirect addressing with the X register.  Without this option, the compiler may assume that there is an addressing mode X+const similar to Y+const and Z+const and emit instructions to emulate such an addressing mode for X."
-msgstr ""
+msgstr "При доступе к ОЗУ использовать X как велит аппаратура, т.е. просто использовать предекремент, постинкремент и косвенную адресацию с X регистром.  Без этой опции компилятор может предполагать что имеет место режим адресации X+const аналогичный Y+const и Z+const и выдавать инструкции для эмуляции такого режима адресации для X."
  
  #: config/avr/avr.opt:88
  msgid "The device has no SPH special function register. This option will be overridden by the compiler driver with the correct setting if presence/absence of SPH can be deduced from -mmcu=MCU."
-msgstr ""
+msgstr "Устройство не имеет SPH специального функционального регистра. Эта опция будет перебита драйвером компилятора с корректной установкой если присутствие/отсутствие SPH могут быть выведено из -mmcu=MCU."
  
  #: config/avr/avr.opt:92
  #, fuzzy
+#| msgid "taking the address of a label is non-standard"
  msgid "Warn if the address space of an address is changed."
-msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %s Ð² %s Ð² %L"
+msgstr "Ð²Ð·Ñ\8fÑ\82Ð¸Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð° Ð¼ÐµÑ\82ÐºÐ¸ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f ISO C/C++"
  
  #: config/avr/avr.opt:96
  msgid "Allow to use truncation instead of rounding towards 0 for fractional int types."
@@ -11142,11 +11705,13 @@ msgstr "архитектура ESA/390"
  
  #: config/s390/s390.opt:108
  #, fuzzy
+#| msgid "Enable decimal floating point hardware support"
  msgid "Enable decimal floating point hardware support."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð»Ð¸ Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ñ\83Ñ\80Ñ\83 Ð´Ð»Ñ\8f Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¹ Ñ\81 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\83Ñ\8e Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð´ÐµÑ\81Ñ\8fÑ\82Ð¸Ñ\87Ð½Ð¾Ð¹ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
  
  #: config/s390/s390.opt:112
  #, fuzzy
+#| msgid "Enable hardware floating point"
  msgid "Enable hardware floating point."
  msgstr "Использовать аппаратную реализацию плавающей арифметики"
  
@@ -11156,13 +11721,15 @@ msgstr ""
  
  #: config/s390/s390.opt:134
  #, fuzzy
+#| msgid "Use hardware floating point instructions"
  msgid "Use hardware transactional execution instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° paired-single (Ð½Ð°Ð´ Ð¿Ð°Ñ\80Ð°Ð¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸)"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
  
  #: config/s390/s390.opt:138
  #, fuzzy
+#| msgid "hardware decimal floating point instructions not available on %s"
  msgid "Use hardware vector facility instructions and enable the vector ABI."
-msgstr "Ð\9eÐ³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8fÐ¼Ð¸ Ð½Ð°Ð´ 32-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8fÐ¼Ð¸"
+msgstr "Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð´ÐµÑ\81Ñ\8fÑ\82Ð¸Ñ\87Ð½Ð¾Ð¹ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¸ Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\82 Ð½Ð° %s"
  
  #: config/s390/s390.opt:142
  #, fuzzy
@@ -11178,20 +11745,25 @@ msgstr "Использовать команду bras, если выполняе
  
  #: config/s390/s390.opt:150
  #, fuzzy
+#| msgid "Disable hardware floating point"
  msgid "Disable hardware floating point."
-msgstr "Ð\98спользовать аппаратную реализацию плавающей арифметики"
+msgstr "Ð\9dÐµ Ð¸спользовать аппаратную реализацию плавающей арифметики"
  
  #: config/s390/s390.opt:154
+#, fuzzy
+#| msgid "Set the max. number of bytes which has to be left to stack size before a trap instruction is triggered"
  msgid "Set the max. number of bytes which has to be left to stack size before a trap instruction is triggered."
-msgstr ""
+msgstr "Максимальное число байт до границы стека, при достижении которого будет выполнена команда trap"
  
  #: config/s390/s390.opt:158
  msgid "Switches off the -mstack-guard= option."
  msgstr ""
  
  #: config/s390/s390.opt:162
+#, fuzzy
+#| msgid "Emit extra code in the function prologue in order to trap if the stack size exceeds the given limit"
  msgid "Emit extra code in the function prologue in order to trap if the stack size exceeds the given limit."
-msgstr ""
+msgstr "Генерировать в прологе код, обеспечивающий выполнение trap при переполнении стека"
  
  #: config/s390/s390.opt:166
  msgid "Switches off the -mstack-size= option."
@@ -11227,12 +11799,11 @@ msgstr "z/Архитектура"
  
  #: config/s390/s390.opt:195
  msgid "Set the branch costs for conditional branch instructions.  Reasonable"
-msgstr ""
+msgstr "Установить (разумные) стоимости условных переходов"
  
  #: config/rl78/rl78.opt:27 config/rx/rx.opt:87
-#, fuzzy
  msgid "Use the simulator runtime."
-msgstr "Использовать среду запуска симулятора"
+msgstr "Использовать поддержку времени выполнения симулятора."
  
  #: config/rl78/rl78.opt:31
  msgid "Selects the type of hardware multiplication and division to use (none/g13/g14)."
@@ -11240,8 +11811,9 @@ msgstr ""
  
  #: config/rl78/rl78.opt:50
  #, fuzzy
+#| msgid "Specifies the number of registers to reserve for interrupt handlers."
  msgid "Use all registers, reserving none for interrupt handlers."
-msgstr "Ð ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80 Ð´Ð»Ñ\8f PIC-Ð°Ð´Ñ\80ÐµÑ\81Ð°Ñ\86Ð¸Ð¸"
+msgstr "Ð\97Ð°Ð´Ð°ÐµÑ\82 Ñ\87Ð¸Ñ\81Ð»Ð¾ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð² Ñ\80ÐµÐ·ÐµÑ\80Ð²Ð¸Ñ\80Ñ\83ÐµÐ¼Ñ\8bÑ\85 Ð´Ð»Ñ\8f Ð¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82Ñ\87Ð¸ÐºÐ¾Ð² Ð¿Ñ\80ÐµÑ\80Ñ\8bÐ²Ð°Ð½Ð¸Ð¹."
  
  #: config/rl78/rl78.opt:54
  msgid "Enable assembler and linker relaxation.  Enabled by default at -Os."
@@ -11253,18 +11825,21 @@ msgstr ""
  
  #: config/rl78/rl78.opt:77
  #, fuzzy
+#| msgid "Alias for --help=target"
  msgid "Alias for -mcpu=g10."
-msgstr "Ð\97Ð°Ð¼ÐµÐ½Ð° Ð´Ð»Ñ\8f -mflat-abi=hard"
+msgstr "Ð¡Ð¸Ð½Ð¾Ð½Ð¸Ð¼ --help=target"
  
  #: config/rl78/rl78.opt:81
  #, fuzzy
+#| msgid "Alias for --help=target"
  msgid "Alias for -mcpu=g13."
-msgstr "Ð\97Ð°Ð¼ÐµÐ½Ð° Ð´Ð»Ñ\8f -mflat-abi=hard"
+msgstr "Ð¡Ð¸Ð½Ð¾Ð½Ð¸Ð¼ --help=target"
  
  #: config/rl78/rl78.opt:85 config/rl78/rl78.opt:89
  #, fuzzy
+#| msgid "Alias for --help=target"
  msgid "Alias for -mcpu=g14."
-msgstr "Ð\97Ð°Ð¼ÐµÐ½Ð° Ð´Ð»Ñ\8f -mflat-abi=hard"
+msgstr "Ð¡Ð¸Ð½Ð¾Ð½Ð¸Ð¼ --help=target"
  
  #: config/rl78/rl78.opt:93
  msgid "Assume ES is zero throughout program execution, use ES: for read-only data."
@@ -11278,19 +11853,19 @@ msgstr "Создавать библиотеке для симулятора"
  
  #: config/arm/arm-tables.opt:25
  msgid "Known ARM CPUs (for use with the -mcpu= and -mtune= options):"
-msgstr ""
+msgstr "Известные ARM CPUs (для использования с -mcpu= и -mtune= опциями):"
  
  #: config/arm/arm-tables.opt:341
  msgid "Known ARM architectures (for use with the -march= option):"
-msgstr ""
+msgstr "Известные ARM архитектуры (для использования с -march= опцией):"
  
  #: config/arm/arm-tables.opt:438
  msgid "Known ARM FPUs (for use with the -mfpu= option):"
-msgstr ""
+msgstr "Известные ARM FPUs (для использования с -mfpu= опцией):"
  
  #: config/arm/arm.opt:26
  msgid "TLS dialect to use:"
-msgstr ""
+msgstr "TLS диалект для использования:"
  
  #: config/arm/arm.opt:36
  #, fuzzy
@@ -11300,7 +11875,7 @@ msgstr "Задать интерфейс (ABI)"
  
  #: config/arm/arm.opt:40
  msgid "Known ARM ABIs (for use with the -mabi= option):"
-msgstr ""
+msgstr "Известные ARM ABIs (для использования с -mabi= опцией):"
  
  #: config/arm/arm.opt:59
  #, fuzzy
@@ -11327,9 +11902,8 @@ msgid "Generate re-entrant, PIC code."
  msgstr "Генерировать реентерабельный PIC-код"
  
  #: config/arm/arm.opt:90
-#, fuzzy
  msgid "Generate code in 32 bit ARM state."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð´Ð»Ñ\8f Ð¿Ñ\80Ñ\8fÐ¼Ð¾Ð³Ð¾ (big endian) Ð¿Ð¾Ñ\80Ñ\8fÐ´ÐºÐ° Ð±Ð°Ð¹Ñ\82"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð² 32-Ð±Ð¸Ñ\82Ð½Ð¾Ð¼ ARM Ñ\81Ð¾Ñ\81Ñ\82Ð¾Ñ\8fÐ½Ð¸Ð¸."
  
  #: config/arm/arm.opt:98
  #, fuzzy
@@ -11351,21 +11925,23 @@ msgstr "Использовать ли аппаратуру для вычисле
  
  #: config/arm/arm.opt:114
  msgid "Known floating-point ABIs (for use with the -mfloat-abi= option):"
-msgstr ""
+msgstr "Известные плавающие ABIs (для использования с -mfloat-abi= опцией):"
  
  #: config/arm/arm.opt:127
+#, fuzzy
+#| msgid "Switch on/off MIPS16 ASE on alternating functions for compiler testing"
  msgid "Switch ARM/Thumb modes on alternating functions for compiler testing."
-msgstr ""
+msgstr "Включить/выключить MIPS16 ASE на альтернативных функциях для тестирования компилятора"
  
  #: config/arm/arm.opt:131
  #, fuzzy
+#| msgid "Specify the __fp16 floating-point format"
  msgid "Specify the __fp16 floating-point format."
-msgstr "Задать целевую аппаратуру для плавающей точки и формат вычислений"
+msgstr "Задать __fp16 формат плавающей точки"
  
  #: config/arm/arm.opt:135
-#, fuzzy
  msgid "Known __fp16 formats (for use with the -mfp16-format= option):"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸: -mfpu=%s"
+msgstr "Ð\98Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐµ __fp16 Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ñ\8b (Ð´Ð»Ñ\8f Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ñ\81 -mfp16-format= Ð¾Ð¿Ñ\86Ð¸ÐµÐ¹):"
  
  #: config/arm/arm.opt:148
  #, fuzzy
@@ -11379,10 +11955,12 @@ msgstr "Задать целевую аппаратуру для плавающе
  msgid "Generate call insns as indirect calls, if necessary."
  msgstr "Генерировать косвенные вызовы, если нужно"
  
+#
  #: config/arm/arm.opt:163
  #, fuzzy
+#| msgid "Assume arguments alias no other storage"
  msgid "Assume data segments are relative to text segment."
-msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ð½Ðµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÐ²Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ð½Ð¸ Ð´Ñ\80Ñ\83Ð³ Ñ\81 Ð´Ñ\80Ñ\83Ð³Ð¾Ð¼, Ð½Ð¸ Ñ\81 Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼Ð¸ Ð´Ð°Ð½Ð½Ñ\8bÐ¼и"
+msgstr "Ð\9fÑ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÑ\82Ñ\81Ñ\8f Ñ\87Ñ\82Ð¾ Ñ\81Ð¸Ð½Ð¾Ð½Ð¸Ð¼Ñ\8b Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð½Ðµ Ñ\82Ñ\80ÐµÐ±Ñ\83Ñ\8eÑ\82 Ð´Ð¾Ð¿Ð¾Ð»Ð½Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð¹ Ð¿Ð°Ð¼Ñ\8fÑ\82и"
  
  #: config/arm/arm.opt:167
  #, fuzzy
@@ -11416,19 +11994,21 @@ msgstr "Минимальное битовое выравнивание в стр
  
  #: config/arm/arm.opt:190
  #, fuzzy
+#| msgid "Generate code for Thumb state"
  msgid "Generate code for Thumb state."
-msgstr "Генерировать код для GNU-ассемблера"
+msgstr "Генерировать код для Thumb состояния"
  
  #: config/arm/arm.opt:194
  #, fuzzy
  #| msgid "Support calls between Thumb and ARM instruction sets"
  msgid "Support calls between Thumb and ARM instruction sets."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶ÐºÑ\83 Ð²Ñ\8bÐ·Ð¾Ð²Ð¾Ð² Ð¼ÐµÐ¶Ð´Ñ\83 Ñ\81Ð¸Ñ\81Ñ\82ÐµÐ¼Ð°Ð¼Ð¸ ÐºÐ¾Ð¼Ð°Ð½Ð´ Thumb Ð¸ ARM"
+msgstr "Ð\9fÐ¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°Ñ\82Ñ\8c Ð²Ñ\8bÐ·Ð¾Ð²Ñ\8b Ð¼ÐµÐ¶Ð´Ñ\83 Thumb Ð¸ ARM Ñ\81Ð¸Ñ\81Ñ\82ÐµÐ¼Ð°Ð¼Ð¸ ÐºÐ¾Ð¼Ð°Ð½Ð´"
  
  #: config/arm/arm.opt:198
  #, fuzzy
+#| msgid "Specify thread local storage scheme"
  msgid "Specify thread local storage scheme."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ð½Ð½Ñ\8bÐ¹ Ð´Ð¸Ð°Ð»ÐµÐºÑ\82 Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ð¾-Ð¿Ð¾Ñ\82Ð¾Ñ\87Ð½Ð¾Ð¹ памяти"
+msgstr "Ð\97Ð°Ð´Ð°Ñ\82Ñ\8c Ñ\81Ñ\85ÐµÐ¼Ñ\83 thread local памяти"
  
  #: config/arm/arm.opt:202
  #, fuzzy
@@ -11437,9 +12017,8 @@ msgid "Specify how to access the thread pointer."
  msgstr "Способ доступа к указателю на нить"
  
  #: config/arm/arm.opt:206
-#, fuzzy
  msgid "Valid arguments to -mtp=:"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs"
+msgstr "Ð\9aÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ð´Ð»Ñ\8f -mtp=:"
  
  #: config/arm/arm.opt:219
  #, fuzzy
@@ -11464,16 +12043,20 @@ msgid "Print CPU tuning information as comment in assembler file.  This is"
  msgstr ""
  
  #: config/arm/arm.opt:242
+#, fuzzy
+#| msgid "Use Neon quad-word (rather than double-word) registers for vectorization"
  msgid "Use Neon quad-word (rather than double-word) registers for vectorization."
-msgstr ""
+msgstr "Использовать четырехсловные (а не двухсловные) Neon регистры для векторизации"
  
  #: config/arm/arm.opt:246
+#, fuzzy
+#| msgid "Use Neon double-word (rather than quad-word) registers for vectorization"
  msgid "Use Neon double-word (rather than quad-word) registers for vectorization."
-msgstr ""
+msgstr "Использовать двухсловные (а не четырехсловные) Neon регистры для векторизации"
  
  #: config/arm/arm.opt:250
  msgid "Only generate absolute relocations on word sized values."
-msgstr ""
+msgstr "Генерировать только абсолютные настройки значений словного размера."
  
  #: config/arm/arm.opt:254
  msgid "Generate IT blocks appropriate for ARMv8."
@@ -11489,11 +12072,11 @@ msgstr ""
  
  #: config/arm/arm.opt:266
  msgid "Avoid overlapping destination and address registers on LDRD instructions"
-msgstr ""
+msgstr "Избегать перекрытия целевых и адресных регистров в LDRD инструкциях"
  
  #: config/arm/arm.opt:271
  msgid "Enable unaligned word and halfword accesses to packed data."
-msgstr ""
+msgstr "Включить невыровненные словные и полусловные обращения к упакованным данным."
  
  #: config/arm/arm.opt:275
  msgid "Use Neon to perform 64-bits operations rather than core registers."
@@ -11512,18 +12095,19 @@ msgstr ""
  #, fuzzy
  #| msgid "Use hardware FP"
  msgid "Use hardware FP."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐ¹ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ñ\81Ñ\82ÐµÐºÐ°"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\83Ñ\8e Ð²ÐµÑ\89ÐµÑ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\83Ñ\8e Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÑ\83"
  
  #: config/sparc/sparc.opt:38 config/visium/visium.opt:41
  #, fuzzy
  #| msgid "Do not use hardware FP"
  msgid "Do not use hardware FP."
-msgstr "Ð\9dÐµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐ¹ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ñ\81Ñ\82ÐµÐºÐ°"
+msgstr "Ð\9dÐµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\83Ñ\8e Ð²ÐµÑ\89ÐµÑ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\83Ñ\8e Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÑ\83"
  
  #: config/sparc/sparc.opt:42
  #, fuzzy
+#| msgid "Use flat register window model"
  msgid "Use flat register window model."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ñ\8bÐµ Ð¸Ð¼ÐµÐ½Ð° Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð»Ð¾Ñ\81ÐºÑ\83Ñ\8e Ð¼Ð¾Ð´ÐµÐ»Ñ\8c Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²Ð¾Ð³Ð¾ Ð¾ÐºÐ½Ð°"
  
  #: config/sparc/sparc.opt:46
  #, fuzzy
@@ -11557,33 +12141,39 @@ msgstr "Использовать ABI для V8+"
  
  #: config/sparc/sparc.opt:66
  #, fuzzy
+#| msgid "Use UltraSPARC Visual Instruction Set version 1.0 extensions"
  msgid "Use UltraSPARC Visual Instruction Set version 1.0 extensions."
-msgstr "Использовать набор команд расширения UltraSPARC Visual"
+msgstr "Использовать расширения UltraSPARC Visual Instruction Set version 1.0"
  
  #: config/sparc/sparc.opt:70
  #, fuzzy
+#| msgid "Use UltraSPARC Visual Instruction Set version 2.0 extensions"
  msgid "Use UltraSPARC Visual Instruction Set version 2.0 extensions."
-msgstr "Использовать набор команд расширения UltraSPARC Visual"
+msgstr "Использовать расширения UltraSPARC Visual Instruction Set version 2.0"
  
  #: config/sparc/sparc.opt:74
  #, fuzzy
+#| msgid "Use UltraSPARC Visual Instruction Set version 3.0 extensions"
  msgid "Use UltraSPARC Visual Instruction Set version 3.0 extensions."
-msgstr "Использовать набор команд расширения UltraSPARC Visual"
+msgstr "Использовать расширения UltraSPARC Visual Instruction Set version 3.0"
  
  #: config/sparc/sparc.opt:78
  #, fuzzy
+#| msgid "Use UltraSPARC Fused Multiply-Add extensions"
  msgid "Use UltraSPARC Compare-and-Branch extensions."
-msgstr "Использовать набор команд расширения UltraSPARC Visual"
+msgstr "Использовать расширения UltraSPARC Fused Multiply-Add "
  
  #: config/sparc/sparc.opt:82
  #, fuzzy
+#| msgid "Use UltraSPARC Fused Multiply-Add extensions"
  msgid "Use UltraSPARC Fused Multiply-Add extensions."
-msgstr "Использовать набор команд расширения UltraSPARC Visual"
+msgstr "Использовать расширения UltraSPARC Fused Multiply-Add "
  
  #: config/sparc/sparc.opt:86
  #, fuzzy
+#| msgid "Use UltraSPARC Population-Count instruction"
  msgid "Use UltraSPARC Population-Count instruction."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° paired-single (Ð½Ð°Ð´ Ð¿Ð°Ñ\80Ð°Ð¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸)"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8e UltraSPARC Population-Count"
  
  #: config/sparc/sparc.opt:90
  #, fuzzy
@@ -11645,24 +12235,27 @@ msgstr "Использовать указанную модель кодиров
  
  #: config/sparc/sparc.opt:203
  #, fuzzy
+#| msgid "Enable debug output"
  msgid "Enable debug output."
  msgstr "Включить отладочную выдачу"
  
  #: config/sparc/sparc.opt:207
  msgid "Enable strict 32-bit psABI struct return checking."
-msgstr ""
+msgstr "Включить строгую проверку возврата структуры 32-битного psABI"
  
  #: config/sparc/sparc.opt:211
  msgid "Enable workaround for single erratum of AT697F processor"
-msgstr ""
+msgstr "Включить обход для single erratum AT697F процессора"
  
  #: config/sparc/sparc.opt:216
+#, fuzzy
+#| msgid "Enable workaround for single erratum of AT697F processor"
  msgid "Enable workarounds for the errata of the UT699 processor."
-msgstr ""
+msgstr "Включить обход для single erratum AT697F процессора"
  
  #: config/sparc/sparc.opt:245
  msgid "Specify the memory model in effect for the program."
-msgstr ""
+msgstr "Задать действующую модель памяти для программы."
  
  #: config/rs6000/darwin.opt:38 config/rs6000/sysv4.opt:141
  #, fuzzy
@@ -11678,11 +12271,13 @@ msgstr "Генерировать 32-битный код"
  
  #: config/rs6000/rs6000-tables.opt:24
  msgid "Known CPUs (for use with the -mcpu= and -mtune= options):"
-msgstr ""
+msgstr "Известные CPUs (для использования с -mcpu= и -mtune= options):"
  
  #: config/rs6000/476.opt:24
+#, fuzzy
+#| msgid "Preserve the PowerPC 476's link stack by matching up a blr with the bcl/bl insns used for GOT accesses"
  msgid "Preserve the PowerPC 476's link stack by matching up a blr with the bcl/bl insns used for GOT accesses."
-msgstr ""
+msgstr "Сохранять PowerPC 476's стек ссылок путем установления соответствия blr с bcl/bl инструкциями используемыми для GOT доступов"
  
  #: config/rs6000/aix64.opt:24
  #, fuzzy
@@ -11698,8 +12293,9 @@ msgstr "Генерировать код с 32-битными указателя
  
  #: config/rs6000/aix64.opt:32 config/rs6000/linux64.opt:28
  #, fuzzy
+#| msgid "Select code model"
  msgid "Select code model."
-msgstr "Ð\98Ð¼Ñ\8f Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð³Ð¾ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80"
+msgstr "Ð\92Ñ\8bÐ±Ñ\80Ð°Ñ\82Ñ\8c Ð¼Ð¾Ð´ÐµÐ»Ñ\8c ÐºÐ¾Ð´Ð°"
  
  #: config/rs6000/aix64.opt:49
  #, fuzzy
@@ -11751,13 +12347,15 @@ msgstr "Использовать команды округления плава
  
  #: config/rs6000/rs6000.opt:133
  #, fuzzy
+#| msgid "Use PowerPC V2.05 compare bytes instruction"
  msgid "Use PowerPC V2.05 compare bytes instruction."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 popcntb Ð¸Ð· PowerPC V2.02"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8e Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8f Ð±Ð°Ð¹Ñ\82 PowerPC V2.05"
  
  #: config/rs6000/rs6000.opt:137
  #, fuzzy
+#| msgid "Use extended PowerPC V2.05 move floating point to/from GPR instructions"
  msgid "Use extended PowerPC V2.05 move floating point to/from GPR instructions."
-msgstr "Использовать команды округления плавающих чисел из PowerPC V2.02"
+msgstr "Использовать расширенные инструкции PowerPC V2.05 перемещения плавающих в/из GPR"
  
  #: config/rs6000/rs6000.opt:141
  #, fuzzy
@@ -11779,18 +12377,21 @@ msgstr "Генерировать инструкции VRSAVE при генера
  
  #: config/rs6000/rs6000.opt:153
  #, fuzzy
+#| msgid "Use decimal floating point instructions"
  msgid "Use decimal floating point instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° paired-single (Ð½Ð°Ð´ Ð¿Ð°Ñ\80Ð°Ð¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸)"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð´ÐµÑ\81Ñ\8fÑ\82Ð¸Ñ\87Ð½Ñ\8bÑ\85 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ñ\85"
  
  #: config/rs6000/rs6000.opt:157
  #, fuzzy
+#| msgid "Use 4xx half-word multiply instructions"
  msgid "Use 4xx half-word multiply instructions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ñ\83Ð¼Ð½Ð¾Ð¶ÐµÐ½Ð¸Ñ\8f Ñ\81 Ð½Ð°ÐºÐ¾Ð¿Ð»ÐµÐ½Ð¸ÐµÐ¼ Ñ\81 Ð½ÐµÑ\87Ñ\91Ñ\82ÐºÐ¸Ð¼ Ñ\80ÐµÐ·Ñ\83Ð»Ñ\8cÑ\82Ð°Ñ\82Ð¾Ð¼"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c 4xx Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð¿Ð¾Ð»Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð³Ð¾ Ñ\83Ð¼Ð½Ð¾Ð¶ÐµÐ½Ð¸Ñ\8f"
  
  #: config/rs6000/rs6000.opt:161
  #, fuzzy
+#| msgid "Use 4xx string-search dlmzb instruction"
  msgid "Use 4xx string-search dlmzb instruction."
-msgstr "Использовать команды AltiVec"
+msgstr "Использовать 4xx dlmzb инструкцию поиска в строке"
  
  #: config/rs6000/rs6000.opt:165
  #, fuzzy
@@ -11806,17 +12407,21 @@ msgstr "Генерировать строковые команды для бло
  
  #: config/rs6000/rs6000.opt:181
  #, fuzzy
+#| msgid "Use PowerPC V2.06 popcntd instruction"
  msgid "Use PowerPC V2.06 popcntd instruction."
-msgstr "Использовать команду popcntb из PowerPC V2.02"
+msgstr "Использовать PowerPC V2.06 popcntd инструкцию"
  
  #: config/rs6000/rs6000.opt:185
+#, fuzzy
+#| msgid "Under -ffast-math, generate a FRIZ instruction for (double)(long long) conversions"
  msgid "Under -ffast-math, generate a FRIZ instruction for (double)(long long) conversions."
-msgstr ""
+msgstr "При -ffast-math, генерировать FRIZ инструкцию для (double)(long long) преобразований"
  
  #: config/rs6000/rs6000.opt:193
  #, fuzzy
+#| msgid "Use vector/scalar (VSX) instructions"
  msgid "Use vector/scalar (VSX) instructions."
-msgstr "Использовать команды манипулирования медиаданными"
+msgstr "Использовать vector/scalar (VSX) инструкции"
  
  #: config/rs6000/rs6000.opt:240
  #, fuzzy
@@ -11831,13 +12436,16 @@ msgid "Generate load/store with update instructions."
  msgstr "Генерировать команды чтения/записи с изменением адресного регистра"
  
  #: config/rs6000/rs6000.opt:252
+#, fuzzy
+#| msgid "Avoid generation of indexed load/store instructions when possible"
  msgid "Avoid generation of indexed load/store instructions when possible."
-msgstr ""
+msgstr "Избегать генерации индексированных инструкций загрузки/сохранения если возможно"
  
  #: config/rs6000/rs6000.opt:256
  #, fuzzy
+#| msgid "Mark __tls_get_addr calls with argument info"
  msgid "Mark __tls_get_addr calls with argument info."
-msgstr "Ð²Ñ\8bÐ·Ð¾Ð² %<__builtin_next_arg%> Ð±ÐµÐ· Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°"
+msgstr "Ð\9fÐ¾Ð¼ÐµÑ\82Ð¸Ñ\82Ñ\8c __tls_get_addr Ð²Ñ\8bÐ·Ð¾Ð²Ñ\8b Ð¸Ð½Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\86Ð¸ÐµÐ¹ Ð¾Ð± Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°Ñ\85"
  
  #: config/rs6000/rs6000.opt:263
  #, fuzzy
@@ -11864,13 +12472,12 @@ msgid "Conform more closely to IBM XLC semantics."
  msgstr "Более подробно следовать семантике IBM XLC"
  
  #: config/rs6000/rs6000.opt:279 config/rs6000/rs6000.opt:283
-#, fuzzy
  msgid "Generate software reciprocal divide and square root for better throughput."
-msgstr "Генерировать программное деление плавающих для большей производительности"
+msgstr "Генерировать программные обратное деление и квадратный корень для повышения пропускной способности."
  
  #: config/rs6000/rs6000.opt:287
  msgid "Assume that the reciprocal estimate instructions provide more accuracy."
-msgstr ""
+msgstr "Предполагать что инструкции оценки обратного обеспечивают более высокую точность."
  
  #: config/rs6000/rs6000.opt:291
  #, fuzzy
@@ -11916,17 +12523,21 @@ msgstr "Генерировать инструкции VRSAVE при генера
  
  #: config/rs6000/rs6000.opt:326
  #, fuzzy
+#| msgid "Deprecated option.  Use -mno-vrsave instead"
  msgid "Deprecated option.  Use -mno-vrsave instead."
-msgstr "Устаревший ключ. Используйте -mvrsave/-mno-vrsave в качестве замены"
+msgstr "Устаревший ключ.  Используйте -mno-vrsave взамен"
  
  #: config/rs6000/rs6000.opt:330
  #, fuzzy
+#| msgid "Deprecated option.  Use -mvrsave instead"
  msgid "Deprecated option.  Use -mvrsave instead."
-msgstr "Ð\9aÐ»Ñ\8eÑ\87 Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ». Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -Os Ð² ÐºÐ°Ñ\87ÐµÑ\81Ñ\82Ð²Ðµ Ð·Ð°Ð¼ÐµÐ½Ñ\8b"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð¸Ð¹ ÐºÐ»Ñ\8eÑ\87.  Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -mvrsave Ð²Ð·Ð°Ð¼ÐµÐ½"
  
  #: config/rs6000/rs6000.opt:334
+#, fuzzy
+#| msgid "Specify how many bytes should be moved inline before calling out to memcpy/memmove"
  msgid "Specify how many bytes should be moved inline before calling out to memcpy/memmove."
-msgstr ""
+msgstr "Задать сколько байт следует перемещать inline прежде чем вызывать memcpy/memmove"
  
  #: config/rs6000/rs6000.opt:338
  #, fuzzy
@@ -11936,13 +12547,15 @@ msgstr "Генерировать команды isel"
  
  #: config/rs6000/rs6000.opt:342
  #, fuzzy
+#| msgid "Deprecated option.  Use -mno-isel instead"
  msgid "Deprecated option.  Use -mno-isel instead."
-msgstr "Устаревший ключ. Используйте -misel/-mno-isel в качестве замены"
+msgstr "Устаревший ключ.  Используйте -mno-isel взамен"
  
  #: config/rs6000/rs6000.opt:346
  #, fuzzy
+#| msgid "Deprecated option.  Use -misel instead"
  msgid "Deprecated option.  Use -misel instead."
-msgstr "Ð\9aÐ»Ñ\8eÑ\87 Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ». Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -Os Ð² ÐºÐ°Ñ\87ÐµÑ\81Ñ\82Ð²Ðµ Ð·Ð°Ð¼ÐµÐ½Ñ\8b"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð¸Ð¹ ÐºÐ»Ñ\8eÑ\87.  Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -misel Ð²Ð·Ð°Ð¼ÐµÐ½"
  
  #: config/rs6000/rs6000.opt:350
  #, fuzzy
@@ -11950,45 +12563,54 @@ msgstr "Ключ устарел. используйте -Os в качестве
  msgid "Generate SPE SIMD instructions on E500."
  msgstr "Генерировать команды SPE SIMD на E500"
  
+#
  #: config/rs6000/rs6000.opt:354
  #, fuzzy
+#| msgid "Generate PPC750CL paired-single instructions"
  msgid "Generate PPC750CL paired-single instructions."
-msgstr "Генерировать команды isel"
+msgstr "Генерировать PPC750CL paired-single инструкции"
  
  #: config/rs6000/rs6000.opt:358
  #, fuzzy
+#| msgid "Deprecated option.  Use -mno-spe instead"
  msgid "Deprecated option.  Use -mno-spe instead."
-msgstr "Устаревший ключ. Используйте -mspe/-mno-spe в качестве замены"
+msgstr "Устаревший ключ.  Используйте -mno-spe взамен"
  
  #: config/rs6000/rs6000.opt:362
  #, fuzzy
+#| msgid "Deprecated option.  Use -mspe instead"
  msgid "Deprecated option.  Use -mspe instead."
-msgstr "Ð\9aÐ»Ñ\8eÑ\87 Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ». Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -Os Ð² ÐºÐ°Ñ\87ÐµÑ\81Ñ\82Ð²Ðµ Ð·Ð°Ð¼ÐµÐ½Ñ\8b"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð¸Ð¹ ÐºÐ»Ñ\8eÑ\87.  Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -mspe Ð²Ð·Ð°Ð¼ÐµÐ½"
  
  #: config/rs6000/rs6000.opt:366
  #, fuzzy
+#| msgid "-mdebug=\tEnable debug output"
  msgid "-mdebug=\tEnable debug output."
-msgstr "Включить отладочную выдачу"
+msgstr "-mdebug=\tВключить отладочную выдачу"
  
  #: config/rs6000/rs6000.opt:370
  #, fuzzy
+#| msgid "Use the AltiVec ABI extensions"
  msgid "Use the AltiVec ABI extensions."
-msgstr "Использовать расширение указателей Cray"
+msgstr "Использовать расширения AltiVec ABI"
  
  #: config/rs6000/rs6000.opt:374
  #, fuzzy
+#| msgid "Do not use the AltiVec ABI extensions"
  msgid "Do not use the AltiVec ABI extensions."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать расширения AltiVec ABI"
  
  #: config/rs6000/rs6000.opt:378
  #, fuzzy
+#| msgid "Use the SPE ABI extensions"
  msgid "Use the SPE ABI extensions."
-msgstr "Использовать расширение указателей Cray"
+msgstr "Использовать расширения SPE ABI"
  
  #: config/rs6000/rs6000.opt:382
  #, fuzzy
+#| msgid "Do not use the SPE ABI extensions"
  msgid "Do not use the SPE ABI extensions."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать расширения SPE ABI"
  
  #: config/rs6000/rs6000.opt:386
  #, fuzzy
@@ -12004,34 +12626,37 @@ msgstr "Использовать EABI"
  
  #: config/rs6000/rs6000.opt:397
  msgid "using darwin64 ABI"
-msgstr ""
+msgstr "использование darwin64 ABI"
  
  #: config/rs6000/rs6000.opt:400
  msgid "using old darwin ABI"
-msgstr ""
+msgstr "использование старого darwin ABI"
  
  #: config/rs6000/rs6000.opt:403
  msgid "using IEEE extended precision long double"
-msgstr ""
+msgstr "использование IEEE extended precision long double"
  
  #: config/rs6000/rs6000.opt:406
  msgid "using IBM extended precision long double"
-msgstr ""
+msgstr "использование IBM extended precision long double"
  
  #: config/rs6000/rs6000.opt:410
  #, fuzzy
+#| msgid "-mcpu=\tUse features of and schedule code for given CPU"
  msgid "-mcpu=\tUse features of and schedule code for given CPU."
-msgstr "Использовать свойства указанного процессора и планировать код для него"
+msgstr "-mcpu=\tИспользовать свойства указанного процессора и планировать код для него"
  
  #: config/rs6000/rs6000.opt:414
  #, fuzzy
+#| msgid "-mtune=\tSchedule code for given CPU"
  msgid "-mtune=\tSchedule code for given CPU."
-msgstr "Планировать код для указанного процессора"
+msgstr "-mtune=\tПланировать код для указанного процессора"
  
  #: config/rs6000/rs6000.opt:418
  #, fuzzy
+#| msgid "-mtraceback=\tSelect full, part, or no traceback table"
  msgid "-mtraceback=\tSelect full, part, or no traceback table."
-msgstr "Вывод traceback-таблицы: full (полная), part (частичная), no (не выводить таблицу)"
+msgstr "-mtraceback=\tВывод traceback-таблицы: full (полная), part (частичная), no (не выводить таблицу)"
  
  #: config/rs6000/rs6000.opt:434
  #, fuzzy
@@ -12041,13 +12666,15 @@ msgstr "Не устанавливать предельные диапазоны
  
  #: config/rs6000/rs6000.opt:438
  #, fuzzy
+#| msgid "Generate Cell microcode"
  msgid "Generate Cell microcode."
-msgstr "Генерировать код SH2e"
+msgstr "Генерировать Cell микрокод"
  
  #: config/rs6000/rs6000.opt:442
  #, fuzzy
+#| msgid "Warn when a Cell microcoded instruction is emitted"
  msgid "Warn when a Cell microcoded instruction is emitted."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ ÐºÐ»Ð°Ñ\81Ñ\81Ð°Ñ\85, Ð² ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÑ\85 Ð²Ñ\81Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b Ð¸ Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b private"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð²Ñ\8bÐ´Ð°Ñ\87Ðµ Ð¼Ð¸ÐºÑ\80Ð¾ÐºÐ¾Ð´Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÑ\85 Cell Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹"
  
  #: config/rs6000/rs6000.opt:446
  #, fuzzy
@@ -12057,18 +12684,19 @@ msgstr "Предупреждать об использовании устаре
  
  #: config/rs6000/rs6000.opt:450
  #, fuzzy
+#| msgid "-mfloat-gprs=\tSelect GPR floating point method"
  msgid "-mfloat-gprs=\tSelect GPR floating point method."
-msgstr "Выбрать метод GPR работы с плавающими значениями"
+msgstr "-mfloat-gprs=\tВыбрать метод GPR работы с плавающими значениями"
  
  #: config/rs6000/rs6000.opt:454
-#, fuzzy
  msgid "Valid arguments to -mfloat-gprs=:"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs"
+msgstr "Ð\9aÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b ÐºÐ»Ñ\8eÑ\87Ð° -mfloat-gprs=:"
  
  #: config/rs6000/rs6000.opt:470
  #, fuzzy
+#| msgid "-mlong-double-<n>\tSpecify size of long double (64 or 128 bits)"
  msgid "-mlong-double-<n>\tSpecify size of long double (64 or 128 bits)."
-msgstr "Размер long double (64 или 128 бит)"
+msgstr "-mlong-double-<n>\tЗадать размер long double (64 или 128 бит)"
  
  #: config/rs6000/rs6000.opt:478
  #, fuzzy
@@ -12089,9 +12717,8 @@ msgid "Specify alignment of structure fields default/natural."
  msgstr "Задает выравнивание полей структур default/natural"
  
  #: config/rs6000/rs6000.opt:490
-#, fuzzy
  msgid "Valid arguments to -malign-:"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs"
+msgstr "Ð\9aÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b ÐºÐ»Ñ\8eÑ\87Ð° -malign-:"
  
  #: config/rs6000/rs6000.opt:500
  #, fuzzy
@@ -12101,35 +12728,41 @@ msgstr "Задать приоритет планирования для кома
  
  #: config/rs6000/rs6000.opt:504
  #, fuzzy
+#| msgid "Single-precision floating point unit"
  msgid "Single-precision floating point unit."
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð½ÐµÑ\83Ð¿Ð¾Ñ\80Ñ\8fÐ´Ð¾Ñ\87ÐµÐ½Ð½Ð¾Ð³Ð¾ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8f - Ð½Ðµ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ"
+msgstr "Ð£Ñ\81Ñ\82Ñ\80Ð¾Ð¹Ñ\81Ñ\82Ð²Ð¾ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸"
  
  #: config/rs6000/rs6000.opt:508
  #, fuzzy
+#| msgid "Double-precision floating point unit"
  msgid "Double-precision floating point unit."
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð½ÐµÑ\83Ð¿Ð¾Ñ\80Ñ\8fÐ´Ð¾Ñ\87ÐµÐ½Ð½Ð¾Ð³Ð¾ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8f - Ð½Ðµ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ"
+msgstr "Ð£Ñ\81Ñ\82Ñ\80Ð¾Ð¹Ñ\81Ñ\82Ð²Ð¾ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ð´Ð²Ð¾Ð¹Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸"
  
  #: config/rs6000/rs6000.opt:512
  #, fuzzy
+#| msgid "Floating point unit does not support divide & sqrt"
  msgid "Floating point unit does not support divide & sqrt."
-msgstr "-fdata-sections не поддерживается для этой целевой машины"
+msgstr "Устройство плавающей арифметики не поддерживает деление и sqrt"
  
  #: config/rs6000/rs6000.opt:516
+#, fuzzy
+#| msgid "-mfpu=\tSpecify FP (sp, dp, sp-lite, dp-lite) (implies -mxilinx-fpu)"
  msgid "-mfpu=\tSpecify FP (sp, dp, sp-lite, dp-lite) (implies -mxilinx-fpu)."
-msgstr ""
+msgstr "-mfpu=\tЗадать FP (sp, dp, sp-lite, dp-lite) (влечет -mxilinx-fpu)"
  
  #: config/rs6000/rs6000.opt:538
-#, fuzzy
  msgid "Specify Xilinx FPU."
-msgstr "Задать интерфейс (ABI)"
+msgstr "Задать Xilinx FPU."
  
  #: config/rs6000/rs6000.opt:542
  msgid "Use/do not use r11 to hold the static link in calls to functions via pointers."
-msgstr ""
+msgstr "(Не) использовать r11 для хранения статической ссылки в вызовах функций через указатели."
  
  #: config/rs6000/rs6000.opt:546
+#, fuzzy
+#| msgid "Control whether we save the TOC in the prologue for indirect calls or generate the save inline"
  msgid "Control whether we save the TOC in the prologue for indirect calls or generate the save inline."
-msgstr ""
+msgstr "Контролировать, сохраняем ли мы TOC в прологе для косвенных вызовов или генерируем сохранение inline"
  
  #: config/rs6000/rs6000.opt:550
  msgid "Allow 128-bit integers in VSX registers."
@@ -12159,8 +12792,9 @@ msgstr ""
  
  #: config/rs6000/rs6000.opt:574
  #, fuzzy
+#| msgid "Use vector/scalar (VSX) instructions"
  msgid "Use ISA 2.07 transactional memory (HTM) instructions."
-msgstr "Использовать команды манипулирования медиаданными"
+msgstr "Использовать vector/scalar (VSX) инструкции"
  
  #: config/rs6000/rs6000.opt:578
  #, fuzzy
@@ -12220,8 +12854,9 @@ msgstr ""
  
  #: config/rs6000/rs6000.opt:634
  #, fuzzy
+#| msgid "Use decimal floating point instructions"
  msgid "Enable/disable using IEEE 128-bit floating point instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° paired-single (Ð½Ð°Ð´ Ð¿Ð°Ñ\80Ð°Ð¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸)"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð´ÐµÑ\81Ñ\8fÑ\82Ð¸Ñ\87Ð½Ñ\8bÑ\85 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ñ\85"
  
  #: config/rs6000/rs6000.opt:638
  msgid "Enable/disable default conversions between __float128 & long double."
@@ -12297,8 +12932,9 @@ msgstr "Использовать альтернативные имена рег
  
  #: config/rs6000/sysv4.opt:113
  #, fuzzy
+#| msgid "Use default method for sdata handling"
  msgid "Use default method for sdata handling."
-msgstr "Ð\9cÐµÑ\82Ð¾Ð´ Ð¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82ÐºÐ¸ sdata"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¼ÐµÑ\82Ð¾Ð´ Ð¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82ÐºÐ¸ sdata Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e"
  
  #: config/rs6000/sysv4.opt:117
  #, fuzzy
@@ -12476,46 +13112,53 @@ msgstr "Задать уточненную информацию о латентн
  
  #: config/tilepro/tilepro.opt:23
  msgid "Compile with 32 bit longs and pointers, which is the only supported"
-msgstr ""
+msgstr "Компилировать с 32-битными длинными и указателями, которые только и поддерживаются"
  
  #: config/tilepro/tilepro.opt:28 config/tilegx/tilegx.opt:26
  #, fuzzy
+#| msgid "-mcpu=CPU\tUse features of and schedule code for given CPU"
  msgid "-mcpu=CPU\tUse features of and schedule code for given CPU."
-msgstr "Использовать свойства указанного процессора и планировать код для него"
+msgstr "-mcpu=CPU\tИспользовать возможности и планировать код для заданного CPU"
  
  #: config/tilepro/tilepro.opt:32
  msgid "Known TILEPro CPUs (for use with the -mcpu= option):"
-msgstr ""
+msgstr "Известные TILEPro CPUs (для использования с -mcpu= опцией):"
  
  #: config/lm32/lm32.opt:24
  #, fuzzy
+#| msgid "Enable multiply instructions"
  msgid "Enable multiply instructions."
-msgstr "Включить инструкции умножения с накоплением с нечётким результатом"
+msgstr "Включить инструкции умножения"
  
  #: config/lm32/lm32.opt:28
  #, fuzzy
+#| msgid "Enable divide and modulus instructions"
  msgid "Enable divide and modulus instructions."
-msgstr "Включить инструкции умножения с накоплением с нечётким результатом"
+msgstr "Включить инструкции деления и деления с остатком"
  
  #: config/lm32/lm32.opt:32
  #, fuzzy
+#| msgid "Enable barrel shift instructions"
  msgid "Enable barrel shift instructions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´а"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ñ\86Ð¸ÐºÐ»Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ñ\81Ð´Ð²Ð¸Ð³а"
  
  #: config/lm32/lm32.opt:36
  #, fuzzy
+#| msgid "Enable sign extend instructions"
  msgid "Enable sign extend instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 DB"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ñ\80Ð°Ð·Ð¼Ð½Ð¾Ð¶ÐµÐ½Ð¸Ñ\8f Ð·Ð½Ð°ÐºÐ°"
  
  #: config/lm32/lm32.opt:40
  #, fuzzy
+#| msgid "Enable user-defined instructions"
  msgid "Enable user-defined instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 DB"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»Ñ\8fÐµÐ¼Ñ\8bÐµ Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: config/nios2/elf.opt:26
  #, fuzzy
+#| msgid "Link with the fast floating-point library"
  msgid "Link with a limited version of the C library."
-msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81 Ð±Ð¸Ð±Ð»Ð¸Ð¾Ñ\82ÐµÐºÐ°Ð¼Ð¸ pic"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81 Ð±Ð¸Ð±Ð»Ð¸Ð¾Ñ\82ÐµÐºÐ¾Ð¹ Ð±Ñ\8bÑ\81Ñ\82Ñ\80Ð¾Ð¹ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
  
  #: config/nios2/elf.opt:30
  msgid "Name of system library to link against."
@@ -12535,26 +13178,31 @@ msgstr ""
  
  #: config/nios2/nios2.opt:39
  #, fuzzy
+#| msgid "Enable clip instructions"
  msgid "Enable MUL instructions."
-msgstr "Включить генерацию параллельного кода"
+msgstr "Включить clip инструкции"
  
  #: config/nios2/nios2.opt:43
  msgid "Enable MULX instructions, assume fast shifter."
  msgstr ""
  
  #: config/nios2/nios2.opt:47
+#, fuzzy
+#| msgid "Use the software emulation for divides (default)"
  msgid "Use table based fast divide (default at -O3)."
-msgstr ""
+msgstr "Использовать программную эмуляцию для делений (умолчание)"
  
  #: config/nios2/nios2.opt:51
  #, fuzzy
+#| msgid "Enable unaligned load/store instruction"
  msgid "All memory accesses use I/O load/store instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 DB"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð½ÐµÐ²Ñ\8bÑ\80Ð¾Ð²Ð½ÐµÐ½Ð½Ð¾Ð¹ Ð·Ð°Ð³Ñ\80Ñ\83Ð·ÐºÐ¸/Ñ\81Ð¾Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f"
  
  #: config/nios2/nios2.opt:55
  #, fuzzy
+#| msgid "Enable unaligned load/store instruction"
  msgid "Volatile memory accesses use I/O load/store instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 DB"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð½ÐµÐ²Ñ\8bÑ\80Ð¾Ð²Ð½ÐµÐ½Ð½Ð¾Ð¹ Ð·Ð°Ð³Ñ\80Ñ\83Ð·ÐºÐ¸/Ñ\81Ð¾Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f"
  
  #: config/nios2/nios2.opt:59
  msgid "Volatile memory accesses do not use I/O load/store instructions."
@@ -12562,9 +13210,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:63
  #, fuzzy
-#| msgid "Disable indexed addressing"
+#| msgid "unusual TP-relative address"
  msgid "Enable/disable GP-relative addressing."
-msgstr "Ð\9dÐµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ð´ÐµÐºÑ\81Ð½Ñ\83Ñ\8e Ð°Ð´Ñ\80ÐµÑ\81Ð°Ñ\86Ð¸Ñ\8e"
+msgstr "Ð½ÐµÐ¾Ð±Ñ\8bÑ\87Ð½Ñ\8bÐ¹ Ð°Ð´Ñ\80ÐµÑ\81 Ð¾Ñ\82Ð½Ð¾Ñ\81Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾ TP"
  
  #: config/nios2/nios2.opt:67
  msgid "Valid options for GP-relative addressing (for -mgpopt):"
@@ -12598,9 +13246,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:106
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the ftruncds custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:110
  msgid "Integer id (N) of ftruncds custom instruction."
@@ -12608,9 +13256,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:114
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fextsd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:118
  msgid "Integer id (N) of fextsd custom instruction."
@@ -12618,9 +13266,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:122
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fixdu custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:126
  msgid "Integer id (N) of fixdu custom instruction."
@@ -12628,9 +13276,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:130
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fixdi custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:134
  msgid "Integer id (N) of fixdi custom instruction."
@@ -12638,9 +13286,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:138
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fixsu custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:142
  msgid "Integer id (N) of fixsu custom instruction."
@@ -12648,9 +13296,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:146
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fixsi custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:150
  msgid "Integer id (N) of fixsi custom instruction."
@@ -12658,9 +13306,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:154
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the floatud custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:158
  msgid "Integer id (N) of floatud custom instruction."
@@ -12668,9 +13316,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:162
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the floatid custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:166
  msgid "Integer id (N) of floatid custom instruction."
@@ -12678,9 +13326,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:170
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the floatus custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:174
  msgid "Integer id (N) of floatus custom instruction."
@@ -12688,9 +13336,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:178
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the floatis custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:182
  msgid "Integer id (N) of floatis custom instruction."
@@ -12698,9 +13346,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:186
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcmpned custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:190
  msgid "Integer id (N) of fcmpned custom instruction."
@@ -12708,9 +13356,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:194
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcmpeqd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:198
  msgid "Integer id (N) of fcmpeqd custom instruction."
@@ -12718,9 +13366,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:202
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcmpged custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:206
  msgid "Integer id (N) of fcmpged custom instruction."
@@ -12728,9 +13376,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:210
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcmpgtd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:214
  msgid "Integer id (N) of fcmpgtd custom instruction."
@@ -12738,9 +13386,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:218
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcmpled custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:222
  msgid "Integer id (N) of fcmpled custom instruction."
@@ -12748,9 +13396,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:226
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcmpltd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:230
  msgid "Integer id (N) of fcmpltd custom instruction."
@@ -12758,9 +13406,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:234
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the flogd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:238
  msgid "Integer id (N) of flogd custom instruction."
@@ -12768,9 +13416,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:242
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fexpd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:246
  msgid "Integer id (N) of fexpd custom instruction."
@@ -12778,9 +13426,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:250
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fatand custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:254
  msgid "Integer id (N) of fatand custom instruction."
@@ -12788,9 +13436,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:258
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the ftand custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:262
  msgid "Integer id (N) of ftand custom instruction."
@@ -12798,9 +13446,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:266
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fsind custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:270
  msgid "Integer id (N) of fsind custom instruction."
@@ -12808,9 +13456,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:274
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcosd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:278
  msgid "Integer id (N) of fcosd custom instruction."
@@ -12818,9 +13466,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:282
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fsqrtd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:286
  msgid "Integer id (N) of fsqrtd custom instruction."
@@ -12828,9 +13476,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:290
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fabsd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:294
  msgid "Integer id (N) of fabsd custom instruction."
@@ -12838,9 +13486,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:298
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fnegd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:302
  msgid "Integer id (N) of fnegd custom instruction."
@@ -12848,9 +13496,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:306
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fmaxd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:310
  msgid "Integer id (N) of fmaxd custom instruction."
@@ -12858,9 +13506,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:314
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fmind custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:318
  msgid "Integer id (N) of fmind custom instruction."
@@ -12868,9 +13516,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:322
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fdivd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:326
  msgid "Integer id (N) of fdivd custom instruction."
@@ -12878,9 +13526,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:330
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fmuld custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:334
  msgid "Integer id (N) of fmuld custom instruction."
@@ -12888,9 +13536,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:338
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fsubd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:342
  msgid "Integer id (N) of fsubd custom instruction."
@@ -12898,9 +13546,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:346
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the faddd custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:350
  msgid "Integer id (N) of faddd custom instruction."
@@ -12908,9 +13556,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:354
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcmpnes custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:358
  msgid "Integer id (N) of fcmpnes custom instruction."
@@ -12918,9 +13566,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:362
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcmpeqs custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:366
  msgid "Integer id (N) of fcmpeqs custom instruction."
@@ -12928,9 +13576,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:370
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcmpges custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:374
  msgid "Integer id (N) of fcmpges custom instruction."
@@ -12938,9 +13586,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:378
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcmpgts custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:382
  msgid "Integer id (N) of fcmpgts custom instruction."
@@ -12948,9 +13596,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:386
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcmples custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:390
  msgid "Integer id (N) of fcmples custom instruction."
@@ -12958,9 +13606,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:394
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcmplts custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:398
  msgid "Integer id (N) of fcmplts custom instruction."
@@ -12968,9 +13616,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:402
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the flogs custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:406
  msgid "Integer id (N) of flogs custom instruction."
@@ -12978,9 +13626,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:410
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fexps custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:414
  msgid "Integer id (N) of fexps custom instruction."
@@ -12988,9 +13636,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:418
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fatans custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:422
  msgid "Integer id (N) of fatans custom instruction."
@@ -12998,9 +13646,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:426
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the ftans custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:430
  msgid "Integer id (N) of ftans custom instruction."
@@ -13008,9 +13656,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:434
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fsins custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:438
  msgid "Integer id (N) of fsins custom instruction."
@@ -13018,9 +13666,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:442
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fcoss custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:446
  msgid "Integer id (N) of fcoss custom instruction."
@@ -13028,9 +13676,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:450
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fsqrts custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:454
  msgid "Integer id (N) of fsqrts custom instruction."
@@ -13038,9 +13686,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:458
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fabss custom instr."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:462
  msgid "Integer id (N) of fabss custom instruction."
@@ -13048,9 +13696,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:466
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fnegs custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:470
  msgid "Integer id (N) of fnegs custom instruction."
@@ -13058,9 +13706,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:474
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fmaxs custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:478
  msgid "Integer id (N) of fmaxs custom instruction."
@@ -13068,9 +13716,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:482
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fmins custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:486
  msgid "Integer id (N) of fmins custom instruction."
@@ -13078,9 +13726,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:490
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fdivs custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:494
  msgid "Integer id (N) of fdivs custom instruction."
@@ -13088,9 +13736,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:498
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fmuls custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:502
  msgid "Integer id (N) of fmuls custom instruction."
@@ -13098,9 +13746,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:506
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fsubs custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:510
  msgid "Integer id (N) of fsubs custom instruction."
@@ -13108,9 +13756,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:514
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fadds custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:518
  msgid "Integer id (N) of fadds custom instruction."
@@ -13118,9 +13766,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:522
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the frdy custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:526
  msgid "Integer id (N) of frdy custom instruction."
@@ -13128,9 +13776,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:530
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the frdxhi custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:534
  msgid "Integer id (N) of frdxhi custom instruction."
@@ -13138,9 +13786,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:538
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the frdxlo custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:542
  msgid "Integer id (N) of frdxlo custom instruction."
@@ -13148,9 +13796,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:546
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fwry custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:550
  msgid "Integer id (N) of fwry custom instruction."
@@ -13158,9 +13806,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:554
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the fwrx custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:558
  msgid "Integer id (N) of fwrx custom instruction."
@@ -13168,9 +13816,9 @@ msgstr ""
  
  #: config/nios2/nios2.opt:562
  #, fuzzy
-#| msgid "Do not use the bit-field instructions"
+#| msgid "Do not use the callt instruction"
  msgid "Do not use the round custom instruction."
-msgstr "Не использовать команды работы с битовыми полями"
+msgstr "Не использовать команды callt"
  
  #: config/nios2/nios2.opt:566
  msgid "Integer id (N) of round custom instruction."
@@ -13182,74 +13830,73 @@ msgstr ""
  
  #: config/nios2/nios2.opt:584
  #, fuzzy
+#| msgid "Enable saturation instructions"
  msgid "Enable generation of R2 BMX instructions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð½Ð°Ñ\81Ñ\8bÑ\89ÐµÐ½Ð¸Ñ\8f"
  
  #: config/nios2/nios2.opt:588
  #, fuzzy
+#| msgid "Enable saturation instructions"
  msgid "Enable generation of R2 CDX instructions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð½Ð°Ñ\81Ñ\8bÑ\89ÐµÐ½Ð¸Ñ\8f"
  
  #: config/rx/rx.opt:29
  msgid "Store doubles in 64 bits."
-msgstr ""
+msgstr "Хранить doubles в 64 битах."
  
  #: config/rx/rx.opt:33
  msgid "Stores doubles in 32 bits.  This is the default."
-msgstr ""
+msgstr "Хранить doubles в 32 битах.  Это умолчание."
  
  #: config/rx/rx.opt:37
-#, fuzzy
  msgid "Disable the use of RX FPU instructions.  "
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b RTPB"
+msgstr "Ð\92Ñ\8bÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ RX FPU Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹.  "
  
  #: config/rx/rx.opt:44
-#, fuzzy
  msgid "Enable the use of RX FPU instructions.  This is the default."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b RTPB"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ RX FPU Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹.  ÐÑ\82Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ðµ."
  
  #: config/rx/rx.opt:50
-#, fuzzy
  msgid "Specify the target RX cpu type."
-msgstr "Ð\98Ð¼Ñ\8f Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð³Ð¾ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80"
+msgstr "Ð\97Ð°Ð´Ð°Ñ\82Ñ\8c Ñ\82Ð¸Ð¿ Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð³Ð¾ RX cpu."
  
  #: config/rx/rx.opt:71
  msgid "Data is stored in big-endian format."
-msgstr ""
+msgstr "Данные сохраняются в big-endian формате (с прямым порядком байт)."
  
  #: config/rx/rx.opt:75
  msgid "Data is stored in little-endian format.  (Default)."
-msgstr ""
+msgstr "Данные сохраняются в little-endian формате (с обратным порядком байт).  (Умолчание)."
  
  #: config/rx/rx.opt:81
  msgid "Maximum size of global and static variables which can be placed into the small data area."
-msgstr ""
+msgstr "Максимальный размер глобальных и статических переменных которые могут быть помещены в small data область."
  
  #: config/rx/rx.opt:93
+#, fuzzy
+#| msgid "Generate assembler output that is compatible with the Renesas AS100 assembler.  This may restrict some of the compiler's capabilities.  The default is to generate GAS compatable syntax."
  msgid "Generate assembler output that is compatible with the Renesas AS100 assembler.  This may restrict some of the compiler's capabilities.  The default is to generate GAS compatible syntax."
-msgstr ""
+msgstr "Генерировать ассемблерный вывод совместимый с Renesas AS100 ассемблером.  Это может ограничить некоторые из возможностей компилятора.  По умолчанию генерируется GAS совместимый синтаксис."
  
  #: config/rx/rx.opt:99
-#, fuzzy
  msgid "Enable linker relaxation."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c ÐºÐ»Ñ\8eÑ\87 -relax Ð¿Ñ\80Ð¸ ÐºÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²ÐºÐµ"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¾Ñ\81Ð»Ð°Ð±Ð»ÐµÐ½Ð¸Ñ\8f ÐºÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²Ñ\89Ð¸ÐºÐ¾Ð¼."
  
  #: config/rx/rx.opt:105
  msgid "Maximum size in bytes of constant values allowed as operands."
-msgstr ""
+msgstr "Максимальный размер в байтах константных величин допустимых в качестве операндов."
  
  #: config/rx/rx.opt:111
-#, fuzzy
  msgid "Specifies the number of registers to reserve for interrupt handlers."
-msgstr "Ð ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80 Ð´Ð»Ñ\8f PIC-Ð°Ð´Ñ\80ÐµÑ\81Ð°Ñ\86Ð¸Ð¸"
+msgstr "Ð\97Ð°Ð´Ð°ÐµÑ\82 Ñ\87Ð¸Ñ\81Ð»Ð¾ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð² Ñ\80ÐµÐ·ÐµÑ\80Ð²Ð¸Ñ\80Ñ\83ÐµÐ¼Ñ\8bÑ\85 Ð´Ð»Ñ\8f Ð¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82Ñ\87Ð¸ÐºÐ¾Ð² Ð¿Ñ\80ÐµÑ\80Ñ\8bÐ²Ð°Ð½Ð¸Ð¹."
  
  #: config/rx/rx.opt:117
  msgid "Specifies whether interrupt functions should save and restore the accumulator register."
-msgstr ""
+msgstr "Специфицирует должны ли функции прерываний сохранять и восстанавливать регистр сумматора."
  
  #: config/rx/rx.opt:123
  msgid "Enables Position-Independent-Data (PID) mode."
-msgstr ""
+msgstr "Включить режим позиционно-независимых данных (PID)."
  
  #: config/rx/rx.opt:129
  msgid "Warn when multiple, different, fast interrupt handlers are in the compilation unit."
@@ -13265,6 +13912,7 @@ msgstr ""
  
  #: config/rx/rx.opt:145
  #, fuzzy
+#| msgid "Enable the use of the short load instructions"
  msgid "Enable the use of the LRA register allocator."
  msgstr "Включить использование коротких команд загрузки"
  
@@ -13294,12 +13942,13 @@ msgstr "Компоновать с libsim.a, libc.a и sim-crt0.o"
  #, fuzzy
  #| msgid "Use hardware FP"
  msgid "Use hardware FP (default)."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐ¹ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ñ\81Ñ\82ÐµÐºÐ°"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\83Ñ\8e Ð²ÐµÑ\89ÐµÑ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\83Ñ\8e Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÑ\83"
  
  #: config/visium/visium.opt:65
  #, fuzzy
+#| msgid "Generate code for CR16C+ architecture (Default)"
  msgid "Generate code for the supervisor mode (default)."
-msgstr "Генерировать код для GNU-ассемблера (gas)"
+msgstr "Генерировать код для CR16C+ архитектуры (По умолчанию)"
  
  #: config/visium/visium.opt:69
  #, fuzzy
@@ -13308,13 +13957,14 @@ msgid "Generate code for the user mode."
  msgstr "Генерировать код для сборщика мусора Boehm"
  
  #: config/visium/visium.opt:73
+#, fuzzy
+#| msgid "Does nothing. Preserved for backward compatibility."
  msgid "Only retained for backward compatibility."
-msgstr ""
+msgstr "Игнорируется. Сохранен для обратной совместимости."
  
  #: config/fused-madd.opt:22
-#, fuzzy
  msgid "%<-mfused-madd%> is deprecated; use %<-ffp-contract=%> instead"
-msgstr "ÐÑ\82Ð¾Ñ\82 ÐºÐ»Ñ\8eÑ\87 Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ»; Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -Wextra."
+msgstr "Ð\9aÐ»Ñ\8eÑ\87 %<-mfused-madd%> Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ»; Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ %<-ffp-contract=%>."
  
  #: config/sol2.opt:32
  msgid "Clear hardware capabilities when linking."
@@ -13322,8 +13972,9 @@ msgstr ""
  
  #: config/sol2.opt:36
  #, fuzzy
+#| msgid "Pass -z text to linker"
  msgid "Pass -z text to linker."
-msgstr "Передать компоновщику ключ -assert pure-text"
+msgstr "Передать компоновщику ключ -z"
  
  #: config/moxie/moxie.opt:31
  #, fuzzy
@@ -13333,33 +13984,39 @@ msgstr "Использовать команды MPY||ADD, MPY||SUB"
  
  #: config/microblaze/microblaze.opt:40
  #, fuzzy
+#| msgid "Use software emulation for floating point (default)"
  msgid "Use software emulation for floating point (default)."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ð½Ñ\83Ñ\8e Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ð½Ñ\83Ñ\8e Ñ\8dÐ¼Ñ\83Ð»Ñ\8fÑ\86Ð¸Ñ\8e Ð´Ð»Ñ\8f Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ (Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ðµ)"
  
  #: config/microblaze/microblaze.opt:44
  #, fuzzy
+#| msgid "Use hardware floating point instructions"
  msgid "Use hardware floating point instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° paired-single (Ð½Ð°Ð´ Ð¿Ð°Ñ\80Ð°Ð¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸)"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
  
  #: config/microblaze/microblaze.opt:48
  #, fuzzy
+#| msgid "Use table lookup optimization for small signed integer divisions"
  msgid "Use table lookup optimization for small signed integer divisions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\86Ð¸ÐºÐ»Ð¾Ð² Ð½Ð° Ð´Ñ\80ÐµÐ²Ð¾Ð²Ð¸Ð´Ð½Ð¾Ð¼ Ð¿Ñ\80ÐµÐ´Ñ\81Ñ\82Ð°Ð²Ð»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿Ñ\80Ð¾Ñ\81Ð¼Ð¾Ñ\82Ñ\80Ð° Ñ\82Ð°Ð±Ð»Ð¸Ñ\86 Ð´Ð»Ñ\8f Ð´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð½ÐµÐ±Ð¾Ð»Ñ\8cÑ\88Ð¸Ñ\85 Ñ\86ÐµÐ»Ñ\8bÑ\85 Ñ\81Ð¾ Ð·Ð½Ð°ÐºÐ¾Ð¼"
  
  #: config/microblaze/microblaze.opt:52
  #, fuzzy
+#| msgid "-mcpu=PROCESSOR\t\tUse features of and schedule code for given CPU"
  msgid "-mcpu=PROCESSOR\t\tUse features of and schedule code for given CPU."
-msgstr "Использовать свойства указанного процессора и планировать код для него"
+msgstr "-mcpu=PROCESSOR\t\tИспользовать возможности и планировать код для заданного CPU"
  
  #: config/microblaze/microblaze.opt:56
  #, fuzzy
+#| msgid "Don't optimize block moves, use memcpy"
  msgid "Don't optimize block moves, use memcpy."
-msgstr "Не оптимизировать блочные пересылки"
+msgstr "Не оптимизировать блочные пересылки, использовать memcpy"
  
  #: config/microblaze/microblaze.opt:68
  #, fuzzy
+#| msgid "Use the soft multiply emulation (default)"
  msgid "Use the soft multiply emulation (default)."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ð½Ñ\83Ñ\8e Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ð½Ñ\83Ñ\8e Ñ\8dÐ¼Ñ\83Ð»Ñ\8fÑ\86Ð¸Ñ\8e Ñ\83Ð¼Ð½Ð¾Ð¶ÐµÐ½Ð¸Ñ\8f (Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ðµ)"
  
  #: config/microblaze/microblaze.opt:72
  msgid "Use reorder instructions (swap and byte reversed load/store) (default)."
@@ -13367,27 +14024,32 @@ msgstr ""
  
  #: config/microblaze/microblaze.opt:76
  #, fuzzy
+#| msgid "Use the software emulation for divides (default)"
  msgid "Use the software emulation for divides (default)."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ð½Ñ\83Ñ\8e Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ð½Ñ\83Ñ\8e Ñ\8dÐ¼Ñ\83Ð»Ñ\8fÑ\86Ð¸Ñ\8e Ð´Ð»Ñ\8f Ð´ÐµÐ»ÐµÐ½Ð¸Ð¹ (Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ðµ)"
  
  #: config/microblaze/microblaze.opt:80
+#, fuzzy
+#| msgid "Use the hardware barrel shifter instead of emulation"
  msgid "Use the hardware barrel shifter instead of emulation."
-msgstr ""
+msgstr "Использовать аппаратное устройство циклического сдвига вместо эмуляции"
  
  #: config/microblaze/microblaze.opt:84
  #, fuzzy
+#| msgid "Use pattern compare instructions"
  msgid "Use pattern compare instructions."
-msgstr "Использовать инструкции двойной точности плавающих вычислений"
+msgstr "Использовать инструкции сравнения шаблонов"
  
  #: config/microblaze/microblaze.opt:87
-#, fuzzy, c-format
+#, c-format
  msgid "%qs is deprecated; use -fstack-check"
-msgstr "имя %qs будет исключено в будущих версиях"
+msgstr "%qs устарело; используйте -fstack-check"
  
  #: config/microblaze/microblaze.opt:88
  #, fuzzy
+#| msgid "Check for stack overflow at runtime"
  msgid "Check for stack overflow at runtime."
-msgstr "Ð\9fÑ\80Ð¾Ð²ÐµÑ\80Ð¸Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð½Ð° Ð½Ð°Ð»Ð¸Ñ\87Ð¸Ðµ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ñ\85 Ð¾Ñ\88Ð¸Ð±Ð¾Ðº Ð¸ Ð·Ð°Ð²ÐµÑ\80Ñ\88Ð¸Ñ\82Ñ\8c Ñ\80Ð°Ð±Ð¾Ñ\82Ñ\83"
+msgstr "Ð\9fÑ\80Ð¾Ð²ÐµÑ\80Ð¸Ñ\82Ñ\8c Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ñ\81Ñ\82ÐµÐºÐ° Ð²Ð¾ Ð²Ñ\80ÐµÐ¼Ñ\8f Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8f"
  
  #: config/microblaze/microblaze.opt:92 config/iq2000/iq2000.opt:65
  #, fuzzy
@@ -13398,41 +14060,55 @@ msgstr "Использовать секции sdata/sbss, адресуемые 
  #: config/microblaze/microblaze.opt:95
  #, c-format
  msgid "%qs is deprecated; use -fno-zero-initialized-in-bss"
-msgstr ""
+msgstr "%qs устарело; используйте -fno-zero-initialized-in-bss"
  
  #: config/microblaze/microblaze.opt:96
+#, fuzzy
+#| msgid "Clear the BSS to zero and place zero initialized in BSS"
  msgid "Clear the BSS to zero and place zero initialized in BSS."
-msgstr ""
+msgstr "Зачистить BSS нулями и поместить инициализированные нулями в BSS"
  
  #: config/microblaze/microblaze.opt:100
+#, fuzzy
+#| msgid "Use multiply high instructions for high part of 32x32 multiply"
  msgid "Use multiply high instructions for high part of 32x32 multiply."
-msgstr ""
+msgstr "Использовать multiply high инструкции для high части 32x32 умножения"
  
  #: config/microblaze/microblaze.opt:104
  #, fuzzy
+#| msgid "Use hardware floating point conversion instructions"
  msgid "Use hardware floating point conversion instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° paired-single (Ð½Ð°Ð´ Ð¿Ð°Ñ\80Ð°Ð¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸)"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ñ\87Ð¸Ñ\81ÐµÐ» Ñ\81 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹"
  
  #: config/microblaze/microblaze.opt:108
  #, fuzzy
+#| msgid "Use hardware floating point square root instruction"
  msgid "Use hardware floating point square root instruction."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° paired-single (Ð½Ð°Ð´ Ð¿Ð°Ñ\80Ð°Ð¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸)"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ð¸Ð·Ð²Ð»ÐµÑ\87ÐµÐ½Ð¸Ñ\8f ÐºÐ²Ð°Ð´Ñ\80Ð°Ñ\82Ð½Ð¾Ð³Ð¾ ÐºÐ¾Ñ\80Ð½Ñ\8f"
  
  #: config/microblaze/microblaze.opt:112
+#, fuzzy
+#| msgid "Description for mxl-mode-executable"
  msgid "Description for mxl-mode-executable."
-msgstr ""
+msgstr "Описание для mxl-mode-executable"
  
  #: config/microblaze/microblaze.opt:116
+#, fuzzy
+#| msgid "Description for mxl-mode-xmdstub"
  msgid "Description for mxl-mode-xmdstub."
-msgstr ""
+msgstr "Описание для mxl-mode-xmdstub"
  
  #: config/microblaze/microblaze.opt:120
+#, fuzzy
+#| msgid "Description for mxl-mode-bootstrap"
  msgid "Description for mxl-mode-bootstrap."
-msgstr ""
+msgstr "Описание для mxl-mode-bootstrap"
  
  #: config/microblaze/microblaze.opt:124
+#, fuzzy
+#| msgid "Description for mxl-mode-novectors"
  msgid "Description for mxl-mode-novectors."
-msgstr ""
+msgstr "Описание для mxl-mode-novectors"
  
  #: config/microblaze/microblaze.opt:128
  #, fuzzy
@@ -13472,8 +14148,9 @@ msgstr "Использовать соглашения о структурах VA
  
  #: config/vax/vax.opt:51
  #, fuzzy
+#| msgid "Use new adddi3/subdi3 patterns"
  msgid "Use new adddi3/subdi3 patterns."
-msgstr "Использовать шаблоны для 16-битного abs"
+msgstr "Использовать новые шаблоны adddi3/subdi3"
  
  #: config/frv/frv.opt:30
  #, fuzzy
@@ -13537,7 +14214,7 @@ msgstr "Имя целевого процессора"
  
  #: config/frv/frv.opt:73
  msgid "Known FR-V CPUs (for use with the -mcpu= option):"
-msgstr ""
+msgstr "Имена процессоров FR-V (могут использоваться как аргументы ключа -mcpu= ):"
  
  #: config/frv/frv.opt:122
  #, fuzzy
@@ -13703,8 +14380,9 @@ msgstr "Генерировать код для процессора AM33/2.0"
  
  #: config/mn10300/mn10300.opt:38
  #, fuzzy
+#| msgid "Target the AM34 processor"
  msgid "Target the AM34 processor."
-msgstr "Генерировать код для процессора AM33"
+msgstr "Генерировать код для процессора AM34"
  
  #: config/mn10300/mn10300.opt:46
  #, fuzzy
@@ -13726,16 +14404,19 @@ msgstr "Возвращать указатели и на a0 и на d0"
  
  #: config/mn10300/mn10300.opt:63
  #, fuzzy
+#| msgid "Allow gcc to generate LIW instructions"
  msgid "Allow gcc to generate LIW instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b RTPB"
+msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ ÐºÐ¾Ð¼Ð°Ð½Ð´ LIW"
  
  #: config/mn10300/mn10300.opt:67
  #, fuzzy
+#| msgid "Allow gcc to generate the SETLB and Lcc instructions"
  msgid "Allow gcc to generate the SETLB and Lcc instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b RTPB"
+msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ ÐºÐ¾Ð¼Ð°Ð½Ð´ SETLB Ð¸ Lcc"
  
  #: config/nds32/nds32.opt:26
  #, fuzzy
+#| msgid "Generate code in big endian mode"
  msgid "Generate code in big-endian mode."
  msgstr "Генерировать код для прямого (big endian) порядка байт"
  
@@ -13759,13 +14440,15 @@ msgstr "Планировать код перед распределением р
  
  #: config/nds32/nds32.opt:42
  #, fuzzy
+#| msgid "enable conditional move instruction usage."
  msgid "Generate conditional move instructions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð²ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð³Ð¾ Ð¿ÐµÑ\80ÐµÐ¼ÐµÑ\89ÐµÐ½Ð¸Ñ\8f."
  
  #: config/nds32/nds32.opt:46
  #, fuzzy
+#| msgid "Generate bit instructions"
  msgid "Generate performance extension instructions."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b isel"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð±Ð¸Ñ\82Ð¾Ð²Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: config/nds32/nds32.opt:50
  #, fuzzy
@@ -13775,8 +14458,9 @@ msgstr "Генерировать команды isel"
  
  #: config/nds32/nds32.opt:54
  #, fuzzy
+#| msgid "Generate bit instructions"
  msgid "Generate 16-bit instructions."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b isel"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð±Ð¸Ñ\82Ð¾Ð²Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: config/nds32/nds32.opt:58
  msgid "Specify the size of each interrupt vector, which must be 4 or 16."
@@ -13788,8 +14472,9 @@ msgstr ""
  
  #: config/nds32/nds32.opt:70
  #, fuzzy
+#| msgid "Known ARM architectures (for use with the -march= option):"
  msgid "Known arch types (for use with the -march= option):"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸: -mfpu=%s"
+msgstr "Ð\98Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐµ ARM Ð°Ñ\80Ñ\85Ð¸Ñ\82ÐµÐºÑ\82Ñ\83Ñ\80Ñ\8b (Ð´Ð»Ñ\8f Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ñ\81 -march= Ð¾Ð¿Ñ\86Ð¸ÐµÐ¹):"
  
  #: config/nds32/nds32.opt:83
  msgid "Specify the address generation strategy for code model."
@@ -13797,8 +14482,9 @@ msgstr ""
  
  #: config/nds32/nds32.opt:87
  #, fuzzy
+#| msgid "Known code models (for use with the -mcmodel= option):"
  msgid "Known cmodel types (for use with the -mcmodel= option):"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸: -mfpu=%s"
+msgstr "Ð\98Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐµ Ð¼Ð¾Ð´ÐµÐ»Ð¸ ÐºÐ¾Ð´Ð° (Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mcmodel= ):"
  
  #: config/nds32/nds32.opt:100
  #, fuzzy
@@ -13826,7 +14512,7 @@ msgstr "Процессор, для которого осуществляется
  
  #: config/iq2000/iq2000.opt:51
  msgid "Known IQ2000 CPUs (for use with the -mcpu= option):"
-msgstr ""
+msgstr "Известные IQ2000 CPUs (для использования с -mcpu= опцией):"
  
  #: config/iq2000/iq2000.opt:61 config/mips/mips.opt:142
  #, fuzzy
@@ -13848,17 +14534,19 @@ msgstr "Размещать неинициализированные конста
  
  #: config/c6x/c6x-tables.opt:24
  msgid "Known C6X ISAs (for use with the -march= option):"
-msgstr ""
+msgstr "Известные C6X ISAs (для использования с -march= опцией):"
  
  #: config/c6x/c6x.opt:46
  #, fuzzy
+#| msgid "Valid arguments for the -msdata= option"
  msgid "Valid arguments for the -msdata= option."
-msgstr "Ð\9fÐµÑ\80ÐµÐ´Ð°Ð²Ð°Ñ\82Ñ\8c Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ð² Ñ\81Ñ\82ÐµÐºÐµ"
+msgstr "Ð\9aÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ð´Ð»Ñ\8f -msdata= Ð¾Ð¿Ñ\86Ð¸Ð¸"
  
  #: config/c6x/c6x.opt:59
  #, fuzzy
+#| msgid "Compile for the DSBT shared library ABI"
  msgid "Compile for the DSBT shared library ABI."
-msgstr "Ð\9fÐ¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°Ñ\82Ñ\8c Ñ\80Ð°Ð·Ð´ÐµÐ»Ñ\8fÐµÐ¼Ñ\8bÐµ Ð±Ð¸Ð±Ð»Ð¸Ð¾Ñ\82ÐµÐºÐ¸ Ð½Ð° Ð¾Ñ\81Ð½Ð¾Ð²Ðµ ID"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¸Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð´Ð»Ñ\8f ABI DSBT Ñ\80Ð°Ð·Ð´ÐµÐ»Ñ\8fÐµÐ¼Ñ\8bÑ\85 Ð±Ð¸Ð±Ð»Ð¸Ð¾Ñ\82ÐµÐº"
  
  #: config/cris/linux.opt:27
  #, fuzzy
@@ -13952,18 +14640,21 @@ msgstr "Отменить -mbest-lib-options"
  
  #: config/cris/cris.opt:165
  #, fuzzy
+#| msgid "-march=ARCH\tGenerate code for the specified chip or CPU version"
  msgid "-march=ARCH\tGenerate code for the specified chip or CPU version."
-msgstr "Генерировать код для указанного процессора или версии процессора"
+msgstr "-march=ARCH\tГенерировать код для указанной микросхемы или версии CPU"
  
  #: config/cris/cris.opt:169
  #, fuzzy
+#| msgid "-mtune=ARCH\tTune alignment for the specified chip or CPU version"
  msgid "-mtune=ARCH\tTune alignment for the specified chip or CPU version."
-msgstr "Делать выравнивание для указанного процессора или версии процессора"
+msgstr "-mtune=ARCH\tНастроить выравнивание для указанной микросхемы или версии CPU"
  
  #: config/cris/cris.opt:173
  #, fuzzy
+#| msgid "-mmax-stackframe=SIZE\tWarn when a stackframe is larger than the specified size"
  msgid "-mmax-stackframe=SIZE\tWarn when a stackframe is larger than the specified size."
-msgstr "Предупреждать, если кадр стека превышает указанный размер"
+msgstr "-mmax-stackframe=SIZE\tПредупреждать если кадр стека превышает указанный размер"
  
  #: config/cris/cris.opt:180
  msgid "Emit traps as \"break 8\", default for CRIS v3 and up.  If disabled, calls to abort() are used."
@@ -13979,11 +14670,11 @@ msgstr ""
  
  #: config/sh/superh.opt:6
  msgid "Board name [and memory region]."
-msgstr ""
+msgstr "Имя платы [и области памяти]."
  
  #: config/sh/superh.opt:10
  msgid "Runtime name."
-msgstr ""
+msgstr "Имя времени выполнения."
  
  #: config/sh/sh.opt:48
  #, fuzzy
@@ -13999,8 +14690,9 @@ msgstr "Генерировать код SH2"
  
  #: config/sh/sh.opt:56
  #, fuzzy
+#| msgid "Generate default double-precision SH2a-FPU code"
  msgid "Generate default double-precision SH2a-FPU code."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ SH2a Ñ\81 Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ñ\8cÑ\8e Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ ÐºÐ¾Ð´ Ð´Ð²Ð¾Ð¹Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸ SH2a-FPU"
  
  #: config/sh/sh.opt:60
  #, fuzzy
@@ -14010,13 +14702,15 @@ msgstr "Генерировать код для SH2a без FPU"
  
  #: config/sh/sh.opt:64
  #, fuzzy
+#| msgid "Generate default single-precision SH2a-FPU code"
  msgid "Generate default single-precision SH2a-FPU code."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ SH2a Ñ\81 Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ñ\8cÑ\8e Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ ÐºÐ¾Ð´ Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸ SH2a-FPU"
  
  #: config/sh/sh.opt:68
  #, fuzzy
+#| msgid "Generate only single-precision SH2a-FPU code"
  msgid "Generate only single-precision SH2a-FPU code."
-msgstr "Генерировать только код SH2a с одинарной точностью"
+msgstr "Генерировать только код одинарной точности SH2a-FPU"
  
  #: config/sh/sh.opt:72
  #, fuzzy
@@ -14044,18 +14738,21 @@ msgstr "Генерировать код SH4"
  
  #: config/sh/sh.opt:88
  #, fuzzy
+#| msgid "Generate SH4-100 code"
  msgid "Generate SH4-100 code."
-msgstr "Генерировать код SH1"
+msgstr "Генерировать код SH4-100"
  
  #: config/sh/sh.opt:92
  #, fuzzy
+#| msgid "Generate SH4-200 code"
  msgid "Generate SH4-200 code."
-msgstr "Генерировать код SH2"
+msgstr "Генерировать код SH4-200"
  
  #: config/sh/sh.opt:98
  #, fuzzy
+#| msgid "Generate SH4-300 code"
  msgid "Generate SH4-300 code."
-msgstr "Генерировать код SH3"
+msgstr "Генерировать код SH4-300"
  
  #: config/sh/sh.opt:102
  #, fuzzy
@@ -14065,33 +14762,37 @@ msgstr "Генерировать код для SH4 без FPU"
  
  #: config/sh/sh.opt:106
  #, fuzzy
+#| msgid "Generate SH4-100 FPU-less code"
  msgid "Generate SH4-100 FPU-less code."
-msgstr "Генерировать код для SH4 без FPU"
+msgstr "Генерировать код для SH4-100 без FPU"
  
  #: config/sh/sh.opt:110
  #, fuzzy
+#| msgid "Generate SH4-200 FPU-less code"
  msgid "Generate SH4-200 FPU-less code."
-msgstr "Генерировать код для SH4 без FPU"
+msgstr "Генерировать код для SH4-200 без FPU"
  
  #: config/sh/sh.opt:114
  #, fuzzy
+#| msgid "Generate SH4-300 FPU-less code"
  msgid "Generate SH4-300 FPU-less code."
-msgstr "Генерировать код для SH4 без FPU"
+msgstr "Генерировать код для SH4-300 без FPU"
  
  #: config/sh/sh.opt:118
  #, fuzzy
+#| msgid "Generate code for SH4 340 series (MMU/FPU-less)"
  msgid "Generate code for SH4 340 series (MMU/FPU-less)."
-msgstr "Генерировать код для процессора C30"
+msgstr "Генерировать код для SH4 340 серии (без MMU/FPU)"
  
  #: config/sh/sh.opt:123
  #, fuzzy
+#| msgid "Generate code for SH4 400 series (MMU/FPU-less)"
  msgid "Generate code for SH4 400 series (MMU/FPU-less)."
-msgstr "Генерировать код для процессора C40"
+msgstr "Генерировать код для SH4 400 серии (без MMU/FPU)"
  
  #: config/sh/sh.opt:128
-#, fuzzy
  msgid "Generate code for SH4 500 series (FPU-less)."
-msgstr "Генерировать код для процессора C40"
+msgstr "Генерировать код для SH4 500 серии (без FPU)."
  
  #: config/sh/sh.opt:133
  #, fuzzy
@@ -14101,18 +14802,21 @@ msgstr "Генерировать код SH4 с одинарной точност
  
  #: config/sh/sh.opt:137
  #, fuzzy
+#| msgid "Generate default single-precision SH4-100 code"
  msgid "Generate default single-precision SH4-100 code."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ SH4 Ñ\81 Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ñ\8cÑ\8e Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸ю"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ ÐºÐ¾Ð´ SH4-100 Ñ\81 Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ñ\8cю"
  
  #: config/sh/sh.opt:141
  #, fuzzy
+#| msgid "Generate default single-precision SH4-200 code"
  msgid "Generate default single-precision SH4-200 code."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ SH4 Ñ\81 Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ñ\8cÑ\8e Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸ю"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ ÐºÐ¾Ð´ SH4-200 Ñ\81 Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ñ\8cю"
  
  #: config/sh/sh.opt:145
  #, fuzzy
+#| msgid "Generate default single-precision SH4-300 code"
  msgid "Generate default single-precision SH4-300 code."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ SH4 Ñ\81 Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ñ\8cÑ\8e Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸ю"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ ÐºÐ¾Ð´ SH4-300 Ñ\81 Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ñ\8cю"
  
  #: config/sh/sh.opt:149
  #, fuzzy
@@ -14122,18 +14826,21 @@ msgstr "Генерировать только код SH4 с одинарной 
  
  #: config/sh/sh.opt:153
  #, fuzzy
+#| msgid "Generate only single-precision SH4-100 code"
  msgid "Generate only single-precision SH4-100 code."
-msgstr "Генерировать только код SH4 с одинарной точностью"
+msgstr "Генерировать только код SH4-100 с одинарной точностью"
  
  #: config/sh/sh.opt:157
  #, fuzzy
+#| msgid "Generate only single-precision SH4-200 code"
  msgid "Generate only single-precision SH4-200 code."
-msgstr "Генерировать только код SH4 с одинарной точностью"
+msgstr "Генерировать только код SH4-200 с одинарной точностью"
  
  #: config/sh/sh.opt:161
  #, fuzzy
+#| msgid "Generate only single-precision SH4-300 code"
  msgid "Generate only single-precision SH4-300 code."
-msgstr "Генерировать только код SH4 с одинарной точностью"
+msgstr "Генерировать только код SH4-300 с одинарной точностью"
  
  #: config/sh/sh.opt:165
  #, fuzzy
@@ -14185,38 +14892,45 @@ msgstr "Генерировать 64-битный код для SHmedia"
  
  #: config/sh/sh.opt:197
  #, fuzzy
+#| msgid "Generate 64-bit FPU-less SHmedia code"
  msgid "Generate 64-bit FPU-less SHmedia code."
-msgstr "Генерировать код для обратного порядка байт (big endian)"
+msgstr "Генерировать 64-битный SHmedia код без FPU"
  
  #: config/sh/sh.opt:201
  #, fuzzy
+#| msgid "Generate SHcompact code"
  msgid "Generate SHcompact code."
-msgstr "Генерировать код SA"
+msgstr "Генерировать код SHcompact"
  
  #: config/sh/sh.opt:205
  #, fuzzy
+#| msgid "Generate FPU-less SHcompact code"
  msgid "Generate FPU-less SHcompact code."
-msgstr "Генерировать код относительно pc"
+msgstr "Генерировать SHcompact код без FPU"
  
  #: config/sh/sh.opt:217
  #, fuzzy
+#| msgid "Generate code in big endian mode"
  msgid "Generate code in big endian mode."
  msgstr "Генерировать код для прямого (big endian) порядка байт"
  
  #: config/sh/sh.opt:221
  #, fuzzy
+#| msgid "Generate 32-bit offsets in switch tables"
  msgid "Generate 32-bit offsets in switch tables."
-msgstr "Генерировать 4-байтные элементы в таблицах переключателей"
+msgstr "Генерировать 32-битные смещения в таблицах переключателей"
  
  #: config/sh/sh.opt:225
  #, fuzzy
+#| msgid "Generate bit instructions"
  msgid "Generate bit instructions."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b isel"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð±Ð¸Ñ\82Ð¾Ð²Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: config/sh/sh.opt:229
  #, fuzzy
+#| msgid "Cost to assume for a branch insn"
  msgid "Cost to assume for a branch insn."
-msgstr "Ð¦ÐµÐ½Ð° Ð´Ð»Ñ\8f Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ gettr"
+msgstr "Ð\9fÑ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð°Ñ\8f Ñ\86ÐµÐ½Ð° Ð´Ð»Ñ\8f Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð²ÐµÑ\82Ð²Ð»ÐµÐ½Ð¸Ñ\8f"
  
  #: config/sh/sh.opt:233
  msgid "Assume that zero displacement conditional branches are fast."
@@ -14229,29 +14943,36 @@ msgid "%qs is deprecated and has no effect"
  msgstr "Устаревший ключ. Игнорируется."
  
  #: config/sh/sh.opt:237
+#, fuzzy
+#| msgid "Enable cbranchdi4 pattern"
  msgid "Enable cbranchdi4 pattern."
-msgstr ""
+msgstr "Включить cbranchdi4 шаблон"
  
  #: config/sh/sh.opt:241
  msgid "Emit cmpeqdi_t pattern even when -mcbranchdi is in effect."
-msgstr ""
+msgstr "Выдавать cmpeqdi_t шаблон даже если -mcbranchdi действует."
  
  #: config/sh/sh.opt:245
  msgid "Force the usage of delay slots for conditional branches."
  msgstr ""
  
  #: config/sh/sh.opt:249
+#, fuzzy
+#| msgid "Enable SH5 cut2 workaround"
  msgid "Enable SH5 cut2 workaround."
-msgstr ""
+msgstr "Включить SH5 cut2 обход"
  
  #: config/sh/sh.opt:253
  #, fuzzy
+#| msgid "Align doubles at 64-bit boundaries"
  msgid "Align doubles at 64-bit boundaries."
-msgstr "Ð\92Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ñ\82Ñ\8c Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÐµ Ð¿Ð¾ Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ðµ 16 Ð±Ð¸Ñ\82"
+msgstr "Ð\92Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ñ\82Ñ\8c Ð´Ð²Ð¾Ð¹Ð½Ñ\8bÐµ Ð¿Ð¾ 64-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ð°Ð¼"
  
  #: config/sh/sh.opt:257
+#, fuzzy
+#| msgid "Division strategy, one of: call, call2, fp, inv, inv:minlat, inv20u, inv20l, inv:call, inv:call2, inv:fp, call-div1, call-fp, call-table"
  msgid "Division strategy, one of: call, call2, fp, inv, inv:minlat, inv20u, inv20l, inv:call, inv:call2, inv:fp, call-div1, call-fp, call-table."
-msgstr ""
+msgstr "Стратегии деления, одна из: call, call2, fp, inv, inv:minlat, inv20u, inv20l, inv:call, inv:call2, inv:fp, call-div1, call-fp, call-table"
  
  #: config/sh/sh.opt:261
  #, fuzzy
@@ -14267,7 +14988,7 @@ msgstr "Генерировать код для LP64"
  
  #: config/sh/sh.opt:269
  msgid "Enable the use of 64-bit floating point registers in fmov instructions.  See -mdalign if 64-bit alignment is required."
-msgstr ""
+msgstr "Включить использование 64-битных плавающих регистров в fmov инструкциях.  См. -mdalign если 64-битное выравнивание требуется."
  
  #: config/sh/sh.opt:277
  #, fuzzy
@@ -14283,17 +15004,21 @@ msgstr "Следовать соглашениям о вызовах Renesas (б
  
  #: config/sh/sh.opt:285
  #, fuzzy
+#| msgid "Increase the IEEE compliance for floating-point comparisons"
  msgid "Increase the IEEE compliance for floating-point comparisons."
-msgstr "Увеличить соответствие кода для плавающей арифметики стандарту IEEE"
+msgstr "Увеличить IEEE соответствие для сравнений с плавающей точкой"
  
  #: config/sh/sh.opt:289
+#, fuzzy
+#| msgid "Enable the use of the indexed addressing mode for SHmedia32/SHcompact"
  msgid "Enable the use of the indexed addressing mode for SHmedia32/SHcompact."
-msgstr ""
+msgstr "Включить использование режима индексной адресации для SHmedia32/SHcompact"
  
  #: config/sh/sh.opt:293
  #, fuzzy
+#| msgid "inline code to invalidate instruction cache entries after setting up nested function trampolines"
  msgid "inline code to invalidate instruction cache entries after setting up nested function trampolines."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð²Ñ\8bÐ·Ð¾Ð² Ð±Ð¸Ð±Ð»Ð¸Ð¾Ñ\82ÐµÑ\87Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð´Ð»Ñ\8f Ñ\81Ð±Ñ\80Ð¾Ñ\81Ð° ÐºÑ\8dÑ\88Ð° Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð¿Ð¾Ñ\81Ð»Ðµ Ð¸Ñ\81Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ñ\82Ñ\80Ð°Ð¼Ð¿Ð»Ð¸Ð½Ð°"
+msgstr "Ð²Ñ\81Ñ\82Ð°Ð²Ð»Ñ\8fÑ\82Ñ\8c ÐºÐ¾Ð´ Ð´Ð»Ñ\8f Ð¸Ð½Ð²Ð°Ð»Ð¸Ð´Ð°Ñ\86Ð¸Ð¸ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð² ÐºÑ\8dÑ\88Ð° ÐºÐ¾Ð¼Ð°Ð½Ð´ Ð¿Ð¾Ñ\81Ð»Ðµ Ñ\83Ñ\81Ñ\82Ð°Ð½Ð¾Ð²ÐºÐ¸ Ñ\82Ñ\80Ð°Ð¼Ð¿Ð»Ð¸Ð½Ð¾Ð² Ð²Ð»Ð¾Ð¶ÐµÐ½Ð½Ñ\8bÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
  
  #: config/sh/sh.opt:297
  #, fuzzy
@@ -14302,8 +15027,10 @@ msgid "Assume symbols might be invalid."
  msgstr "Предполагать, что символы могут быть неправильными"
  
  #: config/sh/sh.opt:301 config/arc/arc.opt:209
+#, fuzzy
+#| msgid "Annotate assembler instructions with estimated addresses"
  msgid "Annotate assembler instructions with estimated addresses."
-msgstr ""
+msgstr "Аннотировать ассемблерные инструкции с оцененным адресом"
  
  #: config/sh/sh.opt:305
  #, fuzzy
@@ -14345,8 +15072,9 @@ msgstr ""
  
  #: config/sh/sh.opt:339
  #, fuzzy
+#| msgid "Generate code for built-in atomic operations"
  msgid "Specify the model for atomic operations."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð´Ð»Ñ\8f Ð¿Ñ\80Ñ\8fÐ¼Ð¾Ð³Ð¾ (big endian) Ð¿Ð¾Ñ\80Ñ\8fÐ´ÐºÐ° Ð±Ð°Ð¹Ñ\82"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð´Ð»Ñ\8f Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ñ\8bÑ\85 Ð°Ñ\82Ð¾Ð¼Ð°Ñ\80Ð½Ñ\8bÑ\85 Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¹"
  
  #: config/sh/sh.opt:343
  msgid "Use tas.b instruction for __atomic_test_and_set."
@@ -14354,8 +15082,9 @@ msgstr ""
  
  #: config/sh/sh.opt:347
  #, fuzzy
+#| msgid "Deprecated.  Use -Os instead"
  msgid "Deprecated.  Use -Os instead."
-msgstr "Ð\9aÐ»Ñ\8eÑ\87 Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ». Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -Os Ð² ÐºÐ°Ñ\87ÐµÑ\81Ñ\82Ð²Ðµ Ð·Ð°Ð¼ÐµÐ½Ñ\8b"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ñ\80ÐµÐ»Ð¾.  Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -Os Ð²Ð·Ð°Ð¼ÐµÐ½"
  
  #: config/sh/sh.opt:351
  #, fuzzy
@@ -14365,19 +15094,21 @@ msgstr "Цена за команду умножения"
  
  #: config/sh/sh.opt:355
  msgid "Don't generate privileged-mode only code; implies -mno-inline-ic_invalidate if the inline code would not work in user mode."
-msgstr ""
+msgstr "Не генерировать только привилегированный код; влечет -mno-inline-ic_invalidate если inline код не будет работать в пользовательском режиме."
  
  #: config/sh/sh.opt:361
  msgid "Pretend a branch-around-a-move is a conditional move."
-msgstr ""
+msgstr "Делать вид что branch-around-a-move есть условный move."
  
  #: config/sh/sh.opt:365
  #, fuzzy
+#| msgid "Enable the use of the short load instructions"
  msgid "Enable the use of the fsca instruction."
  msgstr "Включить использование коротких команд загрузки"
  
  #: config/sh/sh.opt:369
  #, fuzzy
+#| msgid "Enable the use of the short load instructions"
  msgid "Enable the use of the fsrra instruction."
  msgstr "Включить использование коротких команд загрузки"
  
@@ -14393,149 +15124,187 @@ msgstr "Предполагать малое адресное пространс
  
  #: config/mep/mep.opt:23
  #, fuzzy
+#| msgid "Enable absolute difference instructions"
  msgid "Enable absolute difference instructions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\82Ð°Ð½Ð¸Ñ\8f Ð°Ð±Ñ\81Ð¾Ð»Ñ\8eÑ\82Ð½Ñ\8bÑ\85 Ð²ÐµÐ»Ð¸Ñ\87Ð¸Ð½"
  
  #: config/mep/mep.opt:27
  #, fuzzy
+#| msgid "Enable all optional instructions"
  msgid "Enable all optional instructions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð²Ñ\81Ðµ Ð½ÐµÐ¾Ð±Ñ\8fÐ·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: config/mep/mep.opt:31
  #, fuzzy
+#| msgid "Enable average instructions"
  msgid "Enable average instructions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ñ\83Ñ\81Ñ\80ÐµÐ´Ð½ÐµÐ½Ð¸Ñ\8f"
  
  #: config/mep/mep.opt:35
+#, fuzzy
+#| msgid "Variables this size and smaller go in the based section. (default 0)"
  msgid "Variables this size and smaller go in the based section. (default 0)."
-msgstr ""
+msgstr "Переменные этого и меньшего размера отправляются в базированную секцию. (по умолчанию 0)"
  
  #: config/mep/mep.opt:39
  #, fuzzy
+#| msgid "Enable bit manipulation instructions"
  msgid "Enable bit manipulation instructions."
-msgstr "Включить инструкции умножения с накоплением с нечётким результатом"
+msgstr "Включить инструкции манипуляций с битами"
  
  #: config/mep/mep.opt:43
+#, fuzzy
+#| msgid "Section to put all const variables in (tiny, near, far) (no default)"
  msgid "Section to put all const variables in (tiny, near, far) (no default)."
-msgstr ""
+msgstr "Секция куда помещать все const переменные (tiny, near, far) (нет умолчанию)"
  
  #: config/mep/mep.opt:47
  #, fuzzy
+#| msgid "Enable clip instructions"
  msgid "Enable clip instructions."
-msgstr "Включить генерацию параллельного кода"
+msgstr "Включить clip инструкции"
  
  #: config/mep/mep.opt:51
+#, fuzzy
+#| msgid "Configuration name"
  msgid "Configuration name."
-msgstr ""
+msgstr "Имя конфигурации"
  
  #: config/mep/mep.opt:55
  #, fuzzy
+#| msgid "Enable MeP Coprocessor"
  msgid "Enable MeP Coprocessor."
-msgstr "Ð¢Ñ\80Ð°Ð´Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c MeP Ñ\81Ð¾Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80"
  
  #: config/mep/mep.opt:59
+#, fuzzy
+#| msgid "Enable MeP Coprocessor with 32-bit registers"
  msgid "Enable MeP Coprocessor with 32-bit registers."
-msgstr ""
+msgstr "Включить MeP сопроцессор с 32-битными регистрами"
  
  #: config/mep/mep.opt:63
+#, fuzzy
+#| msgid "Enable MeP Coprocessor with 64-bit registers"
  msgid "Enable MeP Coprocessor with 64-bit registers."
-msgstr ""
+msgstr "Включить MeP сопроцессор с 64-битными регистрами"
  
  #: config/mep/mep.opt:67
  #, fuzzy
+#| msgid "Enable IVC2 scheduling"
  msgid "Enable IVC2 scheduling."
-msgstr "Включить режим отладки"
+msgstr "Включить IVC2 планирование"
  
  #: config/mep/mep.opt:71
  #, fuzzy
+#| msgid "Const variables default to the near section"
  msgid "Const variables default to the near section."
-msgstr "слишком мало аргументов функции"
+msgstr "Const переменные по умолчанию помещаются в near секцию"
  
  #: config/mep/mep.opt:78
  #, fuzzy
+#| msgid "Enable 32-bit divide instructions"
  msgid "Enable 32-bit divide instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b деления"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ 32-Ð±Ð¸Ñ\82Ð½Ð¾Ð³Ð¾ деления"
  
  #: config/mep/mep.opt:93
+#, fuzzy
+#| msgid "__io vars are volatile by default"
  msgid "__io vars are volatile by default."
-msgstr ""
+msgstr "__io переменные volatile по умолчанию"
  
  #: config/mep/mep.opt:97
  #, fuzzy
+#| msgid "All variables default to the far section"
  msgid "All variables default to the far section."
-msgstr "Ð Ð°Ð·Ð¼ÐµÑ\89Ð°Ñ\82Ñ\8c Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ñ\8b Ð´Ð°Ð½Ð½Ñ\8bÑ\85 Ð² Ð¾Ñ\82Ð´ÐµÐ»Ñ\8cÐ½Ñ\8bÑ\85 Ñ\81ÐµÐºÑ\86Ð¸Ñ\8fÑ\85"
+msgstr "Ð\92Ñ\81Ðµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÐµ Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð² far Ñ\81ÐµÐºÑ\86Ð¸Ñ\8e"
  
  #: config/mep/mep.opt:101
  #, fuzzy
+#| msgid "Enable leading zero instructions"
  msgid "Enable leading zero instructions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ñ\81 Ð²ÐµÐ´Ñ\83Ñ\89Ð¸Ð¼ Ð½Ñ\83Ð»ÐµÐ¼"
  
  #: config/mep/mep.opt:108
  #, fuzzy
+#| msgid "All variables default to the near section"
  msgid "All variables default to the near section."
-msgstr "Ð Ð°Ð·Ð¼ÐµÑ\89Ð°Ñ\82Ñ\8c Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ñ\8b Ð´Ð°Ð½Ð½Ñ\8bÑ\85 Ð² Ð¾Ñ\82Ð´ÐµÐ»Ñ\8cÐ½Ñ\8bÑ\85 Ñ\81ÐµÐºÑ\86Ð¸Ñ\8fÑ\85"
+msgstr "Ð\92Ñ\81Ðµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÐµ Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð² near Ñ\81ÐµÐºÑ\86Ð¸Ñ\8e"
  
  #: config/mep/mep.opt:112
  #, fuzzy
+#| msgid "Enable min/max instructions"
  msgid "Enable min/max instructions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ min/max"
  
  #: config/mep/mep.opt:116
  #, fuzzy
+#| msgid "Enable 32-bit multiply instructions"
  msgid "Enable 32-bit multiply instructions."
-msgstr "Включить инструкции умножения с накоплением с нечётким результатом"
+msgstr "Включить инструкции 32-битного умножения"
  
  #: config/mep/mep.opt:120
  #, fuzzy
+#| msgid "Disable all optional instructions"
  msgid "Disable all optional instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b AltiVec"
+msgstr "Ð\92Ñ\8bÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð²Ñ\81Ðµ Ð½ÐµÐ¾Ð±Ñ\8fÐ·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: config/mep/mep.opt:127
  #, fuzzy
+#| msgid "Allow gcc to use the repeat/erepeat instructions"
  msgid "Allow gcc to use the repeat/erepeat instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b RTPB"
+msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c gcc Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c repeat/erepeat Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: config/mep/mep.opt:131
  #, fuzzy
+#| msgid "All variables default to the tiny section"
  msgid "All variables default to the tiny section."
-msgstr "Ð Ð°Ð·Ð¼ÐµÑ\89Ð°Ñ\82Ñ\8c Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ñ\8b Ð´Ð°Ð½Ð½Ñ\8bÑ\85 Ð² Ð¾Ñ\82Ð´ÐµÐ»Ñ\8cÐ½Ñ\8bÑ\85 Ñ\81ÐµÐºÑ\86Ð¸Ñ\8fÑ\85"
+msgstr "Ð\92Ñ\81Ðµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÐµ Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð² tiny Ñ\81ÐµÐºÑ\86Ð¸Ñ\8e"
  
  #: config/mep/mep.opt:135
  #, fuzzy
+#| msgid "Enable saturation instructions"
  msgid "Enable saturation instructions."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð½Ð°Ñ\81Ñ\8bÑ\89ÐµÐ½Ð¸Ñ\8f"
  
  #: config/mep/mep.opt:139
  #, fuzzy
+#| msgid "Use sdram version of runtime"
  msgid "Use sdram version of runtime."
-msgstr "Использовать среду запуска симулятора"
+msgstr "Использовать sdram версию поддержки времени выполнения"
  
  #: config/mep/mep.opt:147
  #, fuzzy
+#| msgid "Use simulator runtime without vectors"
  msgid "Use simulator runtime without vectors."
-msgstr "Использовать среду запуска симулятора"
+msgstr "Использовать поддержку времени выполнения симулятора без векторов"
  
  #: config/mep/mep.opt:151
  #, fuzzy
+#| msgid "All functions default to the far section"
  msgid "All functions default to the far section."
-msgstr "Ð\9fÐ¾Ð¼ÐµÑ\89Ð°Ñ\82Ñ\8c ÐºÐ°Ð¶Ð´Ñ\83Ñ\8e Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8e Ð² Ð¾Ñ\82Ð´ÐµÐ»Ñ\8cÐ½Ñ\83Ñ\8e секцию"
+msgstr "Ð\92Ñ\81Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð² far секцию"
  
  #: config/mep/mep.opt:155
+#, fuzzy
+#| msgid "Variables this size and smaller go in the tiny section. (default 4)"
  msgid "Variables this size and smaller go in the tiny section. (default 4)."
-msgstr ""
+msgstr "Переменные этого и меньшего размера отправляются в tiny секцию. (по умолчанию 4)"
  
  #: config/mips/mips.opt:32
  #, fuzzy
+#| msgid "-mabi=ABI\tGenerate code that conforms to the given ABI"
  msgid "-mabi=ABI\tGenerate code that conforms to the given ABI."
-msgstr "Генерировать код в соответствии с заданным ABI"
+msgstr "-mabi=ABI\tГенерировать код в соответствии с заданным ABI"
  
  #: config/mips/mips.opt:36
  msgid "Known MIPS ABIs (for use with the -mabi= option):"
-msgstr ""
+msgstr "MIPS ABI (возможные аргументы ключа -mabi=):"
  
  #: config/mips/mips.opt:55
+#, fuzzy
+#| msgid "Generate code that can be used in SVR4-style dynamic objects"
  msgid "Generate code that can be used in SVR4-style dynamic objects."
-msgstr ""
+msgstr "Генерировать код, который может использоваться в динамических объектах SVR4"
  
  #: config/mips/mips.opt:59
  #, fuzzy
@@ -14551,13 +15320,15 @@ msgstr "Использовать команды плавающего умнож
  
  #: config/mips/mips.opt:67
  #, fuzzy
+#| msgid "-march=ISA\tGenerate code for the given ISA"
  msgid "-march=ISA\tGenerate code for the given ISA."
-msgstr "Генерировать код для указанной системы команд (ISA)"
+msgstr "-march=ISA\tГенерировать код для указанной системы команд (ISA)"
  
  #: config/mips/mips.opt:71
  #, fuzzy
+#| msgid "-mbranch-cost=COST\tSet the cost of branches to roughly COST instructions"
  msgid "-mbranch-cost=COST\tSet the cost of branches to roughly COST instructions."
-msgstr "Установить цену переходов"
+msgstr "-mbranch-cost=COST\tУстановить цену переходов равной примерно COST команд"
  
  #: config/mips/mips.opt:75
  #, fuzzy
@@ -14566,8 +15337,10 @@ msgid "Use Branch Likely instructions, overriding the architecture default."
  msgstr "Использовать команды Branch Likely, вопреки умолчанию для указанной архитектуры"
  
  #: config/mips/mips.opt:79
+#, fuzzy
+#| msgid "Switch on/off MIPS16 ASE on alternating functions for compiler testing"
  msgid "Switch on/off MIPS16 ASE on alternating functions for compiler testing."
-msgstr ""
+msgstr "Включить/выключить MIPS16 ASE на альтернативных функциях для тестирования компилятора"
  
  #: config/mips/mips.opt:83
  #, fuzzy
@@ -14576,13 +15349,14 @@ msgid "Trap on integer divide by zero."
  msgstr "Выдавать прерывание по целочисленному делению на ноль"
  
  #: config/mips/mips.opt:87
+#, fuzzy
+#| msgid "-mcode-readable=SETTING\tSpecify when instructions are allowed to access code"
  msgid "-mcode-readable=SETTING\tSpecify when instructions are allowed to access code."
-msgstr ""
+msgstr "-mcode-readable=SETTING\tЗадать, когда команды имеют доступ к коду"
  
  #: config/mips/mips.opt:91
-#, fuzzy
  msgid "Valid arguments to -mcode-readable=:"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs"
+msgstr "Ð\94Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b ÐºÐ»Ñ\8eÑ\87Ð° -mcode-readable=:"
  
  #: config/mips/mips.opt:104
  #, fuzzy
@@ -14598,8 +15372,9 @@ msgstr "Проверка целочисленного деления на нол
  
  #: config/mips/mips.opt:112
  #, fuzzy
+#| msgid "Allow the use of MDMX instructions"
  msgid "Allow the use of MDMX instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 DB"
+msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ ÐºÐ¾Ð¼Ð°Ð½Ð´ MDMX"
  
  #: config/mips/mips.opt:116
  #, fuzzy
@@ -14615,8 +15390,9 @@ msgstr "Использовать команды MIPS-DSP"
  
  #: config/mips/mips.opt:124
  #, fuzzy
+#| msgid "Use MIPS-DSP REV 2 instructions"
  msgid "Use MIPS-DSP REV 2 instructions."
-msgstr "Использовать команды MIPS-DSP"
+msgstr "Использовать команды MIPS-DSP версии 2"
  
  #: config/mips/mips.opt:146
  #, fuzzy
@@ -14631,13 +15407,16 @@ msgid "Use NewABI-style %reloc() assembly operators."
  msgstr "Использовать ассемблерные команды %reloc()"
  
  #: config/mips/mips.opt:154
+#, fuzzy
+#| msgid "Use -G for data that is not defined by the current object"
  msgid "Use -G for data that is not defined by the current object."
-msgstr ""
+msgstr "Использовать -G для данных, которые не определены текущим объектом"
  
  #: config/mips/mips.opt:158
  #, fuzzy
+#| msgid "Work around certain 24K errata"
  msgid "Work around certain 24K errata."
-msgstr "Обходить некоторые ошибки процессора R4000"
+msgstr "Обходить некоторые ошибки процессора 24K"
  
  #: config/mips/mips.opt:162
  #, fuzzy
@@ -14659,8 +15438,9 @@ msgstr "Обходить некоторые ошибки процессора R4
  
  #: config/mips/mips.opt:174
  #, fuzzy
+#| msgid "Work around certain R10000 errata"
  msgid "Work around certain R10000 errata."
-msgstr "Обходить некоторые ошибки процессора R4000"
+msgstr "Обходить некоторые ошибки процессора R10000"
  
  #: config/mips/mips.opt:178
  #, fuzzy
@@ -14710,8 +15490,9 @@ msgstr "Использовать 64-битные регистры сопроце
  
  #: config/mips/mips.opt:210
  #, fuzzy
+#| msgid "-mflush-func=FUNC\tUse FUNC to flush the cache before calling stack trampolines"
  msgid "-mflush-func=FUNC\tUse FUNC to flush the cache before calling stack trampolines."
-msgstr "Использовать указанную функцию для сброса кэша перед вызовом стекового трамплина"
+msgstr "-mflush-func=ФУНКЦИЯ\tИспользовать указанную ФУНКЦИЮ для сброса кэша перед вызовом стековых трамплинов"
  
  #: config/mips/mips.opt:214
  msgid "-mabs=MODE\tSelect the IEEE 754 ABS/NEG instruction execution mode."
@@ -14723,8 +15504,9 @@ msgstr ""
  
  #: config/mips/mips.opt:222
  #, fuzzy
+#| msgid "Known MIPS CPUs (for use with the -march= and -mtune= options):"
  msgid "Known MIPS IEEE 754 settings (for use with the -mabs= and -mnan= options):"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸: -mfpu=%s"
+msgstr "Ð\98Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐµ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80Ñ\8b MIPS (Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð·Ð°Ð´Ð°Ð½Ñ\8b ÐºÐ°Ðº Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b -march= Ð¸ -mtune=)"
  
  #: config/mips/mips.opt:232
  #, fuzzy
@@ -14739,35 +15521,46 @@ msgid "Use 64-bit general registers."
  msgstr "Использовать 64-битные регистры общего назначения"
  
  #: config/mips/mips.opt:240
+#, fuzzy
+#| msgid "Use GP-relative addressing to access small data"
  msgid "Use GP-relative addressing to access small data."
-msgstr ""
+msgstr "Использовать адресацию относительно GP для доступа к данным малого размера"
  
  #: config/mips/mips.opt:244
+#, fuzzy
+#| msgid "When generating -mabicalls code, allow executables to use PLTs and copy relocations"
  msgid "When generating -mabicalls code, allow executables to use PLTs and copy relocations."
-msgstr ""
+msgstr "При генерации кода -mabicalls разрешить выполняемому модулю использование PLT и копирование перемещений"
  
  #: config/mips/mips.opt:248
  #, fuzzy
+#| msgid "Allow the use of hardware floating-point ABI and instructions"
  msgid "Allow the use of hardware floating-point ABI and instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐµ ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b для операций с плавающей точкой"
+msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÑ\85 ÐºÐ¾Ð¼Ð°Ð½Ð´ Ð¸ ABI для операций с плавающей точкой"
  
  #: config/mips/mips.opt:252
+#, fuzzy
+#| msgid "Generate code that can be safely linked with MIPS16 code."
  msgid "Generate code that is link-compatible with MIPS16 and microMIPS code."
-msgstr ""
+msgstr "Генерировать код, который может быть скомпонован с кодом MIPS16."
  
  #: config/mips/mips.opt:256
+#, fuzzy
+#| msgid "Does nothing. Preserved for backward compatibility."
  msgid "An alias for minterlink-compressed provided for backward-compatibility."
-msgstr ""
+msgstr "Игнорируется. Сохранен для обратной совместимости."
  
  #: config/mips/mips.opt:260
  #, fuzzy
+#| msgid "-mipsN\tGenerate code for ISA level N"
  msgid "-mipsN\tGenerate code for ISA level N."
-msgstr "Генерировать код для ассемблера ISA уровня N"
+msgstr "-mipsN\tГенерировать код для ассемблера ISA уровня N"
  
  #: config/mips/mips.opt:264
  #, fuzzy
+#| msgid "Generate MIPS16 code"
  msgid "Generate MIPS16 code."
-msgstr "Генерировать код SH1"
+msgstr "Генерировать код MIPS16"
  
  #: config/mips/mips.opt:268
  #, fuzzy
@@ -14777,12 +15570,15 @@ msgstr "Использовать команды MIPS-3D"
  
  #: config/mips/mips.opt:272
  #, fuzzy
+#| msgid "Use ll, sc and sync instructions"
  msgid "Use ll, sc and sync instructions."
-msgstr "Использовать команды плавающего умножения со сложением/вычитанием"
+msgstr "Использовать команды ll, sc и sync"
  
  #: config/mips/mips.opt:276
+#, fuzzy
+#| msgid "Use -G for object-local data"
  msgid "Use -G for object-local data."
-msgstr ""
+msgstr "Использовать -G для доступа к локальным данным модуля"
  
  #: config/mips/mips.opt:280
  #, fuzzy
@@ -14803,8 +15599,10 @@ msgid "Use a 64-bit long type."
  msgstr "Использовать 64-битное представление для типа long"
  
  #: config/mips/mips.opt:292
+#, fuzzy
+#| msgid "Pass the address of the ra save location to _mcount in $12"
  msgid "Pass the address of the ra save location to _mcount in $12."
-msgstr ""
+msgstr "Передать адрес, где сохранен ra функции _mcount в $12"
  
  #: config/mips/mips.opt:296
  #, fuzzy
@@ -14814,21 +15612,25 @@ msgstr "Не оптимизировать блочные пересылки"
  
  #: config/mips/mips.opt:300
  #, fuzzy
+#| msgid "Use SmartMIPS instructions"
  msgid "Use microMIPS instructions."
-msgstr "Использовать команды MIPS-3D"
+msgstr "Использовать команды SmartMIPS"
  
  #: config/mips/mips.opt:304
  #, fuzzy
+#| msgid "Allow the use of MT instructions"
  msgid "Allow the use of MT instructions."
-msgstr "Использовать команды RTPB"
+msgstr "Использовать команды MT"
  
  #: config/mips/mips.opt:308
  #, fuzzy
+#| msgid "Prevent the use of all floating-point operations"
  msgid "Prevent the use of all floating-point operations."
  msgstr "Не использовать аппаратную реализацию плавающих операций"
  
  #: config/mips/mips.opt:312
  #, fuzzy
+#| msgid "Use MIPS-3D instructions"
  msgid "Use MCU instructions."
  msgstr "Использовать команды MIPS-3D"
  
@@ -14840,8 +15642,9 @@ msgstr "Не использовать функцию сброса кэша пе
  
  #: config/mips/mips.opt:320
  #, fuzzy
+#| msgid "Do not use MDMX instructions"
  msgid "Do not use MDMX instructions."
-msgstr "Не использовать команды MIPS-3D"
+msgstr "Не использовать команды MDMX"
  
  #: config/mips/mips.opt:324
  #, fuzzy
@@ -14862,21 +15665,26 @@ msgid "Use paired-single floating-point instructions."
  msgstr "Использовать команды плавающей арифметики формата paired-single (над парами значений одинарной точности)"
  
  #: config/mips/mips.opt:336
+#, fuzzy
+#| msgid "-mr10k-cache-barrier=SETTING\tSpecify when r10k cache barriers should be inserted"
  msgid "-mr10k-cache-barrier=SETTING\tSpecify when r10k cache barriers should be inserted."
-msgstr ""
+msgstr "-mr10k-cache-barrier=SETTING\tУказать, когда должны вставляться барьеры кэша r10k"
  
  #: config/mips/mips.opt:340
-#, fuzzy
  msgid "Valid arguments to -mr10k-cache-barrier=:"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs"
+msgstr "Ð\92Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b ÐºÐ»Ñ\8eÑ\87Ð° -mr10k-cache-barrier=:"
  
  #: config/mips/mips.opt:353
+#, fuzzy
+#| msgid "Try to allow the linker to turn PIC calls into direct calls"
  msgid "Try to allow the linker to turn PIC calls into direct calls."
-msgstr ""
+msgstr "Позволить компоновщику преобразовывать PIC-вызовы в прямые вызовы"
  
  #: config/mips/mips.opt:357
+#, fuzzy
+#| msgid "When generating -mabicalls code, make the code suitable for use in shared libraries"
  msgid "When generating -mabicalls code, make the code suitable for use in shared libraries."
-msgstr ""
+msgstr "При генерации кода -mabicalls генерировать код, подходящий для использования в разделяемых библиотеках"
  
  #: config/mips/mips.opt:361
  #, fuzzy
@@ -14886,8 +15694,9 @@ msgstr "Ограничить использование плавающей ар
  
  #: config/mips/mips.opt:365
  #, fuzzy
+#| msgid "Use SmartMIPS instructions"
  msgid "Use SmartMIPS instructions."
-msgstr "Использовать команды MIPS-3D"
+msgstr "Использовать команды SmartMIPS"
  
  #: config/mips/mips.opt:369
  #, fuzzy
@@ -14908,23 +15717,28 @@ msgid "Assume all symbols have 32-bit values."
  msgstr "Предполагать, что все символы имеют 32-битные значения"
  
  #: config/mips/mips.opt:381
+#, fuzzy
+#| msgid "Use synci instruction to invalidate i-cache"
  msgid "Use synci instruction to invalidate i-cache."
-msgstr ""
+msgstr "Использовать команды synci для инвалидации кэша инструкций"
  
  #: config/mips/mips.opt:389
  #, fuzzy
+#| msgid "-mtune=PROCESSOR\tOptimize the output for PROCESSOR"
  msgid "-mtune=PROCESSOR\tOptimize the output for PROCESSOR."
-msgstr "Оптимизировать код для указанного ПРОЦЕССОРа"
+msgstr "-mtune=ПРОЦЕССОР\tОптимизировать код для указанного ПРОЦЕССОРа"
  
  #: config/mips/mips.opt:397
  #, fuzzy
+#| msgid "Use decimal floating point instructions"
  msgid "Use Virtualization Application Specific instructions."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° paired-single (Ð½Ð°Ð´ Ð¿Ð°Ñ\80Ð°Ð¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð¾Ð´Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87Ð½Ð¾Ñ\81Ñ\82Ð¸)"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð´ÐµÑ\81Ñ\8fÑ\82Ð¸Ñ\87Ð½Ñ\8bÑ\85 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ñ\85"
  
  #: config/mips/mips.opt:401
  #, fuzzy
+#| msgid "Use vector/scalar (VSX) instructions"
  msgid "Use eXtended Physical Address (XPA) instructions."
-msgstr "Использовать команды манипулирования медиаданными"
+msgstr "Использовать vector/scalar (VSX) инструкции"
  
  #: config/mips/mips.opt:405
  #, fuzzy
@@ -14966,40 +15780,41 @@ msgstr ""
  
  #: config/mips/mips-tables.opt:24
  msgid "Known MIPS CPUs (for use with the -march= and -mtune= options):"
-msgstr ""
+msgstr "Известные процессоры MIPS (могут быть заданы как аргументы -march= и -mtune=)"
  
  #: config/mips/mips-tables.opt:28
  msgid "Known MIPS ISA levels (for use with the -mips option):"
-msgstr ""
+msgstr "Известные уровни ISA (могут быть заданы с ключом -mips)"
  
  #: config/tilegx/tilegx.opt:30
  msgid "Known TILE-Gx CPUs (for use with the -mcpu= option):"
-msgstr ""
+msgstr "Известные TILE-Gx CPUs (для использования с -mcpu= опцией):"
  
  #: config/tilegx/tilegx.opt:37
-#, fuzzy
  msgid "Compile with 32 bit longs and pointers."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ñ\81 32-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8fÐ¼Ð¸"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¸Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81 32-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼Ð¸ Ð´Ð»Ð¸Ð½Ð½Ñ\8bÐ¼Ð¸ Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8fÐ¼Ð¸."
  
  #: config/tilegx/tilegx.opt:41
-#, fuzzy
  msgid "Compile with 64 bit longs and pointers."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ñ\81 64-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8fÐ¼Ð¸"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¸Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81 64-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼Ð¸ Ð´Ð»Ð¸Ð½Ð½Ñ\8bÐ¼Ð¸ Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8fÐ¼Ð¸."
  
  #: config/tilegx/tilegx.opt:53
  #, fuzzy
+#| msgid "Use given x86-64 code model"
  msgid "Use given TILE-Gx code model."
  msgstr "Использовать указанную модель кода x86-64"
  
  #: config/arc/arc.opt:26
  #, fuzzy
+#| msgid "Generate code in big endian mode"
  msgid "Compile code for big endian mode."
  msgstr "Генерировать код для прямого (big endian) порядка байт"
  
  #: config/arc/arc.opt:30
  #, fuzzy
+#| msgid "Stores doubles in 32 bits.  This is the default."
  msgid "Compile code for little endian mode.  This is the default."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b RTPB"
+msgstr "Ð¥Ñ\80Ð°Ð½Ð¸Ñ\82Ñ\8c doubles Ð² 32 Ð±Ð¸Ñ\82Ð°Ñ\85.  ÐÑ\82Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ðµ."
  
  #: config/arc/arc.opt:34
  msgid "Disable ARCompact specific pass to generate conditional execution instructions."
@@ -15010,8 +15825,10 @@ msgid "Generate ARCompact 32-bit code for ARC600 processor."
  msgstr ""
  
  #: config/arc/arc.opt:42
+#, fuzzy
+#| msgid "Same as -k128rio"
  msgid "Same as -mA6."
-msgstr ""
+msgstr "То же, что -k128rio"
  
  #: config/arc/arc.opt:46
  msgid "Generate ARCompact 32-bit code for ARC601 processor."
@@ -15022,8 +15839,10 @@ msgid "Generate ARCompact 32-bit code for ARC700 processor."
  msgstr ""
  
  #: config/arc/arc.opt:54
+#, fuzzy
+#| msgid "Same as -k128rio"
  msgid "Same as -mA7."
-msgstr ""
+msgstr "То же, что -k128rio"
  
  #: config/arc/arc.opt:58
  msgid "-mmpy-option={0,1,2,3,4,5,6,7,8,9} Compile ARCv2 code with a multiplier design option.  Option 2 is default on."
@@ -15031,17 +15850,21 @@ msgstr ""
  
  #: config/arc/arc.opt:62
  #, fuzzy
+#| msgid "Enable clip instructions"
  msgid "Enable DIV-REM instructions for ARCv2."
-msgstr "Включить генерацию параллельного кода"
+msgstr "Включить clip инструкции"
  
  #: config/arc/arc.opt:66
  #, fuzzy
+#| msgid "Enable barrel shift instructions"
  msgid "Enable code density instructions for ARCv2."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´а"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ñ\86Ð¸ÐºÐ»Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ñ\81Ð´Ð²Ð¸Ð³а"
  
  #: config/arc/arc.opt:70
+#, fuzzy
+#| msgid "preferentially allocate registers that allow short instruction generation."
  msgid "Tweak register allocation to help 16-bit instruction generation."
-msgstr ""
+msgstr "Предпочтительно выделять регистры которые допускают генерацию коротких инструкций."
  
  #: config/arc/arc.opt:80
  msgid "Use ordinarily cached memory accesses for volatile references."
@@ -15059,8 +15882,9 @@ msgstr "Генерировать строковые команды для бло
  
  #: config/arc/arc.opt:92
  #, fuzzy
+#| msgid "Generate bit instructions"
  msgid "Generate norm instruction."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b isel"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð±Ð¸Ñ\82Ð¾Ð²Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: config/arc/arc.opt:96
  #, fuzzy
@@ -15090,13 +15914,15 @@ msgstr ""
  
  #: config/arc/arc.opt:116
  #, fuzzy
+#| msgid "Generate call insns as indirect calls"
  msgid "Generate call insns as register indirect calls."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ñ\8bÐµ Ð²Ñ\8bÐ·Ð¾Ð²Ñ\8b, ÐµÑ\81Ð»Ð¸ Ð½Ñ\83Ð¶Ð½Ð¾"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð²Ñ\8bÐ·Ð¾Ð²Ð° ÐºÐ°Ðº ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ñ\8bÐµ Ð²Ñ\8bÐ·Ð¾Ð²Ñ\8b"
  
  #: config/arc/arc.opt:120
  #, fuzzy
+#| msgid "Generate cld instruction in the function prologue."
  msgid "Do no generate BRcc instructions in arc_reorg."
-msgstr "Ð\92Ñ\8bÐ´ÐµÐ»Ñ\8fÑ\82Ñ\8c Ð¼ÐµÑ\81Ñ\82Ð¾ Ð´Ð»Ñ\8f Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÐ¼Ñ\8bÑ\85 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² Ð¿Ñ\80Ð¾Ð»Ð¾Ð³Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 cld Ð² Ð¿Ñ\80Ð¾Ð»Ð¾Ð³Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸."
  
  #: config/arc/arc.opt:124
  msgid "Generate sdata references.  This is the default, unless you compile for PIC."
@@ -15112,8 +15938,9 @@ msgstr ""
  
  #: config/arc/arc.opt:140
  #, fuzzy
+#| msgid "Generate bit instructions"
  msgid "FPX: Generate Single Precision FPX (fast) instructions."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b isel"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð±Ð¸Ñ\82Ð¾Ð²Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: config/arc/arc.opt:144
  msgid "FPX: Enable Argonaut ARC CPU Double Precision Floating Point extensions."
@@ -15121,13 +15948,15 @@ msgstr ""
  
  #: config/arc/arc.opt:148 config/arc/arc.opt:152
  #, fuzzy
+#| msgid "Generate bit instructions"
  msgid "FPX: Generate Double Precision FPX (compact) instructions."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b isel"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð±Ð¸Ñ\82Ð¾Ð²Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: config/arc/arc.opt:156
  #, fuzzy
+#| msgid "Generate bit instructions"
  msgid "FPX: Generate Double Precision FPX (fast) instructions."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b isel"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð±Ð¸Ñ\82Ð¾Ð²Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: config/arc/arc.opt:160
  msgid "Disable LR and SR instructions from using FPX extension aux registers."
@@ -15137,10 +15966,12 @@ msgstr ""
  msgid "Enable generation of ARC SIMD instructions via target-specific builtins."
  msgstr ""
  
+#
  #: config/arc/arc.opt:168
  #, fuzzy
+#| msgid "-mcpu=CPU\tCompile code for ARC variant CPU"
  msgid "-mcpu=CPU\tCompile code for ARC variant CPU."
-msgstr "Генерировать код для вариантов процессора ARC"
+msgstr "-mcpu=CPU\tКомпилировать код для ARC варианта CPU"
  
  #: config/arc/arc.opt:205
  msgid "size optimization level: 0:none 1:opportunistic 2: regalloc 3:drop align, -Os."
@@ -15211,8 +16042,10 @@ msgid "Enable Rcw constraint handling - ccfsm condexec mostly depends on this."
  msgstr ""
  
  #: config/arc/arc.opt:279
+#, fuzzy
+#| msgid "Enable cbranchdi4 pattern"
  msgid "Enable pre-reload use of cbranchsi pattern."
-msgstr ""
+msgstr "Включить cbranchdi4 шаблон"
  
  #: config/arc/arc.opt:283
  msgid "Enable bbit peephole2."
@@ -15223,13 +16056,16 @@ msgid "Use pc-relative switch case tables - this enables case table shortening."
  msgstr ""
  
  #: config/arc/arc.opt:291
+#, fuzzy
+#| msgid "Enable cbranchdi4 pattern"
  msgid "Enable compact casesi pattern."
-msgstr ""
+msgstr "Включить cbranchdi4 шаблон"
  
  #: config/arc/arc.opt:295
  #, fuzzy
+#| msgid "Enable clip instructions"
  msgid "Enable 'q' instruction alternatives."
-msgstr "Включить генерацию параллельного кода"
+msgstr "Включить clip инструкции"
  
  #: config/arc/arc.opt:299
  msgid "Expand adddi3 and subdi3 at rtl generation time into add.f / adc etc."
@@ -15247,13 +16083,15 @@ msgstr "Включить расширения языка Plan 9"
  
  #: config/arc/arc.opt:314
  #, fuzzy
+#| msgid "Enable linker relaxation."
  msgid "Enable dual viterbi butterfly extension."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c ÐºÐ»Ñ\8eÑ\87 -relax Ð¿Ñ\80Ð¸ ÐºÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²ÐºÐµ"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¾Ñ\81Ð»Ð°Ð±Ð»ÐµÐ½Ð¸Ñ\8f ÐºÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²Ñ\89Ð¸ÐºÐ¾Ð¼."
  
  #: config/arc/arc.opt:324
  #, fuzzy
+#| msgid "Enable leading zero instructions"
  msgid "Enable Dual and Single Operand Instructions for Telephony."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð°Ñ\80Ð°Ð»Ð»ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð°"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ñ\81 Ð²ÐµÐ´Ñ\83Ñ\89Ð¸Ð¼ Ð½Ñ\83Ð»ÐµÐ¼"
  
  #: config/arc/arc.opt:328
  msgid "Enable XY Memory extension (DSP version 3)."
@@ -15261,33 +16099,39 @@ msgstr ""
  
  #: config/arc/arc.opt:333
  #, fuzzy
+#| msgid "Enable hoisting loads from conditional pointers."
  msgid "Enable Locked Load/Store Conditional extension."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ñ\8bÐµ ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b move"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÑ\82Ñ\8c Ð¿Ð¾Ð´Ð½Ñ\8fÑ\82Ð¸Ðµ Ð·Ð°Ð³Ñ\80Ñ\83Ð·Ð¾Ðº Ð¿Ð¾ Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ñ\8bÐ¼ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8fÐ¼"
  
  #: config/arc/arc.opt:337
  #, fuzzy
+#| msgid "Enable sign extend instructions"
  msgid "Enable swap byte ordering extension instruction."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 DB"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ñ\80Ð°Ð·Ð¼Ð½Ð¾Ð¶ÐµÐ½Ð¸Ñ\8f Ð·Ð½Ð°ÐºÐ°"
  
  #: config/arc/arc.opt:341
  #, fuzzy
+#| msgid "Enable bit manipulation instructions"
  msgid "Enable 64-bit Time-Stamp Counter extension instruction."
-msgstr "Включить инструкции умножения с накоплением с нечётким результатом"
+msgstr "Включить инструкции манипуляций с битами"
  
  #: config/arc/arc.opt:345
  #, fuzzy
+#| msgid "Pass -z text to linker"
  msgid "Pass -EB option through to linker."
-msgstr "Передать компоновщику ключ -assert pure-text"
+msgstr "Передать компоновщику ключ -z"
  
  #: config/arc/arc.opt:349
  #, fuzzy
+#| msgid "Pass -z text to linker"
  msgid "Pass -EL option through to linker."
-msgstr "Передать компоновщику ключ -assert pure-text"
+msgstr "Передать компоновщику ключ -z"
  
  #: config/arc/arc.opt:353
  #, fuzzy
+#| msgid "Pass -z text to linker"
  msgid "Pass -marclinux option through to linker."
-msgstr "Передать компоновщику ключ -assert pure-text"
+msgstr "Передать компоновщику ключ -z"
  
  #: config/arc/arc.opt:357
  msgid "Pass -marclinux_prof option through to linker."
@@ -15295,8 +16139,9 @@ msgstr ""
  
  #: config/arc/arc.opt:365
  #, fuzzy
+#| msgid "Enable linker relaxation."
  msgid "Enable lra."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c ÐºÐ»Ñ\8eÑ\87 -relax Ð¿Ñ\80Ð¸ ÐºÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²ÐºÐµ"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¾Ñ\81Ð»Ð°Ð±Ð»ÐµÐ½Ð¸Ñ\8f ÐºÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²Ñ\89Ð¸ÐºÐ¾Ð¼."
  
  #: config/arc/arc.opt:369
  msgid "Don't indicate any priority with TARGET_REGISTER_PRIORITY."
@@ -15316,13 +16161,15 @@ msgstr ""
  
  #: config/arc/arc.opt:411
  #, fuzzy
+#| msgid "Enable clip instructions"
  msgid "Enable atomic instructions."
-msgstr "Включить генерацию параллельного кода"
+msgstr "Включить clip инструкции"
  
  #: config/arc/arc.opt:415
  #, fuzzy
+#| msgid "Enable unaligned load/store instruction"
  msgid "Enable double load/store instructions for ARC HS."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 DB"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð½ÐµÐ²Ñ\8bÑ\80Ð¾Ð²Ð½ÐµÐ½Ð½Ð¾Ð¹ Ð·Ð°Ð³Ñ\80Ñ\83Ð·ÐºÐ¸/Ñ\81Ð¾Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f"
  
  #: config/arc/arc.opt:419
  #, fuzzy
@@ -15350,8 +16197,9 @@ msgstr "Уведомлять, когда модификаторы употреб
  
  #: java/lang.opt:150
  #, fuzzy
+#| msgid "--CLASSPATH\tDeprecated; use --classpath instead"
  msgid "--CLASSPATH\tDeprecated; use --classpath instead."
-msgstr "Этот ключ устарел, используйте --classpath"
+msgstr "--CLASSPATH\tЭтот ключ устарел, используйте --classpath"
  
  #: java/lang.opt:157
  #, fuzzy
@@ -15361,8 +16209,9 @@ msgstr "Разрешить использование ключевого сло
  
  #: java/lang.opt:179
  #, fuzzy
+#| msgid "--bootclasspath=<path>\tReplace system path"
  msgid "--bootclasspath=<path>\tReplace system path."
-msgstr "Замена для системного пути"
+msgstr "--bootclasspath=<path>\tЗамена для системного пути"
  
  #: java/lang.opt:183
  #, fuzzy
@@ -15372,8 +16221,9 @@ msgstr "Генерировать код проверки ссылок по NULL-
  
  #: java/lang.opt:187
  #, fuzzy
+#| msgid "--classpath=<path>\tSet class path"
  msgid "--classpath=<path>\tSet class path."
-msgstr "Замена для системного пути"
+msgstr "--classpath=<path>\tПуть поиска классов"
  
  #: java/lang.opt:194
  #, fuzzy
@@ -15389,13 +16239,15 @@ msgstr "Замена для -femit-class-file"
  
  #: java/lang.opt:202
  #, fuzzy
+#| msgid "--encoding=<encoding>\tChoose input encoding (defaults from your locale)"
  msgid "--encoding=<encoding>\tChoose input encoding (defaults from your locale)."
-msgstr "Выбрать кодировку входных файлов (по умолчанию из locale)"
+msgstr "--encoding=<encoding>\tВыбрать кодировку входных файлов (по умолчанию из locale)"
  
  #: java/lang.opt:206
  #, fuzzy
+#| msgid "--extdirs=<path>\tSet the extension directory path"
  msgid "--extdirs=<path>\tSet the extension directory path."
-msgstr "Задать путь к каталогу расширений"
+msgstr "--extdirs=<путь>\tЗадать путь к каталогу расширений"
  
  #: java/lang.opt:216
  #, fuzzy
@@ -15465,27 +16317,33 @@ msgstr "Вызывать функцию библиотеки для делени
  
  #: java/lang.opt:269
  #, fuzzy
+#| msgid "Generate code for built-in atomic operations"
  msgid "Generate code for built-in atomic operations."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð´Ð»Ñ\8f Ð¿Ñ\80Ñ\8fÐ¼Ð¾Ð³Ð¾ (big endian) Ð¿Ð¾Ñ\80Ñ\8fÐ´ÐºÐ° Ð±Ð°Ð¹Ñ\82"
+msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð´Ð»Ñ\8f Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ñ\8bÑ\85 Ð°Ñ\82Ð¾Ð¼Ð°Ñ\80Ð½Ñ\8bÑ\85 Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¹"
  
  #: java/lang.opt:273
+#, fuzzy
+#| msgid "Generated should be loaded by bootstrap loader"
  msgid "Generated should be loaded by bootstrap loader."
-msgstr ""
+msgstr "Сгенерированный файл должен загружаться стартовым загрузчиком"
  
  #: java/lang.opt:277
  #, fuzzy
+#| msgid "Set the source language version"
  msgid "Set the source language version."
-msgstr "Ð\98Ð¼Ñ\8f Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð³Ð¾ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80а"
+msgstr "Ð\97Ð°Ð´Ð°Ñ\82Ñ\8c Ð²ÐµÑ\80Ñ\81Ð¸Ñ\8e Ð²Ñ\85Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\8fÐ·Ñ\8bÐºа"
  
  #: java/lang.opt:281
  #, fuzzy
+#| msgid "Set the target VM version"
  msgid "Set the target VM version."
-msgstr "Ð\98Ð¼Ñ\8f Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð³Ð¾ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80Ð°"
+msgstr "Ð\97Ð°Ð´Ð°Ñ\82Ñ\8c Ð²ÐµÑ\80Ñ\81Ð¸Ñ\8e Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð¹ VM"
  
  #: lto/lang.opt:28
  #, fuzzy, c-format
+#| msgid "unknown machine mode %qE"
  msgid "unknown linker output %qs"
-msgstr "неизвестная машинный режим %qs"
+msgstr "неизвестная машинный режим %qE"
  
  #: lto/lang.opt:47
  msgid "Set linker output type (used internally during LTO optimization)"
@@ -15493,15 +16351,15 @@ msgstr ""
  
  #: lto/lang.opt:52
  msgid "Run the link-time optimizer in local transformation (LTRANS) mode."
-msgstr ""
+msgstr "Выполнить оптимизации времени компоновки в режиме локальных трансформаций (LTRANS)."
  
  #: lto/lang.opt:56
  msgid "Specify a file to which a list of files output by LTRANS is written."
-msgstr ""
+msgstr "Указать имя файла, в который требуется записать список файлов, выведенных LTRANS"
  
  #: lto/lang.opt:60
  msgid "Run the link-time optimizer in whole program analysis (WPA) mode."
-msgstr ""
+msgstr "Выполнить оптимизации времени компоновки в режиме анализа всей программы (WPA)"
  
  #: lto/lang.opt:64
  msgid "Whole program analysis (WPA) mode with number of parallel jobs specified."
@@ -15509,13 +16367,15 @@ msgstr ""
  
  #: lto/lang.opt:68
  #, fuzzy
+#| msgid "The resolution file"
  msgid "The resolution file."
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80 Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83Ðºции"
+msgstr "Ð¤Ð°Ð¹Ð» Ñ\80ÐµÐ·Ð¾Ð»Ñ\8eции"
  
  #: common.opt:235
  #, fuzzy
+#| msgid "Enable user-defined instructions"
  msgid "Enable coverage-guided fuzzing code instrumentation."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 DB"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»Ñ\8fÐµÐ¼Ñ\8bÐµ Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: common.opt:302
  #, fuzzy
@@ -15524,23 +16384,28 @@ msgid "Display this information."
  msgstr "Выдать эту информацию"
  
  #: common.opt:306
+#, fuzzy
+#| msgid "--help=<class>\tDisplay descriptions of a specific class of options.  <class> is one or more of optimizers, target, warnings, undocumented, params"
  msgid "--help=<class>\tDisplay descriptions of a specific class of options.  <class> is one or more of optimizers, target, warnings, undocumented, params."
-msgstr ""
+msgstr "--help=<класс>\tВыдать описание указанного класса ключей. <класс> задает одно или более из следующих слов: optimizers, target, warnings, undocumented, params"
  
  #: common.opt:424
  #, fuzzy
+#| msgid "Alias for --help=target"
  msgid "Alias for --help=target."
-msgstr "Ð\97Ð°Ð¼ÐµÐ½Ð° Ð´Ð»Ñ\8f -mflat-abi=hard"
+msgstr "Ð¡Ð¸Ð½Ð¾Ð½Ð¸Ð¼ --help=target"
  
  #: common.opt:449
  #, fuzzy
+#| msgid "--param <param>=<value>\tSet parameter <param> to value.  See below for a complete list of parameters"
  msgid "--param <param>=<value>\tSet parameter <param> to value.  See below for a complete list of parameters."
-msgstr "Задать значение для параметра. См. далее полный список параметров"
+msgstr "--param <param>=<value>\tЗадать значение параметра <param> равным <value>. См. далее полный список параметров"
  
  #: common.opt:477
  #, fuzzy
+#| msgid "-O<number>\tSet optimization level to <number>"
  msgid "-O<number>\tSet optimization level to <number>."
-msgstr "Задать уровень оптимизации"
+msgstr "-O<уровень>\tЗадать <уровень> оптимизации"
  
  #: common.opt:481
  #, fuzzy
@@ -15549,11 +16414,14 @@ msgid "Optimize for space rather than speed."
  msgstr "Оптимизировать размер, а не быстродействие"
  
  #: common.opt:485
+#, fuzzy
+#| msgid "Optimize for speed disregarding exact standards compliance"
  msgid "Optimize for speed disregarding exact standards compliance."
-msgstr ""
+msgstr "Оптимизировать по скорости выполнения, пренебрегая некоторыми требованиями стандарта"
  
  #: common.opt:489
  #, fuzzy
+#| msgid "Optimize for space rather than speed"
  msgid "Optimize for debugging experience rather than speed or size."
  msgstr "Оптимизировать размер, а не быстродействие"
  
@@ -15575,9 +16443,9 @@ msgstr ""
  
  #: common.opt:550 common.opt:554
  #, fuzzy
-#| msgid "Warn if .class files are out of date"
+#| msgid "Warn if an array is accessed out of bounds"
  msgid "Warn if an array is accessed out of bounds."
-msgstr "Предупреждать, если файл .class устарел"
+msgstr "Предупреждать о выходе за границы массива"
  
  #: common.opt:558
  #, fuzzy
@@ -15593,8 +16461,9 @@ msgstr "Предупреждать о приведении указательн
  
  #: common.opt:566
  #, fuzzy
+#| msgid "Warn when a #warning directive is encountered"
  msgid "Warn when a #warning directive is encountered."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÐ¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÑ\85 Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð°Ñ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\92Ñ\8bÐ´Ð°Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ñ\8f Ð² Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ð¸ Ñ\81 Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð°Ð¼Ð¸ #warning"
  
  #: common.opt:570
  #, fuzzy
@@ -15616,8 +16485,9 @@ msgstr "Все предупреждения считать ошибками"
  
  #: common.opt:582
  #, fuzzy
+#| msgid "Treat specified warning as error"
  msgid "Treat specified warning as error."
-msgstr "Ð\92Ñ\81Ðµ Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ñ\8f Ñ\81Ñ\87Ð¸Ñ\82Ð°Ñ\82Ñ\8c Ð¾Ñ\88Ð¸Ð±ÐºÐ°Ð¼Ð¸"
+msgstr "Ð¢Ñ\80Ð°ÐºÑ\82Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ð½Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ðµ ÐºÐ°Ðº Ð¾Ñ\88Ð¸Ð±ÐºÑ\83"
  
  #: common.opt:586
  #, fuzzy
@@ -15633,12 +16503,15 @@ msgstr "Закончить работу при первой обнаруженн
  
  #: common.opt:594
  #, fuzzy
+#| msgid "-Wframe-larger-than=<number>\tWarn if a function's stack frame requires more than <number> bytes"
  msgid "-Wframe-larger-than=<number>\tWarn if a function's stack frame requires more than <number> bytes."
-msgstr "Предупреждать об объектах, размер которых превышает <число> байт"
+msgstr "-Wframe-larger-than=<number>\tПредупреждать, если размер стека функции превышает <number> байт"
  
  #: common.opt:598
+#, fuzzy
+#| msgid "Warn when attempting to free a non-heap object"
  msgid "Warn when attempting to free a non-heap object."
-msgstr ""
+msgstr "Предупреждать о попытках освобождения объектов, размещенных не в динамической памяти"
  
  #: common.opt:602
  #, fuzzy
@@ -15654,12 +16527,13 @@ msgstr "Предупреждать об inline-функциях, подстан
  
  #: common.opt:610
  msgid "Warn when an atomic memory model parameter is known to be outside the valid range."
-msgstr ""
+msgstr "Предупреждать, если параметр атомарной модели памяти находится заведомо вне корректного диапазона"
  
  #: common.opt:617
  #, fuzzy
+#| msgid "-Wlarger-than=<number>\tWarn if an object is larger than <number> bytes"
  msgid "-Wlarger-than=<number>\tWarn if an object is larger than <number> bytes."
-msgstr "Предупреждать об объектах, размер которых превышает <число> байт"
+msgstr "-Wlarger-than=<число>\tПредупреждать об объектах, размер которых превышает <число> байт"
  
  #: common.opt:621
  msgid "Warn if comparing pointer parameter with nonnull attribute with NULL."
@@ -15679,8 +16553,9 @@ msgstr ""
  
  #: common.opt:640
  #, fuzzy
+#| msgid "Warn about overflow in arithmetic expressions"
  msgid "Warn about overflow in arithmetic expressions."
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8fÑ\85 Ð² Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ñ\85 Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8fÑ\85"
  
  #: common.opt:644
  msgid "During link time optimization warn about mismatched types of global declarations."
@@ -15706,6 +16581,7 @@ msgstr "Выдавать предупреждения, требуемые для
  
  #: common.opt:660
  #, fuzzy
+#| msgid "returning reference to temporary"
  msgid "Warn about returning a pointer/reference to a local or temporary variable."
  msgstr "возврат ссылки на временную переменную"
  
@@ -15722,8 +16598,10 @@ msgid "Warn when not issuing stack smashing protection for some reason."
  msgstr "Предупреждать, если защита от разрушения стека по каким-то причинам не сгенерирована"
  
  #: common.opt:672
+#, fuzzy
+#| msgid "Warn if stack usage might be larger than specified amount"
  msgid "Warn if stack usage might be larger than specified amount."
-msgstr ""
+msgstr "Предупреждать, если используемый размер стека может превышать указанную величину"
  
  #: common.opt:676 common.opt:680
  #, fuzzy
@@ -15733,18 +16611,21 @@ msgstr "Предупреждать о возможных нарушениях п
  
  #: common.opt:684 common.opt:688
  #, fuzzy
+#| msgid "Warn about optimizations that assume that signed overflow is undefined"
  msgid "Warn about optimizations that assume that signed overflow is undefined."
-msgstr "Ð\9eÑ\82Ð¼ÐµÐ½Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸, Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°Ñ\8eÑ\89Ð¸Ðµ Ñ\81Ñ\82Ð°Ð½Ð´Ð°Ñ\80Ñ\82Ð½Ð¾Ðµ Ð¾ÐºÑ\80Ñ\83Ð³Ð»ÐµÐ½Ð¸Ðµ Ð²ÐµÑ\89ÐµÑ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÑ\85 Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾Ð± Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8fÑ\85, Ð¾Ñ\81Ð½Ð¾Ð²Ð°Ð½Ð½Ñ\8bÑ\85 Ð½Ð° Ñ\82Ð¾Ð¼, Ñ\87Ñ\82Ð¾ Ð¿Ñ\80Ð¸ Ð·Ð½Ð°ÐºÐ¾Ð²Ð¾Ð¼ Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ð¸ Ð¿Ð¾Ð²ÐµÐ´ÐµÐ½Ð¸Ðµ Ð½Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¾"
  
  #: common.opt:692
  #, fuzzy
+#| msgid "Warn about functions which might be candidates for __attribute__((const))"
  msgid "Warn about functions which might be candidates for __attribute__((const))."
-msgstr "Предупреждать о функциях, которым можно назначить атрибут noreturn"
+msgstr "Предупреждать о функциях, которым можно назначить __attribute__((const))"
  
  #: common.opt:696
  #, fuzzy
+#| msgid "Warn about functions which might be candidates for __attribute__((pure))"
  msgid "Warn about functions which might be candidates for __attribute__((pure))."
-msgstr "Предупреждать о функциях, которым можно назначить атрибут noreturn"
+msgstr "Предупреждать о функциях, которым можно назначить __attribute__((pure))"
  
  #: common.opt:700
  #, fuzzy
@@ -15768,13 +16649,15 @@ msgstr "Не подавлять предупреждения от системн
  
  #: common.opt:716
  #, fuzzy
+#| msgid "Warn whenever a trampoline is generated"
  msgid "Warn whenever a trampoline is generated."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÐ¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÑ\85 Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ \"Ñ\82Ñ\80Ð°Ð¼Ð¿Ð»Ð¸Ð½Ð¾Ð²\" Ð´Ð»Ñ\8f Ð²Ð»Ð¾Ð¶ÐµÐ½Ð½Ñ\8bÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
  
  #: common.opt:720
  #, fuzzy
+#| msgid "Warn if a comparison is always true or always false due to the limited range of the data type"
  msgid "Warn if a comparison is always true or always false due to the limited range of the data type."
-msgstr "Ð¸Ð·-Ð·Ð° Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87ÐµÐ½Ð½Ð¾Ñ\81Ñ\82Ð¸ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° Ñ\82Ð¸Ð¿Ð° Ð´Ð°Ð½Ð½Ñ\8bÑ\85, Ñ\80ÐµÐ·Ñ\83Ð»Ñ\8cÑ\82Ð°Ñ\82 Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8f Ð²Ñ\81ÐµÐ³Ð´Ð° Ð»Ð¾Ð¶Ñ\8c"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c, ÐµÑ\81Ð»Ð¸ Ð¸Ð·-Ð·Ð° Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87ÐµÐ½Ð½Ð¾Ñ\81Ñ\82Ð¸ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° Ñ\82Ð¸Ð¿Ð° Ð´Ð°Ð½Ð½Ñ\8bÑ\85, Ñ\80ÐµÐ·Ñ\83Ð»Ñ\8cÑ\82Ð°Ñ\82 Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8f Ð²Ñ\81ÐµÐ³Ð´Ð° Ð»Ð¾Ð¶Ñ\8c Ð¸Ð»Ð¸ Ð²Ñ\81ÐµÐ³Ð´Ð° Ð¸Ñ\81Ñ\82Ð¸Ð½Ð°"
  
  #: common.opt:724
  #, fuzzy
@@ -15784,8 +16667,9 @@ msgstr "Предупреждать о неинициализированных 
  
  #: common.opt:728
  #, fuzzy
+#| msgid "Warn about maybe uninitialized automatic variables"
  msgid "Warn about maybe uninitialized automatic variables."
-msgstr "Предупреждать о неинициализированных автоматических переменных"
+msgstr "Предупреждать о, возможно, неинициализированных автоматических переменных"
  
  #: common.opt:736
  #, fuzzy
@@ -15795,13 +16679,15 @@ msgstr "Включить все предупреждения -Wunused-"
  
  #: common.opt:740
  #, fuzzy
+#| msgid "Warn when a function parameter is only set, otherwise unused"
  msgid "Warn when a function parameter is only set, otherwise unused."
-msgstr "Предупреждать о неиспользуемых параметрах функций"
+msgstr "Предупреждать, если параметр функции не используется иначе чем для присваивания ему значений"
  
  #: common.opt:744
  #, fuzzy
+#| msgid "Warn when a variable is only set, otherwise unused"
  msgid "Warn when a variable is only set, otherwise unused."
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÐ¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÑ\85 Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85, ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ ÐºÐ°Ðº Ð»ÐµÐ²Ð°Ñ\8f Ñ\87Ð°Ñ\81Ñ\82Ñ\8c Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¹"
  
  #: common.opt:748
  #, fuzzy
@@ -15834,32 +16720,40 @@ msgid "Warn when a variable is unused."
  msgstr "Предупреждать о неиспользуемых переменных"
  
  #: common.opt:768
+#, fuzzy
+#| msgid "Warn in case profiles in -fprofile-use do not match"
  msgid "Warn in case profiles in -fprofile-use do not match."
-msgstr ""
+msgstr "Предупреждать о несоответствии данных профилирования, заданных ключом -fprofile-use"
  
  #: common.opt:772
+#, fuzzy
+#| msgid "Warn when a vector operation is compiled outside the SIMD"
  msgid "Warn when a vector operation is compiled outside the SIMD."
-msgstr ""
+msgstr "Предупреждать о векторных операциях, скомпилированных не при помощи SIMD-команд"
  
  #: common.opt:788
  #, fuzzy
+#| msgid "-aux-info <file>\tEmit declaration information into <file>"
  msgid "-aux-info <file>\tEmit declaration information into <file>."
-msgstr "Выдать информацию о декларациях в <файл>"
+msgstr "-aux-info <файл>\tВыдать информацию о декларациях в <файл>"
  
  #: common.opt:807
  #, fuzzy
+#| msgid "-d<letters>\tEnable dumps from specific passes of the compiler"
  msgid "-d<letters>\tEnable dumps from specific passes of the compiler."
-msgstr "Выдать дампы от различных проходов компиляции"
+msgstr "-d<letters>\tВыдать дампы от различных проходов компиляции"
  
  #: common.opt:811
  #, fuzzy
+#| msgid "-dumpbase <file>\tSet the file basename to be used for dumps"
  msgid "-dumpbase <file>\tSet the file basename to be used for dumps."
-msgstr "Базовое имя файла для дампов"
+msgstr "-dumpbase <file>\tБазовое имя файла для дампов"
  
  #: common.opt:815
  #, fuzzy
+#| msgid "-dumpdir <dir>\tSet the directory name to be used for dumps"
  msgid "-dumpdir <dir>\tSet the directory name to be used for dumps."
-msgstr "Базовое имя файла для дампов"
+msgstr "-dumpdir <каталог>\tУказать <каталог> для выдачи дампов"
  
  #: common.opt:884
  msgid "The version of the C++ ABI in use."
@@ -15894,8 +16788,10 @@ msgid "Align the start of loops."
  msgstr "Выравнивать начало циклов"
  
  #: common.opt:936
+#, fuzzy
+#| msgid "Select the runtime"
  msgid "Select what to sanitize."
-msgstr ""
+msgstr "Выбрать runtime-поддержку"
  
  #: common.opt:940
  msgid "-fasan-shadow-offset=<number>\tUse custom shadow memory offset."
@@ -15927,8 +16823,9 @@ msgstr "Генерировать unwind-таблицы, корректные н
  
  #: common.opt:965
  #, fuzzy
+#| msgid "Generate auto-inc/dec instructions"
  msgid "Generate auto-inc/dec instructions."
-msgstr "Генерировать команды isel"
+msgstr "Генерировать команды автоинкрементации/автодекрементации"
  
  #: common.opt:969
  msgid "Use sample profile information for call graph node weights. The default"
@@ -15978,13 +16875,15 @@ msgstr "Ограничить миграцию регистров, в котор
  
  #: common.opt:1007
  #, fuzzy
+#| msgid "-fcall-saved-<register>\tMark <register> as being preserved across functions"
  msgid "-fcall-saved-<register>\tMark <register> as being preserved across functions."
-msgstr "Считать, что <регистр> сохраняется при вызовах функций"
+msgstr "-fcall-saved-<регистр>\tСчитать, что <регистр> сохраняется при вызовах функций"
  
  #: common.opt:1011
  #, fuzzy
+#| msgid "-fcall-used-<register>\tMark <register> as being corrupted by function calls"
  msgid "-fcall-used-<register>\tMark <register> as being corrupted by function calls."
-msgstr "Считать, что <регистр> портится при вызовах функций"
+msgstr "-fcall-used-<регистр>\tСчитать, что <регистр> портится при вызовах функций"
  
  #: common.opt:1018
  #, fuzzy
@@ -16012,7 +16911,7 @@ msgstr "обнаружена несогласованность внутренн
  
  #: common.opt:1034
  msgid "Looks for opportunities to reduce stack adjustments and stack references."
-msgstr ""
+msgstr "По возможности сокращать число операций со стеком и обращений к стеку"
  
  #: common.opt:1038
  #, fuzzy
@@ -16021,21 +16920,28 @@ msgid "Do not put uninitialized globals in the common section."
  msgstr "Не размещать неинициализированные глобальные данные в общих блоках"
  
  #: common.opt:1046
+#, fuzzy
+#| msgid "-fcompare-debug[=<opts>]\tCompile with and without e.g. -gtoggle, and compare the final-insns dump"
  msgid "-fcompare-debug[=<opts>]\tCompile with and without e.g. -gtoggle, and compare the final-insns dump."
-msgstr ""
+msgstr "-fcompare-debug[=<opts>]\tКомпилировать с ключом, например, -gtoggle, и сравнивать финальные дампы инструкций"
  
  #: common.opt:1050
+#, fuzzy
+#| msgid "Run only the second compilation of -fcompare-debug"
  msgid "Run only the second compilation of -fcompare-debug."
-msgstr ""
+msgstr "Выполнять только вторую компиляцию по -fcompare-debug"
  
  #: common.opt:1054
  #, fuzzy
+#| msgid "Perform comparison elimination after register allocation has finished"
  msgid "Perform comparison elimination after register allocation has finished."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ñ\83Ñ\8e Ñ\8dÐºÐ¾Ð½Ð¾Ð¼Ð¸Ñ\8e Ð¾Ð±Ñ\89Ð¸Ñ\85 Ð¿Ð¾Ð´Ð²Ñ\8bÑ\80Ð°Ð¶ений после распределения регистров"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ðµ Ð»Ð¸Ñ\88Ð½Ð¸Ñ\85 Ñ\81Ñ\80Ð°Ð²Ð½ений после распределения регистров"
  
  #: common.opt:1058
+#, fuzzy
+#| msgid "Do not perform optimizations increasing noticeably stack usage"
  msgid "Do not perform optimizations increasing noticeably stack usage."
-msgstr ""
+msgstr "Не выполнять оптимизации, существенно увеличивающие использование стека"
  
  #: common.opt:1062
  #, fuzzy
@@ -16062,8 +16968,10 @@ msgid "Omit range reduction step when performing complex division."
  msgstr "Отбрасывать шаг редукции отрезка при выполнении комплексного деления"
  
  #: common.opt:1082
+#, fuzzy
+#| msgid "Complex multiplication and division follow Fortran rules"
  msgid "Complex multiplication and division follow Fortran rules."
-msgstr ""
+msgstr "Использовать правила Фортрана для комплексного умножения и деления"
  
  #: common.opt:1086
  #, fuzzy
@@ -16073,19 +16981,23 @@ msgstr "Размещать элементы данных в отдельных 
  
  #: common.opt:1090
  msgid "List all available debugging counters with their limits and counts."
-msgstr ""
+msgstr "Перечислить все отладочные счетчики с их границами и значениями"
  
  #: common.opt:1094
+#, fuzzy
+#| msgid "-fdbg-cnt=<counter>:<limit>[,<counter>:<limit>,...]\tSet the debug counter limit.   "
  msgid "-fdbg-cnt=<counter>:<limit>[,<counter>:<limit>,...]\tSet the debug counter limit."
-msgstr ""
+msgstr "-fdbg-cnt=<counter>:<limit>[,<counter>:<limit>,...]\tЗадать список отладочных счетчиков.   "
  
  #: common.opt:1098
+#, fuzzy
+#| msgid "Map one directory name to another in debug information"
  msgid "Map one directory name to another in debug information."
-msgstr ""
+msgstr "Отобразить имя каталога на другое имя в отладочной информации"
  
  #: common.opt:1102
  msgid "Output .debug_types section when using DWARF v4 debuginfo."
-msgstr ""
+msgstr "Выдать секцию .debug_types если используется формат DWARF v4"
  
  #: common.opt:1108
  #, fuzzy
@@ -16121,12 +17033,13 @@ msgstr "Формировать суперблоки методом дублир
  
  #: common.opt:1132
  msgid "Try to convert virtual calls to direct ones."
-msgstr ""
+msgstr "Пытаться преобразовать виртуальные классы в обычные"
  
  #: common.opt:1136
  #, fuzzy
+#| msgid "-fdiagnostics-show-location=[once|every-line]\tHow often to emit source location at the beginning of line-wrapped diagnostics"
  msgid "-fdiagnostics-show-location=[once|every-line]\tHow often to emit source location at the beginning of line-wrapped diagnostics."
-msgstr "Выдавать местоположение источника сообщения один раз или для каждой строки (для многострочных сообщений)"
+msgstr "-fdiagnostics-show-location=[once|every-line]\tВыдавать местоположение источника сообщения один раз или для каждой строки многострочных сообщений"
  
  #: common.opt:1153
  msgid "Show the source line with a caret indicating the column."
@@ -16143,30 +17056,40 @@ msgid "Amend appropriate diagnostic messages with the command line option that c
  msgstr "Дополнять диагностические сообщения ключом, который контролирует это сообщение"
  
  #: common.opt:1185
+#, fuzzy
+#| msgid "-fdisable-[tree|rtl|ipa]-<pass>=range1+range2 disables an optimization pass"
  msgid "-fdisable-[tree|rtl|ipa]-<pass>=range1+range2 disables an optimization pass."
-msgstr ""
+msgstr "-fdisable-[tree|rtl|ipa]-<pass>=range1+range2 отменяет проход оптимизации"
  
  #: common.opt:1189
+#, fuzzy
+#| msgid "-fenable-[tree|rtl|ipa]-<pass>=range1+range2 enables an optimization pass"
  msgid "-fenable-[tree|rtl|ipa]-<pass>=range1+range2 enables an optimization pass."
-msgstr ""
+msgstr "-fenable-[tree|rtl|ipa]-<pass>=range1+range2 включает проход оптимизации"
  
  #: common.opt:1193
  #, fuzzy
+#| msgid "-fdump-<type>\tDump various compiler internals to a file"
  msgid "-fdump-<type>\tDump various compiler internals to a file."
-msgstr "Выдать внутреннюю информацию компилятора в файл"
+msgstr "-fdump-<type>\tВыдать внутреннюю информацию о компиляции в файл"
  
  #: common.opt:1200
+#, fuzzy
+#| msgid "-fdump-final-insns=filename\tDump to filename the insns at the end of translation"
  msgid "-fdump-final-insns=filename\tDump to filename the insns at the end of translation."
-msgstr ""
+msgstr "-fdump-final-insns=файл\tВывести в файл дамп инструкций в конце компиляции"
  
  #: common.opt:1204
+#, fuzzy
+#| msgid "-fdump-go-spec=filename\tWrite all declarations to file as Go code"
  msgid "-fdump-go-spec=filename\tWrite all declarations to file as Go code."
-msgstr ""
+msgstr "-fdump-go-spec=файл\tЗаписать в файл все декларации в виде кода Go"
  
  #: common.opt:1208
  #, fuzzy
+#| msgid "Suppress output of addresses in debugging dumps"
  msgid "Suppress output of addresses in debugging dumps."
-msgstr "Ð\9fÐ¾Ð´Ð°Ð²Ð»Ñ\8fÑ\82Ñ\8c Ð²Ñ\8bÐ²Ð¾Ð´ Ð½Ð¾Ð¼ÐµÑ\80Ð¾Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð¸ Ð½Ð¾Ð¼ÐµÑ\80Ð¾Ð² Ñ\81Ñ\82Ñ\80Ð¾Ðº в отладочных дампах"
+msgstr "Ð\9fÐ¾Ð´Ð°Ð²Ð»Ñ\8fÑ\82Ñ\8c Ð²Ñ\8bÐ²Ð¾Ð´ Ð°Ð´Ñ\80ÐµÑ\81Ð¾Ð² в отладочных дампах"
  
  #: common.opt:1212
  msgid "Collect and dump debug information into temporary file if ICE in C/C++"
@@ -16178,22 +17101,25 @@ msgstr ""
  
  #: common.opt:1221
  #, fuzzy
+#| msgid "Dump optimization passes"
  msgid "Dump optimization passes."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð»Ð½Ñ\83Ñ\8e Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿ÐµÑ\80ÐµÐ¼ÐµÑ\89ÐµÐ½Ð¸Ñ\8f Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²"
+msgstr "Ð\92Ñ\8bÐ´Ð°Ñ\82Ñ\8c Ð´Ð°Ð¼Ð¿Ñ\8b Ð¿Ñ\80Ð¾Ñ\85Ð¾Ð´Ð¾Ð² Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸"
  
  #: common.opt:1225
  #, fuzzy
+#| msgid "Suppress output of instruction numbers, line number notes and addresses in debugging dumps"
  msgid "Suppress output of instruction numbers, line number notes and addresses in debugging dumps."
-msgstr "Подавлять вывод номеров инструкций и номеров строк в отладочных дампах"
+msgstr "Ð\9fÐ¾Ð´Ð°Ð²Ð»Ñ\8fÑ\82Ñ\8c Ð²Ñ\8bÐ²Ð¾Ð´ Ð½Ð¾Ð¼ÐµÑ\80Ð¾Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð¸ Ð½Ð¾Ð¼ÐµÑ\80Ð¾Ð² Ñ\81Ñ\82Ñ\80Ð¾Ðº Ð¸ Ð°Ð´Ñ\80ÐµÑ\81Ð¾Ð² Ð² Ð¾Ñ\82Ð»Ð°Ð´Ð¾Ñ\87Ð½Ñ\8bÑ\85 Ð´Ð°Ð¼Ð¿Ð°Ñ\85"
  
  #: common.opt:1229
  #, fuzzy
+#| msgid "Suppress output of previous and next insn numbers in debugging dumps"
  msgid "Suppress output of previous and next insn numbers in debugging dumps."
-msgstr "Ð\9fÐ¾Ð´Ð°Ð²Ð»Ñ\8fÑ\82Ñ\8c Ð²Ñ\8bÐ²Ð¾Ð´ Ð½Ð¾Ð¼ÐµÑ\80Ð¾Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Ð¸ Ð½Ð¾Ð¼ÐµÑ\80Ð¾Ð² Ñ\81Ñ\82Ñ\80Ð¾Ðº в отладочных дампах"
+msgstr "Ð\9fÐ¾Ð´Ð°Ð²Ð»Ñ\8fÑ\82Ñ\8c Ð²Ñ\8bÐ²Ð¾Ð´ Ð½Ð¾Ð¼ÐµÑ\80Ð¾Ð² Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ð¸ Ñ\81Ð»ÐµÐ´Ñ\83Ñ\8eÑ\89ÐµÐ¹ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ в отладочных дампах"
  
  #: common.opt:1233
  msgid "Enable CFI tables via GAS assembler directives."
-msgstr ""
+msgstr "Выдавать таблицы DWARF CFI в виде ассемблерных директив .cfi_*"
  
  #: common.opt:1237
  #, fuzzy
@@ -16209,8 +17135,9 @@ msgstr "Исключить дублирование информации DWARF2"
  
  #: common.opt:1245
  #, fuzzy
+#| msgid "Perform interprocedural reduction of aggregates"
  msgid "Perform interprocedural reduction of aggregates."
-msgstr "Выполнить межпроцедурное распространение констант"
+msgstr "Выполнить межпроцедурную редукцию агрегатных данных"
  
  #: common.opt:1249
  #, fuzzy
@@ -16226,7 +17153,7 @@ msgstr "Исключить отладочную информацию о неис
  
  #: common.opt:1257
  msgid "Do not suppress C++ class debug information."
-msgstr ""
+msgstr "Не подавлять отладочную информацию о классах C++"
  
  #: common.opt:1261
  #, fuzzy
@@ -16241,17 +17168,19 @@ msgid "Perform a number of minor, expensive optimizations."
  msgstr "Выполнить некоторые дополнительные дорогостоящие оптимизации"
  
  #: common.opt:1269
+#, fuzzy
+#| msgid "-fexcess-precision=[fast|standard]\tSpecify handling of excess floating-point precision"
  msgid "-fexcess-precision=[fast|standard]\tSpecify handling of excess floating-point precision."
-msgstr ""
+msgstr "-fexcess-precision=[fast|standard]\tЗадать способ обработки данных с плавающей точкой повышенной точности"
  
  #: common.opt:1272
-#, fuzzy, c-format
+#, c-format
  msgid "unknown excess precision style %qs"
-msgstr "неизвестный стиль декодирования имён '%s'"
+msgstr "неизвестный стиль способ обработки данных повышенной точности %qs"
  
  #: common.opt:1285
  msgid "Output lto objects containing both the intermediate language and binary output."
-msgstr ""
+msgstr "Выводить в объектные файлы lto и промежуточное, и бинарное представление"
  
  #: common.opt:1289
  #, fuzzy
@@ -16261,8 +17190,9 @@ msgstr "Предполагать что результаты вычислени
  
  #: common.opt:1293
  #, fuzzy
+#| msgid "-ffixed-<register>\tMark <register> as being unavailable to the compiler"
  msgid "-ffixed-<register>\tMark <register> as being unavailable to the compiler."
-msgstr "Не использовать <регистр> при генерации кода"
+msgstr "-ffixed-<register>\tНе использовать <регистр> при генерации кода"
  
  #: common.opt:1297
  #, fuzzy
@@ -16272,17 +17202,18 @@ msgstr "Не выделять для значений типа float и double 
  
  #: common.opt:1305
  #, fuzzy
+#| msgid "Perform a forward propagation pass on RTL"
  msgid "Perform a forward propagation pass on RTL."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð¾Ð² Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð½Ð° Ð´Ñ\80ÐµÐ²Ð¾Ð²Ð¸Ð´Ð½Ð¾Ð¼ Ð¿Ñ\80ÐµÐ´Ñ\81Ñ\82Ð°Ð²Ð»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f Ð½Ð° Ð¿Ñ\80ÐµÐ´Ñ\81Ñ\82Ð°Ð²Ð»ÐµÐ½Ð¸Ð¸ RTL"
  
  #: common.opt:1309
  msgid "-ffp-contract=[off|on|fast] Perform floating-point expression contraction."
-msgstr ""
+msgstr "-ffp-contract=[off|on|fast] Выполнить сокращение выражений с плавающей точкой."
  
  #: common.opt:1312
-#, fuzzy, c-format
+#, c-format
  msgid "unknown floating point contraction style %qs"
-msgstr "не плавающий аргумент в вызове функции %qs"
+msgstr "некорректный аргумент %qs ключа -ffp-contract"
  
  #: common.opt:1329
  #, fuzzy
@@ -16315,12 +17246,14 @@ msgid "Perform store motion after global common subexpression elimination."
  msgstr "В рамках глобальной экономии общих подвыражений выполнить перенос записей в память между блоками"
  
  #: common.opt:1349
+#, fuzzy
+#| msgid "Perform redundant load after store elimination in global common subexpression elimination"
  msgid "Perform redundant load after store elimination in global common subexpression"
  msgstr "В рамках глобальной экономии общих подвыражений исключать лишние чтения из памяти после записей по тем же адресам"
  
  #: common.opt:1354
  #, fuzzy
-#| msgid "Perform global common subexpression elimination after register allocation"
+#| msgid "Perform global common subexpression elimination after register allocation has finished"
  msgid "Perform global common subexpression elimination after register allocation has"
  msgstr "Выполнить глобальную экономию общих подвыражений после распределения регистров"
  
@@ -16330,31 +17263,40 @@ msgstr ""
  
  #: common.opt:1376
  #, fuzzy
+#| msgid "Enable in and out of Graphite representation"
  msgid "Enable in and out of Graphite representation."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ñ\83Ð´Ð°Ð»ÐµÐ½Ð¸Ñ\8f Ð¼ÐµÑ\80Ñ\82Ð²Ñ\8bÑ\85 ÐºÐ¾Ð¼Ð°Ð½Ð´ Ð·Ð°Ð¿Ð¸Ñ\81Ð¸ Ð² Ð¿Ð°Ð¼Ñ\8fÑ\82Ñ\8c"
+msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ð²Ð²Ð¾Ð´ Ð¸ Ð²Ñ\8bÐ²Ð¾Ð´ Ð¿Ñ\80ÐµÐ´Ñ\81Ñ\82Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Graphite"
  
  #: common.opt:1380
  #, fuzzy
+#| msgid "Enable Graphite Identity transformation"
  msgid "Enable Graphite Identity transformation."
-msgstr "Ð\92Ñ\8bÐ´Ð°Ð²Ð°Ñ\82Ñ\8c Ð³Ñ\80Ð°Ñ\84 Ð²Ñ\8bÐ·Ð¾Ð²Ð¾Ð²"
+msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\86Ð¸Ð¸ Graphite"
  
  #: common.opt:1384
  #, fuzzy
+#| msgid "Enable hoisting loads from conditional pointers."
  msgid "Enable hoisting adjacent loads to encourage generating conditional move"
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ñ\8bÐµ ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b move"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÑ\82Ñ\8c Ð¿Ð¾Ð´Ð½Ñ\8fÑ\82Ð¸Ðµ Ð·Ð°Ð³Ñ\80Ñ\83Ð·Ð¾Ðº Ð¿Ð¾ Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ñ\8bÐ¼ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8fÐ¼"
  
  #: common.opt:1393
+#, fuzzy
+#| msgid "Mark all loops as parallel"
  msgid "Mark all loops as parallel."
-msgstr ""
+msgstr "Пометить все циклы как параллельные"
  
  #: common.opt:1397 common.opt:1401 common.opt:1405 common.opt:1409
  #: common.opt:2395
+#, fuzzy
+#| msgid "Enable loop interchange transforms.  Same as -floop-interchange"
  msgid "Enable loop nest transforms.  Same as -floop-nest-optimize."
-msgstr ""
+msgstr "Включить трансформации обмена циклов. То же, что -floop-interchange"
  
  #: common.opt:1413
+#, fuzzy
+#| msgid "Enable support for GNU transactional memory"
  msgid "Enable support for GNU transactional memory."
-msgstr ""
+msgstr "Включить поддержку транзакционной памяти GNU"
  
  #: common.opt:1417
  msgid "Use STB_GNU_UNIQUE if supported by the assembler."
@@ -16367,8 +17309,10 @@ msgid "Enable the loop nest optimizer."
  msgstr "Выполнить оптимизацию циклов дважды"
  
  #: common.opt:1429
+#, fuzzy
+#| msgid "Force bitfield accesses to match their type width"
  msgid "Force bitfield accesses to match their type width."
-msgstr ""
+msgstr "Генерировать доступ к битовым полям в соответствии с шириной их типа"
  
  #: common.opt:1433
  #, fuzzy
@@ -16400,17 +17344,21 @@ msgstr ""
  
  #: common.opt:1456
  #, fuzzy, c-format
+#| msgid "unknown TLS model %qs"
  msgid "unknown Stack Reuse Level %qs"
-msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¼Ð°Ñ\88Ð¸Ð½Ð½Ñ\8bÐ¹ Ñ\80ÐµÐ¶Ð¸Ð¼ %qs"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¼Ð¾Ð´ÐµÐ»Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ð´Ð° TLS %qs"
  
  #: common.opt:1469
  #, fuzzy
+#| msgid "Convert conditional jumps in innermost loops to branchless equivalents"
  msgid "Convert conditional jumps in innermost loops to branchless equivalents."
-msgstr "Преобразовывать условные переходы в эквивалентный код без переходов"
+msgstr "Преобразовывать условные переходы во внутренних циклах в эквивалентный код без переходов"
  
  #: common.opt:1473
+#, fuzzy
+#| msgid "Also if-convert conditional jumps containing memory writes"
  msgid "Also if-convert conditional jumps containing memory writes."
-msgstr ""
+msgstr "Применить if-конверсию к условным переходам, включающим запись в память"
  
  #: common.opt:1481
  #, fuzzy
@@ -16420,36 +17368,43 @@ msgstr "Не генерировать директивы .size"
  
  #: common.opt:1485
  #, fuzzy
+#| msgid "Perform indirect inlining"
  msgid "Perform indirect inlining."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c inline-Ð¿Ð¾Ð´Ñ\81Ñ\82Ð°Ð½Ð¾Ð²ÐºÐ¸ Ð½Ð° Ñ\80Ð°Ð½Ð½Ð¸Ñ\85 Ð¿Ñ\80Ð¾Ñ\85Ð¾Ð´Ð°Ñ\85 Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c inline-Ð¿Ð¾Ð´Ñ\81Ñ\82Ð°Ð½Ð¾Ð²ÐºÐ¸ ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ñ\8bÑ\85 Ð²Ñ\8bÐ·Ð¾Ð²Ð¾Ð²"
  
  #: common.opt:1491
+#, fuzzy
+#| msgid "Enable inlining of function declared \"inline\", disabling disables all inlining"
  msgid "Enable inlining of function declared \"inline\", disabling disables all inlining."
-msgstr ""
+msgstr "Включить inline-подстановки функций со спецификатором \"inline\", отмена отключает все inline-подстановки"
  
  #: common.opt:1495
  #, fuzzy
+#| msgid "Integrate functions into their callers when code size is known not to grow"
  msgid "Integrate functions into their callers when code size is known not to grow."
-msgstr "Подставлять тела простых функций в места вызовов"
+msgstr "Подставлять тела функций в места вызовов, когда это не увеличивает размер кода"
  
  #: common.opt:1499
  #, fuzzy
+#| msgid "Integrate functions not declared \"inline\" into their callers when profitable"
  msgid "Integrate functions not declared \"inline\" into their callers when profitable."
-msgstr "Подставлять тела функций, вызываемых один раз, в места вызовов"
+msgstr "Подставлять тела функций без спецификатора \"inline\" в места вызова, когда это выгодно"
  
  #: common.opt:1503
  #, fuzzy
+#| msgid "Integrate functions only required by their single caller"
  msgid "Integrate functions only required by their single caller."
-msgstr "Подставлять тела функций, вызываемых один раз, в места вызовов"
+msgstr "Подставлять в места вызовов тела функций, вызываемых только один раз"
  
  #: common.opt:1510
  #, fuzzy
+#| msgid "-finline-limit=<number>\tLimit the size of inlined functions to <number>"
  msgid "-finline-limit=<number>\tLimit the size of inlined functions to <number>."
-msgstr "Максимальный <размер> функций для inline-подстановки"
+msgstr "-finline-limit=<размер>\tМаксимальный <размер> функций для inline-подстановки"
  
  #: common.opt:1514
  msgid "Inline __atomic operations when a lock free instruction sequence is available."
-msgstr ""
+msgstr "Делать подстановку операций __atomic, если имеется соответствующая неблокирующая последовательность инструкций"
  
  #: common.opt:1518
  #, fuzzy
@@ -16458,12 +17413,16 @@ msgid "Instrument function entry and exit with profiling calls."
  msgstr "При входе и выходе из функции генерировать вызовы профилирования"
  
  #: common.opt:1522
+#, fuzzy
+#| msgid "-finstrument-functions-exclude-function-list=name,...  Do not instrument listed functions"
  msgid "-finstrument-functions-exclude-function-list=name,...  Do not instrument listed functions."
-msgstr ""
+msgstr "-finstrument-functions-exclude-function-list=name,...  Не инструментировать перечисленные функции"
  
  #: common.opt:1526
+#, fuzzy
+#| msgid "-finstrument-functions-exclude-file-list=filename,...  Do not instrument functions listed in files"
  msgid "-finstrument-functions-exclude-file-list=filename,...  Do not instrument functions listed in files."
-msgstr ""
+msgstr "-finstrument-functions-exclude-file-list=filename,...  Не инструментировать функции, перечисленные в указанных файлах"
  
  #: common.opt:1530
  #, fuzzy
@@ -16473,23 +17432,27 @@ msgstr "Выполнить межпроцедурное распростране
  
  #: common.opt:1534
  #, fuzzy
+#| msgid "Perform cloning to make Interprocedural constant propagation stronger"
  msgid "Perform cloning to make Interprocedural constant propagation stronger."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¼ÐµÐ¶Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð½Ð¾Ðµ Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ðµ констант"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c ÐºÐ»Ð¾Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð´Ð»Ñ\8f Ñ\83Ñ\81Ð¸Ð»ÐµÐ½Ð¸Ñ\8f Ð¼ÐµÐ¶Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð½Ð¾Ð³Ð¾ Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f констант"
  
  #: common.opt:1538
  #, fuzzy
+#| msgid "Perform cloning to make Interprocedural constant propagation stronger"
  msgid "Perform alignment discovery and propagation to make Interprocedural constant propagation stronger."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¼ÐµÐ¶Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð½Ð¾Ðµ Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ðµ констант"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c ÐºÐ»Ð¾Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð´Ð»Ñ\8f Ñ\83Ñ\81Ð¸Ð»ÐµÐ½Ð¸Ñ\8f Ð¼ÐµÐ¶Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð½Ð¾Ð³Ð¾ Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f констант"
  
  #: common.opt:1542
  #, fuzzy
+#| msgid "Perform interprocedural profile propagation"
  msgid "Perform interprocedural profile propagation."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¼ÐµÐ¶Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð½Ð¾Ðµ Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¼ÐµÐ¶Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð½Ð¾Ðµ Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¾Ñ\84Ð¸Ð»Ñ\8f"
  
  #: common.opt:1546
  #, fuzzy
+#| msgid "Perform interprocedural points-to analysis"
  msgid "Perform interprocedural points-to analysis."
-msgstr "Выполнить межпроцедурное распространение констант"
+msgstr "Выполнить межпроцедурный анализ указателей"
  
  #: common.opt:1550
  #, fuzzy
@@ -16516,38 +17479,44 @@ msgid "Discover readonly and non addressable static variables."
  msgstr "Выявлять неадресуемые статические переменные, доступные только для чтения"
  
  #: common.opt:1578
+#, fuzzy
+#| msgid "-fira-algorithm=[CB|priority] Set the used IRA algorithm"
  msgid "-fira-algorithm=[CB|priority] Set the used IRA algorithm."
-msgstr ""
+msgstr "-fira-algorithm=[CB|priority] Задать алгоритм раскраски для распределения регистров"
  
  #: common.opt:1581
-#, fuzzy, c-format
+#, c-format
  msgid "unknown IRA algorithm %qs"
-msgstr "неизвестная машинный режим %qs"
+msgstr "неизвестный алгоритм раскраски %qs"
  
  #: common.opt:1591
+#, fuzzy
+#| msgid "-fira-region=[one|all|mixed] Set regions for IRA"
  msgid "-fira-region=[one|all|mixed] Set regions for IRA."
-msgstr ""
+msgstr "-fira-region=[one|all|mixed] Задать регионы для IRA"
  
  #: common.opt:1594
-#, fuzzy, c-format
+#, c-format
  msgid "unknown IRA region %qs"
-msgstr "неизвестное имя регистра: %s"
+msgstr "неизвестный регион %qs для распределения регистров"
  
  #: common.opt:1607 common.opt:1612
+#, fuzzy
+#| msgid "Use IRA based register pressure calculation in RTL loop optimizations."
  msgid "Use IRA based register pressure calculation"
-msgstr ""
+msgstr "Использовать IRA для оценки регистрового давления в RTL-оптимизациях циклов"
  
  #: common.opt:1617
  msgid "Share slots for saving different hard registers."
-msgstr ""
+msgstr "Использовать общие слоты стека для сохранения разных аппаратных регистров"
  
  #: common.opt:1621
  msgid "Share stack slots for spilled pseudo-registers."
-msgstr ""
+msgstr "Использовать общие слоты стека для сохранения вытолкнутых псевдорегистров"
  
  #: common.opt:1625
  msgid "-fira-verbose=<number>\tControl IRA's level of diagnostic messages."
-msgstr ""
+msgstr "-fira-verbose=<уровень>\tЗадать <уровень> диагностики IRA."
  
  #: common.opt:1629
  #, fuzzy
@@ -16590,26 +17559,28 @@ msgid "Do CFG-sensitive rematerialization in LRA."
  msgstr ""
  
  #: common.opt:1661
-#, fuzzy
  msgid "Enable link-time optimization."
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²ÐºÐ¸"
+msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð¸ ÐºÐ¾Ð¼Ð¿Ð¾Ð½Ð¾Ð²ÐºÐ¸."
  
  #: common.opt:1665
  msgid "Link-time optimization with number of parallel jobs or jobserver."
-msgstr ""
+msgstr "Включить оптимизации времени компоновки с заданным числом параллельных задач или с использованием сервера задач"
  
  #: common.opt:1668
  #, fuzzy, c-format
+#| msgid "unknown TLS model %qs"
  msgid "unknown LTO partitioning model %qs"
-msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¼Ð°Ñ\88Ð¸Ð½Ð½Ñ\8bÐ¹ Ñ\80ÐµÐ¶Ð¸Ð¼ %qs"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¼Ð¾Ð´ÐµÐ»Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ð´Ð° TLS %qs"
  
  #: common.opt:1687
  msgid "Specify the algorithm to partition symbols and vars at linktime."
  msgstr ""
  
  #: common.opt:1692
+#, fuzzy
+#| msgid "-flto-compression-level=<number>\tUse zlib compression level <number> for IL"
  msgid "-flto-compression-level=<number>\tUse zlib compression level <number> for IL."
-msgstr ""
+msgstr "-flto-compression-level=<уровень>\tИспользовать заданный <уровень> сжатия zlib для промежуточного представления."
  
  #: common.opt:1696
  msgid "Merge C++ types using One Definition Rule."
@@ -16617,13 +17588,15 @@ msgstr ""
  
  #: common.opt:1700
  #, fuzzy
+#| msgid "Report various link-time optimization statistics"
  msgid "Report various link-time optimization statistics."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿ÐµÑ\80ÐµÐ¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²"
+msgstr "Ð\92Ñ\8bÐ´Ð°Ñ\82Ñ\8c Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\81Ñ\82Ð¸ÐºÑ\83 Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð¸ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8f"
  
  #: common.opt:1704
  #, fuzzy
+#| msgid "Report various link-time optimization statistics"
  msgid "Report various link-time optimization statistics for WPA only."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿ÐµÑ\80ÐµÐ¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²"
+msgstr "Ð\92Ñ\8bÐ´Ð°Ñ\82Ñ\8c Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\81Ñ\82Ð¸ÐºÑ\83 Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð¸ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8f"
  
  #: common.opt:1708
  #, fuzzy
@@ -16633,8 +17606,9 @@ msgstr "Устанавливать errno после вызовов встрое
  
  #: common.opt:1712
  #, fuzzy
+#| msgid "-fmax-errors=<number>\tMaximum number of errors to report"
  msgid "-fmax-errors=<number>\tMaximum number of errors to report."
-msgstr "Максимальный коэффициент развертки цикла"
+msgstr "-fmax-errors=<number>\tМаксимальное число сообщений об ошибках"
  
  #: common.opt:1716
  #, fuzzy
@@ -16644,6 +17618,7 @@ msgstr "Вывести информацию о распределении пам
  
  #: common.opt:1720
  #, fuzzy
+#| msgid "Report on permanent memory allocation"
  msgid "Report on permanent memory allocation in WPA only."
  msgstr "Вывести информацию о распределении памяти"
  
@@ -16661,13 +17636,15 @@ msgstr "Слить идентичные константы по всем еди
  
  #: common.opt:1735
  #, fuzzy
+#| msgid "Attempt to merge identical debug strings across compilation units"
  msgid "Attempt to merge identical debug strings across compilation units."
-msgstr "Ð¡Ð»Ð¸Ñ\82Ñ\8c Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\87Ð½Ñ\8bÐµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ñ\8b Ð¿Ð¾ Ð²Ñ\81ÐµÐ¼ ÐµÐ´Ð¸Ð½Ð¸Ñ\86Ð°Ð¼ компиляции"
+msgstr "Ð\9fÐ¾Ð¿Ñ\8bÑ\82Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ñ\81Ð»Ð¸Ñ\82Ñ\8c Ð¾Ð´Ð¸Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐµ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð² Ð¾Ñ\82Ð»Ð°Ð´Ð¾Ñ\87Ð½Ð¾Ð¹ Ð¸Ð½Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\86Ð¸Ð¸ Ð´Ð»Ñ\8f Ð²Ñ\81ÐµÑ\85 ÐµÐ´Ð¸Ð½Ð¸Ñ\86 компиляции"
  
  #: common.opt:1739
  #, fuzzy
+#| msgid "-fmessage-length=<number>\tLimit diagnostics to <number> characters per line.  0 suppresses line-wrapping"
  msgid "-fmessage-length=<number>\tLimit diagnostics to <number> characters per line.  0 suppresses line-wrapping."
-msgstr "Установить <длину> строк диагностических сообщений в символах. 0 - подавить разбиение на строки"
+msgstr "-fmessage-length=<длина>\tУстановить <длину> строк диагностических сообщений в символах. 0 - подавить разбиение на строки"
  
  #: common.opt:1743
  #, fuzzy
@@ -16677,6 +17654,7 @@ msgstr "Выполнять планирование циклов по модул
  
  #: common.opt:1747
  #, fuzzy
+#| msgid "Perform SMS based modulo scheduling with register moves allowed"
  msgid "Perform SMS based modulo scheduling with register moves allowed."
  msgstr "Выполнять планирование циклов по модулю методом SMS перед первым проходом планирования команд"
  
@@ -16688,13 +17666,15 @@ msgstr "Выносить инвариантные вычисления за пр
  
  #: common.opt:1755
  #, fuzzy
+#| msgid "Use the RTL dead code elimination pass"
  msgid "Use the RTL dead code elimination pass."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ñ\83Ð´Ð°Ð»ÐµÐ½Ð¸Ñ\8f Ð¼ÐµÑ\80Ñ\82Ð²Ñ\8bÑ\85 ÐºÐ¾Ð¼Ð°Ð½Ð´ Ð·Ð°Ð¿Ð¸Ñ\81Ð¸ Ð² Ð¿Ð°Ð¼Ñ\8fÑ\82Ñ\8c"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ñ\83Ð´Ð°Ð»ÐµÐ½Ð¸Ñ\8f Ð¼ÐµÑ\80Ñ\82Ð²Ñ\8bÑ\85 ÐºÐ¾Ð¼Ð°Ð½Ð´ Ð² RTL-Ð¿Ñ\80ÐµÐ´Ñ\81Ñ\82Ð°Ð²Ð»ÐµÐ½Ð¸Ð¸"
  
  #: common.opt:1759
  #, fuzzy
+#| msgid "Use the RTL dead store elimination pass"
  msgid "Use the RTL dead store elimination pass."
-msgstr "Выполнить оптимизацию удаления мертвых команд записи в память"
+msgstr "Выполнить оптимизацию удаления мертвых команд записи в память в RTL-представлении"
  
  #: common.opt:1763
  #, fuzzy
@@ -16724,8 +17704,9 @@ msgstr ""
  
  #: common.opt:1778
  #, fuzzy, c-format
+#| msgid "unknown TLS model %qs"
  msgid "unknown offload ABI %qs"
-msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¼Ð°Ñ\88Ð¸Ð½Ð½Ñ\8bÐ¹ Ñ\80ÐµÐ¶Ð¸Ð¼ %qs"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¼Ð¾Ð´ÐµÐ»Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ð´Ð° TLS %qs"
  
  #: common.opt:1788
  #, fuzzy
@@ -16735,6 +17716,7 @@ msgstr "По возможности не создавать кадры стек
  
  #: common.opt:1792
  #, fuzzy
+#| msgid "Enable loop optimizations on tree level"
  msgid "Enable all optimization info dumps on stderr."
  msgstr "Включить оптимизации циклов на древовидном представлении"
  
@@ -16750,12 +17732,15 @@ msgstr "Оптимизировать парные вызовы и хвостов
  
  #: common.opt:1808
  #, fuzzy
+#| msgid "Perform partial inlining"
  msgid "Perform partial inlining."
-msgstr "Выполнить inline-подстановки на ранних проходах оптимизации"
+msgstr "Выполнить частичные inline-подстановки"
  
  #: common.opt:1812 common.opt:1816
+#, fuzzy
+#| msgid "Report on memory allocation before interprocedural optimization"
  msgid "Report on memory allocation before interprocedural optimization."
-msgstr ""
+msgstr "Выдать отчет о распределении памяти перед межпроцедурными оптимизациями"
  
  #: common.opt:1820
  #, fuzzy
@@ -16765,8 +17750,9 @@ msgstr "Паковать поля структур без дыр"
  
  #: common.opt:1824
  #, fuzzy
+#| msgid "-fpack-struct=<number>\tSet initial maximum structure member alignment"
  msgid "-fpack-struct=<number>\tSet initial maximum structure member alignment."
-msgstr "Установить начальное максимальное выравнивание для элементов структур"
+msgstr "-fpack-struct=<number>\tУстановить начальное максимальное выравнивание для элементов структур"
  
  #: common.opt:1828
  #, fuzzy
@@ -16822,17 +17808,19 @@ msgstr ""
  
  #: common.opt:1864
  #, fuzzy
+#| msgid "Specify a plugin to load"
  msgid "Specify a plugin to load."
-msgstr "Ð\97Ð°Ð´Ð°Ñ\82Ñ\8c ÐºÐ»Ñ\8eÑ\87Ð¸ GNAT"
+msgstr "Ð\97Ð°Ð´Ð°Ñ\82Ñ\8c Ð¿Ð¾Ð´Ð³Ñ\80Ñ\83Ð¶Ð°ÐµÐ¼Ñ\8bÐ¹ Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8c"
  
  #: common.opt:1868
+#, fuzzy
+#| msgid "-fplugin-arg-<name>-<key>[=<value>]\tSpecify argument <key>=<value> for plugin <name>"
  msgid "-fplugin-arg-<name>-<key>[=<value>]\tSpecify argument <key>=<value> for plugin <name>."
-msgstr ""
+msgstr "-fplugin-arg-<name>-<key>[=<value>]\tЗадать аргумент <key>=<value> для подгружаемого модуля <name>"
  
  #: common.opt:1872
-#, fuzzy
  msgid "Run predictive commoning optimization."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿ÐµÑ\80ÐµÐ¼ÐµÑ\89ÐµÐ½Ð¸Ñ\8f Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿ÐµÑ\80ÐµÐ¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¹"
  
  #: common.opt:1876
  #, fuzzy
@@ -16853,12 +17841,16 @@ msgid "Insert arc-based program profiling code."
  msgstr "Вставлять код для профилирования по дугам управляющего графа программы"
  
  #: common.opt:1888
+#, fuzzy
+#| msgid "Set the top-level directory for storing the profile data. The default is 'pwd'."
  msgid "Set the top-level directory for storing the profile data."
-msgstr ""
+msgstr "Указать каталог верхнего уровня для сохранения данных профилирования. По умолчанию 'pwd'."
  
  #: common.opt:1893
+#, fuzzy
+#| msgid "Enable correction of flow inconsistent profile data input"
  msgid "Enable correction of flow inconsistent profile data input."
-msgstr ""
+msgstr "Включить коррекцию несовместимых с потоком управления данных профилирования"
  
  #: common.opt:1897
  #, fuzzy
@@ -16868,8 +17860,9 @@ msgstr "Активировать ключи генерации данных пр
  
  #: common.opt:1901
  #, fuzzy
+#| msgid "Enable common options for generating profile info for profile feedback directed optimizations, and set -fprofile-dir="
  msgid "Enable common options for generating profile info for profile feedback directed optimizations, and set -fprofile-dir=."
-msgstr "Активировать ключи генерации данных профилирования для выполнения соответствующих оптимизаций"
+msgstr "Активировать ключи генерации данных профилирования для выполнения соответствующих оптимизаций и установить -fprofile-dir="
  
  #: common.opt:1905
  #, fuzzy
@@ -16879,8 +17872,9 @@ msgstr "Активировать ключи оптимизаций, основа
  
  #: common.opt:1909
  #, fuzzy
+#| msgid "Enable common options for performing profile feedback directed optimizations, and set -fprofile-dir="
  msgid "Enable common options for performing profile feedback directed optimizations, and set -fprofile-dir=."
-msgstr "Активировать ключи оптимизаций, основанных на данных профилирования"
+msgstr "Активировать ключи оптимизаций, основанных на данных профилирования и установить -fprofile-dir="
  
  #: common.opt:1913
  #, fuzzy
@@ -16890,6 +17884,7 @@ msgstr "Вставлять код для профилирования значе
  
  #: common.opt:1917
  #, fuzzy
+#| msgid "internal consistency failure"
  msgid "Report on consistency of profile."
  msgstr "обнаружена несогласованность внутреннего представления gcc"
  
@@ -16901,26 +17896,29 @@ msgstr "Переупорядочить функции для улучшения
  
  #: common.opt:1928
  #, fuzzy
+#| msgid "-frandom-seed=<string>\tMake compile reproducible using <string>"
  msgid "-frandom-seed=<string>\tMake compile reproducible using <string>."
-msgstr "Компилировать воспроизводимым образом, используя <строку> для генерации случайных чисел"
+msgstr "-frandom-seed=<строка>\tКомпилировать воспроизводимым образом, используя <строку> для генерации случайных чисел"
  
  #: common.opt:1938
  msgid "Record gcc command line switches in the object file."
-msgstr ""
+msgstr "Записать ключи командной строки gcc в объектный файл"
  
  #: common.opt:1942
  #, fuzzy
  #| msgid "Return small aggregates in registers"
  msgid "Return small aggregates in registers."
-msgstr "Возвращать короткие агрегатные в регистрах"
+msgstr "Ð\92Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°Ñ\82Ñ\8c ÐºÐ¾Ñ\80Ð¾Ñ\82ÐºÐ¸Ðµ Ð°Ð³Ñ\80ÐµÐ³Ð°Ñ\82Ð½Ñ\8bÐµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ð² Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð°Ñ\85"
  
  #: common.opt:1950
  msgid "Tell DSE that the storage for a C++ object is dead when the constructor"
  msgstr ""
  
  #: common.opt:1958
+#, fuzzy
+#| msgid "Enable register pressure sensitive insn scheduling"
  msgid "Relief of register pressure through live range shrinkage."
-msgstr ""
+msgstr "Использовать планирование команд с учетом регистрового давления"
  
  #: common.opt:1962
  #, fuzzy
@@ -16946,8 +17944,9 @@ msgstr ""
  
  #: common.opt:1977
  #, fuzzy, c-format
+#| msgid "unknown IRA algorithm %qs"
  msgid "unknown basic block reordering algorithm %qs"
-msgstr "неизвестная машинный режим %qs"
+msgstr "неизвестный алгоритм раскраски %qs"
  
  #: common.opt:1987
  #, fuzzy
@@ -16981,8 +17980,9 @@ msgstr "Планировать команды в рамках нескольки
  
  #: common.opt:2011
  #, fuzzy
+#| msgid "Enable register pressure sensitive insn scheduling"
  msgid "Enable register pressure sensitive insn scheduling."
-msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\83Ñ\80Ð¾Ð²ÐµÐ½Ñ\8c Ð¿Ð¾Ð´Ñ\80Ð¾Ð±Ð½Ð¾Ñ\81Ñ\82Ð¸ Ñ\81Ð¾Ð¾Ð±Ñ\89ÐµÐ½Ð¸Ð¹ Ð¾Ñ\82 Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ð¾Ð²Ñ\89Ð¸ÐºÐ°"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð»Ð°Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ ÐºÐ¾Ð¼Ð°Ð½Ð´ Ñ\81 Ñ\83Ñ\87ÐµÑ\82Ð¾Ð¼ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²Ð¾Ð³Ð¾ Ð´Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f"
  
  #: common.opt:2015
  #, fuzzy
@@ -17004,8 +18004,9 @@ msgstr "Разрешить более активный спекулятивны
  
  #: common.opt:2027
  #, fuzzy
+#| msgid "-fsched-verbose=<number>\tSet the verbosity level of the scheduler"
  msgid "-fsched-verbose=<number>\tSet the verbosity level of the scheduler."
-msgstr "Установить уровень подробности сообщений от планировщика"
+msgstr "-fsched-verbose=<уровень>\tУстановить <уровень> подробности сообщений от планировщика"
  
  #: common.opt:2031
  #, fuzzy
@@ -17026,24 +18027,34 @@ msgid "Reschedule instructions after register allocation."
  msgstr "Планировать код после распределения регистров"
  
  #: common.opt:2050
+#, fuzzy
+#| msgid "Schedule instructions using selective scheduling algorithm"
  msgid "Schedule instructions using selective scheduling algorithm."
-msgstr ""
+msgstr "Использовать алгоритм селективного планирования команд"
  
  #: common.opt:2054
+#, fuzzy
+#| msgid "Run selective scheduling after reload"
  msgid "Run selective scheduling after reload."
-msgstr ""
+msgstr "Выполнить селективное планирование после прохода перегрузки регистров"
  
  #: common.opt:2058
+#, fuzzy
+#| msgid "Perform software pipelining of inner loops during selective scheduling"
  msgid "Perform software pipelining of inner loops during selective scheduling."
-msgstr ""
+msgstr "Выполнить программную конвейеризацию внутренних циклов во время селективного планирования"
  
  #: common.opt:2062
+#, fuzzy
+#| msgid "Perform software pipelining of outer loops during selective scheduling"
  msgid "Perform software pipelining of outer loops during selective scheduling."
-msgstr ""
+msgstr "Выполнить программную конвейеризацию внешних циклов во время селективного планирования"
  
  #: common.opt:2066
+#, fuzzy
+#| msgid "Reschedule pipelined regions without pipelining"
  msgid "Reschedule pipelined regions without pipelining."
-msgstr ""
+msgstr "Перепланировать конвейеризованные области без конвейеризации"
  
  #: common.opt:2070
  msgid "Allow interposing function (or variables) by ones with different semantics (or initializer) respectively by dynamic linker."
@@ -17057,8 +18068,9 @@ msgstr "Разрешить предварительное планировани
  
  #: common.opt:2080
  #, fuzzy
+#| msgid "-fsched-stalled-insns=<number>\tSet number of queued insns that can be prematurely scheduled"
  msgid "-fsched-stalled-insns=<number>\tSet number of queued insns that can be prematurely scheduled."
-msgstr "Число отложенных команд, подлежащих предварительному планированию"
+msgstr "-fsched-stalled-insns=<число>\tЗадать <число> отложенных команд, подлежащих предварительному планированию"
  
  #: common.opt:2088
  #, fuzzy
@@ -17068,55 +18080,67 @@ msgstr "Включить проверку дальности зависимос
  
  #: common.opt:2092
  #, fuzzy
+#| msgid "-fsched-stalled-insns-dep=<number>\tSet dependence distance checking in premature scheduling of queued insns"
  msgid "-fsched-stalled-insns-dep=<number>\tSet dependence distance checking in premature scheduling of queued insns."
-msgstr "Включить проверку дальности зависимостей при предварительном планировании отложенных команд"
+msgstr "-fsched-stalled-insns-dep=<number>\tВключить проверку дистанции зависимостей при предварительном планировании отложенных команд"
  
  #: common.opt:2096
  #, fuzzy
+#| msgid "Enable the group heuristic in the scheduler"
  msgid "Enable the group heuristic in the scheduler."
-msgstr "Установить уровень подробности сообщений от планировщика"
+msgstr "Установить групповую эвристику для планировщика"
  
  #: common.opt:2100
  #, fuzzy
+#| msgid "Enable the critical path heuristic in the scheduler"
  msgid "Enable the critical path heuristic in the scheduler."
-msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\83Ñ\80Ð¾Ð²ÐµÐ½Ñ\8c Ð¿Ð¾Ð´Ñ\80Ð¾Ð±Ð½Ð¾Ñ\81Ñ\82Ð¸ Ñ\81Ð¾Ð¾Ð±Ñ\89ÐµÐ½Ð¸Ð¹ Ð¾Ñ\82 планировщика"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\8dÐ²Ñ\80Ð¸Ñ\81Ñ\82Ð¸ÐºÑ\83 ÐºÑ\80Ð¸Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ð¿Ñ\83Ñ\82Ð¸ Ð´Ð»Ñ\8f планировщика"
  
  #: common.opt:2104
  #, fuzzy
+#| msgid "Enable the speculative instruction heuristic in the scheduler"
  msgid "Enable the speculative instruction heuristic in the scheduler."
-msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\83Ñ\80Ð¾Ð²ÐµÐ½Ñ\8c Ð¿Ð¾Ð´Ñ\80Ð¾Ð±Ð½Ð¾Ñ\81Ñ\82Ð¸ Ñ\81Ð¾Ð¾Ð±Ñ\89ÐµÐ½Ð¸Ð¹ Ð¾Ñ\82 планировщика"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\8dÐ²Ñ\80Ð¸Ñ\81Ñ\82Ð¸ÐºÑ\83 Ñ\81Ð¿ÐµÐºÑ\83Ð»Ñ\8fÑ\82Ð¸Ð²Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8f ÐºÐ¾Ð¼Ð°Ð½Ð´ Ð´Ð»Ñ\8f планировщика"
  
  #: common.opt:2108
  #, fuzzy
+#| msgid "Enable the rank heuristic in the scheduler"
  msgid "Enable the rank heuristic in the scheduler."
-msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\83Ñ\80Ð¾Ð²ÐµÐ½Ñ\8c Ð¿Ð¾Ð´Ñ\80Ð¾Ð±Ð½Ð¾Ñ\81Ñ\82Ð¸ Ñ\81Ð¾Ð¾Ð±Ñ\89ÐµÐ½Ð¸Ð¹ Ð¾Ñ\82 планировщика"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\8dÐ²Ñ\80Ð¸Ñ\81Ñ\82Ð¸ÐºÑ\83 Ñ\80Ð°Ð½Ð¶Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð´Ð»Ñ\8f планировщика"
  
  #: common.opt:2112
  #, fuzzy
+#| msgid "Enable the last instruction heuristic in the scheduler"
  msgid "Enable the last instruction heuristic in the scheduler."
-msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\83Ñ\80Ð¾Ð²ÐµÐ½Ñ\8c Ð¿Ð¾Ð´Ñ\80Ð¾Ð±Ð½Ð¾Ñ\81Ñ\82Ð¸ Ñ\81Ð¾Ð¾Ð±Ñ\89ÐµÐ½Ð¸Ð¹ Ð¾Ñ\82 планировщика"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\8dÐ²Ñ\80Ð¸Ñ\81Ñ\82Ð¸ÐºÑ\83 \"Ð¿Ð¾Ñ\81Ð»ÐµÐ´Ð½ÐµÐ¹ ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b\" Ð´Ð»Ñ\8f планировщика"
  
  #: common.opt:2116
  #, fuzzy
+#| msgid "Enable the dependent count heuristic in the scheduler"
  msgid "Enable the dependent count heuristic in the scheduler."
-msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\83Ñ\80Ð¾Ð²ÐµÐ½Ñ\8c Ð¿Ð¾Ð´Ñ\80Ð¾Ð±Ð½Ð¾Ñ\81Ñ\82Ð¸ Ñ\81Ð¾Ð¾Ð±Ñ\89ÐµÐ½Ð¸Ð¹ Ð¾Ñ\82 планировщика"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ñ\8dÐ²Ñ\80Ð¸Ñ\81Ñ\82Ð¸ÐºÑ\83 Ð¿Ð¾ Ñ\87Ð¸Ñ\81Ð»Ñ\83 Ð·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ñ\8bÑ\85 ÐºÐ¾Ð¼Ð°Ð½Ð´ Ð´Ð»Ñ\8f планировщика"
  
  #: common.opt:2120
+#, fuzzy
+#| msgid "Access data in the same section from shared anchor points"
  msgid "Access data in the same section from shared anchor points."
-msgstr ""
+msgstr "Использовать доступ к данным из одной секции по общим опорным точкам"
  
  #: common.opt:2132
  msgid "Turn on Redundant Extensions Elimination pass."
-msgstr ""
+msgstr "Включить проход исключения избыточных расширений данных"
  
  #: common.opt:2136
  #, fuzzy
+#| msgid "Show column numbers in diagnostics, when available.  Default on"
  msgid "Show column numbers in diagnostics, when available.  Default on."
-msgstr "Показывать номера колонок в диагностических сообщений. По умолчанию включено"
+msgstr "Показывать номера колонок в диагностических сообщениях, если возможно. По умолчанию включено"
  
  #: common.opt:2140
+#, fuzzy
+#| msgid "Emit function prologues only before parts of the function that need it, rather than at the top of the function."
  msgid "Emit function prologues only before parts of the function that need it,"
-msgstr ""
+msgstr "Выводить пролог функции только перед теми частями функции, которые используют его, а не в начале функции."
  
  #: common.opt:2145
  #, fuzzy
@@ -17125,8 +18149,10 @@ msgid "Disable optimizations observable by IEEE signaling NaNs."
  msgstr "Отменить оптимизации, влияющие на поведение сигнализирующих NaN по IEEE"
  
  #: common.opt:2149
+#, fuzzy
+#| msgid "Disable floating point optimizations that ignore the IEEE signedness of zero"
  msgid "Disable floating point optimizations that ignore the IEEE signedness of zero."
-msgstr ""
+msgstr "Отменить оптимизации вычислений с плавающей точкой и игнорировать знак нуля по IEEE"
  
  #: common.opt:2153
  #, fuzzy
@@ -17142,17 +18168,21 @@ msgstr "Разбивать диапазоны жизни индуктивных
  
  #: common.opt:2161
  #, fuzzy
+#| msgid "Generate discontiguous stack frames"
  msgid "Generate discontiguous stack frames."
-msgstr "Генерировать APCS-совместимые кадры стека"
+msgstr "Генерировать не непрерывные кадры стека"
  
  #: common.opt:2165
+#, fuzzy
+#| msgid "Split wide types into independent registers"
  msgid "Split wide types into independent registers."
-msgstr ""
+msgstr "Использовать независимые регистры для широких типов"
  
  #: common.opt:2169
  #, fuzzy
+#| msgid "Enable forward propagation on trees"
  msgid "Enable backward propagation of use properties at the SSA level."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÑ\82Ñ\8c Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ðµ ÐºÐ¾Ð¿Ð¸Ð¹ в древовидном представлении"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÑ\82Ñ\8c Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ðµ Ð²Ð¿ÐµÑ\80ÐµÐ´ в древовидном представлении"
  
  #: common.opt:2173
  msgid "Optimize conditional patterns using SSA PHI nodes."
@@ -17170,23 +18200,27 @@ msgstr "Выполнять расширение переменных при ра
  
  #: common.opt:2185
  #, fuzzy
+#| msgid "-fstack-check=[no|generic|specific]\tInsert stack checking code into the program"
  msgid "-fstack-check=[no|generic|specific]\tInsert stack checking code into the program."
-msgstr "Генерировать код для проверки стека"
+msgstr "-fstack-check=[no|generic|specific]\tГенерировать код для проверки стека"
  
  #: common.opt:2189
  #, fuzzy
+#| msgid "Insert stack checking code into the program.  Same as -fstack-check=specific"
  msgid "Insert stack checking code into the program.  Same as -fstack-check=specific."
-msgstr "Генерировать код для проверки стека"
+msgstr "Генерировать код для проверки стека. То же, что -fstack-check=specific"
  
  #: common.opt:2196
  #, fuzzy
+#| msgid "-fstack-limit-register=<register>\tTrap if the stack goes past <register>"
  msgid "-fstack-limit-register=<register>\tTrap if the stack goes past <register>."
-msgstr "Прерывание при переполнении стека, <регистр> задает границу стека"
+msgstr "-fstack-limit-register=<регистр>\tПрерывание при переполнении стека, <регистр> задает границу стека"
  
  #: common.opt:2200
  #, fuzzy
+#| msgid "-fstack-limit-symbol=<name>\tTrap if the stack goes past symbol <name>"
  msgid "-fstack-limit-symbol=<name>\tTrap if the stack goes past symbol <name>."
-msgstr "Прерывание при переполнении стека, <символ> задает границу стека"
+msgstr "-fstack-limit-symbol=<символ>\tПрерывание при переполнении стека, <символ> задает границу стека"
  
  #: common.opt:2204
  #, fuzzy
@@ -17214,8 +18248,9 @@ msgstr "Использовать защиту стека для каждой ф
  
  #: common.opt:2220
  #, fuzzy
+#| msgid "Output stack usage information on a per-function basis"
  msgid "Output stack usage information on a per-function basis."
-msgstr "Включить использование r30"
+msgstr "Выводить информацию об использовании стека для каждой функции"
  
  #: common.opt:2232
  #, fuzzy
@@ -17225,8 +18260,9 @@ msgstr "Предполагать строгое соблюдение прави
  
  #: common.opt:2236
  #, fuzzy
+#| msgid "Treat signed overflow as undefined"
  msgid "Treat signed overflow as undefined."
-msgstr "Ð¢Ñ\80Ð°ÐºÑ\82Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\89Ð¸Ðµ Ð·Ð°Ð³Ð¾Ð»Ð¾Ð²ÐºÐ¸ ÐºÐ°Ðº Ð³ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ñ\83ÐµÐ¼Ñ\8bÐµ Ñ\84Ð°Ð¹Ð»Ñ\8b"
+msgstr "Ð¢Ñ\80Ð°ÐºÑ\82Ð¾Ð²Ð°Ñ\82Ñ\8c Ð·Ð½Ð°ÐºÐ¾Ð²Ð¾Ðµ Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ ÐºÐ°Ðº Ð½ÐµÐ¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð¾Ðµ Ð¿Ð¾Ð²ÐµÐ´ÐµÐ½Ð¸Ðµ"
  
  #: common.opt:2240
  msgid "Implement __atomic operations via libcalls to legacy __sync functions."
@@ -17258,17 +18294,20 @@ msgstr "Показать время, затраченное на каждый п
  
  #: common.opt:2260
  #, fuzzy
+#| msgid "-ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]\tSet the default thread-local storage code generation model"
  msgid "-ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]\tSet the default thread-local storage code generation model."
-msgstr "Модель генерации кода для данных, локальных для потов, по умолчанию"
+msgstr "-ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]\tМодель генерации кода для данных, локальных для потов, по умолчанию"
  
  #: common.opt:2263
-#, fuzzy, c-format
+#, c-format
  msgid "unknown TLS model %qs"
-msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¼Ð°Ñ\88Ð¸Ð½Ð½Ñ\8bÐ¹ Ñ\80ÐµÐ¶Ð¸Ð¼ %qs"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¼Ð¾Ð´ÐµÐ»Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ð´Ð° TLS %qs"
  
  #: common.opt:2279
+#, fuzzy
+#| msgid "Reorder top level functions, variables, and asms"
  msgid "Reorder top level functions, variables, and asms."
-msgstr ""
+msgstr "Переупорядочивать функции, переменные и операторы asm верхнего уровня"
  
  #: common.opt:2283
  #, fuzzy
@@ -17296,8 +18335,9 @@ msgstr "Включить SSA-оптимизацию  распространен
  
  #: common.opt:2302
  #, fuzzy
+#| msgid "Enable SSA-BIT-CCP optimization on trees"
  msgid "Enable SSA-BIT-CCP optimization on trees."
-msgstr "Включить SSA-оптимизацию  распространения констант на древовидном представлении"
+msgstr "Включить SSA-BIT-CCP оптимизацию на древовидном представлении"
  
  #: common.opt:2310
  #, fuzzy
@@ -17319,13 +18359,13 @@ msgstr "Выполнять распространение копий в древ
  
  #: common.opt:2334
  #, fuzzy
+#| msgid "Transform condition stores into unconditional ones"
  msgid "Transform condition stores into unconditional ones."
-msgstr "Ð\9fÑ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ñ\8bÐ²Ð°Ñ\82Ñ\8c Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ñ\8bÐµ Ð¿ÐµÑ\80ÐµÑ\85Ð¾Ð´Ñ\8b Ð² Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÐµÐ¼Ñ\8bÐ¹ ÐºÐ¾Ð´"
+msgstr "Ð\9fÑ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ñ\8bÐ²Ð°Ñ\82Ñ\8c Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ñ\8bÐµ Ð·Ð°Ð¿Ð¸Ñ\81Ð¸ Ð² Ð±ÐµÐ·Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ñ\8bÐµ"
  
  #: common.opt:2338
-#, fuzzy
  msgid "Perform conversions of switch initializations."
-msgstr "Ð\9fÑ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ñ\8bÐ²Ð°Ñ\82Ñ\8c Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ñ\8bÐµ Ð¿ÐµÑ\80ÐµÑ\85Ð¾Ð´Ñ\8b Ð² Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÐµÐ¼Ñ\8bÐ¹ ÐºÐ¾Ð´"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÑ\82Ñ\8c Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð¿ÐµÑ\80ÐµÐºÐ»Ñ\8eÑ\87Ð°Ñ\82ÐµÐ»ÐµÐ¹."
  
  #: common.opt:2342
  #, fuzzy
@@ -17341,8 +18381,9 @@ msgstr "Включить оптимизации доминаторов"
  
  #: common.opt:2350
  #, fuzzy
+#| msgid "Enable tail merging on trees"
  msgid "Enable tail merging on trees."
-msgstr "Включить копирование заголовков циклов в древовидном представлении"
+msgstr "Включить слияние хвостов в древовидном представлении"
  
  #: common.opt:2354
  #, fuzzy
@@ -17352,8 +18393,9 @@ msgstr "Выполнить оптимизацию удаления мертвы
  
  #: common.opt:2358
  #, fuzzy
+#| msgid "Enable forward propagation on trees"
  msgid "Enable forward propagation on trees."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÑ\82Ñ\8c Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ðµ ÐºÐ¾Ð¿Ð¸Ð¹ в древовидном представлении"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÑ\82Ñ\8c Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ðµ Ð²Ð¿ÐµÑ\80ÐµÐ´ в древовидном представлении"
  
  #: common.opt:2362
  #, fuzzy
@@ -17363,8 +18405,9 @@ msgstr "Выполнить полный набор оптимизаций уда
  
  #: common.opt:2366
  #, fuzzy
+#| msgid "Enable string length optimizations on trees"
  msgid "Enable string length optimizations on trees."
-msgstr "Включить SSA-оптимизацию  распространения констант на древовидном представлении"
+msgstr "Включить оптимизацию вычисления длин строк на древовидном представлении"
  
  #: common.opt:2370
  msgid "Detect paths that trigger erroneous or undefined behavior due to"
@@ -17376,13 +18419,15 @@ msgstr ""
  
  #: common.opt:2383
  #, fuzzy
+#| msgid "Enable loop distribution on trees"
  msgid "Enable loop distribution on trees."
-msgstr "Выполнить векторизацию циклов на древовидном представлении"
+msgstr "Выполнить распределение циклов на древовидном представлении"
  
  #: common.opt:2387
  #, fuzzy
+#| msgid "Enable loop distribution for patterns transformed into a library call"
  msgid "Enable loop distribution for patterns transformed into a library call."
-msgstr "Выполнить векторизацию циклов на древовидном представлении"
+msgstr "Выполнить распределение циклов для шаблонов, преобразованных в библиотечные вызовы"
  
  #: common.opt:2391
  #, fuzzy
@@ -17404,13 +18449,13 @@ msgstr "Включить оптимизации циклов на древови
  
  #: common.opt:2407
  #, fuzzy
+#| msgid "Enable automatic parallelization of loops"
  msgid "Enable automatic parallelization of loops."
-msgstr "Включить автоматическую конкретизацию шаблонов"
+msgstr "Включить автоматическое распараллеливание циклов"
  
  #: common.opt:2411
-#, fuzzy
  msgid "Enable hoisting loads from conditional pointers."
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ñ\8bÐµ ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b move"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÑ\82Ñ\8c Ð¿Ð¾Ð´Ð½Ñ\8fÑ\82Ð¸Ðµ Ð·Ð°Ð³Ñ\80Ñ\83Ð·Ð¾Ðº Ð¿Ð¾ Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ñ\8bÐ¼ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8fÐ¼"
  
  #: common.opt:2415
  #, fuzzy
@@ -17423,14 +18468,14 @@ msgid "In SSA-PRE optimization on trees, enable partial-partial redundancy elimi
  msgstr ""
  
  #: common.opt:2423
-#, fuzzy
  msgid "Perform function-local points-to analysis on trees."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¼ÐµÐ¶Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð½Ð¾Ðµ Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð°Ð½Ð°Ð»Ð¸Ð· Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¹ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹ Ð½Ð° Ð´Ñ\80ÐµÐ²Ð¾Ð²Ð¸Ð´Ð½Ð¾Ð¼ Ð¿Ñ\80ÐµÐ´Ñ\81Ñ\82Ð°Ð²Ð»ÐµÐ½Ð¸Ð¸"
  
  #: common.opt:2427
  #, fuzzy
+#| msgid "Enable reassociation on tree level"
  msgid "Enable reassociation on tree level."
-msgstr "Включить оптимизации циклов на древовидном представлении"
+msgstr "Включить оптимизацию ассоциативных операций на древовидном представлении"
  
  #: common.opt:2435
  #, fuzzy
@@ -17499,12 +18544,14 @@ msgid "Allow loop optimizations to assume that the loops behave in normal way."
  msgstr "При оптимизации циклов предполагать нормальное поведение цикла"
  
  #: common.opt:2487
+#, fuzzy
+#| msgid "Allow optimization for floating-point arithmetic which may change the result of the operation due to rounding."
  msgid "Allow optimization for floating-point arithmetic which may change the"
-msgstr ""
+msgstr "Разрешить оптимизации плавающей арифметики, которые могут изменить результат операции из-за округления."
  
  #: common.opt:2492
  msgid "Same as -fassociative-math for expressions which include division."
-msgstr ""
+msgstr "То же, что -fassociative-math для выражений, включающих деление."
  
  #: common.opt:2500
  #, fuzzy
@@ -17525,12 +18572,16 @@ msgid "Just generate unwind tables for exception handling."
  msgstr "Генерировать unwind-таблицы только для обработки исключений"
  
  #: common.opt:2512
+#, fuzzy
+#| msgid "Use the hardware barrel shifter instead of emulation"
  msgid "Use the bfd linker instead of the default linker."
-msgstr ""
+msgstr "Использовать аппаратное устройство циклического сдвига вместо эмуляции"
  
  #: common.opt:2516
+#, fuzzy
+#| msgid "Use the hardware barrel shifter instead of emulation"
  msgid "Use the gold linker instead of the default linker."
-msgstr ""
+msgstr "Использовать аппаратное устройство циклического сдвига вместо эмуляции"
  
  #: common.opt:2528
  #, fuzzy
@@ -17540,17 +18591,21 @@ msgstr "Выполнить отслеживание переменных"
  
  #: common.opt:2536
  #, fuzzy
+#| msgid "Perform variable tracking by annotating assignments"
  msgid "Perform variable tracking by annotating assignments."
-msgstr "Выполнить отслеживание переменных"
+msgstr "Выполнить отслеживание переменных путем аннотирования присваиваний"
  
  #: common.opt:2542
+#, fuzzy
+#| msgid "Toggle -fvar-tracking-assignments"
  msgid "Toggle -fvar-tracking-assignments."
-msgstr ""
+msgstr "Переключить -fvar-tracking-assignments"
  
  #: common.opt:2550
  #, fuzzy
+#| msgid "Perform variable tracking and also tag variables that are uninitialized"
  msgid "Perform variable tracking and also tag variables that are uninitialized."
-msgstr "Выполнить отслеживание переменных"
+msgstr "Выполнить отслеживание переменных и пометить неинициализированные переменные"
  
  #: common.opt:2554
  #, fuzzy
@@ -17566,13 +18621,15 @@ msgstr "Выполнить векторизацию циклов на древо
  
  #: common.opt:2566
  #, fuzzy
+#| msgid "Enable basic block vectorization (SLP) on trees"
  msgid "Enable basic block vectorization (SLP) on trees."
-msgstr "Выполнить векторизацию циклов на древовидном представлении"
+msgstr "Выполнить векторизацию базовых блоков (SLP) на древовидном представлении"
  
  #: common.opt:2570
  #, fuzzy
+#| msgid "Enable use of cost model in vectorization"
  msgid "Specifies the cost model for vectorization."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð´Ð»Ñ\8f Ð¿Ñ\80Ñ\8fÐ¼Ð¾Ð³Ð¾ (big endian) Ð¿Ð¾Ñ\80Ñ\8fÐ´ÐºÐ° Ð±Ð°Ð¹Ñ\82"
+msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\83 Ñ\81Ñ\82Ð¾Ð¸Ð¼Ð¾Ñ\81Ñ\82Ð½Ñ\83Ñ\8e Ð¼Ð¾Ð´ÐµÐ»Ñ\8c Ð¿Ñ\80Ð¸ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð¸Ð·Ð°Ñ\86Ð¸Ð¸"
  
  #: common.opt:2574
  msgid "Specifies the vectorization cost model for code marked with a simd directive."
@@ -17580,21 +18637,25 @@ msgstr ""
  
  #: common.opt:2577
  #, fuzzy, c-format
+#| msgid "unknown TLS model %qs"
  msgid "unknown vectorizer cost model %qs"
-msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¼Ð°Ñ\88Ð¸Ð½Ð½Ñ\8bÐ¹ Ñ\80ÐµÐ¶Ð¸Ð¼ %qs"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¼Ð¾Ð´ÐµÐ»Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ ÐºÐ¾Ð´Ð° TLS %qs"
  
  #: common.opt:2590
+#, fuzzy
+#| msgid "Does nothing.  Preserved for backward compatibility."
  msgid "Enables the dynamic vectorizer cost model.  Preserved for backward compatibility."
-msgstr ""
+msgstr "Игнорируется. Сохранен для обратной совместимости"
  
  #: common.opt:2594
+#, fuzzy
+#| msgid "Does nothing.  Preserved for backward compatibility."
  msgid "Enables the unlimited vectorizer cost model.  Preserved for backward compatibility."
-msgstr ""
+msgstr "Игнорируется. Сохранен для обратной совместимости"
  
  #: common.opt:2602
-#, fuzzy
  msgid "Enable copy propagation of scalar-evolution information."
-msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÑ\82Ñ\8c Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ðµ ÐºÐ¾Ð¿Ð¸Ð¹ Ð´Ð»Ñ\8f Ð·Ð°Ð¿Ð¸Ñ\81ÐµÐ¹ Ð¸ Ð·Ð°Ð³Ñ\80Ñ\83Ð·Ð¾Ðº"
+msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÑ\82Ñ\8c Ñ\80Ð°Ñ\81Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½ÐµÐ½Ð¸Ðµ ÐºÐ¾Ð¿Ð¸Ð¹ Ð¿Ð¾ Ð¸Ð½Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\86Ð¸Ð¸ Ð¾Ð± Ñ\8dÐ²Ð¾Ð»Ñ\8eÑ\86Ð¸Ð¸ Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80Ð½Ñ\8bÑ\85 Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹."
  
  #: common.opt:2612
  #, fuzzy
@@ -17603,13 +18664,15 @@ msgid "Add extra commentary to assembler output."
  msgstr "Добавить комментарии к ассемблерному коду"
  
  #: common.opt:2616
+#, fuzzy
+#| msgid "-fvisibility=[default|internal|hidden|protected]\tSet the default symbol visibility"
  msgid "-fvisibility=[default|internal|hidden|protected]\tSet the default symbol visibility."
-msgstr ""
+msgstr "-fvisibility=[default|internal|hidden|protected]\tУстановить атрибут видимости символов по умолчанию"
  
  #: common.opt:2619
-#, fuzzy, c-format
+#, c-format
  msgid "unrecognized visibility value %qs"
-msgstr "некорректный тип видимости \"%s\""
+msgstr "некорректный тип видимости %qs"
  
  #: common.opt:2635
  msgid "Validate vtable pointers before using them."
@@ -17643,8 +18706,9 @@ msgstr "Снять зависимости между различными исп
  
  #: common.opt:2667
  #, fuzzy
+#| msgid "Enable conditional dead code elimination for builtin calls"
  msgid "Enable conditional dead code elimination for builtin calls."
-msgstr "Выполнить удаление мертвого SSA-кода на древовидном представлении"
+msgstr "Выполнить удаление условного мертвого кода для вызовов встроенных функций"
  
  #: common.opt:2671
  #, fuzzy
@@ -17684,8 +18748,9 @@ msgstr "Генерировать отладочную информацию в ф
  
  #: common.opt:2695
  #, fuzzy
+#| msgid "Generate debug information in DWARF v2 (or later) format"
  msgid "Generate debug information in DWARF v2 (or later) format."
-msgstr "Генерировать отладочную информацию в формате DWARF версии 2"
+msgstr "Генерировать отладочную информацию в формате DWARF версии 2 или более поздней"
  
  #: common.opt:2699
  #, fuzzy
@@ -17707,19 +18772,21 @@ msgstr ""
  
  #: common.opt:2715
  msgid "Don't record gcc command line switches in DWARF DW_AT_producer."
-msgstr ""
+msgstr "Не записывать ключи командной строки gcc в DWARF DW_AT_producer."
  
  #: common.opt:2719
  msgid "Record gcc command line switches in DWARF DW_AT_producer."
-msgstr ""
+msgstr "Записывать ключи командной строки gcc в DWARF DW_AT_producer."
  
  #: common.opt:2723
  #, fuzzy
+#| msgid "Generate debug information in default format"
  msgid "Don't generate debug information in separate .dwo files."
  msgstr "Генерировать отладочную информацию в формате по умолчанию"
  
  #: common.opt:2727
  #, fuzzy
+#| msgid "Generate debug information in default format"
  msgid "Generate debug information in separate .dwo files."
  msgstr "Генерировать отладочную информацию в формате по умолчанию"
  
@@ -17736,17 +18803,22 @@ msgid "Generate debug information in extended STABS format."
  msgstr "Генерировать отладочную информацию в расширенном формате STABS"
  
  #: common.opt:2739
+#, fuzzy
+#| msgid "Emit DWARF additions beyond selected version"
  msgid "Emit DWARF additions beyond selected version."
-msgstr ""
+msgstr "Генерировать дополнения DWARF, не входящие в выбранную версию"
  
  #: common.opt:2743
+#, fuzzy
+#| msgid "Don't emit DWARF additions beyond selected version"
  msgid "Don't emit DWARF additions beyond selected version."
-msgstr ""
+msgstr "Не генерировать дополнения DWARF, не входящие в выбранную версию"
  
  #: common.opt:2747
  #, fuzzy
+#| msgid "Toggle debug information generation"
  msgid "Toggle debug information generation."
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¾Ñ\82Ð»Ð°Ð´Ð¾Ñ\87Ð½Ñ\83Ñ\8e Ð¸Ð½Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\86Ð¸Ñ\8e Ð² Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ðµ VMS"
+msgstr "Ð\9fÐµÑ\80ÐµÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ð¾Ñ\82Ð»Ð°Ð´Ð¾Ñ\87Ð½Ð¾Ð¹ Ð¸Ð½Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\86Ð¸Ð¸"
  
  #: common.opt:2751
  #, fuzzy
@@ -17778,18 +18850,21 @@ msgstr ""
  
  #: common.opt:2788
  #, fuzzy
+#| msgid "-iplugindir=<dir>\tSet <dir> to be the default plugin directory"
  msgid "-iplugindir=<dir>\tSet <dir> to be the default plugin directory."
-msgstr "Считать <каталог> корневым каталогом системы"
+msgstr "-iplugindir=<каталог>\tУстановить <каталог> подгружаемых модулей по умолчанию"
  
  #: common.opt:2792
  #, fuzzy
+#| msgid "-imultiarch <dir>\tSet <dir> to be the multiarch include subdirectory"
  msgid "-imultiarch <dir>\tSet <dir> to be the multiarch include subdirectory."
-msgstr "Считать <каталог> корневым каталогом системы"
+msgstr "-imultiarch <каталог>\tУстановить <каталог> заголовочных файлов для мультиархитектуры"
  
  #: common.opt:2814
  #, fuzzy
+#| msgid "-o <file>\tPlace output into <file>"
  msgid "-o <file>\tPlace output into <file>."
-msgstr "Записать результат в <файл>"
+msgstr "-o <файл>\tЗаписать результат в <файл>"
  
  #: common.opt:2818
  #, fuzzy
@@ -17829,18 +18904,21 @@ msgstr "Подавить выдачу предупреждений"
  
  #: common.opt:2918
  #, fuzzy
+#| msgid "Create a shared library"
  msgid "Create a shared library."
-msgstr "Ð\9fÐ¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°Ñ\82Ñ\8c Ñ\80Ð°Ð·Ð´ÐµÐ»Ñ\8fÐµÐ¼Ñ\8bÐµ Ð±Ð¸Ð±Ð»Ð¸Ð¾Ñ\82ÐµÐºÐ¸ Ð½Ð° Ð¾Ñ\81Ð½Ð¾Ð²Ðµ ID"
+msgstr "Ð¡Ð¾Ð·Ð´Ð°Ñ\82Ñ\8c Ñ\80Ð°Ð·Ð´ÐµÐ»Ñ\8fÐµÐ¼Ñ\83Ñ\8e Ð±Ð¸Ð±Ð»Ð¸Ð¾Ñ\82ÐµÐºÑ\83"
  
  #: common.opt:2963
  #, fuzzy
+#| msgid "Create a position independent executable"
  msgid "Don't create a position independent executable."
-msgstr "Генерировать позиционно-независимый код для выполняемых модулей, если возможно (режим large)"
+msgstr "Генерировать позиционно-независимый код для выполняемого модуля"
  
  #: common.opt:2967
  #, fuzzy
+#| msgid "Create a position independent executable"
  msgid "Create a position independent executable."
-msgstr "Генерировать позиционно-независимый код для выполняемых модулей, если возможно (режим large)"
+msgstr "Генерировать позиционно-независимый код для выполняемого модуля"
  
  #: common.opt:2974
  msgid "Use caller save register across calls if possible."
@@ -17853,30 +18931,25 @@ msgid "value computed is not used"
  msgstr "вычисленное значение не используется"
  
  #: go/gofrontend/expressions.cc:617
-#, fuzzy
  msgid "invalid use of type"
-msgstr "некорректное использование %qD"
+msgstr "некорректное использование типа"
  
  #: go/gofrontend/expressions.cc:2744 go/gofrontend/expressions.cc:2810
  #: go/gofrontend/expressions.cc:2826
-#, fuzzy
  msgid "constant refers to itself"
-msgstr "указатель inlined_to ссылается на себя"
+msgstr "константа ссылается на себя"
  
  #: go/gofrontend/expressions.cc:3632 go/gofrontend/expressions.cc:4034
-#, fuzzy
  msgid "expected pointer"
-msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c"
  
  #: go/gofrontend/expressions.cc:4005
-#, fuzzy
  msgid "expected numeric type"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ñ\87Ð¸Ñ\81Ð»Ð¾Ð²Ð¾Ð¹ Ñ\82Ð¸Ð¿"
  
  #: go/gofrontend/expressions.cc:4010
-#, fuzzy
  msgid "expected boolean type"
-msgstr "ожидалось выражение"
+msgstr "ожидался булевый тип"
  
  #: go/gofrontend/expressions.cc:4015 c/c-parser.c:12595 c/c-parser.c:12602
  #: cp/parser.c:31676 cp/parser.c:31683
@@ -17887,13 +18960,13 @@ msgstr "Ожидалось целочисленное значение"
  
  #: go/gofrontend/expressions.cc:5553
  #, fuzzy
+#| msgid "invalid comparison code in gimple cond"
  msgid "invalid comparison of nil with nil"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86ии"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ¾Ð´ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8f Ð² gimple Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½ии"
  
  #: go/gofrontend/expressions.cc:5559 go/gofrontend/expressions.cc:5577
-#, fuzzy
  msgid "incompatible types in binary expression"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð°"
+msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
  
  #: go/gofrontend/expressions.cc:5597
  #, fuzzy
@@ -17902,35 +18975,29 @@ msgid "integer division by zero"
  msgstr "деление на ноль"
  
  #: go/gofrontend/expressions.cc:5605
-#, fuzzy
  msgid "shift of non-integer operand"
-msgstr "Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° %qs Ð¸Ð¼ÐµÐµÑ\82 Ð½Ðµ Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
+msgstr "Ñ\81Ð´Ð²Ð¸Ð³ Ð½ÐµÑ\86ÐµÐ»Ð¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð°"
  
  #: go/gofrontend/expressions.cc:5608 go/gofrontend/expressions.cc:5612
  #: go/gofrontend/expressions.cc:5620
-#, fuzzy
  msgid "shift count not unsigned integer"
-msgstr "в операторе switch задано не целое"
+msgstr "счетчик сдвига не есть беззнаковое целое"
  
  #: go/gofrontend/expressions.cc:5625
-#, fuzzy
  msgid "negative shift count"
-msgstr "отрицательная длина RTL-инструкции"
+msgstr "отрицательный счетчик сдвига"
  
  #: go/gofrontend/expressions.cc:6276
-#, fuzzy
  msgid "object is not a method"
-msgstr "Ð²Ñ\8bÐ·Ñ\8bÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ Ð¾Ð±Ñ\8aÐµÐºÑ\82 %qE Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸ÐµÐ¹"
+msgstr "Ð¾Ð±Ñ\8aÐµÐºÑ\82 Ð½Ðµ ÐµÑ\81Ñ\82Ñ\8c Ð¼ÐµÑ\82Ð¾Ð´"
  
  #: go/gofrontend/expressions.cc:6293
-#, fuzzy
  msgid "method type does not match object type"
-msgstr "аргумент типа %qT не соответствует типу %qT"
+msgstr "типа метода не соответствует типу объекта"
  
  #: go/gofrontend/expressions.cc:6773
-#, fuzzy
  msgid "invalid use of %<...%> with builtin function"
-msgstr "некорректный аргумент внутренней функции"
+msgstr "некорректное использование %<...%> со встроенной функцией"
  
  #: go/gofrontend/expressions.cc:6784
  #, fuzzy
@@ -17947,9 +19014,8 @@ msgstr ""
  #: go/gofrontend/expressions.cc:7951 go/gofrontend/expressions.cc:7997
  #: go/gofrontend/expressions.cc:8056 go/gofrontend/expressions.cc:9268
  #: go/gofrontend/expressions.cc:9285 go/gofrontend/expressions.cc:9301
-#, fuzzy
  msgid "not enough arguments"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b"
+msgstr "Ð½ÐµÐ´Ð¾Ñ\81Ñ\82Ð°Ñ\82Ð¾Ñ\87Ð½Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð²"
  
  #: go/gofrontend/expressions.cc:6825 go/gofrontend/expressions.cc:6886
  #: go/gofrontend/expressions.cc:7807 go/gofrontend/expressions.cc:7934
@@ -17957,151 +19023,132 @@ msgstr "отсутствуют аргументы"
  #: go/gofrontend/expressions.cc:8058 go/gofrontend/expressions.cc:8842
  #: go/gofrontend/expressions.cc:9273 go/gofrontend/expressions.cc:9287
  #: go/gofrontend/expressions.cc:9308
-#, fuzzy
  msgid "too many arguments"
-msgstr "слишком много аргументов для форматирования"
+msgstr "слишком много аргументов"
  
  #: go/gofrontend/expressions.cc:6888
-#, fuzzy
  msgid "argument 1 must be a map"
-msgstr "аргумент %qD не является константой"
+msgstr "аргумент 1 должен быть отображением"
  
  #: go/gofrontend/expressions.cc:7012
-#, fuzzy
  msgid "invalid type for make function"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾Ðµ Ñ\83Ð¿Ð¾Ñ\82Ñ\80ÐµÐ±Ð»ÐµÐ½Ð¸Ðµ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð° %<restrict%>"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f make Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
  
  #: go/gofrontend/expressions.cc:7028
  msgid "length required when allocating a slice"
-msgstr ""
+msgstr "длина требуется при размещении вырезки"
  
  #: go/gofrontend/expressions.cc:7063
  msgid "len larger than cap"
  msgstr ""
  
  #: go/gofrontend/expressions.cc:7075
-#, fuzzy
  msgid "too many arguments to make"
-msgstr "слишком много аргументов для %s `%+#D'"
+msgstr "слишком много аргументов для make"
  
  #: go/gofrontend/expressions.cc:7851
-#, fuzzy
  msgid "argument must be array or slice or channel"
-msgstr "аргумент %qD не является константой"
+msgstr "аргумент должен быть массивом или вырезкой или каналом"
  
  #: go/gofrontend/expressions.cc:7861
  msgid "argument must be string or array or slice or map or channel"
-msgstr ""
+msgstr "аргумент должен быть строкой массивом или вырезкой отображением или каналом"
  
  #: go/gofrontend/expressions.cc:7907
-#, fuzzy
  msgid "unsupported argument type to builtin function"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 внутренней функции"
+msgstr "Ð½ÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° Ð´Ð»Ñ\8f внутренней функции"
  
  #: go/gofrontend/expressions.cc:7918
-#, fuzzy
  msgid "argument must be channel"
-msgstr "аргумент %qD не является константой"
+msgstr "аргумент должен быть каналом"
  
  #: go/gofrontend/expressions.cc:7920
-#, fuzzy
  msgid "cannot close receive-only channel"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð·Ð°ÐºÑ\80Ñ\8bÑ\82Ñ\8c ÐºÐ°Ð½Ð°Ð» Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f Ð¿Ð¾Ð»Ñ\83Ñ\87ÐµÐ½Ð¸Ñ\8f"
  
  #: go/gofrontend/expressions.cc:7942
-#, fuzzy
  msgid "argument must be a field reference"
-msgstr "Ð¼Ð°Ñ\81ÐºÐ° Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¾Ð¹ Ð½Ð° Ð¿Ð¾Ð»Ðµ"
  
  #: go/gofrontend/expressions.cc:7972
-#, fuzzy
  msgid "left argument must be a slice"
-msgstr "Ð¼Ð°Ñ\81ÐºÐ° Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð»ÐµÐ²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð²Ñ\8bÑ\80ÐµÐ·ÐºÐ¾Ð¹"
  
  #: go/gofrontend/expressions.cc:7980
  msgid "element types must be the same"
-msgstr ""
+msgstr "типы элементов должны быть одинаковыми"
  
  #: go/gofrontend/expressions.cc:7985
-#, fuzzy
  msgid "first argument must be []byte"
-msgstr "Ð¼Ð°Ñ\81ÐºÐ° Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c []byte"
  
  #: go/gofrontend/expressions.cc:7988
-#, fuzzy
  msgid "second argument must be slice or string"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %qD Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82ой"
+msgstr "Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð²Ñ\8bÑ\80ÐµÐ·ÐºÐ¾Ð¹ Ð¸Ð»Ð¸ Ñ\81Ñ\82Ñ\80Ð¾Ðºой"
  
  #: go/gofrontend/expressions.cc:8032
-#, fuzzy
  msgid "argument 2 has invalid type"
-msgstr "%Jпараметр %u имеет неполный void"
+msgstr "аргумент 2 имеет некорректный тип"
  
  #: go/gofrontend/expressions.cc:8048
-#, fuzzy
  msgid "argument must have complex type"
-msgstr "%Jпараметр %u имеет неполный тип"
+msgstr "аргумент должен иметь complex тип"
  
  #: go/gofrontend/expressions.cc:8066
-#, fuzzy
  msgid "complex arguments must have identical types"
-msgstr "аргумент атрибута cleanup - не идентификатор"
+msgstr "complex аргументы должны иметь идентичные типы"
  
  #: go/gofrontend/expressions.cc:8068
-#, fuzzy
  msgid "complex arguments must have floating-point type"
-msgstr "Не использовать аппаратную плавающую арифметику"
+msgstr "complex аргументы должны иметь плавающие типы"
  
  #: go/gofrontend/expressions.cc:8653 go/gofrontend/expressions.cc:9214
  #: go/gofrontend/expressions.cc:9605
-#, fuzzy
  msgid "expected function"
-msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
  
  #: go/gofrontend/expressions.cc:8681
  #, fuzzy
+#| msgid "multiple value function call in single value context"
  msgid "multiple-value argument in single-value context"
-msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f C-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ `%#D' Ð¿Ñ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ñ\82"
+msgstr "Ð²Ñ\8bÐ·Ð¾Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ñ\81Ð¾ Ð¼Ð½Ð¾Ð¶ÐµÑ\81Ñ\82Ð²Ð¾Ð¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð² ÐºÐ¾Ð½Ñ\82ÐµÐºÑ\81Ñ\82Ðµ Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f"
  
  #: go/gofrontend/expressions.cc:8846
-#, fuzzy
  msgid "invalid use of %<...%> with non-slice"
-msgstr "некорректное использование %<this%> на внешнем уровне"
+msgstr "некорректное использование %<...%> с non-slice"
  
+#
  #: go/gofrontend/expressions.cc:9222
  #, fuzzy
+#| msgid "Function return value not set"
  msgid "function result count mismatch"
-msgstr "функция возвращает агрегатное значение"
+msgstr "Возвращаемое функцией значение не установлено"
  
  #: go/gofrontend/expressions.cc:9240
-#, fuzzy
  msgid "incompatible type for receiver"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82а"
+msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð¿Ñ\80Ð¸ÐµÐ¼Ð½Ð¸Ðºа"
  
  #: go/gofrontend/expressions.cc:9258
-#, fuzzy
  msgid "invalid use of %<...%> calling non-variadic function"
-msgstr "некорректное использование %<this%> в функции, не являющейся элементом"
+msgstr "некорректное использование %<...%> при вызове non-variadic функции"
  
  #: go/gofrontend/expressions.cc:9614 go/gofrontend/expressions.cc:9628
-#, fuzzy
  msgid "number of results does not match number of values"
-msgstr "число входящих дуг не соответствует числу аргументов PHI"
+msgstr "число результатов не соответствует числу значений"
  
  #: go/gofrontend/expressions.cc:9921 go/gofrontend/expressions.cc:10474
-#, fuzzy
  msgid "index must be integer"
-msgstr "Ð¿Ñ\80ÐµÐ´Ð¸ÐºÐ°Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð¾м"
+msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\86ÐµÐ»Ñ\8bм"
  
  #: go/gofrontend/expressions.cc:9929 go/gofrontend/expressions.cc:10482
-#, fuzzy
  msgid "slice end must be integer"
-msgstr "Ð¿Ñ\80ÐµÐ´Ð¸ÐºÐ°Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð¾м"
+msgstr "ÐºÐ¾Ð½ÐµÑ\86 Ð²Ñ\8bÑ\80ÐµÐ·ÐºÐ¸ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\86ÐµÐ»Ñ\8bм"
  
  #: go/gofrontend/expressions.cc:9937
  #, fuzzy
+#| msgid "slice end must be integer"
  msgid "slice capacity must be integer"
-msgstr "Ð¿Ñ\80ÐµÐ´Ð¸ÐºÐ°Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð¾м"
+msgstr "ÐºÐ¾Ð½ÐµÑ\86 Ð²Ñ\8bÑ\80ÐµÐ·ÐºÐ¸ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\86ÐµÐ»Ñ\8bм"
  
  #: go/gofrontend/expressions.cc:9987 go/gofrontend/expressions.cc:10516
  msgid "inverted slice range"
@@ -18109,57 +19156,54 @@ msgstr ""
  
  #: go/gofrontend/expressions.cc:10030
  msgid "slice of unaddressable value"
-msgstr ""
+msgstr "вырезка неадресуемого значения"
  
  #: go/gofrontend/expressions.cc:10746
-#, fuzzy
  msgid "incompatible type for map index"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸"
+msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð´Ð»Ñ\8f Ð¸Ð½Ð´ÐµÐºÑ\81Ð° Ð¾Ñ\82Ð¾Ð±Ñ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
  
  #: go/gofrontend/expressions.cc:11132
  msgid "expected interface or pointer to interface"
-msgstr ""
+msgstr "Ожидался интерфейс или указатель на интерфейс"
  
  #: go/gofrontend/expressions.cc:11802
-#, fuzzy
  msgid "too many expressions for struct"
-msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð´Ð»Ñ\8f Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f"
+msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¹ Ð´Ð»Ñ\8f struct"
  
  #: go/gofrontend/expressions.cc:11815
-#, fuzzy
  msgid "too few expressions for struct"
-msgstr "недостаточно аргументов для указанного формата"
+msgstr "слишком мало выражений для struct"
  
  #: go/gofrontend/expressions.cc:13363 go/gofrontend/statements.cc:1582
  msgid "type assertion only valid for interface types"
-msgstr ""
+msgstr "type assertion корректно только для интерфейсных типов"
  
  #: go/gofrontend/expressions.cc:13375
  msgid "impossible type assertion: type does not implement interface"
-msgstr ""
+msgstr "невозможное type assertion: тип не реализует интерфейс"
  
  #: go/gofrontend/expressions.cc:13498 go/gofrontend/expressions.cc:13518
  #: go/gofrontend/statements.cc:1427
-#, fuzzy
  msgid "expected channel"
-msgstr "ожидалось имя класса"
+msgstr "ожидался канал"
  
  #: go/gofrontend/expressions.cc:13523 go/gofrontend/statements.cc:1432
  msgid "invalid receive on send-only channel"
-msgstr ""
+msgstr "некорректный receive или send-only канал"
  
  #: go/gofrontend/parse.cc:3016
+#, fuzzy
+#| msgid "parentheses required around this composite literalto avoid parsing ambiguity"
  msgid "parentheses required around this composite literal to avoid parsing ambiguity"
-msgstr ""
+msgstr "скобки требуются вокруг этого составного литерала чтобы избежать неоднозначности разбора"
  
  #: go/gofrontend/parse.cc:4593
  msgid "cannot fallthrough final case in switch"
  msgstr ""
  
  #: go/gofrontend/statements.cc:592
-#, fuzzy
  msgid "invalid left hand side of assignment"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð»ÐµÐ²Ð°Ñ\8f Ñ\87Ð°Ñ\81Ñ\82Ñ\8c Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð»ÐµÐ²Ð°Ñ\8f Ñ\87Ð°Ñ\81Ñ\82Ñ\8c Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ñ\8f"
  
  #: go/gofrontend/statements.cc:603 go/gofrontend/statements.cc:1021
  msgid "use of untyped nil"
@@ -18167,206 +19211,191 @@ msgstr ""
  
  #: go/gofrontend/statements.cc:1143
  msgid "expected map index on right hand side"
-msgstr ""
+msgstr "ожидался индекс отображения в правой части"
  
  #: go/gofrontend/statements.cc:1294
-#, fuzzy
  msgid "expected map index on left hand side"
-msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð¾Ðµ Ð¾ÐºÐ¾Ð½Ñ\87Ð°Ð½Ð¸Ðµ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¾Ñ\82Ð¾Ð±Ñ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ð² Ð»ÐµÐ²Ð¾Ð¹ Ñ\87Ð°Ñ\81Ñ\82Ð¸"
  
  #: go/gofrontend/statements.cc:2707 go/gofrontend/statements.cc:2737
-#, fuzzy
  msgid "not enough arguments to return"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b"
+msgstr "Ð½ÐµÐ´Ð¾Ñ\81Ñ\82Ð°Ñ\82Ð¾Ñ\87Ð½Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð´Ð»Ñ\8f return"
  
  #: go/gofrontend/statements.cc:2715
-#, fuzzy
  msgid "return with value in function with no return type"
-msgstr "оператор %<return%> <значение> в функции возвращающей void"
+msgstr "return со значением в функции без типа возврата"
  
  #: go/gofrontend/statements.cc:2743
-#, fuzzy
  msgid "too many values in return statement"
-msgstr "неверное lvalue-выражение в операторе asm"
+msgstr "слишком много значений в return операторе"
  
  #: go/gofrontend/statements.cc:3192
-#, fuzzy
  msgid "expected boolean expression"
-msgstr "ожидалось выражение"
+msgstr "ожидалось boolean выражение"
  
  #: go/gofrontend/statements.cc:4281
  msgid "cannot type switch on non-interface value"
-msgstr ""
+msgstr "невозможно типизировать switch на non-interface значение"
  
  #: go/gofrontend/statements.cc:4416
-#, fuzzy
  msgid "incompatible types in send"
-msgstr "несовместимые типы в операторе возврата"
+msgstr "несовместимые типы в send"
  
  #: go/gofrontend/statements.cc:4421
-#, fuzzy
  msgid "invalid send on receive-only channel"
-msgstr "некорректный операнд в инструкции"
+msgstr "некорректный send для receive-only канала"
  
  #: go/gofrontend/statements.cc:5392
  msgid "too many variables for range clause with channel"
-msgstr ""
+msgstr "слишком много переменных для range клаузулы с каналом"
  
  #: go/gofrontend/statements.cc:5399
-#, fuzzy
  msgid "range clause must have array, slice, string, map, or channel type"
-msgstr "аргумент %qD не является константой"
+msgstr "range клаузула должна иметь тип массива, вырезки, строки, отображения или канала"
  
  #: go/gofrontend/types.cc:509
-#, fuzzy
  msgid "invalid comparison of non-ordered type"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð´Ð»Ñ\8f Ð½Ðµ ÐºÐ»Ð°Ñ\81Ñ\81Ð¾Ð²Ñ\8bÑ\85 Ñ\82Ð¸Ð¿Ð¾Ð² Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ Ð½ÐµÑ\83Ð¿Ð¾Ñ\80Ñ\8fÐ´Ð¾Ñ\87ÐµÐ½Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð°"
  
  #: go/gofrontend/types.cc:525
-#, fuzzy
  msgid "slice can only be compared to nil"
-msgstr "%Hповторно встреченный класс будет скомпилирован только один раз"
+msgstr "вырезка может сравниваться только с nil"
  
  #: go/gofrontend/types.cc:527
-#, fuzzy
  msgid "map can only be compared to nil"
-msgstr "%Hповторно встреченный класс будет скомпилирован только один раз"
+msgstr "отображение может сравниваться только с nil"
  
  #: go/gofrontend/types.cc:529
-#, fuzzy
  msgid "func can only be compared to nil"
-msgstr "%Hповторно встреченный класс будет скомпилирован только один раз"
+msgstr "функция может сравниваться только с nil"
  
  #: go/gofrontend/types.cc:535
-#, fuzzy, c-format
+#, c-format
  msgid "invalid operation (%s)"
-msgstr "некорректный операнд для %%R"
+msgstr "некорректная операция (%s)"
  
  #: go/gofrontend/types.cc:558
-#, fuzzy
  msgid "invalid comparison of non-comparable type"
-msgstr "некорректный операнд в инструкции"
+msgstr "некорректное сравнение несравнимого типа"
  
  #: go/gofrontend/types.cc:576
-#, fuzzy
  msgid "invalid comparison of non-comparable struct"
-msgstr "некорректный операнд в инструкции"
+msgstr "некорректное сравнение несравнимой структуры"
  
  #: go/gofrontend/types.cc:587
-#, fuzzy
  msgid "invalid comparison of non-comparable array"
-msgstr "некорректное использование массива, не являющегося левой частью присваивания"
+msgstr "некорректное сравнение несравнимого массива"
  
  #: go/gofrontend/types.cc:615
  #, fuzzy
+#| msgid "multiple value function call in single value context"
  msgid "multiple-value function call in single-value context"
-msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f C-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ `%#D' Ð¿Ñ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ñ\82"
+msgstr "Ð²Ñ\8bÐ·Ð¾Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ñ\81Ð¾ Ð¼Ð½Ð¾Ð¶ÐµÑ\81Ñ\82Ð²Ð¾Ð¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð² ÐºÐ¾Ð½Ñ\82ÐµÐºÑ\81Ñ\82Ðµ Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f"
  
  #: go/gofrontend/types.cc:692
-#, fuzzy
  msgid "need explicit conversion"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð½Ñ\83Ð¶Ð½Ð¾ Ñ\8fÐ²Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ"
  
  #: go/gofrontend/types.cc:699
-#, fuzzy, c-format
+#, c-format
  msgid "cannot use type %s as type %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¾Ñ\82 Ñ\82Ð¸Ð¿Ð° %qT Ðº Ñ\82Ð¸Ð¿Ñ\83 %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\82Ð¸Ð¿ %s ÐºÐ°Ðº Ñ\82Ð¸Ð¿ %s"
  
  #: go/gofrontend/types.cc:3503
-#, fuzzy
  msgid "different receiver types"
-msgstr "некорректный тип приемника %qs"
+msgstr "разные типы приемников"
  
  #: go/gofrontend/types.cc:3523 go/gofrontend/types.cc:3536
  #: go/gofrontend/types.cc:3551
-#, fuzzy
  msgid "different number of parameters"
-msgstr "повторное определение параметра %q+D"
+msgstr "разное число параметров"
  
  #: go/gofrontend/types.cc:3544
-#, fuzzy
  msgid "different parameter types"
-msgstr "некорректный тип параметра %qT"
+msgstr "разные типы параметров"
  
  #: go/gofrontend/types.cc:3559
  msgid "different varargs"
-msgstr ""
+msgstr "разные varargs"
  
  #: go/gofrontend/types.cc:3568 go/gofrontend/types.cc:3581
  #: go/gofrontend/types.cc:3596
  msgid "different number of results"
-msgstr ""
+msgstr "разное число результатов"
  
  #: go/gofrontend/types.cc:3589
  msgid "different result types"
-msgstr ""
+msgstr "разные типы результатов"
  
  #: go/gofrontend/types.cc:7396
  #, c-format
  msgid "need explicit conversion; missing method %s%s%s"
-msgstr ""
+msgstr "нужно явное преобразование; отсутствует метод %s%s%s"
  
  #: go/gofrontend/types.cc:7413 go/gofrontend/types.cc:7555
-#, fuzzy, c-format
+#, c-format
  msgid "incompatible type for method %s%s%s"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %d Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE"
+msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð¼ÐµÑ\82Ð¾Ð´Ð° %s%s%s"
  
  #: go/gofrontend/types.cc:7417 go/gofrontend/types.cc:7559
-#, fuzzy, c-format
+#, c-format
  msgid "incompatible type for method %s%s%s (%s)"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %d Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE"
+msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð¼ÐµÑ\82Ð¾Ð´Ð° %s%s%s (%s)"
  
  #: go/gofrontend/types.cc:7496 go/gofrontend/types.cc:7509
  msgid "pointer to interface type has no methods"
-msgstr ""
+msgstr "указатель на интерфейсный тип не имеет методов"
  
  #: go/gofrontend/types.cc:7498 go/gofrontend/types.cc:7511
-#, fuzzy
  msgid "type has no methods"
-msgstr "ошибка при грамматическом разборе методов"
+msgstr "тип не имеет методов"
  
  #: go/gofrontend/types.cc:7532
-#, fuzzy, c-format
+#, c-format
  msgid "ambiguous method %s%s%s"
-msgstr "неоднозначное сокращение %s"
+msgstr "неоднозначный метод %s%s%s"
  
  #: go/gofrontend/types.cc:7535
-#, fuzzy, c-format
+#, c-format
  msgid "missing method %s%s%s"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f \"%s\""
+msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¼ÐµÑ\82Ð¾Ð´ %s%s%s"
  
  #: go/gofrontend/types.cc:7576
-#, c-format
+#, fuzzy, c-format
+#| msgid "method %s%s%s requires a pointer"
  msgid "method %s%s%s requires a pointer receiver"
-msgstr ""
+msgstr "метод %s%s%s требует указателя"
  
  #: go/gofrontend/types.cc:7594
-#, c-format
+#, fuzzy, c-format
+#| msgid "method %s%s%s requires a pointer"
  msgid "method %s%s%s is marked go:nointerface"
-msgstr ""
+msgstr "метод %s%s%s требует указателя"
  
  #. Warn about and ignore all others for now, but store them.
  #: attribs.c:436 c-family/c-common.c:8653 objc/objc-act.c:4956
  #: objc/objc-act.c:6925 objc/objc-act.c:8114 objc/objc-act.c:8165
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute directive ignored"
-msgstr "Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¸Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² %qs проигнорирована"
+msgstr "Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¸Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qE проигнорирована"
  
  #: attribs.c:440
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute directive ignored"
  msgid "%<%E::%E%> scoped attribute directive ignored"
-msgstr "Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¸Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² %qs проигнорирована"
+msgstr "Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¸Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qE проигнорирована"
  
  #: attribs.c:449
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "wrong number of arguments specified for %qE attribute"
-msgstr "для атрибута %qs задано неверное число аргументов"
+msgstr "для атрибута %qE задано неверное число аргументов"
  
  #. This is a c++11 attribute that appertains to a
  #. type-specifier, outside of the definition of, a class
  #. type.  Ignore it.
  #: attribs.c:462
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute ignored"
  msgid "attribute ignored"
  msgstr "атрибут %qE проигнорирован"
  
@@ -18376,19 +19405,19 @@ msgid "an attribute that appertains to a type-specifier is ignored"
  msgstr ""
  
  #: attribs.c:481
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute does not apply to types"
-msgstr "атрибут %qs недопустим в декларациях типов"
+msgstr "атрибут %qE недопустим в декларациях типов"
  
  #: attribs.c:529
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute only applies to function types"
-msgstr "атрибут %qs недопустим для функций"
+msgstr "атрибут %qE допустим только для функций"
  
  #: attribs.c:539
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type attributes ignored after type is already defined"
-msgstr "атрибуты типов учитываются только в определениях типов"
+msgstr "атрибуты типов игнорируются, если тип уже определен"
  
  #: auto-profile.c:348
  #, gcc-internal-format
@@ -18399,12 +19428,13 @@ msgstr ""
  #, fuzzy, gcc-internal-format
  #| msgid "expected %<.%>"
  msgid "Not expected TAG."
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾сь %<.%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°сь %<.%>"
  
  #: auto-profile.c:890
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Cannot open source file %s\n"
  msgid "Cannot open profile file %s."
-msgstr "%s:ошибка открытия исходного файла\n"
+msgstr "Ошибка открытия исходного файла %s\n"
  
  #: auto-profile.c:893
  #, gcc-internal-format
@@ -18418,18 +19448,21 @@ msgstr ""
  
  #: auto-profile.c:907
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "cannot read LTO decls from %s"
  msgid "Cannot read string table from %s."
-msgstr "Ð½ÐµÑ\82 ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qs"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f LTO Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¹ Ð¸Ð· %s"
  
  #: auto-profile.c:912
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "cannot read LTO decls from %s"
  msgid "Cannot read function profile from %s."
-msgstr "Ð½ÐµÑ\82 ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qs"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f LTO Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¹ Ð¸Ð· %s"
  
  #: auto-profile.c:919
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "cannot read LTO decls from %s"
  msgid "Cannot read working set from %s."
-msgstr "Ð½ÐµÑ\82 ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qs"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f LTO Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¹ Ð¸Ð· %s"
  
  #: bt-load.c:1566
  #, gcc-internal-format
@@ -18474,8 +19507,9 @@ msgstr "некорректное использование %qD"
  
  #: builtins.c:4289
  #, fuzzy, gcc-internal-format
+#| msgid "unsupported argument type to builtin function"
  msgid "unsupported argument to %qD"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 внутренней функции"
+msgstr "Ð½ÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° Ð´Ð»Ñ\8f внутренней функции"
  
  #. Warn since no effort is made to ensure that any frame
  #. beyond the current one exists or can be safely reached.
@@ -18485,83 +19519,85 @@ msgid "calling %qD with a nonzero argument is unsafe"
  msgstr ""
  
  #: builtins.c:4547
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "both arguments to %<__builtin___clear_cache%> must be pointers"
-msgstr "третий аргумент %<__builtin_prefetch%> должен быть константой"
+msgstr "оба аргумента %<__builtin___clear_cache%> должны быть указателями"
  
  #: builtins.c:4645
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "trampoline generated for nested function %qD"
-msgstr "Использовать защиту стека для каждой функции"
+msgstr "сгенерирован трамплин для вложенной функции %qD"
  
  #: builtins.c:4937 builtins.c:4950
  #, gcc-internal-format
  msgid "%qD changed semantics in GCC 4.4"
-msgstr ""
+msgstr "семантика %qD изменилась в GCC 4.4"
  
  #: builtins.c:5056
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unknown architecture specifier in memory model to builtin"
-msgstr "неизвестная архитектура '%s'"
+msgstr ""
  
  #: builtins.c:5064
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid memory model argument to builtin"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ðµй функции"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¼Ð¾Ð´ÐµÐ»Ð¸ Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸ Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð¾й функции"
  
  #: builtins.c:5125
  #, gcc-internal-format
  msgid "failure memory model cannot be stronger than success memory model for %<__atomic_compare_exchange%>"
-msgstr ""
+msgstr "модель памяти для случая отказа не может быть сильнее, чем для случая успеха в вызове %<__atomic_compare_exchange%>"
  
  #: builtins.c:5133
  #, gcc-internal-format
  msgid "invalid failure memory model for %<__atomic_compare_exchange%>"
-msgstr ""
+msgstr "задан некорректный аргумент модели памяти для случая отказа в вызове %<__atomic_compare_exchange%>"
  
  #: builtins.c:5198
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid memory model for %<__atomic_load%>"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ %<::%>"
+msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð¼Ð¾Ð´ÐµÐ»Ñ\8c Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸ Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ %<__atomic_load%>"
  
  #: builtins.c:5230 builtins.c:5333
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid memory model for %<__atomic_store%>"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ %<::%>"
+msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð¼Ð¾Ð´ÐµÐ»Ñ\8c Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸ Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ %<__atomic_store%>"
  
  #: builtins.c:5448
  #, gcc-internal-format
  msgid "non-constant argument 1 to __atomic_always_lock_free"
-msgstr ""
+msgstr "неконстантный аргумент 1 в вызове __atomic_always_lock_free"
  
  #: builtins.c:5490
  #, gcc-internal-format
  msgid "non-integer argument 1 to __atomic_is_lock_free"
-msgstr ""
+msgstr "нецелочисленный аргумент 1 в вызове __atomic_is_lock_free"
  
  #: builtins.c:5554
  #, fuzzy, gcc-internal-format
+#| msgid "__builtin_eh_return not supported on this target"
  msgid "__builtin_thread_pointer is not supported on this target"
  msgstr "__builtin_eh_return не поддерживается для этой платформы"
  
  #: builtins.c:5574
  #, fuzzy, gcc-internal-format
+#| msgid "__builtin_eh_return not supported on this target"
  msgid "__builtin_set_thread_pointer is not supported on this target"
  msgstr "__builtin_eh_return не поддерживается для этой платформы"
  
  #. All valid uses of __builtin_va_arg_pack () are removed during
  #. inlining.
  #: builtins.c:5831 expr.c:10565
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%Kinvalid use of %<__builtin_va_arg_pack ()%>"
-msgstr "неверный аргумент для %<__builtin_frame_address%>"
+msgstr "%Kнекорректное использование %<__builtin_va_arg_pack ()%>"
  
  #. All valid uses of __builtin_va_arg_pack_len () are removed during
  #. inlining.
  #: builtins.c:5837
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%Kinvalid use of %<__builtin_va_arg_pack_len ()%>"
-msgstr "неверный аргумент для %<__builtin_frame_address%>"
+msgstr "%Kнекорректное использование %<__builtin_va_arg_pack_len ()%>"
  
  #: builtins.c:6056
  #, gcc-internal-format
@@ -18587,9 +19623,9 @@ msgid "%<va_start%> used in function with fixed args"
  msgstr "%<va_start%> в функции с фиксированным числом аргументов"
  
  #: builtins.c:8924
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "wrong number of arguments to function %<va_start%>"
-msgstr "слишком мало аргументов в вызове функции %<va_start%>"
+msgstr "неверное число аргументов в вызове функции %<va_start%>"
  
  #: builtins.c:8939
  #, gcc-internal-format
@@ -18597,9 +19633,9 @@ msgid "%<__builtin_next_arg%> called without an argument"
  msgstr "вызов %<__builtin_next_arg%> без аргумента"
  
  #: builtins.c:8944
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "wrong number of arguments to function %<__builtin_next_arg%>"
-msgstr "слишком мало аргументов в вызове функции %<va_start%>"
+msgstr "неверное число аргументов в вызове функции %<__builtin_next_arg%>"
  
  #: builtins.c:8976
  #, gcc-internal-format
@@ -18607,49 +19643,52 @@ msgid "second parameter of %<va_start%> not last named argument"
  msgstr "второй аргумент %<va_start%> не является последним явным аргументом"
  
  #: builtins.c:8989
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "undefined behaviour when second parameter of %<va_start%> is declared with %<register%> storage"
  msgid "undefined behavior when second parameter of %<va_start%> is declared with %<register%> storage"
-msgstr ""
+msgstr "неопределенное поведение, т.к. второй параметр %<va_start%> продекларирован с классом памяти %<register%>"
  
  #: builtins.c:9018
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%Kfirst argument of %D must be a pointer, second integer constant"
-msgstr "%Hпервый аргумент %D должен быть указателем, второй - целой константой"
+msgstr "%Kпервый аргумент %D должен быть указателем, второй - целой константой"
  
  #: builtins.c:9031
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%Klast argument of %D is not integer constant between 0 and 3"
-msgstr "%Hпоследний аргумент %D не является целой константой от 0 до 3"
+msgstr "%Kпоследний аргумент %D не является целой константой от 0 до 3"
  
  #: builtins.c:9076 builtins.c:9227 builtins.c:9284
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%Kcall to %D will always overflow destination buffer"
-msgstr "%Hвызов %D всегда переполняет целевой буфер"
+msgstr "%Kвызов %D всегда переполняет целевой буфер"
  
  #: builtins.c:9217
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%Kcall to %D might overflow destination buffer"
-msgstr "%Hвызов %D всегда переполняет целевой буфер"
+msgstr "%Kвызов %D может переполнять целевой буфер"
  
  #: builtins.c:9305
  #, gcc-internal-format
  msgid "%Kattempt to free a non-heap object %qD"
-msgstr ""
+msgstr "%Kпопытка освобождения объекта %qD, не находящегося в динамической памяти"
  
  #: builtins.c:9308
  #, gcc-internal-format
  msgid "%Kattempt to free a non-heap object"
-msgstr ""
+msgstr "%Kпопытка освобождения объекта, не находящегося в динамической памяти"
  
  #: calls.c:2491
  #, gcc-internal-format
  msgid "function call has aggregate value"
  msgstr "функция возвращает агрегатное значение"
  
+#
  #: calls.c:3187
  #, fuzzy, gcc-internal-format
+#| msgid "passing %qT for argument %P to %qD"
  msgid "passing too large argument on stack"
-msgstr "при передаче аргумента %P функции `%+D'"
+msgstr "передача %qT для аргумента %P в %qD"
  
  #: cfgexpand.c:1643 function.c:986 varasm.c:2158
  #, gcc-internal-format
@@ -18673,9 +19712,9 @@ msgid "operand constraints for %<asm%> differ in number of alternatives"
  msgstr "ограничители %<asm%> различаются по числу альтернатив"
  
  #: cfgexpand.c:2739
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "asm-specifier for variable %qE conflicts with asm clobber list"
-msgstr "asm-спецификатор для переменной %qs конфликтует со списком переписываемых регистров"
+msgstr "asm-спецификатор для переменной %qE конфликтует со списком переписываемых регистров"
  
  #: cfgexpand.c:2813
  #, gcc-internal-format
@@ -18690,9 +19729,9 @@ msgstr "неизвестное имя регистра %qs в операторе
  
  #. ??? Diagnose during gimplification?
  #: cfgexpand.c:2887
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "PIC register clobbered by %qs in %<asm%>"
-msgstr "%<asm%> портит PIC-регистр %qs"
+msgstr "%qs в %<asm%> портит PIC-регистр"
  
  #: cfgexpand.c:2992
  #, gcc-internal-format, gfc-internal-format
@@ -18715,14 +19754,14 @@ msgid "asm clobber conflict with input operand"
  msgstr "конфликт в списках переписываемых регистров и входных операндов в asm"
  
  #: cfgexpand.c:6215
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "stack protector not protecting local variables: variable length buffer"
-msgstr "локальные переменные не защищены: буфер переменного размера"
+msgstr "локальные переменные не защищены протектором стека: буфер переменного размера"
  
  #: cfgexpand.c:6219
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "stack protector not protecting function: all local arrays are less than %d bytes long"
-msgstr "функция не защищена: отсутствует буфер размера не менее %d байт"
+msgstr "функция не защищена протектором стека: все локальные массивы имеют размер менее %d байт"
  
  #: cfghooks.c:111
  #, gcc-internal-format, gfc-internal-format
@@ -18737,12 +19776,12 @@ msgstr "предшественником (prev_bb) блока %d должен б
  #: cfghooks.c:134
  #, gcc-internal-format, gfc-internal-format
  msgid "verify_flow_info: Block %i has loop_father, but there are no loops"
-msgstr ""
+msgstr "verify_flow_info: Блок %i имеет поле loop_father, хотя циклов нет"
  
  #: cfghooks.c:140
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "verify_flow_info: Block %i lacks loop_father"
-msgstr "verify_flow_info: Ð\92Ñ\8bÑ\85Ð¾Ð´Ð½Ð°Ñ\8f Ð´Ñ\83Ð³Ð° Ð±Ð»Ð¾ÐºÐ° %d Ð¿Ð¾Ð²Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð°"
+msgstr "verify_flow_info: Ð£ Ð±Ð»Ð¾ÐºÐ° %i Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 loop_father"
  
  #: cfghooks.c:146
  #, gcc-internal-format, gfc-internal-format
@@ -18801,6 +19840,7 @@ msgstr "процедура verify_flow_info выявила ошибки"
  
  #: cfghooks.c:310
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%s does not support duplicate_block"
  msgid "%s does not support dump_bb_for_graph"
  msgstr "%s не поддерживает duplicate_block"
  
@@ -18810,9 +19850,9 @@ msgid "%s does not support redirect_edge_and_branch"
  msgstr "%s не поддерживает redirect_edge_and_branch"
  
  #: cfghooks.c:373
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s does not support can_remove_branch_p"
-msgstr "%s не поддерживает can_merge_blocks_p"
+msgstr "%s не поддерживает can_remove_branch_p"
  
  #: cfghooks.c:470
  #, gcc-internal-format, gfc-internal-format
@@ -18870,9 +19910,9 @@ msgid "%s does not support make_forwarder_block"
  msgstr "%s не поддерживает make_forwarder_block"
  
  #: cfghooks.c:1022
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s does not support force_nonfallthru"
-msgstr "%s не поддерживает move_block_after"
+msgstr "%s не поддерживает force_nonfallthru"
  
  #: cfghooks.c:1050
  #, gcc-internal-format, gfc-internal-format
@@ -18910,24 +19950,25 @@ msgid "corrupt loop tree root"
  msgstr ""
  
  #: cfgloop.c:1343
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "loop with header %d marked for removal"
-msgstr "Включить копирование заголовков циклов в древовидном представлении"
+msgstr ""
  
  #: cfgloop.c:1348
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Enable loop header copying on trees"
  msgid "loop with header %d not in loop tree"
  msgstr "Включить копирование заголовков циклов в древовидном представлении"
  
  #: cfgloop.c:1354
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "non-loop with header %d not marked for removal"
-msgstr "Включить копирование заголовков циклов в древовидном представлении"
+msgstr ""
  
  #: cfgloop.c:1368
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "removed loop %d in loop tree"
-msgstr "Включить копирование заголовков циклов в древовидном представлении"
+msgstr ""
  
  #: cfgloop.c:1376
  #, gcc-internal-format, gfc-internal-format
@@ -18936,56 +19977,61 @@ msgstr "размер цикла %d должен быть %d, а не %d"
  
  #: cfgloop.c:1387
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "bb %d do not belong to loop %d"
  msgid "bb %d does not belong to loop %d"
  msgstr "блок %d не принадлежит циклу %d"
  
  #: cfgloop.c:1399
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "size of loop %d should be %d, not %d"
  msgid "bb %d has father loop %d, should be loop %d"
  msgstr "размер цикла %d должен быть %d, а не %d"
  
  #: cfgloop.c:1416
  #, fuzzy, gcc-internal-format
+#| msgid "loop %d%'s header does not have exactly 2 entries"
  msgid "loop %d%'s header is not a loop header"
  msgstr "заголовок цикла %d не имеет в точности 2 входа"
  
  #: cfgloop.c:1422
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "loop %d%'s header does not have exactly 2 entries"
  msgstr "заголовок цикла %d не имеет в точности 2 входа"
  
  #: cfgloop.c:1429
  #, fuzzy, gcc-internal-format
+#| msgid "loop %d%'s latch does not have header as successor"
  msgid "loop %d%'s latch does not have an edge to its header"
  msgstr "затвор (latch) цикла %d не содержит заголовок цикла среди преемников"
  
  #: cfgloop.c:1434
  #, fuzzy, gcc-internal-format
+#| msgid "loop %d%'s latch does not have header as successor"
  msgid "loop %d%'s latch is not dominated by its header"
  msgstr "затвор (latch) цикла %d не содержит заголовок цикла среди преемников"
  
  #: cfgloop.c:1442
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "loop %d%'s latch does not have exactly 1 successor"
  msgstr "затвор (latch) цикла %d не имеет в точности 1 преемника"
  
  #: cfgloop.c:1447
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "loop %d%'s latch does not have header as successor"
  msgstr "затвор (latch) цикла %d не содержит заголовок цикла среди преемников"
  
  #: cfgloop.c:1452
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "loop %d%'s latch does not belong directly to it"
  msgstr "затвор (latch) цикла %d не принадлежит непосредственно циклу"
  
  #: cfgloop.c:1458
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "loop %d%'s header does not belong directly to it"
  msgstr "заголовок цикла %d не принадлежит циклу"
  
  #: cfgloop.c:1464
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "loop %d%'s latch is marked as part of irreducible region"
  msgstr "затвор (latch) цикла %d помечен как часть несокращаемого региона"
  
@@ -19012,37 +20058,37 @@ msgstr "дуга из %d в %d не должна быть помечена ка
  #: cfgloop.c:1533
  #, gcc-internal-format, gfc-internal-format
  msgid "corrupted head of the exits list of loop %d"
-msgstr ""
+msgstr "испорчена голова списка выходов цикла %d"
  
  #: cfgloop.c:1551
  #, gcc-internal-format, gfc-internal-format
  msgid "corrupted exits list of loop %d"
-msgstr ""
+msgstr "испорчен список выходов цикла %d"
  
  #: cfgloop.c:1560
  #, gcc-internal-format, gfc-internal-format
  msgid "nonempty exits list of loop %d, but exits are not recorded"
-msgstr ""
+msgstr "список выходов цикла %d непуст, но выходы не записаны"
  
  #: cfgloop.c:1587
  #, gcc-internal-format, gfc-internal-format
  msgid "exit %d->%d not recorded"
-msgstr ""
+msgstr "выход %d->%d не записан"
  
  #: cfgloop.c:1610
  #, gcc-internal-format, gfc-internal-format
  msgid "wrong list of exited loops for edge  %d->%d"
-msgstr ""
+msgstr "некорректный список выходов из циклов для дуги %d->%d"
  
  #: cfgloop.c:1619
  #, gcc-internal-format
  msgid "too many loop exits recorded"
-msgstr ""
+msgstr "записано слишком много выходов из цикла"
  
  #: cfgloop.c:1630
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%d exits recorded for loop %d (having %d exits)"
-msgstr "нет записи о единственном выходе из цикла %d"
+msgstr "%d записано для цикла %d (имеющего %d выходов)"
  
  #: cfgrtl.c:2326
  #, gcc-internal-format, gfc-internal-format
@@ -19068,27 +20114,30 @@ msgstr "verify_flow_info: REG_BR_PROB не соответствует CFG %wi %i
  #: cfgrtl.c:2470
  #, gcc-internal-format
  msgid "EDGE_CROSSING incorrectly set across same section"
-msgstr ""
+msgstr "EDGE_CROSSING некорректно установлена через одну и ту же секцию"
  
  #: cfgrtl.c:2475
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "fallthru edge crosses section boundary (bb %i)"
  msgid "fallthru edge crosses section boundary in bb %i"
  msgstr "сквозная дуга пересекает границу секции (блок %i)"
  
  #: cfgrtl.c:2481
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "EH edge crosses section boundary (bb %i)"
  msgid "EH edge crosses section boundary in bb %i"
-msgstr "сквозная дуга пересекает границу секции (блок %i)"
+msgstr "EH дуга пересекает границу секции (блок %i)"
  
  #: cfgrtl.c:2487
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "EH edge crosses section boundary (bb %i)"
  msgid "No region crossing jump at section boundary in bb %i"
-msgstr "сквозная дуга пересекает границу секции (блок %i)"
+msgstr "EH дуга пересекает границу секции (блок %i)"
  
  #: cfgrtl.c:2494
  #, gcc-internal-format
  msgid "EDGE_CROSSING missing across section boundary"
-msgstr ""
+msgstr "EDGE_CROSSING отсутствует для границы секции"
  
  #: cfgrtl.c:2524
  #, gcc-internal-format, gfc-internal-format
@@ -19097,11 +20146,13 @@ msgstr ""
  
  #: cfgrtl.c:2531
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "missing REG_EH_REGION note in the end of bb %i"
  msgid "missing REG_EH_REGION note at the end of bb %i"
  msgstr "отсутствует пометка REG_EH_REGION в конце блока %i"
  
  #: cfgrtl.c:2536
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "too many outgoing branch edges from bb %i"
  msgid "too many exception handling edges in bb %i"
  msgstr "слишком много переходов, исходящих из блока %i"
  
@@ -19112,26 +20163,31 @@ msgstr "слишком много переходов, исходящих из б
  
  #: cfgrtl.c:2549
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "fallthru edge after unconditional jump %i"
  msgid "fallthru edge after unconditional jump in bb %i"
  msgstr "сквозная дуга после безусловного перехода %i"
  
  #: cfgrtl.c:2554
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "wrong number of branch edges after unconditional jump %i"
  msgid "wrong number of branch edges after unconditional jump in bb %i"
  msgstr "некорректное число ветвлений после безусловного перехода %i"
  
  #: cfgrtl.c:2561
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "wrong amount of branch edges after conditional jump %i"
  msgid "wrong amount of branch edges after conditional jump in bb %i"
  msgstr "некорректное число ветвлений после условного перехода %i"
  
  #: cfgrtl.c:2567
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "call edges for non-call insn in bb %i"
  msgid "abnormal call edges for non-call insn in bb %i"
  msgstr "дуги вызова для не-call инструкции в блоке %i"
  
  #: cfgrtl.c:2572
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "call edges for non-call insn in bb %i"
  msgid "sibcall edges for non-call insn in bb %i"
  msgstr "дуги вызова для не-call инструкции в блоке %i"
  
@@ -19163,22 +20219,22 @@ msgstr "для блока %d не установлен флаг BB_RTL"
  #: cfgrtl.c:2686
  #, gcc-internal-format, gfc-internal-format
  msgid "insn %d basic block pointer is %d, should be %d"
-msgstr ""
+msgstr "insn %d: указатель базового блока %d, должно быть %d"
  
  #: cfgrtl.c:2697
  #, gcc-internal-format, gfc-internal-format
  msgid "insn %d in header of bb %d has non-NULL basic block"
-msgstr ""
+msgstr "insn %d в начале блока %d имеет ненулевой базовый блок"
  
  #: cfgrtl.c:2705
  #, gcc-internal-format, gfc-internal-format
  msgid "insn %d in footer of bb %d has non-NULL basic block"
-msgstr ""
+msgstr "insn %d в конце блока %d имеет ненулевой базовый блок"
  
  #: cfgrtl.c:2778 cfgrtl.c:2826
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "insn %d outside of basic blocks has non-NULL bb field"
-msgstr "RTL-инструкция - вне блока"
+msgstr "RTL-инструкция %d вне блока имеет ненулевое поле bb"
  
  #: cfgrtl.c:2786
  #, gcc-internal-format, gfc-internal-format
@@ -19226,14 +20282,14 @@ msgid "caller edge count is negative"
  msgstr "отрицательный счётчик дуг, соответствующих вызовам"
  
  #: cgraph.c:2733
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "caller edge frequency is negative"
-msgstr "Ð¾Ñ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\81Ñ\87Ñ\91Ñ\82Ñ\87Ð¸Ðº Ð´Ñ\83Ð³, Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\89Ð¸Ñ\85 Ð²Ñ\8bÐ·Ð¾Ð²Ð°Ð¼"
+msgstr "Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ñ\81Ñ\87Ñ\91Ñ\82Ñ\87Ð¸ÐºÐ° Ð´Ñ\83Ð³ Ð²Ñ\8bÐ·Ð¾Ð²Ð° Ð¾Ñ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾"
  
  #: cgraph.c:2738
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "caller edge frequency is too large"
-msgstr "Ð¾Ñ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\81Ñ\87Ñ\91Ñ\82Ñ\87Ð¸Ðº Ð´Ñ\83Ð³, Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\89Ð¸Ñ\85 Ð²Ñ\8bÐ·Ð¾Ð²Ð°Ð¼"
+msgstr "Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ñ\81Ñ\87Ñ\91Ñ\82Ñ\87Ð¸ÐºÐ° Ð´Ñ\83Ð³ Ð²Ñ\8bÐ·Ð¾Ð²Ð° Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð²ÐµÐ»Ð¸ÐºÐ¾"
  
  #: cgraph.c:2822
  #, gcc-internal-format, gfc-internal-format
@@ -19241,14 +20297,15 @@ msgid "aux field set for edge %s->%s"
  msgstr "для дуги %s->%s установлено вспомогательное поле"
  
  #: cgraph.c:2829
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "execution count is negative"
-msgstr "Ð\9eтрицательный счётчик числа выполнений"
+msgstr "Ð¾трицательный счётчик числа выполнений"
  
  #: cgraph.c:2834
  #, fuzzy, gcc-internal-format
+#| msgid "node is alone in a comdat group"
  msgid "inline clone in same comdat group list"
-msgstr "ошибка при возврате ненужной функции"
+msgstr "только один узел в comdat группе"
  
  #: cgraph.c:2839
  #, fuzzy, gcc-internal-format
@@ -19259,27 +20316,28 @@ msgstr "Предполагать, что символы могут быть не
  #: cgraph.c:2844
  #, gcc-internal-format
  msgid "externally visible inline clone"
-msgstr ""
+msgstr "видимый извне inline клон"
  
  #: cgraph.c:2849
  #, gcc-internal-format
  msgid "inline clone with address taken"
-msgstr ""
+msgstr "взятие inline клона с адресом"
  
  #: cgraph.c:2854
  #, fuzzy, gcc-internal-format
+#| msgid "inline clone is needed"
  msgid "inline clone is forced to output"
-msgstr "некорректный указатель inlined_to"
+msgstr "требуется inline клон"
  
  #: cgraph.c:2861
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "aux field set for indirect edge from %s"
-msgstr "для дуги %s->%s установлено вспомогательное поле"
+msgstr "aux поле установлено для косвенной дуги из %s"
  
  #: cgraph.c:2868
  #, 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 ""
+msgstr "Косвенная дуга из %s не помечена как косвенная или имеет ассоциированную indirect_info, соответствующий оператор есть: "
  
  #: cgraph.c:2883
  #, gcc-internal-format, gfc-internal-format
@@ -19302,17 +20360,18 @@ msgid "inlined_to pointer set for noninline callers"
  msgstr "указатель inlined_to установлен для не inline вызова"
  
  #: cgraph.c:2924
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "caller edge frequency %i does not match BB frequency %i"
-msgstr "отрицательный счётчик дуг, соответствующих вызовам"
+msgstr "счётчик дуг вызова %i не соответствует частоте базового блока %i"
  
  #: cgraph.c:2942
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "caller edge frequency %i does not match BB frequency %i"
  msgid "indirect call frequency %i does not match BB frequency %i"
-msgstr "отрицательный счётчик дуг, соответствующих вызовам"
+msgstr "счётчик дуг вызова %i не соответствует частоте базового блока %i"
  
  #: cgraph.c:2951
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "inlined_to pointer is set but no predecessors found"
  msgstr "указатель inlined_to установлен, но не найдено ни одного предшественника"
  
@@ -19322,49 +20381,53 @@ msgid "inlined_to pointer refers to itself"
  msgstr "указатель inlined_to ссылается на себя"
  
  #: cgraph.c:2968
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "node has wrong clone_of"
  msgid "cgraph_node has wrong clone_of"
-msgstr ""
+msgstr "узел имеет некорректное значение clone_of"
  
  #: cgraph.c:2980
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "node has wrong clone list"
  msgid "cgraph_node has wrong clone list"
-msgstr ""
+msgstr "узел имеет некорректный список клонов"
  
  #: cgraph.c:2986
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "node is in clone list but it is not clone"
  msgid "cgraph_node is in clone list but it is not clone"
-msgstr ""
+msgstr "узел в списке клонов, но не является клоном"
  
  #: cgraph.c:2991
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "node has wrong prev_clone pointer"
  msgid "cgraph_node has wrong prev_clone pointer"
-msgstr ""
+msgstr "узел имеет некорректное значение prev_clone pointer"
  
  #: cgraph.c:2996
  #, gcc-internal-format
  msgid "double linked list of clones corrupted"
-msgstr ""
+msgstr "испорчен двусвязный список клонов"
  
  #: cgraph.c:3008
  #, gcc-internal-format
  msgid "Alias has call edges"
-msgstr ""
+msgstr "Alias имеет дуги вызовов"
  
  #: cgraph.c:3016
  #, gcc-internal-format
  msgid "Alias has non-alias reference"
-msgstr ""
+msgstr "Alias имеет не-alias ссылку"
  
  #: cgraph.c:3021
  #, gcc-internal-format
  msgid "Alias has more than one alias reference"
-msgstr ""
+msgstr "Alias имеет более одной alias ссылки"
  
  #: cgraph.c:3028
  #, gcc-internal-format
  msgid "Analyzed alias has no reference"
-msgstr ""
+msgstr "Проанализированный alias не имеет ссылки"
  
  #: cgraph.c:3037
  #, gcc-internal-format
@@ -19373,28 +20436,33 @@ msgstr ""
  
  #: cgraph.c:3044
  #, fuzzy, gcc-internal-format
+#| msgid "alignment of %qD is bigger than original declaration"
  msgid "Not instrumented node has non-NULL original declaration"
-msgstr "Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ (Ð° Ð½Ðµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f) Ð² декларации"
+msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ %qD Ð±Ð¾Ð»Ñ\8cÑ\88Ðµ Ñ\87ÐµÐ¼ Ð² Ð¸Ñ\81Ñ\85Ð¾Ð´Ð½Ð¾Ð¹ декларации"
  
  #: cgraph.c:3054
  #, fuzzy, gcc-internal-format
+#| msgid "alignment of %qD is bigger than original declaration"
  msgid "Instrumented node has wrong original declaration"
-msgstr "Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ (Ð° Ð½Ðµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f) Ð² декларации"
+msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ %qD Ð±Ð¾Ð»Ñ\8cÑ\88Ðµ Ñ\87ÐµÐ¼ Ð² Ð¸Ñ\81Ñ\85Ð¾Ð´Ð½Ð¾Ð¹ декларации"
  
  #: cgraph.c:3072
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Alias has more than one alias reference"
  msgid "Node has more than one chkp reference"
-msgstr ""
+msgstr "Alias имеет более одной alias ссылки"
  
  #: cgraph.c:3077
  #, fuzzy, gcc-internal-format
+#| msgid "forming reference to reference type %qT"
  msgid "Wrong node is referenced with chkp reference"
-msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ %s на ссылочный тип %qT"
+msgstr "Ñ\84Ð¾Ñ\80Ð¼Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ на ссылочный тип %qT"
  
  #: cgraph.c:3085
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Analyzed alias has no reference"
  msgid "Analyzed node has no reference to instrumented version"
-msgstr ""
+msgstr "Проанализированный alias не имеет ссылки"
  
  #: cgraph.c:3099
  #, gcc-internal-format
@@ -19404,17 +20472,17 @@ msgstr ""
  #: cgraph.c:3108
  #, gcc-internal-format
  msgid "No edge out of thunk node"
-msgstr ""
+msgstr "Нет дуги из thunk-узла"
  
  #: cgraph.c:3113
  #, gcc-internal-format
  msgid "More than one edge out of thunk node"
-msgstr ""
+msgstr "Более одной дуги исходит из thunk-узла"
  
  #: cgraph.c:3118
  #, gcc-internal-format
  msgid "Thunk is not supposed to have body"
-msgstr ""
+msgstr "Thunk не должен иметь тела"
  
  #: cgraph.c:3124
  #, gcc-internal-format
@@ -19434,7 +20502,7 @@ msgstr "дуга указывает на неверную декларацию:"
  #: cgraph.c:3177
  #, gcc-internal-format
  msgid "an indirect edge with unknown callee corresponding to a call_stmt with a known declaration:"
-msgstr ""
+msgstr "косвенная дуга с неизвестной вызываемой функцией, соответствующая call_stmt в известной декларации"
  
  #: cgraph.c:3187
  #, gcc-internal-format
@@ -19453,9 +20521,9 @@ msgid "edge %s->%s has no corresponding call_stmt"
  msgstr "отсутствует call_stmt, соответствующий дуге %s->%s"
  
  #: cgraph.c:3222
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "an indirect edge from %s has no corresponding call_stmt"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 call_stmt, Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\89Ð¸Ð¹ Ð´Ñ\83Ð³Ðµ %s->%s"
+msgstr "ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ð°Ñ\8f Ð´Ñ\83Ð³Ð° Ð¸Ð· %s Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\89ÐµÐ³Ð¾ call_stmt"
  
  #: cgraph.c:3233
  #, gcc-internal-format
@@ -19463,34 +20531,34 @@ msgid "verify_cgraph_node failed"
  msgstr "процедура verify_cgraph_node выявила ошибки"
  
  #: cgraph.c:3332 varpool.c:304
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s: section %s is missing"
-msgstr "не задан аргумент ключа '-%s'"
+msgstr "%s: секция %s отсутствует"
  
  #: cgraphunit.c:680
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<weakref%> attribute should be accompanied with an %<alias%> attribute"
-msgstr "%Jатрибут weakref должен задаваться до атрибута alias"
+msgstr "атрибут %<weakref%> должен сопровождаться атрибутом %<alias%>"
  
  #: cgraphunit.c:732 cgraphunit.c:768
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<externally_visible%> attribute have effect only on public objects"
-msgstr "%qE атрибут действует только в public-объектах"
+msgstr "атрибут %<externally_visible%> действует только в public-объектах"
  
  #: cgraphunit.c:739
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<weakref%> attribute ignored because function is defined"
-msgstr "атрибут %qE для не классовых типов игнорируется"
+msgstr "атрибут %<weakref%> игнорируется, поскольку функция определена"
  
  #: cgraphunit.c:751
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "always_inline function might not be inlinable"
-msgstr "Предупреждать об inline-функциях, подстановка которых невозможна"
+msgstr "always_inline функция, возможно, не годится для подстановки"
  
  #: cgraphunit.c:776
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<weakref%> attribute ignored because variable is initialized"
-msgstr "атрибут %qE для не классовых типов игнорируется"
+msgstr "атрибут %<weakref%> игнорируется, поскольку переменная инициализирована"
  
  #. include_self=
  #: cgraphunit.c:936 c/c-decl.c:10760
@@ -19510,14 +20578,14 @@ msgid "%qD defined but not used"
  msgstr "%q+D определена, но нигде не используется"
  
  #: cgraphunit.c:1271 c-family/c-pragma.c:335
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q+D aliased to undefined symbol %qE"
-msgstr "%q+D - алиас неопределенного символа %qs"
+msgstr "%q+D - алиас неопределенного символа %qE"
  
  #: cgraphunit.c:1287
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q+D aliased to external symbol %qE"
-msgstr "%q+D - алиас внешнего символа %qs"
+msgstr "%q+D - алиас внешнего символа %qE"
  
  #: cgraphunit.c:1308
  #, gcc-internal-format
@@ -19526,8 +20594,9 @@ msgstr ""
  
  #: cgraphunit.c:1310
  #, fuzzy, gcc-internal-format
+#| msgid "%q+D used prior to declaration"
  msgid "%q+D aliased declaration"
-msgstr "%J%qD использовано до декларации"
+msgstr "%q+D использовано до декларации"
  
  #: cgraphunit.c:1381
  #, gcc-internal-format
@@ -19535,14 +20604,15 @@ msgid "failed to reclaim unneeded function"
  msgstr "ошибка при возврате ненужной функции"
  
  #: cgraphunit.c:1409
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "failed to reclaim unneeded function in same comdat group"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80Ð¸ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ðµ Ð½ÐµÐ½Ñ\83Ð¶Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð½Ðµ Ñ\83Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð·Ð°Ð¿Ñ\80Ð¾Ñ\81Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð¾ Ð½ÐµÐ½Ñ\83Ð¶Ð½Ñ\83Ñ\8e Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8e Ð² Ñ\82Ð¾Ð¹ Ð¶Ðµ comdat Ð³Ñ\80Ñ\83Ð¿Ð¿Ðµ"
  
  #: cgraphunit.c:1651
  #, fuzzy, gcc-internal-format
+#| msgid "generic thunk code fails for method %q#D which uses %<...%>"
  msgid "generic thunk code fails for method %qD which uses %<...%>"
-msgstr "ошибка в обобщенном thunk-коде для метода `%#D', который использует `...'"
+msgstr "ошибка в обобщенном thunk-коде для метода %q#D, который использует %<...%>"
  
  #: cgraphunit.c:2008
  #, gcc-internal-format
@@ -19555,14 +20625,14 @@ msgid "size of return value of %q+D is larger than %wd bytes"
  msgstr "размер возвращаемого значение %q+D превышает %wd байт"
  
  #: cgraphunit.c:2505
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "nodes with unreleased memory found"
  msgstr "обнаружены узлы с неосвобожденной памятью"
  
  #: collect-utils.c:68
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can't get program status: %m"
-msgstr "не удалось получить состояние программы"
+msgstr "не удалось получить состояние программы: %m"
  
  #: collect-utils.c:82
  #, gcc-internal-format, gfc-internal-format
@@ -19595,14 +20665,14 @@ msgid "cannot find '%s'"
  msgstr "не удалось найти '%s'"
  
  #: collect-utils.c:183 collect2.c:2361 collect2.c:2560 gcc.c:3060 gcc.c:6729
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "pex_init failed: %m"
-msgstr "ошибка в pex_init"
+msgstr "ошибка в pex_init: %m"
  
  #: collect-utils.c:192 collect2.c:2370 collect2.c:2568 gcc.c:8345
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s: %m"
-msgstr "%s: %s"
+msgstr "%s: %m"
  
  #: collect2.c:702
  #, gcc-internal-format
@@ -19611,9 +20681,9 @@ msgstr "должна быть установлена COLLECT_LTO_WRAPPER"
  
  #: collect2.c:966 gcc.c:7255 lto-wrapper.c:1479
  #: config/i386/intelmic-mkoffload.c:554 config/nvptx/mkoffload.c:403
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "atexit failed"
-msgstr "ошибка в pex_init"
+msgstr "ошибка в atexit"
  
  #: collect2.c:1064
  #, gcc-internal-format
@@ -19621,9 +20691,9 @@ msgid "no arguments"
  msgstr "отсутствуют аргументы"
  
  #: collect2.c:1303 opts.c:890
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "LTO support has not been enabled in this configuration"
-msgstr "-m%s в данной конфигурации не поддерживается"
+msgstr "Поддержка LTO в данной конфигурации отсутствует"
  
  #: collect2.c:1344
  #, gcc-internal-format
@@ -19636,14 +20706,14 @@ msgid "unknown demangling style '%s'"
  msgstr "неизвестный стиль декодирования имён '%s'"
  
  #: collect2.c:1546 collect2.c:1729 collect2.c:1769
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "fopen %s: %m"
-msgstr "fopen %s"
+msgstr "fopen %s: %m"
  
  #: collect2.c:1549 collect2.c:1734 collect2.c:1772
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "fclose %s: %m"
-msgstr "fclose %s"
+msgstr "fclose %s: %m"
  
  #: collect2.c:2335
  #, gcc-internal-format
@@ -19651,9 +20721,9 @@ msgid "cannot find 'nm'"
  msgstr "не удалось найти 'nm'"
  
  #: collect2.c:2383
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can't open nm output: %m"
-msgstr "не удалось открыть выходной файл nm"
+msgstr "не удалось открыть выходной файл nm: %m"
  
  #: collect2.c:2467
  #, gcc-internal-format, gfc-internal-format
@@ -19671,9 +20741,9 @@ msgid "cannot find 'ldd'"
  msgstr "не найдена программа `ldd'"
  
  #: collect2.c:2581
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can't open ldd output: %m"
-msgstr "не удалось открыть выходной файл ldd"
+msgstr "не удалось открыть выходной файл ldd: %m"
  
  #: collect2.c:2599
  #, gcc-internal-format, gfc-internal-format
@@ -19722,6 +20792,7 @@ msgstr "преобразование к неполному типу"
  
  #: convert.c:942
  #, fuzzy, gcc-internal-format
+#| msgid "can%'t convert between vector values of different size"
  msgid "can%'t convert a vector of type %qT to type %qT which has different size"
  msgstr "невозможно преобразовать векторное значение в векторное значение другого размера"
  
@@ -19742,18 +20813,19 @@ msgstr "агрегатное значение вместо ожидаемого
  
  #: convert.c:1073
  #, fuzzy, gcc-internal-format
+#| msgid "can%'t convert between vector values of different size"
  msgid "can%'t convert a value of type %qT to vector type %qT which has different size"
  msgstr "невозможно преобразовать векторное значение в векторное значение другого размера"
  
  #: convert.c:1081
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t convert value to a vector"
  msgstr "невозможно преобразовать значение в вектор"
  
  #: convert.c:1120
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "aggregate value used where a fixed-point was expected"
-msgstr "Ð°Ð³Ñ\80ÐµÐ³Ð°Ñ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð²Ð¼ÐµÑ\81Ñ\82Ð¾ Ð¾Ð¶Ð¸Ð´Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ³Ð¾"
+msgstr "Ð°Ð³Ñ\80ÐµÐ³Ð°Ñ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¾ Ð²Ð¼ÐµÑ\81Ñ\82Ð¾ Ð¾Ð¶Ð¸Ð´Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ñ\81 Ñ\84Ð¸ÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹"
  
  #: coverage.c:198
  #, gcc-internal-format
@@ -19768,12 +20840,12 @@ msgstr "%qs версии %q.*s, ожидаемая версия %q.*s"
  #: coverage.c:291 coverage.c:301
  #, gcc-internal-format, gfc-internal-format
  msgid "Profile data for function %u is corrupted"
-msgstr ""
+msgstr "Данные профилирования для функции %u испорчены"
  
  #: coverage.c:292
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "checksum is (%x,%x) instead of (%x,%x)"
-msgstr "контрольная сумма %x, а должна быть %x"
+msgstr "контрольная сумма (%x,%x), а должна быть (%x,%x)"
  
  #: coverage.c:302
  #, gcc-internal-format, gfc-internal-format
@@ -19793,22 +20865,24 @@ msgstr "переполнение %qs"
  #: coverage.c:386
  #, gcc-internal-format
  msgid "the control flow of function %qE does not match its profile data (counter %qs)"
-msgstr ""
+msgstr "поток управления функции %qE не соответствует данным профилирования (счетчик %qs)"
  
  #: coverage.c:402
  #, fuzzy, gcc-internal-format
+#| msgid "execution counts estimated"
  msgid "execution counts estimated\n"
-msgstr "Ð\9eÑ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\81Ñ\87Ñ\91Ñ\82Ñ\87Ð¸Ðº числа выполнений"
+msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ñ\8b Ð¾Ñ\86ÐµÐ½ÐºÐ¸ Ñ\81Ñ\87Ñ\91Ñ\82Ñ\87Ð¸ÐºÐ¾Ð² числа выполнений"
  
  #: coverage.c:403
  #, fuzzy, gcc-internal-format
+#| msgid "execution counts assumed to be zero"
  msgid "execution counts assumed to be zero\n"
-msgstr "Ð\9eÑ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\81Ñ\87Ñ\91Ñ\82Ñ\87Ð¸Ðº Ñ\87Ð¸Ñ\81Ð»Ð° Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ð¹"
+msgstr "Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÑ\82Ñ\81Ñ\8f, Ñ\87Ñ\82Ð¾ Ñ\81Ñ\87Ñ\91Ñ\82Ñ\87Ð¸ÐºÐ¸ Ñ\87Ð¸Ñ\81Ð»Ð° Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ð¹ Ð½Ñ\83Ð»ÐµÐ²Ñ\8bÐµ"
  
  #: coverage.c:415
  #, gcc-internal-format
  msgid "source locations for function %qE have changed, the profile data may be out of date"
-msgstr ""
+msgstr "размещение исходного текста функции %qE изменилось, возможно, данные профилирования устарели"
  
  #: coverage.c:677
  #, gcc-internal-format
@@ -19823,32 +20897,32 @@ msgstr "ошибка открытия %s"
  #: data-streamer-in.c:53
  #, gcc-internal-format
  msgid "bytecode stream: string too long for the string table"
-msgstr ""
+msgstr "байткод: строка лишком длинная для таблицы строк"
  
  #: data-streamer-in.c:84 data-streamer-in.c:113
  #, gcc-internal-format
  msgid "bytecode stream: found non-null terminated string"
-msgstr ""
+msgstr "байткод: обнаружена строка, не заканчивающаяся нулем"
  
  #: dbgcnt.c:133
  #, gcc-internal-format
  msgid "cannot find a valid counter:value pair:"
-msgstr ""
+msgstr "не найдена корректная пара счетчик:значение"
  
  #: dbgcnt.c:134
  #, gcc-internal-format, gfc-internal-format
  msgid "-fdbg-cnt=%s"
-msgstr ""
+msgstr "-fdbg-cnt=%s"
  
  #: dbgcnt.c:135
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "          %s"
-msgstr "      "
+msgstr "          %s"
  
  #: dbxout.c:3331
  #, gcc-internal-format
  msgid "common symbol debug info is not structured as symbol+offset"
-msgstr ""
+msgstr "отладочная информация common-символа не имеет вид символ+смещение"
  
  #: dbxout.c:3803
  #, gcc-internal-format
@@ -19876,9 +20950,9 @@ msgid "dominator of %d should be %d, not %d"
  msgstr "доминатором %d должен быть %d, а не %d"
  
  #: dumpfile.c:316 dumpfile.c:480 dumpfile.c:573
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "could not open dump file %qs: %m"
-msgstr "ошибка открытия дамп-файла %qs: %s"
+msgstr "ошибка открытия дамп-файла %qs: %m"
  
  #: dumpfile.c:815
  #, gcc-internal-format
@@ -19887,6 +20961,7 @@ msgstr "проигнорирован неопознанная опция %q.*s 
  
  #: dumpfile.c:923
  #, fuzzy, gcc-internal-format
+#| msgid "ignoring unknown option %q.*s in %<-fdump-%s%>"
  msgid "unknown option %q.*s in %<-fopt-info-%s%>"
  msgstr "проигнорирован неопознанная опция %q.*s в %<-fdump-%s%>"
  
@@ -19898,12 +20973,12 @@ msgstr ""
  #: dwarf2out.c:1099
  #, gcc-internal-format
  msgid "multiple EH personalities are supported only with assemblers supporting .cfi_personality directive"
-msgstr ""
+msgstr "множественные программы индивидуальности для EH поддерживаются только если ассемблер поддерживает директиву .cfi_personality"
  
  #: dwarf2out.c:12431
  #, gcc-internal-format, gfc-internal-format
  msgid "non-delegitimized UNSPEC %s (%d) found in variable location"
-msgstr ""
+msgstr "non-delegitimized UNSPEC %s (%d) найден в расположении переменной"
  
  #: dwarf2out.c:25296
  #, gcc-internal-format
@@ -19918,7 +20993,7 @@ msgstr "Некорректное разделение rtl-кода в инстр
  #: emit-rtl.c:2734
  #, gcc-internal-format
  msgid "shared rtx"
-msgstr "разделяемый rtl-код"
+msgstr "разделяемый rtx"
  
  #: emit-rtl.c:2736
  #, gcc-internal-format
@@ -19951,9 +21026,9 @@ msgid "region_array is corrupted for region %i"
  msgstr "испорчен region_array для региона %i"
  
  #: except.c:3330 except.c:3361
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "lp_array is corrupted for lp %i"
-msgstr "испорчен region_array для региона %i"
+msgstr "испорчен lp_array для lp %i"
  
  #: except.c:3347
  #, gcc-internal-format, gfc-internal-format
@@ -19966,9 +21041,9 @@ msgid "negative nesting depth of region %i"
  msgstr "отрицательная глубина вложенности региона %i"
  
  #: except.c:3366
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "region of lp %i is wrong"
-msgstr "Ð½ÐµÐ¿Ñ\80Ð°Ð²Ð¸Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¹ Ð±Ð»Ð¾Ðº Ñ\80ÐµÐ³Ð¸Ð¾Ð½Ð° %i"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\80ÐµÐ³Ð¸Ð¾Ð½ lp %i"
  
  #: except.c:3393
  #, gcc-internal-format, gfc-internal-format
@@ -19976,14 +21051,14 @@ msgid "tree list ends on depth %i"
  msgstr "лист дерева на глубине %i"
  
  #: except.c:3398
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "region_array does not match region_tree"
-msgstr "массив не соответствует дереву регионов"
+msgstr "region_array не соответствует region_tree"
  
  #: except.c:3403
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "lp_array does not match region_tree"
-msgstr "массив не соответствует дереву регионов"
+msgstr "lp_array не соответствует region_tree"
  
  #: except.c:3410
  #, gcc-internal-format
@@ -20016,39 +21091,39 @@ msgid "write of %wu-bit data outside the bound of destination object, data trunc
  msgstr ""
  
  #: expr.c:10572
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%Kcall to %qs declared with attribute error: %s"
-msgstr "%Jфункция %qD повторно декларирована с атрибутом noinline"
+msgstr "%Kвызов %qs, объявленной с атрибутом error: %s"
  
  #: expr.c:10579
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%Kcall to %qs declared with attribute warning: %s"
-msgstr "%Jфункция %qD повторно декларирована с атрибутом noinline"
+msgstr "%Kвызов %qs, объявленной с атрибутом warning: %s"
  
  #: final.c:1533
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid argument %qs to -fdebug-prefix-map"
-msgstr "некорректный аргумент атрибута %qs"
+msgstr "некорректный аргумент %qs ключа -fdebug-prefix-map"
  
  #: final.c:1835
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the frame size of %wd bytes is larger than %wd bytes"
-msgstr "размер %q+D больше %wd байт"
+msgstr "размер кадра %wd байт больше чем %wd байт"
  
  #: final.c:4589 toplev.c:1374 tree-cfgcleanup.c:1122
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "could not open final insn dump file %qs: %m"
-msgstr "ошибка открытия дамп-файла %qs: %s"
+msgstr "ошибка открытия дамп-файла прохода final %qs: %m"
  
  #: final.c:4642 tree-cfgcleanup.c:1138
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "could not close final insn dump file %qs: %m"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82Ð¸Ñ\8f Ð´Ð°Ð¼Ð¿-Ñ\84Ð°Ð¹Ð»Ð° %qs: %s"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð·Ð°ÐºÑ\80Ñ\8bÑ\82Ð¸Ñ\8f Ð´Ð°Ð¼Ð¿-Ñ\84Ð°Ð¹Ð»Ð° Ð¿Ñ\80Ð¾Ñ\85Ð¾Ð´Ð° final %qs: %m"
  
  #: fixed-value.c:128
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "large fixed-point constant implicitly truncated to fixed-point type"
-msgstr "Ð½ÐµÑ\8fÐ²Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ðµ Ð±Ð¾Ð»Ñ\8cÑ\88Ð¾Ð³Ð¾ Ñ\86ÐµÐ»Ð¾Ð³Ð¾ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ðº Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ð¾Ð¼Ñ\83 Ñ\82Ð¸Ð¿Ñ\83"
+msgstr "Ð±Ð¾Ð»Ñ\8cÑ\88Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ñ\81 Ñ\84Ð¸ÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹ Ð½ÐµÑ\8fÐ²Ð½Ð¾ Ñ\83Ñ\80ÐµÐ·Ð°Ð½Ð° Ðº Ñ\82Ð¸Ð¿Ñ\83 Ñ\81 Ñ\84Ð¸ÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹"
  
  #: fold-const.c:3943 fold-const.c:3953
  #, gcc-internal-format, gfc-internal-format
@@ -20058,7 +21133,7 @@ msgstr "при данной ширине битового поля резуль
  #: fold-const.c:5316 tree-ssa-reassoc.c:2144
  #, gcc-internal-format
  msgid "assuming signed overflow does not occur when simplifying range test"
-msgstr ""
+msgstr "предполагается что при упрощении проверки диапазона не произошло переполнение"
  
  #: fold-const.c:5765 fold-const.c:5779
  #, gcc-internal-format, gfc-internal-format
@@ -20078,17 +21153,18 @@ msgstr "%<или%> от двух взаимно исключающих срав
  #: fold-const.c:8267
  #, gcc-internal-format
  msgid "assuming signed overflow does not occur when reducing constant in comparison"
-msgstr ""
+msgstr "предполагается что при редукции константы в сравнении не произошло переполнение"
  
  #: fold-const.c:8437
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "assuming signed overflow does not occur when changing X +- C1 cmp C2 to X cmp C1 +- C2"
  msgid "assuming signed overflow does not occur when changing X +- C1 cmp C2 to X cmp C2 -+ C1"
-msgstr ""
+msgstr "предполагается что при замене X +- C1 cmp C2 на X cmp C1 +- C2 не произошло переполнение"
  
  #: fold-const.c:8708
  #, gcc-internal-format
  msgid "assuming signed overflow does not occur when combining constants around a comparison"
-msgstr ""
+msgstr "предполагается, что при комбинировании констант вокруг сравнения не произошло переполнение"
  
  #: fold-const.c:12274
  #, gcc-internal-format
@@ -20096,9 +21172,9 @@ msgid "fold check: original tree changed by fold"
  msgstr "проверка fold: исходное дерево изменено функцией fold"
  
  #: function.c:241
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "total size of local objects too large"
-msgstr "%Jобщий размер локальных объектов слишком велик"
+msgstr "общий размер локальных объектов слишком велик"
  
  #: function.c:1758 gimplify.c:5335
  #, gcc-internal-format
@@ -20136,9 +21212,9 @@ msgid "specs %s spec was not found to be renamed"
  msgstr "спецификация %s, которую нужно переименовать, не найдена"
  
  #: gcc.c:2198
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s: attempt to rename spec %qs to already defined spec %qs"
-msgstr "%s: попытка переименовать '%s в уже определённую спецификацию '%s'"
+msgstr "%s: попытка переименовать %qs в уже определённую спецификацию %qs"
  
  #: gcc.c:2220
  #, gcc-internal-format, gfc-internal-format
@@ -20156,9 +21232,9 @@ msgid "spec file has no spec for linking"
  msgstr "в файле спецификаций отсутствует спецификация для компоновки"
  
  #: gcc.c:2849
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "system path %qs is not absolute"
-msgstr "путь '%s' в файловой системе не является абсолютным"
+msgstr "системный путь %qs не является абсолютным"
  
  #: gcc.c:2937
  #, gcc-internal-format
@@ -20166,24 +21242,24 @@ msgid "-pipe not supported"
  msgstr "ключ -pipe не поддерживается"
  
  #: gcc.c:3099
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "failed to get exit status: %m"
-msgstr "не удалось получить код возврата"
+msgstr "не удалось получить код возврата: %m"
  
  #: gcc.c:3105
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "failed to get process times: %m"
-msgstr "не удалось вычислить время обработки"
+msgstr "не удалось вычислить время обработки: %m"
  
  #: gcc.c:3131
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s (program %s)"
-msgstr "программы: %s\n"
+msgstr "%s (программа %s)"
  
  #: gcc.c:3585 opts-common.c:1158 opts-common.c:1182 opts-global.c:136
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unrecognized command line option %qs"
-msgstr "некорректный ключ \"%s\""
+msgstr "некорректный ключ %qs"
  
  #: gcc.c:3650
  #, gcc-internal-format, gfc-internal-format
@@ -20193,7 +21269,7 @@ msgstr ""
  #: gcc.c:3948
  #, gcc-internal-format
  msgid "%qs is an unknown -save-temps option"
-msgstr ""
+msgstr "%qs - неопределенный ключ -save-temps"
  
  #: gcc.c:4414 toplev.c:893
  #, fuzzy, gcc-internal-format
@@ -20202,29 +21278,29 @@ msgid "input file %qs is the same as output file"
  msgstr "%qs не является корректным выходным файлом"
  
  #: gcc.c:4441
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-pipe ignored because -save-temps specified"
-msgstr "Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ðµ: ÐºÐ»Ñ\8eÑ\87 -pipe Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83ÐµÑ\82Ñ\81Ñ\8f, Ñ\82.Ðº. Ð·Ð°Ð´Ð°Ð½ ÐºÐ»Ñ\8eÑ\87 -save-temps"
+msgstr "ключ -pipe игнорируется, т.к. задан ключ -save-temps"
  
  #: gcc.c:4529
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<-x %s%> after last input file has no effect"
-msgstr "предупреждение: '-x %s' не имеет смысла за последним входным файлом"
+msgstr "%<-x %s%> не имеет смысла за последним входным файлом"
  
  #: gcc.c:4711
  #, gcc-internal-format
  msgid "unable to locate default linker script %qs in the library search paths"
-msgstr ""
+msgstr "не найден скрипт компоновки по умолчанию %qs в пути поиска библиотек"
  
  #: gcc.c:4916
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "switch %qs does not start with %<-%>"
-msgstr "ключ '%s' не начинается с '-'"
+msgstr "ключ %qs не начинается с %<-%>"
  
  #: gcc.c:4920
  #, gcc-internal-format
  msgid "spec-generated switch is just %<-%>"
-msgstr ""
+msgstr "ключ, сгенерированный программой spec, состоит из одного знака %<-%>"
  
  #: gcc.c:5013
  #, gcc-internal-format, gfc-internal-format
@@ -20242,47 +21318,47 @@ msgid "could not close temporary response file %s"
  msgstr "не удалось закрыть временный файл ответа %s"
  
  #: gcc.c:5149
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "spec %qs invalid"
-msgstr "спецификация '%s' некорректна"
+msgstr "спецификация %qs некорректна"
  
  #: gcc.c:5299
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "spec %qs has invalid %<%%0%c%>"
-msgstr "спецификация '%s' имеет некорректный '%%0%c'"
+msgstr "спецификация %qs имеет некорректный %<%%0%c%>"
  
  #: gcc.c:5619
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "spec %qs has invalid %<%%W%c%>"
-msgstr "спецификация '%s' имеет некорректный '%%W%c'"
+msgstr "спецификация %qs имеет некорректный %<%%W%c%>"
  
  #: gcc.c:5642
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "spec %qs has invalid %<%%x%c%>"
-msgstr "спецификация '%s' имеет некорректный '%%x%c'"
+msgstr "спецификация %qs имеет некорректный %<%%x%c%>"
  
  #. Catch the case where a spec string contains something like
  #. '%{foo:%*}'.  i.e. there is no * in the pattern on the left
  #. hand side of the :.
  #: gcc.c:5853
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "spec failure: %<%%*%> has not been initialized by pattern match"
-msgstr "ошибка спецификации: элемент '%%*' не инициализирован при сопоставлении"
+msgstr "ошибка спецификации: элемент %<%%*%> не инициализирован при сопоставлении"
  
  #: gcc.c:5896
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "spec failure: unrecognized spec option %qc"
-msgstr "ошибка спецификации: неопознанный ключ '%c'"
+msgstr "ошибка спецификации: неопознанный ключ %qc"
  
  #: gcc.c:5958
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unknown spec function %qs"
-msgstr "неизвестная функция '%s' в спецификации"
+msgstr "неизвестная функция %qs в спецификации"
  
  #: gcc.c:5988
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "error in args to spec function %qs"
-msgstr "ошибка в аргументах spec-функции '%s'"
+msgstr "ошибка в аргументах spec-функции %qs"
  
  #: gcc.c:6042
  #, gcc-internal-format
@@ -20301,34 +21377,34 @@ msgid "malformed spec function arguments"
  msgstr "некорректные аргументы spec-функции"
  
  #: gcc.c:6338
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "braced spec %qs is invalid at %qc"
-msgstr "ошибка в спецификации '%s' в скобках на символе '%c'"
+msgstr "ошибка в спецификации %qs в скобках на символе %qc"
  
  #: gcc.c:6433
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "braced spec body %qs is invalid"
-msgstr "ошибка в спецификации '%s' в скобках"
+msgstr "ошибка в спецификации %qs в скобках"
  
  #: gcc.c:7039
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s: could not determine length of compare-debug file %s"
-msgstr "не удалось записать файл отзыва %s"
+msgstr "%s: не удалось определить длину файла %s для сравнения результатов компиляции с отладочной информацией и без"
  
  #: gcc.c:7050
  #, gcc-internal-format, gfc-internal-format
  msgid "%s: -fcompare-debug failure (length)"
-msgstr ""
+msgstr "%s: ошибка -fcompare-debug (длина)"
  
  #: gcc.c:7060 gcc.c:7101
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s: could not open compare-debug file %s"
-msgstr "%s:ошибка открытия выходного файла '%s'\n"
+msgstr "%s: ошибка открытия файла %s для сравнения результатов компиляции с отладочной информацией и без"
  
  #: gcc.c:7080 gcc.c:7117
  #, gcc-internal-format, gfc-internal-format
  msgid "%s: -fcompare-debug failure"
-msgstr ""
+msgstr "%s: ошибка -fcompare-debug"
  
  #: gcc.c:7425
  #, gcc-internal-format
@@ -20342,13 +21418,15 @@ msgstr "ошибка спецификации: задано более одно
  
  #: gcc.c:7740
  #, fuzzy, gcc-internal-format
+#| msgid "unrecognized command line option %<-fdump-%s%>"
  msgid "unrecognized command line option %<-%s%>; did you mean %<-%s%>?"
-msgstr "некорректный ключ \"%s\""
+msgstr "некорректный ключ %<-fdump-%s%>"
  
  #: gcc.c:7744
  #, fuzzy, gcc-internal-format
+#| msgid "unrecognized command line option %<-fdump-%s%>"
  msgid "unrecognized command line option %<-%s%>"
-msgstr "некорректный ключ \"%s\""
+msgstr "некорректный ключ %<-fdump-%s%>"
  
  #: gcc.c:7870
  #, gcc-internal-format
@@ -20361,9 +21439,9 @@ msgid "no input files"
  msgstr "не заданы входные файлы"
  
  #: gcc.c:7982
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot specify -o with -c, -S or -E with multiple files"
-msgstr "нельзя использовать -o с -c или -S и несколькими файлами"
+msgstr "нельзя использовать -o с, -S или -E и несколькими файлами"
  
  #: gcc.c:8023
  #, gcc-internal-format, gfc-internal-format
@@ -20373,22 +21451,22 @@ msgstr "%s: компилятор %s не установлен"
  #: gcc.c:8047
  #, gcc-internal-format
  msgid "recompiling with -fcompare-debug"
-msgstr ""
+msgstr "повторная компиляция с -fcompare-debug"
  
  #: gcc.c:8063
  #, gcc-internal-format
  msgid "during -fcompare-debug recompilation"
-msgstr ""
+msgstr "во время повторной компиляции для -fcompare-debug"
  
  #: gcc.c:8072
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "comparing final insns dumps"
-msgstr "Ñ\80ÐµÐ·Ñ\83Ð»Ñ\8cÑ\82Ð°Ñ\82 Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8f - Ð²Ñ\81ÐµÐ³Ð´Ð° %d"
+msgstr "Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ Ñ\84Ð¸Ð½Ð°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ð´Ð°Ð¼Ð¿Ð¾Ð² ÐºÐ¾Ð¼Ð¿Ð¸Ð»Ñ\8fÑ\82Ð¾Ñ\80Ð°"
  
  #: gcc.c:8189
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "-fuse-linker-plugin, but %s not found"
-msgstr "нет поля %qs"
+msgstr "-fuse-linker-plugin, но %s не найден"
  
  #: gcc.c:8222
  #, gcc-internal-format, gfc-internal-format
@@ -20401,39 +21479,40 @@ msgid "language %s not recognized"
  msgstr "некорректное задание языка %s"
  
  #: gcc.c:8513
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "multilib spec %qs is invalid"
-msgstr "описание мультибиблиотеки '%s' некорректно"
+msgstr "описание мультибиблиотеки %qs некорректно"
  
  #: gcc.c:8715
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "multilib exclusions %qs is invalid"
-msgstr "исключения '%s' в мультибиблиотеке некорректны"
+msgstr "исключения %qs в мультибиблиотеке некорректны"
  
  #: gcc.c:8779
  #, fuzzy, gcc-internal-format
+#| msgid "multilib select %qs is invalid"
  msgid "multilib select %qs %qs is invalid"
-msgstr "выбор мультибиблиотеки '%s' некорректен"
+msgstr "выбор мультибиблиотеки %qs некорректен"
  
  #: gcc.c:8941
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "multilib select %qs is invalid"
-msgstr "выбор мультибиблиотеки '%s' некорректен"
+msgstr "выбор мультибиблиотеки %qs некорректен"
  
  #: gcc.c:8981
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "multilib exclusion %qs is invalid"
-msgstr "исключение '%s' в мультибиблиотеке некорректно"
+msgstr "исключение %qs в мультибиблиотеке некорректно"
  
  #: gcc.c:9196
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "environment variable %qs not defined"
-msgstr "переменная окружения \"%s\" не определена"
+msgstr "переменная окружения %qs не определена"
  
  #: gcc.c:9335 gcc.c:9340
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid version number %qs"
-msgstr "некорректный номер версии '%s'"
+msgstr "некорректный номер версии %qs"
  
  #: gcc.c:9383
  #, gcc-internal-format, gfc-internal-format
@@ -20446,37 +21525,38 @@ msgid "too many arguments to %%:version-compare"
  msgstr "слишком много аргументов в %%:version-compare"
  
  #: gcc.c:9431
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unknown operator %qs in %%:version-compare"
-msgstr "Неизвестный оператор '%s' в %%:version-compare"
+msgstr "Неизвестный оператор %qs в %%:version-compare"
  
  #: gcc.c:9555
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "too many arguments to %%:compare-debug-dump-opt"
-msgstr "слишком много аргументов в %%:version-compare"
+msgstr "слишком много аргументов в %%:compare-debug-dump-opt"
  
  #: gcc.c:9628
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "too many arguments to %%:compare-debug-self-opt"
-msgstr "слишком много аргументов в %%:version-compare"
+msgstr "слишком много аргументов в %%:compare-debug-self-opt"
  
  #: gcc.c:9664
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "too few arguments to %%:compare-debug-auxbase-opt"
-msgstr "слишком мало аргументов в %%:version-compare"
+msgstr "слишком мало аргументов в %%:compare-debug-auxbase-opt"
  
  #: gcc.c:9668
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "too many arguments to %%:compare-debug-auxbase-opt"
-msgstr "слишком много аргументов в %%:version-compare"
+msgstr "слишком много аргументов в %%:compare-debug-auxbase-opt"
  
  #: gcc.c:9675
  #, gcc-internal-format, gfc-internal-format
  msgid "argument to %%:compare-debug-auxbase-opt does not end in .gk"
-msgstr ""
+msgstr "аргумент %%:compare-debug-auxbase-opt заканчивается не .gk"
  
  #: gcc.c:9749
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "too few arguments to function"
  msgid "too few arguments to %%:replace-extension"
  msgstr "слишком мало аргументов функции"
  
@@ -20486,10 +21566,12 @@ msgstr "слишком мало аргументов функции"
  msgid "error in removing %s\n"
  msgstr "ошибка записи %qs"
  
+#
  #: gcov-tool.c:103
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "can't create directory %s: %m"
  msgid "Cannot make directory %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¿Ð¾Ð¿Ñ\8bÑ\82ÐºÐ° Ð²Ð·Ñ\8fÑ\82Ñ\8c Ð°Ð´Ñ\80ÐµÑ\81 Ð±Ð¸Ñ\82Ð¾Ð²Ð¾Ð³Ð¾ Ð¿Ð¾Ð»Ñ\8f %qD"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ñ\8f ÐºÐ°Ñ\82Ð°Ð»Ð¾Ð³Ð° %s: %m"
  
  #: gcov-tool.c:111
  #, fuzzy, gcc-internal-format
@@ -20497,21 +21579,24 @@ msgstr "некорректная попытка взять адрес битов
  msgid "Cannot get current directory name"
  msgstr "%s: ошибка доступа к рабочему каталогу: %s\n"
  
+#
  #: gcov-tool.c:115 gcov-tool.c:121
  #, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "%s: cannot get working directory: %s\n"
+#| msgid "can't create directory %s: %m"
  msgid "Cannot change directory to %s"
-msgstr "%s: ошибка доступа к рабочему каталогу: %s\n"
+msgstr "ошибка создания каталога %s: %m"
  
  #: gcov-tool.c:214
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L must be nonnegative"
  msgid "weights need to be non-negative\n"
-msgstr "%qD не является элементом типа %qT"
+msgstr "'%s' в %L должен быть неотрицательным"
  
  #: gcov-tool.c:355
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L must be nonnegative"
  msgid "scale needs to be non-negative\n"
-msgstr "%qD не является элементом типа %qT"
+msgstr "'%s' в %L должен быть неотрицательным"
  
  #: gcse.c:3986
  #, gcc-internal-format, gfc-internal-format
@@ -20536,8 +21621,9 @@ msgstr ""
  
  #: gentarget-def.c:126
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "invalid abstract type for %q+D"
  msgid "invalid prototype for '%s'"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° '%c'"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ð±Ñ\81Ñ\82Ñ\80Ð°ÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f %q+D"
  
  #: gentarget-def.c:131
  #, gcc-internal-format, gfc-internal-format
@@ -20546,8 +21632,9 @@ msgstr ""
  
  #: gentarget-def.c:148
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Actual argument to '%s' at %L must have the same declared type"
  msgid "argument %d of '%s' did not have the expected name"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ñ\82Ð¾Ñ\82 Ð¶Ðµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
  
  #: gentarget-def.c:168
  #, gcc-internal-format, gfc-internal-format
@@ -20566,28 +21653,29 @@ msgstr ""
  
  #: gentarget-def.c:276
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "deleted definition of %qD"
  msgid "duplicate definition of '%s'"
-msgstr "переопределение %q+D"
+msgstr "удаленное определение %qD"
  
  #: ggc-common.c:393 ggc-common.c:401 ggc-common.c:470 ggc-common.c:488
  #: ggc-page.c:2457 ggc-page.c:2488 ggc-page.c:2495
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t write PCH file: %m"
  msgstr "ошибка записи в файл PCH: %m"
  
  #: ggc-common.c:481 config/i386/host-cygwin.c:55
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t get position in PCH file: %m"
  msgstr "ошибка позиционирования в PCH файле: %m"
  
  #: ggc-common.c:491
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t write padding to PCH file: %m"
  msgstr "ошибка записи заполнителя в PCH файл: %m"
  
  #: ggc-common.c:613 ggc-common.c:621 ggc-common.c:624 ggc-common.c:634
  #: ggc-common.c:637 ggc-page.c:2589
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t read PCH file: %m"
  msgstr "ошибка чтения PCH файла: %m"
  
@@ -20602,7 +21690,7 @@ msgid "open /dev/zero: %m"
  msgstr "open /dev/zero: %m"
  
  #: ggc-page.c:2473 ggc-page.c:2479
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t write PCH file"
  msgstr "ошибка записи PCH файла"
  
@@ -20611,19 +21699,21 @@ msgstr "ошибка записи PCH файла"
  #: c/c-typeck.c:9690 cp/call.c:6152 cp/constexpr.c:757 cp/constexpr.c:1944
  #: cp/decl2.c:5114 cp/pt.c:7578 cp/semantics.c:1763 cp/typeck.c:1640
  #: cp/typeck.c:1833 cp/typeck.c:3660
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declared here"
-msgstr "%q+D объявлено здесь"
+msgstr "объявлено здесь"
  
  #: gimple-ssa-isolate-paths.c:332
  #, fuzzy, gcc-internal-format
+#| msgid "target is not pointer or reference"
  msgid "potential null pointer dereference"
-msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ñ\87Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
+msgstr "Ñ\86ÐµÐ»Ñ\8c Ð½Ðµ ÐµÑ\81Ñ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð¸Ð»Ð¸ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ°"
  
  #: gimple-ssa-isolate-paths.c:400
  #, fuzzy, gcc-internal-format
+#| msgid "null pointer"
  msgid "null pointer dereference"
-msgstr "нулевой указатель в вызове PRINT_OPERAND"
+msgstr "нулевой указатель"
  
  #: gimple-ssa-nonnull-compare.c:102
  #, gcc-internal-format
@@ -20633,17 +21723,17 @@ msgstr ""
  #: gimple-streamer-in.c:210
  #, gcc-internal-format, gfc-internal-format
  msgid "bytecode stream: unknown GIMPLE statement tag %s"
-msgstr ""
+msgstr "байткод: неизвестный тег оператора GIMPLE %s"
  
  #: gimple.c:1166
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "gimple check: expected %s(%s), have %s(%s) in %s, at %s:%d"
-msgstr "Ð´ÐµÑ\80ÐµÐ²Ð¾: Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f ÐºÐ»Ð°Ñ\81Ñ\81 %qs, Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶ÐµÐ½ %qs (%s) Ð² %s, Ð½Ð° %s:%d"
+msgstr "Ð¿Ñ\80Ð¾Ð²ÐµÑ\80ÐºÐ° gimple: Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f %s(%s), Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶ÐµÐ½ %s(%s) Ð² %s, Ð² %s:%d"
  
  #: gimplify.c:2566
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "using result of function returning %<void%>"
-msgstr "Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸, ÐºÐ¾Ñ\82Ð¾Ñ\80Ð°Ñ\8f Ð´Ð¾Ð»Ð¶Ð½Ð° Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°Ñ\82Ñ\8c Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ, Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 return"
+msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\80ÐµÐ·Ñ\83Ð»Ñ\8cÑ\82Ð°Ñ\82 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸, Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°Ñ\8eÑ\89ÐµÐ¹ %<void%>"
  
  #: gimplify.c:5194
  #, gcc-internal-format, gfc-internal-format
@@ -20653,7 +21743,7 @@ msgstr "неверное lvalue-выражение в выходном опер
  #: gimplify.c:5336
  #, gcc-internal-format, gfc-internal-format
  msgid "non-memory input %d must stay in memory"
-msgstr ""
+msgstr "входное значение %d должно быть в памяти"
  
  #: gimplify.c:5376 gimplify.c:5385
  #, gcc-internal-format, gfc-internal-format
@@ -20662,39 +21752,43 @@ msgstr "невозможна прямая адресация к входной 
  
  #: gimplify.c:5917
  #, fuzzy, gcc-internal-format
+#| msgid "threadprivate variable %qE used in untied task"
  msgid "threadprivate variable %qE used in target region"
-msgstr "Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qD Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð° Ð²Ð¾ Ð²Ð»Ð¾Ð¶ÐµÐ½Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ñ\87Ð°Ñ\81Ñ\82Ð½Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ð¿Ð¾Ñ\82Ð¾ÐºÐ° %qE Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð° Ð² Ð±ÐµÐ·Ñ\8bÐ¼Ñ\8fÐ½Ð½Ð¾Ð¹ Ð·Ð°Ð´Ð°Ñ\87Ðµ"
  
  #: gimplify.c:5919
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "enclosing task"
  msgid "enclosing target region"
-msgstr ""
+msgstr "объемлющая задача"
  
  #: gimplify.c:5931
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "threadprivate variable %qE used in untied task"
-msgstr "Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qD Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð° Ð²Ð¾ Ð²Ð»Ð¾Ð¶ÐµÐ½Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ñ\87Ð°Ñ\81Ñ\82Ð½Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ð¿Ð¾Ñ\82Ð¾ÐºÐ° %qE Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð° Ð² Ð±ÐµÐ·Ñ\8bÐ¼Ñ\8fÐ½Ð½Ð¾Ð¹ Ð·Ð°Ð´Ð°Ñ\87Ðµ"
  
  #: gimplify.c:5933
  #, gcc-internal-format
  msgid "enclosing task"
-msgstr ""
+msgstr "объемлющая задача"
  
  #: gimplify.c:5995
  #, fuzzy, gcc-internal-format
+#| msgid "%qE not specified in enclosing parallel"
  msgid "%qE not specified in enclosing %s"
-msgstr "отсутствует декларация %qD в %qD"
+msgstr "%qE не задано в объемлющей конструкции parallel"
  
  #: gimplify.c:5997
  #, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "error closing %s: %m"
+#| msgid "enclosing task"
  msgid "enclosing %s"
-msgstr "ошибка закрытия %s: %m"
+msgstr "объемлющая задача"
  
  #: gimplify.c:6107
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%qE not specified in enclosing parallel"
  msgid "%qE not specified in enclosing OpenACC %qs construct"
-msgstr ""
+msgstr "%qE не задано в объемлющей конструкции parallel"
  
  #: gimplify.c:6109
  #, gcc-internal-format
@@ -20708,8 +21802,9 @@ msgstr ""
  
  #: gimplify.c:6168
  #, fuzzy, gcc-internal-format
+#| msgid "%qE undeclared (first use in this function)"
  msgid "%qE requires a %<declare%> directive for use in a %<routine%> function"
-msgstr "%H%qE не описан (первое использование в этой функции)"
+msgstr "%qE не описан (первое использование в этой функции)"
  
  #: gimplify.c:6244 gimplify.c:6848
  #, fuzzy, gcc-internal-format
@@ -20722,40 +21817,45 @@ msgstr "переменная %q+D декларирована со специфи
  msgid "%qD referenced in target region does not have a mappable type"
  msgstr ""
  
+#
  #: gimplify.c:6380 gimplify.c:6412
  #, fuzzy, gcc-internal-format
+#| msgid "%Hiteration variable %qE is unsigned"
  msgid "iteration variable %qE is predetermined linear"
-msgstr "instance-переменная %qs имеет неизвестный размер"
+msgstr "%Hитерационная переменная %qE есть unsigned"
  
  #: gimplify.c:6383
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "iteration variable %qE should be private"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "итерационная переменная %qE должна быть private"
  
  #: gimplify.c:6397
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "iteration variable %qE should not be firstprivate"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "итерационная переменная %qE не должна быть firstprivate"
  
  #: gimplify.c:6400
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "iteration variable %qE should not be reduction"
-msgstr "регистровая переменная %qs использована во вложенной функции"
+msgstr "итерационная переменная %qE не должна быть редукцией"
  
  #: gimplify.c:6403
  #, fuzzy, gcc-internal-format
+#| msgid "iteration variable %qE should not be reduction"
  msgid "iteration variable %qE should not be linear"
-msgstr "регистровая переменная %qs использована во вложенной функции"
+msgstr "итерационная переменная %qE не должна быть редукцией"
  
  #: gimplify.c:6406
  #, fuzzy, gcc-internal-format
+#| msgid "iteration variable %qE should not be firstprivate"
  msgid "iteration variable %qE should not be lastprivate"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "итерационная переменная %qE не должна быть firstprivate"
  
  #: gimplify.c:6409
  #, fuzzy, gcc-internal-format
+#| msgid "iteration variable %qE should be private"
  msgid "iteration variable %qE should not be private"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "итерационная переменная %qE должна быть private"
  
  #: gimplify.c:6722
  #, gcc-internal-format
@@ -20768,19 +21868,21 @@ msgid "mapping field %qE of variable length structure"
  msgstr ""
  
  #: gimplify.c:7093
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%qE appears more than once in data clauses"
  msgid "%qE appears more than once in map clauses"
-msgstr ""
+msgstr "%qE встречается более одного раза в конструкции данных"
  
  #: gimplify.c:7385
  #, fuzzy, gcc-internal-format
+#| msgid "%s variable %qE is private in outer context"
  msgid "copyprivate variable %qE is not threadprivate or private in outer context"
-msgstr "локальная переменная %qD недопустима в данном контексте"
+msgstr "%s переменная %qE является частной для внешнего контекста"
  
  #: gimplify.c:7405
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s variable %qE is private in outer context"
-msgstr "локальная переменная %qD недопустима в данном контексте"
+msgstr "%s переменная %qE является частной для внешнего контекста"
  
  #: gimplify.c:7431
  #, gcc-internal-format
@@ -20804,9 +21906,10 @@ msgid "invalid private reduction on %qE"
  msgstr "некорректная template-декларация %qD"
  
  #: gimplify.c:9948 omp-low.c:3622
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "ordered region must be closely nested inside a loop region with an ordered clause"
  msgid "%<ordered%> construct with %<depend%> clause must be closely nested inside a loop with %<ordered%> clause with a parameter"
-msgstr ""
+msgstr "ordered область должна быть тесно вложена внутри области цикла с ordered клаузулой"
  
  #: gimplify.c:9966
  #, gcc-internal-format
@@ -20815,8 +21918,9 @@ msgstr ""
  
  #: gimplify.c:9979
  #, fuzzy, gcc-internal-format
+#| msgid "number of results does not match number of values"
  msgid "number of variables in %<depend(sink)%> clause does not match number of iteration variables"
-msgstr "число входящих дуг не соответствует числу аргументов PHI"
+msgstr "число результатов не соответствует числу значений"
  
  #: gimplify.c:9992
  #, gcc-internal-format
@@ -20830,13 +21934,14 @@ msgstr ""
  
  #: gimplify.c:10931
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<}%> before %<else%>"
  msgid "expected %<_Cilk_spawn%> before %<_Cilk_sync%>"
-msgstr "ожидалось %<,%> или %<;%>"
+msgstr "ожидалось %<}%> перед %<else%>"
  
  #: gimplify.c:11227
  #, gcc-internal-format
  msgid "gimplification failed"
-msgstr ""
+msgstr "преобразование в gimple завершилось неуспешно"
  
  #: gimplify.c:11697 c-family/c-common.c:5731 c-family/c-common.c:5804
  #, gcc-internal-format
@@ -20859,14 +21964,14 @@ msgid "if this code is reached, the program will abort"
  msgstr "при достижении этого кода выполнение программы завершится аварийно"
  
  #: godump.c:1432
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "could not close Go dump file: %m"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82Ð¸Ñ\8f Ð´Ð°Ð¼Ð¿-Ñ\84Ð°Ð¹Ð»Ð° %qs: %s"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð·Ð°ÐºÑ\80Ñ\8bÑ\82Ð¸Ñ\8f Ð´Ð°Ð¼Ð¿-Ñ\84Ð°Ð¹Ð»Ð° GO: %m"
  
  #: godump.c:1444
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "could not open Go dump file %qs: %m"
-msgstr "ошибка открытия дамп-файла %qs: %s"
+msgstr "ошибка открытия дамп-файла Go %qs: %m"
  
  #: graph.c:55 toplev.c:1491 java/jcf-parse.c:1751 java/jcf-parse.c:1890
  #: objc/objc-act.c:461
@@ -20876,8 +21981,9 @@ msgstr "ошибка открытия %s: %m"
  
  #: graphite.c:344
  #, fuzzy, gcc-internal-format
+#| msgid "Graphite loop optimizations cannot be used"
  msgid "Graphite loop optimizations cannot be used (isl is not available)."
-msgstr "Включить оптимизации циклов на древовидном представлении"
+msgstr "Graphite оптимизации циклов не могут быть использованы"
  
  #: hsa-brig.c:899
  #, gcc-internal-format
@@ -20939,8 +22045,9 @@ msgstr ""
  
  #: ipa-chkp.c:661
  #, fuzzy, gcc-internal-format
+#| msgid "%qs function cannot have arguments"
  msgid "function cannot be instrumented"
-msgstr "%qD не может иметь аргументов по умолчанию"
+msgstr "%qs функция не может иметь аргументы"
  
  #: ipa-devirt.c:751 ipa-devirt.c:902
  #, gcc-internal-format
@@ -21000,8 +22107,9 @@ msgstr ""
  
  #: ipa-devirt.c:946
  #, fuzzy, gcc-internal-format
+#| msgid "virtual function %q+D"
  msgid "virtual method %qD"
-msgstr "виртуальная функция %qs не является элементом класса"
+msgstr "виртуальная функция %q+D"
  
  #: ipa-devirt.c:950
  #, gcc-internal-format
@@ -21021,8 +22129,9 @@ msgstr ""
  #: ipa-devirt.c:997 ipa-devirt.c:1012 ipa-devirt.c:1262 ipa-devirt.c:1354
  #: ipa-devirt.c:1393 ipa-devirt.c:1411
  #, fuzzy, gcc-internal-format
+#| msgid "%q+D declared here, later in the translation unit"
  msgid "a different type is defined in another translation unit"
-msgstr "%H%qE не описан в этой области (не в функции)"
+msgstr "%q+D декларировано здесь, позднее в единице компиляции"
  
  #: ipa-devirt.c:1004
  #, gcc-internal-format
@@ -21046,8 +22155,9 @@ msgstr ""
  
  #: ipa-devirt.c:1118
  #, fuzzy, gcc-internal-format
+#| msgid "incompatible types in binary expression"
  msgid "the incompatible type defined in another translation unit"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð°"
+msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
  
  #: ipa-devirt.c:1141
  #, gcc-internal-format
@@ -21056,8 +22166,9 @@ msgstr ""
  
  #: ipa-devirt.c:1145 ipa-devirt.c:1237
  #, fuzzy, gcc-internal-format
+#| msgid "incompatible types in send"
  msgid "the incompatible type is defined here"
-msgstr "несовместимые типы в операторе возврата"
+msgstr "несовместимые типы в send"
  
  #: ipa-devirt.c:1173
  #, fuzzy, gcc-internal-format
@@ -21065,25 +22176,31 @@ msgstr "несовместимые типы в операторе возврат
  msgid "array types have different bounds"
  msgstr "Ссылка на массив выходит за границы"
  
+#
  #: ipa-devirt.c:1188
  #, fuzzy, gcc-internal-format
+#| msgid "field initializer type mismatch"
  msgid "return value type mismatch"
-msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80 Ð¿Ð¾Ð»Ñ\8f Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
+msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð° Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ð° Ð¿Ð¾Ð»Ñ\8f"
  
+#
  #: ipa-devirt.c:1203
  #, fuzzy, gcc-internal-format
+#| msgid "field initializer type mismatch"
  msgid "implicit this pointer type mismatch"
-msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80 Ð¿Ð¾Ð»Ñ\8f Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
+msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð° Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ð° Ð¿Ð¾Ð»Ñ\8f"
  
  #: ipa-devirt.c:1206
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "type mismatch in nontype parameter pack"
  msgid "type mismatch in parameter %i"
-msgstr "несоответствие типов в условном выражении"
+msgstr "несоответствие типов в нетиповом parameter pack"
  
  #: ipa-devirt.c:1217
  #, fuzzy, gcc-internal-format
+#| msgid "different parameter types"
  msgid "types have different parameter counts"
-msgstr "некорректный тип параметра %qT"
+msgstr "разные типы параметров"
  
  #: ipa-devirt.c:1228
  #, gcc-internal-format
@@ -21148,13 +22265,15 @@ msgstr ""
  
  #: ipa-devirt.c:1453
  #, fuzzy, gcc-internal-format
+#| msgid "%q+D declared here, later in the translation unit"
  msgid "has different return value in another translation unit"
-msgstr "%H%qE не описан в этой области (не в функции)"
+msgstr "%q+D декларировано здесь, позднее в единице компиляции"
  
  #: ipa-devirt.c:1476 ipa-devirt.c:1488
  #, fuzzy, gcc-internal-format
+#| msgid "%q+D declared here, later in the translation unit"
  msgid "has different parameters in another translation unit"
-msgstr "%H%qE не описан в этой области (не в функции)"
+msgstr "%q+D декларировано здесь, позднее в единице компиляции"
  
  #: ipa-devirt.c:1511
  #, gcc-internal-format
@@ -21178,8 +22297,9 @@ msgstr ""
  
  #: ipa-devirt.c:1548
  #, fuzzy, gcc-internal-format
+#| msgid "%q+D declared here, later in the translation unit"
  msgid "a field with different name is defined in another translation unit"
-msgstr "%H%qE не описан в этой области (не в функции)"
+msgstr "%q+D декларировано здесь, позднее в единице компиляции"
  
  #: ipa-devirt.c:1562
  #, gcc-internal-format
@@ -21188,8 +22308,9 @@ msgstr ""
  
  #: ipa-devirt.c:1575
  #, fuzzy, gcc-internal-format
+#| msgid "%q+D declared here, later in the translation unit"
  msgid "fields has different layout in another translation unit"
-msgstr "%H%qE не описан в этой области (не в функции)"
+msgstr "%q+D декларировано здесь, позднее в единице компиляции"
  
  #: ipa-devirt.c:1598
  #, gcc-internal-format
@@ -21208,8 +22329,9 @@ msgstr ""
  
  #: ipa-devirt.c:1637
  #, fuzzy, gcc-internal-format
+#| msgid "%q+D declared here, later in the translation unit"
  msgid "virtual table layout differs in another translation unit"
-msgstr "%H%qE не описан в этой области (не в функции)"
+msgstr "%q+D декларировано здесь, позднее в единице компиляции"
  
  #: ipa-devirt.c:1646
  #, gcc-internal-format
@@ -21233,8 +22355,9 @@ msgstr ""
  
  #: ipa-devirt.c:1807
  #, fuzzy, gcc-internal-format
+#| msgid "label %qD defined here"
  msgid "the extra base is defined here"
-msgstr "метка %q+D определена, но не используется"
+msgstr "метка %qD определена здесь"
  
  #: ipa-devirt.c:3777
  #, gcc-internal-format
@@ -21286,18 +22409,19 @@ msgstr[2] ""
  
  #: ipa-hsa.c:57
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%qE is neither function nor member function; cannot be declared friend"
  msgid "could not emit HSAIL for function %s: function cannot be cloned"
-msgstr "%qs не является ни функцией, ни элементом-функцией; friend-декларация не допускается"
+msgstr "%qE не является ни функцией, ни элементом-функцией; не может быть декларировано как friend"
  
  #: ipa-inline-analysis.c:4305
  #, gcc-internal-format
  msgid "ipa inline summary is missing in input file"
-msgstr ""
+msgstr "во входном файле отсутствует информация о межпроцедурных inline-подстановках"
  
  #: ipa-reference.c:1182
  #, gcc-internal-format
  msgid "ipa reference summary is missing in ltrans unit"
-msgstr ""
+msgstr "сводка ссылок межпроцедурного анализа отсутствует в модуле ltrans"
  
  #: ira.c:2309 ira.c:2323 ira.c:2337
  #, gcc-internal-format, gfc-internal-format
@@ -21321,9 +22445,9 @@ msgid "frame size too large for reliable stack checking"
  msgstr "кадр слишком велик для надежного контроля стека"
  
  #: lra-assigns.c:1395 reload1.c:1254
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<asm%> operand has impossible constraints"
-msgstr "для операнда %<asm%> требуется неосуществимая перезагрузка данных"
+msgstr "для операнда %<asm%> заданы недопустимые ограничения"
  
  #: lra-assigns.c:1416
  #, fuzzy, gcc-internal-format
@@ -21332,9 +22456,9 @@ msgid "unable to find a register to spill"
  msgstr "не найден регистр класса %qs для выталкивания в память"
  
  #: lra-assigns.c:1630
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Maximum number of LRA assignment passes is achieved (%d)\n"
-msgstr "Число отложенных команд, подлежащих предварительному планированию"
+msgstr ""
  
  #: lra-constraints.c:3566 reload.c:3831 reload.c:4086
  #, gcc-internal-format
@@ -21347,44 +22471,45 @@ msgid "Max. number of generated reload insns per insn is achieved (%d)\n"
  msgstr ""
  
  #: lto-cgraph.c:1289
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "bytecode stream: found multiple instances of cgraph node %d"
  msgid "bytecode stream: found multiple instances of cgraph node with uid %d"
-msgstr ""
+msgstr "поток байткода: найдено несколько копий cgraph узла %d"
  
  #: lto-cgraph.c:1467
  #, gcc-internal-format
  msgid "bytecode stream: no caller found while reading edge"
-msgstr ""
+msgstr "поток байткода: не найден вызывающий при чтении дуги"
  
  #: lto-cgraph.c:1473
  #, gcc-internal-format
  msgid "bytecode stream: no callee found while reading edge"
-msgstr ""
+msgstr "поток байткода: не найден вызываемый при чтении дуги"
  
  #: lto-cgraph.c:1548
  #, gcc-internal-format
  msgid "bytecode stream: found empty cgraph node"
-msgstr ""
+msgstr "поток байткода: найден пустой cgraph узел"
  
  #: lto-cgraph.c:1726
  #, gcc-internal-format, gfc-internal-format
  msgid "At most %i profile runs is supported. Perhaps corrupted profile?"
-msgstr ""
+msgstr "Не более %i профильных запусков поддерживается. Возможно поврежден профиль?"
  
  #: lto-cgraph.c:1813
  #, gcc-internal-format, gfc-internal-format
  msgid "Profile information in %s corrupted"
-msgstr ""
+msgstr "Данные профилирование в %s испорчены"
  
  #: lto-cgraph.c:1846
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "cannot find LTO cgraph in %s"
-msgstr "нет класса %qs"
+msgstr "не найден граф вызовов LTO в %s"
  
  #: lto-cgraph.c:1856
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "cannot find LTO section refs in %s"
-msgstr "нет декларации протокола для %qs"
+msgstr "невозможно найти ссылки на LTO секцию в %s"
  
  #: lto-cgraph.c:1935
  #, fuzzy, gcc-internal-format, gfc-internal-format
@@ -21396,27 +22521,28 @@ msgstr "некорректная инструкция rotate"
  #: lto-compress.c:293 lto-compress.c:314
  #, gcc-internal-format, gfc-internal-format
  msgid "compressed stream: %s"
-msgstr ""
+msgstr "сжатый поток: %s"
  
  #: lto-section-in.c:444
  #, gcc-internal-format, gfc-internal-format
  msgid "bytecode stream: trying to read %d bytes after the end of the input buffer"
-msgstr ""
+msgstr "поток байткода: попытка чтения %d байт после конца буфера ввода"
  
  #: lto-section-in.c:455
  #, gcc-internal-format, gfc-internal-format
  msgid "%s out of range: Range is %i to %i, value is %i"
-msgstr ""
+msgstr "%s вне диапазона: диапазон от %i до %i, значение %i"
  
  #: lto-streamer-in.c:79
  #, gcc-internal-format, gfc-internal-format
  msgid "bytecode stream: unexpected tag %s"
-msgstr ""
+msgstr "поток байткода: неожиданный тег %s"
  
  #: lto-streamer-in.c:909 lto-streamer-in.c:919
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "machine independent builtin code out of range"
  msgid "Cgraph edge statement index out of range"
-msgstr ""
+msgstr "машинно независимый встроенный код вне диапазона"
  
  #: lto-streamer-in.c:913 lto-streamer-in.c:922
  #, gcc-internal-format
@@ -21425,19 +22551,21 @@ msgstr ""
  
  #: lto-streamer-in.c:929
  #, fuzzy, gcc-internal-format
+#| msgid "operand number out of range"
  msgid "Reference statement index out of range"
-msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qs вне диапазона"
+msgstr "Ð½Ð¾Ð¼ÐµÑ\80 Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð° вне диапазона"
  
  #: lto-streamer-in.c:932
  #, fuzzy, gcc-internal-format
-#| msgid "Warn if deprecated empty statements are found"
+#| msgid "expected statement at end of input"
  msgid "Reference statement index not found"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¸ Ñ\83Ð¿Ð¾Ñ\82Ñ\80ÐµÐ±Ð»ÐµÐ½Ð¸Ð¸ Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð¸Ñ\85 Ð¿Ñ\83Ñ\81Ñ\82Ñ\8bÑ\85 Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¹"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² ÐºÐ¾Ð½Ñ\86Ðµ Ð²Ñ\85Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ð¿Ð¾Ñ\82Ð¾ÐºÐ°"
  
  #: lto-streamer-in.c:1513
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "cannot read LTO decls from %s"
  msgid "cannot read LTO mode table from %s"
-msgstr "Ð½ÐµÑ\82 ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qs"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f LTO Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¹ Ð¸Ð· %s"
  
  #: lto-streamer-in.c:1611
  #, fuzzy, gcc-internal-format, gfc-internal-format
@@ -21446,19 +22574,19 @@ msgid "unsupported mode %s\n"
  msgstr "поддержка моды %qs"
  
  #: lto-streamer-out.c:419 lto-streamer-out.c:674
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "tree code %qs is not supported in LTO streams"
-msgstr "ÐºÐ»Ñ\8eÑ\87 -mcmodel= Ð½Ð° 32-Ð±Ð¸Ñ\82Ð½Ñ\8bÑ\85 Ñ\81Ð¸Ñ\81Ñ\82ÐµÐ¼Ð°Ñ\85 Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð´Ñ\80ÐµÐ²Ð¾Ð²Ð¸Ð´Ð½Ñ\8bÐ¹ ÐºÐ¾Ð´ %qs Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f Ð² LTO Ð¿Ð¾Ñ\82Ð¾ÐºÐ°Ñ\85"
  
  #: lto-streamer.c:162
  #, gcc-internal-format, gfc-internal-format
  msgid "bytecode stream: unexpected LTO section %s"
-msgstr ""
+msgstr "байткод: некорректная секция %s"
  
  #: lto-streamer.c:383
  #, gcc-internal-format, gfc-internal-format
  msgid "bytecode stream generated with LTO version %d.%d instead of the expected %d.%d"
-msgstr ""
+msgstr "байткод сгенерирован LTO версии %d.%d вместо ожидаемой %d.%d"
  
  #: lto-wrapper.c:114
  #, fuzzy, gcc-internal-format
@@ -21495,8 +22623,9 @@ msgstr "не заданы входные файлы"
  
  #: lto-wrapper.c:840
  #, fuzzy, gcc-internal-format
+#| msgid "Error writing output file '%s'\n"
  msgid "writing output file"
-msgstr "%s:ошибка записи в выходной файл '%s'\n"
+msgstr "Ошибка записи в выходной файл '%s'\n"
  
  #: lto-wrapper.c:870
  #, gcc-internal-format
@@ -21527,38 +22656,45 @@ msgstr "ошибка чтения %s: %m"
  
  #: lto-wrapper.c:1165
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "invalid operation (%s)"
  msgid "invalid format of %s"
-msgstr "некорректный операнд для %%R"
+msgstr "некорректная операция (%s)"
  
  #: lto-wrapper.c:1301
  #, fuzzy, gcc-internal-format
+#| msgid "fopen %s: %m"
  msgid "fopen: %s: %m"
-msgstr "fopen %s"
+msgstr "fopen %s: %m"
  
  #: multiple_target.c:67
  #, fuzzy, gcc-internal-format
+#| msgid "nested functions not supported on this target"
  msgid "the call requires ifunc, which is not supported by this target"
-msgstr "Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ñ\8bÐµ Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b не поддерживаются для этой платформы"
+msgstr "Ð²Ð»Ð¾Ð¶ÐµÐ½Ð½Ñ\8bÐµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ не поддерживаются для этой платформы"
  
  #: multiple_target.c:76
  #, fuzzy, gcc-internal-format
+#| msgid "version attribute is not a string"
  msgid "default target_clones attribute was not set"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾Ð²Ð¾Ð¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ð²ÐµÑ\80Ñ\81Ð¸Ð¸ Ð½Ðµ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
  
  #: multiple_target.c:256
  #, fuzzy, gcc-internal-format
+#| msgid "%qE incompatible attribute ignored"
  msgid "single target_clones attribute is ignored"
-msgstr "%qs - несовместимый атрибут, игнорируется"
+msgstr "несовместимый атрибут %qE игнорируется"
  
  #: multiple_target.c:268
  #, fuzzy, gcc-internal-format
+#| msgid "default argument %qE uses %qD"
  msgid "default target was not set"
-msgstr "аргумент по умолчанию %qE использует локальную переменную %qD"
+msgstr "аргумент по умолчанию %qE использует %qD"
  
  #: multiple_target.c:300
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "attribute(target(\"%s\")) is unknown"
  msgid "attribute(target_clones(\"%s\")) is not valid for current target"
-msgstr ""
+msgstr "attribute(target(\"%s\")) неизвестен"
  
  #: multiple_target.c:331
  #, gcc-internal-format
@@ -21602,9 +22738,10 @@ msgid "non-OpenACC construct inside of OpenACC region"
  msgstr ""
  
  #: omp-low.c:3285
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "ordered region may not be closely nested inside of critical or explicit task region"
  msgid "%<ordered simd threads%> must be closely nested inside of %<for simd%> region"
-msgstr ""
+msgstr "ordered область не может быть тесно вложена внутри critical, или explicit task области"
  
  #: omp-low.c:3293
  #, gcc-internal-format
@@ -21642,9 +22779,10 @@ msgid "%<#pragma omp cancel for%> inside %<ordered%> for construct"
  msgstr ""
  
  #: omp-low.c:3439 omp-low.c:3452
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
  msgid "%<#pragma omp cancel sections%> inside %<nowait%> sections construct"
-msgstr ""
+msgstr "%<#pragma omp section%> может использоваться только в конструкции %<#pragma omp sections%>"
  
  #: omp-low.c:3478
  #, gcc-internal-format
@@ -21653,8 +22791,9 @@ msgstr ""
  
  #: omp-low.c:3492
  #, fuzzy, gcc-internal-format
+#| msgid "invalid PHI argument"
  msgid "invalid arguments"
-msgstr "некорректный тип аргумента"
+msgstr "некорректный аргумент PHI"
  
  #: omp-low.c:3498
  #, gcc-internal-format
@@ -21662,19 +22801,22 @@ msgid "%<%s %s%> construct not closely nested inside of %qs"
  msgstr ""
  
  #: omp-low.c:3526
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "barrier region may not be closely nested inside of work-sharing, critical, ordered, master or explicit task region"
  msgid "barrier region may not be closely nested inside of work-sharing, %<critical%>, %<ordered%>, %<master%>, explicit %<task%> or %<taskloop%> region"
-msgstr ""
+msgstr "область барьера не может быть тесно вложена внутри work-sharing. critical, ordered, master или explicit task области"
  
  #: omp-low.c:3533
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "work-sharing region may not be closely nested inside of work-sharing, critical, ordered, master or explicit task region"
  msgid "work-sharing region may not be closely nested inside of work-sharing, %<critical%>, %<ordered%>, %<master%>, explicit %<task%> or %<taskloop%> region"
-msgstr ""
+msgstr "work-sharing область не может быть тесно вложена внутри work-sharing, critical, ordered, master или explicit task области"
  
  #: omp-low.c:3562
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "master region may not be closely nested inside of work-sharing or explicit task region"
  msgid "%<master%> region may not be closely nested inside of work-sharing, explicit %<task%> or %<taskloop%> region"
-msgstr ""
+msgstr "master область не может быть тесно вложена внутри work-sharing или explicit task области"
  
  #: omp-low.c:3586 omp-low.c:3725
  #, gcc-internal-format
@@ -21682,34 +22824,40 @@ msgid "%<depend(%s)%> is only allowed in %<omp ordered%>"
  msgstr ""
  
  #: omp-low.c:3614
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "ordered region must be closely nested inside a loop region with an ordered clause"
  msgid "%<ordered%> construct with %<depend%> clause must be closely nested inside an %<ordered%> loop"
-msgstr ""
+msgstr "ordered область должна быть тесно вложена внутри области цикла с ordered клаузулой"
  
  #: omp-low.c:3631
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "invalid schedule kind before %<decltype%>"
  msgid "invalid depend kind in omp %<ordered%> %<depend%>"
-msgstr ""
+msgstr "некорректный тип планирования перед %<decltype%>"
  
  #: omp-low.c:3646
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "ordered region must be closely nested inside a loop region with an ordered clause"
  msgid "%<ordered%> %<simd%> must be closely nested inside %<simd%> region"
-msgstr ""
+msgstr "ordered область должна быть тесно вложена внутри области цикла с ordered клаузулой"
  
  #: omp-low.c:3659
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "ordered region may not be closely nested inside of critical or explicit task region"
  msgid "%<ordered%> region may not be closely nested inside of %<critical%>, %<ordered%>, explicit %<task%> or %<taskloop%> region"
-msgstr ""
+msgstr "ordered область не может быть тесно вложена внутри critical, или explicit task области"
  
  #: omp-low.c:3670 omp-low.c:3683
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "ordered region must be closely nested inside a loop region with an ordered clause"
  msgid "%<ordered%> region must be closely nested inside a loop region with an %<ordered%> clause"
-msgstr ""
+msgstr "ordered область должна быть тесно вложена внутри области цикла с ordered клаузулой"
  
  #: omp-low.c:3700
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "critical region may not be nested inside a critical region with the same name"
  msgid "%<critical%> region may not be nested inside a %<critical%> region with the same name"
-msgstr ""
+msgstr "critical область не может быть вложена внутри critical области с тем же именем"
  
  #: omp-low.c:3712
  #, gcc-internal-format
@@ -21769,19 +22917,22 @@ msgstr ""
  
  #: omp-low.c:18011
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "invalid exit from OpenMP structured block"
  msgid "invalid exit from %s structured block"
-msgstr "  входит в try-блок"
+msgstr "некорректный выход из OpenMP структурного блока"
  
  #: omp-low.c:18013 omp-low.c:18018
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "invalid entry to OpenMP structured block"
  msgid "invalid entry to %s structured block"
-msgstr "  входит в try-блок"
+msgstr "некорректный вход в OpenMP структурный блок"
  
  #. Otherwise, be vague and lazy, but efficient.
  #: omp-low.c:18022
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "invalid branch to/from an OpenMP structured block"
  msgid "invalid branch to/from %s structured block"
-msgstr "  входит в try-блок"
+msgstr "некорректная ветка в/из структурного блока OpenMP"
  
  #: omp-low.c:18823
  #, gcc-internal-format, gfc-internal-format
@@ -21805,8 +22956,9 @@ msgstr ""
  
  #: omp-low.c:19421
  #, fuzzy, gcc-internal-format
+#| msgid "%qD declared here"
  msgid "routine %qD declared here"
-msgstr "%q+D объявлено здесь"
+msgstr "%qD объявлено здесь"
  
  #: omp-low.c:19434
  #, gcc-internal-format
@@ -21831,8 +22983,9 @@ msgstr ""
  
  #: optabs.c:4194
  #, fuzzy, gcc-internal-format
+#| msgid "BYTE type used at %C is not available on the target machine"
  msgid "indirect jumps are not available on this target"
-msgstr "%Jатрибут section для данной платформы не поддерживается"
+msgstr "BYTE тип использованный в %C не доступен на целевой машине"
  
  #: opts-common.c:1079
  #, gcc-internal-format
@@ -21840,55 +22993,56 @@ msgid "command line option %qs is not supported by this configuration"
  msgstr "ключ %qs для этой конфигурации не поддерживается"
  
  #: opts-common.c:1089
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "missing argument to %qs"
-msgstr "отсутствует аргумент для \"%s\""
+msgstr "отсутствует аргумент для %qs"
  
  #: opts-common.c:1095
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument to %qs should be a non-negative integer"
-msgstr "аргумент \"%s\" должен быть неотрицательным целым числом"
+msgstr "аргумент %qs должен быть неотрицательным целым числом"
  
  #: opts-common.c:1110
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unrecognized argument in option %qs"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 \"%s\""
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
  
  #: opts-common.c:1128
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "valid arguments to %qs are: %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs"
+msgstr "Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b %qs: %s"
  
  #: opts-global.c:99
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "command line option %qs is valid for the driver but not for %s"
-msgstr "ключ \"%s\" годится для %s, но не для %s"
+msgstr "ключ %qs годится для драйвера, но не для %s"
  
  #. Eventually this should become a hard error IMO.
  #: opts-global.c:105
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "command line option %qs is valid for %s but not for %s"
-msgstr "ключ \"%s\" годится для %s, но не для %s"
+msgstr "ключ %qs годится для %s, но не для %s"
  
  #: opts-global.c:364
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unrecognized command line option %<-fdump-%s%>"
-msgstr "некорректный ключ \"%s\""
+msgstr "некорректный ключ %<-fdump-%s%>"
  
  #: opts-global.c:369
  #, fuzzy, gcc-internal-format
+#| msgid "unrecognized command line option %<-fdump-%s%>"
  msgid "unrecognized command line option %<-fopt-info-%s%>"
-msgstr "некорректный ключ \"%s\""
+msgstr "некорректный ключ %<-fdump-%s%>"
  
  #: opts-global.c:390 opts-global.c:398
  #, gcc-internal-format
  msgid "plugin support is disabled; configure with --enable-plugin"
-msgstr ""
+msgstr "поддержка plugin-модулей отсутствует; используйте в вызове configure ключ --enable-plugin"
  
  #: opts-global.c:422
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unrecognized register name %qs"
-msgstr "некорректное имя регистра \"%s\""
+msgstr "некорректное имя регистра %qs"
  
  #: opts-global.c:440
  #, gcc-internal-format
@@ -21902,54 +23056,55 @@ msgid "unrecognized shadow offset %qs"
  msgstr "некорректный адрес"
  
  #: opts.c:89
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument %qs to %<-femit-struct-debug-detailed%> not recognized"
-msgstr "некорректный аргумент %qs ключа %<-Wnormalized%>"
+msgstr "некорректный аргумент %qs ключа %<-femit-struct-debug-detailed%>"
  
  #: opts.c:125
  #, gcc-internal-format
  msgid "argument %qs to %<-femit-struct-debug-detailed%> unknown"
-msgstr ""
+msgstr "неизвестный аргумент %qs ключа %<-femit-struct-debug-detailed%>"
  
  #: opts.c:132
  #, gcc-internal-format
  msgid "%<-femit-struct-debug-detailed=dir:...%> must allow at least as much as %<-femit-struct-debug-detailed=ind:...%>"
-msgstr ""
+msgstr "%<-femit-struct-debug-detailed=dir:...%> должно позволять не меньше чем %<-femit-struct-debug-detailed=ind:...%>"
  
  #: opts.c:580
  #, fuzzy, gcc-internal-format
+#| msgid "argument to %qs should be a non-negative integer"
  msgid "argument to %<-O%> should be a non-negative integer, %<g%>, %<s%> or %<fast%>"
-msgstr "аргумент \"%s\" должен быть неотрицательным целым числом"
+msgstr "аргумент %qs должен быть неотрицательным целым числом"
  
  #: opts.c:733
  #, gcc-internal-format
  msgid "section anchors must be disabled when unit-at-a-time is disabled"
-msgstr ""
+msgstr "опорные точки секций нельзя использовать при не включенном unit-at-a-time"
  
  #: opts.c:737
  #, gcc-internal-format
  msgid "toplevel reorder must be disabled when unit-at-a-time is disabled"
-msgstr ""
+msgstr "переупорядочение на верхнем уровне невозможно при не включенном unit-at-a-time"
  
  #: opts.c:743
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "transactional memory is not supported with non-call exceptions"
-msgstr "-m%s в данной конфигурации не поддерживается"
+msgstr "транзакционная память не поддерживается с non-call исключениями"
  
  #: opts.c:758
  #, gcc-internal-format
  msgid "section anchors must be disabled when toplevel reorder is disabled"
-msgstr ""
+msgstr "опорные точки секций нельзя использовать если не включено переупорядочение на верхнем уровне"
  
  #: opts.c:813 config/darwin.c:3113
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-freorder-blocks-and-partition does not work with exceptions on this architecture"
-msgstr "-freorder-blocks-and-partition не работает для заданной архитектуры"
+msgstr "-freorder-blocks-and-partition не работает с исключениями для заданной архитектуры"
  
  #: opts.c:829
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-freorder-blocks-and-partition does not support unwind info on this architecture"
-msgstr "-freorder-blocks-and-partition не работает для заданной архитектуры"
+msgstr "-freorder-blocks-and-partition не поддерживает данные раскрутки для заданной архитектуры"
  
  #: opts.c:847 config/pa/pa.c:526
  #, gcc-internal-format
@@ -21958,18 +23113,20 @@ msgstr "-freorder-blocks-and-partition не работает для заданн
  
  #: opts.c:898
  #, fuzzy, gcc-internal-format
+#| msgid "-fno-fat-lto-objects are supported only with linker plugin."
  msgid "-fno-fat-lto-objects are supported only with linker plugin"
-msgstr "проверка выхода за границу стека не поддерживается для этой платформы"
+msgstr "-fno-fat-lto-objects поддерживается только с linker plugin."
  
  #: opts.c:911
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<-fsplit-stack%> is not supported by this compiler configuration"
-msgstr "%s для этой конфигурации не поддерживается"
+msgstr "%<-fsplit-stack%> для этой конфигурации не поддерживается"
  
  #: opts.c:944
  #, fuzzy, gcc-internal-format
+#| msgid "-fdirectives-only is incompatible with -traditional"
  msgid "-fsanitize=address is incompatible with -fsanitize=kernel-address"
-msgstr "ключ -G несовместим с PIC-кодом, который генерируется по умолчанию"
+msgstr "-fdirectives-only несовместим с -traditional"
  
  #: opts.c:952
  #, gcc-internal-format
@@ -21978,18 +23135,20 @@ msgstr ""
  
  #: opts.c:958
  #, fuzzy, gcc-internal-format
+#| msgid "-falign-loops=%d is not supported"
  msgid "-fsanitize-recover=thread is not supported"
-msgstr "-malign-loops=%d вне диапазона 0 - %d"
+msgstr "-falign-loops=%d не поддерживается"
  
  #: opts.c:961
  #, fuzzy, gcc-internal-format
+#| msgid "-fpic is not supported"
  msgid "-fsanitize-recover=leak is not supported"
-msgstr "ключ -pipe не поддерживается"
+msgstr "ключ -fpic не поддерживается"
  
  #: opts.c:1375
  #, gcc-internal-format
  msgid "unrecognized include_flags 0x%x passed to print_specific_help"
-msgstr ""
+msgstr "неопознанный include_flags 0x%x передан print_specific_help"
  
  #: opts.c:1509
  #, gcc-internal-format
@@ -21998,23 +23157,25 @@ msgstr ""
  
  #: opts.c:1524
  #, fuzzy, gcc-internal-format
+#| msgid "unrecognized argument to --help= option: %q.*s"
  msgid "unrecognized argument to -fsanitize%s= option: %q.*s"
-msgstr "Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ðµ: Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° --help=: %.*s\n"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° --help=: %q.*s"
  
  #: opts.c:1695
  #, gcc-internal-format
  msgid "--help argument %q.*s is ambiguous, please be more specific"
-msgstr ""
+msgstr "аргумент --help %q.*s неоднозначен, требуется уточнение"
  
  #: opts.c:1704
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unrecognized argument to --help= option: %q.*s"
-msgstr "Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ðµ: Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° --help=: %.*s\n"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° --help=: %q.*s"
  
  #: opts.c:1936
  #, fuzzy, gcc-internal-format
+#| msgid "LTO support has not been enabled in this configuration"
  msgid "HSA has not been enabled during configuration"
-msgstr "-m%s в данной конфигурации не поддерживается"
+msgstr "Поддержка LTO в данной конфигурации отсутствует"
  
  #: opts.c:1948
  #, gcc-internal-format
@@ -22028,8 +23189,9 @@ msgstr "выравнивание структуры должно быть неб
  
  #: opts.c:2070
  #, fuzzy, gcc-internal-format
+#| msgid "unknown stack check parameter \"%s\""
  msgid "unknown stack check parameter %qs"
-msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %q+D Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 Ð¿Ñ\80Ð¾Ð²ÐµÑ\80ÐºÐ¸ Ñ\81Ñ\82ÐµÐºÐ° \"%s\""
  
  #: opts.c:2102
  #, gcc-internal-format
@@ -22037,9 +23199,9 @@ msgid "%<-gdwarf%s%> is ambiguous; use %<-gdwarf-%s%> for DWARF version or %<-gd
  msgstr ""
  
  #: opts.c:2113
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "dwarf version %d is not supported"
-msgstr "выражение для границы стека не поддерживается"
+msgstr "версия dwarf %d не поддерживается"
  
  #: opts.c:2213
  #, gcc-internal-format, gfc-internal-format
@@ -22098,7 +23260,7 @@ msgstr "некорректный ключ отладки: %c"
  #: opts.c:2467
  #, gcc-internal-format, gfc-internal-format
  msgid "-Werror=%s: no option -%s"
-msgstr ""
+msgstr "-Werror=%s: ключа -%s не существует"
  
  #: opts.c:2469
  #, gcc-internal-format, gfc-internal-format
@@ -22133,79 +23295,79 @@ msgid "pass %s needs a set_pass_param implementation to handle the extra argumen
  msgstr ""
  
  #: passes.c:1023
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unrecognized option -fenable"
-msgstr "неопознанный ключ '-%s'"
+msgstr "неопознанный ключ -fenable"
  
  #: passes.c:1025
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unrecognized option -fdisable"
-msgstr "неопознанный ключ '-%s'"
+msgstr "неопознанный ключ -fdisable"
  
  #: passes.c:1033
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "unknown pass %s specified in -fenable"
-msgstr "неизвестное поле %qE в инициализаторе"
+msgstr "неизвестный проход %s задан в -fenable"
  
  #: passes.c:1035
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "unknown pass %s specified in -fdisable"
-msgstr "неизвестное поле %qE в инициализаторе"
+msgstr "неизвестный проход %s задан в -fdisable"
  
  #: passes.c:1060 passes.c:1149
  #, gcc-internal-format, gfc-internal-format
  msgid "enable pass %s for functions in the range of [%u, %u]"
-msgstr ""
+msgstr "активировать проход %s для функций в диапазоне [%u, %u]"
  
  #: passes.c:1063 passes.c:1160
  #, gcc-internal-format, gfc-internal-format
  msgid "disable pass %s for functions in the range of [%u, %u]"
-msgstr ""
+msgstr "отключить проход %s для функций в диапазоне [%u, %u]"
  
  #: passes.c:1099 passes.c:1127
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid range %s in option %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸: -mfpu=%s"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½ %s Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° %s"
  
  #: passes.c:1145
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "enable pass %s for function %s"
-msgstr "Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs Ð·Ð°Ð´Ð°Ð½ Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð°ÐºÑ\82Ð¸Ð²Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ñ\85Ð¾Ð´ %s Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %s"
  
  #: passes.c:1156
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "disable pass %s for function %s"
-msgstr "Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs Ð·Ð°Ð´Ð°Ð½ Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð¾Ñ\82ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¿Ñ\80Ð¾Ñ\85Ð¾Ð´ %s Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %s"
  
  #: passes.c:1385
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid pass positioning operation"
-msgstr "некорректный операнд условного оператора"
+msgstr "некорректная операция позиционирования прохода"
  
  #: passes.c:1447
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "plugin cannot register a missing pass"
-msgstr "не задан регистр в адресе"
+msgstr "plugin-модуль не может зарегистрировать отсутствующий проход"
  
  #: passes.c:1450
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "plugin cannot register an unnamed pass"
-msgstr "неизвестное имя регистра: %s"
+msgstr "plugin-модуль не может зарегистрировать безымянный проход"
  
  #: passes.c:1455
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "plugin cannot register pass %qs without reference pass name"
-msgstr "передача rvalue-выражения в качестве параметра-ссылки запрещена"
+msgstr "plugin-модуль не может зарегистрировать проход %qs без указания имени reference-прохода"
  
  #: passes.c:1474
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "pass %qs not found but is referenced by new pass %qs"
-msgstr "Ð½ÐµÑ\82 Ñ\82ÐµÐ³Ð° Ð´Ð»Ñ\8f ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qs"
+msgstr "Ð¿Ñ\80Ð¾Ñ\85Ð¾Ð´ %qs Ð½Ðµ Ð½Ð°Ð¹Ð´ÐµÐ½, Ð½Ð¾ Ð½Ð° Ð½ÐµÐ³Ð¾ Ñ\81Ñ\81Ñ\8bÐ»Ð°ÐµÑ\82Ñ\81Ñ\8f Ð½Ð¾Ð²Ñ\8bÐ¹ Ð¿Ñ\80Ð¾Ñ\85Ð¾Ð´ %qs"
  
  #: plugin.c:177
  #, gcc-internal-format
  msgid "inaccessible plugin file %s expanded from short plugin name %s: %m"
-msgstr ""
+msgstr "недоступный файл плагина %s получен из короткого имени плагина %s: %m"
  
  #: plugin.c:198
  #, gcc-internal-format, gfc-internal-format
@@ -22214,33 +23376,38 @@ msgid ""
  "%s\n"
  "%s"
  msgstr ""
+"плагин %s был задан с разными путями:\n"
+"%s\n"
+"%s"
  
  #: plugin.c:257
  #, gcc-internal-format, gfc-internal-format
  msgid "malformed option -fplugin-arg-%s (missing -<key>[=<value>])"
-msgstr ""
+msgstr "некорректная опция -fplugin-arg-%s (отсутствует -<ключ>[=<значение>])"
  
  #: plugin.c:319
  #, gcc-internal-format, gfc-internal-format
  msgid "plugin %s should be specified before -fplugin-arg-%s in the command line"
-msgstr ""
+msgstr "плагин %s должен быть задан до -fplugin-arg-%s в командной строке"
  
  #: plugin.c:425
  #, gcc-internal-format, gfc-internal-format
  msgid "unknown callback event registered by plugin %s"
-msgstr ""
+msgstr "неизвестное callback событие зарегистрированное плагином %s"
  
  #: plugin.c:457
  #, gcc-internal-format, gfc-internal-format
  msgid "plugin %s registered a null callback function for event %s"
-msgstr ""
+msgstr "плагин %s зарегистрировал нулевую callback функцию для события %s"
  
  #: plugin.c:580
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid ""
  "cannot load plugin %s\n"
  "%s"
-msgstr "ошибка открытия %s"
+msgstr ""
+"ошибка загрузки плагина %s\n"
+"%s"
  
  #: plugin.c:590
  #, gcc-internal-format, gfc-internal-format
@@ -22248,28 +23415,33 @@ msgid ""
  "plugin %s is not licensed under a GPL-compatible license\n"
  "%s"
  msgstr ""
+"плагин %s не лицензирован с GPL-совместимой лицензией\n"
+"%s"
  
  #: plugin.c:599
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid ""
  "cannot find %s in plugin %s\n"
  "%s"
-msgstr "нет класса %qs"
+msgstr ""
+"не найден %s в плагине %s\n"
+"%s"
  
  #: plugin.c:607
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "fail to initialize plugin %s"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f friend-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð¿Ð»Ð°Ð³Ð¸Ð½Ð° %s"
  
  #: plugin.c:889
  #, gcc-internal-format
  msgid "-iplugindir <dir> option not passed from the gcc driver"
-msgstr ""
+msgstr "опция -iplugindir <dir> не была передана из драйвера gcc"
  
  #: predict.c:2709
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Missing argument list in function '%s' at %C"
  msgid "Missing counts for called function %s/%i"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\81Ð¿Ð¸Ñ\81Ð¾Ðº Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s' Ð² %C"
  
  #: profile.c:461
  #, gcc-internal-format, gfc-internal-format
@@ -22282,14 +23454,14 @@ msgid "corrupted profile info: sum_all is smaller than sum_max"
  msgstr "испорчены данные профилирования: sum_all меньше sum_max"
  
  #: profile.c:724
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "corrupted profile info: profile data is not flow-consistent"
-msgstr "испорчены данные профилирования: дуга из %i в %i превышает максимальный счётчик"
+msgstr "испорчена информация профилирования: данные профилирования не согласованы с потоком управления"
  
  #: profile.c:741
  #, gcc-internal-format, gfc-internal-format
  msgid "corrupted profile info: number of iterations for basic block %d thought to be %i"
-msgstr "испорчены данные профилирования: число повторений блока %d должно быть %i"
+msgstr "испорчена информация профилирования: число повторений блока %d должно быть %i"
  
  #: profile.c:762
  #, gcc-internal-format, gfc-internal-format
@@ -22342,19 +23514,19 @@ msgid "validate_value_data: [%u] Non-empty reg in chain (%s %u %i)"
  msgstr "validate_value_data: [%u] Непустой регистр в списке (%s %u %i)"
  
  #: reginfo.c:708
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t use %qs as a call-saved register"
-msgstr "нельзя использовать '%s' как %s регистр"
+msgstr "нельзя использовать '%qs' как регистр, сохраняемый при вызовах"
  
  #: reginfo.c:712
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t use %qs as a call-used register"
-msgstr "нельзя использовать '%s' как %s регистр"
+msgstr "нельзя использовать '%qs' как регистр, не сохраняемый при вызовах"
  
  #: reginfo.c:724
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t use %qs as a fixed register"
-msgstr "нельзя использовать '%s' как %s регистр"
+msgstr "нельзя использовать '%qs' как регистр специального назначения"
  
  #: reginfo.c:750 config/ia64/ia64.c:5940 config/ia64/ia64.c:5947
  #: config/pa/pa.c:437 config/pa/pa.c:444 config/sh/sh.c:9627
@@ -22364,9 +23536,9 @@ msgid "unknown register name: %s"
  msgstr "неизвестное имя регистра: %s"
  
  #: reginfo.c:763
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "stack register used for global register variable"
-msgstr "Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80 Ð½Ð°Ð·Ð½Ð°Ñ\87ÐµÐ½ Ð´Ð»Ñ\8f Ð´Ð²Ñ\83Ñ\85 Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²Ñ\8bÑ\85 Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+msgstr "Ñ\81Ñ\82ÐµÐºÐ¾Ð²Ñ\8bÐ¹ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½ Ð´Ð»Ñ\8f Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ð¾Ð¹ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹"
  
  #: reginfo.c:769
  #, gcc-internal-format
@@ -22374,14 +23546,14 @@ msgid "global register variable follows a function definition"
  msgstr "глобальная регистровая переменная - за определением функции"
  
  #: reginfo.c:774
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "register of %qD used for multiple global register variables"
-msgstr "регистр назначен для двух глобальных регистровых переменных"
+msgstr "регистр %qD назначен для нескольких глобальных регистровых переменных"
  
  #: reginfo.c:777 config/rs6000/rs6000.c:27665
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conflicts with %qD"
-msgstr "  конфликт с %q+D"
+msgstr "конфликтует с %qD"
  
  #: reginfo.c:782
  #, gcc-internal-format
@@ -22404,7 +23576,7 @@ msgid "%<&%> constraint used with no register class"
  msgstr "ограничитель %<&%> без указания класса регистров"
  
  #: reload1.c:2076
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t find a register in class %qs while reloading %<asm%>"
  msgstr "не найден регистр класса %qs для загрузки операндов %<asm%>"
  
@@ -22454,9 +23626,9 @@ msgid "RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d"
  msgstr "RTL: ожидался код '%s' или '%s', обнаружено '%s'; функция %s, в %s:%d"
  
  #: rtl.c:846
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "RTL check: attempt to treat non-block symbol as a block symbol in %s, at %s:%d"
-msgstr "RTL: Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿ Ðº Ñ\8dÐ»-Ñ\82Ñ\83 %d '%s' Ð¿Ð¾Ñ\81Ð»ÐµÐ´Ð½Ð¸Ð¼ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð¼ %d; Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s, в %s:%d"
+msgstr "RTL: Ð¿Ð¾Ð¿Ñ\8bÑ\82ÐºÐ° Ñ\82Ñ\80Ð°ÐºÑ\82Ð¾Ð²Ð°Ñ\82Ñ\8c Ð½Ðµ Ð±Ð»Ð¾Ñ\87Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð¼Ð²Ð¾Ð» ÐºÐ°Ðº Ð±Ð»Ð¾Ñ\87Ð½Ñ\8bÐ¹ Ð² %s, в %s:%d"
  
  #: rtl.c:856
  #, fuzzy, gcc-internal-format, gfc-internal-format
@@ -22562,7 +23734,7 @@ msgstr "вставка отступов в структуру для вырав
  #: stor-layout.c:1289
  #, gcc-internal-format
  msgid "offset of packed bit-field %qD has changed in GCC 4.4"
-msgstr ""
+msgstr "смещение упакованного битового поля %qD изменилось в GCC 4.4"
  
  #: stor-layout.c:1598
  #, gcc-internal-format
@@ -22570,14 +23742,14 @@ msgid "padding struct size to alignment boundary"
  msgstr "дополнение размера структуры до границы выравнивания"
  
  #: stor-layout.c:1626
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "packed attribute causes inefficient alignment for %qE"
-msgstr "атрибут packed приводит к неэффективному выравниванию для %qs"
+msgstr "атрибут packed приводит к неэффективному выравниванию для %qE"
  
  #: stor-layout.c:1630
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "packed attribute is unnecessary for %qE"
-msgstr "атрибут packed для %qs не требуется"
+msgstr "атрибут packed для %qE не требуется"
  
  #: stor-layout.c:1636
  #, gcc-internal-format
@@ -22601,18 +23773,22 @@ msgstr "переименование %D после ссылки в ассемб
  
  #: symtab.c:964
  #, fuzzy, gcc-internal-format
+#| msgid "function returning a function"
  msgid "function symbol is not function"
-msgstr "%qs объявлена как функция, возвращающая функцию"
+msgstr "функция возвращает функцию"
  
+#
  #: symtab.c:972
  #, fuzzy, gcc-internal-format
+#| msgid "array is not addressable"
  msgid "variable symbol is not variable"
-msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð° Ð¿Ñ\80Ñ\8fÐ¼Ð°Ñ\8f Ð°Ð´Ñ\80ÐµÑ\81Ð°Ñ\86Ð¸Ñ\8f Ðº Ð²Ñ\85Ð¾Ð´Ð½Ð¾Ð¹ Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¸ Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸ %d"
+msgstr "Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð½ÐµÐ°Ð´Ñ\80ÐµÑ\81Ñ\83ÐµÐ¼"
  
  #: symtab.c:978
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "node has wrong clone list"
  msgid "node has unknown type"
-msgstr ""
+msgstr "узел имеет некорректный список клонов"
  
  #: symtab.c:987
  #, gcc-internal-format
@@ -22631,23 +23807,27 @@ msgstr ""
  
  #: symtab.c:1017
  #, fuzzy, gcc-internal-format
+#| msgid "node not found in cgraph_hash"
  msgid "node not found in symtab assembler name hash"
-msgstr "не найден узел в хеш-таблице DECL_ASSEMBLER_NAME"
+msgstr "не найден узел в cgraph_hash"
  
  #: symtab.c:1024
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "double linked list of clones corrupted"
  msgid "double linked list of assembler names corrupted"
-msgstr ""
+msgstr "испорчен двусвязный список клонов"
  
  #: symtab.c:1029
  #, fuzzy, gcc-internal-format
+#| msgid "%qD used before its definition"
  msgid "node has body_removed but is definition"
-msgstr "%q+D использована без предварительного определения"
+msgstr "%qD использована до своего определения"
  
  #: symtab.c:1034
  #, fuzzy, gcc-internal-format
+#| msgid "node is in clone list but it is not clone"
  msgid "node is analyzed byt it is not a definition"
-msgstr "декларация %q#D вне класса не является определением"
+msgstr "узел в списке клонов, но не является клоном"
  
  #: symtab.c:1039
  #, gcc-internal-format
@@ -22656,8 +23836,9 @@ msgstr ""
  
  #: symtab.c:1044
  #, fuzzy, gcc-internal-format
+#| msgid "node is in clone list but it is not clone"
  msgid "node is alias but not definition"
-msgstr "%Jопределение функции в старом стиле"
+msgstr "узел в списке клонов, но не является клоном"
  
  #: symtab.c:1049
  #, gcc-internal-format
@@ -22670,14 +23851,16 @@ msgid "node is transparent_alias but not an alias"
  msgstr ""
  
  #: symtab.c:1063
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "node is in clone list but it is not clone"
  msgid "node is in same_comdat_group list but has no comdat_group"
-msgstr ""
+msgstr "узел в списке клонов, но не является клоном"
  
  #: symtab.c:1068
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "same_comdat_group is not a circular list"
  msgid "same_comdat_group list across different groups"
-msgstr ""
+msgstr "same_comdat_group не является циклическим списком"
  
  #: symtab.c:1073
  #, gcc-internal-format
@@ -22687,12 +23870,12 @@ msgstr ""
  #: symtab.c:1078
  #, gcc-internal-format
  msgid "node is alone in a comdat group"
-msgstr ""
+msgstr "только один узел в comdat группе"
  
  #: symtab.c:1085
  #, gcc-internal-format
  msgid "same_comdat_group is not a circular list"
-msgstr ""
+msgstr "same_comdat_group не является циклическим списком"
  
  #: symtab.c:1100
  #, gcc-internal-format, gfc-internal-format
@@ -22706,8 +23889,9 @@ msgstr ""
  
  #: symtab.c:1117
  #, fuzzy, gcc-internal-format
+#| msgid "node is alone in a comdat group"
  msgid "Both section and comdat group is set"
-msgstr "ошибка при возврате ненужной функции"
+msgstr "только один узел в comdat группе"
  
  #: symtab.c:1129
  #, gcc-internal-format
@@ -22731,8 +23915,9 @@ msgstr ""
  
  #: symtab.c:1182 symtab.c:1219
  #, fuzzy, gcc-internal-format
+#| msgid "verify_ssa failed"
  msgid "symtab_node::verify failed"
-msgstr "процедура verify_cgraph_node выявила ошибки"
+msgstr "процедура verify_ssa выявила ошибки"
  
  #: symtab.c:1215
  #, gcc-internal-format
@@ -22740,14 +23925,14 @@ msgid "Two symbols with same comdat_group are not linked by the same_comdat_grou
  msgstr ""
  
  #: symtab.c:1622
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "function %q+D part of alias cycle"
-msgstr "функция %q+D повторно декларирована как inline"
+msgstr "функция %q+D является частью цикла алиасов"
  
  #: symtab.c:1624
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %q+D part of alias cycle"
-msgstr "Ð¼ÐµÑ\82ÐºÐ° %q+D Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð°, Ð½Ð¾ Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %q+D Ð²Ñ\85Ð¾Ð´Ð¸Ñ\82 Ð² Ñ\86Ð¸ÐºÐ» Ð°Ð»Ð¸Ð°Ñ\81Ð¾Ð²"
  
  #: symtab.c:1652
  #, gcc-internal-format
@@ -22760,34 +23945,34 @@ msgid "__builtin_saveregs not supported by this target"
  msgstr "__builtin_saveregs не поддерживается для этой целевой платформы"
  
  #: targhooks.c:870
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "nested functions not supported on this target"
-msgstr "Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ñ\8bÐµ Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b не поддерживаются для этой платформы"
+msgstr "Ð²Ð»Ð¾Ð¶ÐµÐ½Ð½Ñ\8bÐµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ не поддерживаются для этой платформы"
  
  #: targhooks.c:883
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "nested function trampolines not supported on this target"
-msgstr "-ffunction-sections не поддерживается для этой целевой машины"
+msgstr "трамплины вложенных функций не поддерживается для этой платформы"
  
  #: targhooks.c:1330
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "target attribute is not supported on this machine"
-msgstr "атрибут %qs не поддерживается на данной платформе"
+msgstr "атрибут target не поддерживается для данной машины"
  
  #: targhooks.c:1344
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "#pragma GCC target is not supported for this machine"
-msgstr "#pragma extern_prefix для этой платформы не поддерживается"
+msgstr "#pragma GCC target для этой машины не поддерживается"
  
  #: tlink.c:487
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "removing .rpo file: %m"
-msgstr "удаление файла .rpo"
+msgstr "удаление файла .rpo: %m"
  
  #: tlink.c:489
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "renaming .rpo file: %m"
-msgstr "переименование файла .rpo"
+msgstr "переименование файла .rpo: %m"
  
  #: tlink.c:493
  #, gcc-internal-format, gfc-internal-format
@@ -22811,29 +23996,29 @@ msgid "can%'t open %qs for writing: %m"
  msgstr "ошибка открытия %s на запись: %m"
  
  #: toplev.c:919
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-frecord-gcc-switches is not supported by the current target"
-msgstr "-fdata-sections не поддерживается для этой целевой машины"
+msgstr "-frecord-gcc-switches не поддерживается для этой целевой машины"
  
  #: toplev.c:968
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "stack usage computation not supported for this target"
-msgstr "-fstack-protector не поддерживается для этой целевой платформы"
+msgstr "вычисление размера используемой области стека не поддерживается для этой целевой платформы"
  
  #: toplev.c:1037
  #, gcc-internal-format
  msgid "stack usage might be unbounded"
-msgstr ""
+msgstr "размер используемой области стека, возможно, неограничен"
  
  #: toplev.c:1042
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "stack usage might be %wd bytes"
-msgstr "кадр стека слишком велик: %d байт"
+msgstr "размер используемой области стека может составлять %wd байт"
  
  #: toplev.c:1045
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "stack usage is %wd bytes"
-msgstr "кадр стека слишком велик: %d байт"
+msgstr "размер используемой области стека равен %wd байт"
  
  #: toplev.c:1061
  #, gcc-internal-format
@@ -22841,24 +24026,27 @@ msgid "can%'t open %s for writing: %m"
  msgstr "ошибка открытия %s на запись: %m"
  
  #: toplev.c:1231
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "this target does not support %qs"
-msgstr "%s не поддерживает %s"
+msgstr "для этой целевой платформы не поддерживается %qs"
  
  #: toplev.c:1257
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Graphite loop optimizations cannot be used (-fgraphite, -fgraphite-identity, -floop-block, -floop-flatten, -floop-interchange, -floop-strip-mine, -floop-parallelize-all, and -ftree-loop-linear)"
  msgid "Graphite loop optimizations cannot be used (isl is not available)(-fgraphite, -fgraphite-identity, -floop-block, -floop-interchange, -floop-strip-mine, -floop-parallelize-all, -floop-unroll-and-jam, and -ftree-loop-linear)"
-msgstr ""
+msgstr "Graphite-оптимизации циклов не могут быть использованы (-fgraphite, -fgraphite-identity, -floop-block, -floop-flatten, -floop-interchange, -floop-strip-mine, -floop-parallelize-all и -ftree-loop-linear)"
  
  #: toplev.c:1268
  #, fuzzy, gcc-internal-format
+#| msgid "fixed-point types not supported for this target"
  msgid "-fcheck-pointer-bounds is not supported for this target"
-msgstr "-fdata-sections не поддерживается для этой целевой машины"
+msgstr "типы с фиксированной точкой не поддерживаются для этой целевой платформы"
  
  #: toplev.c:1275
  #, fuzzy, gcc-internal-format
+#| msgid "-fuse-linker-plugin is not supported in this configuration"
  msgid "-fcheck-pointer-bounds is not supported with Address Sanitizer"
-msgstr "-m%s в данной конфигурации не поддерживается"
+msgstr "-fuse-linker-plugin в данной конфигурации не поддерживается"
  
  #: toplev.c:1290
  #, fuzzy, gcc-internal-format
@@ -22882,9 +24070,9 @@ msgid "-f%sleading-underscore not supported on this target machine"
  msgstr "-f%sleading-underscore не поддерживается для этой целевой машины"
  
  #: toplev.c:1381
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "could not close zeroed insn dump file %qs: %m"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82Ð¸Ñ\8f Ð´Ð°Ð¼Ð¿-Ñ\84Ð°Ð¹Ð»Ð° %qs: %s"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð·Ð°ÐºÑ\80Ñ\8bÑ\82Ð¸Ñ\8f Ð´Ð°Ð¼Ð¿-Ñ\84Ð°Ð¹Ð»Ð° %qs: %m"
  
  #: toplev.c:1418
  #, fuzzy, gcc-internal-format
@@ -22905,7 +24093,7 @@ msgstr "запрошено отслеживание переменных, но 
  #: toplev.c:1473
  #, gcc-internal-format
  msgid "var-tracking-assignments changes selective scheduling"
-msgstr ""
+msgstr "присваивания с отслеживанием переменных влияют на селективное планирование"
  
  #: toplev.c:1499
  #, gcc-internal-format
@@ -22935,7 +24123,7 @@ msgstr "-fprefetch-loop-arrays не поддерживается с -Os"
  #: toplev.c:1541
  #, gcc-internal-format
  msgid "-fassociative-math disabled; other options take precedence"
-msgstr ""
+msgstr "-fassociative-math отменен в пользу более приоритетных ключей"
  
  #: toplev.c:1559
  #, gcc-internal-format
@@ -22944,11 +24132,13 @@ msgstr "-fstack-protector не поддерживается для этой це
  
  #: toplev.c:1571
  #, 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 "-fdata-sections не поддерживается для этой целевой машины"
+msgstr "атрибут section для данной платформы не поддерживается"
  
  #: toplev.c:1580
  #, fuzzy, gcc-internal-format
+#| msgid "-fdata-sections not supported for this target"
  msgid "-fsanitize=address not supported for this target"
  msgstr "-fdata-sections не поддерживается для этой целевой машины"
  
@@ -22964,88 +24154,90 @@ msgstr "ошибка закрытия %s: %m"
  
  #: trans-mem.c:621
  #, fuzzy, gcc-internal-format
+#| msgid "invalid volatile use of %qD inside transaction"
  msgid "invalid use of volatile lvalue inside transaction"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð±Ð°Ð·Ð¾Ð²Ð¾Ð³Ð¾ ÐºÐ»Ð°Ñ\81Ñ\81Ð°"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ volatile %qD Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\82Ñ\80Ð°Ð½Ð·Ð°ÐºÑ\86Ð¸Ð¸"
  
  #: trans-mem.c:624
  #, fuzzy, gcc-internal-format
+#| msgid "asm not allowed in %<transaction_safe%> function"
  msgid "invalid use of volatile lvalue inside %<transaction_safe%>function"
-msgstr "атрибуты не допускаются при определении функции"
+msgstr "asm не допускается в %<transaction_safe%> функции"
  
  #: trans-mem.c:656
  #, gcc-internal-format
  msgid "%<transaction_may_cancel_outer%> function call not within outer transaction or %<transaction_may_cancel_outer%>"
-msgstr ""
+msgstr "%<transaction_may_cancel_outer%> вызов функции не внутри внешней транзакции или %<transaction_may_cancel_outer%>"
  
  #: trans-mem.c:725 trans-mem.c:4840
  #, gcc-internal-format
  msgid "unsafe function call %qD within atomic transaction"
-msgstr ""
+msgstr "небезопасный вызов функции %qD внутри атомарной транзакции"
  
  #: trans-mem.c:731
  #, gcc-internal-format
  msgid "unsafe function call %qE within atomic transaction"
-msgstr ""
+msgstr "небезопасный вызов функции %qE внутри атомарной транзакции"
  
  #: trans-mem.c:735
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unsafe indirect function call within atomic transaction"
-msgstr "inline-функции, переопределённые как extern, не подлежат подстановке"
+msgstr "небезопасный косвенный вызов функции внутри атомарной транзакции"
  
  #: trans-mem.c:743 trans-mem.c:4772
  #, gcc-internal-format
  msgid "unsafe function call %qD within %<transaction_safe%> function"
-msgstr ""
+msgstr "небезопасный вызов функции %qD внутри %<transaction_safe%> функции"
  
  #: trans-mem.c:749
  #, gcc-internal-format
  msgid "unsafe function call %qE within %<transaction_safe%> function"
-msgstr ""
+msgstr "небезопасный вызов функции %qE внутри %<transaction_safe%> функции"
  
  #: trans-mem.c:753
  #, gcc-internal-format
  msgid "unsafe indirect function call within %<transaction_safe%> function"
-msgstr ""
+msgstr "небезопасный косвенный вызов функции внутри %<transaction_safe%> функции"
  
  #: trans-mem.c:768 trans-mem.c:4812
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "asm not allowed in atomic transaction"
-msgstr "пространство имён %qD не допускается в using-декларации"
+msgstr "asm не допускается в атомарной транзакции"
  
  #: trans-mem.c:771
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "asm not allowed in %<transaction_safe%> function"
-msgstr "атрибуты не допускаются при определении функции"
+msgstr "asm не допускается в %<transaction_safe%> функции"
  
  #: trans-mem.c:783
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "relaxed transaction in atomic transaction"
-msgstr "Ð\9fÐ¾Ð¼ÐµÑ\89Ð°Ñ\82Ñ\8c ÐºÐ°Ð¶Ð´Ñ\83Ñ\8e Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8e Ð² Ð¾Ñ\82Ð´ÐµÐ»Ñ\8cÐ½Ñ\83Ñ\8e Ñ\81ÐµÐºÑ\86Ð¸Ñ\8e"
+msgstr "Ð¾Ñ\81Ð»Ð°Ð±Ð»ÐµÐ½Ð½Ð°Ñ\8f Ñ\82Ñ\80Ð°Ð½Ð·Ð°ÐºÑ\86Ð¸Ñ\8f Ð² Ð°Ñ\82Ð¾Ð¼Ð°Ñ\80Ð½Ð¾Ð¹ Ñ\82Ñ\80Ð°Ð½Ð·Ð°ÐºÑ\86Ð¸Ð¸"
  
  #: trans-mem.c:786
  #, gcc-internal-format
  msgid "relaxed transaction in %<transaction_safe%> function"
-msgstr ""
+msgstr "ослабленная транзакция в %<transaction_safe%> функции"
  
  #: trans-mem.c:793
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "outer transaction in transaction"
-msgstr "указатель на функцию в операции вычитания"
+msgstr "внешняя транзакция в транзакции"
  
  #: trans-mem.c:796
  #, gcc-internal-format
  msgid "outer transaction in %<transaction_may_cancel_outer%> function"
-msgstr ""
+msgstr "внешняя транзакция в %<transaction_may_cancel_outer%> функции"
  
  #: trans-mem.c:800
  #, gcc-internal-format
  msgid "outer transaction in %<transaction_safe%> function"
-msgstr ""
+msgstr "внешняя транзакция в %<transaction_safe%> функции"
  
  #: trans-mem.c:4438
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%Kasm not allowed in %<transaction_safe%> function"
-msgstr "атрибуты не допускаются при определении функции"
+msgstr "%Kasm не допускается в %<transaction_safe%> функции"
  
  #: tree-cfg.c:339
  #, gcc-internal-format
@@ -23065,7 +24257,7 @@ msgstr "побочные эффекты не перевычислены посл
  #: tree-cfg.c:2803
  #, gcc-internal-format
  msgid "DECL_GIMPLE_REG_P set on a variable with address taken"
-msgstr ""
+msgstr "DECL_GIMPLE_REG_P установлен для переменной, от которой берется адрес"
  
  #: tree-cfg.c:2832
  #, gcc-internal-format
@@ -23075,17 +24267,17 @@ msgstr "имя SSA в списке свободных, но на него ест
  #: tree-cfg.c:2838 tree-cfg.c:4174
  #, gcc-internal-format
  msgid "INDIRECT_REF in gimple IL"
-msgstr ""
+msgstr "INDIRECT_REF в gimple IL"
  
  #: tree-cfg.c:2846
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid first operand of MEM_REF"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f %%R"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f MEM_REF"
  
  #: tree-cfg.c:2852
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid offset operand of MEM_REF"
-msgstr "некорректный операнд для %%R"
+msgstr "некорректный операнд смещения для MEM_REF"
  
  #: tree-cfg.c:2865
  #, gcc-internal-format
@@ -23095,7 +24287,7 @@ msgstr "ASSERT_EXPR с тождественно ложным условием"
  #: tree-cfg.c:2871
  #, gcc-internal-format
  msgid "MODIFY_EXPR not expected while having tuples"
-msgstr ""
+msgstr "MODIFY_EXPR не ожидалось при разборе tuples"
  
  #: tree-cfg.c:2898 tree-ssa.c:870
  #, gcc-internal-format
@@ -23103,9 +24295,9 @@ msgid "address taken, but ADDRESSABLE bit not set"
  msgstr "адрес был взят, а бит ADDRESSABLE не установлен"
  
  #: tree-cfg.c:2909
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-integral used in condition"
-msgstr "в условии использовано не булево выражение"
+msgstr "в условии использовано не целочисленное выражение"
  
  #: tree-cfg.c:2914
  #, gcc-internal-format
@@ -23118,24 +24310,26 @@ msgid "non-scalar BIT_FIELD_REF, IMAGPART_EXPR or REALPART_EXPR"
  msgstr ""
  
  #: tree-cfg.c:2949
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid position or size operand to BIT_FIELD_REF"
-msgstr "некорректные ограничения для операнда"
+msgstr "некорректная позиция или размер для BIT_FIELD_REF"
  
  #: tree-cfg.c:2956
  #, gcc-internal-format
  msgid "integral result type precision does not match field size of BIT_FIELD_REF"
-msgstr ""
+msgstr "точность целочисленного типа результата не соответствует размеру поля в BIT_FIELD_REF"
  
  #: tree-cfg.c:2965
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "mode precision of non-integral result does not match field size of BIT_FIELD_REF"
  msgid "mode size of non-integral result does not match field size of BIT_FIELD_REF"
-msgstr ""
+msgstr "точность моды нецелочисленного результата не соответствует размеру поля в BIT_FIELD_REF"
  
  #: tree-cfg.c:2973
  #, fuzzy, gcc-internal-format
+#| msgid "invalid position or size operand to BIT_FIELD_REF"
  msgid "position plus size exceeds size of referenced object in BIT_FIELD_REF"
-msgstr "некорректные ограничения для операнда"
+msgstr "некорректная позиция или размер для BIT_FIELD_REF"
  
  #: tree-cfg.c:3006
  #, gcc-internal-format
@@ -23148,209 +24342,209 @@ msgid "invalid reference prefix"
  msgstr "неверный префикс ссылки"
  
  #: tree-cfg.c:3027
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operand to plus/minus, type is a pointer"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ Ð¿Ð»Ñ\8eÑ\81/Ð¼Ð¸Ð½Ñ\83Ñ\81, Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
  
  #: tree-cfg.c:3038
  #, gcc-internal-format
  msgid "invalid operand to pointer plus, first operand is not a pointer"
-msgstr ""
+msgstr "некорректный операнд для операции сложения с указателем, первый операнд не указатель"
  
  #: tree-cfg.c:3044
  #, gcc-internal-format
  msgid "invalid operand to pointer plus, second operand is not an integer type of appropriate width"
-msgstr ""
+msgstr "некорректный операнд для операции сложения с указателем, тип второго операнда не является целочисленным подходящей ширины"
  
  #: tree-cfg.c:3095
  #, gcc-internal-format
  msgid "invalid CASE_CHAIN"
-msgstr ""
+msgstr "некорректная CASE_CHAIN"
  
  #: tree-cfg.c:3123
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid expression for min lvalue"
-msgstr "Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð·Ð°Ð´Ð°Ð½Ð¾ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² Ð»ÐµÐ²Ð¾Ð¹ Ñ\87Ð°Ñ\81Ñ\82Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ min"
  
  #: tree-cfg.c:3134
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operand in indirect reference"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ð¾Ð¹ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐµ"
  
  #: tree-cfg.c:3163
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operands to array reference"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %s"
+msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð² Ñ\81Ñ\81Ñ\8bÐ»ÐºÐµ Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²"
  
  #: tree-cfg.c:3174
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in array reference"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð°"
+msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð¾Ð² Ð² Ñ\81Ñ\81Ñ\8bÐ»ÐºÐµ Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²"
  
  #: tree-cfg.c:3183
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in array range reference"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¸Ð½Ð´ÐµÐºÑ\81 массива"
+msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð¾Ð² Ð² Ñ\81Ñ\81Ñ\8bÐ»ÐºÐµ Ð½Ð° Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½ массива"
  
  #: tree-cfg.c:3194
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in real/imagpart reference"
-msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð¾Ð² Ð² Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
+msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð¾Ð² Ð² Ñ\81Ñ\81Ñ\8bÐ»ÐºÐµ Ð½Ð° Ð²ÐµÑ\89ÐµÑ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\83Ñ\8e/Ð¼Ð½Ð¸Ð¼Ñ\83Ñ\8e Ñ\87Ð°Ñ\81Ñ\82Ñ\8c"
  
  #: tree-cfg.c:3204
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in component reference"
-msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð¾Ð² Ð² Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
+msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð¾Ð² Ð² Ñ\81Ñ\81Ñ\8bÐ»ÐºÐµ Ð½Ð° ÐºÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82"
  
  #: tree-cfg.c:3221
  #, gcc-internal-format
  msgid "conversion of an SSA_NAME on the left hand side"
-msgstr ""
+msgstr "преобразование SSA_NAME в левой части"
  
  #: tree-cfg.c:3228
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion of register to a different size"
-msgstr "Ð¿Ñ\80Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ðµ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ðº Ñ\86ÐµÐ»Ð¾Ð¼Ñ\83 Ð´Ñ\80Ñ\83Ð³Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð°"
+msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð° Ðº Ð´Ñ\80Ñ\83Ð³Ð¾Ð¼Ñ\83 Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ñ\83"
  
  #: tree-cfg.c:3243
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid address operand in MEM_REF"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f %%R"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð°Ð´Ñ\80ÐµÑ\81Ð° Ð² MEM_REF"
  
  #: tree-cfg.c:3250
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid offset operand in MEM_REF"
-msgstr "некорректный оператор сдвига"
+msgstr "некорректный операнд отступа в MEM_REF"
  
  #: tree-cfg.c:3260
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid address operand in TARGET_MEM_REF"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f %%R"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð°Ð´Ñ\80ÐµÑ\81Ð° Ð² TARGET_MEM_REF"
  
  #: tree-cfg.c:3267
  #, gcc-internal-format
  msgid "invalid offset operand in TARGET_MEM_REF"
-msgstr ""
+msgstr "некорректный операнд отступа в TARGET_MEM_REF"
  
  #: tree-cfg.c:3321
  #, gcc-internal-format
  msgid "gimple call has two targets"
-msgstr ""
+msgstr "gimple вызов имеет две цели"
  
  #: tree-cfg.c:3330
  #, gcc-internal-format
  msgid "gimple call has no target"
-msgstr ""
+msgstr "gimple вызов не имеет цели"
  
  #: tree-cfg.c:3337
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid function in gimple call"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ðµ Ðº Ñ\82Ð¸Ð¿Ñ\83 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qT"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ð² gimple Ð²Ñ\8bÐ·Ð¾Ð²Ðµ"
  
  #: tree-cfg.c:3347
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-function in gimple call"
-msgstr "inline-подстановка функции невозможна"
+msgstr "не функция в gimple вызове"
  
  #: tree-cfg.c:3358
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid pure const state for function"
-msgstr "Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs Ð·Ð°Ð´Ð°Ð½ Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ñ\81Ð¾Ñ\81Ñ\82Ð¾Ñ\8fÐ½Ð¸Ðµ pure const Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
  
  #: tree-cfg.c:3367
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid LHS in gimple call"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ PC Ð² Ñ\82Ð°Ð±Ð»Ð¸Ñ\86Ðµ Ð½Ð¾Ð¼ÐµÑ\80Ð¾Ð² Ñ\81Ñ\82Ñ\80Ð¾Ðº"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð»ÐµÐ²Ð°Ñ\8f Ñ\87Ð°Ñ\81Ñ\82Ñ\8c Ð² gimple Ð²Ñ\8bÐ·Ð¾Ð²Ðµ"
  
  #: tree-cfg.c:3377
  #, gcc-internal-format
  msgid "LHS in noreturn call"
-msgstr ""
+msgstr "левая часть в вызове без возврата (noreturn)"
  
  #: tree-cfg.c:3393
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid conversion in gimple call"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ðº %<__fpreg%>"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð² gimple Ð²Ñ\8bÐ·Ð¾Ð²Ðµ"
  
  #: tree-cfg.c:3402
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid static chain in gimple call"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ PC Ð² Ñ\82Ð°Ð±Ð»Ð¸Ñ\86Ðµ Ð½Ð¾Ð¼ÐµÑ\80Ð¾Ð² Ñ\81Ñ\82Ñ\80Ð¾Ðº"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ñ\86ÐµÐ¿Ð¾Ñ\87ÐºÐ° Ð² gimple Ð²Ñ\8bÐ·Ð¾Ð²Ðµ"
  
  #: tree-cfg.c:3413
  #, gcc-internal-format
  msgid "static chain with function that doesn%'t use one"
-msgstr ""
+msgstr "статическая цепочка с функцией, которая не использует ее"
  
  #: tree-cfg.c:3430
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid argument to gimple call"
-msgstr "некорректный аргумент внутренней функции"
+msgstr "некорректный аргумент в gimple вызове"
  
  #: tree-cfg.c:3450
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operands in gimple comparison"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86ии"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð² gimple Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½ии"
  
  #: tree-cfg.c:3466
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "mismatching comparison operand types"
-msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð¾Ð² Ð² Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
+msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð¾Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8f"
  
  #: tree-cfg.c:3483
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unsupported operation or type for vector comparison returning a boolean"
-msgstr "неправильное использование void-выражения"
+msgstr ""
  
  #: tree-cfg.c:3498
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-vector operands in vector comparison"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86ии"
+msgstr "Ð½ÐµÐ²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð² Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ð¾Ð¼ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½ии"
  
  #: tree-cfg.c:3506
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid vector comparison resulting type"
-msgstr "Ð½ÐµÐ¿Ñ\80Ð°Ð²Ð¸Ð»Ñ\8cÐ½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ void-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ñ\80ÐµÐ·Ñ\83Ð»Ñ\8cÑ\82Ð°Ñ\82Ð° Ð² Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ð¾Ð¼ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ð¸"
  
  #: tree-cfg.c:3513
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "bogus comparison result type"
-msgstr "Предупреждать о отступлениях от стиля Effective C++"
+msgstr "фиктивный тип результата в векторном сравнении"
  
  #: tree-cfg.c:3535
  #, gcc-internal-format
  msgid "non-register as LHS of unary operation"
-msgstr ""
+msgstr "не-регистр в левой части унарной операции"
  
  #: tree-cfg.c:3541
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operand in unary operation"
-msgstr "неверные операнды бинарной операции %s"
+msgstr "неверные операнды унарной операции"
  
  #: tree-cfg.c:3573
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid types in nop conversion"
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² nop-Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸"
  
  #: tree-cfg.c:3588
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid types in address space conversion"
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ð³Ð¾ Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ð°"
  
  #: tree-cfg.c:3602
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid types in fixed-point conversion"
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ñ\81 Ñ\84Ð¸ÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹"
  
  #: tree-cfg.c:3617
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid types in conversion to floating point"
-msgstr "некорректное преобразование к %<__fpreg%>"
+msgstr "некорректные типы в преобразовании к типу с плавающей точкой"
  
  #: tree-cfg.c:3632
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid types in conversion to integer"
-msgstr "некорректное преобразование к %<__fpreg%>"
+msgstr "некорректные типы в преобразовании к целочисленному типу"
  
  #: tree-cfg.c:3646
  #, gcc-internal-format
@@ -23358,72 +24552,72 @@ msgid "reduction should convert from vector to element type"
  msgstr ""
  
  #: tree-cfg.c:3674
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-trivial conversion in unary operation"
-msgstr "некорректная левая часть в присваивании"
+msgstr "нетривиальное преобразование в унарной операции"
  
  #: tree-cfg.c:3699
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-register as LHS of binary operation"
-msgstr "Ð\92 Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ðµ"
+msgstr "Ð½Ðµ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80 Ð² Ð»ÐµÐ²Ð¾Ð¹ Ñ\87Ð°Ñ\81Ñ\82Ð¸ Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸"
  
  #: tree-cfg.c:3706
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operands in binary operation"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %s"
+msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð² Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸"
  
  #: tree-cfg.c:3721
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in complex expression"
-msgstr "несоответствие типов в условном выражении"
+msgstr "несоответствие типов в комплексном выражении"
  
  #: tree-cfg.c:3750
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in shift expression"
  msgstr "несоответствие типов в условном выражении"
  
  #: tree-cfg.c:3767 tree-cfg.c:3788
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in widening vector shift expression"
-msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð¾Ð² Ð² Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
+msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð¾Ð² Ð² Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80Ñ\8fÑ\8eÑ\89ÐµÐ¼ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ñ\81Ð´Ð²Ð¸Ð³Ð°"
  
  #: tree-cfg.c:3809
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid non-vector operands to vector valued plus"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %s"
+msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ð½ÐµÐ²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ Ð¿Ð»Ñ\8eÑ\81"
  
  #: tree-cfg.c:3820
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid (pointer) operands to plus/minus"
-msgstr "неверные операнды бинарной операции %s"
+msgstr "неверные операнды (указатели) операции плюс/минус"
  
  #: tree-cfg.c:3834
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in pointer plus expression"
-msgstr "несоответствие типов в условном выражении"
+msgstr "несоответствие типов в выражении сложения с указателем"
  
  #: tree-cfg.c:3914
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in binary expression"
-msgstr "несоответствие типов в условном выражении"
+msgstr "несоответствие типов в бинарном выражении"
  
  #: tree-cfg.c:3942
  #, gcc-internal-format
  msgid "non-register as LHS of ternary operation"
-msgstr ""
+msgstr "не регистр в левой части тернарной операции"
  
  #: tree-cfg.c:3951
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operands in ternary operation"
-msgstr "неверные операнды бинарной операции %s"
+msgstr "неверные операнды тернарной операции"
  
  #: tree-cfg.c:3967
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in widening multiply-accumulate expression"
-msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð¾Ð² Ð² Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
+msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80Ñ\8fÑ\8eÑ\89ÐµÐ¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ñ\83Ð¼Ð½Ð¾Ð¶ÐµÐ½Ð¸Ñ\8f Ñ\81 Ð½Ð°ÐºÐ¾Ð¿Ð»ÐµÐ½Ð¸ÐµÐ¼"
  
  #: tree-cfg.c:3981
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in fused multiply-add expression"
  msgstr "несоответствие типов в условном выражении"
  
@@ -23438,39 +24632,41 @@ msgid "type mismatch in conditional expression"
  msgstr "несоответствие типов в условном выражении"
  
  #: tree-cfg.c:4019
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in vector permute expression"
-msgstr "несоответствие типов в условном выражении"
+msgstr "несоответствие типов в векторном выражении перестановки"
  
  #: tree-cfg.c:4031
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "vector types expected in vector permute expression"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¸Ñ\81Ñ\8c Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ð¿ÐµÑ\80ÐµÑ\81Ñ\82Ð°Ð½Ð¾Ð²ÐºÐ¸"
  
  #: tree-cfg.c:4045
  #, gcc-internal-format
  msgid "vectors with different element number found in vector permute expression"
-msgstr ""
+msgstr "в векторном выражении перестановки обнаружены векторы с разным числом элементов"
  
  #: tree-cfg.c:4058
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid mask type in vector permute expression"
-msgstr "некорректный операнд в инструкции"
+msgstr "некорректный тип маски в выражении векторной перестановки"
  
  #: tree-cfg.c:4074
  #, fuzzy, gcc-internal-format
+#| msgid "type mismatch in address expression"
  msgid "type mismatch in sad expression"
-msgstr "несоответствие типов в условном выражении"
+msgstr "несоответствие типов в адресном выражении"
  
  #: tree-cfg.c:4086
  #, fuzzy, gcc-internal-format
+#| msgid "vector types expected in vector permute expression"
  msgid "vector types expected in sad expression"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¸Ñ\81Ñ\8c Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ð¿ÐµÑ\80ÐµÑ\81Ñ\82Ð°Ð½Ð¾Ð²ÐºÐ¸"
  
  #: tree-cfg.c:4122
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-trivial conversion at assignment"
-msgstr "некорректная левая часть в присваивании"
+msgstr "нетривиальное преобразование в присваивании"
  
  #: tree-cfg.c:4131
  #, gcc-internal-format
@@ -23478,19 +24674,19 @@ msgid "non-decl/MEM_REF LHS in clobber statement"
  msgstr ""
  
  #: tree-cfg.c:4149
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operand in unary expression"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %s"
+msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ñ\83Ð½Ð°Ñ\80Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
  
  #: tree-cfg.c:4163
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in address expression"
-msgstr "несоответствие типов в условном выражении"
+msgstr "несоответствие типов в адресном выражении"
  
  #: tree-cfg.c:4189 tree-cfg.c:4215
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid rhs for gimple memory store"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ð°Ñ\8f Ð°Ð´Ñ\80ÐµÑ\81Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¿Ñ\80Ð°Ð²Ð°Ñ\8f Ñ\87Ð°Ñ\81Ñ\82Ñ\8c Ð² gimple Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ Ð·Ð°Ð¿Ð¸Ñ\81Ð¸ Ð² Ð¿Ð°Ð¼Ñ\8fÑ\82Ñ\8c"
  
  #: tree-cfg.c:4249 tree-cfg.c:4267 tree-cfg.c:4281
  #, gcc-internal-format
@@ -23507,10 +24703,12 @@ msgstr ""
  msgid "vector CONSTRUCTOR with non-NULL element index"
  msgstr ""
  
+#
  #: tree-cfg.c:4296
  #, fuzzy, gcc-internal-format
+#| msgid "PHI argument is not a GIMPLE value"
  msgid "vector CONSTRUCTOR element is not a GIMPLE value"
-msgstr "определение PHI - не GIMPLE-значение"
+msgstr "PHI аргумент не есть GIMPLE-значение"
  
  #: tree-cfg.c:4304
  #, gcc-internal-format
@@ -23518,57 +24716,64 @@ msgid "non-vector CONSTRUCTOR with elements"
  msgstr ""
  
  #: tree-cfg.c:4363
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operand in return statement"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%s"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ return"
  
  #: tree-cfg.c:4378
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid conversion in return statement"
-msgstr "некорректный операнд для кода %%s"
+msgstr "некорректное преобразование в операторе return"
  
  #: tree-cfg.c:4402
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "goto destination is neither a label nor a pointer"
-msgstr "индексируемый объект не является ни массивом, ни указателем"
+msgstr "цель оператора goto не является ни меткой, ни указателем"
  
  #: tree-cfg.c:4421
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operand to switch statement"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%s"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° switch"
  
  #: tree-cfg.c:4429
  #, fuzzy, gcc-internal-format
+#| msgid "invalid operand to switch statement"
  msgid "non-integral type switch statement"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%s"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° switch"
  
  #: tree-cfg.c:4437
  #, fuzzy, gcc-internal-format
+#| msgid "%<default%> label not within a switch statement"
  msgid "invalid default case label in switch statement"
  msgstr "метка %<default%> вне оператора switch"
  
  #: tree-cfg.c:4449
  #, fuzzy, gcc-internal-format
+#| msgid "case label not within a switch statement"
  msgid "invalid case label in switch statement"
  msgstr "case-метка вне оператора switch"
  
  #: tree-cfg.c:4456
  #, fuzzy, gcc-internal-format
+#| msgid "invalid operand to switch statement"
  msgid "invalid case range in switch statement"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%s"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° switch"
  
  #: tree-cfg.c:4466
  #, fuzzy, gcc-internal-format
+#| msgid "case label not within a switch statement"
  msgid "type mismatch for case label in switch statement"
  msgstr "case-метка вне оператора switch"
  
  #: tree-cfg.c:4476
  #, fuzzy, gcc-internal-format
+#| msgid "case label not within a switch statement"
  msgid "type precision mismatch in switch statement"
  msgstr "case-метка вне оператора switch"
  
  #: tree-cfg.c:4485
  #, fuzzy, gcc-internal-format
+#| msgid "case label not within a switch statement"
  msgid "case labels not sorted in switch statement"
  msgstr "case-метка вне оператора switch"
  
@@ -23580,52 +24785,52 @@ msgstr ""
  #: tree-cfg.c:4537
  #, gcc-internal-format
  msgid "incorrect entry in label_to_block_map"
-msgstr ""
+msgstr "некорректный элемент в label_to_block_map"
  
  #: tree-cfg.c:4547
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "incorrect setting of landing pad number"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð² Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð½Ð¾Ð¹ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐµ"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\83Ñ\81Ñ\82Ð°Ð½Ð¾Ð²ÐºÐ° Ð½Ð¾Ð¼ÐµÑ\80Ð° landing pad"
  
  #: tree-cfg.c:4563
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid comparison code in gimple cond"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86ии"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ¾Ð´ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8f Ð² gimple Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½ии"
  
  #: tree-cfg.c:4571
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid labels in gimple cond"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾Ðµ lvalue-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ð¾Ð¼ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ %d Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° asm"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð¼ÐµÑ\82ÐºÐ¸ Ð² gimple Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
  
  #: tree-cfg.c:4654 tree-cfg.c:4663
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid PHI result"
-msgstr "некорректный адрес"
+msgstr "некорректный результат PHI"
  
  #: tree-cfg.c:4673
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "missing PHI def"
-msgstr "отсутствует определение"
+msgstr "отсутствует определение PHI"
  
  #: tree-cfg.c:4687
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid PHI argument"
-msgstr "некорректный тип аргумента"
+msgstr "некорректный аргумент PHI"
  
  #: tree-cfg.c:4694
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "incompatible types in PHI argument %u"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸"
+msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ PHI %u"
  
  #: tree-cfg.c:4792 tree-cfg.c:5125
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "verify_gimple failed"
-msgstr "процедура verify_stmts выявила ошибки"
+msgstr "процедура verify_gimple выявила ошибки"
  
  #: tree-cfg.c:4852
  #, gcc-internal-format
  msgid "dead STMT in EH table"
-msgstr ""
+msgstr "мертвый оператор в таблице EH"
  
  #: tree-cfg.c:4868
  #, gcc-internal-format
@@ -23633,12 +24838,13 @@ msgid "location references block not in block tree"
  msgstr ""
  
  #: tree-cfg.c:4991
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "gimple_bb (phi) is set to a wrong basic block"
-msgstr "bb_for_stmt (phi) указывает не на тот блок"
+msgstr "gimple_bb (phi) указывает не на тот блок"
  
  #: tree-cfg.c:5000
  #, fuzzy, gcc-internal-format
+#| msgid "from this location"
  msgid "PHI node with location"
  msgstr "в этом месте"
  
@@ -23653,14 +24859,14 @@ msgid "virtual PHI with argument locations"
  msgstr ""
  
  #: tree-cfg.c:5048
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "gimple_bb (stmt) is set to a wrong basic block"
-msgstr "bb_for_stmt (stmt) указывает не на тот блок"
+msgstr "gimple_bb (stmt) указывает не на тот блок"
  
  #: tree-cfg.c:5084
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "in statement"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80"
+msgstr "Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ"
  
  #: tree-cfg.c:5101
  #, gcc-internal-format
@@ -23673,14 +24879,14 @@ msgid "statement marked for throw in middle of block"
  msgstr "оператор помечен как throw в середине блока"
  
  #: tree-cfg.c:5147
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ENTRY_BLOCK has IL associated with it"
-msgstr "с ENTRY_BLOCK ассоциирован список операторов"
+msgstr "с ENTRY_BLOCK ассоциирован IL"
  
  #: tree-cfg.c:5154
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "EXIT_BLOCK has IL associated with it"
-msgstr "с EXIT_BLOCK ассоциирован список операторов"
+msgstr "с EXIT_BLOCK ассоциирован IL"
  
  #: tree-cfg.c:5161
  #, gcc-internal-format, gfc-internal-format
@@ -23690,17 +24896,17 @@ msgstr "сквозной выход из блока %d"
  #: tree-cfg.c:5185
  #, gcc-internal-format
  msgid "nonlocal label "
-msgstr ""
+msgstr "нелокальная метка"
  
  #: tree-cfg.c:5194
  #, gcc-internal-format
  msgid "EH landing pad label "
-msgstr ""
+msgstr "EH landing pad метка "
  
  #: tree-cfg.c:5203 tree-cfg.c:5212 tree-cfg.c:5237
  #, gcc-internal-format
  msgid "label "
-msgstr ""
+msgstr "метка "
  
  #: tree-cfg.c:5227
  #, gcc-internal-format, gfc-internal-format
@@ -23713,9 +24919,9 @@ msgid "fallthru edge after a control statement in bb %d"
  msgstr "сквозная дуга после оператора управления в блоке %d"
  
  #: tree-cfg.c:5273
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "true/false edge after a non-GIMPLE_COND in bb %d"
-msgstr "дуга true/false после не COND_EXPR в блоке %d"
+msgstr "дуга true/false после не GIMPLE_COND в блоке %d"
  
  #: tree-cfg.c:5296 tree-cfg.c:5318 tree-cfg.c:5335 tree-cfg.c:5405
  #, gcc-internal-format, gfc-internal-format
@@ -23733,14 +24939,14 @@ msgid "return edge does not point to exit in bb %d"
  msgstr "дуга return не указывает на конец блока %d"
  
  #: tree-cfg.c:5371
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "found default case not at the start of case vector"
-msgstr "Ñ\81Ð»Ñ\83Ñ\87Ð°Ð¹ default - Ð½Ðµ Ð² ÐºÐ¾Ð½Ñ\86е case-вектора"
+msgstr "Ñ\81Ð»Ñ\83Ñ\87Ð°Ð¹ default - Ð½Ðµ Ð² Ð½Ð°Ñ\87Ð°Ð»е case-вектора"
  
  #: tree-cfg.c:5379
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "case labels not sorted: "
-msgstr "case-метки не отсортированы"
+msgstr "case-метки не отсортированы: "
  
  #: tree-cfg.c:5396
  #, gcc-internal-format, gfc-internal-format
@@ -23753,24 +24959,24 @@ msgid "missing edge %i->%i"
  msgstr "отсутствует дуга %i->%i"
  
  #: tree-cfg.c:8725
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<noreturn%> function does return"
-msgstr "%Hвыход из функции с атрибутом %<noreturn%>"
+msgstr "выход из функции с атрибутом %<noreturn%>"
  
  #: tree-cfg.c:8746
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "control reaches end of non-void function"
-msgstr "%Hуправление достигает конца не-void функции"
+msgstr "управление достигает конца не-void функции"
  
  #: tree-cfg.c:8812
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ignoring return value of %qD, declared with attribute warn_unused_result"
-msgstr "%Hрезультат %qD, декларированной с атрибутом warn_unused_result, игнорируется"
+msgstr "результат %qD, декларированной с атрибутом warn_unused_result, игнорируется"
  
  #: tree-cfg.c:8817
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ignoring return value of function declared with attribute warn_unused_result"
-msgstr "%Hрезультат функции, декларированной с атрибутом warn_unused_result, игнорируется"
+msgstr "результат функции, декларированной с атрибутом warn_unused_result, игнорируется"
  
  #: tree-chkp-opt.c:718
  #, gcc-internal-format
@@ -23819,73 +25025,75 @@ msgstr ""
  
  #: tree-diagnostic.c:202
  #, fuzzy, gcc-internal-format
+#| msgid "redefinition of %q+D"
  msgid "in definition of macro %qs"
  msgstr "переопределение %q+D"
  
  #: tree-diagnostic.c:219
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%s:%d:   in constexpr expansion of %qs"
  msgid "in expansion of macro %qs"
-msgstr ""
+msgstr "%s:%d:   в раскрытии константного выражения %qs"
  
  #: tree-eh.c:4651
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "BB %i has multiple EH edges"
-msgstr "Ð±Ð»Ð¾Ðº %i Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð²Ñ\8bÐ´Ð°Ð²Ð°Ñ\82Ñ\8c Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ð¹, Ð½Ð¾ Ð¸Ð¼ÐµÐµÑ\82 EH-дуги"
+msgstr "Ð±Ð»Ð¾Ðº %i Ð¸Ð¼ÐµÐµÑ\82 Ð¼Ð½Ð¾Ð¶ÐµÑ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐµ EH-дуги"
  
  #: tree-eh.c:4663
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "BB %i can not throw but has an EH edge"
-msgstr "блок %i не может выдавать исключений, но имеет EH-дуги"
+msgstr "блок %i не может выдавать исключений, но имеет EH-дугу"
  
  #: tree-eh.c:4671
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "BB %i last statement has incorrectly set lp"
-msgstr "в последнем операторе блока %i некорректно установлен регион"
+msgstr "в последнем операторе блока %i некорректно установлен lp"
  
  #: tree-eh.c:4677
  #, gcc-internal-format, gfc-internal-format
  msgid "BB %i is missing an EH edge"
-msgstr ""
+msgstr "в блоке %i отсутствует EH-дуга"
  
  #: tree-eh.c:4683
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Incorrect EH edge %i->%i"
-msgstr "Ð½ÐµÐ½Ñ\83Ð¶ная EH-дуга %i->%i"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ная EH-дуга %i->%i"
  
  #: tree-eh.c:4717 tree-eh.c:4736
  #, gcc-internal-format, gfc-internal-format
  msgid "BB %i is missing an edge"
-msgstr ""
+msgstr "в блоке %i отсутствует дуга"
  
  #: tree-eh.c:4753
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "BB %i too many fallthru edges"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f RTL-Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8f Ð² Ñ\81ÐºÐ²Ð¾Ð·Ð½Ð¾Ð¹ Ð´Ñ\83Ð³Ðµ"
+msgstr "Ð² Ð±Ð»Ð¾ÐºÐµ %i Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ñ\81ÐºÐ²Ð¾Ð·Ð½Ñ\8bÑ\85 Ð´Ñ\83Ð³"
  
  #: tree-eh.c:4762
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "BB %i has incorrect edge"
-msgstr "Ð² Ð¿Ð¾Ñ\81Ð»ÐµÐ´Ð½ÐµÐ¼ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð±Ð»Ð¾ÐºÐ° %i Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾ Ñ\83Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð»ÐµÐ½ Ñ\80ÐµÐ³Ð¸Ð¾Ð½"
+msgstr "Ð±Ð»Ð¾Ðº %i Ñ\81Ð¾Ð´ÐµÑ\80Ð¶Ð¸Ñ\82 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\83Ñ\8e Ð´Ñ\83Ð³Ñ\83"
  
  #: tree-eh.c:4768
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "BB %i has incorrect fallthru edge"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f RTL-Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8f Ð² Ñ\81ÐºÐ²Ð¾Ð·Ð½Ð¾Ð¹ Ð´Ñ\83Ð³Ðµ"
+msgstr "Ð±Ð»Ð¾Ðº %i Ñ\81Ð¾Ð´ÐµÑ\80Ð¶Ð¸Ñ\82 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\83Ñ\8e Ñ\81ÐºÐ²Ð¾Ð·Ð½Ñ\83Ñ\8e Ð´Ñ\83Ð³Ñ\83"
  
  #: tree-inline.c:3528
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "function %q+F can never be copied because it receives a non-local goto"
-msgstr "inline-подстановка функции %q+F невозможна, поскольку имеют нелокальные переходы в эту функцию"
+msgstr "функция %q+F не может быть скопирована, поскольку имеют нелокальные переходы в эту функцию"
  
  #: tree-inline.c:3535
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "function %q+F can never be copied because it saves address of local label in a static variable"
-msgstr "inline-подстановка функции %q+F невозможна, поскольку функция использует переменные переменного размера"
+msgstr "функция %q+F не может быть скопирована, поскольку она сохраняет адрес локальной метки в статической переменной"
  
  #: tree-inline.c:3575
  #, gcc-internal-format
  msgid "function %q+F can never be inlined because it uses alloca (override using the always_inline attribute)"
-msgstr "inline-подстановка функции %q+F невозможна, поскольку функция использует alloca (задайте атрибут always_inline)"
+msgstr "inline-подстановка функции %q+F невозможна, поскольку функция использует alloca (что отменяет атрибут always_inline)"
  
  #: tree-inline.c:3589
  #, gcc-internal-format
@@ -23928,9 +25136,9 @@ msgid "function %q+F can never be inlined because it uses attributes conflicting
  msgstr "подстановка функции %q+F невозможна, т.к. она имеет атрибуты, препятствующие inline-подстановке"
  
  #: tree-inline.c:4425
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "inlining failed in call to always_inline %q+F: %s"
-msgstr "inline-Ð¿Ð¾Ð´Ñ\81Ñ\82Ð°Ð½Ð¾Ð²ÐºÐ° Ð¿Ñ\80Ð¸ Ð²Ñ\8bÐ·Ð¾Ð²Ðµ %q+F не выполнена: %s"
+msgstr "inline-Ð¿Ð¾Ð´Ñ\81Ñ\82Ð°Ð½Ð¾Ð²ÐºÐ° Ð´Ð»Ñ\8f Ð²Ñ\8bÐ·Ð¾Ð²Ð° always_inline Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q+F не выполнена: %s"
  
  #: tree-inline.c:4428 tree-inline.c:4448
  #, gcc-internal-format
@@ -23970,9 +25178,9 @@ msgid "unimplemented functionality"
  msgstr "нереализованная функциональность"
  
  #: tree-ssa-loop-niter.c:2921
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "iteration %s invokes undefined behavior"
-msgstr "операция над %qE может дать неопределенный результат"
+msgstr ""
  
  #: tree-ssa-loop-niter.c:2922
  #, fuzzy, gcc-internal-format
@@ -23983,62 +25191,62 @@ msgstr "в данном контексте"
  #: tree-ssa-operands.c:974
  #, gcc-internal-format
  msgid "virtual definition of statement not up-to-date"
-msgstr ""
+msgstr "виртуальное определение оператора не соответствует текущему состоянию"
  
  #: tree-ssa-operands.c:981
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "virtual def operand missing for stmt"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%s"
+msgstr "Ð²Ð¸Ñ\80Ñ\82Ñ\83Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ def Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð°"
  
  #: tree-ssa-operands.c:991
  #, gcc-internal-format
  msgid "virtual use of statement not up-to-date"
-msgstr ""
+msgstr "виртуальное использование оператора не соответствует текущему состоянию"
  
  #: tree-ssa-operands.c:998
  #, gcc-internal-format
  msgid "virtual use operand missing for stmt"
-msgstr ""
+msgstr "отсутствует виртуальный use операнд для оператора"
  
  #: tree-ssa-operands.c:1015
  #, gcc-internal-format
  msgid "excess use operand for stmt"
-msgstr ""
+msgstr "избыточный use операнд для оператора"
  
  #: tree-ssa-operands.c:1025
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use operand missing for stmt"
-msgstr "Ð½Ðµ Ð·Ð°Ð´Ð°Ð½ Ð½Ð¾Ð¼ÐµÑ\80 Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð° Ð¿Ð¾Ñ\81Ð»Ðµ %%-Ð±Ñ\83ÐºÐ²а"
+msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 use Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80а"
  
  #: tree-ssa-operands.c:1032
  #, gcc-internal-format
  msgid "stmt volatile flag not up-to-date"
-msgstr ""
+msgstr "флаг volatile в операторе не соответствует текущему состоянию"
  
  #: tree-ssa-uninit.c:169 varasm.c:328
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD was declared here"
-msgstr "  имя `%#D' объявлено здесь"
+msgstr "%qD было объявлено здесь"
  
  #: tree-ssa-uninit.c:201
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is used uninitialized in this function"
-msgstr "%H%qD используется без инициализации в данной функции"
+msgstr "%qD используется без инициализации в данной функции"
  
  #: tree-ssa-uninit.c:206 tree-ssa-uninit.c:2367
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD may be used uninitialized in this function"
-msgstr "%H%qD, возможно, используется без инициализации в данной функции"
+msgstr "%qD, возможно, используется без инициализации в данной функции"
  
  #: tree-ssa-uninit.c:237
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is used uninitialized in this function"
-msgstr "%H%qD используется без инициализации в данной функции"
+msgstr "%qE используется без инициализации в данной функции"
  
  #: tree-ssa-uninit.c:242
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE may be used uninitialized in this function"
-msgstr "%H%qD, возможно, используется без инициализации в данной функции"
+msgstr "%qE, возможно, используется без инициализации в данной функции"
  
  #: tree-ssa.c:616
  #, gcc-internal-format
@@ -24063,7 +25271,7 @@ msgstr "найдено виртуальное определение для GIMP
  #: tree-ssa.c:641
  #, gcc-internal-format
  msgid "virtual SSA name for non-VOP decl"
-msgstr ""
+msgstr "виртуальное SSA имя для не-VOP декларации"
  
  #: tree-ssa.c:647
  #, gcc-internal-format
@@ -24073,12 +25281,12 @@ msgstr "найдено действительное определение дл
  #: tree-ssa.c:654
  #, gcc-internal-format
  msgid "found a default name with a non-empty defining statement"
-msgstr ""
+msgstr "найдено имя по умолчанию с непустым оператором определения"
  
  #: tree-ssa.c:684
  #, gcc-internal-format
  msgid "RESULT_DECL should be read only when DECL_BY_REFERENCE is set"
-msgstr ""
+msgstr "RESULT_DECL должно читаться только когда установлено DECL_BY_REFERENCE"
  
  #: tree-ssa.c:690
  #, gcc-internal-format, gfc-internal-format
@@ -24146,9 +25354,9 @@ msgid "AUX pointer initialized for edge %d->%d"
  msgstr "инициализирован указатель AUX для дуги %d->%d"
  
  #: tree-ssa.c:982
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "stmt (%p) marked modified after optimization pass: "
-msgstr "оператор (%p) помечен как измененный после прохода оптимизации : "
+msgstr "оператор (%p) помечен как измененный после прохода оптимизации: "
  
  #: tree-ssa.c:1039
  #, gcc-internal-format
@@ -24158,42 +25366,43 @@ msgstr "процедура verify_ssa выявила ошибки"
  #: tree-streamer-in.c:343 tree-streamer-in.c:1138
  #, gcc-internal-format
  msgid "machine independent builtin code out of range"
-msgstr ""
+msgstr "машинно независимый встроенный код вне диапазона"
  
  #: tree-streamer-in.c:349 tree-streamer-in.c:1162
  #, gcc-internal-format
  msgid "target specific builtin not available"
-msgstr ""
+msgstr "специфическая для целевой платформы встроенная функция недоступна"
  
  #: tree-streamer-out.c:500
  #, gcc-internal-format
  msgid "tree bytecode streams do not support machine specific builtin functions on this target"
-msgstr ""
+msgstr "потоки байткода деревьев не поддерживают специфические встроенные функции для этой целевой платформы"
  
  #: tree-vect-generic.c:265
  #, gcc-internal-format
  msgid "vector operation will be expanded piecewise"
-msgstr ""
+msgstr "векторная операция будет выполнена по частям"
  
  #: tree-vect-generic.c:268
  #, gcc-internal-format
  msgid "vector operation will be expanded in parallel"
-msgstr ""
+msgstr "векторная операция будет выполнена параллельно"
  
  #: tree-vect-generic.c:319
  #, gcc-internal-format
  msgid "vector operation will be expanded with a single scalar operation"
-msgstr ""
+msgstr "векторная операция будет выполнена при помощи одной скалярной операции"
  
  #: tree-vect-generic.c:887
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "vector operation will be expanded piecewise"
  msgid "vector condition will be expanded piecewise"
-msgstr ""
+msgstr "векторная операция будет выполнена по частям"
  
  #: tree-vect-generic.c:1304
  #, gcc-internal-format
  msgid "vector shuffling operation will be expanded piecewise"
-msgstr ""
+msgstr "векторная операция перемешивания будет выполнена по частям"
  
  #: tree-vect-loop.c:3379
  #, gcc-internal-format
@@ -24201,54 +25410,55 @@ msgid "vectorization did not happen for a simd loop"
  msgstr ""
  
  #: tree-vrp.c:6500 tree-vrp.c:6540 tree-vrp.c:6621
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "array subscript is above array bounds"
-msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð¿Ñ\80ÐµÐ²Ñ\8bÑ\88Ð°ÐµÑ\82 Ð²ÐµÑ\80Ñ\85Ð½ÐµÐµ Ð³Ñ\80Ð°Ð½Ð¸Ñ\87Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ"
  
  #: tree-vrp.c:6524
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "array subscript is outside array bounds"
-msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð°"
  
  #: tree-vrp.c:6553 tree-vrp.c:6608
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "array subscript is below array bounds"
-msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð¼ÐµÐ½Ñ\8cÑ\88Ðµ Ð½Ð¸Ð¶Ð½ÐµÐ³Ð¾ Ð³Ñ\80Ð°Ð½Ð¸Ñ\87Ð½Ð¾Ð³Ð¾ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f"
  
  #: tree-vrp.c:7462
  #, gcc-internal-format
  msgid "assuming signed overflow does not occur when simplifying conditional to constant"
-msgstr ""
+msgstr "предполагается что не произойдет знакового переполнения при сведении условной операции к константе"
  
  #: tree-vrp.c:7468 tree-vrp.c:9432 tree-vrp.c:9476 tree-vrp.c:9539
  #, gcc-internal-format
  msgid "assuming signed overflow does not occur when simplifying conditional"
-msgstr ""
+msgstr "предполагается что не произойдет знакового переполнения при упрощении условной операции"
  
  #: tree-vrp.c:7512
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "comparison always false due to limited range of data type"
  msgstr "из-за ограниченности диапазона типа данных, результат сравнения всегда ложь"
  
  #: tree-vrp.c:7514
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "comparison always true due to limited range of data type"
  msgstr "из-за ограниченности диапазона типа данных, результат сравнения всегда истина"
  
  #: tree-vrp.c:9031
  #, gcc-internal-format
  msgid "assuming signed overflow does not occur when simplifying %</%> or %<%%%> to %<>>%> or %<&%>"
-msgstr ""
+msgstr "предполагается что не произойдет знакового переполнения при упрощении %</%> или %<%%%> до %<>>%> или %<&%>"
  
  #: tree-vrp.c:9096
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "assuming signed overflow does not occur when simplifying %<abs (X)%> to %<X%> or %<-X%>"
  msgid "assuming signed overflow does not occur when simplifying %<min/max (X,Y)%> to %<X%> or %<Y%>"
-msgstr ""
+msgstr "предполагается что не произойдет знакового переполнения при упрощении %<abs (X)%> до %<X%> или %<-X%>"
  
  #: tree-vrp.c:9149
  #, gcc-internal-format
  msgid "assuming signed overflow does not occur when simplifying %<abs (X)%> to %<X%> or %<-X%>"
-msgstr ""
+msgstr "предполагается что не произойдет знакового переполнения при упрощении %<abs (X)%> до %<X%> или %<-X%>"
  
  #: tree.c:1836
  #, gcc-internal-format
@@ -24261,9 +25471,9 @@ msgid "side-effects element in no-side-effects CONSTRUCTOR"
  msgstr ""
  
  #: tree.c:4839
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ignoring attributes applied to %qT after definition"
-msgstr "Ð¾Ñ\82Ð±Ñ\80Ð¾Ñ\88ÐµÐ½Ñ\8b Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b ÐºÐ»Ð°Ñ\81Ñ\81Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ñ\8bÐµ Ð²Ð½Ðµ ÐµÐ³Ð¾ Ð¾Ð±Ñ\8aÑ\8fÐ²ления"
+msgstr "Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ñ\8b Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b, Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð½Ñ\8bÐµ Ðº %qT Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿Ñ\80ÐµÐ´Ðµления"
  
  #: tree.c:6328
  #, gcc-internal-format
@@ -24324,14 +25534,14 @@ msgid "variable %q+D definition is marked dllimport"
  msgstr "определение переменной %q+D помечено dllimport"
  
  #: tree.c:6482
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "external linkage required for symbol %q+D because of %qE attribute"
-msgstr "символ %q+D должен быть внешним, поскольку задан атрибут %qs"
+msgstr "символ %q+D должен быть внешним, поскольку задан атрибут %qE"
  
  #: tree.c:6496
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE implies default visibility, but %qD has already been declared with a different visibility"
-msgstr "%J%qD повторно декларирован как символ другого вида"
+msgstr "%qE предполагает видимость по умолчанию, но %qD уже был декларирован с другим атрибутом видимости"
  
  #: tree.c:8245
  #, gcc-internal-format
@@ -24359,17 +25569,17 @@ msgid "tree check: expected class %qs, have %qs (%s) in %s, at %s:%d"
  msgstr "дерево: ожидался класс %qs, обнаружен %qs (%s) в %s, на %s:%d"
  
  #: tree.c:9740
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "tree check: did not expect class %qs, have %qs (%s) in %s, at %s:%d"
-msgstr "дерево: ожидался класс %qs, обнаружен %qs (%s) в %s, на %s:%d"
+msgstr "Ð´ÐµÑ\80ÐµÐ²Ð¾: Ð½Ðµ Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f ÐºÐ»Ð°Ñ\81Ñ\81 %qs, Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶ÐµÐ½ %qs (%s) Ð² %s, Ð½Ð° %s:%d"
  
  #: tree.c:9753
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "tree check: expected omp_clause %s, have %s in %s, at %s:%d"
-msgstr "Ð´ÐµÑ\80ÐµÐ²Ð¾: Ð½Ðµ Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð½Ð¸Ñ\87ÐµÐ³Ð¾ Ð¸Ð· %s, обнаружено %s в %s, на %s:%d"
+msgstr "Ð´ÐµÑ\80ÐµÐ²Ð¾: Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c omp_clause %s, обнаружено %s в %s, на %s:%d"
  
  #: tree.c:9813
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "tree check: expected tree that contains %qs structure, have %qs in %s, at %s:%d"
  msgstr "дерево: ожидалось дерево, содержащее структуру %qs, обнаружено %qs в %s, на %s:%d"
  
@@ -24390,34 +25600,36 @@ msgid "tree check: accessed operand %d of %s with %d operands in %s, at %s:%d"
  msgstr "дерево: доступ к операнду %d функции %s с %d операндами в %s, в %s:%d"
  
  #: tree.c:9865
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "tree check: accessed operand %d of omp_clause %s with %d operands in %s, at %s:%d"
-msgstr "дерево: доступ к операнду %d функции %s с %d операндами в %s, в %s:%d"
+msgstr "дерево: доступ к операнду %d функции omp_clause %s с %d операндами в %s, в %s:%d"
  
  #: tree.c:12584
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is deprecated: %s"
  msgid "%qD is deprecated: %s"
-msgstr "имя %qs будет исключено в будущих версиях"
+msgstr "%qE устаревшее: %s"
  
  #: tree.c:12587
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is deprecated"
  msgid "%qD is deprecated"
-msgstr "имя %qs будет исключено в будущих версиях"
+msgstr "имя %qE будет исключено в будущих версиях"
  
  #: tree.c:12611 tree.c:12633
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is deprecated: %s"
-msgstr "имя %qs будет исключено в будущих версиях"
+msgstr "%qE устаревшее: %s"
  
  #: tree.c:12614 tree.c:12636
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is deprecated"
-msgstr "имя %qs будет исключено в будущих версиях"
+msgstr "имя %qE будет исключено в будущих версиях"
  
  #: tree.c:12620 tree.c:12641
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "type is deprecated: %s"
-msgstr "поддержка данного типа будет исключена в будущих версиях"
+msgstr "поддержка данного типа будет исключена в будущих версиях: %s"
  
  #: tree.c:12623 tree.c:12644
  #, gcc-internal-format
@@ -24502,9 +25714,9 @@ msgid "type variant has different TYPE_FIELDS"
  msgstr ""
  
  #: tree.c:13211
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "first mismatch is field"
-msgstr "%s:штамп не соответствует графическому файлу\n"
+msgstr ""
  
  #: tree.c:13213
  #, gcc-internal-format
@@ -24528,13 +25740,15 @@ msgstr ""
  
  #: tree.c:13241
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not compatible with %qD"
  msgid "type is not compatible with its vairant"
-msgstr "отсутствует декларация %qD в %qD"
+msgstr "%qD не совместим с %qD"
  
  #: tree.c:13540
  #, fuzzy, gcc-internal-format
+#| msgid "environment variable %qs not defined"
  msgid "Main variant is not defined"
-msgstr "переменная окружения \"%s\" не определена"
+msgstr "переменная окружения %qs не определена"
  
  #: tree.c:13545
  #, gcc-internal-format
@@ -24638,13 +25852,15 @@ msgstr ""
  
  #: tree.c:13772
  #, fuzzy, gcc-internal-format
+#| msgid "size of array %qE has non-integer type"
  msgid "Array TYPE_DOMAIN is not integer type"
-msgstr "размер массива %qs имеет не целочисленный тип"
+msgstr "размер массива %qE имеет не целочисленный тип"
  
  #: tree.c:13781
  #, fuzzy, gcc-internal-format
+#| msgid "field %qE has incomplete type"
  msgid "TYPE_FIELDS defined in incomplete type"
-msgstr "поле %qs имеет неполный тип"
+msgstr "поле %qE имеет неполный тип"
  
  #: tree.c:13801
  #, gcc-internal-format
@@ -24703,48 +25919,50 @@ msgstr ""
  
  #: tree.c:13910
  #, fuzzy, gcc-internal-format
+#| msgid "verify_gimple failed"
  msgid "verify_type failed"
-msgstr "процедура verify_stmts выявила ошибки"
+msgstr "процедура verify_gimple выявила ошибки"
  
  #: value-prof.c:528
  #, gcc-internal-format
  msgid "dead histogram"
-msgstr ""
+msgstr "мертвая гистограмма"
  
  #: value-prof.c:557
  #, gcc-internal-format
  msgid "Histogram value statement does not correspond to the statement it is associated with"
-msgstr ""
+msgstr "Оператор значения гистограммы не соответствует оператору, с которым она ассоциирована"
  
  #: value-prof.c:569
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "verify_histograms failed"
-msgstr "процедура verify_stmts выявила ошибки"
+msgstr "процедура verify_histograms выявила ошибки"
  
  #: value-prof.c:626
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "corrupted value profile: %s profile counter (%d out of %d) inconsistent with basic-block count (%d)"
-msgstr "%HИспорчен профиль значений: общий счётчик профиля %s (%d) не соответствует BB count (%d)"
+msgstr "Испорчен профиль значений: общий счётчик профиля %s (%d из %d) не соответствует счетчику блока (%d)"
  
  #: var-tracking.c:7128
  #, gcc-internal-format
  msgid "variable tracking size limit exceeded with -fvar-tracking-assignments, retrying without"
-msgstr ""
+msgstr "лимит памяти для отслеживания переменных превышен с -fvar-tracking-assignments, повторная попытка без этого ключа"
  
  #: var-tracking.c:7132
  #, gcc-internal-format
  msgid "variable tracking size limit exceeded"
-msgstr ""
+msgstr "лимит памяти для отслеживания переменных превышен"
  
  #: varasm.c:323
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%+D causes a section type conflict with %D"
-msgstr "%+D создает конфликт типов секций"
+msgstr "%+D создает конфликт типов секций с %D"
  
  #: varasm.c:326
  #, fuzzy, gcc-internal-format
+#| msgid "%+D causes a section type conflict with %D"
  msgid "section type conflict with %D"
-msgstr "%+D создает конфликт типов секций"
+msgstr "%+D создает конфликт типов секций с %D"
  
  #: varasm.c:331
  #, gcc-internal-format
@@ -24779,14 +25997,14 @@ msgid "data type of %q+D isn%'t suitable for a register"
  msgstr "данные типа %q+D нельзя поместить на регистр"
  
  #: varasm.c:1371
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the register specified for %q+D cannot be accessed by the current target"
-msgstr "Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80, Ð·Ð°Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð´Ð»Ñ\8f %q+D, Ð½Ðµ Ð³Ð¾Ð´Ð¸Ñ\82Ñ\81Ñ\8f Ð´Ð»Ñ\8f Ñ\8dÑ\82Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° Ð´Ð°Ð½Ð½Ñ\8bÑ\85"
+msgstr "Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80, Ð·Ð°Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð´Ð»Ñ\8f %q+D, Ð½Ðµ Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿ÐµÐ½ Ð´Ð»Ñ\8f Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð¹ Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð¹ Ð¿Ð»Ð°Ñ\82Ñ\84Ð¾Ñ\80Ð¼Ñ\8b"
  
  #: varasm.c:1374
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the register specified for %q+D is not general enough to be used as a register variable"
-msgstr "регистр назначен для двух глобальных регистровых переменных"
+msgstr "регистр, заданный для %q+D, не достаточно общий для использования в качестве регистровой переменной"
  
  #: varasm.c:1377
  #, gcc-internal-format
@@ -24824,9 +26042,9 @@ msgid "storage size of %q+D isn%'t known"
  msgstr "размер %q+D в памяти неизвестен"
  
  #: varasm.c:4750
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "initializer for integer/fixed-point value is too complicated"
-msgstr "слишком сложное инициализирующее выражение для целого"
+msgstr "слишком сложное инициализирующее выражение для целого или значения с фиксированной точкой"
  
  #: varasm.c:4755
  #, gcc-internal-format
@@ -24834,9 +26052,9 @@ msgid "initializer for floating value is not a floating constant"
  msgstr "инициализирующее выражение для плавающего не является плавающей константой"
  
  #: varasm.c:5064
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid initial value for member %qE"
-msgstr "некорректное начальное значение для элемента %qs"
+msgstr "некорректное начальное значение для элемента %qE"
  
  #: varasm.c:5324
  #, fuzzy, gcc-internal-format
@@ -24860,14 +26078,15 @@ msgid "only weak aliases are supported in this configuration"
  msgstr "в данной конфигурации поддерживаются только слабые алиасы"
  
  #: varasm.c:5634
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "weakref is not supported in this configuration"
-msgstr "%Jweakref в данной конфигурации не поддерживается"
+msgstr "weakref в данной конфигурации не поддерживается"
  
  #: varasm.c:5666
  #, fuzzy, gcc-internal-format
+#| msgid "nested functions not supported on this target"
  msgid "ifunc is not supported on this target"
-msgstr "Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ñ\8bÐµ Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b не поддерживаются для этой платформы"
+msgstr "Ð²Ð»Ð¾Ð¶ÐµÐ½Ð½Ñ\8bÐµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ не поддерживаются для этой платформы"
  
  #: varasm.c:5724
  #, gcc-internal-format
@@ -24875,19 +26094,19 @@ msgid "weakref %q+D ultimately targets itself"
  msgstr "слабая ссылка %q+D в конечном счёте направлена на себя"
  
  #: varasm.c:5726
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "weakref %q+D must have static linkage"
-msgstr "недопустимая декларация статического элемента-функции %qD"
+msgstr "слабая ссылка %q+D должна иметь статическое связывание"
  
  #: varasm.c:5733
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "alias definitions not supported in this configuration"
-msgstr "%Jв данной конфигурации определения алиасов не поддерживаются"
+msgstr "в данной конфигурации определения алиасов не поддерживаются"
  
  #: varasm.c:5741
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ifunc is not supported in this configuration"
-msgstr "-m%s в данной конфигурации не поддерживается"
+msgstr "ifunc в данной конфигурации не поддерживается"
  
  #: varasm.c:5959 config/sol2.c:157 config/i386/winnt.c:260
  #, gcc-internal-format
@@ -24903,29 +26122,34 @@ msgstr "отсутствует sclass для %s stab (0x%x)"
  #: lto-streamer.h:1017
  #, gcc-internal-format, gfc-internal-format
  msgid "bytecode stream: expected tag %s instead of %s"
-msgstr ""
+msgstr "поток байткода: ожидался тег %s, а не %s"
  
  #: lto-streamer.h:1027
  #, gcc-internal-format, gfc-internal-format
  msgid "bytecode stream: tag %s is not in the expected range [%s, %s]"
-msgstr ""
+msgstr "поток байткода: тег %s вне ожидаемого диапазона [%s, %s]"
  
  #: c-family/array-notation-common.c:71
  #, fuzzy, gcc-internal-format
+#| msgid "case label is not an integer constant expression"
  msgid "__sec_implicit_index parameter must be an integer constant expression"
-msgstr "размер массива не является целочисленным константным выражением"
+msgstr "case-метка не является целочисленным константным выражением"
  
+#
  #: c-family/array-notation-common.c:107
  #, fuzzy, gcc-internal-format
+#| msgid "type mismatch in not expression"
  msgid "length mismatch in expression"
-msgstr "несоответствие типов в условном выражении"
+msgstr "несоответствие типов в not выражении"
  
  #: c-family/array-notation-common.c:282 c-family/array-notation-common.c:310
  #: c/c-array-notation.c:731 cp/cp-array-notation.c:611
  #, fuzzy, gcc-internal-format
+#| msgid "  mismatched types %qT and %qT"
  msgid "rank mismatch between %qE and %qE"
-msgstr "сравнение между типами `%#T' и `%#T'"
+msgstr "  несоответствие типов %qT и %qT"
  
+#
  #. Here the original expression is printed as a "heads-up"
  #. to the programmer.  This is because since there is no
  #. location information for the offending argument, the
@@ -24934,8 +26158,9 @@ msgstr "сравнение между типами `%#T' и `%#T'"
  #. may lie in the original expression.
  #: c-family/array-notation-common.c:291
  #, fuzzy, gcc-internal-format
+#| msgid "type mismatch in not expression"
  msgid "rank mismatch in expression %qE"
-msgstr "несоответствие типов в условном выражении"
+msgstr "несоответствие типов в not выражении"
  
  #: c-family/array-notation-common.c:667
  #, gcc-internal-format
@@ -24944,18 +26169,21 @@ msgstr ""
  
  #: c-family/c-cilkplus.c:38
  #, fuzzy, gcc-internal-format
+#| msgid "iteration variable %qE should be private"
  msgid "iteration variable cannot be volatile"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "итерационная переменная %qE должна быть private"
  
  #: c-family/c-cilkplus.c:81
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%qE appears more than once in data clauses"
  msgid "variable appears in more than one clause"
-msgstr ""
+msgstr "%qE встречается более одного раза в конструкции данных"
  
  #: c-family/c-cilkplus.c:83
  #, fuzzy, gcc-internal-format
+#| msgid "struct defined here"
  msgid "other clause defined here"
-msgstr "Ñ\8dÑ\82Ð¾ Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ `%#D'"
+msgstr "Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ñ\83Ñ\80Ð° Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð° Ð·Ð´ÐµÑ\81Ñ\8c"
  
  #: c-family/c-common.c:1016
  #, gcc-internal-format
@@ -24984,9 +26212,9 @@ msgid "floating point overflow in expression"
  msgstr "переполнение при вычислении выражения с плавающей точкой"
  
  #: c-family/c-common.c:1170
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "fixed-point overflow in expression"
-msgstr "переполнение при вычислении выражения с плавающей точкой"
+msgstr "переполнение при вычислении выражения с фиксированной точкой"
  
  #: c-family/c-common.c:1174
  #, gcc-internal-format
@@ -24994,44 +26222,46 @@ msgid "vector overflow in expression"
  msgstr "переполнение при вычислении векторного выражения"
  
  #: c-family/c-common.c:1180
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "complex integer overflow in expression"
-msgstr "переполнение при вычислении целочисленного выражения"
+msgstr "переполнение при вычислении комплексного целочисленного выражения"
  
  #: c-family/c-common.c:1183
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "complex floating point overflow in expression"
-msgstr "переполнение при вычислении выражения с плавающей точкой"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ ÐºÐ¾Ð¼Ð¿Ð»ÐµÐºÑ\81Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ñ\81 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹"
  
  #: c-family/c-common.c:1236
  #, gcc-internal-format
  msgid "logical %<or%> applied to non-boolean constant"
-msgstr ""
+msgstr "логическое %<или%> применено к не булевой константе"
  
  #: c-family/c-common.c:1239
  #, gcc-internal-format
  msgid "logical %<and%> applied to non-boolean constant"
-msgstr ""
+msgstr "логическое %<и%> применено к не булевой константе"
  
  #: c-family/c-common.c:1309
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "logical %<or%> of collectively exhaustive tests is always true"
-msgstr "%<или%> от двух взаимно исключающих сравнений на равенство - всегда 0"
+msgstr "логическое %<или%> от совокупности исчерпывающих сравнений - всегда истина"
  
  #: c-family/c-common.c:1313
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "logical %<and%> of mutually exclusive tests is always false"
-msgstr "%<или%> от двух взаимно исключающих сравнений на равенство - всегда 0"
+msgstr "логическое %<и%> от взаимно исключающих сравнений - всегда ложь"
  
  #: c-family/c-common.c:1323
  #, fuzzy, gcc-internal-format
+#| msgid "invalid operand in unary expression"
  msgid "logical %<or%> of equal expressions"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %s"
+msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ñ\83Ð½Ð°Ñ\80Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
  
  #: c-family/c-common.c:1326
  #, fuzzy, gcc-internal-format
+#| msgid "logical %<and%> of mutually exclusive tests is always false"
  msgid "logical %<and%> of equal expressions"
-msgstr "%<или%> от двух взаимно исключающих сравнений на равенство - всегда 0"
+msgstr "логическое %<и%> от взаимно исключающих сравнений - всегда ложь"
  
  #: c-family/c-common.c:1401
  #, fuzzy, gcc-internal-format
@@ -25173,38 +26403,39 @@ msgstr "%q+D может быть функцией с двумя аргумент
  
  #: c-family/c-common.c:1957
  #, fuzzy, gcc-internal-format
+#| msgid "field %qE declared as a function"
  msgid "%q+D declared as variadic function"
-msgstr "поле %qs описано как функция"
+msgstr "поле %qE описано как функция"
  
  #: c-family/c-common.c:2025
  #, gcc-internal-format
  msgid "use -flax-vector-conversions to permit conversions between vectors with differing element types or numbers of subparts"
-msgstr ""
+msgstr "используйте -flax-vector-conversions, чтобы разрешить преобразования между векторами с элементами различных типов или с разным числом компонентов"
  
  #: c-family/c-common.c:2065
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "__builtin_shuffle last argument must be an integer vector"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¿Ð¾Ñ\81Ð»ÐµÐ´Ð½Ð¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 __builtin_shuffle Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bÐ¼ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð¾м"
  
  #: c-family/c-common.c:2074
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "__builtin_shuffle arguments must be vectors"
-msgstr "Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %<__builtin_longjmp%> Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 1"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b __builtin_shuffle Ð´Ð¾Ð»Ð¶Ð½Ñ\8b Ð±Ñ\8bÑ\82Ñ\8c Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð°Ð¼Ð¸"
  
  #: c-family/c-common.c:2081
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "__builtin_shuffle argument vectors must be of the same type"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b __builtin_shuffle Ð´Ð¾Ð»Ð¶Ð½Ñ\8b Ð±Ñ\8bÑ\82Ñ\8c Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð°"
  
  #: c-family/c-common.c:2092
  #, gcc-internal-format
  msgid "__builtin_shuffle number of elements of the argument vector(s) and the mask vector should be the same"
-msgstr ""
+msgstr "число элементов в векторных аргументах __builtin_shuffle и в векторе-маске должно быть одинаково"
  
  #: c-family/c-common.c:2102
  #, gcc-internal-format
  msgid "__builtin_shuffle argument vector(s) inner type must have the same size as inner type of the mask"
-msgstr ""
+msgstr "внутренний тип векторных аргументов __builtin_shuffle должен иметь тот же размер, что и внутренний размер маски"
  
  #: c-family/c-common.c:2329
  #, gcc-internal-format
@@ -25214,27 +26445,27 @@ msgstr "неявное приведение отрицательного цел
  #: c-family/c-common.c:2335
  #, gcc-internal-format
  msgid "conversion of unsigned constant value to negative integer"
-msgstr ""
+msgstr "преобразование беззнаковой константы в отрицательное целое"
  
  #: c-family/c-common.c:2486 c-family/c-common.c:2548
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to %qT from %qT may change the sign of the result"
-msgstr "преобразование %qE из %qT в %qT неоднозначно"
+msgstr "преобразование %qT из %qT может изменить знак результата"
  
  #: c-family/c-common.c:2606
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to %qT from boolean expression"
-msgstr "преобразование %qE из %qT в %qT неоднозначно"
+msgstr "преобразование в %qT из булева выражения"
  
  #: c-family/c-common.c:2615 c-family/c-common.c:2619
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to %qT alters %qT constant value"
-msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð¾"
+msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð² %qT Ð¸Ð·Ð¼ÐµÐ½Ñ\8fÐµÑ\82 ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ %qT"
  
  #: c-family/c-common.c:2639 c-family/c-common.c:2647
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to %qT from %qT may alter its value"
-msgstr "преобразование %qE из %qT в %qT неоднозначно"
+msgstr "преобразование в %qT из %qT может изменить значение"
  
  #: c-family/c-common.c:2643
  #, fuzzy, gcc-internal-format
@@ -25285,12 +26516,12 @@ msgstr "верхняя граница диапазона case-метки бол
  #: c-family/c-common.c:3336
  #, gcc-internal-format
  msgid "GCC cannot support operators with integer types and fixed-point types that have too many integral and fractional bits together"
-msgstr ""
+msgstr "GCC не поддерживает операторы с целыми типами и типами с фиксированной точкой, имеющих в совокупности слишком много бит в целой и дробной частях"
  
  #: c-family/c-common.c:3866
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operands to binary %s (have %qT and %qT)"
-msgstr "неверные операнды бинарной операции %s"
+msgstr "неверные операнды бинарной операции %s (%qT и %qT)"
  
  #: c-family/c-common.c:4116
  #, gcc-internal-format
@@ -25323,14 +26554,15 @@ msgid "pointer to a function used in arithmetic"
  msgstr "в арифметическом выражении использован указатель на функцию"
  
  #: c-family/c-common.c:4480
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the address of %qD will always evaluate as %<true%>"
-msgstr "адрес %qD всегда будет %<истина%>"
+msgstr "адрес %qD всегда будет иметь значение %<истина%>"
  
  #: c-family/c-common.c:4562
  #, fuzzy, gcc-internal-format
+#| msgid "the address of %qD will always evaluate as %<true%>"
  msgid "the compiler can assume that the address of %qD will always evaluate to %<true%>"
-msgstr "адрес %qD всегда будет %<истина%>"
+msgstr "адрес %qD всегда будет иметь значение %<истина%>"
  
  #: c-family/c-common.c:4589 cp/semantics.c:660 cp/typeck.c:8448
  #, gcc-internal-format
@@ -25348,14 +26580,14 @@ msgid "invalid application of %<sizeof%> to a function type"
  msgstr "недопустимое применение %<sizeof%> к типу функции"
  
  #: c-family/c-common.c:4878
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ does not permit %<alignof%> applied to a function type"
-msgstr "ISO C++ не поддерживает назначенные инициализаторы"
+msgstr "ISO C++ не разрешает применение %<alignof%> к типу функции"
  
  #: c-family/c-common.c:4881
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C does not permit %<_Alignof%> applied to a function type"
-msgstr "ISO C++ не поддерживает назначенные инициализаторы"
+msgstr "ISO C++ не разрешает применение %<_Alignof%> к типу функции"
  
  #: c-family/c-common.c:4892
  #, gcc-internal-format
@@ -25363,14 +26595,14 @@ msgid "invalid application of %qs to a void type"
  msgstr "недопустимое применение %qs к типу void"
  
  #: c-family/c-common.c:4901
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid application of %qs to incomplete type %qT"
-msgstr "некорректное применение %qs к неполному типу %qT "
+msgstr "некорректное применение %qs к неполному типу %qT"
  
  #: c-family/c-common.c:4909
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid application of %qs to array type %qT of incomplete element type"
-msgstr "некорректное применение %qs к неполному типу %qT "
+msgstr "некорректное применение %qs к типу массива %qT с неполным типом элементов"
  
  #: c-family/c-common.c:4951
  #, gcc-internal-format
@@ -25403,9 +26635,9 @@ msgid "duplicate (or overlapping) case value"
  msgstr "повтор (или перекрытие) case-значений"
  
  #: c-family/c-common.c:6128
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "this is the first entry overlapping that value"
-msgstr "%Jэто первое case-значение, с которым перекрывается данное значение"
+msgstr "это первое case-значение, с которым перекрывается данное значение"
  
  #: c-family/c-common.c:6132
  #, gcc-internal-format
@@ -25413,9 +26645,9 @@ msgid "duplicate case value"
  msgstr "повтор case-значения,"
  
  #: c-family/c-common.c:6133 c-family/c-common.c:12710
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "previously used here"
-msgstr "%Jкоторое ранее использовано здесь"
+msgstr "которое ранее использовано здесь"
  
  #: c-family/c-common.c:6137
  #, gcc-internal-format
@@ -25423,24 +26655,24 @@ msgid "multiple default labels in one switch"
  msgstr "несколько меток default в операторе switch"
  
  #: c-family/c-common.c:6139
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "this is the first default label"
-msgstr "%Jэто первая метка default"
+msgstr "это первая метка default"
  
  #: c-family/c-common.c:6183
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "case value %qs not in enumerated type"
-msgstr "%Jcase-значение %qs не принадлежит к перечислимому типу"
+msgstr "case-значение %qs не принадлежит к перечислимому типу"
  
  #: c-family/c-common.c:6188
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "case value %qs not in enumerated type %qT"
-msgstr "%Jcase-значение %qs не принадлежит к перечислимому типу %qT"
+msgstr "case-значение %qs не принадлежит к перечислимому типу %qT"
  
  #: c-family/c-common.c:6249
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "switch missing default case"
-msgstr "%Hоператор switch без метки default"
+msgstr "оператор switch без метки default"
  
  #: c-family/c-common.c:6294
  #, gcc-internal-format
@@ -25448,9 +26680,9 @@ msgid "switch condition has boolean value"
  msgstr ""
  
  #: c-family/c-common.c:6367
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "enumeration value %qE not handled in switch"
-msgstr "%Hв переключателе пропущено значение %qE перечислимого типа"
+msgstr "в переключателе пропущено значение %qE перечислимого типа"
  
  #: c-family/c-common.c:6393
  #, gcc-internal-format
@@ -25464,19 +26696,21 @@ msgstr "атрибут %qE для поля типа %qT проигнориров
  
  #: c-family/c-common.c:6684 c-family/c-common.c:6712 c-family/c-common.c:6808
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute conflicts with attribute %s"
  msgid "%qE attribute ignored due to conflict with attribute %qs"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "атрибут %qE конфликтует с атрибутом %s"
  
  #: c-family/c-common.c:6872 c-family/c-common.c:6878 c-family/c-common.c:9429
  #: c-family/c-common.c:9451 c-family/c-common.c:9457
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute conflicts with attribute %s"
  msgid "%qE attribute ignored due to conflict with %qs attribute"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "атрибут %qE конфликтует с атрибутом %s"
  
  #: c-family/c-common.c:6934 lto/lto-lang.c:248
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute has no effect on unit local functions"
-msgstr "%qE атрибут действует только в public-объектах"
+msgstr "атрибут %qE не действует для локальных функций"
  
  #: c-family/c-common.c:7086
  #, gcc-internal-format
@@ -25485,8 +26719,9 @@ msgstr "%qE атрибут действует только в public-объек
  
  #: c-family/c-common.c:7115
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute only applies to variables"
  msgid "%qE attribute only affects top level objects"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%qE атрибут применим только к переменным"
  
  #: c-family/c-common.c:7169
  #, gcc-internal-format
@@ -25499,39 +26734,39 @@ msgid "scalar_storage_order argument must be one of \"big-endian\" or \"little-e
  msgstr ""
  
  #: c-family/c-common.c:7282
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "destructor priorities are not supported"
-msgstr "\"трамплины\" не поддерживаются"
+msgstr "приоритеты деструкторов не поддерживаются"
  
  #: c-family/c-common.c:7284
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "constructor priorities are not supported"
-msgstr "\"трамплины\" не поддерживаются"
+msgstr "приоритеты конструкторов не поддерживаются"
  
  #: c-family/c-common.c:7306
  #, gcc-internal-format, gfc-internal-format
  msgid "destructor priorities from 0 to %d are reserved for the implementation"
-msgstr ""
+msgstr "приоритеты деструкторов от 0 до %d зарезервированы для реализации"
  
  #: c-family/c-common.c:7311
  #, gcc-internal-format, gfc-internal-format
  msgid "constructor priorities from 0 to %d are reserved for the implementation"
-msgstr ""
+msgstr "приоритеты конструкторов от 0 до %d зарезервированы для реализации"
  
  #: c-family/c-common.c:7319
  #, gcc-internal-format, gfc-internal-format
  msgid "destructor priorities must be integers from 0 to %d inclusive"
-msgstr ""
+msgstr "приоритеты деструкторов должны быть целыми от 0 до %d включительно"
  
  #: c-family/c-common.c:7322
  #, gcc-internal-format, gfc-internal-format
  msgid "constructor priorities must be integers from 0 to %d inclusive"
-msgstr ""
+msgstr "приоритеты конструкторов должны быть целыми от 0 до %d включительно"
  
  #: c-family/c-common.c:7478
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unknown machine mode %qE"
-msgstr "неизвестная машинный режим %qs"
+msgstr "неизвестная машинный режим %qE"
  
  #: c-family/c-common.c:7507
  #, gcc-internal-format
@@ -25556,7 +26791,7 @@ msgstr "неизвестная машинный режим %qs для указа
  #: c-family/c-common.c:7547
  #, gcc-internal-format
  msgid "signedness of type and machine mode %qs don%'t match"
-msgstr ""
+msgstr "знаковость типа и машинной моды %qs не соответствуют друг другу"
  
  #: c-family/c-common.c:7558
  #, gcc-internal-format
@@ -25574,9 +26809,9 @@ msgid "mode %qs applied to inappropriate type"
  msgstr "режим %qs применен к неподходящему типу"
  
  #: c-family/c-common.c:7617
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "section attributes are not supported for this target"
-msgstr "%Jатрибут section для данной платформы не поддерживается"
+msgstr "атрибут section для данной платформы не поддерживается"
  
  #: c-family/c-common.c:7625
  #, gcc-internal-format
@@ -25585,13 +26820,14 @@ msgstr "атрибут section для %q+D недопустим"
  
  #: c-family/c-common.c:7631
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute argument not a string constant"
  msgid "section attribute argument not a string constant"
-msgstr "аргумент атрибута %qs не является строковой константой"
+msgstr "аргумент атрибута %qE не строковая константа"
  
  #: c-family/c-common.c:7640
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "section attribute cannot be specified for local variables"
-msgstr "%Jатрибут section недопустим для локальных переменных"
+msgstr "атрибут section недопустим для локальных переменных"
  
  #: c-family/c-common.c:7650 config/bfin/bfin.c:4773 config/bfin/bfin.c:4824
  #: config/bfin/bfin.c:4850 config/bfin/bfin.c:4863
@@ -25600,14 +26836,14 @@ msgid "section of %q+D conflicts with previous declaration"
  msgstr "атрибут section, заданный для %q+D, противоречит предшествующей декларации"
  
  #: c-family/c-common.c:7658
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "section of %q+D cannot be overridden"
-msgstr "`%#D' и `%#D' не могут быть перегружены"
+msgstr "секция %q+D не может быть переопределена"
  
  #: c-family/c-common.c:7684
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "requested alignment is not an integer constant"
-msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f константой"
+msgstr "Ð·Ð°Ð¿Ñ\80Ð¾Ñ\88ÐµÐ½Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ð¾Ð¹ константой"
  
  #: c-family/c-common.c:7692
  #, fuzzy, gcc-internal-format
@@ -25622,6 +26858,7 @@ msgstr "выравнивание слишком велико"
  
  #: c-family/c-common.c:7780
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "requested alignment is too large"
  msgid "requested alignment %d is larger than %d"
  msgstr "выравнивание слишком велико"
  
@@ -25633,42 +26870,43 @@ msgstr "нельзя задавать выравнивание для %q+D"
  #: c-family/c-common.c:7864
  #, gcc-internal-format
  msgid "alignment for %q+D was previously specified as %d and may not be decreased"
-msgstr ""
+msgstr "выравнивание для %q+D ранее было определено как %d и не может быть уменьшено"
  
  #: c-family/c-common.c:7868
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "alignment for %q+D must be at least %d"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð´Ð»Ñ\8f %q+D Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c Ð½Ðµ Ð¼ÐµÐ½ÐµÐµ %d"
  
  #: c-family/c-common.c:7893
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "inline function %q+D declared weak"
-msgstr "вложенная функция %q+D объявлена, но нигде не определена"
+msgstr "inline функция %q+D объявлена weak"
  
  #: c-family/c-common.c:7898
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "indirect function %q+D cannot be declared weak"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs ÐºÐ°Ðº %<mutable%>"
+msgstr "ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»ÐµÐ½Ð° weak"
  
  #: c-family/c-common.c:7922
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute only applies to functions"
  msgid "%qE attribute is only applicable on functions"
-msgstr "атрибут %qs допустим только для функций"
+msgstr "%qE атрибут применим только к функциям"
  
  #: c-family/c-common.c:7953
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q+D defined both normally and as %qE attribute"
-msgstr "%q+D Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¾ ÐºÐ°Ðº Ð¾Ð±Ñ\8bÑ\87Ð½Ð¾Ðµ Ð¸Ð¼Ñ\8f Ð¸ ÐºÐ°Ðº alias"
+msgstr "%q+D Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¾ Ð¾Ð±Ñ\8bÑ\87Ð½Ñ\8bÐ¼ Ð¾Ð±Ñ\80Ð°Ð·Ð¾Ð¼ Ð¸ ÐºÐ°Ðº Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE"
  
  #: c-family/c-common.c:7961
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "weak %q+D cannot be defined %qE"
-msgstr "декларация %q+#D недопустима,"
+msgstr "weak %q+D не может быть определено %qE"
  
  #: c-family/c-common.c:7978 c-family/c-common.c:8522
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "attribute %qE argument not a string"
-msgstr "аргумент атрибута %qs не является строковой константой"
+msgstr "аргумент атрибута %qE не является строковой константой"
  
  #: c-family/c-common.c:8008
  #, fuzzy, gcc-internal-format
@@ -25683,14 +26921,14 @@ msgid "%+D declared ifunc after being used"
  msgstr "%q+D: inline-декларация после вызова"
  
  #: c-family/c-common.c:8061
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "indirect function %q+D cannot be declared weakref"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs ÐºÐ°Ðº %<mutable%>"
+msgstr "ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q+D Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»ÐµÐ½Ð° ÐºÐ°Ðº weakref"
  
  #: c-family/c-common.c:8083
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "weakref attribute must appear before alias attribute"
-msgstr "%Jатрибут weakref должен задаваться до атрибута alias"
+msgstr "атрибут weakref должен задаваться до атрибута alias"
  
  #: c-family/c-common.c:8095
  #, fuzzy, gcc-internal-format
@@ -25704,9 +26942,9 @@ msgid "%qE attribute ignored on non-class types"
  msgstr "атрибут %qE для не классовых типов игнорируется"
  
  #: c-family/c-common.c:8125
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute ignored because %qT is already defined"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð´Ð»Ñ\8f Ð½Ðµ ÐºÐ»Ð°Ñ\81Ñ\81Ð¾Ð²Ñ\8bÑ\85 Ñ\82Ð¸Ð¿Ð¾Ð² Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83ÐµÑ\82Ñ\81Ñ\8f, Ð¿Ð¾Ñ\81ÐºÐ¾Ð»Ñ\8cÐºÑ\83 %qT Ñ\83Ð¶Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½"
  
  #: c-family/c-common.c:8138
  #, gcc-internal-format
@@ -25724,14 +26962,14 @@ msgid "visibility argument must be one of \"default\", \"hidden\", \"protected\"
  msgstr "аргумент атрибута visibility должен быть \"default\", \"hidden\", \"protected\" или \"internal\""
  
  #: c-family/c-common.c:8177
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD redeclared with different visibility"
-msgstr "%J%qD повторно декларирован как символ другого вида"
+msgstr "%qD повторно декларирован с другим атрибутом видимости"
  
  #: c-family/c-common.c:8180 c-family/c-common.c:8184
  #, gcc-internal-format
  msgid "%qD was declared %qs which implies default visibility"
-msgstr ""
+msgstr "%qD был объявлен %qs, что подразумевает значение видимости по умолчанию"
  
  #: c-family/c-common.c:8267
  #, gcc-internal-format
@@ -25745,24 +26983,26 @@ msgstr "аргумент атрибута tls_model должен быть \"loca
  
  #: c-family/c-common.c:8300 c-family/c-common.c:8599 c-family/c-common.c:9646
  #: config/m32c/m32c.c:2932
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute applies only to functions"
-msgstr "%J%qE: атрибут допустим только для функций"
+msgstr "%qE: атрибут допустим только для функций"
  
  #: c-family/c-common.c:8348
  #, gcc-internal-format
  msgid "alloc_size parameter outside range"
-msgstr ""
+msgstr "параметр alloc_size вне диапазона"
  
  #: c-family/c-common.c:8373
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "alloc_size parameter outside range"
  msgid "alloc_align parameter outside range"
-msgstr ""
+msgstr "параметр alloc_size вне диапазона"
  
  #: c-family/c-common.c:8397
  #, fuzzy, gcc-internal-format
+#| msgid "requested alignment is not an integer constant"
  msgid "assume_aligned parameter not integer constant"
-msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f константой"
+msgstr "Ð·Ð°Ð¿Ñ\80Ð¾Ñ\88ÐµÐ½Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ð¾Ð¹ константой"
  
  #: c-family/c-common.c:8508 c/c-parser.c:16459
  #, gcc-internal-format
@@ -25775,24 +27015,24 @@ msgid "only %<inbranch%> and %<notinbranch%> flags are allowed for %<__simd__%>
  msgstr ""
  
  #: c-family/c-common.c:8605 c-family/c-common.c:9652
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t set %qE attribute after definition"
-msgstr "%Jатрибут %qE нельзя установить после определения объекта"
+msgstr "атрибут %qE нельзя установить после определения объекта"
  
  #: c-family/c-common.c:8663
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute duplicated"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80ирован"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð¿Ñ\80Ð¾Ð´Ñ\83Ð±Ð»ирован"
  
  #: c-family/c-common.c:8665
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute follows %qE"
-msgstr "атрибут %qE для %qE проигнорирован"
+msgstr "атрибут %qE следует после %qE"
  
  #: c-family/c-common.c:8764
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type was previously declared %qE"
-msgstr "Ñ\8dÑ\82Ð¾ Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ `%#D'"
+msgstr "Ñ\82Ð¸Ð¿ Ð±Ñ\8bÐ» Ñ\80Ð°Ð½ÐµÐµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½ ÐºÐ°Ðº %qE"
  
  #: c-family/c-common.c:8777 cp/class.c:4625
  #, fuzzy, gcc-internal-format
@@ -25801,14 +27041,14 @@ msgid "%<transaction_safe_dynamic%> may only be specified for a virtual function
  msgstr "%qs допустим только для функций"
  
  #: c-family/c-common.c:8835
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE argument not an identifier"
-msgstr "аргумент атрибута cleanup - не идентификатор"
+msgstr "аргумент %qE - не идентификатор"
  
  #: c-family/c-common.c:8846
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is not compatible with %qD"
-msgstr "отсутствует декларация %qD в %qD"
+msgstr "%qD не совместим с %qD"
  
  #: c-family/c-common.c:8849
  #, fuzzy, gcc-internal-format
@@ -25817,9 +27057,9 @@ msgid "%qE argument is not a function"
  msgstr "аргумент атрибута cleanup - не функция"
  
  #: c-family/c-common.c:8897
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "deprecated message is not a string"
-msgstr "аргумент атрибута %qs не является строковой константой"
+msgstr "сообщение для атрибута deprecated не является строковой константой"
  
  #: c-family/c-common.c:8938
  #, gcc-internal-format
@@ -25867,14 +27107,14 @@ msgid "nonnull argument references non-pointer operand (argument %lu, operand %l
  msgstr "непустой аргумент ссылается на операнд, не являющийся указателем (аргумент %lu, операнд %lu)"
  
  #: c-family/c-common.c:9192
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "not enough variable arguments to fit a sentinel"
-msgstr "слишком мало аргументов функции"
+msgstr "слишком мало аргументов функции для использования атрибута sentinel"
  
  #: c-family/c-common.c:9206
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "missing sentinel in function call"
-msgstr "Ð\97Ð°Ð¿Ñ\80ÐµÑ\82Ð¸Ñ\82Ñ\8c Ð²Ñ\8bÐ·Ð¾Ð²Ñ\8b Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹ Ð¾Ñ\82Ð½Ð¾Ñ\81Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾ PC"
+msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 sentinel Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
  
  #: c-family/c-common.c:9248
  #, gcc-internal-format, gfc-internal-format
@@ -25914,27 +27154,29 @@ msgstr "заданная позиция меньше нуля"
  #: c-family/c-common.c:9546
  #, gcc-internal-format, gfc-internal-format
  msgid "bad option %s to optimize attribute"
-msgstr ""
+msgstr "некорректная опция %s для атрибута оптимизации"
  
  #: c-family/c-common.c:9549
  #, gcc-internal-format, gfc-internal-format
  msgid "bad option %s to pragma attribute"
-msgstr ""
+msgstr "некорректная опция %s для атрибута pragma"
  
  #: c-family/c-common.c:9669
  #, fuzzy, gcc-internal-format
+#| msgid "return with value in function with no return type"
  msgid "returns_nonnull attribute on a function not returning a pointer"
-msgstr "оператор %<return%> <значение> в функции возвращающей void"
+msgstr "return со значением в функции без типа возврата"
  
  #: c-family/c-common.c:9684
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute only applies to function types"
  msgid "%qE attribute is only valid on %<struct%> type"
-msgstr "атрибут %qs недопустим для функций"
+msgstr "атрибут %qE допустим только для функций"
  
  #: c-family/c-common.c:9809
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "not enough arguments to function %qE"
-msgstr "слишком мало аргументов в вызове функции %qE"
+msgstr "недостаточно аргументов в вызове функции %qE"
  
  #: c-family/c-common.c:9815 c-family/c-common.c:10816 c/c-typeck.c:3213
  #, gcc-internal-format
@@ -25947,34 +27189,36 @@ msgid "second argument to function %qE must be a constant integer power of 2 bet
  msgstr ""
  
  #: c-family/c-common.c:9873 c-family/c-common.c:9919
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-floating-point argument in call to function %qE"
-msgstr "не плавающий аргумент в вызове функции %qs"
+msgstr "не плавающий аргумент в вызове функции %qE"
  
  #: c-family/c-common.c:9896
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-floating-point arguments in call to function %qE"
-msgstr "Ð½Ðµ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs"
+msgstr "Ð½Ðµ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ðµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE"
  
  #: c-family/c-common.c:9912
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-const integer argument %u in call to function %qE"
-msgstr "Ð½Ðµ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %u Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ð¾Ð¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
  
  #: c-family/c-common.c:9932
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-integer argument 3 in call to function %qE"
-msgstr "Ð½Ðµ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 3 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bÐ¼"
  
  #: c-family/c-common.c:9948
  #, fuzzy, gcc-internal-format
+#| msgid "argument %d of %qE must be a pointer type"
  msgid "argument %u in call to function %qE does not have integral type"
-msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qT Ð² ÐºÐ°Ñ\87ÐµÑ\81Ñ\82Ð²Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %d Ð´Ð»Ñ\8f %qE Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼"
  
  #: c-family/c-common.c:9955
  #, fuzzy, gcc-internal-format
+#| msgid "argument 1 of %qE must be a pointer to a constant size type"
  msgid "argument 3 in call to function %qE does not have pointer to integer type"
-msgstr "%Hпервый аргумент %D должен быть указателем, второй - целой константой"
+msgstr "аргумент 1 для %qE должен быть типом с константным размером"
  
  #: c-family/c-common.c:10268
  #, gcc-internal-format
@@ -25982,14 +27226,14 @@ msgid "cannot apply %<offsetof%> to static data member %qD"
  msgstr "недопустимое применение %<offsetof%> к статическому элементу данных %qD"
  
  #: c-family/c-common.c:10273
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot apply %<offsetof%> when %<operator[]%> is overloaded"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ %<offsetof%> Ðº Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¼Ñ\83 Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ñ\83 Ð´Ð°Ð½Ð½Ñ\8bÑ\85 %qD"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½Ð¸Ñ\82 %<offsetof%> Ðº Ð¿ÐµÑ\80ÐµÐ³Ñ\80Ñ\83Ð¶ÐµÐ½Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %<operator[]%>"
  
  #: c-family/c-common.c:10280
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot apply %<offsetof%> to a non constant address"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÑ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° %qD"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½Ð¸Ñ\82 %<offsetof%> Ðº Ð½ÐµÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð¼Ñ\83 Ð°Ð´Ñ\80ÐµÑ\81Ñ\83"
  
  #: c-family/c-common.c:10293 cp/typeck.c:5733
  #, gcc-internal-format
@@ -25999,32 +27243,32 @@ msgstr "взятие адреса от битового поля структу
  #: c-family/c-common.c:10345
  #, gcc-internal-format
  msgid "index %E denotes an offset greater than size of %qT"
-msgstr ""
+msgstr "индекс %E обозначает смещение, превышающее размер %qT"
  
  #: c-family/c-common.c:10385
  #, gcc-internal-format
  msgid "the omitted middle operand in ?: will always be %<true%>, suggest explicit middle operand"
-msgstr ""
+msgstr "пропущенный средний операнд в ?: всегда %<true%>, предлагается явно задать средний операнд"
  
  #: c-family/c-common.c:10406
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "assignment of member %qD in read-only object"
-msgstr "присваивание позиции в памяти, доступной только на чтение"
+msgstr "присваивание элементу %qD в объекте, доступном только на чтение"
  
  #: c-family/c-common.c:10408
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "increment of member %qD in read-only object"
-msgstr "инкрементация позиции в памяти, доступной только на чтение"
+msgstr "инкрементация элемента %qD в объекте, доступном только на чтение"
  
  #: c-family/c-common.c:10410
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "decrement of member %qD in read-only object"
-msgstr "декрементация позиции в памяти, доступной только на чтение"
+msgstr "декрементация элемента %qD в объекте, доступном только на чтение"
  
  #: c-family/c-common.c:10412
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "member %qD in read-only object used as %<asm%> output"
-msgstr "доступная только на чтение позиция памяти использована как выходной операнд %<asm%>"
+msgstr "элемент %qD в объекте, доступном только на чтение, использован как выходной операнд %<asm%>"
  
  #: c-family/c-common.c:10416
  #, gcc-internal-format
@@ -26067,144 +27311,145 @@ msgid "read-only variable %qD used as %<asm%> output"
  msgstr "доступная только на чтение переменная %qD использована как выходной операнд %<asm%>"
  
  #: c-family/c-common.c:10429
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "assignment of read-only parameter %qD"
-msgstr "присваивание элементу %qD, доступному только на чтение"
+msgstr "присваивание параметру %qD, доступному только на чтение"
  
  #: c-family/c-common.c:10430
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "increment of read-only parameter %qD"
-msgstr "инкрементация элемента %qD, доступного только на чтение"
+msgstr "инкрементация параметра %qD, доступного только на чтение"
  
  #: c-family/c-common.c:10431
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "decrement of read-only parameter %qD"
-msgstr "декрементация элемента %qD, доступного только на чтение"
+msgstr "декрементация параметра %qD, доступного только на чтение"
  
  #: c-family/c-common.c:10432
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "read-only parameter %qD use as %<asm%> output"
-msgstr "доступный только на чтение элемент %qD использован как выходной операнд %<asm%>"
+msgstr "доступный только на чтение параметр %qD использован как выходной операнд %<asm%>"
  
  #: c-family/c-common.c:10437
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "assignment of read-only named return value %qD"
-msgstr "Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qD, Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð¾Ð¹ только на чтение"
+msgstr "Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð½Ð¾Ð¼Ñ\83 Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÐ¼Ð¾Ð¼Ñ\83 Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8e %qD, Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð¾Ð¼Ñ\83 только на чтение"
  
  #: c-family/c-common.c:10439
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "increment of read-only named return value %qD"
-msgstr "Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qD, Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð¾Ð¹ только на чтение"
+msgstr "Ð¸Ð½ÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð°Ñ\86Ð¸Ñ\8f Ð¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f %qD, Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð¾Ð³Ð¾ только на чтение"
  
  #: c-family/c-common.c:10441
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "decrement of read-only named return value %qD"
-msgstr "Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qD, Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð¾Ð¹ только на чтение"
+msgstr "Ð´ÐµÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð°Ñ\86Ð¸Ñ\8f Ð¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f %qD, Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð¾Ð³Ð¾ только на чтение"
  
  #: c-family/c-common.c:10443
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "read-only named return value %qD used as %<asm%>output"
-msgstr "Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð°Ñ\8f Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð½Ð° Ñ\87Ñ\82ÐµÐ½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qD Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð° как выходной операнд %<asm%>"
+msgstr "Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð¾Ðµ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð½Ð° Ñ\87Ñ\82ÐµÐ½Ð¸Ðµ Ð¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð½Ð¾Ðµ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÐ¼Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ %qD Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¾ как выходной операнд %<asm%>"
  
  #: c-family/c-common.c:10448
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "assignment of function %qD"
-msgstr "Ð²Ñ\8bÐ·Ð¾Ð² Ð½е функции %qD"
+msgstr "Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸е функции %qD"
  
  #: c-family/c-common.c:10449
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "increment of function %qD"
-msgstr "Ð²Ñ\8bÐ·Ð¾Ð² Ð½Ðµ функции %qD"
+msgstr "Ð¸Ð½ÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð°Ñ\86Ð¸Ñ\8f функции %qD"
  
  #: c-family/c-common.c:10450
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "decrement of function %qD"
-msgstr "Ð²Ñ\8bÐ·Ð¾Ð² Ð½Ðµ функции %qD"
+msgstr "Ð´ÐµÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð°Ñ\86Ð¸Ñ\8f функции %qD"
  
  #: c-family/c-common.c:10451
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "function %qD used as %<asm%> output"
-msgstr "доступная только на чтение позиция памяти использована как выходной операнд %<asm%>"
+msgstr "функция %qD использована как выходной операнд %<asm%>"
  
  #: c-family/c-common.c:10454 c/c-typeck.c:4566
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "assignment of read-only location %qE"
-msgstr "присваивание позиции в памяти, доступной только на чтение"
+msgstr "присваивание позиции в памяти %qE, доступной только на чтение"
  
  #: c-family/c-common.c:10455 c/c-typeck.c:4569
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "increment of read-only location %qE"
-msgstr "инкрементация позиции в памяти, доступной только на чтение"
+msgstr "инкрементация позиции в памяти %qE, доступной только на чтение"
  
  #: c-family/c-common.c:10456 c/c-typeck.c:4572
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "decrement of read-only location %qE"
-msgstr "декрементация позиции в памяти, доступной только на чтение"
+msgstr "декрементация позиции в памяти %qE, доступной только на чтение"
  
  #: c-family/c-common.c:10457
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "read-only location %qE used as %<asm%> output"
-msgstr "доступная только на чтение позиция памяти использована как выходной операнд %<asm%>"
+msgstr "доступная только на чтение позиция памяти %qE использована как выходной операнд %<asm%>"
  
  #: c-family/c-common.c:10471
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "lvalue required as left operand of assignment"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð»ÐµÐ²Ð°Ñ\8f Ñ\87Ð°Ñ\81Ñ\82Ñ\8c Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸"
+msgstr "Ð»ÐµÐ²Ð°Ñ\8f Ñ\87Ð°Ñ\81Ñ\82Ñ\8c Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c lvalue-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸ÐµÐ¼"
  
  #: c-family/c-common.c:10474
  #, gcc-internal-format
  msgid "lvalue required as increment operand"
-msgstr ""
+msgstr "операнд инкрементации должен быть lvalue-выражением"
  
  #: c-family/c-common.c:10477
  #, gcc-internal-format
  msgid "lvalue required as decrement operand"
-msgstr ""
+msgstr "операнд декрементации должен быть lvalue-выражением"
  
  #: c-family/c-common.c:10480
  #, gcc-internal-format
  msgid "lvalue required as unary %<&%> operand"
-msgstr ""
+msgstr "операнд унарной операции %<&%> должен быть lvalue-выражением"
  
  #: c-family/c-common.c:10483
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "lvalue required in asm statement"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾Ðµ lvalue-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ asm"
+msgstr "Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ asm Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f lvalue-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
  
  #: c-family/c-common.c:10500
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid type argument (have %qT)"
-msgstr "неверный аргумент для %qs"
+msgstr "неверный аргумент-тип (задан %qT)"
  
  #: c-family/c-common.c:10504
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid type argument of array indexing (have %qT)"
-msgstr "неверный аргумент для %qs"
+msgstr "неверный аргумент-тип для индексации (задан %qT)"
  
  #: c-family/c-common.c:10509
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid type argument of unary %<*%> (have %qT)"
-msgstr "неверный аргумент для %qs"
+msgstr "неверный аргумент-тип для унарной операции %<*%> (задан %qT)"
  
  #: c-family/c-common.c:10514
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid type argument of %<->%> (have %qT)"
-msgstr "неверный аргумент для %qs"
+msgstr "неверный аргумент-тип для операции %<->%> (задан %qT)"
  
  #: c-family/c-common.c:10519
  #, fuzzy, gcc-internal-format
+#| msgid "invalid type argument of %<->%> (have %qT)"
  msgid "invalid type argument of %<->*%> (have %qT)"
-msgstr "неверный аргумент для %qs"
+msgstr "неверный аргумент-тип для операции %<->%> (задан %qT)"
  
  #: c-family/c-common.c:10524
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid type argument of implicit conversion (have %qT)"
-msgstr "неверный аргумент для %qs"
+msgstr "неверный аргумент-тип для неявного преобразования (задан %qT)"
  
  #: c-family/c-common.c:10666 cp/init.c:2782 cp/init.c:2801
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "size of array is too large"
-msgstr "размер массива %qs слишком велик"
+msgstr "размер массива слишком велик"
  
  #: c-family/c-common.c:10719 c-family/c-common.c:10790 c/c-typeck.c:3459
  #, gcc-internal-format
@@ -26218,44 +27463,44 @@ msgid "operand type %qT is incompatible with argument %d of %qE"
  msgstr "несовместимый тип аргумента %d функции %qE"
  
  #: c-family/c-common.c:10883
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "incorrect number of arguments to function %qE"
-msgstr "слишком мало аргументов в вызове функции %qE"
+msgstr "неправильное число аргументов в вызове функции %qE"
  
  #: c-family/c-common.c:10898
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument 1 of %qE must be a non-void pointer type"
-msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qT Ð² ÐºÐ°Ñ\87ÐµÑ\81Ñ\82Ð²Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 1 Ð´Ð»Ñ\8f %qE Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð½Ðµ-void Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼"
  
  #: c-family/c-common.c:10907
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument 1 of %qE must be a pointer to a constant size type"
-msgstr "%Hпервый аргумент %D должен быть указателем, второй - целой константой"
+msgstr "аргумент 1 для %qE должен быть типом с константным размером"
  
  #: c-family/c-common.c:10918
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument 1 of %qE must be a pointer to a nonzero size object"
-msgstr "%Hпервый аргумент %D должен быть указателем, второй - целой константой"
+msgstr "аргумент 1 для %qE должен быть указателем на объект ненулевого размера"
  
  #: c-family/c-common.c:10933
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument %d of %qE must be a pointer type"
-msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qT Ð² ÐºÐ°Ñ\87ÐµÑ\81Ñ\82Ð²Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %d Ð´Ð»Ñ\8f %qE Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼"
  
  #: c-family/c-common.c:10941
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "size mismatch in argument %d of %qE"
-msgstr "Ð¿Ñ\80Ð¸ Ð¿ÐµÑ\80ÐµÐ´Ð°Ñ\87Ðµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %P Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ `%+D'"
+msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ %d Ð´Ð»Ñ\8f %qE"
  
  #: c-family/c-common.c:10957
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid memory model argument %d of %qE"
-msgstr "несовместимый тип аргумента %d функции %qE"
+msgstr "некорректный аргумент %d модели памяти для %qE"
  
  #: c-family/c-common.c:10964
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-integer memory model argument %d of %qE"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %d Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE"
+msgstr "Ð½ÐµÑ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %d Ð¼Ð¾Ð´ÐµÐ»Ð¸ Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸ Ð´Ð»Ñ\8f %qE"
  
  #: c-family/c-common.c:11562
  #, gcc-internal-format
@@ -26263,89 +27508,89 @@ msgid "array subscript has type %<char%>"
  msgstr "индекс массива имеет тип %<char%>"
  
  #: c-family/c-common.c:11597 c-family/c-common.c:11600
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around %<+%> inside %<<<%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ + Ð¸Ð»Ð¸ -, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÐµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð°Ñ\85 Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¹ Ñ\81Ð´Ð²Ð¸Ð³Ð°"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð·Ð°ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð² Ñ\81ÐºÐ¾Ð±ÐºÐ¸ %<+%> Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %<<<%>"
  
  #: c-family/c-common.c:11603 c-family/c-common.c:11606
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around %<-%> inside %<<<%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ + Ð¸Ð»Ð¸ -, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÐµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð°Ñ\85 Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¹ Ñ\81Ð´Ð²Ð¸Ð³Ð°"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð·Ð°ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð² Ñ\81ÐºÐ¾Ð±ÐºÐ¸ %<-%> Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %<<<%>"
  
  #: c-family/c-common.c:11612 c-family/c-common.c:11615
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around %<+%> inside %<>>%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ + Ð¸Ð»Ð¸ -, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÐµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð°Ñ\85 Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¹ Ñ\81Ð´Ð²Ð¸Ð³Ð°"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð·Ð°ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð² Ñ\81ÐºÐ¾Ð±ÐºÐ¸ %<+%> Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %<>>%>"
  
  #: c-family/c-common.c:11618 c-family/c-common.c:11621
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around %<-%> inside %<>>%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ + Ð¸Ð»Ð¸ -, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÐµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð°Ñ\85 Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¹ Ñ\81Ð´Ð²Ð¸Ð³Ð°"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð·Ð°ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð² Ñ\81ÐºÐ¾Ð±ÐºÐ¸ %<-%> Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %<>>%>"
  
  #: c-family/c-common.c:11627 c-family/c-common.c:11630
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around %<&&%> within %<||%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ &&, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ð¾Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ ||"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð·Ð°ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð² Ñ\81ÐºÐ¾Ð±ÐºÐ¸ %<&&%> Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %<||%>"
  
  #: c-family/c-common.c:11637 c-family/c-common.c:11641
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around arithmetic in operand of %<|%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÑ\83Ñ\8e Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\83Ñ\8e Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ |"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð·Ð°ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð² Ñ\81ÐºÐ¾Ð±ÐºÐ¸ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ %<|%>"
  
  #: c-family/c-common.c:11645 c-family/c-common.c:11648
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around comparison in operand of %<|%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ð¾Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ |"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð·Ð°ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð² Ñ\81ÐºÐ¾Ð±ÐºÐ¸ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ %<|%>"
  
  #: c-family/c-common.c:11653
  #, gcc-internal-format
  msgid "suggest parentheses around operand of %<!%> or change %<|%> to %<||%> or %<!%> to %<~%>"
-msgstr ""
+msgstr "рекомендуется окружить скобками операнд %<!%>, либо заменить %<|%> на %<||%> или %<!%> на %<~%>"
  
  #: c-family/c-common.c:11661 c-family/c-common.c:11665
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around arithmetic in operand of %<^%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÑ\83Ñ\8e Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\83Ñ\8e Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ ^"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð¸Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ %<^%>"
  
  #: c-family/c-common.c:11669 c-family/c-common.c:11672
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around comparison in operand of %<^%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ð¾Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ ^"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð¸Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ %<^%>"
  
  #: c-family/c-common.c:11678 c-family/c-common.c:11681
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around %<+%> in operand of %<&%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ + Ð¸Ð»Ð¸ -, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÐµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ &"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð¸Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ %<+%> Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ %<&%>"
  
  #: c-family/c-common.c:11684 c-family/c-common.c:11687
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around %<-%> in operand of %<&%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ + Ð¸Ð»Ð¸ -, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÐµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ &"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð¸Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ %<-%> Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ %<&%>"
  
  #: c-family/c-common.c:11691 c-family/c-common.c:11694
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around comparison in operand of %<&%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ð¾Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ &"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð¸Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ %<&%>"
  
  #: c-family/c-common.c:11699
  #, gcc-internal-format
  msgid "suggest parentheses around operand of %<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>"
-msgstr ""
+msgstr "рекомендуется окружить скобками операнд %<!%>, либо заменить %<&%> на %<&&%> или %<!%> на %<~%>"
  
  #: c-family/c-common.c:11706 c-family/c-common.c:11709
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around comparison in operand of %<==%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ð¾Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ |"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð¸Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ð¾Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ %<==%>"
  
  #: c-family/c-common.c:11714 c-family/c-common.c:11717
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around comparison in operand of %<!=%>"
-msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð°Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ð¾Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ |"
+msgstr "Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¾ÐºÑ\80Ñ\83Ð¶Ð¸Ñ\82Ñ\8c Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ð¾Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ %<!=%>"
  
  #: c-family/c-common.c:11727 c-family/c-common.c:11733
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "comparisons like %<X<=Y<=Z%> do not have their mathematical meaning"
-msgstr "сравнения вида X<=Y<=Z трактуются в C не так, как в математике"
+msgstr "сравнения вида %<X<=Y<=Z%> трактуются в C не так, как в математике"
  
  #: c-family/c-common.c:11749
  #, gcc-internal-format
@@ -26364,9 +27609,9 @@ msgstr "деление на ноль"
  
  #: c-family/c-common.c:11799 c/c-typeck.c:11041 c/c-typeck.c:11198
  #: cp/typeck.c:4820
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "comparison between types %qT and %qT"
-msgstr "сравнение между типами `%#T' и `%#T'"
+msgstr "сравнение между типами %qT и %qT"
  
  #: c-family/c-common.c:11850
  #, gcc-internal-format
@@ -26376,7 +27621,7 @@ msgstr "сравнение знакового и беззнакового цел
  #: c-family/c-common.c:11901
  #, gcc-internal-format
  msgid "promoted ~unsigned is always non-zero"
-msgstr ""
+msgstr "расширенное значение ~unsigned всегда ненулевое"
  
  #: c-family/c-common.c:11904
  #, gcc-internal-format
@@ -26395,9 +27640,9 @@ msgid "unused parameter %qD"
  msgstr "параметр %q+D не используется"
  
  #: c-family/c-common.c:12109
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "typedef %qD locally defined but not used"
-msgstr "%q+D определена, но нигде не используется"
+msgstr "typedef %qD определен локально, но нигде не используется"
  
  #: c-family/c-common.c:12146 c-family/c-common.c:12172
  #, fuzzy, gcc-internal-format
@@ -26417,22 +27662,24 @@ msgid "result of %qE requires %u bits to represent, but %qT only has %u bits"
  msgstr ""
  
  #: c-family/c-common.c:12467
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "index value is out of bound"
-msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð½Ð¾Ñ\81Ñ\82Ð¸ %d Ð²Ñ\8bÑ\85Ð¾Ð´Ð¸Ñ\82 Ð·Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ñ\8b Ð² %L"
+msgstr "Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð¸Ð½Ð´ÐµÐºÑ\81Ð° Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°"
  
  #: c-family/c-common.c:12539 c-family/c-common.c:12587
  #: c-family/c-common.c:12602 cp/call.c:4692 cp/call.c:4699
  #, fuzzy, gcc-internal-format
+#| msgid "conversion of scalar to vector involves truncation"
  msgid "conversion of scalar %qT to vector %qT involves truncation"
-msgstr "преобразование из %qT в %qT неоднозначно"
+msgstr "преобразование скаляра в вектор приводит к усечению значения"
  
  #. Reject arguments that are built-in functions with
  #. no library fallback.
  #: c-family/c-common.c:12673
  #, fuzzy, gcc-internal-format
+#| msgid "built-in function %qD takes one argument only"
  msgid "built-in function %qE must be directly called"
-msgstr "внутренняя функция %q+D декларирована как не функция"
+msgstr "внутренняя функция %qD принимает только один аргумент"
  
  #: c-family/c-common.c:12709
  #, fuzzy, gcc-internal-format
@@ -26441,14 +27688,14 @@ msgid "duplicated %<if%> condition"
  msgstr "повторное употребление %<const%>"
  
  #: c-family/c-common.c:12736 c/c-decl.c:5913
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "size of array %qE is too large"
-msgstr "размер массива %qs слишком велик"
+msgstr "размер массива %qE слишком велик"
  
  #: c-family/c-common.c:12738 c/c-decl.c:5916
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "size of unnamed array is too large"
-msgstr "Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° %qs слишком велик"
+msgstr "Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð±ÐµÐ·Ñ\8bÐ¼Ñ\8fÐ½Ð½Ð¾Ð³Ð¾ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° слишком велик"
  
  #: c-family/c-format.c:175 c-family/c-format.c:362
  #, gcc-internal-format
@@ -26461,29 +27708,29 @@ msgid "function does not return string type"
  msgstr "функция возвращает значение не строкового типа"
  
  #: c-family/c-format.c:225
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "format string argument is not a string type"
  msgstr "аргумент, задающий формат, имеет не строковый тип"
  
  #: c-family/c-format.c:251
  #, gcc-internal-format
  msgid "found a %<%s%> reference but the format argument should be a string"
-msgstr ""
+msgstr "найдена ссылка %<%s%>, но аргумент, задающий формат, должен быть строкой"
  
  #: c-family/c-format.c:254
  #, gcc-internal-format
  msgid "found a %qT but the format argument should be a string"
-msgstr ""
+msgstr "найден %qT, но аргумент, задающий формат, должен быть строкой"
  
  #: c-family/c-format.c:264
  #, gcc-internal-format
  msgid "format argument should be a %<%s%> reference but a string was found"
-msgstr ""
+msgstr "аргумент, задающий формат, должен быть ссылкой %<%s%>, но найдена строка"
  
  #: c-family/c-format.c:286
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "format argument should be a %<%s%> reference"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q+D Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ñ\82Ð¸Ð¿ %<int%>"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82, Ð·Ð°Ð´Ð°Ñ\8eÑ\89Ð¸Ð¹ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82, Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¾Ð¹ %<%s%>"
  
  #: c-family/c-format.c:330
  #, gcc-internal-format
@@ -26493,7 +27740,7 @@ msgstr "некорректный спецификатор формата"
  #: c-family/c-format.c:345
  #, gcc-internal-format
  msgid "%qE is only allowed in Objective-C dialects"
-msgstr ""
+msgstr "%qE допускается только в Objective-C диалектах"
  
  #: c-family/c-format.c:354
  #, gcc-internal-format
@@ -26737,24 +27984,24 @@ msgid "extra type qualifiers in format argument (argument %d)"
  msgstr "избыточные квалификаторы типа в аргументе форматирования (аргумент %d)"
  
  #: c-family/c-format.c:2678
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s %<%s%.*s%> expects argument of type %<%s%s%>, but argument %d has type %qT"
-msgstr "формат %q.*s предполагает тип %<%s%s%>, но аргумент %d имеет тип %qT"
+msgstr "%s %<%s%.*s%> ожидает аргумент типа %<%s%s%>, но аргумент %d имеет тип %qT"
  
  #: c-family/c-format.c:2686
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s %<%s%.*s%> expects a matching %<%s%s%> argument"
-msgstr "для %qs требуется константный аргумент"
+msgstr "%s %<%s%.*s%> ожидает соответствующий %<%s%s%> аргумент"
  
  #: c-family/c-format.c:2695
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s %<%s%.*s%> expects argument of type %<%T%s%>, but argument %d has type %qT"
-msgstr "формат %q.*s предполагает тип %<%T%s%>, но аргумент %d имеет тип %qT"
+msgstr "%s %<%s%.*s%> ожидает аргумент типа %<%T%s%>, но аргумент %d имеет тип %qT"
  
  #: c-family/c-format.c:2703
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s %<%s%.*s%> expects a matching %<%T%s%> argument"
-msgstr "для %qs требуется константный аргумент"
+msgstr "%s %<%s%.*s%> ожидает соответствующий %<%T%s%> аргумент"
  
  #: c-family/c-format.c:2763 c-family/c-format.c:2769 c-family/c-format.c:2920
  #, gcc-internal-format
@@ -26812,15 +28059,15 @@ msgid "badly nested C headers from preprocessor"
  msgstr "некорректная вложенность заголовочных файлов C в результате препроцессирования"
  
  #: c-family/c-lex.c:257
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "ignoring #pragma %s %s"
-msgstr "%Hдиректива #pragma %s %s проигнорирована"
+msgstr "директива #pragma %s %s проигнорирована"
  
  #. ... or not.
  #: c-family/c-lex.c:494 c-family/c-lex.c:1157
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "stray %<@%> in program"
-msgstr "%Hнекорректное употребление символа %<@%>"
+msgstr "в программе обнаружен одиночный символ %<@%>"
  
  #: c-family/c-lex.c:509
  #, gcc-internal-format
@@ -26853,104 +28100,106 @@ msgid "this decimal constant would be unsigned in ISO C90"
  msgstr "эта десятичная константа являлась бы беззнаковой только в ISO C90"
  
  #: c-family/c-lex.c:755
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "integer constant is too large for %<unsigned long%> type"
-msgstr "целая константа слишком велика для типа %qs"
+msgstr "целая константа слишком велика для типа %<unsigned long%>"
  
  #: c-family/c-lex.c:795
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unsuffixed float constant"
-msgstr "размер %qD в памяти не является константой"
+msgstr "константа с плавающей точкой без суффикса"
  
  #: c-family/c-lex.c:827
  #, gcc-internal-format
  msgid "unsupported non-standard suffix on floating constant"
-msgstr ""
+msgstr "неподдерживаемый нестандартный суффикс в константе с плавающей точкой"
  
  #: c-family/c-lex.c:832
  #, gcc-internal-format
  msgid "non-standard suffix on floating constant"
-msgstr ""
+msgstr "нестандартный суффикс в константе с плавающей точкой"
  
  #: c-family/c-lex.c:903 c-family/c-lex.c:906
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "floating constant exceeds range of %qT"
-msgstr "плавающая константа превышает диапазон для %<%s%>"
+msgstr "плавающая константа превышает диапазон для %qT"
  
  #: c-family/c-lex.c:921
  #, gcc-internal-format
  msgid "floating constant truncated to zero"
-msgstr "Ð´ÐµÐ»ÐµÐ½Ð¸Ðµ Ð½Ð° Ð½Ð¾Ð»Ñ\8c Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ñ\8b"
+msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82aÐ½Ñ\82a Ñ\81 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹ Ñ\83Ñ\81ÐµÑ\87ÐµÐ½Ð° Ð´Ð¾ Ð½Ñ\83Ð»Ñ\8f"
  
  #: c-family/c-lex.c:1119
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "repeated %<@%> before Objective-C string"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾Ðµ Ð¿Ð¾Ð»Ð¾Ð¶ÐµÐ½Ð¸Ðµ %<@%D%> ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Objective-C++"
+msgstr "Ð´Ñ\83Ð±Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐµ %<@%> Ð¿ÐµÑ\80ÐµÐ´ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾Ð¹ Objective-C"
  
  #: c-family/c-lex.c:1138 cp/parser.c:3934
  #, gcc-internal-format
  msgid "unsupported non-standard concatenation of string literals"
-msgstr ""
+msgstr "неподдерживаемая нестандартная конкатенация строковых литералов"
  
  #: c-family/c-lex.c:1166
  #, gcc-internal-format
  msgid "traditional C rejects string constant concatenation"
-msgstr "Ñ\81 Ñ\82Ñ\80Ð°Ð´Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾Ð¼ Ð¡ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½ÐºÐ°Ñ\82ÐµÐ½Ð°Ñ\86Ð¸Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾Ðº"
+msgstr "Ñ\82Ñ\80Ð°Ð´Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ñ\8bÐ¹ Ð¡Ð¸ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 ÐºÐ¾Ð½ÐºÐ°Ñ\82ÐµÐ½Ð°Ñ\86Ð¸Ñ\8e Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾Ð²Ñ\8bÑ\85 ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82"
  
  #: c-family/c-omp.c:199
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid expression type for %<#pragma omp atomic%>"
-msgstr "Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð·Ð°Ð´Ð°Ð½Ð¾ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ð´Ð»Ñ\8f %<#pragma omp atomic%>"
  
  #: c-family/c-omp.c:276
  #, gcc-internal-format
  msgid "%<#pragma omp atomic update%> uses two different variables for memory"
-msgstr ""
+msgstr "в %<#pragma omp atomic update%> используются две различные переменные для памяти"
  
  #: c-family/c-omp.c:279 c-family/c-omp.c:292
  #, gcc-internal-format
  msgid "%<#pragma omp atomic capture%> uses two different variables for memory"
-msgstr ""
+msgstr "в %<#pragma omp atomic capture%> используются две различные переменные для памяти"
  
  #: c-family/c-omp.c:480 cp/semantics.c:8077
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid type for iteration variable %qE"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾ Ð·Ð°Ð´Ð°Ð½ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qE"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð¸Ñ\82ÐµÑ\80Ð°Ñ\86Ð¸Ð¾Ð½Ð½Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qE"
  
  #: c-family/c-omp.c:493
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not initialized"
-msgstr "параметр %qD инициализирован"
+msgstr "%qE не инициализирован"
  
  #: c-family/c-omp.c:514 cp/semantics.c:7965
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "missing controlling predicate"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð°"
+msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»Ñ\8fÑ\8eÑ\89Ð¸Ð¹ Ð¿Ñ\80ÐµÐ´Ð¸ÐºÐ°Ñ\82"
  
  #: c-family/c-omp.c:599 cp/semantics.c:7629
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid controlling predicate"
-msgstr "некорректный операнд условного оператора"
+msgstr "некорректный управляющий предикат"
  
  #: c-family/c-omp.c:606 cp/semantics.c:7971
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "missing increment expression"
-msgstr "Ð¿Ð¾Ð´Ð°Ð²Ð»ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ñ\8f"
+msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¸Ð½ÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
  
  #: c-family/c-omp.c:670 cp/semantics.c:7744
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid increment expression"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾Ðµ Ð»Ð¾Ð³Ð¸Ñ\87ÐµÑ\81Ðºое выражение"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ð½ÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð°Ð»Ñ\8cÐ½ое выражение"
  
  #: c-family/c-omp.c:733
  #, fuzzy, gcc-internal-format
+#| msgid "invalid type for iteration variable %qE"
  msgid "initializer expression refers to iteration variable %qD"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾ Ð·Ð°Ð´Ð°Ð½ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qE"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð¸Ñ\82ÐµÑ\80Ð°Ñ\86Ð¸Ð¾Ð½Ð½Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qE"
  
  #: c-family/c-omp.c:737
  #, fuzzy, gcc-internal-format
+#| msgid "invalid type for iteration variable %qE"
  msgid "condition expression refers to iteration variable %qD"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾ Ð·Ð°Ð´Ð°Ð½ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qE"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð¸Ñ\82ÐµÑ\80Ð°Ñ\86Ð¸Ð¾Ð½Ð½Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qE"
  
  #: c-family/c-omp.c:741
  #, fuzzy, gcc-internal-format
@@ -26959,14 +28208,17 @@ msgid "increment expression refers to iteration variable %qD"
  msgstr "инкрементация переменной %qD, доступной только на чтение"
  
  #: c-family/c-omp.c:1300
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "expected %<none%> or %<shared%> before end of line"
  msgid "expected %<parallel%> or %<target%> %<if%> clause modifier"
-msgstr ""
+msgstr "ожидалось %<none%> или %<shared%> перед концом строки"
  
+#
  #: c-family/c-omp.c:1398 c-family/c-omp.c:1413
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is not a function name"
  msgid "%qD is not an function argument"
-msgstr "%qD не является шаблоном функции"
+msgstr "%qE не является именем функции"
  
  #: c-family/c-opts.c:320
  #, gcc-internal-format
@@ -26976,12 +28228,13 @@ msgstr "дважды задан ключ -I-"
  #: c-family/c-opts.c:323
  #, gcc-internal-format
  msgid "obsolete option -I- used, please use -iquote instead"
-msgstr "Устаревший ключ -I-, используйте, пожалуйста, вместо него -iquote"
+msgstr "устаревший ключ -I-, используйте, пожалуйста, вместо него -iquote"
  
  #: c-family/c-opts.c:401
  #, fuzzy, gcc-internal-format
+#| msgid "%<__int128%> is not supported by this target"
  msgid "%<-Wabi=1%> is not supported, using =2"
-msgstr "ключ -f%s не поддерживается; игнорируется"
+msgstr "%<__int128%> не поддерживается этой целевой платформой"
  
  #: c-family/c-opts.c:593 fortran/cpp.c:350
  #, gcc-internal-format
@@ -26991,12 +28244,12 @@ msgstr "дважды задано имя выходного файла"
  #: c-family/c-opts.c:772
  #, gcc-internal-format
  msgid "-fexcess-precision=standard for C++"
-msgstr ""
+msgstr "-fexcess-precision=standard для C++"
  
  #: c-family/c-opts.c:795
  #, gcc-internal-format
  msgid "-fno-gnu89-inline is only supported in GNU99 or C99 mode"
-msgstr ""
+msgstr "-fno-gnu89-inline поддерживается только в режиме GNU99 или C99"
  
  #: c-family/c-opts.c:841
  #, gcc-internal-format
@@ -27019,9 +28272,9 @@ msgid "-Wformat-nonliteral ignored without -Wformat"
  msgstr "ключ -Wformat-nonliteral без -Wformat игнорируется"
  
  #: c-family/c-opts.c:849
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-Wformat-contains-nul ignored without -Wformat"
-msgstr "ключ -Wformat-nonliteral без -Wformat игнорируется"
+msgstr "ключ -Wformat-contains-nul без -Wformat игнорируется"
  
  #: c-family/c-opts.c:851
  #, gcc-internal-format
@@ -27030,13 +28283,15 @@ msgstr "ключ -Wformat-security без -Wformat игнорируется"
  
  #: c-family/c-opts.c:885
  #, fuzzy, gcc-internal-format
+#| msgid "-falign-loops=%d is not supported"
  msgid "%<-fabi-compat-version=1%> is not supported, using =2"
-msgstr "-malign-loops=%d вне диапазона 0 - %d"
+msgstr "-falign-loops=%d не поддерживается"
  
  #: c-family/c-opts.c:923
  #, fuzzy, gcc-internal-format
+#| msgid "nested functions not supported on this target"
  msgid "external TLS initialization functions not supported on this target"
-msgstr "Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ñ\8bÐµ Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b не поддерживаются для этой платформы"
+msgstr "Ð²Ð»Ð¾Ð¶ÐµÐ½Ð½Ñ\8bÐµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ не поддерживаются для этой платформы"
  
  #: c-family/c-opts.c:943
  #, gcc-internal-format
@@ -27046,7 +28301,7 @@ msgstr "при открытии выходного файла %s: %m"
  #: c-family/c-opts.c:948
  #, gcc-internal-format, gfc-internal-format
  msgid "too many filenames given.  Type %s --help for usage"
-msgstr "задано слишком много имён файлов. Введите %s --help для получения справочной информации"
+msgstr "задано слишком много имен файлов. Введите %s --help для получения справочной информации"
  
  #: c-family/c-opts.c:967
  #, gcc-internal-format, gfc-internal-format
@@ -27074,19 +28329,19 @@ msgid "to generate dependencies you must specify either -M or -MM"
  msgstr "для вывода зависимостей нужно задать -M или -MM"
  
  #: c-family/c-opts.c:1245
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-MG may only be used with -M or -MM"
-msgstr "-mn без -mh или -ms"
+msgstr "-MG может использоваться только с -M или -MM"
  
  #: c-family/c-opts.c:1273
  #, gcc-internal-format
  msgid "-fdirectives-only is incompatible with -Wunused_macros"
-msgstr ""
+msgstr "-fdirectives-only несовместим с -Wunused_macros"
  
  #: c-family/c-opts.c:1275
  #, gcc-internal-format
  msgid "-fdirectives-only is incompatible with -traditional"
-msgstr ""
+msgstr "-fdirectives-only несовместим с -traditional"
  
  #: c-family/c-opts.c:1467
  #, gcc-internal-format
@@ -27144,9 +28399,9 @@ msgid "#pragma pack (pop) encountered without matching #pragma pack (push)"
  msgstr "#pragma pack (pop) без соответствующей прагмы #pragma pack (push)"
  
  #: c-family/c-pragma.c:105
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "#pragma pack(pop, %E) encountered without matching #pragma pack(push, %E)"
-msgstr "#pragma pack(pop, %s) без соответствующей прагмы #pragma pack(push, %s)"
+msgstr "#pragma pack(pop, %E) встретилась без соответствующей #pragma pack(push, %E)"
  
  #: c-family/c-pragma.c:135
  #, gcc-internal-format
@@ -27174,9 +28429,9 @@ msgid "malformed %<#pragma pack(pop[, id])%> - ignored"
  msgstr "некорректный синтаксис %<#pragma pack(pop[, id])%> - директива проигнорирована"
  
  #: c-family/c-pragma.c:166
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unknown action %qE for %<#pragma pack%> - ignored"
-msgstr "неопознанное действие %qs в %<#pragma pack%> - действие проигнорировано"
+msgstr "неопознанное действие %qE для %<#pragma pack%> - проигнорировано"
  
  #: c-family/c-pragma.c:195
  #, gcc-internal-format
@@ -27204,9 +28459,9 @@ msgid "malformed #pragma weak, ignored"
  msgstr "неверный синтаксис #pragma weak, директива проигнорирована"
  
  #: c-family/c-pragma.c:363
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of %<#pragma weak%>"
-msgstr "мусор в конце директивы %<#pragma pack%>"
+msgstr "мусор в конце директивы %<#pragma weak%>"
  
  #: c-family/c-pragma.c:369
  #, fuzzy, gcc-internal-format
@@ -27236,19 +28491,19 @@ msgid "malformed #pragma redefine_extname, ignored"
  msgstr "неверный синтаксис #pragma redefine_extname, директива проигнорирована"
  
  #: c-family/c-pragma.c:488
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of %<#pragma redefine_extname%>"
-msgstr "мусор в конце #pragma redefine_extname"
+msgstr "мусор в конце директивы %<#pragma redefine_extname%>"
  
  #: c-family/c-pragma.c:516 c-family/c-pragma.c:589
  #, gcc-internal-format
  msgid "#pragma redefine_extname ignored due to conflict with previous rename"
-msgstr "#pragma redefine_extname игнорирована, поскольку конфликтует с предыдущим  переименованием"
+msgstr "#pragma redefine_extname Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð°, Ð¿Ð¾Ñ\81ÐºÐ¾Ð»Ñ\8cÐºÑ\83 ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83ÐµÑ\82 Ñ\81 Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89Ð¸Ð¼  Ð¿ÐµÑ\80ÐµÐ¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð¸ÐµÐ¼"
  
  #: c-family/c-pragma.c:544
  #, gcc-internal-format
  msgid "#pragma redefine_extname ignored due to conflict with previous #pragma redefine_extname"
-msgstr "#pragma redefine_extname игнорирована, поскольку конфликтует с предыдущей  директивой #pragma redefine_extname"
+msgstr "#pragma redefine_extname Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð°, Ð¿Ð¾Ñ\81ÐºÐ¾Ð»Ñ\8cÐºÑ\83 ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83ÐµÑ\82 Ñ\81 Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹  Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð¾Ð¹ #pragma redefine_extname"
  
  #: c-family/c-pragma.c:580
  #, gcc-internal-format
@@ -27283,7 +28538,7 @@ msgstr "отсутствует %<(%> после %<#pragma GCC visibility push%>
  #: c-family/c-pragma.c:728
  #, gcc-internal-format
  msgid "malformed #pragma GCC visibility push"
-msgstr "Ð\9dекорректный синтаксис #pragma builtin"
+msgstr "Ð½екорректный синтаксис #pragma builtin"
  
  #: c-family/c-pragma.c:736
  #, gcc-internal-format
@@ -27292,188 +28547,191 @@ msgstr "мусор в конце %<#pragma GCC visibility%>"
  
  #: c-family/c-pragma.c:748
  #, fuzzy, gcc-internal-format
+#| msgid "missing [error|warning|ignored] after %<#pragma GCC diagnostic%>"
  msgid "missing [error|warning|ignored|push|pop] after %<#pragma GCC diagnostic%>"
-msgstr "отсутствует %<(%> после %<#pragma pack%> - директива проигнорирована"
+msgstr "отсутствует [error|warning|ignored] после %<#pragma GCC diagnostic%>"
  
  #: c-family/c-pragma.c:774
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected [error|warning|ignored|push|pop] after %<#pragma GCC diagnostic%>"
-msgstr "отсутствует %<(%> после %<#pragma pack%> - директива проигнорирована"
+msgstr "ожидалось [error|warning|ignored|push|pop] после %<#pragma GCC diagnostic%>"
  
  #: c-family/c-pragma.c:783
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "missing option after %<#pragma GCC diagnostic%> kind"
-msgstr "отсутствует %<(%> после %<#pragma pack%> - директива проигнорирована"
+msgstr "отсутствует опция после %<#pragma GCC diagnostic%> kind"
  
  #: c-family/c-pragma.c:794
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unknown option after %<#pragma GCC diagnostic%> kind"
-msgstr "Ð½ÐµÐ¾Ð¿Ð¾Ð·Ð½Ð°Ð½Ð½Ð¾Ðµ Ð´ÐµÐ¹Ñ\81Ñ\82Ð²Ð¸Ðµ %qs Ð² %<#pragma pack%> - Ð´ÐµÐ¹Ñ\81Ñ\82Ð²Ð¸Ðµ Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¾"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¾Ð¿Ñ\86Ð¸Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ %<#pragma GCC diagnostic%> kind"
  
  #: c-family/c-pragma.c:800
  #, fuzzy, gcc-internal-format
+#| msgid "%qs is not a valid option to the preprocessor"
  msgid "%qs is not an option that controls warnings"
-msgstr "неверный ключ препроцессора \"%s\""
+msgstr "неверный ключ препроцессора %qs"
  
  #: c-family/c-pragma.c:808
  #, fuzzy, gcc-internal-format
+#| msgid "command line option %qs is valid for %s but not for %s"
  msgid "option %qs is valid for %s but not for %s"
-msgstr "ключ \"%s\" годится для %s, но не для %s"
+msgstr "ключ %qs годится для %s, но не для %s"
  
  #: c-family/c-pragma.c:840
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "#pragma GCC option is not allowed inside functions"
-msgstr "фигурные скобки внутри выражений допускаются только в теле функции"
+msgstr "#pragma GCC option не допускается внутри функций"
  
  #: c-family/c-pragma.c:853
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<#pragma GCC option%> is not a string"
-msgstr "некорректно употреблять %<#pragma%>"
+msgstr "%<#pragma GCC option%> не является строковым литералом"
  
  #: c-family/c-pragma.c:880
  #, gcc-internal-format
  msgid "%<#pragma GCC target (string [,string]...)%> does not have a final %<)%>"
-msgstr ""
+msgstr "%<#pragma GCC target (string [,string]...)%> не имеет закрывающей %<)%>"
  
  #: c-family/c-pragma.c:886
  #, gcc-internal-format
  msgid "#pragma GCC target string... is badly formed"
-msgstr ""
+msgstr "#pragma GCC target string... оформлена некорректно"
  
  #: c-family/c-pragma.c:909
  #, gcc-internal-format
  msgid "#pragma GCC optimize is not allowed inside functions"
-msgstr ""
+msgstr "#pragma GCC optimize не допускается внутри функций"
  
  #: c-family/c-pragma.c:922
  #, gcc-internal-format
  msgid "%<#pragma GCC optimize%> is not a string or number"
-msgstr ""
+msgstr "%<#pragma GCC optimize%> не строка и не число"
  
  #: c-family/c-pragma.c:948
  #, gcc-internal-format
  msgid "%<#pragma GCC optimize (string [,string]...)%> does not have a final %<)%>"
-msgstr ""
+msgstr "%<#pragma GCC optimize (string [,string]...)%> не имеет закрывающей %<)%>"
  
  #: c-family/c-pragma.c:954
  #, gcc-internal-format
  msgid "#pragma GCC optimize string... is badly formed"
-msgstr ""
+msgstr "#pragma GCC optimize string... оформлена некорректно"
  
  #: c-family/c-pragma.c:995
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of %<#pragma push_options%>"
-msgstr "мусор в конце директивы %<#pragma pack%>"
+msgstr "мусор в конце директивы %<#pragma push_options%>"
  
  #: c-family/c-pragma.c:1025
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of %<#pragma pop_options%>"
-msgstr "мусор в конце директивы %<#pragma pack%>"
+msgstr "мусор в конце директивы %<#pragma pop_options%>"
  
  #: c-family/c-pragma.c:1032
  #, gcc-internal-format
  msgid "%<#pragma GCC pop_options%> without a corresponding %<#pragma GCC push_options%>"
-msgstr ""
+msgstr "%<#pragma GCC pop_options%> без соответствующей %<#pragma GCC push_options%>"
  
  #: c-family/c-pragma.c:1074
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of %<#pragma reset_options%>"
-msgstr "мусор в конце директивы '#pragma options'"
+msgstr "мусор в конце директивы %<#pragma reset_options%>"
  
  #: c-family/c-pragma.c:1112 c-family/c-pragma.c:1119
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected a string after %<#pragma message%>"
-msgstr "ожидался строковый литерал"
+msgstr "ожидался строковый литерал после %<#pragma message%>"
  
  #: c-family/c-pragma.c:1114
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed %<#pragma message%>, ignored"
-msgstr "неверный синтаксис #pragma weak, директива проигнорирована"
+msgstr "неверный синтаксис %<#pragma message%>, директива проигнорирована"
  
  #: c-family/c-pragma.c:1124
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of %<#pragma message%>"
-msgstr "мусор в конце директивы %<#pragma pack%>"
+msgstr "мусор в конце директивы %<#pragma message%>"
  
  #: c-family/c-pragma.c:1127
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "#pragma message: %s"
-msgstr "программы: %s\n"
+msgstr "#pragma message: %s"
  
  #: c-family/c-pragma.c:1164
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid location for %<pragma %s%>, ignored"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð² %<#pragma pack%> - директива проигнорирована"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ñ\80Ð°Ñ\81Ð¿Ð¾Ð»Ð¾Ð¶ÐµÐ½Ð¸Ðµ Ð´Ð»Ñ\8f %<pragma %s%>, директива проигнорирована"
  
  #: c-family/c-pragma.c:1171 c-family/c-pragma.c:1185
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed %<#pragma %s%>, ignored"
-msgstr "некорректный синтаксис %<#pragma pack%> - директива проигнорирована"
+msgstr "некорректный синтаксис %<#pragma %s%>, директива проигнорирована"
  
  #: c-family/c-pragma.c:1191
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of %<#pragma %s%>"
-msgstr "мусор в конце #pragma %s"
+msgstr "мусор в конце директивы %<#pragma %s%>"
  
  #: c-family/c-pragma.c:1209
  #, gcc-internal-format
  msgid "%<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported for C++"
-msgstr ""
+msgstr "%<#pragma STDC FLOAT_CONST_DECIMAL64%> не поддерживается для C++"
  
  #: c-family/c-pragma.c:1218
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<#pragma STDC FLOAT_CONST_DECIMAL64%> is not supported on this target"
-msgstr "#pragma extern_prefix для этой платформы не поддерживается"
+msgstr "%<#pragma STDC FLOAT_CONST_DECIMAL64%> не поддерживается на этой целевой платформе"
  
  #: c-family/c-pragma.c:1224
  #, gcc-internal-format
  msgid "ISO C does not support %<#pragma STDC FLOAT_CONST_DECIMAL64%>"
-msgstr ""
+msgstr "ISO C не поддерживает %<#pragma STDC FLOAT_CONST_DECIMAL64%>"
  
  #: c-family/c-pretty-print.c:327
  #, gcc-internal-format
  msgid "<type-error>"
-msgstr ""
+msgstr "<ошибка типа>"
  
  #: c-family/c-pretty-print.c:366
  #, gcc-internal-format
  msgid "<unnamed-unsigned:"
-msgstr ""
+msgstr "<unnamed-unsigned:"
  
  #: c-family/c-pretty-print.c:370
  #, gcc-internal-format
  msgid "<unnamed-float:"
-msgstr ""
+msgstr "<unnamed-float:"
  
  #: c-family/c-pretty-print.c:373
  #, gcc-internal-format
  msgid "<unnamed-fixed:"
-msgstr ""
+msgstr "<unnamed-fixed:"
  
  #: c-family/c-pretty-print.c:388
  #, gcc-internal-format
  msgid "<typedef-error>"
-msgstr ""
+msgstr "<ошибка typedef>"
  
  #: c-family/c-pretty-print.c:403
  #, gcc-internal-format
  msgid "<tag-error>"
-msgstr ""
+msgstr "<ошибка тега>"
  
  #: c-family/c-pretty-print.c:1241
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "<erroneous-expression>"
-msgstr "  в throw-выражении"
+msgstr "<ошибочное выражение>"
  
  #: c-family/c-pretty-print.c:1245 cp/cxx-pretty-print.c:137
  #, gcc-internal-format
  msgid "<return-value>"
-msgstr ""
+msgstr "<return-значение>"
  
  #: c-family/c-semantics.c:152
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "wrong type argument to %s"
-msgstr "неверный тип аргумента для abs"
+msgstr "неверный аргумент типа для %s"
  
  #: c-family/cilk.c:93 cp/parser.c:6518
  #, fuzzy, gcc-internal-format
@@ -27483,19 +28741,21 @@ msgstr "%<friend%> может быть задан только внутри кл
  
  #: c-family/cilk.c:106
  #, fuzzy, gcc-internal-format
-#| msgid "virtual functions cannot be friends"
+#| msgid "only one -flto-partition value can be specified"
  msgid "only function calls can be spawned"
-msgstr "Ð²Ð¸Ñ\80Ñ\82Ñ\83Ð°Ð»Ñ\8cÐ½Ñ\8bÐµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð½Ðµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð±Ñ\8bÑ\82Ñ\8c friend-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8fÐ¼Ð¸"
+msgstr "Ð¼Ð¾Ð¶Ð½Ð¾ Ð·Ð°Ð´Ð°Ñ\82Ñ\8c Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ -flto-partition"
  
  #: c-family/cilk.c:250
  #, fuzzy, gcc-internal-format
+#| msgid "invalid use of %<auto%>"
  msgid "invalid use of %<_Cilk_spawn%>"
-msgstr "недопустимое использование %<::%>"
+msgstr "недопустимое использование %<auto%>"
  
  #: c-family/cilk.c:392
  #, fuzzy, gcc-internal-format
+#| msgid "address of explicit register variable %qD requested"
  msgid "explicit register variable %qD may not be modified in spawn"
-msgstr "Ð·Ð°Ð¿Ñ\80Ð¾Ñ\88ÐµÐ½ Ð°Ð´Ñ\80ÐµÑ\81 Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qs"
+msgstr "Ð·Ð°Ð¿Ñ\80Ð¾Ñ\88ÐµÐ½ Ð°Ð´Ñ\80ÐµÑ\81 Ñ\8fÐ²Ð½Ð¾Ð¹ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qD"
  
  #: c-family/cilk.c:473
  #, gcc-internal-format
@@ -27504,8 +28764,9 @@ msgstr ""
  
  #: c-family/cilk.c:494
  #, fuzzy, gcc-internal-format
+#| msgid "invalid use of %qD in linkage specification"
  msgid "invalid use of label %q+D in %<_Cilk_spawn%>"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð±Ð°Ð·Ð¾Ð²Ð¾Ð³Ð¾ ÐºÐ»Ð°Ñ\81Ñ\81Ð°"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ %qD Ð² Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð¿Ñ\80Ð¸Ð²Ñ\8fÐ·ÐºÐ¸"
  
  #: c-family/cilk.c:991
  #, gcc-internal-format
@@ -27513,19 +28774,21 @@ msgid "register assignment ignored for %qD used in Cilk block"
  msgstr ""
  
  #: c-family/cppspec.c:93
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs is not a valid option to the preprocessor"
-msgstr "неверный ключ препроцессора \"%s\""
+msgstr "неверный ключ препроцессора %qs"
  
  #: c-family/cppspec.c:112
  #, gcc-internal-format
  msgid "too many input files"
  msgstr "слишком много входных файлов"
  
+#
  #: common/config/aarch64/aarch64-common.c:315 config/aarch64/aarch64.c:8164
  #, fuzzy, gcc-internal-format
+#| msgid "unknown value %s for -mfpu"
  msgid "unknown value %qs for -mcpu"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %qs Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mcpu"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ %s Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mfpu"
  
  #: common/config/alpha/alpha-common.c:76
  #, gcc-internal-format
@@ -27540,8 +28803,9 @@ msgstr "задано несколько атрибутов типа функци
  
  #: common/config/arc/arc-common.c:127
  #, fuzzy, gcc-internal-format
+#| msgid "bad value %qs for -mtune switch"
  msgid "bad value %qs for -mmpy-option switch"
-msgstr "некорректное значение (%s) для ключа -mtune="
+msgstr "некорректное значение %qs для ключа -mtune"
  
  #: common/config/bfin/bfin-common.c:303 common/config/m68k/m68k-common.c:60
  #, gcc-internal-format, gfc-internal-format
@@ -27556,62 +28820,64 @@ msgstr "недопустимый параметр -mcpu=%s"
  #: common/config/bfin/bfin-common.c:358
  #, gcc-internal-format, gfc-internal-format
  msgid "-mcpu=%s has invalid silicon revision"
-msgstr ""
+msgstr "-mcpu=%s имеет некорректную кремниевую версию"
  
  #: common/config/i386/i386-common.c:985
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-malign-loops is obsolete, use -falign-loops"
-msgstr "-malign-loops - устаревший ключ, используйте -falign-loops"
+msgstr "-malign-loops устарело, используйте -falign-loops"
  
  #: common/config/i386/i386-common.c:987
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "-malign-loops=%d is not between 0 and %d"
-msgstr "-malign-loops=%d Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° 0 - %d"
+msgstr "-malign-loops=%d Ð½Ðµ Ð¼ÐµÐ¶Ð´Ñ\83 0 Ð¸ %d"
  
  #: common/config/i386/i386-common.c:994
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-malign-jumps is obsolete, use -falign-jumps"
-msgstr "-malign-jumps - устаревший ключ, используйте -falign-jumps"
+msgstr "-malign-jumps устаревший ключ, используйте -falign-jumps"
  
  #: common/config/i386/i386-common.c:996
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "-malign-jumps=%d is not between 0 and %d"
-msgstr "-malign-loops=%d Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° 0 - %d"
+msgstr "-malign-loops=%d Ð½Ðµ Ð¼ÐµÐ¶Ð´Ñ\83 0 Ð¸ %d"
  
  #: common/config/i386/i386-common.c:1004
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-malign-functions is obsolete, use -falign-functions"
-msgstr "-malign-functions - устаревший ключ, используйте -falign-functions"
+msgstr "-malign-functions устаревший ключ, используйте -falign-functions"
  
  #: common/config/i386/i386-common.c:1006
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "-malign-functions=%d is not between 0 and %d"
-msgstr "-malign-loops=%d Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° 0 - %d"
+msgstr "-malign-loops=%d Ð½Ðµ Ð¼ÐµÐ¶Ð´Ñ\83 0 Ð¸ %d"
  
  #: common/config/i386/i386-common.c:1015
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "-mbranch-cost=%d is not between 0 and 5"
-msgstr "-mbranch-cost=%d Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° 0 - 5"
+msgstr "-mbranch-cost=%d Ð½Ðµ Ð¼ÐµÐ¶Ð´Ñ\83 0 Ð¸ 5"
  
  #: common/config/i386/i386-common.c:1069
  #, gcc-internal-format
  msgid "%<-fsplit-stack%> currently only supported on GNU/Linux"
-msgstr ""
+msgstr "%<-fsplit-stack%> в настоящее время поддерживается только на GNU/Linux"
  
  #: common/config/i386/i386-common.c:1075
  #, gcc-internal-format
  msgid "%<-fsplit-stack%> requires assembler support for CFI directives"
-msgstr ""
+msgstr "%<-fsplit-stack%> требует поддержку ассемблера для CFI директив"
  
  #: common/config/ia64/ia64-common.c:58
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "bad value %<%s%> for -mtls-size= switch"
-msgstr "некорректное значение (%s) для ключа -mtls-size"
+msgstr "некорректное значение %<%s%> для ключа -mtls-size="
  
+#
  #: common/config/msp430/msp430-common.c:57
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "unrecognized argument to -mmcu= option: %qs"
  msgid "unrecognised argument of -mcpu: %s"
-msgstr "Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ðµ: Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° --help=: %.*s\n"
+msgstr "Ð½ÐµÐ¾Ð¿Ð¾Ð·Ð½Ð°Ð½Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° -mmcu= option: %qs"
  
  #: common/config/nds32/nds32-common.c:49
  #, gcc-internal-format
@@ -27629,54 +28895,56 @@ msgid "unknown -mdebug-%s switch"
  msgstr "некорректный ключ -mdebug-%s"
  
  #: common/config/rs6000/rs6000-common.c:220
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "unknown switch -mlong-double-%s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºтный ключ -mlong-double-%s"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81тный ключ -mlong-double-%s"
  
  #: common/config/rs6000/rs6000-common.c:230
  #, gcc-internal-format
  msgid "-msingle-float option equivalent to -mhard-float"
-msgstr ""
+msgstr "опция -msingle-float эквивалентна -mhard-float"
  
  #: common/config/rs6000/rs6000-common.c:246
  #, gcc-internal-format
  msgid "-msimple-fpu option ignored"
-msgstr ""
+msgstr "опция -msimple-fpu игнорируется"
  
  #: common/config/rs6000/rs6000-common.c:312
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<-fsplit-stack%> currently only supported on GNU/Linux"
  msgid "%<-fsplit-stack%> currently only supported on PowerPC64 GNU/Linux with glibc-2.18 or later"
-msgstr ""
+msgstr "%<-fsplit-stack%> в настоящее время поддерживается только на GNU/Linux"
  
  #: common/config/rx/rx-common.c:61
  #, gcc-internal-format
  msgid "the RX200 cpu does not have FPU hardware"
-msgstr ""
+msgstr "процессор RX200 не оборудован FPU"
  
  #: common/config/rx/rx-common.c:63
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "the RX200 cpu does not have FPU hardware"
  msgid "the RX100 cpu does not have FPU hardware"
-msgstr ""
+msgstr "процессор RX200 не оборудован FPU"
  
  #: common/config/s390/s390-common.c:95
  #, gcc-internal-format
  msgid "stack guard value must be an exact power of 2"
-msgstr ""
+msgstr "охраняющее значение стека должно быть точной степенью 2"
  
  #: common/config/s390/s390-common.c:100
  #, gcc-internal-format
  msgid "stack size must be an exact power of 2"
-msgstr ""
+msgstr "размер стека должен быть точной степенью 2"
  
  #: common/config/v850/v850-common.c:47
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "value passed in %qs is too large"
-msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ слишком велико"
+msgstr "Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ, Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð½Ð¾Ðµ Ð² %qs слишком велико"
  
  #: config/darwin-c.c:81
  #, gcc-internal-format
  msgid "too many #pragma options align=reset"
-msgstr "Слишком много #pragma-ключей align=reset"
+msgstr "слишком много #pragma-ключей align=reset"
  
  #: config/darwin-c.c:101 config/darwin-c.c:104 config/darwin-c.c:106
  #: config/darwin-c.c:108
@@ -27710,19 +28978,19 @@ msgid "junk at end of '#pragma unused'"
  msgstr "мусор в конце директивы '#pragma unused'"
  
  #: config/darwin-c.c:168
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed '#pragma ms_struct', ignoring"
-msgstr "некорректная директива '#pragma options', игнорируется"
+msgstr "некорректная директива '#pragma ms_struct', игнорируется"
  
  #: config/darwin-c.c:176
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed '#pragma ms_struct {on|off|reset}', ignoring"
-msgstr "некорректная директива '#pragma options', игнорируется"
+msgstr "некорректная директива '#pragma ms_struct {on|off|reset}', игнорируется"
  
  #: config/darwin-c.c:179
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of '#pragma ms_struct'"
-msgstr "мусор в конце '#pragma %s'"
+msgstr "мусор в конце директивы '#pragma ms_struct'"
  
  #: config/darwin-c.c:405
  #, gcc-internal-format, gfc-internal-format
@@ -27730,30 +28998,32 @@ msgid "subframework include %s conflicts with framework include"
  msgstr "включение подсистемы %s конфликтует с включением системы"
  
  #: config/darwin-c.c:717
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unknown value %qs of -mmacosx-version-min"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºтное значение %qs ключа -mmacosx-version-min"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81тное значение %qs ключа -mmacosx-version-min"
  
  #: config/darwin-driver.c:50
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "sysctl for kern.osversion failed: %m"
-msgstr "Не выполнено необходимое условие в коде CRIS: "
+msgstr "sysctl для kern.osversion завершился неудачей: %m"
  
  #: config/darwin-driver.c:84
  #, gcc-internal-format
  msgid "couldn%'t understand kern.osversion %q.*s"
-msgstr ""
+msgstr "непонятно kern.osversion %q.*s"
  
  #. Arbitrary limit, number should be like xx.yy.zz
  #: config/darwin-driver.c:124
  #, fuzzy, gcc-internal-format
+#| msgid "couldn%'t understand kern.osversion %q.*s"
  msgid "couldn%'t understand version %s\n"
-msgstr "collect2 версия %s"
+msgstr "непонятно kern.osversion %q.*s"
  
  #: config/darwin-driver.c:177
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "this target does not support %qs"
  msgid "this compiler does not support %s"
-msgstr "%s не поддерживает %s"
+msgstr "для этой целевой платформы не поддерживается %qs"
  
  #: config/darwin-driver.c:232
  #, gcc-internal-format
@@ -27762,23 +29032,27 @@ msgstr ""
  
  #: config/darwin-driver.c:236
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "-mcpu=%s conflicts with -march=%s"
  msgid "%s conflicts with i386 (arch flags ignored)"
-msgstr "ключ -mcpu=%s несовместим с ключом -march="
+msgstr "-mcpu=%s конфликтует с -march=%s"
  
  #: config/darwin-driver.c:244
  #, gcc-internal-format, gfc-internal-format
  msgid "%s conflicts with x86_64 (arch flags ignored)"
  msgstr ""
  
+#
  #: config/darwin-driver.c:251
  #, fuzzy, gcc-internal-format
+#| msgid "The C parser does not support -dy, option ignored"
  msgid "this compiler does not support X86 (arch flags ignored)"
-msgstr "реентерабельный код APCS не поддерживается. Ключ игнорируется."
+msgstr "C парсер не поддерживает -dy, опция игнорируется"
  
  #: config/darwin-driver.c:255
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "-mcpu=%s conflicts with -march=%s"
  msgid "%s conflicts with ppc (arch flags ignored)"
-msgstr "ключ -mcpu=%s несовместим с ключом -march="
+msgstr "-mcpu=%s конфликтует с -march=%s"
  
  #: config/darwin-driver.c:263
  #, gcc-internal-format, gfc-internal-format
@@ -27788,127 +29062,128 @@ msgstr ""
  #: config/darwin.c:1650
  #, gcc-internal-format
  msgid "the use of _OBJC_-prefixed variable names to select meta-data sections is deprecated at 4.6 and will be removed in 4.7"
-msgstr ""
+msgstr "использование имен переменных с _OBJC_-префиксами для выбора секций метаданных не рекомендуется в 4.6 и не будет поддерживаться в 4.7"
  
  #: config/darwin.c:1905
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "failed to open temporary file %s for LTO output"
-msgstr "не удалось открыть временный файл ответа %s"
+msgstr "не удалось открыть временный файл %s для LTO вывода"
  
  #: config/darwin.c:1994
  #, gcc-internal-format
  msgid "%qE 2.95 vtable-compatibility attribute applies only when compiling a kext"
-msgstr ""
+msgstr "атрибут %qE 2.95 vtable-совместимости применим только при компиляции kext"
  
  #: config/darwin.c:2001
  #, gcc-internal-format
  msgid "%qE 2.95 vtable-compatibility attribute applies only to C++ classes"
-msgstr ""
+msgstr "атрибут %qE 2.95 vtable-совместимости применим только к классам C++"
  
  #: config/darwin.c:2713
  #, fuzzy, gcc-internal-format
+#| msgid "visibility attribute not supported in this configuration; ignored"
  msgid "protected visibility attribute not supported in this configuration; ignored"
  msgstr "атрибут видимости не поддерживается в данной конфигурации; определение игнорируется"
  
  #: config/darwin.c:2899
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "failed to open temporary file %s with LTO output"
-msgstr "не удалось открыть временный файл ответа %s"
+msgstr "не удалось открыть временный файл %s с LTO выводом"
  
  #: config/darwin.c:3072
  #, gcc-internal-format
  msgid "%<-fobjc-abi-version%> >= 2 must be used for %<-m64%> targets with %<-fnext-runtime%>"
-msgstr ""
+msgstr "%<-fobjc-abi-version%> >= 2 следует использовать для %<-m64%> целевых платформ с %<-fnext-runtime%>"
  
  #: config/darwin.c:3076
  #, gcc-internal-format
  msgid "%<-fobjc-abi-version%> >= 2 is not supported on %<-m32%> targets with %<-fnext-runtime%>"
-msgstr ""
+msgstr "%<-fobjc-abi-version%> >= 2 не поддерживается на %<-m32%> целевых платформах с %<-fnext-runtime%>"
  
  #: config/darwin.c:3161
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<-mdynamic-no-pic%> overrides %<-fpic%>, %<-fPIC%>, %<-fpie%> or %<-fPIE%>"
-msgstr "-mdynamic-no-pic отменяет -fpic или -fPIC"
+msgstr "%<-mdynamic-no-pic%> перебивает %<-fpic%>, %<-fPIC%>, %<-fpie%> или %<-fPIE%>"
  
  #: config/darwin.c:3349
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "built-in function %qD requires the %<-mconstant-cfstrings%> flag"
-msgstr "внутренняя функция %q+D декларирована как не функция"
+msgstr "внутренняя функция %qD требует флаг %<-mconstant-cfstrings%>"
  
  #: config/darwin.c:3356
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "built-in function %qD takes one argument only"
-msgstr "внутренняя функция %q+D декларирована как не функция"
+msgstr "внутренняя функция %qD принимает только один аргумент"
  
  #: config/darwin.c:3442
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "CFString literal is missing"
-msgstr "Ð½Ðµ Ð·Ð°Ð´Ð°Ð½ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° '-Xlinker'"
+msgstr "Ð¿Ñ\80Ð¾Ð¿Ñ\83Ñ\89ÐµÐ½ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð» CFString"
  
  #: config/darwin.c:3453
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "CFString literal expression is not a string constant"
-msgstr "целочисленное выражение %qE не является константой"
+msgstr "литеральное выражение CFString не является строковой константой"
  
  #: config/darwin.c:3476
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s in CFString literal"
-msgstr "ожидался строковый литерал"
+msgstr "%s в CFString литерале"
  
  #: config/host-darwin.c:61
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "couldn%'t unmap pch_address_space: %m"
-msgstr "Ð\9eÑ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80Ð¸ Ð´ÐµÑ\88Ð¸Ñ\84Ñ\80Ð¾Ð²ÐºÐµ pch_address_space: %m\n"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ñ\81Ð´ÐµÐ»Ð°Ñ\82Ñ\8c unmap pch_address_space: %m"
  
  #: config/sol2-c.c:91 config/sol2-c.c:107
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed %<#pragma align%>, ignoring"
-msgstr "некорректный синтаксис #pragma align - директива проигнорирована"
+msgstr "некорректный синтаксис %<#pragma align%>, директива проигнорирована"
  
  #: config/sol2-c.c:100
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid alignment for %<#pragma align%>, ignoring"
-msgstr "некорректный синтаксис #pragma align - директива проигнорирована"
+msgstr "некорректное выравнивание для %<#pragma align%>, директива проигнорирована"
  
  #: config/sol2-c.c:115
  #, gcc-internal-format
  msgid "%<#pragma align%> must appear before the declaration of %D, ignoring"
-msgstr ""
+msgstr "%<#pragma align%> должна предшествовать декларации %D, игнорируется"
  
  #: config/sol2-c.c:127 config/sol2-c.c:139
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed %<#pragma align%>"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma builtin"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 %<#pragma align%>"
  
  #: config/sol2-c.c:134
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of %<#pragma align%>"
-msgstr "мусор в конце #pragma %s"
+msgstr "мусор в конце директивы %<#pragma align%>"
  
  #: config/sol2-c.c:155 config/sol2-c.c:162
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed %<#pragma init%>, ignoring"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° '#pragma options', игнорируется"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾ Ð¾Ñ\84Ð¾Ñ\80Ð¼Ð»ÐµÐ½Ð° Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° %<#pragma init%>, игнорируется"
  
  #: config/sol2-c.c:186 config/sol2-c.c:198
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed %<#pragma init%>"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma builtin"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾ Ð¾Ñ\84Ð¾Ñ\80Ð¼Ð»ÐµÐ½Ð° Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° %<#pragma init%>"
  
  #: config/sol2-c.c:193
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of %<#pragma init%>"
-msgstr "мусор в конце #pragma %s"
+msgstr "мусор в конце директивы %<#pragma init%>"
  
  #: config/sol2-c.c:214 config/sol2-c.c:221
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed %<#pragma fini%>, ignoring"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° '#pragma options', игнорируется"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾ Ð¾Ñ\84Ð¾Ñ\80Ð¼Ð»ÐµÐ½Ð° Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° %<#pragma fini%>', игнорируется"
  
  #: config/sol2-c.c:245 config/sol2-c.c:257
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed %<#pragma fini%>"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma builtin"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾ Ð¾Ñ\84Ð¾Ñ\80Ð¼Ð»ÐµÐ½Ð° Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° %<#pragma fini%>"
  
  #: config/sol2-c.c:252
  #, gcc-internal-format
@@ -27921,9 +29196,9 @@ msgid "ignoring %<#pragma align%> for explicitly aligned %q+D"
  msgstr "игнорируется %<#pragma align%> для явно выравненного %q+D"
  
  #: config/vxworks.c:145
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "PIC is only supported for RTPs"
-msgstr "Ð² TFP-OS Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f static"
+msgstr "Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾-Ð½ÐµÐ·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ñ\8bÐ¹ ÐºÐ¾Ð´ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f RTPs"
  
  #. Mach-O supports 'weak imports', and 'weak definitions' in coalesced
  #. sections.  machopic_select_section ensures that weak variables go in
@@ -27943,28 +29218,35 @@ msgstr "поддержка профилирования для VxWorks"
  
  #: config/aarch64/aarch64-builtins.c:1003 config/arm/arm-builtins.c:2122
  #, fuzzy, gcc-internal-format
+#| msgid "argument must be a constant"
  msgid "%Kargument %d must be a constant immediate"
-msgstr "аргумент %qD не является константой"
+msgstr "аргумент должен быть константой"
  
+#
  #: config/aarch64/aarch64-builtins.c:1074 config/arm/arm-builtins.c:2241
  #, fuzzy, gcc-internal-format
+#| msgid "index mask must be an immediate"
  msgid "%Klane index must be a constant immediate"
-msgstr "маска должна быть непосредственным значением"
+msgstr "Ð¼Ð°Ñ\81ÐºÐ° Ð¸Ð½Ð´ÐµÐºÑ\81Ð° Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
  
+#
  #: config/aarch64/aarch64-builtins.c:1077
  #, fuzzy, gcc-internal-format
+#| msgid "the second argument must be a 4-bit immediate"
  msgid "%Ktotal size and element size must be a non-zero constant immediate"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "второй аргумент должен быть 4-битным непосредственным"
  
  #: config/aarch64/aarch64.c:721
  #, fuzzy, gcc-internal-format
+#| msgid "%qs is incompatible with %qs"
  msgid "%qs is incompatible with %s %s"
-msgstr "ключ -march=%s несовместим с выбранным ABI"
+msgstr "%qs несовместим с %qs"
  
  #: config/aarch64/aarch64.c:723
  #, fuzzy, gcc-internal-format
+#| msgid "%qs is incompatible with %qs"
  msgid "%qs feature modifier is incompatible with %s %s"
-msgstr "ключ -march=%s несовместим с выбранным ABI"
+msgstr "%qs несовместим с %qs"
  
  #: config/aarch64/aarch64.c:7830
  #, gcc-internal-format, gfc-internal-format
@@ -27978,53 +29260,64 @@ msgstr ""
  
  #: config/aarch64/aarch64.c:7931
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Invalid range %s in option %s"
  msgid "tuning string missing in option (%s)"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸: -mfpu=%s"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½ %s Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° %s"
  
  #: config/aarch64/aarch64.c:7949
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "unknown spec function %qs"
  msgid "unknown tuning option (%s)"
-msgstr "неизвестная функция '%s' в спецификации"
+msgstr "неизвестная функция %qs в спецификации"
  
  #: config/aarch64/aarch64.c:8161
  #, fuzzy, gcc-internal-format
+#| msgid "missing path after %qs"
  msgid "missing cpu name in -mcpu=%qs"
  msgstr "не задан маршрут после %qs"
  
  #: config/aarch64/aarch64.c:8167
  #, fuzzy, gcc-internal-format
+#| msgid "invalid pointer mode %qs"
  msgid "invalid feature modifier in -mcpu=%qs"
-msgstr "неизвестная машинный режим %qs"
+msgstr "неизвестная машинный режим %qs для указателя"
  
  #: config/aarch64/aarch64.c:8194
  #, fuzzy, gcc-internal-format
+#| msgid "missing path after %qs"
  msgid "missing arch name in -march=%qs"
  msgstr "не задан маршрут после %qs"
  
+#
  #: config/aarch64/aarch64.c:8197
  #, fuzzy, gcc-internal-format
+#| msgid "unknown value %s for -mfpu"
  msgid "unknown value %qs for -march"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %qs Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mcpu"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ %s Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mfpu"
  
  #: config/aarch64/aarch64.c:8200
  #, fuzzy, gcc-internal-format
+#| msgid "invalid data model option -mdata-model=%s"
  msgid "invalid feature modifier in -march=%qs"
-msgstr "не задано имя файла после %qs"
+msgstr "некорректная опция модели данных -mdata-model=%s"
  
  #: config/aarch64/aarch64.c:8226
  #, fuzzy, gcc-internal-format
+#| msgid "missing filename after %qs"
  msgid "missing cpu name in -mtune=%qs"
-msgstr "не задан маршрут после %qs"
+msgstr "не задано имя файла после %qs"
  
+#
  #: config/aarch64/aarch64.c:8229
  #, fuzzy, gcc-internal-format
+#| msgid "unknown value %s for -mfpu"
  msgid "unknown value %qs for -mtune"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %qs Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mcpu"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ %s Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mfpu"
  
  #: config/aarch64/aarch64.c:8331 config/arm/arm.c:3007
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "switch -mcpu=%s conflicts with -march=%s switch"
-msgstr "ключ -mcpu=%s несовместим с ключом -march="
+msgstr "ключ -mcpu=%s несовместим с ключом -march=%s"
  
  #: config/aarch64/aarch64.c:8366
  #, fuzzy, gcc-internal-format
@@ -28038,49 +29331,58 @@ msgid "code model %qs with -f%s"
  msgstr ""
  
  #: config/aarch64/aarch64.c:8597
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "missing architecture name in 'arch' target %s"
-msgstr "не задан маршрут после %qs"
+msgstr ""
  
+#
  #: config/aarch64/aarch64.c:8600
  #, fuzzy, gcc-internal-format
+#| msgid "unknown value %s for -mfpu"
  msgid "unknown value %qs for 'arch' target %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %qs Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mcpu"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ %s Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mfpu"
  
  #: config/aarch64/aarch64.c:8603
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid feature modifier %qs for 'arch' target %s"
-msgstr "не задано имя файла после %qs"
+msgstr ""
  
  #: config/aarch64/aarch64.c:8637
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "missing makefile target after %qs"
  msgid "missing cpu name in 'cpu' target %s"
-msgstr "не задан маршрут после %qs"
+msgstr "не задана цель после %qs"
  
+#
  #: config/aarch64/aarch64.c:8640
  #, fuzzy, gcc-internal-format
+#| msgid "unknown value %s for -mfpu"
  msgid "unknown value %qs for 'cpu' target %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %qs Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mcpu"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ %s Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mfpu"
  
  #: config/aarch64/aarch64.c:8643
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid feature modifier %qs for 'cpu' target %s"
-msgstr "не задано имя файла после %qs"
+msgstr ""
  
+#
  #: config/aarch64/aarch64.c:8674
  #, fuzzy, gcc-internal-format
+#| msgid "unknown value %s for -mfpu"
  msgid "unknown value %qs for 'tune' target %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %qs Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mcpu"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ %s Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mfpu"
  
  #: config/aarch64/aarch64.c:8714
  #, fuzzy, gcc-internal-format
+#| msgid "missing makefile target after %qs"
  msgid "missing feature modifier in target %s %qs"
-msgstr "Ð½Ðµ Ð·Ð°Ð´Ð°Ð½Ð¾ Ð¸Ð¼Ñ\8f Ñ\84Ð°Ð¹Ð»Ð° после %qs"
+msgstr "Ð½Ðµ Ð·Ð°Ð´Ð°Ð½Ð° Ñ\86ÐµÐ»Ñ\8c после %qs"
  
  #: config/aarch64/aarch64.c:8719
  #, fuzzy, gcc-internal-format
+#| msgid "invalid memory model argument %d of %qE"
  msgid "invalid feature modifier in target %s %qs"
-msgstr "не задано имя файла после %qs"
+msgstr "некорректный аргумент %d модели памяти для %qE"
  
  #: config/aarch64/aarch64.c:8769
  #, fuzzy, gcc-internal-format, gfc-internal-format
@@ -28090,8 +29392,9 @@ msgstr "некорректные аргументы spec-функции"
  
  #: config/aarch64/aarch64.c:8817
  #, fuzzy, gcc-internal-format
+#| msgid "%s only accepts 1 argument"
  msgid "target %s %qs does not accept an argument"
-msgstr "%q+D может быть функцией с двумя аргументами, либо функцией без аргументов"
+msgstr "%s принимает только 1 аргумент"
  
  #: config/aarch64/aarch64.c:8826
  #, fuzzy, gcc-internal-format
@@ -28101,18 +29404,21 @@ msgstr "ограничитель не допускает использован
  
  #: config/aarch64/aarch64.c:8881
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%s\"%s\"%s is invalid"
  msgid "target %s %s=%s is not valid"
-msgstr "недопустимый параметр '%s'"
+msgstr "%s\"%s\"%s некорректно"
  
  #: config/aarch64/aarch64.c:8947
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "malformed #pragma call"
  msgid "malformed target %s value"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma builtin"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma call"
  
  #: config/aarch64/aarch64.c:8964
  #, fuzzy, gcc-internal-format
+#| msgid "%s\"%s\"%s is invalid"
  msgid "target %s %qs is invalid"
-msgstr "выбор мультибиблиотеки '%s' некорректен"
+msgstr "%s\"%s\"%s некорректно"
  
  #: config/aarch64/aarch64.c:8973
  #, gcc-internal-format
@@ -28120,14 +29426,14 @@ msgid "malformed target %s list %qs"
  msgstr ""
  
  #: config/aarch64/aarch64.c:10816
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%Klane %wd out of range %wd - %wd"
-msgstr "номер операнда вне диапазона"
+msgstr ""
  
  #: config/aarch64/aarch64.c:10818
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "lane %wd out of range %wd - %wd"
-msgstr "номер операнда вне диапазона"
+msgstr ""
  
  #: config/alpha/alpha.c:425
  #, gcc-internal-format
@@ -28150,9 +29456,9 @@ msgid "bad value %qs for -mcpu switch"
  msgstr "некорректный аргумент %qs для ключа -mcpu"
  
  #: config/alpha/alpha.c:486
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "bad value %qs for -mtune switch"
-msgstr "некорректное значение (%s) для ключа -mtune="
+msgstr "некорректное значение %qs для ключа -mtune"
  
  #: config/alpha/alpha.c:507
  #, gcc-internal-format
@@ -28207,14 +29513,16 @@ msgid "-mmul32x16 supported only for ARC600 or ARC601"
  msgstr ""
  
  #: config/arc/arc.c:709
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "-fno-fat-lto-objects are supported only with linker plugin."
  msgid "-mno-dpfp-lrsr supported only with -mdpfp"
-msgstr ""
+msgstr "-fno-fat-lto-objects поддерживается только с linker plugin."
  
  #: config/arc/arc.c:714
  #, fuzzy, gcc-internal-format
+#| msgid "-mcorea and -mcoreb can%'t be used together"
  msgid "FPX fast and compact options cannot be specified together"
-msgstr "-mglibc и -muclibcips несовместимы"
+msgstr "-mcorea и -mcoreb не могут использоваться совместно"
  
  #: config/arc/arc.c:718
  #, gcc-internal-format
@@ -28222,9 +29530,10 @@ msgid "-mspfp_fast not available on ARC600 or ARC601"
  msgstr ""
  
  #: config/arc/arc.c:723
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "class extensions are not available in Objective-C 1.0"
  msgid "FPX extensions not available on pre-ARC600 cores"
-msgstr ""
+msgstr "расширения класса недоступны в Objective-C 1.0"
  
  #: config/arc/arc.c:730
  #, gcc-internal-format
@@ -28233,8 +29542,9 @@ msgstr ""
  
  #: config/arc/arc.c:735
  #, fuzzy, gcc-internal-format
+#| msgid "this builtin function is only available on the fr450"
  msgid "This multiplier configuration is not available for HS cores"
-msgstr "эта media-функция имеется только в fr400"
+msgstr "эта встроенная функция доступна только на fr450"
  
  #: config/arc/arc.c:741
  #, gcc-internal-format, gfc-internal-format
@@ -28243,13 +29553,15 @@ msgstr ""
  
  #: config/arc/arc.c:747
  #, fuzzy, gcc-internal-format
+#| msgid "-mrelax is only supported for RTP PIC"
  msgid "-matomic is only supported for ARC700 or ARC HS cores"
-msgstr "в TFP-OS не поддерживается static"
+msgstr "-mrelax поддерживается только для RTP PIC"
  
  #: config/arc/arc.c:751
  #, fuzzy, gcc-internal-format
+#| msgid "-mrelax is only supported for RTP PIC"
  msgid "-mll64 is only supported for ARC HS cores"
-msgstr "в TFP-OS не поддерживается static"
+msgstr "-mrelax поддерживается только для RTP PIC"
  
  #: config/arc/arc.c:758
  #, gcc-internal-format
@@ -28274,19 +29586,22 @@ msgstr "задано несколько атрибутов типа функци
  
  #: config/arc/arc.c:1493 config/epiphany/epiphany.c:489
  #: config/epiphany/epiphany.c:529
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument of %qE attribute is not a string constant"
-msgstr "аргумент атрибута %qs не является строковой константой"
+msgstr "аргумент %qE атрибута не строковая константа"
  
+#
  #: config/arc/arc.c:1502
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument of %qE attribute is not \"ilink1\" or \"ilink2\""
-msgstr "аргумент атрибута %qs должен быть \"ilink1\" или \"ilink2\""
+msgstr "аргумент атрибута %qE не есть \"ilink1\" или \"ilink2\""
  
+#
  #: config/arc/arc.c:1510
  #, fuzzy, gcc-internal-format
+#| msgid "argument of %qE attribute is not \"ilink1\" or \"ilink2\""
  msgid "argument of %qE attribute is not \"ilink\""
-msgstr "аргумент атрибута %qs должен быть \"ilink1\" или \"ilink2\""
+msgstr "аргумент атрибута %qE не есть \"ilink1\" или \"ilink2\""
  
  #: config/arc/arc.c:5379
  #, fuzzy, gcc-internal-format
@@ -28307,8 +29622,9 @@ msgstr ""
  
  #: config/arc/arc.c:5555
  #, fuzzy, gcc-internal-format
+#| msgid "-mcorea should be used with -mmulticore"
  msgid "operand 1 should be an unsigned 3-bit immediate"
-msgstr "-frepo следует использовать вместе с -c"
+msgstr "-mcorea следует использовать с -mmulticore"
  
  #: config/arc/arc.c:5596 config/arc/arc.c:5693
  #, gcc-internal-format
@@ -28352,26 +29668,27 @@ msgstr ""
  
  #: config/arc/arc.c:5791
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "symbol used as immediate operand"
  msgid "builtin requires an immediate for operand %d"
-msgstr "константа long long не является корректным непосредственным операндом"
+msgstr "символ использован как непосредственный операнд"
  
  #: config/arc/arc.c:5796
  #, fuzzy, gcc-internal-format, gfc-internal-format
  #| msgid "argument 2 must be a 5-bit unsigned literal"
  msgid "operand %d should be a 6 bit unsigned immediate"
-msgstr "Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 2 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ð¾м"
  
  #: config/arc/arc.c:5800
  #, fuzzy, gcc-internal-format, gfc-internal-format
  #| msgid "argument 2 must be a 5-bit unsigned literal"
  msgid "operand %d should be a 8 bit unsigned immediate"
-msgstr "Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 2 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ð¾м"
  
  #: config/arc/arc.c:5804
  #, fuzzy, gcc-internal-format, gfc-internal-format
  #| msgid "argument 2 must be a 5-bit unsigned literal"
  msgid "operand %d should be a 3 bit unsigned immediate"
-msgstr "Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 2 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ð¾м"
  
  #: config/arc/arc.c:5807
  #, gcc-internal-format, gfc-internal-format
@@ -28395,8 +29712,9 @@ msgstr ""
  
  #: config/arc/arc.c:6660
  #, fuzzy, gcc-internal-format
+#| msgid "Bad address, not register:"
  msgid "insn addresses not freed"
-msgstr "некорректный адрес, не (reg+disp)"
+msgstr "некорректный адрес, не register:"
  
  #: config/arm/arm-builtins.c:2226
  #, gcc-internal-format
@@ -28437,8 +29755,9 @@ msgstr "маска должна быть непосредственным зна
  
  #: config/arm/arm-builtins.c:2591
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute argument should be between 0 to 255"
  msgid "the range of mask should be in 0 to 255"
-msgstr "аргумент атрибута %qs не является целой константой"
+msgstr "аргумент атрибута %qE должен быть между 0 и 255"
  
  #: config/arm/arm-builtins.c:2779
  #, gcc-internal-format
@@ -28560,15 +29879,17 @@ msgstr ""
  msgid "the count should be no less than 0.  please check the intrinsic _mm_sra_si64 in code."
  msgstr ""
  
+#
  #: config/arm/arm.c:2757
  #, fuzzy, gcc-internal-format
+#| msgid "-fPIC and -G are incompatible"
  msgid "iWMMXt and NEON are incompatible"
-msgstr "ключи -fPIC и -mcall-%s несовместимы"
+msgstr "ключи -fPIC и -G несовместимы"
  
  #: config/arm/arm.c:2762
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "target CPU does not support ARM mode"
-msgstr "целевой процессор не поддерживает interworking"
+msgstr "целевой процессор не поддерживает режим ARM"
  
  #: config/arm/arm.c:2767
  #, gcc-internal-format
@@ -28591,14 +29912,14 @@ msgid "iWMMXt unsupported under Thumb mode"
  msgstr ""
  
  #: config/arm/arm.c:2785
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can not use -mtp=cp15 with 16-bit Thumb"
-msgstr "недопустимо использовать -mtp=cp15 и -mthumb"
+msgstr "недопустимо использовать -mtp=cp15 с 16-битным Thumb"
  
  #: config/arm/arm.c:2789
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "RTP PIC is incompatible with Thumb"
-msgstr "ÐºÐ»Ñ\8eÑ\87 -march=%s Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 Ð²Ñ\8bÐ±Ñ\80Ð°Ð½Ð½Ñ\8bÐ¼ ABI"
+msgstr "Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾-Ð½ÐµÐ·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ñ\8bÐ¹ RTP Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 Thumb"
  
  #: config/arm/arm.c:2797
  #, gcc-internal-format
@@ -28611,9 +29932,9 @@ msgid "target CPU does not support THUMB instructions"
  msgstr "целевой процессор не поддерживает команды THUMB"
  
  #: config/arm/arm.c:2931
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "target CPU does not support unaligned accesses"
-msgstr "целевой процессор не поддерживает interworking"
+msgstr "целевой процессор не поддерживает невыровненные доступы"
  
  #: config/arm/arm.c:3136
  #, gcc-internal-format
@@ -28643,47 +29964,47 @@ msgstr "передача плавающих аргументов на регис
  #: config/arm/arm.c:3201
  #, gcc-internal-format
  msgid "iwmmxt requires an AAPCS compatible ABI for proper operation"
-msgstr ""
+msgstr "iwmmxt требует AAPCS совместимого ABI для правильной работы"
  
  #: config/arm/arm.c:3204
  #, gcc-internal-format
  msgid "iwmmxt abi requires an iwmmxt capable cpu"
-msgstr "для работы с ABI iwmmxt необходим процессор с поддержкой iwmmxt"
+msgstr "для работы с iwmmxt ABI требуется процессор с поддержкой iwmmxt"
  
  #: config/arm/arm.c:3233
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "AAPCS does not support -mcaller-super-interworking"
-msgstr "целевой процессор не поддерживает interworking"
+msgstr "AAPCS не поддерживает -mcaller-super-interworking"
  
  #: config/arm/arm.c:3236
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "AAPCS does not support -mcallee-super-interworking"
-msgstr "целевой процессор не поддерживает interworking"
+msgstr "AAPCS не поддерживает -mcaller-super-interworking"
  
  #: config/arm/arm.c:3241
  #, gcc-internal-format
  msgid "__fp16 and no ldrh"
-msgstr ""
+msgstr "__fp16 и нет ldrh"
  
  #: config/arm/arm.c:3257
  #, gcc-internal-format
  msgid "-mfloat-abi=hard and VFP"
-msgstr "-mflat-abi=hard или VFP"
+msgstr "-mflat-abi=hard и VFP"
  
  #: config/arm/arm.c:3293
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "structure size boundary can only be set to 8, 32 or 64"
-msgstr "граница размера структуры может быть только %s"
+msgstr "граница размера структуры может быть только 8, 32 или 64"
  
  #: config/arm/arm.c:3295
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "structure size boundary can only be set to 8 or 32"
-msgstr "граница размера структуры может быть только %s"
+msgstr "граница размера структуры может быть только 8 или 32"
  
  #: config/arm/arm.c:3306
  #, gcc-internal-format
  msgid "RTP PIC is incompatible with -msingle-pic-base"
-msgstr ""
+msgstr "позиционно-независимый RTP несовместим с -msingle-pic-base"
  
  #: config/arm/arm.c:3318
  #, gcc-internal-format
@@ -28696,29 +30017,29 @@ msgid "unable to use '%s' for PIC register"
  msgstr "использование '%s' как PIC-регистра невозможно"
  
  #: config/arm/arm.c:3350
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-freorder-blocks-and-partition not supported on this architecture"
-msgstr "-freorder-blocks-and-partition не работает для заданной архитектуры"
+msgstr "-freorder-blocks-and-partition не поддерживается на этой архитектуре"
  
  #: config/arm/arm.c:5498
  #, gcc-internal-format
  msgid "non-AAPCS derived PCS variant"
-msgstr ""
+msgstr "non-AAPCS производный PCS вариант"
  
  #: config/arm/arm.c:5500
  #, gcc-internal-format
  msgid "variadic functions must use the base AAPCS variant"
-msgstr ""
+msgstr "вариантные функции должны использовать базовый AAPCS вариант"
  
  #: config/arm/arm.c:5519
  #, gcc-internal-format
  msgid "PCS variant"
-msgstr ""
+msgstr "PCS вариант"
  
  #: config/arm/arm.c:5714
  #, gcc-internal-format
  msgid "Thumb-1 hard-float VFP ABI"
-msgstr ""
+msgstr "Thumb-1 аппаратный плавающий VFP ABI"
  
  #: config/arm/arm.c:6456 config/arm/arm.c:6474 config/avr/avr.c:8991
  #: config/avr/avr.c:9007 config/bfin/bfin.c:4672 config/bfin/bfin.c:4733
@@ -28732,9 +30053,9 @@ msgstr ""
  #: config/sh/sh.c:9798 config/sh/sh.c:9827 config/sh/sh.c:9909
  #: config/sh/sh.c:9932 config/spu/spu.c:3680 config/stormy16/stormy16.c:2211
  #: config/v850/v850.c:2082 config/visium/visium.c:699
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute only applies to functions"
-msgstr "атрибут %qs допустим только для функций"
+msgstr "%qE атрибут применим только к функциям"
  
  #: config/arm/arm.c:12912
  #, gcc-internal-format
@@ -28753,8 +30074,9 @@ msgstr "невозможно вычислить фактическое поло
  
  #: config/arm/arm.c:24211
  #, fuzzy, gcc-internal-format
+#| msgid "Unexpected end of module"
  msgid "Unexpected thumb1 far jump"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ ÐºÐ¾Ð½ÐµÑ\86 Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8f"
  
  #: config/arm/arm.c:24478
  #, gcc-internal-format
@@ -28773,64 +30095,75 @@ msgstr ""
  
  #: config/arm/arm.c:30008 config/i386/i386.c:6041 config/s390/s390.c:14519
  #, fuzzy, gcc-internal-format
+#| msgid "attribute %qE argument not a string"
  msgid "attribute %<target%> argument not a string"
-msgstr "аргумент атрибута %qs не является строковой константой"
+msgstr "аргумент атрибута %qE не является строковой константой"
  
  #: config/arm/arm.c:30031
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "invalid vector type for attribute %qs"
  msgid "invalid fpu for attribute(target(\"%s\"))"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾ Ð·Ð°Ð´Ð°Ð½ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qE"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs"
  
  #: config/arm/arm.c:30037 config/i386/i386.c:6107 config/i386/i386.c:6154
  #: config/s390/s390.c:14585 config/s390/s390.c:14635 config/s390/s390.c:14652
  #, gcc-internal-format, gfc-internal-format
  msgid "attribute(target(\"%s\")) is unknown"
-msgstr ""
+msgstr "attribute(target(\"%s\")) неизвестен"
  
  #: config/arm/freebsd.h:126
  #, fuzzy, gcc-internal-format
+#| msgid "target CPU does not support unaligned accesses"
  msgid "target OS does not support unaligned accesses"
-msgstr "целевой процессор не поддерживает interworking"
+msgstr "целевой процессор не поддерживает невыровненные доступы"
  
  #: config/avr/avr-c.c:62 config/avr/avr-c.c:187
  #, fuzzy, gcc-internal-format
+#| msgid "%qs expects a constant argument"
  msgid "%qs expects 1 argument but %d given"
  msgstr "для %qs требуется константный аргумент"
  
  #: config/avr/avr-c.c:73
  #, fuzzy, gcc-internal-format
+#| msgid "%qs expects a constant argument"
  msgid "%qs expects a fixed-point value as argument"
  msgstr "для %qs требуется константный аргумент"
  
  #: config/avr/avr-c.c:99
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute has no effect"
  msgid "using %qs with unsigned type has no effect"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð½Ðµ Ð´ÐµÐ¹Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82"
  
  #: config/avr/avr-c.c:104 config/avr/avr-c.c:170 config/avr/avr-c.c:227
  #, fuzzy, gcc-internal-format
+#| msgid "no matching template for %qD found"
  msgid "no matching fixed-point overload found for %qs"
  msgstr "нет подходящего шаблона для %qD"
  
  #: config/avr/avr-c.c:121
  #, fuzzy, gcc-internal-format
+#| msgid "%qs expects a constant argument"
  msgid "%qs expects 2 arguments but %d given"
  msgstr "для %qs требуется константный аргумент"
  
  #: config/avr/avr-c.c:133 config/avr/avr-c.c:198
  #, fuzzy, gcc-internal-format
+#| msgid "%qs expects a constant argument"
  msgid "%qs expects a fixed-point value as first argument"
  msgstr "для %qs требуется константный аргумент"
  
  #: config/avr/avr-c.c:141
  #, fuzzy, gcc-internal-format
+#| msgid "%qs expects a constant argument"
  msgid "%qs expects an integer value as second argument"
  msgstr "для %qs требуется константный аргумент"
  
  #: config/avr/avr-devices.c:203
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "-fpic is not supported"
  msgid "devices natively supported:%s"
-msgstr "ключ -pipe не поддерживается"
+msgstr "ключ -fpic не поддерживается"
  
  #: config/avr/avr-devices.c:212
  #, gcc-internal-format, gfc-internal-format
@@ -28848,95 +30181,99 @@ msgid "unknown core architecture %qs specified with %qs"
  msgstr "не задано имя класса для %qs"
  
  #: config/avr/avr.c:435 config/mep/mep.c:354 config/visium/visium.c:383
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-fpic is not supported"
-msgstr "ключ -pipe не поддерживается"
+msgstr "ключ -fpic не поддерживается"
  
  #: config/avr/avr.c:437 config/mep/mep.c:356 config/visium/visium.c:385
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-fPIC is not supported"
-msgstr "ключ -pipe не поддерживается"
+msgstr "ключ -fPIC не поддерживается"
  
  #: config/avr/avr.c:439
  #, fuzzy, gcc-internal-format
+#| msgid "-fpic is not supported"
  msgid "-fpie is not supported"
-msgstr "ключ -pipe не поддерживается"
+msgstr "ключ -fpic не поддерживается"
  
  #: config/avr/avr.c:441
  #, fuzzy, gcc-internal-format
+#| msgid "-fPIC is not supported"
  msgid "-fPIE is not supported"
-msgstr "ключ -pipe не поддерживается"
+msgstr "ключ -fPIC не поддерживается"
  
  #: config/avr/avr.c:713
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "function attributes %qs, %qs and %qs are mutually exclusive"
-msgstr "-G и -static несовместимы"
+msgstr "атрибуты функций %qs, %qs и %qs несовместимы"
  
  #: config/avr/avr.c:720
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "function attributes %qs and %qs have no effect on %qs function"
-msgstr "%qE атрибут действует только в public-объектах"
+msgstr "атрибуты функций %qs и %qs не воздействуют на %qs функцию"
  
  #: config/avr/avr.c:747
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs function cannot have arguments"
-msgstr "%qD не может иметь аргументов по умолчанию"
+msgstr "%qs функция не может иметь аргументы"
  
  #: config/avr/avr.c:750
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs function cannot return a value"
-msgstr "функция возвращает значение не строкового типа"
+msgstr "%qs функция не может возвращать значение"
  
  #: config/avr/avr.c:757
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs appears to be a misspelled %s handler"
-msgstr "%qs Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾ Ð½Ð°Ð·Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ð¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82Ñ\87Ð¸Ðº Ñ\81Ð¸Ð³Ð½Ð°Ð»Ð°"
+msgstr "%qs Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¸Ñ\81ÐºÐ°Ð¶ÐµÐ½Ð½Ñ\8bÐ¹ %s Ð¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82Ñ\87Ð¸Ðº"
  
  #: config/avr/avr.c:984
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'builtin_return_address' contains only 2 bytes of address"
  msgid "%<builtin_return_address%> contains only 2 bytes of address"
-msgstr ""
+msgstr "'builtin_return_address' содержит только 2 байта адреса"
  
  #: config/avr/avr.c:2208
  #, gcc-internal-format
  msgid "pointer offset from symbol maybe incorrect"
-msgstr ""
+msgstr "смещение указателя от символа, возможно, некорректно"
  
  #: config/avr/avr.c:2347
  #, gcc-internal-format
  msgid "accessing data memory with program memory address"
-msgstr ""
+msgstr "доступ к памяти данных с адресом программной памяти"
  
  #: config/avr/avr.c:2408
  #, gcc-internal-format
  msgid "accessing program memory with data memory address"
-msgstr ""
+msgstr "доступ к программной памяти с адресом памяти данных"
  
  #: config/avr/avr.c:2853
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "fixed register %s used to pass parameter to function"
-msgstr "Число регистров для передачи целочисленных аргументов"
+msgstr "фиксированный регистр %s использован для передачи параметра функции"
  
  #: config/avr/avr.c:3124
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "writing to address space %qs not supported"
-msgstr "ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83Ñ\8eÑ\89ÐµÐµ Ð¸Ð¼Ñ\8f Ñ\81Ñ\83Ð¿ÐµÑ\80ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qs"
+msgstr "Ð·Ð°Ð¿Ð¸Ñ\81Ñ\8c Ð² Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ð¾ %qs Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f"
  
  #: config/avr/avr.c:9024 config/bfin/bfin.c:4794 config/i386/winnt.c:58
  #: config/mep/mep.c:3788 config/mep/mep.c:3926
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute only applies to variables"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%qE атрибут применим только к переменным"
  
  #: config/avr/avr.c:9035 config/mep/mep.c:3936
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute allows only an integer constant argument"
-msgstr "аргументом атрибута %qs должна быть целая константа"
+msgstr "аргументом атрибута %qE должна быть целая константа"
  
  #: config/avr/avr.c:9045
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute has no effect"
  msgid "%qE attribute address out of range"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð½Ðµ Ð´ÐµÐ¹Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82"
  
  #: config/avr/avr.c:9058
  #, gcc-internal-format
@@ -28945,43 +30282,48 @@ msgstr ""
  
  #: config/avr/avr.c:9068
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute only applies to variables"
  msgid "%qE attribute on non-volatile variable"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%qE атрибут применим только к переменным"
  
  #: config/avr/avr.c:9272
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%qT uses address space %qs beyond flash of %qs"
  msgid "%qT uses address space %qs beyond flash of %d KiB"
-msgstr ""
+msgstr "%qT использует адресное пространство %qs после сброса %qs"
  
  #: config/avr/avr.c:9275
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%s %q+D uses address space %qs beyond flash of %qs"
  msgid "%s %q+D uses address space %qs beyond flash of %d KiB"
-msgstr ""
+msgstr "%s %q+D использует адресное пространство %qs после сброса %qs"
  
  #: config/avr/avr.c:9281
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "pointer targeting address space %qs must be const in %qT"
-msgstr "несоответствие указательных типов в условном выражении"
+msgstr "указатель в адресное пространство %qs должен быть const в %qT"
  
  #: config/avr/avr.c:9284
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "pointer targeting address space %qs must be const in %s %q+D"
-msgstr "несоответствие указательных типов в условном выражении"
+msgstr "указатель в адресное пространство %qs должен быть const в %s %q+D"
  
  #: config/avr/avr.c:9322
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "variable %q+D located in address space %qs beyond flash of %qs"
  msgid "variable %q+D located in address space %qs beyond flash of %d KiB"
-msgstr ""
+msgstr "переменная %q+D расположена в адресном пространстве %qs после сброса %qs"
  
  #: config/avr/avr.c:9327
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "variable %q+D located in address space %qs beyond flash of %qs"
  msgid "variable %q+D located in address space %qs which is not supported for architecture %qs"
-msgstr ""
+msgstr "переменная %q+D расположена в адресном пространстве %qs после сброса %qs"
  
  #: config/avr/avr.c:9343
  #, gcc-internal-format
  msgid "variable %q+D must be const in order to be put into read-only section by means of %qs"
-msgstr ""
+msgstr "переменная %q+D должна быть const чтобы ее можно было поместить в доступную только на чтение секцию посредством %qs"
  
  #: config/avr/avr.c:9383
  #, fuzzy, gcc-internal-format
@@ -28998,12 +30340,12 @@ msgstr "здесь было предыдущее определение %q+D"
  #: config/avr/avr.c:9599
  #, gcc-internal-format
  msgid "only uninitialized variables can be placed in the .noinit section"
-msgstr "Только неинициализированные переменные могут размещаться в секции .noinit"
+msgstr "только неинициализированные переменные могут размещаться в секции .noinit"
  
  #: config/avr/avr.c:9640
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "uninitialized variable %q+D put into program memory area"
-msgstr "Ð¢Ð¾Ð»Ñ\8cÐºÐ¾ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÐµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ñ\80Ð°Ð·Ð¼ÐµÑ\89Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ð² Ð¾Ð±Ð»Ð°Ñ\81Ñ\82Ð¸ программной памяти"
+msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %q+D Ð¿Ð¾Ð¼ÐµÑ\89ÐµÐ½Ð° Ð² Ð¾Ð±Ð»Ð°Ñ\81Ñ\82Ñ\8c программной памяти"
  
  #: config/avr/avr.c:9750
  #, fuzzy, gcc-internal-format
@@ -29013,18 +30355,19 @@ msgstr "MCU %qs поддерживается только для ассембл
  
  #: config/avr/avr.c:12269
  #, fuzzy, gcc-internal-format
+#| msgid "Conversion from %s to %s at %L"
  msgid "conversion from address space %qs to address space %qs"
-msgstr "Ð¿реобразование из %s в %s в %L"
+msgstr "Ð\9fреобразование из %s в %s в %L"
  
  #: config/avr/avr.c:13325
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s expects a compile time integer constant"
-msgstr "Неожиданное окончание модуля в строковой константе"
+msgstr "%s ожидает целую константу времени компиляции"
  
  #: config/avr/avr.c:13339
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s expects a compile time long integer constant as first argument"
-msgstr "для %qs требуется константный аргумент"
+msgstr "%s ожидает длинную целую константу времени компиляции в качестве первого аргумента"
  
  #: config/avr/avr.c:13367
  #, gcc-internal-format, gfc-internal-format
@@ -29048,13 +30391,15 @@ msgstr ""
  
  #: config/avr/driver-avr.c:79
  #, fuzzy, gcc-internal-format
+#| msgid "unknown spec function %qs"
  msgid "bad usage of spec function %qs"
-msgstr "неизвестная функция '%s' в спецификации"
+msgstr "неизвестная функция %qs в спецификации"
  
  #: config/avr/driver-avr.c:107
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Array specification at %C has more than %d dimensions"
  msgid "specified option %qs more than once"
-msgstr ""
+msgstr "Спецификация массива в %C имеет больше чем %d измерений"
  
  #: config/avr/driver-avr.c:129
  #, fuzzy, gcc-internal-format
@@ -29065,7 +30410,7 @@ msgstr "синтаксис файла спецификаций нарушен п
  #: config/bfin/bfin.c:2348
  #, gcc-internal-format
  msgid "-mfdpic is not supported, please use a bfin-linux-uclibc target"
-msgstr ""
+msgstr "-mfdpic не поддерживается, пожалуйста, используйте целевую платформу bfin-linux-uclibc"
  
  #: config/bfin/bfin.c:2353
  #, gcc-internal-format
@@ -29075,17 +30420,17 @@ msgstr "-mshared-library-id= без -mid-shared-library"
  #: config/bfin/bfin.c:2357
  #, gcc-internal-format
  msgid "-fstack-limit- options are ignored with -mfdpic; use -mstack-check-l1"
-msgstr ""
+msgstr "-fstack-limit- игнорируются с -mfdpic; используйте -mstack-check-l1"
  
  #: config/bfin/bfin.c:2362
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t use multiple stack checking methods together"
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð´Ð»Ñ\8f проверки стека"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ñ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¸Ñ\85 Ð¼ÐµÑ\82Ð¾Ð´Ð¾Ð² проверки стека"
  
  #: config/bfin/bfin.c:2365
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ID shared libraries and FD-PIC mode can%'t be used together"
-msgstr "-mips16 и -mdsp несовместимы"
+msgstr "ID разделяемые библиотеки и FD-PIC режим не могут использоваться совместно"
  
  #: config/bfin/bfin.c:2370 config/m68k/m68k.c:552
  #, gcc-internal-format
@@ -29095,22 +30440,22 @@ msgstr "ключи -msep-data и -mid-shared-library несовместимы"
  #: config/bfin/bfin.c:2390
  #, gcc-internal-format
  msgid "-mmulticore can only be used with BF561"
-msgstr ""
+msgstr "-mmulticore можно использовать только с BF561"
  
  #: config/bfin/bfin.c:2393
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-mcorea should be used with -mmulticore"
-msgstr "-frepo следует использовать вместе с -c"
+msgstr "-mcorea следует использовать с -mmulticore"
  
  #: config/bfin/bfin.c:2396
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-mcoreb should be used with -mmulticore"
-msgstr "-frepo следует использовать вместе с -c"
+msgstr "-mcoreb следует использовать с -mmulticore"
  
  #: config/bfin/bfin.c:2399
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-mcorea and -mcoreb can%'t be used together"
-msgstr "-mglibc и -muclibcips несовместимы"
+msgstr "-mcorea и -mcoreb не могут использоваться совместно"
  
  #: config/bfin/bfin.c:4677
  #, gcc-internal-format
@@ -29118,39 +30463,39 @@ msgid "multiple function type attributes specified"
  msgstr "задано несколько атрибутов типа функции"
  
  #: config/bfin/bfin.c:4744
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t apply both longcall and shortcall attributes to the same function"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½Ñ\8fÑ\82Ñ\8c Ðº Ð¾Ð´Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b longcall Ð¸ shortcall"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½Ð¸Ñ\82Ñ\8c Ð¾Ð±Ð° Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° longcall Ð¸ shortcall Ðº Ð¾Ð´Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
  
  #: config/bfin/bfin.c:4801
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute cannot be specified for local variables"
-msgstr "%Jатрибут section недопустим для локальных переменных"
+msgstr "%qE атрибут нельзя задавать для локальных переменных"
  
  #: config/c6x/c6x.c:238
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-fpic and -fPIC not supported without -mdsbt on this target"
-msgstr "ключи -fPIC и -fpic в данной конфигурации не поддерживаются"
+msgstr "-fpic и -fPIC не поддерживаются без -mdsbt на этой платформе"
  
  #: config/c6x/c6x.h:365 config/nvptx/nvptx.h:169
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "profiling is not yet implemented for this architecture"
-msgstr "Ð\9fÑ\80Ð¾Ñ\84Ð¸Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð´Ð»Ñ\8f Ñ\8dÑ\82Ð¾Ð¹ Ð¿Ð»Ð°Ñ\82Ñ\84Ð¾Ñ\80Ð¼Ñ\8b Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð¿Ñ\80Ð¾Ñ\84Ð¸Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¿Ð¾ÐºÐ° Ð½Ðµ Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð¾Ð²Ð°Ð½Ð¾ Ð´Ð»Ñ\8f Ñ\8dÑ\82Ð¾Ð¹ Ð°Ñ\80Ñ\85Ð¸Ñ\82ÐµÐºÑ\82Ñ\83Ñ\80Ñ\8b"
  
  #: config/cr16/cr16.c:290
  #, gcc-internal-format
  msgid "data-model=far not valid for cr16c architecture"
-msgstr ""
+msgstr "data-model=far некорректно для cr16c архитектуры"
  
  #: config/cr16/cr16.c:293
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "invalid data model option -mdata-model=%s"
-msgstr "некорректный указателя потока: -mtp=%s"
+msgstr "некорректная опция модели данных -mdata-model=%s"
  
  #: config/cr16/cr16.h:431
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "profiler support for CR16"
-msgstr "Ð\9fÐ¾Ð´Ð´ÐµÑ\80Ð¶ÐºÐ° Ð¿Ñ\80Ð¾Ñ\84Ð¸Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð´Ð»Ñ\8f CRX"
+msgstr "Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶ÐºÐ° Ð¿Ñ\80Ð¾Ñ\84Ð¸Ð»ÐµÑ\80Ð° Ð´Ð»Ñ\8f CR16"
  
  #. This function is for retrieving a part of an instruction name for
  #. an operator, for immediate output.  If that ever happens for
@@ -29159,12 +30504,12 @@ msgstr "Поддержка профилирования для CRX"
  #: config/cris/cris.c:555
  #, gcc-internal-format
  msgid "MULT case in cris_op_str"
-msgstr ""
+msgstr "MULT случай в cris_op_str"
  
  #: config/cris/cris.c:893
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of ':' modifier"
-msgstr "некорректный операнд для модификатора 'b'"
+msgstr "некорректное использование ':' модификатора"
  
  #: config/cris/cris.c:1127 config/moxie/moxie.c:181
  #, gcc-internal-format, gfc-internal-format
@@ -29208,14 +30553,14 @@ msgid "-fPIC and -fpic are not supported in this configuration"
  msgstr "ключи -fPIC и -fpic в данной конфигурации не поддерживаются"
  
  #: config/cris/cris.c:2976
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unknown src"
-msgstr "Ð\9dÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ Ð¸Ñ\81Ñ\82Ð¾Ñ\87Ð½Ð¸Ðº"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ src"
  
  #: config/cris/cris.c:3031
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unknown dest"
-msgstr "Ð\9dÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð¾Ðµ Ð½Ð°Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ dest"
  
  #: config/cris/cris.c:3312
  #, gcc-internal-format, gfc-internal-format
@@ -29228,9 +30573,9 @@ msgid "expand_binop failed in movsi got"
  msgstr "в movsi не удалось выполнить expand_binop"
  
  #: config/cris/cris.c:3923
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "emitting PIC operand, but PIC register isn%'t set up"
-msgstr "генерация PIC-операнда при неустановленном PIC-регистре"
+msgstr "генерация PIC-операнда, но PIC-регистр не установлен"
  
  #. Definitions for GCC.  Part of the machine description for CRIS.
  #. Copyright (C) 1998-2016 Free Software Foundation, Inc.
@@ -29272,7 +30617,7 @@ msgstr "генерация PIC-операнда при неустановлен
  #: config/cris/cris.h:42
  #, gcc-internal-format
  msgid "CRIS-port assertion failed: "
-msgstr "Ð\9dе выполнено необходимое условие в коде CRIS: "
+msgstr "Ð½е выполнено необходимое условие в коде CRIS: "
  
  #. Node: Caller Saves
  #. (no definitions)
@@ -29283,27 +30628,28 @@ msgstr "Не выполнено необходимое условие в код
  #: config/cris/cris.h:749
  #, gcc-internal-format
  msgid "no FUNCTION_PROFILER for CRIS"
-msgstr "Ð\9eÑ\82Ð¼ÐµÐ½Ð¸Ñ\82Ñ\8c FUNCTION_PROFILER для CRIS"
+msgstr "Ð½ÐµÑ\82 FUNCTION_PROFILER для CRIS"
  
  #: config/epiphany/epiphany.c:480
  #, fuzzy, gcc-internal-format
+#| msgid "interrupt handlers cannot be MIPS16 functions"
  msgid "interrupt handlers cannot have arguments"
-msgstr "ÐºÐ»Ñ\8eÑ\87 '-%c' Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°"
+msgstr "Ð¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82Ñ\87Ð¸ÐºÐ¸ Ð¿Ñ\80ÐµÑ\80Ñ\8bÐ²Ð°Ð½Ð¸Ð¹ Ð½Ðµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð±Ñ\8bÑ\82Ñ\8c Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8fÐ¼Ð¸ MIPS16"
  
  #: config/epiphany/epiphany.c:504
  #, gcc-internal-format
  msgid "argument of %qE attribute is not \"reset\", \"software_exception\", \"page_miss\", \"timer0\", \"timer1\", \"message\", \"dma0\", \"dma1\", \"wand\" or \"swi\""
-msgstr ""
+msgstr "аргумент %qE атрибута не \"reset\", \"software_exception\", \"page_miss\", \"timer0\", \"timer1\", \"message\", \"dma0\", \"dma1\", \"wand\" или \"swi\""
  
  #: config/epiphany/epiphany.c:1521
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "stack_offset must be at least 4"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "stack_offset должно быть не меньше 4"
  
  #: config/epiphany/epiphany.c:1523
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "stack_offset must be a multiple of 4"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "stack_offset должно быть кратно 4"
  
  #: config/frv/frv.c:8589
  #, gcc-internal-format
@@ -29321,9 +30667,9 @@ msgid "inappropriate accumulator for %qs"
  msgstr "неподходящий сумматор для %qs"
  
  #: config/frv/frv.c:8681
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid IACC argument"
-msgstr "некорректный тип аргумента"
+msgstr "некорректный IACC аргумент"
  
  #: config/frv/frv.c:8704
  #, gcc-internal-format
@@ -29346,42 +30692,46 @@ msgid "this media function is only available on the fr500"
  msgstr "эта media-функция имеется только в fr500"
  
  #: config/frv/frv.c:9230
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "this media function is only available on the fr400 and fr550"
-msgstr "Ñ\8dÑ\82Ð° media-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ð¸Ð¼ÐµÐµÑ\82Ñ\81Ñ\8f Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð² fr400"
+msgstr "Ñ\8dÑ\82Ð° media-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð° Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð½Ð° fr400 Ð¸ fr550"
  
  #: config/frv/frv.c:9249
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "this builtin function is only available on the fr405 and fr450"
-msgstr "эта media-функция имеется только в fr400"
+msgstr "эта встроенная функция доступна только на fr405 и fr450"
  
  #: config/frv/frv.c:9258
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "this builtin function is only available on the fr500 and fr550"
-msgstr "эта media-функция имеется только в fr500"
+msgstr "эта встроенная функция доступна только на fr500 и fr550"
  
  #: config/frv/frv.c:9270
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "this builtin function is only available on the fr450"
-msgstr "эта media-функция имеется только в fr400"
+msgstr "эта встроенная функция доступна только на fr450"
  
  #: config/ft32/ft32.c:175
  #, fuzzy, gcc-internal-format
+#| msgid "shift of non-integer operand"
  msgid "'h' applied to non-register operand"
-msgstr "Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° %qs Ð¸Ð¼ÐµÐµÑ\82 Ð½Ðµ Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
+msgstr "Ñ\81Ð´Ð²Ð¸Ð³ Ð½ÐµÑ\86ÐµÐ»Ð¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð°"
  
  #: config/ft32/ft32.c:200
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "array assignment"
  msgid "bad alignment: %d"
-msgstr "Ð\9fрисваивание массивов"
+msgstr "Ð¿рисваивание массивов"
  
  #: config/ft32/ft32.c:478
  #, fuzzy, gcc-internal-format
+#| msgid "stack size must not be greater than 64k"
  msgid "stack frame must be smaller than 64K"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "размер стека должен быть больше чем 64k"
  
  #: config/h8300/h8300.c:325
  #, fuzzy, gcc-internal-format
+#| msgid "-f%s not supported: ignored"
  msgid "-msx is not supported in coff"
  msgstr "ключ -f%s не поддерживается; игнорируется"
  
@@ -29392,21 +30742,25 @@ msgstr "-ms2600 без -ms"
  
  #: config/h8300/h8300.c:353
  #, fuzzy, gcc-internal-format
+#| msgid "-mn is used without -mh or -ms"
  msgid "-mn is used without -mh or -ms or -msx"
  msgstr "-mn без -mh или -ms"
  
  #: config/h8300/h8300.c:359
  #, fuzzy, gcc-internal-format
+#| msgid "-ms2600 is used without -ms"
  msgid "-mexr is used without -ms"
  msgstr "-ms2600 без -ms"
  
  #: config/h8300/h8300.c:365
  #, fuzzy, gcc-internal-format
+#| msgid "%<__int128%> is not supported for this target"
  msgid "-mint32 is not supported for H8300 and H8300L targets"
-msgstr "-fdata-sections не поддерживается для этой целевой машины"
+msgstr "%<__int128%> не поддерживается для этой целевой машины"
  
  #: config/h8300/h8300.c:371
  #, fuzzy, gcc-internal-format
+#| msgid "-mn is used without -mh or -ms"
  msgid "-mexr is used without -ms or -msx"
  msgstr "-mn без -mh или -ms"
  
@@ -29417,23 +30771,25 @@ msgstr ""
  
  #: config/h8300/h8300.c:384
  #, fuzzy, gcc-internal-format
+#| msgid "%<__int128%> is not supported for this target"
  msgid "-mn is not supported for linux targets"
-msgstr "-fdata-sections не поддерживается для этой целевой машины"
+msgstr "%<__int128%> не поддерживается для этой целевой машины"
  
  #: config/i386/host-cygwin.c:62
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t extend PCH file: %m"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ñ\8f PCH Ñ\84Ð°Ð¹Ð»Ð°: %m"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80Ð¸Ñ\82Ñ\8c PCH Ñ\84Ð°Ð¹Ð»: %m"
  
  #: config/i386/host-cygwin.c:73
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t set position in PCH file: %m"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¾Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f в PCH файле: %m"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ñ\83Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ñ\8e в PCH файле: %m"
  
  #: config/i386/i386.c:4088
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "-Werror=%s: no option -%s"
  msgid "wrong arg %s to option %s"
-msgstr "ошибка в аргументах spec-функции '%s'"
+msgstr "-Werror=%s: ключа -%s не существует"
  
  #: config/i386/i386.c:4095
  #, gcc-internal-format, gfc-internal-format
@@ -29448,14 +30804,16 @@ msgstr "не задано имя регистра для %q+D"
  
  #. rep; movq isn't available in 32-bit code.
  #: config/i386/i386.c:4116
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "-mstringop-strategy=rep_8byte not supported for 32-bit code"
  msgid "stringop strategy name %s specified for option %s not supported for 32-bit code"
-msgstr ""
+msgstr "-mstringop-strategy=rep_8byte не поддерживается для 32-битного кода"
  
  #: config/i386/i386.c:4131
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "alignment specified for function %qE"
  msgid "unknown alignment %s specified for option %s"
-msgstr "вызов не функции %qD"
+msgstr "выравнивание задано для функции %qE"
  
  #: config/i386/i386.c:4142
  #, gcc-internal-format, gfc-internal-format
@@ -29464,32 +30822,36 @@ msgstr ""
  
  #: config/i386/i386.c:4150
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Invalid range %s in option %s"
  msgid "too many size ranges specified in option %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸: -mfpu=%s"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½ %s Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° %s"
  
  #: config/i386/i386.c:4204
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unknown argument list function at %L"
  msgid "Unknown parameter to option -mtune-ctrl: %s"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
+msgstr "Ð\9dÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ñ\81Ð¿Ð¸Ñ\81ÐºÐ° Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² %L"
  
  #: config/i386/i386.c:4592
  #, fuzzy, gcc-internal-format
+#| msgid "64-bit ABI not supported in ESA/390 mode"
  msgid "Intel MCU psABI isn%'t supported in %s mode"
-msgstr "64-битный ABI в режиме ESA/390 не поддерживается."
+msgstr "64-битный ABI в режиме ESA/390 не поддерживается"
  
  #: config/i386/i386.c:4639
  #, gcc-internal-format, gfc-internal-format
  msgid "%stune=x86-64%s is deprecated; use %stune=k8%s or %stune=generic%s instead as appropriate"
-msgstr ""
+msgstr "%stune=x86-64%s устарело; используйте вместо этого соответственно %stune=k8%s или %stune=generic%s"
  
  #. rep; movq isn't available in 32-bit code.
  #: config/i386/i386.c:4666
  #, gcc-internal-format
  msgid "-mstringop-strategy=rep_8byte not supported for 32-bit code"
-msgstr ""
+msgstr "-mstringop-strategy=rep_8byte не поддерживается для 32-битного кода"
  
  #: config/i386/i386.c:4683
  #, fuzzy, gcc-internal-format
+#| msgid "code model %qs not supported in the %s bit mode"
  msgid "address mode %qs not supported in the %s bit mode"
  msgstr "модель кодирования %s не поддерживается в %s-битном режиме"
  
@@ -29500,19 +30862,19 @@ msgid "code model %qs not supported in the %s bit mode"
  msgstr "модель кодирования %s не поддерживается в %s-битном режиме"
  
  #: config/i386/i386.c:4721 config/i386/i386.c:4733
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "code model %qs not supported in x32 mode"
-msgstr "Ð¼Ð¾Ð´ÐµÐ»Ñ\8c ÐºÐ¾Ð´Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %s Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f Ð² %s-Ð±Ð¸Ñ\82Ð½Ð¾Ð¼ Ñ\80ÐµÐ¶Ð¸Ð¼Ðµ"
+msgstr "Ð¼Ð¾Ð´ÐµÐ»Ñ\8c ÐºÐ¾Ð´Ð° %qs Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f Ð² Ñ\80ÐµÐ¶Ð¸Ð¼Ðµ x32"
  
  #: config/i386/i386.c:4739 config/i386/i386.c:4748 config/i386/i386.c:5837
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "code model %s does not support PIC mode"
-msgstr "Ð¼Ð¾Ð´ÐµÐ»Ñ\8c ÐºÐ¾Ð´Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %s Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f Ð² Ñ\80ÐµÐ¶Ð¸Ð¼Ðµ PIC"
+msgstr "Ð¼Ð¾Ð´ÐµÐ»Ñ\8c ÐºÐ¾Ð´Ð° %s Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 PIC Ñ\80ÐµÐ¶Ð¸Ð¼"
  
  #: config/i386/i386.c:4776
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-masm=intel not supported in this configuration"
-msgstr "-m%s в данной конфигурации не поддерживается"
+msgstr "-masm=intel не поддерживается в этой конфигурации"
  
  #: config/i386/i386.c:4781
  #, gcc-internal-format, gfc-internal-format
@@ -29531,74 +30893,78 @@ msgid "Intel MPX does not support x32"
  msgstr "%s не поддерживает %s"
  
  #: config/i386/i386.c:4992
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "generic CPU can be used only for %stune=%s %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ (%s) Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mtune="
+msgstr "Ð¾Ð±Ð¾Ð±Ñ\89ÐµÐ½Ð½Ñ\8bÐ¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80 Ð¼Ð¾Ð¶ÐµÑ\82 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f %stune=%s %s"
  
  #: config/i386/i386.c:4995
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "generic CPU can be used only for %stune=%s %s"
  msgid "intel CPU can be used only for %stune=%s %s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ (%s) Ð´Ð»Ñ\8f ÐºÐ»Ñ\8eÑ\87Ð° -mtune="
+msgstr "Ð¾Ð±Ð¾Ð±Ñ\89ÐµÐ½Ð½Ñ\8bÐ¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80 Ð¼Ð¾Ð¶ÐµÑ\82 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f %stune=%s %s"
  
  #: config/i386/i386.c:4998
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "bad value (%s) for %sarch=%s %s"
-msgstr "некорректное значение (%s) для ключа -march"
+msgstr "некорректное значение (%s) для %sarch=%s %s"
  
  #: config/i386/i386.c:5041
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "bad value (%s) for %stune=%s %s"
-msgstr "некорректное значение (%s) для ключа -mtune="
+msgstr "некорректное значение (%s) для %stune=%s %s"
  
  #: config/i386/i386.c:5105
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-mregparm is ignored in 64-bit mode"
-msgstr "соглашения о вызовах -mrtd не поддерживаются в 64-битном режиме"
+msgstr "-mregparm игнорируется в 64-битном режиме"
  
  #: config/i386/i386.c:5107
  #, fuzzy, gcc-internal-format
+#| msgid "-mregparm is ignored in 64-bit mode"
  msgid "-mregparm is ignored for Intel MCU psABI"
-msgstr "соглашения о вызовах -mrtd не поддерживаются в 64-битном режиме"
+msgstr "-mregparm игнорируется в 64-битном режиме"
  
  #: config/i386/i386.c:5110
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "-mregparm=%d is not between 0 and %d"
-msgstr "-mregparm=%d Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° 0 - %d"
+msgstr "-mregparm=%d Ð½Ðµ Ð¼ÐµÐ¶Ð´Ñ\83 0 Ð¸ %d"
  
  #: config/i386/i386.c:5141
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%srtd%s is ignored in 64bit mode"
-msgstr "соглашения о вызовах -mrtd не поддерживаются в 64-битном режиме"
+msgstr "%srtd%s игнорируется в 64-битном режиме"
  
  #: config/i386/i386.c:5219
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-mpreferred-stack-boundary is not supported for this target"
-msgstr "-fprefetch-loop-arrays не поддерживается для этой целевой машины"
+msgstr "-mpreferred-stack-boundary не поддерживается для этой целевой платформы"
  
  #: config/i386/i386.c:5222
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "-mpreferred-stack-boundary=%d is not between %d and %d"
-msgstr "-mpreferred-stack-boundary=%d Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°  %d - 12"
+msgstr "-mpreferred-stack-boundary=%d Ð½Ðµ Ð¼ÐµÐ¶Ð´Ñ\83 %d Ð¸ %d"
  
  #: config/i386/i386.c:5245
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "-mincoming-stack-boundary=%d is not between %d and 12"
-msgstr "-mpreferred-stack-boundary=%d вне диапазона  %d - 12"
+msgstr "-mincoming-stack-boundary=%d не между %d и 12"
  
  #: config/i386/i386.c:5258
  #, fuzzy, gcc-internal-format
+#| msgid "-mno-fentry isn%'t compatible with SEH"
  msgid "-mnop-mcount is not compatible with this target"
-msgstr "ключ -march=%s несовместим с выбранным ABI"
+msgstr "-mno-fentry несовместимо с SEH"
  
  #: config/i386/i386.c:5261
  #, fuzzy, gcc-internal-format
+#| msgid "inter-module optimizations not implemented for C++"
  msgid "-mnop-mcount is not implemented for -fPIC"
-msgstr "Ð¼ÐµÐ¶Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8cÐ½Ñ\8bÐµ Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð¿Ð¾ÐºÐ° Ð½Ðµ Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð¾Ð²Ð°Ð½Ñ\8b"
+msgstr "Ð¼ÐµÐ¶Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8cÐ½Ñ\8bÐµ Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð½Ðµ Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð¾Ð²Ð°Ð½Ñ\8b Ð´Ð»Ñ\8f C++"
  
  #: config/i386/i386.c:5266
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%ssseregparm%s used without SSE enabled"
-msgstr "ключ -msseregparm использован без SSE"
+msgstr "%ssseregparm%s используется без SSE включения"
  
  #: config/i386/i386.c:5276
  #, gcc-internal-format
@@ -29611,34 +30977,35 @@ msgid "387 instruction set disabled, using SSE arithmetics"
  msgstr "набор команд 387 отменен, используется арифметика SSE"
  
  #: config/i386/i386.c:5331
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "stack probing requires %saccumulate-outgoing-args%s for correctness"
-msgstr "Ð´Ð»Ñ\8f ÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ð¹ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶ÐºÐ¸ Ñ\82Ð°Ð±Ð»Ð¸Ñ\86 Ñ\80Ð°Ñ\81ÐºÑ\80Ñ\83Ñ\82ÐºÐ¸ Ñ\81Ñ\82ÐµÐºÐ° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð»Ð¸Ð±Ð¾ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c ÐºÐ°Ð´Ñ\80Ð°, Ð»Ð¸Ð±Ð¾ -maccumulate-outgoing-args"
+msgstr "Ð¾Ð¿Ñ\80Ð¾Ð±Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\81Ñ\82ÐµÐºÐ° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 %saccumulate-outgoing-args%s Ð´Ð»Ñ\8f ÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ð¹ Ñ\80Ð°Ð±Ð¾Ñ\82Ñ\8b"
  
  #: config/i386/i386.c:5342
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "stack probing requires %saccumulate-outgoing-args%s for correctness"
  msgid "fixed ebp register requires %saccumulate-outgoing-args%s"
-msgstr "Ð´Ð»Ñ\8f ÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ð¹ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶ÐºÐ¸ Ñ\82Ð°Ð±Ð»Ð¸Ñ\86 Ñ\80Ð°Ñ\81ÐºÑ\80Ñ\83Ñ\82ÐºÐ¸ Ñ\81Ñ\82ÐµÐºÐ° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð»Ð¸Ð±Ð¾ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c ÐºÐ°Ð´Ñ\80Ð°, Ð»Ð¸Ð±Ð¾ -maccumulate-outgoing-args"
+msgstr "Ð¾Ð¿Ñ\80Ð¾Ð±Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\81Ñ\82ÐµÐºÐ° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 %saccumulate-outgoing-args%s Ð´Ð»Ñ\8f ÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ð¹ Ñ\80Ð°Ð±Ð¾Ñ\82Ñ\8b"
  
  #: config/i386/i386.c:5455
  #, gcc-internal-format
  msgid "-mfentry isn%'t supported for 32-bit in combination with -fpic"
-msgstr ""
+msgstr "-mfentry не поддерживается для 32 бит в комбинации с -fpic"
  
  #: config/i386/i386.c:5462
  #, gcc-internal-format
  msgid "-mno-fentry isn%'t compatible with SEH"
-msgstr ""
+msgstr "-mno-fentry несовместимо с SEH"
  
  #: config/i386/i386.c:5528 config/rs6000/rs6000.c:4845
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "unknown option for -mrecip=%s"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 -m%s=: '%s'"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¾Ð¿Ñ\86Ð¸Ñ\8f Ð´Ð»Ñ\8f -mrecip=%s"
  
  #: config/i386/i386.c:6135
  #, gcc-internal-format, gfc-internal-format
  msgid "option(\"%s\") was already specified"
-msgstr ""
+msgstr "option(\"%s\") уже было задано"
  
  #: config/i386/i386.c:6830 config/i386/i386.c:6881
  #, gcc-internal-format
@@ -29646,19 +31013,19 @@ msgid "fastcall and regparm attributes are not compatible"
  msgstr "атрибуты fastcall и regparm несовместимы"
  
  #: config/i386/i386.c:6835
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "regparam and thiscall attributes are not compatible"
-msgstr "атрибуты fastcall и stdcall несовместимы"
+msgstr "атрибуты regparam и thiscall несовместимы"
  
  #: config/i386/i386.c:6842 config/i386/i386.c:44455
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute requires an integer constant argument"
-msgstr "аргументом атрибута %qs должна быть целая константа"
+msgstr "%qE атрибут требует целый константный аргумент"
  
  #: config/i386/i386.c:6848
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument to %qE attribute larger than %d"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs Ð±Ð¾Ð»Ñ\8cÑ\88Ðµ %d"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qE Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° Ð±Ð¾Ð»Ñ\8cÑ\88Ðµ Ñ\87ÐµÐ¼ %d"
  
  #: config/i386/i386.c:6873 config/i386/i386.c:6916
  #, gcc-internal-format
@@ -29671,9 +31038,9 @@ msgid "fastcall and stdcall attributes are not compatible"
  msgstr "атрибуты fastcall и stdcall несовместимы"
  
  #: config/i386/i386.c:6885 config/i386/i386.c:6934
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "fastcall and thiscall attributes are not compatible"
-msgstr "атрибуты fastcall и stdcall несовместимы"
+msgstr "атрибуты fastcall и thiscall несовместимы"
  
  #: config/i386/i386.c:6895 config/i386/i386.c:6912
  #, gcc-internal-format
@@ -29686,29 +31053,30 @@ msgid "stdcall and fastcall attributes are not compatible"
  msgstr "атрибуты stdcall и fastcall несовместимы"
  
  #: config/i386/i386.c:6903 config/i386/i386.c:6930
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "stdcall and thiscall attributes are not compatible"
-msgstr "атрибуты stdcall и fastcall несовместимы"
+msgstr "атрибуты stdcall и thiscall несовместимы"
  
  #: config/i386/i386.c:6920 config/i386/i386.c:6938
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cdecl and thiscall attributes are not compatible"
-msgstr "атрибуты stdcall и fastcall несовместимы"
+msgstr "атрибуты cdecl и thiscall несовместимы"
  
  #: config/i386/i386.c:6926
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute is used for none class-method"
  msgid "%qE attribute is used for non-class method"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð´Ð»Ñ\8f Ð½Ðµ ÐºÐ»Ð°Ñ\81Ñ\81Ð¾Ð²Ñ\8bÑ\85 Ñ\82Ð¸Ð¿Ð¾Ð² Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð½Ðµ Ð´Ð»Ñ\8f Ð¼ÐµÑ\82Ð¾Ð´Ð° ÐºÐ»Ð°Ñ\81Ñ\81Ð°"
  
  #: config/i386/i386.c:7164
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "calling %qD with attribute sseregparm without SSE/SSE2 enabled"
-msgstr "Ð\92Ñ\8bÐ·Ð¾Ð² %qD Ñ\81 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð¼ sseregparm Ð±ÐµÐ· Ð·Ð°Ð´Ð°ния SSE/SSE2"
+msgstr "Ð²Ñ\8bÐ·Ð¾Ð² %qD Ñ\81 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð¼ sseregparm Ð±ÐµÐ· Ð²ÐºÐ»Ñ\8eÑ\87Ðµния SSE/SSE2"
  
  #: config/i386/i386.c:7167
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "calling %qT with attribute sseregparm without SSE/SSE2 enabled"
-msgstr "Ð\92Ñ\8bÐ·Ð¾Ð² %qT Ñ\81 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð¼ sseregparm Ð±ÐµÐ· Ð·Ð°Ð´Ð°ния SSE/SSE2"
+msgstr "Ð²Ñ\8bÐ·Ð¾Ð² %qT Ñ\81 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð¼ sseregparm Ð±ÐµÐ· Ð²ÐºÐ»Ñ\8eÑ\87Ðµния SSE/SSE2"
  
  #: config/i386/i386.c:7495
  #, fuzzy, gcc-internal-format
@@ -29719,32 +31087,35 @@ msgstr "не поддерживает мультибиблиотеку"
  #: config/i386/i386.c:7527
  #, gcc-internal-format
  msgid "ms_hook_prologue is not compatible with nested function"
-msgstr ""
+msgstr "ms_hook_prologue несовместим с вложенной функцией"
  
  #: config/i386/i386.c:7840
  #, fuzzy, gcc-internal-format
+#| msgid "AVX vector argument without AVX enabled changes the ABI"
  msgid "AVX512F vector argument without AVX512F enabled changes the ABI"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 - Ð²ÐµÐºÑ\82Ð¾Ñ\80 MMX Ð±ÐµÐ· Ð²ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ñ\8f MMX изменяет ABI"
+msgstr "Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 AVX Ð±ÐµÐ· Ð²ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ñ\8f AVX изменяет ABI"
  
  #: config/i386/i386.c:7846
  #, fuzzy, gcc-internal-format
+#| msgid "AVX vector argument without AVX enabled changes the ABI"
  msgid "AVX512F vector return without AVX512F enabled changes the ABI"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 - Ð²ÐµÐºÑ\82Ð¾Ñ\80 MMX Ð±ÐµÐ· Ð²ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ñ\8f MMX изменяет ABI"
+msgstr "Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 AVX Ð±ÐµÐ· Ð²ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ñ\8f AVX изменяет ABI"
  
  #: config/i386/i386.c:7860
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "AVX vector argument without AVX enabled changes the ABI"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 - Ð²ÐµÐºÑ\82Ð¾Ñ\80 MMX Ð±ÐµÐ· Ð²ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ñ\8f MMX изменяет ABI"
+msgstr "Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 AVX Ð±ÐµÐ· Ð²ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ñ\8f AVX изменяет ABI"
  
  #: config/i386/i386.c:7866
  #, fuzzy, gcc-internal-format
+#| msgid "AVX vector argument without AVX enabled changes the ABI"
  msgid "AVX vector return without AVX enabled changes the ABI"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 - Ð²ÐµÐºÑ\82Ð¾Ñ\80 MMX Ð±ÐµÐ· Ð²ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ñ\8f MMX изменяет ABI"
+msgstr "Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 AVX Ð±ÐµÐ· Ð²ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ñ\8f AVX изменяет ABI"
  
  #: config/i386/i386.c:7882
  #, gcc-internal-format
  msgid "SSE vector argument without SSE enabled changes the ABI"
-msgstr "аргумент - вектор SSE без включения SSE изменяет ABI"
+msgstr "SSE векторный аргумент без включения SSE изменяет ABI"
  
  #: config/i386/i386.c:7888
  #, gcc-internal-format
@@ -29764,37 +31135,38 @@ msgstr "возврат вектора MMX без включения MMX изме
  #: config/i386/i386.c:8090
  #, gcc-internal-format
  msgid "the ABI of passing struct with a flexible array member has changed in GCC 4.4"
-msgstr ""
+msgstr "ABI для передачи структуры с элементом flexible array изменен в GCC 4.4"
  
  #: config/i386/i386.c:8207
  #, gcc-internal-format
  msgid "the ABI of passing union with long double has changed in GCC 4.4"
-msgstr ""
+msgstr "ABI для передачи объединения с long double изменен в GCC 4.4"
  
  #: config/i386/i386.c:8325
  #, gcc-internal-format
  msgid "the ABI of passing structure with complex float member has changed in GCC 4.4"
-msgstr ""
+msgstr "ABI для передачи структуры с элементом complex float изменен в GCC 4.4"
  
  #: config/i386/i386.c:8488
  #, gcc-internal-format
  msgid "SSE register return with SSE disabled"
-msgstr "возврат результата в SSE регистре без задания SSE"
+msgstr "SSE регистровый возврат с выключенным SSE"
  
  #: config/i386/i386.c:8494
  #, gcc-internal-format
  msgid "SSE register argument with SSE disabled"
-msgstr "аргумент - SSE регистр без задания SSE"
+msgstr "SSE регистровый аргумент с выключенным SSE"
  
  #: config/i386/i386.c:8510
  #, gcc-internal-format
  msgid "x87 register return with x87 disabled"
-msgstr "результат - вектор SSE без включения SSE изменяет ABI"
+msgstr "x87 регистровый возврат с выключенным x87"
  
  #: config/i386/i386.c:8805 config/i386/i386.c:9070
  #, fuzzy, gcc-internal-format
+#| msgid "calling %qD with attribute sseregparm without SSE/SSE2 enabled"
  msgid "calling %qD with SSE calling convention without SSE/SSE2 enabled"
-msgstr "Ð\92Ñ\8bÐ·Ð¾Ð² %qD Ñ\81 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð¼ sseregparm Ð±ÐµÐ· Ð·Ð°Ð´Ð°ния SSE/SSE2"
+msgstr "Ð²Ñ\8bÐ·Ð¾Ð² %qD Ñ\81 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð¼ sseregparm Ð±ÐµÐ· Ð²ÐºÐ»Ñ\8eÑ\87Ðµния SSE/SSE2"
  
  #: config/i386/i386.c:8807 config/i386/i386.c:9072 config/i386/i386.c:9565
  #, gcc-internal-format
@@ -29804,34 +31176,36 @@ msgstr ""
  #: config/i386/i386.c:9465
  #, gcc-internal-format, gfc-internal-format
  msgid "The ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
-msgstr ""
+msgstr "ABI для передачи параметров с %d-байтным выравниванием изменен в GCC 4.6"
  
  #: config/i386/i386.c:9563
  #, fuzzy, gcc-internal-format
+#| msgid "calling %qD with attribute sseregparm without SSE/SSE2 enabled"
  msgid "calling %qD with SSE caling convention without SSE/SSE2 enabled"
-msgstr "Ð\92Ñ\8bÐ·Ð¾Ð² %qD Ñ\81 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð¼ sseregparm Ð±ÐµÐ· Ð·Ð°Ð´Ð°ния SSE/SSE2"
+msgstr "Ð²Ñ\8bÐ·Ð¾Ð² %qD Ñ\81 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð¼ sseregparm Ð±ÐµÐ· Ð²ÐºÐ»Ñ\8eÑ\87Ðµния SSE/SSE2"
  
  #: config/i386/i386.c:12691
  #, gcc-internal-format
  msgid "ms_hook_prologue attribute isn%'t compatible with -mfentry for 32-bit"
-msgstr ""
+msgstr "атрибут ms_hook_prologue несовместим с -mfentry для 32 бит"
  
  #: config/i386/i386.c:13757
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-fsplit-stack does not support fastcall with nested function"
-msgstr "индукция не поддерживается"
+msgstr "-fsplit-stack не поддерживает fastcall с вложенной функцией"
  
  #: config/i386/i386.c:13777
  #, fuzzy, gcc-internal-format
+#| msgid "-fsplit-stack does not support 2 register  parameters for a nested function"
  msgid "-fsplit-stack does not support 2 register parameters for a nested function"
-msgstr "индукция не поддерживается"
+msgstr "-fsplit-stack не поддерживает 2-регистровые параметры для вложенной функции"
  
  #. FIXME: We could make this work by pushing a register
  #. around the addition and comparison.
  #: config/i386/i386.c:13788
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-fsplit-stack does not support 3 register parameters"
-msgstr "ISO C90 не поддерживает регулируемые элементы-массивы"
+msgstr "-fsplit-stack не поддерживает 3-регистровые параметры"
  
  #: config/i386/i386.c:16599
  #, gcc-internal-format
@@ -29845,8 +31219,9 @@ msgstr "некорректный размер операнда для расши
  
  #: config/i386/i386.c:16806
  #, fuzzy, gcc-internal-format
+#| msgid "non-integer operand used with operand code '%c'"
  msgid "non-integer operand used with operand code 'z'"
-msgstr "некорректный код операнда '%c'"
+msgstr "нецелый операнд использован с кодом операнда '%c'"
  
  #: config/i386/i386.c:36396
  #, gcc-internal-format
@@ -29868,90 +31243,99 @@ msgstr ""
  msgid "Function versions cannot be marked as gnu_inline, bodies have to be generated"
  msgstr ""
  
+#
  #: config/i386/i386.c:36709 config/i386/i386.c:37137
  #, fuzzy, gcc-internal-format
+#| msgid "static linking is not supported"
  msgid "Virtual function multiversioning not supported"
-msgstr "Статическая компоновка не поддерживается.\n"
+msgstr "статическая компоновка не поддерживается"
  
  #: config/i386/i386.c:36772
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "missing %<=%> (after %<getter%> attribute) before %qE"
  msgid "missing %<target%> attribute for multi-versioned %D"
-msgstr ""
+msgstr "отсутствует %<=%> (после атрибута %<getter%>) перед %qE"
  
  #: config/i386/i386.c:36775
  #, fuzzy, gcc-internal-format
+#| msgid "previous declaration of %q+D"
  msgid "previous declaration of %D"
  msgstr "предыдущая декларация %q+D"
  
  #: config/i386/i386.c:36994
  #, fuzzy, gcc-internal-format
+#| msgid "nested functions not supported on this target"
  msgid "multiversioning needs ifunc which is not supported on this target"
-msgstr "-m%s в данной конфигурации не поддерживается"
+msgstr "вложенные функции не поддерживаются для этой платформы"
  
  #: config/i386/i386.c:37380
  #, fuzzy, gcc-internal-format
+#| msgid "argument to %qs must be a 2-bit unsigned literal"
  msgid "Parameter to builtin must be a string constant or literal"
-msgstr "аргумент %qs должен быть 2-битным беззнаковым литеральным значением"
+msgstr "аргумент %qs должен быть 2-битным беззнаковым литералом"
  
  #: config/i386/i386.c:37405 config/i386/i386.c:37455
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Argument to -ffpe-trap is not valid: %s"
  msgid "Parameter to builtin not valid: %s"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f -ffpe-trap Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½: %s"
  
  #: config/i386/i386.c:37866 config/i386/i386.c:39217
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the last argument must be a 2-bit immediate"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "последний аргумент должен быть 2-битным непосредственным"
  
  #: config/i386/i386.c:38261
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the fifth argument must be an 8-bit immediate"
-msgstr "первый аргумент должен быть 5-битным знаковым литеральным значением"
+msgstr "пятый аргумент должен быть 8-битным непосредственным"
  
  #: config/i386/i386.c:38356
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the third argument must be an 8-bit immediate"
-msgstr "первый аргумент должен быть 5-битным знаковым литеральным значением"
+msgstr "третий аргумент должен быть 8-битным непосредственным"
  
  #: config/i386/i386.c:39148
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the last argument must be an 1-bit immediate"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "последний аргумент должен быть 1-битным непосредственным"
  
  #: config/i386/i386.c:39163
  #, fuzzy, gcc-internal-format
+#| msgid "the last argument must be a 32-bit immediate"
  msgid "the last argument must be a 3-bit immediate"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "последний аргумент должен быть 32-битным непосредственным"
  
  #: config/i386/i386.c:39196
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the last argument must be a 4-bit immediate"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "последний аргумент должен быть 4-битным непосредственным"
  
  #: config/i386/i386.c:39236
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the last argument must be a 1-bit immediate"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "последний аргумент должен быть 1-битным непосредственным"
  
  #: config/i386/i386.c:39249
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the last argument must be a 5-bit immediate"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "последний аргумент должен быть 5-битным непосредственным"
  
  #: config/i386/i386.c:39259
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the next to last argument must be an 8-bit immediate"
-msgstr "первый аргумент должен быть 5-битным знаковым литеральным значением"
+msgstr "следующий за последним аргумент должен быть 8-битным непосредственным"
  
  #: config/i386/i386.c:39263 config/i386/i386.c:40027
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the last argument must be an 8-bit immediate"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¿Ð¾Ñ\81Ð»ÐµÐ´Ð½Ð¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 8-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bм"
  
  #: config/i386/i386.c:39430
  #, fuzzy, gcc-internal-format
+#| msgid "argument must be a constant"
  msgid "the third argument must be comparison constant"
-msgstr "аргумент %qD не является константой"
+msgstr "аргумент должен быть константой"
  
  #: config/i386/i386.c:39435
  #, fuzzy, gcc-internal-format
@@ -29967,23 +31351,26 @@ msgstr "недопустимое разделение узлов дерева"
  
  #: config/i386/i386.c:39624
  #, fuzzy, gcc-internal-format
+#| msgid "the last argument must be a 4-bit immediate"
  msgid "the immediate argument must be a 4-bit immediate"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "последний аргумент должен быть 4-битным непосредственным"
  
  #: config/i386/i386.c:39630
  #, fuzzy, gcc-internal-format
+#| msgid "the last argument must be a 5-bit immediate"
  msgid "the immediate argument must be a 5-bit immediate"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "последний аргумент должен быть 5-битным непосредственным"
  
  #: config/i386/i386.c:39633
  #, fuzzy, gcc-internal-format
+#| msgid "the last argument must be an 8-bit immediate"
  msgid "the immediate argument must be an 8-bit immediate"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¿Ð¾Ñ\81Ð»ÐµÐ´Ð½Ð¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 8-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bм"
  
  #: config/i386/i386.c:40025
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the last argument must be a 32-bit immediate"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "последний аргумент должен быть 32-битным непосредственным"
  
  #: config/i386/i386.c:40107 config/rs6000/rs6000.c:13967
  #, gcc-internal-format
@@ -29993,27 +31380,29 @@ msgstr "селектор должен быть целой константой 
  #: config/i386/i386.c:40301
  #, gcc-internal-format
  msgid "%qE needs unknown isa option"
-msgstr ""
+msgstr "%qE требует неизвестную isa опцию"
  
  #: config/i386/i386.c:40305
  #, gcc-internal-format
  msgid "%qE needs isa option %s"
-msgstr ""
+msgstr "%qE требует isa опцию %s"
  
  #: config/i386/i386.c:41067
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "last argument must be an immediate"
-msgstr "Ð¼Ð°Ñ\81ÐºÐ° Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¿Ð¾Ñ\81Ð»ÐµÐ´Ð½Ð¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bм"
  
  #: config/i386/i386.c:41676 config/i386/i386.c:41858
  #, fuzzy, gcc-internal-format
+#| msgid "last argument must be scale 1, 2, 4, 8"
  msgid "the last argument must be scale 1, 2, 4, 8"
-msgstr "Ð¼Ð°Ñ\81ÐºÐ° Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¿Ð¾Ñ\81Ð»ÐµÐ´Ð½Ð¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\81Ñ\82ÐµÐ¿ÐµÐ½Ñ\8cÑ\8e 1, 2, 4, 8"
  
  #: config/i386/i386.c:41911
  #, fuzzy, gcc-internal-format
+#| msgid "last argument must be scale 1, 2, 4, 8"
  msgid "the forth argument must be scale 1, 2, 4, 8"
-msgstr "Ð¼Ð°Ñ\81ÐºÐ° Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¿Ð¾Ñ\81Ð»ÐµÐ´Ð½Ð¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\81Ñ\82ÐµÐ¿ÐµÐ½Ñ\8cÑ\8e 1, 2, 4, 8"
  
  #: config/i386/i386.c:41917
  #, fuzzy, gcc-internal-format
@@ -30023,46 +31412,51 @@ msgstr "некорректная инструкция:"
  
  #: config/i386/i386.c:41936
  #, fuzzy, gcc-internal-format
+#| msgid "the last argument must be an 8-bit immediate"
  msgid "the xabort's argument must be an 8-bit immediate"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¿Ð¾Ñ\81Ð»ÐµÐ´Ð½Ð¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 8-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bм"
  
  #: config/i386/i386.c:44442
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute only available for 32-bit"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "атрибут %qE допустим только для 32 бит"
  
  #: config/i386/i386.c:44463
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument to %qE attribute is neither zero, nor one"
-msgstr "аргумент атрибута %qs не является строковой константой"
+msgstr "аргумент атрибута %qE не ноль и не один"
  
  #: config/i386/i386.c:44496 config/i386/i386.c:44505
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ms_abi and sysv_abi attributes are not compatible"
-msgstr "атрибуты fastcall и stdcall несовместимы"
+msgstr "атрибуты ms_abi и sysv_abi несовместимы"
  
  #: config/i386/i386.c:44541 config/rs6000/rs6000.c:31064
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE incompatible attribute ignored"
-msgstr "%qs - несовместимый атрибут, игнорируется"
+msgstr "несовместимый атрибут %qE игнорируется"
  
  #: config/i386/i386.c:47478
  #, fuzzy, gcc-internal-format
+#| msgid "By-value argument at %L is not allowed in this context"
  msgid "alternatives not allowed in asm flag output"
-msgstr "стандартные преобразования в данном контексте недопустимы"
+msgstr "Аргумент по значению в %L не допускается в этом контексте"
  
  #: config/i386/i386.c:47542
  #, fuzzy, gcc-internal-format
+#| msgid "unknown IRA algorithm %qs"
  msgid "unknown asm flag output %qs"
-msgstr "неизвестная машинный режим %qs"
+msgstr "неизвестный алгоритм раскраски %qs"
  
  #: config/i386/i386.c:47571
  #, fuzzy, gcc-internal-format
+#| msgid "invalid type for make function"
  msgid "invalid type for asm flag output"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾Ðµ Ñ\83Ð¿Ð¾Ñ\82Ñ\80ÐµÐ±Ð»ÐµÐ½Ð¸Ðµ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð° %<restrict%>"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f make Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
  
  #: config/i386/i386.c:53731
  #, fuzzy, gcc-internal-format
+#| msgid "Unknown architecture '%s'"
  msgid "Unknown architecture specific memory model"
  msgstr "неизвестная архитектура '%s'"
  
@@ -30089,8 +31483,9 @@ msgstr ""
  
  #: config/i386/i386.c:53809
  #, fuzzy, gcc-internal-format
+#| msgid "unsupported argument type to builtin function"
  msgid "unsupported argument type %qT for simd\n"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 внутренней функции"
+msgstr "Ð½ÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° Ð´Ð»Ñ\8f внутренней функции"
  
  #: config/i386/i386.c:54136
  #, gcc-internal-format
@@ -30130,18 +31525,19 @@ msgstr "нет поля %qs"
  
  #: config/i386/intelmic-mkoffload.c:582 config/nvptx/mkoffload.c:474
  #, fuzzy, gcc-internal-format
+#| msgid "unrecognized argument in option %qs"
  msgid "unrecognizable argument of option "
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 \"%s\""
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
  
  #: config/i386/winnt.c:78
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute applies only to initialized variables with external linkage"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "атрибут %qE применяется только к инициализированным переменным с внешней линковкой"
  
  #: config/i386/winnt.c:151
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "definition of static data member %q+D of dllimport%'d class"
-msgstr "Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° Ð´Ð°Ð½Ð½Ñ\8bÑ\85 %q+D Ð² Ð¸Ð¼Ð¿Ð¾Ñ\80Ñ\82Ð¸Ñ\80Ñ\83ÐµÐ¼Ð¾Ð¼ ÐºÐ»Ð°Ñ\81Ñ\81Ðµ dllimport"
+msgstr "Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° Ð´Ð°Ð½Ð½Ñ\8bÑ\85 %q+D Ð¸Ð¼Ð¿Ð¾Ñ\80Ñ\82Ð¸Ñ\80Ñ\83ÐµÐ¼Ð¾Ð³Ð¾ dll ÐºÐ»Ð°Ñ\81Ñ\81Ð°"
  
  #. If the environment variable DJDIR is not defined, then DJGPP is not        installed correctly and GCC will quickly become confused with the        default prefix settings. Report the problem now so the user doesn't        receive deceptive "file not found" error messages later.
  #. DJDIR is automatically defined by the DJGPP environment config            file pointed to by the environment variable DJGPP. Examine DJGPP            to try and figure out what's wrong.
@@ -30166,14 +31562,14 @@ msgid "malformed #pragma builtin"
  msgstr "Некорректный синтаксис #pragma builtin"
  
  #: config/ia64/ia64.c:722
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid argument of %qE attribute"
-msgstr "некорректный аргумент атрибута %qs"
+msgstr "некорректный аргумент атрибута %qE"
  
  #: config/ia64/ia64.c:735
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "an address area attribute cannot be specified for local variables"
-msgstr "%Jатрибут адресного пространства для локальных переменных недопустим"
+msgstr "атрибут адресного пространства не может быть задан для локальных переменных"
  
  #: config/ia64/ia64.c:742
  #, gcc-internal-format
@@ -30181,14 +31577,14 @@ msgid "address area of %q+D conflicts with previous declaration"
  msgstr "адресное пространство %q+D противоречит предыдущей декларации"
  
  #: config/ia64/ia64.c:750
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "address area attribute cannot be specified for functions"
-msgstr "%Jатрибут адресного пространства для функций недопустим"
+msgstr "атрибут адресного пространства не может быть задан для функций"
  
  #: config/ia64/ia64.c:783
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute requires a string constant argument"
-msgstr "аргументом атрибута %qs должна быть целая константа"
+msgstr "аргументом атрибута %qE должна быть строковая константа"
  
  #: config/ia64/ia64.c:5928 config/pa/pa.c:425 config/sh/sh.c:9616
  #: config/spu/spu.c:4892
@@ -30203,19 +31599,19 @@ msgid "%s-%s is an empty range"
  msgstr "%s-%s задает пустой диапазон"
  
  #: config/ia64/ia64.c:11154
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "version attribute is not a string"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾Ð²Ð¾Ð¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ð²ÐµÑ\80Ñ\81Ð¸Ð¸ Ð½Ðµ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
  
  #: config/iq2000/iq2000.c:1832
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "gp_offset (%ld) or end_offset (%ld) is less than zero"
-msgstr "gp_offset (%ld) или end_offset (%ld) меньше нуля."
+msgstr "gp_offset (%ld) или end_offset (%ld) меньше нуля"
  
  #: config/iq2000/iq2000.c:2599
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument %qd is not a constant"
-msgstr "аргумент %qD не является константой"
+msgstr "аргумент %qd не константа"
  
  #: config/iq2000/iq2000.c:2902 config/xtensa/xtensa.c:2449
  #, gcc-internal-format
@@ -30233,29 +31629,29 @@ msgid "PRINT_OPERAND null pointer"
  msgstr "нулевой указатель в вызове PRINT_OPERAND"
  
  #: config/m32c/m32c-pragma.c:52
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of #pragma GCC memregs [0..16]"
-msgstr "мусор в конце #pragma %s"
+msgstr "мусор в конце #pragma GCC memregs [0..16]"
  
  #: config/m32c/m32c-pragma.c:59
  #, gcc-internal-format
  msgid "#pragma GCC memregs must precede any function decls"
-msgstr ""
+msgstr "#pragma GCC memregs должна предшествовать всем декларациям функций"
  
  #: config/m32c/m32c-pragma.c:67 config/m32c/m32c-pragma.c:74
  #, gcc-internal-format
  msgid "#pragma GCC memregs takes a number [0..16]"
-msgstr ""
+msgstr "#pragma GCC memregs принимает число [0..16]"
  
  #: config/m32c/m32c-pragma.c:102
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of #pragma ADDRESS"
-msgstr "мусор в конце #pragma %s"
+msgstr "мусор в конце #pragma ADDRESS"
  
  #: config/m32c/m32c-pragma.c:107
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed #pragma ADDRESS variable address"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma builtin"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 Ð°Ð´Ñ\80ÐµÑ\81Ð° Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ #pragma ADDRESS"
  
  #: config/m32c/m32c.c:412
  #, gcc-internal-format, gfc-internal-format
@@ -30263,30 +31659,30 @@ msgid "invalid target memregs value '%d'"
  msgstr "некорректное значение '%d' целевых memregs"
  
  #: config/m32c/m32c.c:2924
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute is not supported for R8C target"
-msgstr "%Jатрибут section для данной платформы не поддерживается"
+msgstr "атрибут %qE не поддерживается для R8C платформы"
  
  #. The argument must be a constant integer.
  #: config/m32c/m32c.c:2940 config/sh/sh.c:9835 config/sh/sh.c:9941
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute argument not an integer constant"
-msgstr "аргумент атрибута %qs не является целой константой"
+msgstr "аргумент атрибута %qE не целая константа"
  
  #: config/m32c/m32c.c:2949
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute argument should be between 18 to 255"
-msgstr "аргумент атрибута %qs не является целой константой"
+msgstr "аргумент атрибута %qE должен быть между 18 и 255"
  
  #: config/m32c/m32c.c:4070
  #, gcc-internal-format
  msgid "%<bank_switch%> has no effect on non-interrupt functions"
-msgstr ""
+msgstr "%<bank_switch%> не действует на функции не для прерываний"
  
  #: config/m32c/m32c.c:4177
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<fast_interrupt%> attribute directive ignored"
-msgstr "Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¸Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² %qs Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð°"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð½Ð°Ñ\8f Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° %<fast_interrupt%> Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
  
  #: config/m32r/m32r.c:389
  #, gcc-internal-format
@@ -30294,39 +31690,40 @@ msgid "invalid argument of %qs attribute"
  msgstr "некорректный аргумент атрибута %qs"
  
  #: config/m68k/m68k.c:493
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "-mcpu=%s conflicts with -march=%s"
-msgstr "ключ -mcpu=%s несовместим с ключом -march="
+msgstr "-mcpu=%s конфликтует с -march=%s"
  
  #: config/m68k/m68k.c:564
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-mpcrel -fPIC is not currently supported on selected cpu"
-msgstr "-fPIC для 68000 и 68010 в настоящее время не поддерживается\n"
+msgstr "-mpcrel -fPIC в настоящее время не поддерживается на выбранном процессоре"
  
  #: config/m68k/m68k.c:626
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "-falign-labels=%d is not supported"
-msgstr "\"трамплины\" не поддерживаются"
+msgstr "-falign-labels=%d не поддерживается"
  
  #: config/m68k/m68k.c:631
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "-falign-loops=%d is not supported"
-msgstr "-malign-loops=%d вне диапазона 0 - %d"
+msgstr "-falign-loops=%d не поддерживается"
  
  #: config/m68k/m68k.c:638
  #, fuzzy, gcc-internal-format
+#| msgid "stack limits not supported on this target"
  msgid "-fstack-limit- options are not supported on this cpu"
  msgstr "проверка выхода за границу стека не поддерживается для этой платформы"
  
  #: config/m68k/m68k.c:755
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "multiple interrupt attributes not allowed"
-msgstr "Ð·Ð°Ð´Ð°Ð½Ð¾ Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ñ\82Ð¸Ð¿Ð° Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ð¿Ñ\80ÐµÑ\80Ñ\8bÐ²Ð°Ð½Ð¸Ð¹ Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f"
  
  #: config/m68k/m68k.c:762
  #, gcc-internal-format
  msgid "interrupt_thread is available only on fido"
-msgstr ""
+msgstr "interrupt_thread доступен только на fido"
  
  #: config/m68k/m68k.c:1096 config/rs6000/rs6000.c:24299
  #, gcc-internal-format
@@ -30339,233 +31736,237 @@ msgid "initialized variable %q+D is marked dllimport"
  msgstr "инициализированная переменная %q+D помечена как dllimport"
  
  #: config/mep/mep-pragma.c:68
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of #pragma io_volatile"
-msgstr "мусор в конце #pragma longcall"
+msgstr "мусор в конце #pragma io_volatile"
  
  #: config/mep/mep-pragma.c:82
  #, gcc-internal-format
  msgid "#pragma io_volatile takes only on or off"
-msgstr ""
+msgstr "#pragma io_volatile принимает только on или off"
  
  #: config/mep/mep-pragma.c:121
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid coprocessor register range"
-msgstr "Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð·Ð°Ð´Ð°Ð½Ð¾ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð² Ñ\81Ð¾Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80Ð°"
  
  #: config/mep/mep-pragma.c:141
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid coprocessor register %qE"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾ Ð·Ð°Ð´Ð°Ð½ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82а %qE"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80 Ñ\81Ð¾Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80а %qE"
  
  #: config/mep/mep-pragma.c:164
  #, gcc-internal-format
  msgid "malformed coprocessor register"
-msgstr ""
+msgstr "некорректный синтаксис регистра сопроцессора"
  
  #: config/mep/mep-pragma.c:251
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of #pragma GCC coprocessor width"
-msgstr "мусор в конце директивы %<#pragma pack%>"
+msgstr "мусор в конце директивы #pragma GCC coprocessor width"
  
  #: config/mep/mep-pragma.c:258
  #, gcc-internal-format
  msgid "#pragma GCC coprocessor width takes only 32 or 64"
-msgstr ""
+msgstr "директива #pragma GCC coprocessor width принимает только 32 или 64"
  
  #: config/mep/mep-pragma.c:289
  #, gcc-internal-format
  msgid "#pragma GCC coprocessor subclass letter must be in [ABCD]"
-msgstr ""
+msgstr "#pragma GCC coprocessor subclass буква должна входить в [ABCD]"
  
  #: config/mep/mep-pragma.c:294
  #, gcc-internal-format, gfc-internal-format
  msgid "#pragma GCC coprocessor subclass '%c' already defined"
-msgstr ""
+msgstr "#pragma GCC coprocessor subclass '%c' уже определен"
  
  #: config/mep/mep-pragma.c:312
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed #pragma GCC coprocessor subclass"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma builtin"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma GCC coprocessor subclass"
  
  #: config/mep/mep-pragma.c:334
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed #pragma disinterrupt"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma builtin"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma disinterrupt"
  
  #: config/mep/mep-pragma.c:348
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed #pragma GCC coprocessor"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma weak, Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð°"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma GCC coprocessor"
  
  #: config/mep/mep-pragma.c:353
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "coprocessor not enabled"
-msgstr "активные ключи: "
+msgstr "сопроцессор не включен"
  
  #: config/mep/mep-pragma.c:364
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unknown #pragma GCC coprocessor %E"
-msgstr "Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð² ÐºÐ¾Ð½Ñ\86Ðµ Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ñ\8b %<#pragma pack%>"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ #pragma GCC intrinsic %E"
  
  #: config/mep/mep-pragma.c:386
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed #pragma call"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma builtin"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma call"
  
  #: config/mep/mep.c:358
  #, gcc-internal-format
  msgid "only one of -ms and -mm may be given"
-msgstr ""
+msgstr "может быть задано либо -ms, либо -mm"
  
  #: config/mep/mep.c:360
  #, gcc-internal-format
  msgid "only one of -ms and -ml may be given"
-msgstr ""
+msgstr "может быть задано либо -ms, либо -ml"
  
  #: config/mep/mep.c:362
  #, gcc-internal-format
  msgid "only one of -mm and -ml may be given"
-msgstr ""
+msgstr "может быть задано либо -mm, либо -ml"
  
  #: config/mep/mep.c:364
  #, gcc-internal-format
  msgid "only one of -ms and -mtiny= may be given"
-msgstr ""
+msgstr "может быть задано либо -ms, либо -mtiny="
  
  #: config/mep/mep.c:366
  #, gcc-internal-format
  msgid "only one of -mm and -mtiny= may be given"
-msgstr ""
+msgstr "может быть задано либо -mm, либо -mtiny="
  
  #: config/mep/mep.c:368
  #, gcc-internal-format
  msgid "-mclip currently has no effect without -mminmax"
-msgstr ""
+msgstr "-mclip в настоящее время не действует без -mminmax"
  
  #: config/mep/mep.c:375
  #, gcc-internal-format
  msgid "-mc= must be -mc=tiny, -mc=near, or -mc=far"
-msgstr ""
+msgstr "-mc= должно быть -mc=tiny, -mc=near или -mc=far"
  
  #: config/mep/mep.c:1377
  #, gcc-internal-format
  msgid "unusual TP-relative address"
-msgstr ""
+msgstr "необычный адрес относительно TP"
  
  #: config/mep/mep.c:3349
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unconvertible operand %c %qs"
-msgstr "Ð½ÐµÐ¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ñ\8bÐ¹ Ð¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ %qs"
+msgstr "Ð½ÐµÐ¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ñ\83ÐµÐ¼Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ %c %qs"
  
  #: config/mep/mep.c:3795 config/mep/mep.c:3858
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "address region attributes not allowed with auto storage class"
-msgstr "атрибут section для %q+D недопустим"
+msgstr "атрибут адресного пространства недопустим с классом памяти auto"
  
  #: config/mep/mep.c:3801 config/mep/mep.c:3864
  #, gcc-internal-format
  msgid "address region attributes on pointed-to types ignored"
-msgstr ""
+msgstr "атрибуты адресного пространства для указуемых типов игнорируются"
  
  #: config/mep/mep.c:3850
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute only applies to variables and functions"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹ Ñ\81 Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÐ¼ Ñ\87Ð¸Ñ\81Ð»Ð¾Ð¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾м"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð¿Ñ\80Ð¸Ð¼ÐµÐ½Ð¸Ð¼ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ðº Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÐ¼ Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8fм"
  
  #: config/mep/mep.c:3870 config/mep/mep.c:4157
  #, gcc-internal-format
  msgid "duplicate address region attribute %qE in declaration of %qE on line %d"
-msgstr ""
+msgstr "повторный атрибут адресного пространства %qE в декларации %qE в строке %d"
  
  #: config/mep/mep.c:3904
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot inline interrupt function %qE"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ va_start Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82ÐºÐ¸ Ð¿Ñ\80ÐµÑ\80Ñ\8bÐ²Ð°Ð½Ð¸Ñ\8f"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿Ð¾Ð´Ñ\81Ñ\82Ð°Ð²Ð¸Ñ\82Ñ\8c Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8e Ð¿Ñ\80ÐµÑ\80Ñ\8bÐ²Ð°Ð½Ð¸Ñ\8f %qE"
  
  #: config/mep/mep.c:3910
  #, gcc-internal-format
  msgid "interrupt function must have return type of void"
-msgstr ""
+msgstr "функция прерывания должна иметь тип результата void"
  
  #: config/mep/mep.c:3915
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "interrupt function must have no arguments"
-msgstr "ключ '-%c' требует аргумента"
+msgstr "функция прерывания не должна иметь аргументы"
  
  #: config/mep/mep.c:3969
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute only applies to functions, not %s"
-msgstr "атрибут %qs допустим только для функций"
+msgstr "атрибут %qE применим только к функциям, а не к %s"
  
  #: config/mep/mep.c:3980
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid ""
  "to describe a pointer to a VLIW function, use syntax like this:\n"
  "%s"
-msgstr "в арифметическом выражении использован указатель на функцию"
+msgstr ""
+"для описания указателя на VLIW-функцию используйте следующий синтаксис:\n"
+"%s"
  
  #: config/mep/mep.c:3989
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid ""
  "to describe an array of VLIW function pointers, use syntax like this:\n"
  "%s"
-msgstr "в арифметическом выражении использован указатель на функцию"
+msgstr ""
+"для описания массива указателей на VLIW-функции используйте следующий синтаксис:\n"
+"%s"
  
  #: config/mep/mep.c:3995
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "VLIW functions are not allowed without a VLIW configuration"
-msgstr "атрибуты не допускаются при определении функции"
+msgstr "VLIW-функции не допускаются без VLIW-конфигурации"
  
  #: config/mep/mep.c:4116
  #, gcc-internal-format, gfc-internal-format
  msgid "\"#pragma disinterrupt %s\" not used"
-msgstr ""
+msgstr "\"#pragma disinterrupt %s\" не используется"
  
  #: config/mep/mep.c:4282
  #, gcc-internal-format
  msgid "__io address 0x%x is the same for %qE and %qE"
-msgstr ""
+msgstr "__io address 0x%x одинаков для %qE и %qE"
  
  #: config/mep/mep.c:4430
  #, gcc-internal-format, gfc-internal-format
  msgid "variable %s (%ld bytes) is too large for the %s section (%d bytes)"
-msgstr ""
+msgstr "переменная %s (%ld байт) слишком велика для %s секции (%d байт)"
  
  #: config/mep/mep.c:4528
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %D of type %<io%> must be uninitialized"
-msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð° %qD Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼а"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %D Ñ\82Ð¸Ð¿Ð° %<io%> Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½а"
  
  #: config/mep/mep.c:4533
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %D of type %<cb%> must be uninitialized"
-msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð° %qD Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼а"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %D Ñ\82Ð¸Ð¿Ð° %<cb%> Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½а"
  
  #: config/mep/mep.c:5968
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "coprocessor intrinsic %qs is not available in this configuration"
-msgstr "ключ %qs для этой конфигурации не поддерживается"
+msgstr "coprocessor intrinsic %qs недопустима в этой конфигурации"
  
  #: config/mep/mep.c:5971
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs is not available in VLIW functions"
-msgstr "%qD не является функцией шаблоном"
+msgstr "%qs не допускается в VLIW функции"
  
  #: config/mep/mep.c:5974
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs is not available in non-VLIW functions"
-msgstr "обычно %q+D является нестатической функцией"
+msgstr "%qs не допускается в не-VLIW функции"
  
  #: config/mep/mep.c:6136 config/mep/mep.c:6253
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument %d of %qE must be in the range %d...%d"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "аргумент %d от %qE должен быть в диапазоне %d...%d"
  
  #: config/mep/mep.c:6139
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument %d of %qE must be a multiple of %d"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "аргумент %d от %qE должен быть кратным %d"
  
  #: config/mep/mep.c:6144 c/c-typeck.c:6625
  #, gcc-internal-format
@@ -30573,49 +31974,51 @@ msgid "incompatible type for argument %d of %qE"
  msgstr "несовместимый тип аргумента %d функции %qE"
  
  #: config/mep/mep.c:6192
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too few arguments to %qE"
-msgstr "слишком мало аргументов для %s `%+#D'"
+msgstr "слишком мало аргументов для %qE"
  
  #: config/mep/mep.c:6197
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too many arguments to %qE"
-msgstr "слишком много аргументов для %s `%+#D'"
+msgstr "слишком много аргументов для %qE"
  
  #: config/mep/mep.c:6215
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument %d of %qE must be an address"
-msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qT Ð² ÐºÐ°Ñ\87ÐµÑ\81Ñ\82Ð²Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %d Ð¾Ñ\82 %qE Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð°Ð´Ñ\80ÐµÑ\81Ð¾Ð¼"
  
  #: config/mep/mep.c:7011
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "2 byte cop instructions are not allowed in 64-bit VLIW mode"
-msgstr "стандартные преобразования в данном контексте недопустимы"
+msgstr "инструкции с 2-байтным кодом операции не допускаются в 64-битном VLIW режиме"
  
  #: config/mep/mep.c:7017
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "unexpected %d byte cop instruction"
-msgstr "Ð¿Ñ\80ÐµÐ´Ð¸ÐºÐ°Ñ\82Ð¸Ð²Ð½Ð°Ñ\8f Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8f Ð´Ð»Ñ\8f Ð°Ñ\80Ñ\85Ð¸Ñ\82ÐµÐºÑ\82Ñ\83Ñ\80Ñ\8b Thumb"
+msgstr "Ð½ÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð°Ñ\8f Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8f Ñ\81 %d-Ð±Ð°Ð¹Ñ\82Ð½Ñ\8bÐ¼ ÐºÐ¾Ð´Ð¾Ð¼ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸"
  
  #: config/microblaze/microblaze.c:1688
  #, fuzzy, gcc-internal-format
+#| msgid "-fstack-protector not supported for this target"
  msgid "-fPIC/-fpic not supported for this target"
  msgstr "-fstack-protector не поддерживается для этой целевой платформы"
  
  #: config/microblaze/microblaze.c:1700
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs is an invalid argument to -mcpu="
-msgstr "некорректный аргумент внутренней функции"
+msgstr "%qs некорректный аргумент для -mcpu="
  
  #: config/microblaze/microblaze.c:1749
  #, gcc-internal-format
  msgid "-mxl-multiply-high can be used only with -mcpu=v6.00.a or greater"
-msgstr ""
+msgstr "-mxl-multiply-high может использоваться только с -mcpu=v6.00.a или выше"
  
  #: config/microblaze/microblaze.c:1765
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "-mxl-multiply-high can be used only with -mcpu=v6.00.a or greater"
  msgid "-mxl-reorder can be used only with -mcpu=v8.30.a or greater"
-msgstr ""
+msgstr "-mxl-multiply-high может использоваться только с -mcpu=v6.00.a или выше"
  
  #: config/microblaze/microblaze.c:1771
  #, gcc-internal-format
@@ -30625,7 +32028,7 @@ msgstr ""
  #: config/microblaze/microblaze.c:1776
  #, gcc-internal-format
  msgid "-mxl-multiply-high requires -mno-xl-soft-mul"
-msgstr ""
+msgstr "-mxl-multiply-high требует -mno-xl-soft-mul"
  
  #: config/mips/mips.c:1385 config/mips/mips.c:1389
  #, gcc-internal-format
@@ -30634,23 +32037,26 @@ msgstr "атрибут %qs допустим только для функций"
  
  #: config/mips/mips.c:1399 config/mips/mips.c:1405
  #, fuzzy, gcc-internal-format
+#| msgid "%qE cannot have both %<mips16%> and %<nomips16%> attributes"
  msgid "%qE cannot have both %qs and %qs attributes"
-msgstr "%q+D определено как обычное имя и как alias"
+msgstr "%qE не может иметь оба атрибута: %<mips16%> и %<nomips16%>"
  
  #: config/mips/mips.c:1434 config/mips/mips.c:1440 config/nios2/nios2.c:3985
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE redeclared with conflicting %qs attributes"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qs Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qE Ñ\81 ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83Ñ\8eÑ\89Ð¸Ð¼Ð¸ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð°Ð¼Ð¸ %qs"
  
  #: config/mips/mips.c:1472 config/mips/mips.c:1526
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute requires a string constant argument"
  msgid "%qE attribute requires a string argument"
-msgstr "аргументом атрибута %qs должна быть целая константа"
+msgstr "аргументом атрибута %qE должна быть строковая константа"
  
  #: config/mips/mips.c:1480
  #, fuzzy, gcc-internal-format
+#| msgid "argument to %qE attribute is neither zero, nor one"
  msgid "argument to %qE attribute is neither eic, nor vector=<line>"
-msgstr "аргумент атрибута %qs не является строковой константой"
+msgstr "аргумент атрибута %qE не ноль и не один"
  
  #: config/mips/mips.c:1496
  #, gcc-internal-format
@@ -30659,23 +32065,25 @@ msgstr ""
  
  #: config/mips/mips.c:1533
  #, fuzzy, gcc-internal-format
+#| msgid "argument of %qE attribute is not a string constant"
  msgid "argument to %qE attribute is not intstack"
-msgstr "аргумент атрибута %qs не является строковой константой"
+msgstr "аргумент %qE атрибута не строковая константа"
  
  #: config/mips/mips.c:7234
  #, gcc-internal-format
  msgid "cannot handle inconsistent calls to %qs"
-msgstr "ошибка при обработке некорректного вызова %qs"
+msgstr "ошибка при обработке некорректных вызовов %qs"
  
  #: config/mips/mips.c:10341
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "the %<interrupt%> attribute requires a MIPS32r2 processor"
  msgid "the %<interrupt%> attribute requires a MIPS32r2 processor or greater"
-msgstr ""
+msgstr "атрибут %<interrupt%> допустим только для процессора MIPS32r2"
  
  #: config/mips/mips.c:10343
  #, gcc-internal-format
  msgid "interrupt handlers cannot be MIPS16 functions"
-msgstr ""
+msgstr "обработчики прерываний не могут быть функциями MIPS16"
  
  #: config/mips/mips.c:11334
  #, gcc-internal-format
@@ -30685,34 +32093,34 @@ msgstr ""
  #: config/mips/mips.c:15095 config/nds32/nds32-intrinsic.c:59
  #: config/nds32/nds32-intrinsic.c:87 config/nds32/nds32-intrinsic.c:117
  #: config/nios2/nios2.c:3135
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid argument to built-in function"
-msgstr "некорректный аргумент внутренней функции"
+msgstr "некорректный аргумент встроенной функции"
  
  #: config/mips/mips.c:15296
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "built-in function %qE not supported for MIPS16"
-msgstr "ms-bitfields не поддерживается для objc"
+msgstr "встроенная функция %qE не поддерживается для MIPS16"
  
  #: config/mips/mips.c:15892
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs does not support MIPS16 code"
-msgstr "%s не поддерживает %s"
+msgstr "%qs не поддерживает код MIPS16"
  
  #: config/mips/mips.c:17588
  #, gcc-internal-format
  msgid "MIPS16 PIC for ABIs other than o32 and o64"
-msgstr ""
+msgstr "MIPS16 PIC для ABI, отличного от o32 и o64"
  
  #: config/mips/mips.c:17591
  #, gcc-internal-format
  msgid "MIPS16 -mxgot code"
-msgstr ""
+msgstr "код MIPS16 -mxgot"
  
  #: config/mips/mips.c:17594
  #, gcc-internal-format
  msgid "hard-float MIPS16 code for ABIs other than o32 and o64"
-msgstr ""
+msgstr "аппаратная реализация плавающей арифметики для MIPS16 и ABI, отличного от o32 и o64"
  
  #: config/mips/mips.c:17769 config/mips/mips.c:17851 config/mips/mips.c:17853
  #: config/mips/mips.c:17881 config/mips/mips.c:17891 config/mips/mips.c:17990
@@ -30722,64 +32130,68 @@ msgid "unsupported combination: %s"
  msgstr "неподдерживаемая комбинация: %s"
  
  #: config/mips/mips.c:17803
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<-%s%> conflicts with the other architecture options, which specify a %s processor"
-msgstr "-%s конфликтует с другими ключами, которые задают процессор %s"
+msgstr "%<-%s%> конфликтует с другими ключами, которые задают процессор %s"
  
  #: config/mips/mips.c:17813
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<-march=%s%> is not compatible with the selected ABI"
-msgstr "ключ -march=%s несовместим с выбранным ABI"
+msgstr "ключ %<-march=%s%> несовместим с выбранным ABI"
  
  #: config/mips/mips.c:17828
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<-mgp64%> used with a 32-bit processor"
-msgstr "ключ -mgp64 задан для 32-битного процессора"
+msgstr "ключ %<-mgp64%> задан для 32-битного процессора"
  
  #: config/mips/mips.c:17830
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<-mgp32%> used with a 64-bit ABI"
-msgstr "ключ -mgp32 задан для 64-битного процессора"
+msgstr "ключ %<-mgp32%> задан для 64-битного процессора"
  
  #: config/mips/mips.c:17832
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<-mgp64%> used with a 32-bit ABI"
-msgstr "ключ -mgp64 задан для 32-битного ABI"
+msgstr "ключ %<-mgp64%> задан для 32-битного ABI"
  
  #: config/mips/mips.c:17848
  #, fuzzy, gcc-internal-format
+#| msgid "the %qs architecture does not support the synci instruction"
  msgid "the %qs architecture does not support %<-mfp32%>"
-msgstr "целевой процессор не поддерживает команды THUMB"
+msgstr "архитектура %qs не поддерживает команду synci"
  
  #: config/mips/mips.c:17857
  #, gcc-internal-format
  msgid "%<-mgp32%> and %<-mfp64%> can only be combined if the target supports the mfhc1 and mthc1 instructions"
-msgstr ""
+msgstr "%<-mgp32%> и %<-mfp64%> могут сочетаться только если процессор поддерживает команды mfhc1 и mthc1"
  
  #: config/mips/mips.c:17860
  #, gcc-internal-format
  msgid "%<-mgp32%> and %<-mfp64%> can only be combined when using the o32 ABI"
-msgstr ""
+msgstr "%<-mgp32%> и %<-mfp64%> могут сочетаться только при использовании ABI o32"
  
  #: config/mips/mips.c:17879
  #, fuzzy, gcc-internal-format
+#| msgid "%<-mgp32%> and %<-mfp64%> can only be combined when using the o32 ABI"
  msgid "%<-mfpxx%> can only be used with the o32 ABI"
-msgstr "ключ -mgp64 задан для 32-битного ABI"
+msgstr "%<-mgp32%> и %<-mfp64%> могут сочетаться только при использовании ABI o32"
  
  #: config/mips/mips.c:17883
  #, fuzzy, gcc-internal-format
+#| msgid "%<-mips3d%> requires %<-mpaired-single%>"
  msgid "%<-march=%s%> requires %<-mfp32%>"
-msgstr "для -mips3d требуется -mpaired-single"
+msgstr "для %<-mips3d%> требуется %<-mpaired-single%>"
  
  #: config/mips/mips.c:17885
  #, fuzzy, gcc-internal-format
+#| msgid "%<-mips3d%> requires %<-mpaired-single%>"
  msgid "%<-mfpxx%> requires %<-mlra%>"
-msgstr "для -mips3d требуется -mpaired-single"
+msgstr "для %<-mips3d%> требуется %<-mpaired-single%>"
  
  #: config/mips/mips.c:17901 config/mips/mips.c:17903 config/mips/mips.c:17916
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs is incompatible with %qs"
-msgstr "ключ -march=%s несовместим с выбранным ABI"
+msgstr "%qs несовместим с %qs"
  
  #. We have traditionally allowed non-abicalls code to use
  #. an LP64 form of o64.  However, it would take a bit more
@@ -30787,24 +32199,26 @@ msgstr "ключ -march=%s несовместим с выбранным ABI"
  #. and 64-bit pointers, so we treat the abicalls case as
  #. an error.
  #: config/mips/mips.c:17910
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the combination of %qs and %qs is incompatible with %qs"
-msgstr "ключ -march=%s несовместим с выбранным ABI"
+msgstr "сочетание %qs and %qs несовместимо с %qs"
  
  #: config/mips/mips.c:17956
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the %qs architecture does not support branch-likely instructions"
-msgstr "целевой процессор не поддерживает команды THUMB"
+msgstr "архитектура %qs не поддерживает команды branch-likely"
  
  #: config/mips/mips.c:17971
  #, fuzzy, gcc-internal-format
+#| msgid "the %qs architecture does not support the synci instruction"
  msgid "the %qs architecture does not support madd or msub instructions"
-msgstr "целевой процессор не поддерживает команды THUMB"
+msgstr "архитектура %qs не поддерживает команду synci"
  
  #: config/mips/mips.c:17985
  #, fuzzy, gcc-internal-format
+#| msgid "the %qs architecture does not support paired-single instructions"
  msgid "the %qs architecture does not support odd single-precision registers"
-msgstr "целевой процессор не поддерживает команды THUMB"
+msgstr "архитектура %qs не поддерживает команды формата PS"
  
  #: config/mips/mips.c:17998 config/mips/mips.c:18004
  #, fuzzy, gcc-internal-format
@@ -30820,68 +32234,73 @@ msgstr "неподдерживаемая комбинация: %s"
  
  #: config/mips/mips.c:18028
  #, fuzzy, gcc-internal-format
+#| msgid "Generate position-independent code if possible (large mode)"
  msgid "cannot generate position-independent code for %qs"
  msgstr "Генерировать позиционно-независимый код, если возможно (режим large)"
  
  #: config/mips/mips.c:18031
  #, fuzzy, gcc-internal-format
+#| msgid "Disable position-independent code (PIC) for use in OS kernel code"
  msgid "position-independent code requires %qs"
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾-Ð½ÐµÐ·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ñ\8bÐ¹ ÐºÐ¾Ð´, ÐµÑ\81Ð»Ð¸ Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ (Ñ\80ÐµÐ¶Ð¸Ð¼ large)"
+msgstr "Ð\92Ñ\8bÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾-Ð½ÐµÐ·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ñ\8bÐ¹ ÐºÐ¾Ð´ (PIC) Ð´Ð»Ñ\8f Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð² ÐºÐ¾Ð´Ðµ Ñ\8fÐ´Ñ\80Ð° OS"
  
  #: config/mips/mips.c:18064
  #, gcc-internal-format
  msgid "%<-mno-gpopt%> needs %<-mexplicit-relocs%>"
-msgstr ""
+msgstr "для %<-mno-gpopt%> требуется %<-mexplicit-relocs%>"
  
  #: config/mips/mips.c:18072 config/mips/mips.c:18075
  #, gcc-internal-format
  msgid "cannot use small-data accesses for %qs"
-msgstr ""
+msgstr "невозможно использовать метод доступа к малым объектам данных для %qs"
  
  #: config/mips/mips.c:18090
  #, fuzzy, gcc-internal-format
+#| msgid "the %qs architecture does not support paired-single instructions"
  msgid "the %qs architecture does not support %<-m%s=legacy%>"
-msgstr "целевой процессор не поддерживает команды THUMB"
+msgstr "архитектура %qs не поддерживает команды формата PS"
  
  #: config/mips/mips.c:18097
  #, fuzzy, gcc-internal-format
+#| msgid "the %qs architecture does not support the synci instruction"
  msgid "the %qs architecture does not support %<-m%s=2008%>"
-msgstr "целевой процессор не поддерживает команды THUMB"
+msgstr "архитектура %qs не поддерживает команду synci"
  
  #: config/mips/mips.c:18115
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<-mips3d%> requires %<-mpaired-single%>"
-msgstr "для -mips3d требуется -mpaired-single"
+msgstr "для %<-mips3d%> требуется %<-mpaired-single%>"
  
  #: config/mips/mips.c:18125
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs must be used with %qs"
-msgstr "-frepo следует использовать вместе с -c"
+msgstr "%qs следует использовать вместе с %qs"
  
  #: config/mips/mips.c:18137
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the %qs architecture does not support paired-single instructions"
-msgstr "целевой процессор не поддерживает команды THUMB"
+msgstr "архитектура %qs не поддерживает команды формата PS"
  
  #: config/mips/mips.c:18146
  #, gcc-internal-format
  msgid "%qs requires a target that provides the %qs instruction"
-msgstr ""
+msgstr "%qs поддерживается только для процессоров, имеющих команду %qs"
  
  #: config/mips/mips.c:18157
  #, fuzzy, gcc-internal-format
+#| msgid "the %qs architecture does not support the synci instruction"
  msgid "the %qs architecture does not support DSP instructions"
-msgstr "целевой процессор не поддерживает команды THUMB"
+msgstr "архитектура %qs не поддерживает команду synci"
  
  #: config/mips/mips.c:18259
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs requires branch-likely instructions"
-msgstr "целевой процессор не поддерживает команды THUMB"
+msgstr "%qs поддерживается только для процессоров, имеющих команды branch likely"
  
  #: config/mips/mips.c:18263
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the %qs architecture does not support the synci instruction"
-msgstr "целевой процессор не поддерживает команды THUMB"
+msgstr "архитектура %qs не поддерживает команду synci"
  
  #: config/mips/mips.c:19075
  #, gcc-internal-format
@@ -30942,7 +32361,7 @@ msgstr "Внутреннее сообщение MMIX: %s не является 
  #: config/mn10300/mn10300.c:102
  #, gcc-internal-format
  msgid "-mtune= expects mn10300, am33, am33-2, or am34"
-msgstr ""
+msgstr "-mtune= ожидает mn10300, am33, am33-2 или am34"
  
  #: config/msp430/driver-msp430.c:646
  #, gcc-internal-format, gfc-internal-format
@@ -31012,8 +32431,9 @@ msgstr ""
  
  #: config/msp430/msp430.c:831
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "unrecognized register name %qs"
  msgid "Unrecognised MCU name '%s'."
-msgstr "некорректное имя регистра \"%s\""
+msgstr "некорректное имя регистра %qs"
  
  #: config/msp430/msp430.c:840
  #, gcc-internal-format
@@ -31032,23 +32452,27 @@ msgstr ""
  
  #: config/msp430/msp430.c:1848
  #, fuzzy, gcc-internal-format
+#| msgid "invalid argument of %qE attribute"
  msgid "unrecognised interrupt vector argument of %qE attribute"
-msgstr "некорректный аргумент атрибута %qs"
+msgstr "некорректный аргумент атрибута %qE"
  
  #: config/msp430/msp430.c:1857
  #, fuzzy, gcc-internal-format
+#| msgid "argument %d of %qE must be in the range %d...%d"
  msgid "numeric argument of %qE attribute must be in range 0..63"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "аргумент %d от %qE должен быть в диапазоне %d...%d"
  
  #: config/msp430/msp430.c:1863
  #, fuzzy, gcc-internal-format
+#| msgid "argument of %qE attribute is not a string constant"
  msgid "argument of %qE attribute is not a string constant or number"
-msgstr "аргумент атрибута %qs не является строковой константой"
+msgstr "аргумент %qE атрибута не строковая константа"
  
  #: config/msp430/msp430.c:2473
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute allows only an integer constant argument"
  msgid "__delay_cycles() only takes constant arguments"
-msgstr "аргументом атрибута %qs должна быть целая константа"
+msgstr "аргументом атрибута %qE должна быть целая константа"
  
  #: config/msp430/msp430.c:2483
  #, gcc-internal-format
@@ -31067,14 +32491,15 @@ msgstr ""
  
  #: config/msp430/msp430.c:2585 config/rx/rx.c:2634 config/xtensa/xtensa.c:3346
  #: config/xtensa/xtensa.c:3372
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "bad builtin code"
-msgstr "некорректный встроенный fcode"
+msgstr "некорректный встроенный code"
  
  #: config/nds32/nds32-isr.c:337
  #, fuzzy, gcc-internal-format
+#| msgid "too few arguments to function %q#D"
  msgid "multiple save reg attributes to function %qD"
-msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð°Ð»Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE"
+msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð°Ð»Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q#D"
  
  #: config/nds32/nds32-isr.c:348
  #, fuzzy, gcc-internal-format
@@ -31084,8 +32509,9 @@ msgstr "задано несколько атрибутов типа функци
  
  #: config/nds32/nds32-isr.c:360
  #, fuzzy, gcc-internal-format
+#| msgid "multiple interrupt attributes not allowed"
  msgid "multiple interrupt attributes to function %qD"
-msgstr "Ð·Ð°Ð´Ð°Ð½Ð¾ Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ñ\82Ð¸Ð¿Ð° Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ð¿Ñ\80ÐµÑ\80Ñ\8bÐ²Ð°Ð½Ð¸Ð¹ Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f"
  
  #. Trampoline is not supported on reduced-set registers yet.
  #: config/nds32/nds32.c:1741 config/nds32/nds32.c:1795
@@ -31094,8 +32520,9 @@ msgstr "задано несколько атрибутов типа функци
  #: config/nds32/nds32.c:2435 config/nds32/nds32.c:2441
  #: config/nds32/nds32.c:2473
  #, fuzzy, gcc-internal-format
+#| msgid "nested functions not supported on this target"
  msgid "a nested function is not supported for reduced registers"
-msgstr "Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ñ\8bÐµ Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b не поддерживаются для этой платформы"
+msgstr "Ð²Ð»Ð¾Ð¶ÐµÐ½Ð½Ñ\8bÐµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ не поддерживаются для этой платформы"
  
  #. The enum index value for array size is out of range.
  #: config/nds32/nds32.c:2276
@@ -31106,8 +32533,9 @@ msgstr "некорректный регистр в инструкции"
  
  #: config/nds32/nds32.c:2581
  #, fuzzy, gcc-internal-format
+#| msgid "invalid type for iteration variable %qE"
  msgid "invalid id value for interrupt/exception attribute"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾ Ð·Ð°Ð´Ð°Ð½ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qE"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð¸Ñ\82ÐµÑ\80Ð°Ñ\86Ð¸Ð¾Ð½Ð½Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qE"
  
  #: config/nds32/nds32.c:2609
  #, fuzzy, gcc-internal-format
@@ -31139,9 +32567,10 @@ msgid "Unknown form for stack limit expression"
  msgstr ""
  
  #: config/nios2/nios2.c:1167
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "target attribute or pragma changes double precision floating point"
  msgid "switch %<-mcustom-%s%> is required for double precision floating point"
-msgstr ""
+msgstr "target attribute или pragma изменяет плавающие двойной точности"
  
  #: config/nios2/nios2.c:1180
  #, gcc-internal-format
@@ -31175,18 +32604,21 @@ msgstr ""
  
  #: config/nios2/nios2.c:1347
  #, fuzzy, gcc-internal-format
+#| msgid "Disable position-independent code (PIC) for use in OS kernel code"
  msgid "position-independent code requires the Linux ABI"
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾-Ð½ÐµÐ·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ñ\8bÐ¹ ÐºÐ¾Ð´, ÐµÑ\81Ð»Ð¸ Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ (Ñ\80ÐµÐ¶Ð¸Ð¼ large)"
+msgstr "Ð\92Ñ\8bÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾-Ð½ÐµÐ·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ñ\8bÐ¹ ÐºÐ¾Ð´ (PIC) Ð´Ð»Ñ\8f Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð² ÐºÐ¾Ð´Ðµ Ñ\8fÐ´Ñ\80Ð° OS"
  
  #: config/nios2/nios2.c:1350
  #, gcc-internal-format
  msgid "PIC support for -fstack-limit-symbol"
  msgstr ""
  
+#
  #: config/nios2/nios2.c:1376
  #, fuzzy, gcc-internal-format
+#| msgid "generation of Branch Likely instructions enabled, but not supported by architecture"
  msgid "BMX instructions are only supported with R2 architecture"
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Branch Likely, Ð²Ð¾Ð¿Ñ\80ÐµÐºÐ¸ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f Ñ\83ÐºÐ°Ð·Ð°Ð½Ð½Ð¾Ð¹ Ð°Ñ\80Ñ\85Ð¸Ñ\82ÐµÐºÑ\82Ñ\83Ñ\80Ñ\8b"
+msgstr "Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8f Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ Branch Likely Ð²ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð°, Ð½Ð¾ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f Ð°Ñ\80Ñ\85Ð¸Ñ\82ÐµÐºÑ\82Ñ\83Ñ\80Ð¾Ð¹"
  
  #: config/nios2/nios2.c:1378
  #, fuzzy, gcc-internal-format
@@ -31212,8 +32644,9 @@ msgstr ""
  
  #: config/nios2/nios2.c:3373
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "invalid argument to built-in function"
  msgid "invalid argument to built-in function %s"
-msgstr "некорректный аргумент внутренней функции"
+msgstr "некорректный аргумент встроенной функции"
  
  #: config/nios2/nios2.c:3432
  #, gcc-internal-format, gfc-internal-format
@@ -31238,13 +32671,15 @@ msgstr ""
  
  #: config/nios2/nios2.c:3545
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Builtin function %s requires the -mvsx option"
  msgid "Builtin function %s requires Nios II R%d"
-msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð¾Ð¿Ñ\86Ð¸Ñ\8e -mvsx"
  
  #: config/nios2/nios2.c:3627
  #, fuzzy, gcc-internal-format
+#| msgid "switch -mcpu=%s conflicts with -march=%s switch"
  msgid "switch %<-mcustom-%s%> conflicts with switch %<-mcustom-%s%>"
-msgstr "ключ -mcpu=%s несовместим с ключом -march="
+msgstr "ключ -mcpu=%s несовместим с ключом -march=%s"
  
  #: config/nios2/nios2.c:3633 config/nios2/nios2.c:3643
  #, gcc-internal-format
@@ -31263,8 +32698,9 @@ msgstr ""
  
  #: config/nios2/nios2.c:3783
  #, fuzzy, gcc-internal-format
+#| msgid "%s only accepts 2 arguments"
  msgid "%<no-custom-%s%> does not accept arguments"
-msgstr "%q+D может быть функцией с двумя аргументами, либо функцией без аргументов"
+msgstr "%s принимает только 2 аргумента"
  
  #: config/nios2/nios2.c:3798
  #, gcc-internal-format
@@ -31301,6 +32737,7 @@ msgstr "должна быть установлена COLLECT_LTO_WRAPPER"
  
  #: config/nvptx/mkoffload.c:545
  #, fuzzy, gcc-internal-format
+#| msgid "%s:cannot open graph file\n"
  msgid "cannot open intermediate ptx file"
  msgstr "%s:ошибка открытия графического файла\n"
  
@@ -31326,14 +32763,14 @@ msgid "using num_workers (%d), ignoring %d"
  msgstr ""
  
  #: config/pa/pa.c:501
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "PIC code generation is not supported in the portable runtime model"
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8f PIC Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f Ð² Ð¿Ð¾Ñ\80Ñ\82Ð¸Ñ\80Ñ\83ÐµÐ¼Ð¾Ð¹ Ð¼Ð¾Ð´ÐµÐ»Ð¸ Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð¸ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8f\n"
+msgstr "Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾-Ð½ÐµÐ·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð° Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f Ð² Ð¿ÐµÑ\80ÐµÐ½Ð¾Ñ\81Ð¸Ð¼Ð¾Ð¹ Ð¼Ð¾Ð´ÐµÐ»Ð¸ Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð¸ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8f"
  
  #: config/pa/pa.c:506
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "PIC code generation is not compatible with fast indirect calls"
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8f PIC Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ð° Ñ\81 Ð±Ñ\8bÑ\81Ñ\82Ñ\80Ñ\8bÐ¼Ð¸ ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ñ\8bÐ¼Ð¸ Ð²Ñ\8bÐ·Ð¾Ð²Ð°Ð¼Ð¸\n"
+msgstr "Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾-Ð½ÐµÐ·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ð¾Ð³Ð¾ ÐºÐ¾Ð´Ð° Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ð° Ñ\81 Ð±Ñ\8bÑ\81Ñ\82Ñ\80Ñ\8bÐ¼Ð¸ ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ñ\8bÐ¼Ð¸ Ð²Ñ\8bÐ·Ð¾Ð²Ð°Ð¼Ð¸"
  
  #: config/pa/pa.c:511
  #, gcc-internal-format
@@ -31348,62 +32785,66 @@ msgstr "ключ -g игнорируется"
  #: config/pa/pa.c:8699
  #, gcc-internal-format, gfc-internal-format
  msgid "alignment (%u) for %s exceeds maximum alignment for global common data.  Using %u"
-msgstr ""
+msgstr "выравнивание (%u) для %s превышает максимальное выравнивание для глобальных общих данных. Используется %u"
  
  #. Address spaces are currently only supported by C.
  #: config/rl78/rl78.c:345
  #, fuzzy, gcc-internal-format
+#| msgid "-mmulticore can only be used with BF561"
  msgid "-mes0 can only be used with C"
-msgstr "-mn без -mh или -ms"
+msgstr "-mmulticore можно использовать только с BF561"
  
  #: config/rl78/rl78.c:360
  #, fuzzy, gcc-internal-format
-#| msgid "-frepo must be used with -c"
+#| msgid "-mmulticore can only be used with BF561"
  msgid "-mmul=g13 cannot be used with -mcpu=g10"
-msgstr "-frepo следует использовать вместе с -c"
+msgstr "-mmulticore можно использовать только с BF561"
  
  #: config/rl78/rl78.c:361
  #, fuzzy, gcc-internal-format
-#| msgid "-frepo must be used with -c"
+#| msgid "-mmulticore can only be used with BF561"
  msgid "-mmul=g14 cannot be used with -mcpu=g10"
-msgstr "-frepo следует использовать вместе с -c"
+msgstr "-mmulticore можно использовать только с BF561"
  
  #. The S2 core does not have mul/div instructions.
  #: config/rl78/rl78.c:372
  #, fuzzy, gcc-internal-format
-#| msgid "-frepo must be used with -c"
+#| msgid "-mmulticore can only be used with BF561"
  msgid "-mmul=g14 cannot be used with -mcpu=g13"
-msgstr "-frepo следует использовать вместе с -c"
+msgstr "-mmulticore можно использовать только с BF561"
  
  #. The G14 core does not have the hardware multiply peripheral used by the
  #. G13 core, hence you cannot use G13 multipliy routines on G14 hardware.
  #: config/rl78/rl78.c:384
  #, fuzzy, gcc-internal-format
-#| msgid "-frepo must be used with -c"
+#| msgid "-mmulticore can only be used with BF561"
  msgid "-mmul=g13 cannot be used with -mcpu=g14"
-msgstr "-frepo следует использовать вместе с -c"
+msgstr "-mmulticore можно использовать только с BF561"
  
  #: config/rl78/rl78.c:779
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute only applies to functions"
  msgid "naked attribute only applies to functions"
-msgstr "атрибут %qs допустим только для функций"
+msgstr "%qE атрибут применим только к функциям"
  
  #: config/rl78/rl78.c:803
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute only applies to functions"
  msgid "%qE attribute doesn't apply to functions"
-msgstr "атрибут %qs допустим только для функций"
+msgstr "%qE атрибут применим только к функциям"
  
  #. This is unpredictable, as we're truncating off usable address
  #. bits.
  #: config/rl78/rl78.c:1142
  #, fuzzy, gcc-internal-format
+#| msgid "converting %<false%> to pointer type %qT"
  msgid "converting far pointer to near pointer"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð´Ð»Ñ\8f Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° `%P' Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qD"
+msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ %<false%> Ð² Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT"
  
  #: config/rs6000/host-darwin.c:59
  #, gcc-internal-format
  msgid "Segmentation Fault (code)"
-msgstr "Ошибка сегментации"
+msgstr "Ошибка сегментации (код)"
  
  #: config/rs6000/host-darwin.c:129
  #, gcc-internal-format
@@ -31432,7 +32873,7 @@ msgstr "При установке обработчика сигналов: %m"
  #: config/rs6000/rs6000-c.c:48
  #, gcc-internal-format
  msgid "ignoring malformed #pragma longcall"
-msgstr "некорректная #pragma longcall проигнориована"
+msgstr "некорректная #pragma longcall проигнорирована"
  
  #: config/rs6000/rs6000-c.c:61
  #, gcc-internal-format
@@ -31470,89 +32911,90 @@ msgid "vec_lvsr is deprecated for little endian; use assignment for unaligned lo
  msgstr ""
  
  #: config/rs6000/rs6000-c.c:4531
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s only accepts %d arguments"
-msgstr "несовпадающие аргументы"
+msgstr "%s принимает только %d аргументов"
  
  #: config/rs6000/rs6000-c.c:4536
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s only accepts 1 argument"
-msgstr "%q+D может быть функцией с двумя аргументами, либо функцией без аргументов"
+msgstr "%s принимает только 1 аргумент"
  
  #: config/rs6000/rs6000-c.c:4541
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s only accepts 2 arguments"
-msgstr "%q+D может быть функцией с двумя аргументами, либо функцией без аргументов"
+msgstr "%s принимает только 2 аргумента"
  
  #: config/rs6000/rs6000-c.c:4607
  #, gcc-internal-format
  msgid "vec_extract only accepts 2 arguments"
-msgstr ""
+msgstr "vec_extract принимает только 2 аргумента"
  
  #: config/rs6000/rs6000-c.c:4709
  #, gcc-internal-format
  msgid "vec_insert only accepts 3 arguments"
-msgstr ""
+msgstr "vec_insert принимает только 3 аргумента"
  
  #: config/rs6000/rs6000-c.c:4841
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "passing arg %d of %qE discards qualifiers frompointer target type"
-msgstr "приведение от %qT к %qT отменяет квалификаторы указуемого типа"
+msgstr "передача arg %d от %qE отменяет квалификаторы frompointer указуемого типа"
  
  #: config/rs6000/rs6000-c.c:4885
  #, gcc-internal-format
  msgid "invalid parameter combination for AltiVec intrinsic"
-msgstr "недопустимая комбинация параметров для AltiVec intrinsic"
+msgstr "недопустимая комбинация параметров для AltiVec встроенной функции"
  
  #: config/rs6000/rs6000.c:3465
  #, gcc-internal-format
  msgid "-mrecip requires -ffinite-math or -ffast-math"
-msgstr ""
+msgstr "-mrecip требует -ffinite-math или -ffast-math"
  
  #: config/rs6000/rs6000.c:3467
  #, gcc-internal-format
  msgid "-mrecip requires -fno-trapping-math or -ffast-math"
-msgstr ""
+msgstr "-mrecip требует -fno-trapping-math или -ffast-math"
  
  #: config/rs6000/rs6000.c:3469
  #, gcc-internal-format
  msgid "-mrecip requires -freciprocal-math or -ffast-math"
-msgstr ""
+msgstr "-mrecip требует -freciprocal-math или -ffast-math"
  
  #: config/rs6000/rs6000.c:3569
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-m64 requires PowerPC64 architecture, enabling"
-msgstr "Ð\9aÐ»Ñ\8eÑ\87 -maix64 Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð°Ñ\80Ñ\85Ð¸Ñ\82ÐµÐºÑ\82Ñ\83Ñ\80Ñ\8b PowerPC64"
+msgstr "ÐºÐ»Ñ\8eÑ\87 -m64 Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð°Ñ\80Ñ\85Ð¸Ñ\82ÐµÐºÑ\82Ñ\83Ñ\80Ñ\8b PowerPC64, Ð²ÐºÐ»Ñ\8eÑ\87Ð°ÐµÑ\82Ñ\81Ñ\8f"
  
  #: config/rs6000/rs6000.c:3682
  #, gcc-internal-format
  msgid "-malign-power is not supported for 64-bit Darwin; it is incompatible with the installed C and C++ libraries"
-msgstr ""
+msgstr "ключ -malign-power не поддерживается для 64-битного Darwin; он несовместим с установленными библиотеками C и C++"
  
  #: config/rs6000/rs6000.c:3844
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "not configured for SPE ABI"
-msgstr "Ð´Ð°Ð½Ð½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\84Ð¸Ð³Ñ\83Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 ABI: '%s'"
+msgstr "Ð½Ðµ Ñ\81ÐºÐ¾Ð½Ñ\84Ð¸Ð³Ñ\83Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¾ Ð´Ð»Ñ\8f SPE ABI"
  
  #: config/rs6000/rs6000.c:3849
  #, fuzzy, gcc-internal-format
+#| msgid "Do not use PowerPC instruction set"
  msgid "not configured for SPE instruction set"
  msgstr "Не использовать систему команд PowerPC"
  
  #: config/rs6000/rs6000.c:3855
  #, gcc-internal-format
  msgid "target attribute or pragma changes SPE ABI"
-msgstr ""
+msgstr "target attribute или pragma изменяет SPE ABI"
  
  #: config/rs6000/rs6000.c:3862
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "AltiVec not supported in this target"
-msgstr "проверка выхода за границу стека не поддерживается для этой платформы"
+msgstr "AltiVec не поддерживается на этой целевой платформе"
  
  #: config/rs6000/rs6000.c:3864 config/rs6000/rs6000.c:3869
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "SPE not supported in this target"
-msgstr "проверка выхода за границу стека не поддерживается для этой платформы"
+msgstr "SPE не поддерживается на этой целевой платформе"
  
  #: config/rs6000/rs6000.c:3897
  #, gcc-internal-format
@@ -31594,8 +33036,9 @@ msgstr "ключ --resource требует задания -o"
  
  #: config/rs6000/rs6000.c:4034
  #, fuzzy, gcc-internal-format
+#| msgid "-msingle-float option equivalent to -mhard-float"
  msgid "-mhard-dfp requires -mhard-float"
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\83Ñ\8e Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸"
+msgstr "Ð¾Ð¿Ñ\86Ð¸Ñ\8f -msingle-float Ñ\8dÐºÐ²Ð¸Ð²Ð°Ð»ÐµÐ½Ñ\82Ð½Ð° -mhard-float"
  
  #: config/rs6000/rs6000.c:4075
  #, fuzzy, gcc-internal-format
@@ -31671,163 +33114,172 @@ msgstr ""
  #: config/rs6000/rs6000.c:4346
  #, gcc-internal-format, gfc-internal-format
  msgid "unknown vectorization library ABI type (%s) for -mveclibabi= switch"
-msgstr ""
+msgstr "неизвестный тип (%s) ABI библиотеки векторизации для ключа -mveclibabi="
  
  #: config/rs6000/rs6000.c:4358
  #, gcc-internal-format
  msgid "target attribute or pragma changes long double size"
-msgstr ""
+msgstr "target attribute или pragma изменяет размер long double"
  
  #: config/rs6000/rs6000.c:4381 config/rs6000/rs6000.c:4396
  #, gcc-internal-format
  msgid "target attribute or pragma changes AltiVec ABI"
-msgstr ""
+msgstr "target attribute или pragma изменяет AltiVec ABI"
  
  #: config/rs6000/rs6000.c:4409
  #, gcc-internal-format
  msgid "target attribute or pragma changes darwin64 ABI"
-msgstr ""
+msgstr "target attribute или pragma изменяет darwin64 ABI"
  
  #: config/rs6000/rs6000.c:4475
  #, gcc-internal-format
  msgid "target attribute or pragma changes single precision floating point"
-msgstr ""
+msgstr "target attribute или pragma изменяет плавающие одинарной точности"
  
  #: config/rs6000/rs6000.c:4478
  #, gcc-internal-format
  msgid "target attribute or pragma changes double precision floating point"
-msgstr ""
+msgstr "target attribute или pragma изменяет плавающие двойной точности"
  
  #: config/rs6000/rs6000.c:6738
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "The ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
  msgid "the layout of aggregates containing vectors with %d-byte alignment has changed in GCC 5"
-msgstr ""
+msgstr "ABI для передачи параметров с %d-байтным выравниванием изменен в GCC 4.6"
  
  #: config/rs6000/rs6000.c:9844
  #, gcc-internal-format
  msgid "GCC vector returned by reference: non-standard ABI extension with no compatibility guarantee"
-msgstr ""
+msgstr "GCC вектор, возвращенный по ссылке: нестандартное расширение ABI без гарантий совместимости"
  
  #: config/rs6000/rs6000.c:9997
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot return value in vector register because altivec instructions are disabled, use -maltivec to enable them"
-msgstr "Ð\92Ð¾Ð·Ð²Ñ\80Ð°Ñ\82 Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ð² Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ð¾Ð¼ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ðµ Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶ÐµÐ½, Ð¿Ð¾Ñ\81ÐºÐ¾Ð»Ñ\8cÐºÑ\83 Ð½Ð°Ð±Ð¾Ñ\80 ÐºÐ¾Ð¼Ð°Ð½Ð´ altivec Ð½Ðµ Ð·Ð°Ð´Ð°Ð½; Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -maltivec Ð´Ð»Ñ\8f ÐµÐ³Ð¾ включения"
+msgstr "Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82 Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ð² Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ð¾Ð¼ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ðµ Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶ÐµÐ½, Ð¿Ð¾Ñ\81ÐºÐ¾Ð»Ñ\8cÐºÑ\83 Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ altivec Ð¾Ñ\82ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ñ\8b, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -maltivec Ð´Ð»Ñ\8f Ð¸Ñ\85 включения"
  
  #: config/rs6000/rs6000.c:10167
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "The ABI for passing parameters with %d-byte alignment has changed in GCC 4.6"
  msgid "the ABI of passing aggregates with %d-byte alignment has changed in GCC 5"
-msgstr ""
+msgstr "ABI для передачи параметров с %d-байтным выравниванием изменен в GCC 4.6"
  
  #: config/rs6000/rs6000.c:10429
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot pass argument in vector register because altivec instructions are disabled, use -maltivec to enable them"
-msgstr "Ð\9fÐµÑ\80ÐµÐ´Ð°Ñ\87Ð° Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° Ð² Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ð¾Ð¼ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ðµ Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð°, Ð¿Ð¾Ñ\81ÐºÐ¾Ð»Ñ\8cÐºÑ\83 Ð½Ð°Ð±Ð¾Ñ\80 ÐºÐ¾Ð¼Ð°Ð½Ð´ altivec Ð½Ðµ Ð·Ð°Ð´Ð°Ð½; Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -maltivec Ð´Ð»Ñ\8f ÐµÐ³Ð¾ включения"
+msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ñ\87Ð° Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° Ð² Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ð¾Ð¼ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ðµ Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð°, Ð¿Ð¾Ñ\81ÐºÐ¾Ð»Ñ\8cÐºÑ\83 Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ altivec Ð¾Ñ\82ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ñ\8b, Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -maltivec Ð´Ð»Ñ\8f Ð¸Ñ\85 включения"
  
  #: config/rs6000/rs6000.c:11289
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "the ABI of passing structure with complex float member has changed in GCC 4.4"
  msgid "the ABI of passing homogeneous float aggregates has changed in GCC 5"
-msgstr ""
+msgstr "ABI для передачи структуры с элементом complex float изменен в GCC 4.4"
  
  #: config/rs6000/rs6000.c:11464
  #, gcc-internal-format
  msgid "GCC vector passed by reference: non-standard ABI extension with no compatibility guarantee"
-msgstr ""
+msgstr "GCC вектор, переданный по ссылке: нестандартное расширение ABI без гарантий совместимости"
  
  #: config/rs6000/rs6000.c:12252
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "internal error: builtin function %s already processed"
-msgstr "Ð¡Ñ\87Ð¸Ñ\82Ð°Ñ\82Ñ\8c, Ñ\87Ñ\82Ð¾ Ð²Ñ\85Ð¾Ð´Ð½Ð¾Ð¹ Ñ\84Ð°Ð¹Ð» Ñ\83Ð¶Ðµ Ð¿Ñ\80ÐµÐ¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
+msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ°: Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ñ\83Ð¶Ðµ Ð¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82Ð°Ð½Ð°"
  
  #: config/rs6000/rs6000.c:12694
  #, fuzzy, gcc-internal-format
  #| msgid "argument 1 must be a 5-bit signed literal"
  msgid "argument 1 must be an 8-bit field value"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 1 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ð¾м"
  
  #: config/rs6000/rs6000.c:12741
  #, gcc-internal-format
  msgid "argument 1 must be a 5-bit signed literal"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 1 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ð¾м"
  
  #: config/rs6000/rs6000.c:12844 config/rs6000/rs6000.c:14430
  #, gcc-internal-format
  msgid "argument 2 must be a 5-bit unsigned literal"
-msgstr "Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 2 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ð¾м"
  
  #: config/rs6000/rs6000.c:12883
  #, gcc-internal-format
  msgid "argument 1 of __builtin_altivec_predicate must be a constant"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 __builtin_altivec_predicate должен быть константой"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 1 __builtin_altivec_predicate должен быть константой"
  
  #: config/rs6000/rs6000.c:12935
  #, gcc-internal-format
  msgid "argument 1 of __builtin_altivec_predicate is out of range"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 __builtin_altivec_predicate вне диапазона"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 1 __builtin_altivec_predicate вне диапазона"
  
  #: config/rs6000/rs6000.c:13309
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%srtd%s is ignored in 64bit mode"
  msgid "builtin %s is only valid in 64-bit mode"
-msgstr "соглашения о вызовах -mrtd не поддерживаются в 64-битном режиме"
+msgstr "%srtd%s игнорируется в 64-битном режиме"
  
  #: config/rs6000/rs6000.c:13358
  #, fuzzy, gcc-internal-format, gfc-internal-format
  #| msgid "argument 2 must be a 5-bit unsigned literal"
  msgid "argument %d must be an unsigned literal"
-msgstr "Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 2 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ð¾м"
  
  #: config/rs6000/rs6000.c:13360
  #, fuzzy, gcc-internal-format, gfc-internal-format
  #| msgid "argument 1 of __builtin_spe_predicate is out of range"
  msgid "argument %d is an unsigned literal that is out of range"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 __builtin_spe_predicate вне диапазона"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 1 __builtin_spe_predicate вне диапазона"
  
  #: config/rs6000/rs6000.c:13498
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%s only accepts 1 argument"
  msgid "builtin %s only accepts a string argument"
-msgstr "%q+D может быть функцией с двумя аргументами, либо функцией без аргументов"
+msgstr "%s принимает только 1 аргумент"
  
  #. Invalid CPU argument.
  #: config/rs6000/rs6000.c:13517
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%qs is an invalid argument to -mcpu="
  msgid "cpu %s is an invalid argument to builtin %s"
-msgstr "некорректный аргумент внутренней функции"
+msgstr "%qs некорректный аргумент для -mcpu="
  
  #. Invalid HWCAP argument.
  #: config/rs6000/rs6000.c:13545
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%qs is an invalid argument to -mcpu="
  msgid "hwcap %s is an invalid argument to builtin %s"
-msgstr "некорректный аргумент внутренней функции"
+msgstr "%qs некорректный аргумент для -mcpu="
  
  #: config/rs6000/rs6000.c:13618
  #, gcc-internal-format
  msgid "argument 3 must be a 4-bit unsigned literal"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "аргумент 3 должен быть 4-битным беззнаковым литералом"
  
  #: config/rs6000/rs6000.c:13636
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument 3 must be a 2-bit unsigned literal"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "аргумент 3 должен быть 2-битным беззнаковым литералом"
  
  #: config/rs6000/rs6000.c:13656
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument 3 must be a 1-bit unsigned literal"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "аргумент 3 должен быть 1-битным беззнаковым литералом"
  
  #: config/rs6000/rs6000.c:13668
  #, fuzzy, gcc-internal-format
+#| msgid "argument 1 must be a map"
  msgid "argument 1 must be 0 or 2"
-msgstr "аргумент %qD не является константой"
+msgstr "аргумент 1 должен быть отображением"
  
  #: config/rs6000/rs6000.c:13680
  #, fuzzy, gcc-internal-format
+#| msgid "argument 3 must be a 1-bit unsigned literal"
  msgid "argument 1 must be a 1-bit unsigned literal"
-msgstr "третий аргумент должен быть 4-битным беззнаковым литеральным значением"
+msgstr "аргумент 3 должен быть 1-битным беззнаковым литералом"
  
  #: config/rs6000/rs6000.c:13694
  #, fuzzy, gcc-internal-format
  #| msgid "argument 2 must be a 5-bit unsigned literal"
  msgid "argument 2 must be a 6-bit unsigned literal"
-msgstr "Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 2 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 5-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ð¾м"
  
  #: config/rs6000/rs6000.c:13706
  #, fuzzy, gcc-internal-format
@@ -31837,133 +33289,142 @@ msgstr "число должно быть 0 или 1"
  
  #: config/rs6000/rs6000.c:13713
  #, fuzzy, gcc-internal-format
+#| msgid "argument %d of %qE must be in the range %d...%d"
  msgid "argument 3 must be in the range 0..15"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "аргумент %d от %qE должен быть в диапазоне %d...%d"
  
  #: config/rs6000/rs6000.c:13900
  #, gcc-internal-format
  msgid "argument to %qs must be a 2-bit unsigned literal"
-msgstr "аргумент %qs должен быть 2-битным беззнаковым литеральным значением"
+msgstr "аргумент %qs должен быть 2-битным беззнаковым литералом"
  
  #: config/rs6000/rs6000.c:14053
  #, gcc-internal-format
  msgid "unresolved overload for Altivec builtin %qF"
-msgstr ""
+msgstr "неразрешенная перегрузка Altivec builtin %qF"
  
  #: config/rs6000/rs6000.c:14183
  #, gcc-internal-format
  msgid "argument to dss must be a 2-bit unsigned literal"
-msgstr "аргумент dss должен быть 2-битным беззнаковым литеральным значением"
+msgstr "аргумент dss должен быть 2-битным беззнаковым литералом"
  
  #: config/rs6000/rs6000.c:14550
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument 1 of __builtin_paired_predicate must be a constant"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 __builtin_spe_predicate должен быть константой"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 1 __builtin_paired_predicate должен быть константой"
  
  #: config/rs6000/rs6000.c:14597
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument 1 of __builtin_paired_predicate is out of range"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 __builtin_spe_predicate вне диапазона"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 1 __builtin_paired_predicate вне диапазона"
  
  #: config/rs6000/rs6000.c:14622
  #, gcc-internal-format
  msgid "argument 1 of __builtin_spe_predicate must be a constant"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 __builtin_spe_predicate должен быть константой"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 1 __builtin_spe_predicate должен быть константой"
  
  #: config/rs6000/rs6000.c:14694
  #, gcc-internal-format
  msgid "argument 1 of __builtin_spe_predicate is out of range"
-msgstr "Ð¿ÐµÑ\80Ð²Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 __builtin_spe_predicate вне диапазона"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 1 __builtin_spe_predicate вне диапазона"
  
  #: config/rs6000/rs6000.c:14776
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Builtin function %s is only valid for the cell processor"
-msgstr "эта media-функция имеется только в fr400"
+msgstr "Встроенная функция %s допустима только для процессора cell"
  
  #: config/rs6000/rs6000.c:14778
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Builtin function %s requires the -mvsx option"
-msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð¾Ð¿Ñ\86Ð¸Ñ\8e -mvsx"
  
  #: config/rs6000/rs6000.c:14780
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Builtin function %s requires the -mvsx option"
  msgid "Builtin function %s requires the -mhtm option"
-msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð¾Ð¿Ñ\86Ð¸Ñ\8e -mvsx"
  
  #: config/rs6000/rs6000.c:14782
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Builtin function %s requires the -maltivec option"
-msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð¾Ð¿Ñ\86Ð¸Ñ\8e --maltivec"
  
  #: config/rs6000/rs6000.c:14784
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Builtin function %s requires the -mpaired option"
-msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð¾Ð¿Ñ\86Ð¸Ñ\8e --mpaired"
  
  #: config/rs6000/rs6000.c:14786
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Builtin function %s requires the -mspe option"
-msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð¾Ð¿Ñ\86Ð¸Ñ\8e -mspe"
  
  #: config/rs6000/rs6000.c:14789
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Builtin function %s requires the -mpaired option"
  msgid "Builtin function %s requires the -mhard-dfp and -mpower8-vector options"
-msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð¾Ð¿Ñ\86Ð¸Ñ\8e --mpaired"
  
  #: config/rs6000/rs6000.c:14792
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Builtin function %s requires the -mpaired option"
  msgid "Builtin function %s requires the -mhard-dfp option"
-msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð¾Ð¿Ñ\86Ð¸Ñ\8e --mpaired"
  
  #: config/rs6000/rs6000.c:14794
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Builtin function %s requires the -mspe option"
  msgid "Builtin function %s requires the -mpower8-vector option"
-msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð¾Ð¿Ñ\86Ð¸Ñ\8e -mspe"
  
  #: config/rs6000/rs6000.c:14797
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Builtin function %s requires the -maltivec option"
  msgid "Builtin function %s requires the -mhard-float and -mlong-double-128 options"
-msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð¾Ð¿Ñ\86Ð¸Ñ\8e --maltivec"
  
  #: config/rs6000/rs6000.c:14800
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Builtin function %s requires the -mpaired option"
  msgid "Builtin function %s requires the -mhard-float option"
-msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð¾Ð¿Ñ\86Ð¸Ñ\8e --mpaired"
  
  #: config/rs6000/rs6000.c:14802
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Builtin function %s is not supported with the current options"
-msgstr "-m%s в данной конфигурации не поддерживается"
+msgstr "Встроенная функция %s не поддерживается с текущими опциями"
  
  #: config/rs6000/rs6000.c:16356
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "internal error: builtin function %s had no type"
-msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ°: Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8f Ñ\81 Ð¿Ð¾Ð±Ð¾Ñ\87Ð½Ñ\8bÐ¼ Ñ\8dÑ\84Ñ\84ÐµÐºÑ\82Ð¾Ð¼, Ð²Ð»Ð¸Ñ\8fÑ\8eÑ\89Ð¸Ð¼ Ð½Ð° Ð¾Ñ\81Ð½Ð¾Ð²Ð½Ð¾Ð¹ Ñ\8dÑ\84Ñ\84ÐµÐºÑ\82"
+msgstr "Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ°: Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿Ð°"
  
  #: config/rs6000/rs6000.c:16364
  #, gcc-internal-format, gfc-internal-format
  msgid "internal error: builtin function %s had an unexpected return type %s"
-msgstr ""
+msgstr "внутренняя ошибка: встроенная функция %s имела неожиданный тип результата %s"
  
  #: config/rs6000/rs6000.c:16381
  #, gcc-internal-format, gfc-internal-format
  msgid "internal error: builtin function %s, argument %d had unexpected argument type %s"
-msgstr ""
+msgstr "внутренняя ошибка: встроенная функция %s, аргумент %d имел неожиданный тип аргумента %s"
  
  #: config/rs6000/rs6000.c:24269
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "stack frame too large"
-msgstr "кадр стека слишком велик: %d байт"
+msgstr "кадр стека слишком велик"
  
  #: config/rs6000/rs6000.c:27663
  #, fuzzy, gcc-internal-format
+#| msgid "-fsplit-stack does not support 3 register parameters"
  msgid "-fsplit-stack uses register r29"
-msgstr "ISO C90 не поддерживает регулируемые элементы-массивы"
+msgstr "-fsplit-stack не поддерживает 3-регистровые параметры"
  
  #: config/rs6000/rs6000.c:27671
  #, fuzzy, gcc-internal-format
+#| msgid "#pragma GCC target is not supported for this machine"
  msgid "Stack frame larger than 2G is not supported for -fsplit-stack"
-msgstr "#pragma extern_prefix для этой платформы не поддерживается"
+msgstr "#pragma GCC target для этой машины не поддерживается"
  
  #: config/rs6000/rs6000.c:28669
  #, gcc-internal-format
@@ -31973,72 +33434,72 @@ msgstr "отсутствует профилирование 64-битного к
  #: config/rs6000/rs6000.c:30751
  #, gcc-internal-format
  msgid "You cannot take the address of a nested function if you use the -mno-pointers-to-nested-functions option."
-msgstr ""
+msgstr "Вы не можете брать адрес вложенной функции, если Вы используете опцию -mno-pointers-to-nested-functions."
  
  #: config/rs6000/rs6000.c:30833
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use of %<long double%> in AltiVec types is invalid"
-msgstr "использование 'long' в типах AltiVec-данных будет отменено; используйте 'int'"
+msgstr "использование %<long double%> в типах AltiVec некорректно"
  
  #: config/rs6000/rs6000.c:30835
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use of boolean types in AltiVec types is invalid"
-msgstr "использование 'long' в типах AltiVec-данных будет отменено; используйте 'int'"
+msgstr "использование типов boolean в типах AltiVec некорректно"
  
  #: config/rs6000/rs6000.c:30837
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use of %<complex%> in AltiVec types is invalid"
-msgstr "использование 'long' в типах AltiVec-данных будет отменено; используйте 'int'"
+msgstr "использование %<complex%> в типах AltiVec некорректно"
  
  #: config/rs6000/rs6000.c:30839
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use of decimal floating point types in AltiVec types is invalid"
-msgstr "использование 'long' в типах AltiVec-данных будет отменено; используйте 'int'"
+msgstr "использование типов decimal floating point в типах AltiVec некорректно"
  
  #: config/rs6000/rs6000.c:30845
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use of %<long%> in AltiVec types is invalid for 64-bit code without -mvsx"
-msgstr "использование 'long' в типах AltiVec-данных будет отменено; используйте 'int'"
+msgstr "использование %<long%> в типах AltiVec некорректно для 64-битного кода без -mvsx"
  
  #: config/rs6000/rs6000.c:30848
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use of %<long%> in AltiVec types is deprecated; use %<int%>"
-msgstr "использование 'long' в типах AltiVec-данных будет отменено; используйте 'int'"
+msgstr "использование %<long%> в типах AltiVec не рекомендуется; используйте %<int%>"
  
  #: config/rs6000/rs6000.c:30853
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use of %<long long%> in AltiVec types is invalid without -mvsx"
-msgstr "использование 'long' в типах AltiVec-данных будет отменено; используйте 'int'"
+msgstr "использование %<long long%> в типах AltiVec некорректно без -mvsx"
  
  #: config/rs6000/rs6000.c:30856
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use of %<double%> in AltiVec types is invalid without -mvsx"
-msgstr "использование 'long' в типах AltiVec-данных будет отменено; используйте 'int'"
+msgstr "использование %<double%> в типах AltiVec некорректно без -mvsx"
  
  #: config/rs6000/rs6000.c:34364
  #, gcc-internal-format, gfc-internal-format
  msgid "emitting microcode insn %s\t[%s] #%d"
-msgstr ""
+msgstr "выдается инструкция микрокода %s\t[%s] #%d"
  
  #: config/rs6000/rs6000.c:34368
  #, gcc-internal-format, gfc-internal-format
  msgid "emitting conditional microcode insn %s\t[%s] #%d"
-msgstr ""
+msgstr "выдается условная инструкция микрокода %s\t[%s] #%d"
  
  #: config/rs6000/rs6000.c:34668
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "invalid cpu \"%s\" for %s\"%s\"%s"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ '%%%c'"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¾Ñ\80 \"%s\" Ð´Ð»Ñ\8f %s\"%s\"%s"
  
  #: config/rs6000/rs6000.c:34671
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s\"%s\"%s is not allowed"
-msgstr "некорректно употреблять %<#pragma%>"
+msgstr "%s\"%s\"%s не допускается"
  
  #: config/rs6000/rs6000.c:34673
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s\"%s\"%s is invalid"
-msgstr "недопустимый параметр '%s'"
+msgstr "%s\"%s\"%s некорректно"
  
  #. Definitions of target machine for GNU compiler,
  #. for IBM RS/6000 POWER running AIX version 4.3.
@@ -32180,9 +33641,9 @@ msgstr "Ключ -maix64 требует архитектуры PowerPC64"
  
  #: config/rs6000/aix43.h:36 config/rs6000/aix52.h:36 config/rs6000/aix53.h:36
  #: config/rs6000/aix61.h:36 config/rs6000/aix71.h:36
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "soft-float and long-double-128 are incompatible"
-msgstr "ключи -mrelocatable и -mcall-%s несовместимы"
+msgstr "ключи soft-float и long-double-128 несовместимы"
  
  #: config/rs6000/aix43.h:40 config/rs6000/aix51.h:34 config/rs6000/aix52.h:40
  #: config/rs6000/aix53.h:40 config/rs6000/aix61.h:40 config/rs6000/aix71.h:40
@@ -32192,34 +33653,38 @@ msgstr "требуется -maix64: 64-битные вычисления с 32-
  
  #: config/rs6000/aix61.h:47 config/rs6000/aix71.h:47
  #: config/rs6000/freebsd64.h:120 config/rs6000/linux64.h:142
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-mcmodel incompatible with other toc options"
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´, Ñ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\81 Ñ\84Ð¸Ñ\80Ð¼ÐµÐ½Ð½Ñ\8bÐ¼Ð¸ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83Ð¼ÐµÐ½Ñ\82Ð°Ð¼Ð¸ TI"
+msgstr "ÐºÐ»Ñ\8eÑ\87 -mcmodel Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 Ð´Ñ\80Ñ\83Ð³Ð¸Ð¼Ð¸ Ð¾Ð¿Ñ\86Ð¸Ñ\8fÐ¼Ð¸ toc"
  
  #: config/rs6000/e500.h:37
  #, fuzzy, gcc-internal-format
+#| msgid "AltiVec and E500 instructions cannot coexist"
  msgid "AltiVec and SPE instructions cannot coexist"
-msgstr "Ð\9aÐ¾Ð¼Ð°Ð½Ð´Ñ\8b AltiVec и E500 несовместимы"
+msgstr "Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ AltiVec и E500 несовместимы"
  
  #: config/rs6000/e500.h:39
  #, fuzzy, gcc-internal-format
+#| msgid "VSX and E500 instructions cannot coexist"
  msgid "VSX and SPE instructions cannot coexist"
-msgstr "Ð\9aÐ¾Ð¼Ð°Ð½Ð´Ñ\8b AltiVec и E500 несовместимы"
+msgstr "Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ VSX и E500 несовместимы"
  
  #: config/rs6000/e500.h:41
  #, fuzzy, gcc-internal-format
+#| msgid "64-bit E500 not supported"
  msgid "64-bit SPE not supported"
-msgstr "ключ -pipe не поддерживается"
+msgstr "64-битный E500 не поддерживается"
  
  #: config/rs6000/e500.h:43
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "E500 and FPRs not supported"
-msgstr "\"трамплины\" не поддерживаются"
+msgstr "E500 и FPRs не поддерживаются"
  
  #: config/rs6000/freebsd64.h:98 config/rs6000/linux64.h:115
  #, fuzzy, gcc-internal-format
+#| msgid "-mas100-syntax is incompatible with -gdwarf"
  msgid "-mcall-aixdesc incompatible with -mabi=elfv2"
-msgstr "ключ -march=%s несовместим с выбранным ABI"
+msgstr "ключ -mas100-syntax несовместим с -gdwarf"
  
  #: config/rs6000/freebsd64.h:113 config/rs6000/linux64.h:135
  #, gcc-internal-format
@@ -32269,9 +33734,9 @@ msgid "-fPIC and -mcall-%s are incompatible"
  msgstr "ключи -fPIC и -mcall-%s несовместимы"
  
  #: config/rs6000/sysv4.h:192
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-msecure-plt not supported by your assembler"
-msgstr "MCU %qs поддерживается только для ассемблера"
+msgstr "ключ -msecure-plt не поддерживается вашим ассемблером"
  
  #: config/rs6000/sysv4.h:211
  #, gcc-internal-format, gfc-internal-format
@@ -32279,24 +33744,25 @@ msgid "-m%s not supported in this configuration"
  msgstr "-m%s в данной конфигурации не поддерживается"
  
  #: config/rx/rx.c:643
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "unrecognized control register number: %d - using 'psw'"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ð¼Ñ\8f Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð° \"%s\""
+msgstr "Ð½ÐµÐ¾Ð¿Ð¾Ð·Ð½Ð°Ð½Ð½Ñ\8bÐ¹ Ð½Ð¾Ð¼ÐµÑ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»Ñ\8fÑ\8eÑ\89ÐµÐ³Ð¾ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð°: %d - Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f 'psw'"
  
  #: config/rx/rx.c:1381
  #, fuzzy, gcc-internal-format
+#| msgid "multiple interrupt attributes not allowed"
  msgid "multiple fast interrupt routines seen: %qE and %qE"
-msgstr "Ð·Ð°Ð´Ð°Ð½Ð¾ Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ñ\82Ð¸Ð¿Ð° Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ð¿Ñ\80ÐµÑ\80Ñ\8bÐ²Ð°Ð½Ð¸Ð¹ Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f"
  
  #: config/rx/rx.c:2572
  #, gcc-internal-format, gfc-internal-format
  msgid "__builtin_rx_%s takes 'C', 'Z', 'S', 'O', 'I', or 'U'"
-msgstr ""
+msgstr "__builtin_rx_%s принимает 'C', 'Z', 'S', 'O', 'I' или 'U'"
  
  #: config/rx/rx.c:2574
  #, gcc-internal-format
  msgid "use __builtin_rx_mvtc (0, ... ) to write arbitrary values to PSW"
-msgstr ""
+msgstr "используйте __builtin_rx_mvtc (0, ... ) для записи произвольных значений в PSW"
  
  #: config/rx/rx.c:2621
  #, gcc-internal-format
@@ -32306,7 +33772,7 @@ msgstr ""
  #: config/rx/rx.c:2768
  #, gcc-internal-format
  msgid "RX FPU instructions do not support NaNs and infinities"
-msgstr ""
+msgstr "инструкции RX FPU не поддерживают NaNs и бесконечности"
  
  #: config/s390/s390-c.c:451
  #, gcc-internal-format
@@ -32332,12 +33798,13 @@ msgstr ""
  #, fuzzy, gcc-internal-format
  #| msgid "invalid parameter combination for AltiVec intrinsic"
  msgid "invalid parameter combination for intrinsic %qs"
-msgstr "недопустимая комбинация параметров для AltiVec intrinsic"
+msgstr "недопустимая комбинация параметров для AltiVec встроенной функции"
  
  #: config/s390/s390-c.c:913
  #, fuzzy, gcc-internal-format
+#| msgid "ambiguous overload for %qs in %<%s %E%>"
  msgid "ambiguous overload for intrinsic %qs"
-msgstr "%s для %qs в '%s %E'"
+msgstr "неоднозначная перегрузка для %qs в %<%s %E%>"
  
  #: config/s390/s390-c.c:953
  #, fuzzy, gcc-internal-format
@@ -32369,14 +33836,15 @@ msgstr ""
  
  #: config/s390/s390.c:848
  #, fuzzy, gcc-internal-format
+#| msgid "<unresolved overloaded function type>"
  msgid "Unresolved overloaded builtin"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "<неразрешенный тип перегруженной функции>"
  
  #: config/s390/s390.c:855 config/tilegx/tilegx.c:3543
  #: config/tilepro/tilepro.c:3110
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "bad builtin icode"
-msgstr "некорректный встроенный fcode"
+msgstr "некорректный встроенный icode"
  
  #: config/s390/s390.c:891
  #, gcc-internal-format
@@ -32385,8 +33853,9 @@ msgstr ""
  
  #: config/s390/s390.c:968
  #, fuzzy, gcc-internal-format
+#| msgid "invalid argument to built-in function"
  msgid "Invalid argument %d for builtin %qF"
-msgstr "некорректный аргумент внутренней функции"
+msgstr "некорректный аргумент встроенной функции"
  
  #: config/s390/s390.c:1069
  #, gcc-internal-format
@@ -32394,29 +33863,29 @@ msgid "requested %qE attribute is not a comma separated pair of non-negative int
  msgstr ""
  
  #: config/s390/s390.c:9641
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "total size of local variables exceeds architecture limit"
-msgstr "Суммарный размер локальных переменных превышает предел для данной архитектуры"
+msgstr "суммарный размер локальных переменных превышает архитектурный предел"
  
  #: config/s390/s390.c:10747
  #, 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 ""
+msgstr "размер кадра функции %qs равен %wd байт, что превышает предоставленный пользователем лимит стека в %d байт.  Добавлен безусловный trap."
  
  #: config/s390/s390.c:10763
  #, 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 ""
+msgstr "размер кадра функции %qs равен %wd байт, что больше половины размера стека. Динамическая проверка не будет надежной. Для этой функции проверка не сгенерирована."
  
  #: config/s390/s390.c:10791
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "frame size of %qs is %wd bytes"
-msgstr "размер %qD в памяти неизвестен"
+msgstr "размер кадра %qs равен %wd байт"
  
  #: config/s390/s390.c:10795
  #, gcc-internal-format
  msgid "%qs uses dynamic stack allocation"
-msgstr ""
+msgstr "%qs использует динамическое размещение стека"
  
  #: config/s390/s390.c:11173
  #, gcc-internal-format
@@ -32424,29 +33893,32 @@ msgid "CPUs older than z900 are not supported for -fsplit-stack"
  msgstr ""
  
  #: config/s390/s390.c:14172
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%<mwords-little-endian%> is deprecated and will be removed in a future release"
  msgid "%sarch=%s%s is deprecated and will be removed in future releases; use at least %sarch=z900%s"
-msgstr ""
+msgstr "%<mwords-little-endian%> не рекомендуется и не будет поддерживаться в будущих версиях"
  
  #: config/s390/s390.c:14184
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%<mwords-little-endian%> is deprecated and will be removed in a future release"
  msgid "%stune=%s%s is deprecated and will be removed in future releases; use at least %stune=z900%s"
-msgstr ""
+msgstr "%<mwords-little-endian%> не рекомендуется и не будет поддерживаться в будущих версиях"
  
  #: config/s390/s390.c:14196
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "z/Architecture mode not supported on %s"
-msgstr "Ñ\80ÐµÐ¶Ð¸Ð¼ z/Architecture Ð½Ð° %s Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f."
+msgstr "Ñ\80ÐµÐ¶Ð¸Ð¼ z/Architecture Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f Ð½Ð° %s"
  
  #: config/s390/s390.c:14199
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "64-bit ABI not supported in ESA/390 mode"
-msgstr "64-битный ABI в режиме ESA/390 не поддерживается."
+msgstr "64-битный ABI в режиме ESA/390 не поддерживается"
  
  #: config/s390/s390.c:14216
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "hardware decimal floating point instructions not available on %s"
  msgid "hardware vector support not available on %s"
-msgstr "Ð\9eÐ³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8fÐ¼Ð¸ Ð½Ð°Ð´ 32-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8fÐ¼Ð¸"
+msgstr "Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð´ÐµÑ\81Ñ\8fÑ\82Ð¸Ñ\87Ð½Ð¾Ð¹ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¸ Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\82 Ð½Ð° %s"
  
  #: config/s390/s390.c:14219
  #, gcc-internal-format
@@ -32454,61 +33926,64 @@ msgid "hardware vector support not available with -msoft-float"
  msgstr ""
  
  #: config/s390/s390.c:14247
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "hardware decimal floating point instructions not available on %s"
-msgstr "Ð\9eÐ³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8fÐ¼Ð¸ Ð½Ð°Ð´ 32-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8fÐ¼Ð¸"
+msgstr "Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð´ÐµÑ\81Ñ\8fÑ\82Ð¸Ñ\87Ð½Ð¾Ð¹ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¸ Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\82 Ð½Ð° %s"
  
  #: config/s390/s390.c:14251
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "hardware decimal floating point instructions not available in ESA/390 mode"
-msgstr "Ð\9eÐ³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸ÐºÐ¸ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8fÐ¼Ð¸ Ð½Ð°Ð´ 32-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼Ð¸ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8fÐ¼Ð¸"
+msgstr "Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ñ\8bÐµ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ Ð´ÐµÑ\81Ñ\8fÑ\82Ð¸Ñ\87Ð½Ð¾Ð¹ Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¸ Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\82 Ð² Ñ\80ÐµÐ¶Ð¸Ð¼Ðµ ESA/390"
  
  #: config/s390/s390.c:14263
  #, gcc-internal-format
  msgid "-mhard-dfp can%'t be used in conjunction with -msoft-float"
-msgstr ""
+msgstr "ключ -mhard-dfp не может быть использован вместе с -msoft-float"
  
  #: config/s390/s390.c:14271
  #, gcc-internal-format
  msgid "-mbackchain -mpacked-stack -mhard-float are not supported in combination"
-msgstr ""
+msgstr "сочетание ключей -mbackchain -mpacked-stack -mhard-float не поддерживается"
  
  #: config/s390/s390.c:14277
  #, gcc-internal-format
  msgid "stack size must be greater than the stack guard value"
-msgstr ""
+msgstr "размер стека должен быть больше чем охраняющее значение стека"
  
  #: config/s390/s390.c:14279
  #, gcc-internal-format
  msgid "stack size must not be greater than 64k"
-msgstr ""
+msgstr "размер стека должен быть больше чем 64k"
  
  #: config/s390/s390.c:14282
  #, gcc-internal-format
  msgid "-mstack-guard implies use of -mstack-size"
-msgstr ""
+msgstr "ключ -mstack-guard влечет использование ключа -mstack-size"
  
  #. argument is not a plain number
  #: config/s390/s390.c:14376
  #, fuzzy, gcc-internal-format
+#| msgid "argument to %qs should be a non-negative integer"
  msgid "arguments to %qs should be non-negative integers"
-msgstr "аргумент \"%s\" должен быть неотрицательным целым числом"
+msgstr "аргумент %qs должен быть неотрицательным целым числом"
  
  #: config/s390/s390.c:14383
  #, fuzzy, gcc-internal-format
+#| msgid "argument to %qE attribute larger than %d"
  msgid "argument to %qs is too large (max. %d)"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs Ð±Ð¾Ð»Ñ\8cÑ\88Ðµ %d"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qE Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° Ð±Ð¾Ð»Ñ\8cÑ\88Ðµ Ñ\87ÐµÐ¼ %d"
  
  #. Value is not allowed for the target attribute.
  #: config/s390/s390.c:14591
  #, fuzzy, gcc-internal-format
+#| msgid "%<__int128%> is not supported by this target"
  msgid "Value %qs is not supported by attribute %<target%>"
-msgstr "__builtin_saveregs не поддерживается для этой целевой платформы"
+msgstr "%<__int128%> не поддерживается этой целевой платформой"
  
  #: config/sh/sh.c:1028
  #, gcc-internal-format
  msgid "ignoring -fschedule-insns because of exception handling bug"
-msgstr ""
+msgstr "игнорируется -fschedule-insns в силу ошибки при обработке исключительной ситуации"
  
  #: config/sh/sh.c:1045
  #, gcc-internal-format
@@ -32521,14 +33996,14 @@ msgid "__builtin_saveregs not supported by this subtarget"
  msgstr "__builtin_saveregs для этой платформы не поддерживается"
  
  #: config/sh/sh.c:9704
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute only applies to interrupt functions"
-msgstr "атрибут %qs применим только к функциям обработки прерываний"
+msgstr "атрибут %qE применим только к функциям прерывания"
  
  #: config/sh/sh.c:9774
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute is supported only for SH2A"
-msgstr "атрибут %qs не поддерживается на данной платформе"
+msgstr "атрибут %qE поддерживается только для SH2A"
  
  #: config/sh/sh.c:9804
  #, gcc-internal-format
@@ -32536,47 +34011,47 @@ msgid "attribute interrupt_handler is not compatible with -m5-compact"
  msgstr "атрибут interrupt_handler несовместим с -m5-compact"
  
  #: config/sh/sh.c:9821
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute only applies to SH2A"
-msgstr "атрибут %qs допустим только для функций"
+msgstr "атрибут %qE применим только к SH2A"
  
  #: config/sh/sh.c:9843
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute argument should be between 0 to 255"
-msgstr "аргумент атрибута %qs не является целой константой"
+msgstr "аргумент атрибута %qE должен быть между 0 и 255"
  
  #. The argument must be a constant string.
  #: config/sh/sh.c:9916
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute argument not a string constant"
-msgstr "аргумент атрибута %qs не является строковой константой"
+msgstr "аргумент атрибута %qE не строковая константа"
  
  #: config/sh/sh.c:12764
  #, gcc-internal-format
  msgid "r0 needs to be available as a call-clobbered register"
-msgstr ""
+msgstr "r0 должен быть доступен как затираемый вызовом регистр"
  
  #: config/sh/sh.c:12785
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "need a second call-clobbered general purpose register"
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80 BK ÐºÐ°Ðº Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80 Ð¾Ð±Ñ\89ÐµÐ³Ð¾ Ð½Ð°Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð½Ñ\83Ð¶ÐµÐ½ Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð·Ð°Ñ\82Ð¸Ñ\80Ð°ÐµÐ¼Ñ\8bÐ¹ Ð²Ñ\8bÐ·Ð¾Ð²Ð¾Ð¼ Ñ\83Ð½Ð¸Ð²ÐµÑ\80Ñ\81Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80"
  
  #: config/sh/sh.c:12793
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "need a call-clobbered target register"
-msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80 BK ÐºÐ°Ðº Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80 Ð¾Ð±Ñ\89ÐµÐ³Ð¾ Ð½Ð°Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð½Ñ\83Ð¶ÐµÐ½ Ð·Ð°Ñ\82Ð¸Ñ\80Ð°ÐµÐ¼Ñ\8bÐ¹ Ð²Ñ\8bÐ·Ð¾Ð²Ð¾Ð¼ Ñ\86ÐµÐ»ÐµÐ²Ð¾Ð¹ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80"
  
  #. FIXME
  #: config/sh/netbsd-elf.h:73
  #, gcc-internal-format
  msgid "unimplemented-shmedia profiling"
-msgstr ""
+msgstr "unimplemented-shmedia профилирование"
  
  #. The kernel loader cannot handle the relaxation                       relocations, so it cannot load kernel modules                   (which are ET_REL) or RTP executables (which are                linked with --emit-relocs).  No relaxation relocations          appear in shared libraries, so relaxation is OK                 for RTP PIC.
  #: config/sh/vxworks.h:43
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-mrelax is only supported for RTP PIC"
-msgstr "в TFP-OS не поддерживается static"
+msgstr "-mrelax поддерживается только для RTP PIC"
  
  #: config/sparc/sparc.c:1342
  #, gcc-internal-format, gfc-internal-format
@@ -32599,24 +34074,24 @@ msgid "-mcmodel= is not supported on 32 bit systems"
  msgstr "ключ -mcmodel= на 32-битных системах не поддерживается"
  
  #: config/sparc/sparc.c:1381
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-fcall-saved-REG is not supported for out registers"
-msgstr "-fdata-sections не поддерживается для этой целевой машины"
+msgstr "-fcall-saved-REG не поддерживается для выходных регистров"
  
  #: config/spu/spu-c.c:131
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "insufficient arguments to overloaded function %s"
-msgstr "слишком мало аргументов в вызове функции %s"
+msgstr "недостаточно аргументов для перегруженной функции %s"
  
  #: config/spu/spu-c.c:162
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "too many arguments to overloaded function %s"
-msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ функции %s"
+msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð´Ð»Ñ\8f Ð¿ÐµÑ\80ÐµÐ³Ñ\80Ñ\83Ð¶ÐµÐ½Ð½Ð¾Ð¹ функции %s"
  
  #: config/spu/spu-c.c:174
  #, gcc-internal-format, gfc-internal-format
  msgid "parameter list does not match a valid signature for %s()"
-msgstr ""
+msgstr "список параметров не соответствует корректной сигнатуре для %s()"
  
  #: config/spu/spu.c:255
  #, gcc-internal-format, gfc-internal-format
@@ -32629,39 +34104,39 @@ msgid "bad value (%s) for -mtune= switch"
  msgstr "некорректное значение (%s) для ключа -mtune="
  
  #: config/spu/spu.c:5172 config/spu/spu.c:5175
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "creating run-time relocation for %qD"
-msgstr "нет декларации интерфейса для %qs"
+msgstr "создание настройки времени выполнения для %qD"
  
  #: config/spu/spu.c:5180 config/spu/spu.c:5182
  #, gcc-internal-format
  msgid "creating run-time relocation"
-msgstr ""
+msgstr "создание настройки времени выполнения"
  
  #: config/spu/spu.c:6317
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s expects an integer literal in the range [%d, %d]"
-msgstr "селектор должен быть целой константой в диапазоне 0..%wi"
+msgstr "%s ожидает целый литерал в диапазоне [%d, %d]"
  
  #: config/spu/spu.c:6337
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s expects an integer literal in the range [%d, %d]. (%wd)"
-msgstr "селектор должен быть целой константой в диапазоне 0..%wi"
+msgstr "%s ожидает целый литерал в диапазоне [%d, %d]. (%wd)"
  
  #: config/spu/spu.c:6366
  #, gcc-internal-format, gfc-internal-format
  msgid "%d least significant bits of %s are ignored"
-msgstr ""
+msgstr "%d младших бит %s игнорируются"
  
  #: config/stormy16/stormy16.c:1043
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "local variable memory requirements exceed capacity"
-msgstr "Недостаточно памяти для локальных переменных"
+msgstr "требования на память для локальных переменных превышают возможности"
  
  #: config/stormy16/stormy16.c:1200
  #, gcc-internal-format
  msgid "function_profiler support"
-msgstr "Ð\9fоддержка function_profiler"
+msgstr "Ð¿оддержка function_profiler"
  
  #: config/stormy16/stormy16.c:1294
  #, gcc-internal-format
@@ -32674,19 +34149,19 @@ msgid "switch statement of size %lu entries too large"
  msgstr "оператор switch содержит слишком много (%lu) элементов"
  
  #: config/stormy16/stormy16.c:2234
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<__BELOW100__%> attribute only applies to variables"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "атрибут %<__BELOW100__%> применим только к переменным"
  
  #: config/stormy16/stormy16.c:2241
  #, gcc-internal-format
  msgid "__BELOW100__ attribute not allowed with auto storage class"
-msgstr ""
+msgstr "атрибут __BELOW100__ не допускается для класса памяти auto"
  
  #: config/tilegx/tilegx.c:3584 config/tilepro/tilepro.c:3136
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "operand must be an immediate of the right size"
-msgstr "Ð¼Ð°Ñ\81ÐºÐ° Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼ Ð¿Ð¾Ð´Ñ\85Ð¾Ð´Ñ\8fÑ\89ÐµÐ³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð°"
  
  #: config/v850/v850-c.c:65
  #, gcc-internal-format
@@ -32714,9 +34189,9 @@ msgid "junk at end of #pragma ghs section"
  msgstr "мусор в конце #pragma ghs section"
  
  #: config/v850/v850-c.c:168
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unrecognized section name %qE"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ð¼Ñ\8f Ñ\81ÐµÐºÑ\86Ð¸Ð¸ \"%s\""
+msgstr "Ð½ÐµÐ¾Ð¿Ð¾Ð·Ð½Ð°Ð½Ð½Ð¾Ðµ Ð¸Ð¼Ñ\8f Ñ\81ÐµÐºÑ\86Ð¸Ð¸ %qE"
  
  #: config/v850/v850-c.c:182
  #, gcc-internal-format
@@ -32759,19 +34234,19 @@ msgid "junk at end of #pragma ghs endzda"
  msgstr "мусор в конце #pragma ghs endzda"
  
  #: config/v850/v850.c:2119
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "data area attributes cannot be specified for local variables"
-msgstr "%Jатрибут области данных недопустим для локальных переменных"
+msgstr "атрибуты области данных не могут быть заданы для локальных переменных"
  
  #: config/v850/v850.c:2130
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "data area of %q+D conflicts with previous declaration"
-msgstr "%Jобласть данных %qD противоречит предыдущей декларации"
+msgstr "область данных %q+D противоречит предыдущей декларации"
  
  #: config/v850/v850.c:2261
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "bogus JR construction: %d"
-msgstr "некорректная конструкция JR: %d\n"
+msgstr "фиктивная конструкция JR: %d"
  
  #: config/v850/v850.c:2279 config/v850/v850.c:2386
  #, gcc-internal-format, gfc-internal-format
@@ -32779,29 +34254,29 @@ msgid "bad amount of stack space removal: %d"
  msgstr "некорректный размер области, удаляемой из стека: %d"
  
  #: config/v850/v850.c:2366
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "bogus JARL construction: %d"
-msgstr "некорректная конструкция JARL: %d\n"
+msgstr "фиктивная конструкция JARL: %d"
  
  #: config/v850/v850.c:2663
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "bogus DISPOSE construction: %d"
-msgstr "Некорректная конструкция DISPOSE: %d\n"
+msgstr "фиктивная конструкция DISPOSE: %d"
  
  #: config/v850/v850.c:2682
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "too much stack space to dispose of: %d"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð²ÐµÐ»Ð¸Ðº Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð¾Ð±Ð»Ð°Ñ\81Ñ\82Ð¸ Ñ\81Ñ\82ÐµÐºÐ° Ð´Ð»Ñ\8f dispose: %d"
+msgstr "Ð¾Ñ\82Ð´Ð°ÐµÑ\82Ñ\81Ñ\8f Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð±Ð¾Ð»Ñ\8cÑ\88Ð¾Ðµ Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ð¾ Ñ\81Ñ\82ÐµÐºÐ°: %d"
  
  #: config/v850/v850.c:2784
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "bogus PREPEARE construction: %d"
-msgstr "Некорректная конструкция PREPEARE: %d\n"
+msgstr "фиктивная конструкция PREPEARE: %d"
  
  #: config/v850/v850.c:2801
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "too much stack space to prepare: %d"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð²ÐµÐ»Ð¸Ðº Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð¾Ð±Ð»Ð°Ñ\81Ñ\82Ð¸ Ñ\81Ñ\82ÐµÐºÐ° Ð´Ð»Ñ\8f prepare: %d"
+msgstr "Ð³Ð¾Ñ\82Ð¾Ð²Ð¸Ñ\82Ñ\81Ñ\8f Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð±Ð¾Ð»Ñ\8cÑ\88Ð¾Ðµ Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ð¾ Ñ\81Ñ\82ÐµÐºÐ°: %d"
  
  #: config/visium/visium.c:705
  #, fuzzy, gcc-internal-format
@@ -32810,77 +34285,79 @@ msgid "an interrupt handler cannot be compiled with -muser-mode"
  msgstr "атрибут interrupt_handler несовместим с -m5-compact"
  
  #: config/vms/vms-c.c:41
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of #pragma __nostandard"
-msgstr "мусор в конце #pragma ghs starttda"
+msgstr "мусор в конце директивы #pragma __nostandard"
  
  #: config/vms/vms-c.c:52
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of #pragma __standard"
-msgstr "мусор в конце #pragma %s"
+msgstr "мусор в конце директивы #pragma __standard"
  
  #: config/vms/vms-c.c:77
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed '#pragma member_alignment', ignoring"
-msgstr "некорректный синтаксис #pragma align - директива проигнорирована"
+msgstr "некорректный синтаксис директивы '#pragma member_alignment', игнорируется"
  
  #: config/vms/vms-c.c:92
  #, gcc-internal-format, gfc-internal-format
  msgid "unknown '#pragma member_alignment' name %s"
-msgstr ""
+msgstr "неизвестное '#pragma member_alignment' имя %s"
  
  #: config/vms/vms-c.c:97
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed '#pragma member_alignment'"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma builtin"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ñ\8b '#pragma member_alignment'"
  
  #: config/vms/vms-c.c:131
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unhandled alignment for '#pragma nomember_alignment'"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma align - Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð°"
+msgstr "Ð½ÐµÐ¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82Ð°Ð½Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð´Ð»Ñ\8f Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ñ\8b '#pragma nomember_alignment'"
  
  #: config/vms/vms-c.c:144
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "garbage at end of '#pragma nomember_alignment'"
-msgstr "мусор в конце директивы '#pragma options'"
+msgstr "мусор в конце директивы '#pragma nomember_alignment'"
  
  #: config/vms/vms-c.c:199
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed '#pragma extern_model', ignoring"
-msgstr "некорректная директива '#pragma options', игнорируется"
+msgstr "некорректный синтаксис директивы '#pragma extern_model', игнорируется"
  
  #: config/vms/vms-c.c:220
  #, gcc-internal-format
  msgid "extern model globalvalue"
-msgstr ""
+msgstr "внешняя модель globalvalue"
  
  #: config/vms/vms-c.c:225
  #, gcc-internal-format, gfc-internal-format
  msgid "unknown '#pragma extern_model' model '%s'"
-msgstr ""
+msgstr "неизвестная модель '#pragma extern_model' '%s'"
  
  #: config/vms/vms-c.c:231
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of '#pragma extern_model'"
-msgstr "мусор в конце #pragma extern_prefix"
+msgstr "мусор в конце директивы '#pragma extern_model'"
  
  #: config/vms/vms-c.c:245
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "vms '#pragma __message' is ignored"
-msgstr "неверный синтаксис #pragma weak, директива проигнорирована"
+msgstr "vms '#pragma __message' игнорируется"
  
  #: config/vms/vms-c.c:270 config/vms/vms-c.c:276
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "malformed '#pragma __extern_prefix', ignoring"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma extern_prefix, Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð°"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ñ\8b '#pragma __extern_prefix', Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
  
  #: config/vms/vms-c.c:309 config/vms/vms-c.c:329
  #, fuzzy, gcc-internal-format
+#| msgid "malformed %<#pragma %s%>, ignored"
  msgid "malformed %<#pragma %s%>, ignoring"
-msgstr "некорректный синтаксис %<#pragma pack%> - директива проигнорирована"
+msgstr "некорректный синтаксис %<#pragma %s%>, директива проигнорирована"
  
  #: config/vms/vms-c.c:325
  #, fuzzy, gcc-internal-format
+#| msgid "invalid constant in %<#pragma pack%> - ignored"
  msgid "invalid constant in %<#pragma %s%>"
  msgstr "некорректная константа в %<#pragma pack%> - директива проигнорирована"
  
@@ -32912,7 +34389,7 @@ msgstr "ошибка: %<-gant%> вместо %<-gnat%>"
  #: ada/gcc-interface/misc.c:260
  #, gcc-internal-format
  msgid "-fexcess-precision=standard for Ada"
-msgstr ""
+msgstr "-fexcess-precision=standard для Ada"
  
  #: ada/gcc-interface/misc.c:277
  #, gcc-internal-format
@@ -32946,9 +34423,9 @@ msgid "containing loop"
  msgstr ""
  
  #: ada/gcc-interface/utils.c:3757
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid element type for attribute %qs"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾ Ð·Ð°Ð´Ð°Ð½ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qE"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qs"
  
  #: ada/gcc-interface/utils.c:3781
  #, fuzzy, gcc-internal-format
@@ -32963,41 +34440,44 @@ msgid "%qs attribute ignored"
  msgstr "атрибут %qs проигнорирован"
  
  #: ada/gcc-interface/utils.c:5912
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs attribute requires prototypes with named arguments"
-msgstr "Ð² Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ðµ %qE Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¿Ñ\80Ð¾Ñ\82Ð¾Ñ\82Ð¸Ð¿ с именованными аргументами"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qs Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð¿Ñ\80Ð¾Ñ\82Ð¾Ñ\82Ð¸Ð¿Ñ\8b с именованными аргументами"
  
  #: ada/gcc-interface/utils.c:5921
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs attribute only applies to variadic functions"
-msgstr "атрибут %qE допустим только для функций с переменным числом аргументом"
+msgstr "атрибут %qs применим только к вариантным функциям"
  
  #: ada/gcc-interface/utils.c:5991
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute has no effect"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð½Ðµ Ð´ÐµÐ¹Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82"
  
  #: ada/gcc-interface/utils.c:6115
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "attribute %qs applies to array types only"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qs Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qs Ð¿Ñ\80Ð¸Ð¼ÐµÐ½Ð¸Ð¼ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð½Ñ\8bÐ¼ Ñ\82Ð¸Ð¿Ð°Ð¼"
  
  #: c/c-array-notation.c:217 c/c-array-notation.c:246 cp/call.c:7795
  #: cp/cp-array-notation.c:250
  #, fuzzy, gcc-internal-format
+#| msgid "invalid PHI argument"
  msgid "Invalid builtin arguments"
-msgstr "некорректный тип аргумента"
+msgstr "некорректный аргумент PHI"
  
  #: c/c-array-notation.c:253 cp/cp-array-notation.c:257
  #, gcc-internal-format
  msgid "__sec_reduce_min_ind or __sec_reduce_max_ind cannot have arrays with dimension greater than 1"
  msgstr ""
  
+#
  #: c/c-array-notation.c:718 c/c-array-notation.c:724
  #: cp/cp-array-notation.c:606
  #, fuzzy, gcc-internal-format
+#| msgid "%qD cannot be declared as constexpr"
  msgid "%qE cannot be scalar when %qE is not"
-msgstr "%qD Ð¼Ð¾Ð¶Ð½Ð¾ Ð½Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»Ñ\8fÑ\82Ñ\8c Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¹"
+msgstr "%qD Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¾ ÐºÐ°Ðº constexpr"
  
  #: c/c-array-notation.c:786 cp/cp-array-notation.c:659
  #, fuzzy, gcc-internal-format
@@ -33062,12 +34542,12 @@ msgstr "%q+D рассматривается как массив из одног
  #: c/c-decl.c:854
  #, gcc-internal-format
  msgid "%qD is static but used in inline function %qD which is not static"
-msgstr ""
+msgstr "%qD статическая, но используется в inline функции %qD, не являющейся статической"
  
  #: c/c-decl.c:859
  #, gcc-internal-format
  msgid "%q+D is static but declared in inline function %qD which is not static"
-msgstr ""
+msgstr "%q+D статическая, но используется в inline функции %qD, не являющейся статической"
  
  #: c/c-decl.c:1044
  #, gcc-internal-format, gfc-internal-format
@@ -33085,7 +34565,7 @@ msgid "nested function %q+D declared but never defined"
  msgstr "вложенная функция %q+D объявлена, но нигде не определена"
  
  #: c/c-decl.c:1254
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "inline function %q+D declared but never defined"
  msgstr "вложенная функция %q+D объявлена, но нигде не определена"
  
@@ -33095,9 +34575,9 @@ msgid "unused variable %q+D"
  msgstr "неиспользуемая переменная %q+D"
  
  #: c/c-decl.c:1275 cp/decl.c:665
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %qD set but not used"
-msgstr "Ð¼ÐµÑ\82ÐºÐ° %q+D определена, но не используется"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qD определена, но не используется"
  
  #: c/c-decl.c:1280
  #, gcc-internal-format
@@ -33105,9 +34585,9 @@ msgid "type of array %q+D completed incompatibly with implicit initialization"
  msgstr "тип массива %q+D завершен несовместимым с неявной инициализацией образом"
  
  #: c/c-decl.c:1559 c/c-decl.c:6391 c/c-decl.c:7263 c/c-decl.c:8002
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "originally defined here"
-msgstr "%J  исходное определение находится здесь"
+msgstr "исходное определение находится здесь"
  
  #: c/c-decl.c:1689
  #, gcc-internal-format
@@ -33210,14 +34690,14 @@ msgid "conflicting type qualifiers for %q+D"
  msgstr "несовместимые квалификаторы типа для %q+D"
  
  #: c/c-decl.c:1964
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "redefinition of typedef %q+D with different type"
-msgstr "переопределение typedef %q+D"
+msgstr "переопределение typedef %q+D с другим типом"
  
  #: c/c-decl.c:1977
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "redefinition of typedef %q+D with variably modified type"
-msgstr "переход в область идентификатора с переменно модифицируемым типом"
+msgstr "переопределение typedef %q+D с переменно модифицируемым типом"
  
  #: c/c-decl.c:1982
  #, gcc-internal-format
@@ -33242,12 +34722,12 @@ msgstr "неstatic-декларация %q+D после static-декларац
  #: c/c-decl.c:2103
  #, gcc-internal-format
  msgid "%<gnu_inline%> attribute present on %q+D"
-msgstr ""
+msgstr "атрибут %<gnu_inline%> в %q+D"
  
  #: c/c-decl.c:2106
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "but not here"
-msgstr "%J  здесь задан один тип,"
+msgstr "но не здесь"
  
  #: c/c-decl.c:2124
  #, gcc-internal-format
@@ -33318,7 +34798,7 @@ msgstr "декларация %q+D перекрывает параметр"
  #: c/c-decl.c:2809 cp/name-lookup.c:1270
  #, gcc-internal-format
  msgid "declaration of %qD shadows a global declaration"
-msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÐ²Ð°ÐµÑ\82 Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ñ\83Ñ\8e Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð°Ñ\86Ð¸Ñ\8e"
+msgstr "декларация %qD перекрывает глобальную декларацию"
  
  #: c/c-decl.c:2821
  #, gcc-internal-format
@@ -33327,9 +34807,9 @@ msgstr "декларация %q+D перекрывает декларирова
  
  #: c/c-decl.c:2826 cp/name-lookup.c:1213 cp/name-lookup.c:1255
  #: cp/name-lookup.c:1273
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "shadowed declaration is here"
-msgstr "%Jперекрытая декларация находится здесь"
+msgstr "перекрытая декларация находится здесь"
  
  #: c/c-decl.c:2952
  #, gcc-internal-format
@@ -33358,19 +34838,19 @@ msgid "incompatible implicit declaration of function %qD"
  msgstr "несовместимая неявная декларация функции %qD"
  
  #: c/c-decl.c:3446
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE undeclared here (not in a function)"
-msgstr "%H%qE не описан в этой области (не в функции)"
+msgstr "%qE не описан здесь (не в функции)"
  
  #: c/c-decl.c:3452
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE undeclared (first use in this function)"
-msgstr "%H%qE не описан (первое использование в этой функции)"
+msgstr "%qE не описан (первое использование в этой функции)"
  
  #: c/c-decl.c:3455
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "each undeclared identifier is reported only once for each function it appears in"
-msgstr "%H(Сообщение о неописанном идентификаторе выдается один раз"
+msgstr "сообщение о каждом неописанном идентификаторе выдается один раз в каждой функции, где он встречается"
  
  #: c/c-decl.c:3503 cp/decl.c:2951
  #, gcc-internal-format
@@ -33383,21 +34863,21 @@ msgid "jump into scope of identifier with variably modified type"
  msgstr "переход в область идентификатора с переменно модифицируемым типом"
  
  #: c/c-decl.c:3542
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "jump skips variable initialization"
-msgstr "  пропускает инициализацию `%#D'"
+msgstr "при переходе пропускаются инициализации переменной"
  
  #: c/c-decl.c:3543 c/c-decl.c:3598 c/c-decl.c:3687
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "label %qD defined here"
-msgstr "метка %q+D определена, но не используется"
+msgstr "метка %qD определена здесь"
  
  #: c/c-decl.c:3544 c/c-decl.c:3815 c/c-typeck.c:7879 cp/class.c:1438
  #: cp/class.c:3303 cp/decl.c:3787 cp/friend.c:340 cp/friend.c:349
  #: cp/parser.c:3146 cp/parser.c:3227 cp/parser.c:3255 cp/parser.c:5994
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD declared here"
-msgstr "%q+D объявлено здесь"
+msgstr "%qD объявлено здесь"
  
  #: c/c-decl.c:3597 c/c-decl.c:3686
  #, gcc-internal-format
@@ -33415,29 +34895,29 @@ msgid "duplicate label %qD"
  msgstr "дублирование метки %qD"
  
  #: c/c-decl.c:3748
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "traditional C lacks a separate namespace for labels, identifier %qE conflicts"
-msgstr "%Hв традиционном C нет отдельного пространства имён для меток, конфликт по идентификатору %qE "
+msgstr "в традиционном C нет отдельного пространства имён для меток, конфликт по идентификатору %qE"
  
  #: c/c-decl.c:3813
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "switch jumps over variable initialization"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð¿Ñ\80Ð¸ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸"
+msgstr "Ð¿Ñ\80Ð¸ Ð¿ÐµÑ\80ÐµÑ\85Ð¾Ð´Ðµ Ð¿Ð¾ Ð¿ÐµÑ\80ÐµÐºÐ»Ñ\8eÑ\87Ð°Ñ\82ÐµÐ»Ñ\8e Ð¿Ñ\80Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
  
  #: c/c-decl.c:3814 c/c-decl.c:3825
  #, gcc-internal-format
  msgid "switch starts here"
-msgstr ""
+msgstr "начало переключателя здесь"
  
  #: c/c-decl.c:3824
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "switch jumps into statement expression"
-msgstr "переход в выражение-оператор"
+msgstr "Ð¿Ð¾ Ð¿ÐµÑ\80ÐµÐºÐ»Ñ\8eÑ\87Ð°Ñ\82ÐµÐ»Ñ\8e Ð¿Ñ\80Ð¾Ð¸Ñ\81Ñ\85Ð¾Ð´Ð¸Ñ\82 Ð¿ÐµÑ\80ÐµÑ\85Ð¾Ð´ Ð² Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80"
  
  #: c/c-decl.c:3907
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE defined as wrong kind of tag"
-msgstr "%H%qE: определение с некорректным видом тега"
+msgstr "%qE: определение с некорректным видом тега"
  
  #: c/c-decl.c:4136
  #, gcc-internal-format
@@ -33447,7 +34927,7 @@ msgstr "struct/union без имени и без описания перемен
  #: c/c-decl.c:4146
  #, gcc-internal-format
  msgid "empty declaration with storage class specifier does not redeclare tag"
-msgstr "пустая декларация со спецификатором класса памяти не переопределяет тег"
+msgstr "пустая декларация со спецификатором класса хранения не переопределяет тег"
  
  #: c/c-decl.c:4161
  #, gcc-internal-format
@@ -33455,9 +34935,9 @@ msgid "empty declaration with type qualifier does not redeclare tag"
  msgstr "пустая декларация с квалификатором типа не переопределяет тег"
  
  #: c/c-decl.c:4172
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "empty declaration with %<_Alignas%> does not redeclare tag"
-msgstr "пустая декларация с квалификатором типа не переопределяет тег"
+msgstr "пустая декларация с %<_Alignas%> не переопределяет тег"
  
  #: c/c-decl.c:4194 c/c-decl.c:4202
  #, gcc-internal-format
@@ -33470,9 +34950,9 @@ msgid "%<inline%> in empty declaration"
  msgstr "%<inline%> в пустой декларации"
  
  #: c/c-decl.c:4216
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<_Noreturn%> in empty declaration"
-msgstr "%<inline%> в пустой декларации"
+msgstr "%<_Noreturn%> в пустой декларации"
  
  #: c/c-decl.c:4222
  #, gcc-internal-format
@@ -33491,8 +34971,9 @@ msgstr "бесполезный спецификатор класса хране
  
  #: c/c-decl.c:4241
  #, fuzzy, gcc-internal-format
+#| msgid "useless %<_Alignas%> in empty declaration"
  msgid "useless %qs in empty declaration"
-msgstr "бесполезное %<__thread%> в пустой декларации"
+msgstr "бесполезное %<_Alignas%> в пустой декларации"
  
  #: c/c-decl.c:4254
  #, gcc-internal-format
@@ -33500,9 +34981,9 @@ msgid "useless type qualifier in empty declaration"
  msgstr "бесполезный квалификатор типа в пустой декларации"
  
  #: c/c-decl.c:4261
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "useless %<_Alignas%> in empty declaration"
-msgstr "бесполезное %<__thread%> в пустой декларации"
+msgstr "бесполезное %<_Alignas%> в пустой декларации"
  
  #: c/c-decl.c:4268 c/c-parser.c:1701
  #, gcc-internal-format
@@ -33525,7 +35006,7 @@ msgstr "ISO C90 не поддерживает конструкцию [*] в де
  #: c/c-decl.c:4349 c/c-decl.c:6831
  #, gcc-internal-format
  msgid "%<[*]%> not allowed in other than function prototype scope"
-msgstr ""
+msgstr "%<[*]%> не допускается нигде кроме прототипа функции"
  
  #: c/c-decl.c:4436 cp/decl2.c:1463
  #, gcc-internal-format
@@ -33573,14 +35054,14 @@ msgid "inline function %q+D given attribute noinline"
  msgstr "inline функция %q+D с атрибутом noinline"
  
  #: c/c-decl.c:4669
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "uninitialized const member in %qT is invalid in C++"
-msgstr "не инициализирован константный элемент %qD"
+msgstr "не инициализированный константный элемент в %qT недопустим в C++"
  
  #: c/c-decl.c:4671
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD should be initialized"
-msgstr "%q+D будет инициализирован после"
+msgstr "%qD должен быть инициализирован"
  
  #: c/c-decl.c:4747
  #, gcc-internal-format
@@ -33613,9 +35094,9 @@ msgid "cannot put object with volatile field into register"
  msgstr "некорректная попытка разместить в регистре объект с volatile-полем"
  
  #: c/c-decl.c:5001
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "uninitialized const %qD is invalid in C++"
-msgstr "неинициализированная константа %qD"
+msgstr "неинициализированная константа %qD не допускается в C++"
  
  #: c/c-decl.c:5058
  #, gcc-internal-format
@@ -33625,7 +35106,7 @@ msgstr "в ISO C упреждающие декларации параметро
  #: c/c-decl.c:5155
  #, gcc-internal-format
  msgid "defining a type in a compound literal is invalid in C++"
-msgstr ""
+msgstr "определение типа в составном литерале не допускается в C++"
  
  #: c/c-decl.c:5209 c/c-decl.c:5224
  #, gcc-internal-format
@@ -33633,9 +35114,9 @@ msgid "bit-field %qs width not an integer constant"
  msgstr "размер битового поля %qs не является целочисленной константой"
  
  #: c/c-decl.c:5219
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "bit-field %qs width not an integer constant expression"
-msgstr "размер битового поля %qs не является целочисленной константой"
+msgstr "размер битового поля %qs не является целочисленным константным выражением"
  
  #: c/c-decl.c:5230
  #, gcc-internal-format
@@ -33668,44 +35149,44 @@ msgid "%qs is narrower than values of its type"
  msgstr "ширина поля %qs не достаточна для значений указанного типа"
  
  #: c/c-decl.c:5289
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C90 forbids array %qE whose size can%'t be evaluated"
-msgstr "ISO C90 не поддерживает массив %qs, размер которого нельзя определить"
+msgstr "ISO C90 не поддерживает массив %qE, размер которого нельзя определить"
  
  #: c/c-decl.c:5292
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C90 forbids array whose size can%'t be evaluated"
-msgstr "ISO C90 не поддерживает массив %qs, размер которого нельзя определить"
+msgstr "ISO C90 не поддерживает массив, размер которого нельзя определить"
  
  #: c/c-decl.c:5299
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C90 forbids variable length array %qE"
-msgstr "ISO C90 не поддерживает массив %qs переменного размера"
+msgstr "ISO C90 не поддерживает массив %qE переменного размера"
  
  #: c/c-decl.c:5301
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C90 forbids variable length array"
-msgstr "ISO C90 не поддерживает массив %qs переменного размера"
+msgstr "ISO C90 не поддерживает массив переменного размера"
  
  #: c/c-decl.c:5480 c/c-decl.c:5843 c/c-decl.c:5853
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variably modified %qE at file scope"
-msgstr "Ð¸Ð¼Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ Ð¸Ð»Ð¸ Ð¿Ð¾Ð»Ñ\8f %qs Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»ÐµÐ½Ð¾ void"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾ Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ %qE Ð½Ð° Ñ\83Ñ\80Ð¾Ð²Ð½Ðµ Ñ\84Ð°Ð¹Ð»Ð°"
  
  #: c/c-decl.c:5482
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variably modified field at file scope"
-msgstr "Ð¸Ð¼Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ Ð¸Ð»Ð¸ Ð¿Ð¾Ð»Ñ\8f %qs Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»ÐµÐ½Ð¾ void"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾ Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ðµ Ð¿Ð¾Ð»Ðµ Ð½Ð° Ñ\83Ñ\80Ð¾Ð²Ð½Ðµ Ñ\84Ð°Ð¹Ð»Ð°"
  
  #: c/c-decl.c:5502
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type defaults to %<int%> in declaration of %qE"
-msgstr "в декларации %qs по умолчанию установлен тип %<int%>"
+msgstr "в декларации %qE по умолчанию установлен тип %<int%>"
  
  #: c/c-decl.c:5506
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type defaults to %<int%> in type name"
-msgstr "Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %qs по умолчанию установлен тип %<int%>"
+msgstr "Ð² Ð¸Ð¼ÐµÐ½Ð¸ Ñ\82Ð¸Ð¿Ð° по умолчанию установлен тип %<int%>"
  
  #: c/c-decl.c:5538
  #, gcc-internal-format
@@ -33729,9 +35210,9 @@ msgid "duplicate %<_Atomic%>"
  msgstr "повторное употребление %<restrict%>"
  
  #: c/c-decl.c:5547
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "conflicting named address spaces (%s vs %s)"
-msgstr "ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83Ñ\8eÑ\89ÐµÐµ Ð¸Ð¼Ñ\8f Ñ\81Ñ\83Ð¿ÐµÑ\80ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qs"
+msgstr "ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83Ñ\8eÑ\89Ð¸Ðµ Ð¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ñ\8bÐµ Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ð° (%s Ð¸ %s)"
  
  #: c/c-decl.c:5570 c/c-parser.c:2584
  #, gcc-internal-format
@@ -33760,24 +35241,24 @@ msgid "function definition declared %qs"
  msgstr "определение функции с классом хранения %<auto%>"
  
  #: c/c-decl.c:5608
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "storage class specified for structure field %qE"
-msgstr "класс хранения в декларации поля структуры %qs"
+msgstr "класс хранения в декларации поля структуры %qE"
  
  #: c/c-decl.c:5611
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "storage class specified for structure field"
-msgstr "класс хранения в декларации поля структуры %qs"
+msgstr "класс хранения в декларации поля структуры"
  
  #: c/c-decl.c:5615
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "storage class specified for parameter %qE"
-msgstr "класс хранения в декларации параметра %qs"
+msgstr "класс хранения в декларации параметра %qE"
  
  #: c/c-decl.c:5618
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "storage class specified for unnamed parameter"
-msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %qs"
+msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f Ð·Ð°Ð´Ð°Ð½ Ð´Ð»Ñ\8f Ð½ÐµÐ¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð°"
  
  #: c/c-decl.c:5621 cp/decl.c:9939
  #, gcc-internal-format
@@ -33785,34 +35266,35 @@ msgid "storage class specified for typename"
  msgstr "класс хранения задан для имени типа"
  
  #: c/c-decl.c:5638
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE initialized and declared %<extern%>"
-msgstr "%<extern%> декларация %qs с инициализацией"
+msgstr "%<extern%> декларация %qE с инициализацией"
  
  #: c/c-decl.c:5642
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE has both %<extern%> and initializer"
-msgstr "для %qs задан спецификатор %<extern%> и инициализатор"
+msgstr "для %qE задан спецификатор %<extern%> и инициализатор"
  
  #: c/c-decl.c:5647
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "file-scope declaration of %qE specifies %<auto%>"
-msgstr "в декларации %qs на уровне файла задан класс хранения %<auto%>"
+msgstr "в декларации %qE на уровне файла задан класс хранения %<auto%>"
  
  #: c/c-decl.c:5651
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "file-scope declaration of %qE specifies %<register%>"
-msgstr "в декларации %qs на уровне файла задан класс хранения %<register%>"
+msgstr "в декларации %qE на уровне файла задан класс хранения %<register%>"
  
  #: c/c-decl.c:5656
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "nested function %qE declared %<extern%>"
-msgstr "вложенная функция %qs объявлена %<extern%>"
+msgstr "вложенная функция %qE объявлена %<extern%>"
  
  #: c/c-decl.c:5659
  #, fuzzy, gcc-internal-format
+#| msgid "function-scope %qE implicitly auto and declared %<__thread%>"
  msgid "function-scope %qE implicitly auto and declared %qs"
-msgstr "имя %qs на уровне функции неявно имеет класс auto и объявлено %<__thread%>"
+msgstr "имя %qE на уровне функции неявно имеет класс auto и объявлено %<__thread%>"
  
  #. Only the innermost declarator (making a parameter be of
  #. array type which is converted to pointer type)
@@ -33823,24 +35305,24 @@ msgid "static or type qualifiers in non-parameter array declarator"
  msgstr "static или квалификаторы типа в деклараторе массива, не являющегося "
  
  #: c/c-decl.c:5754
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %qE as array of voids"
-msgstr "имя %qs описано как массив элементов типа void"
+msgstr "имя %qE описано как массив элементов типа void"
  
  #: c/c-decl.c:5756
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of type name as array of voids"
-msgstr "имя %qs описано как массив элементов типа void"
+msgstr "имя типа описано как массив элементов типа void"
  
  #: c/c-decl.c:5763
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %qE as array of functions"
-msgstr "имя %qs описано как массив функций"
+msgstr "имя %qE описано как массив функций"
  
  #: c/c-decl.c:5766
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of type name as array of functions"
-msgstr "имя %qs описано как массив функций"
+msgstr "имя типа описано как массив функций"
  
  #: c/c-decl.c:5774 c/c-decl.c:7757
  #, gcc-internal-format
@@ -33848,34 +35330,34 @@ msgid "invalid use of structure with flexible array member"
  msgstr "неверное употребление структуры с регулируемым элементом-массивом"
  
  #: c/c-decl.c:5800
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "size of array %qE has non-integer type"
-msgstr "размер массива %qs имеет не целочисленный тип"
+msgstr "размер массива %qE имеет не целочисленный тип"
  
  #: c/c-decl.c:5804
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "size of unnamed array has non-integer type"
-msgstr "Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° %qs имеет не целочисленный тип"
+msgstr "Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð±ÐµÐ·Ñ\8bÐ¼Ñ\8fÐ½Ð½Ð¾Ð³Ð¾ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° имеет не целочисленный тип"
  
  #: c/c-decl.c:5814
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C forbids zero-size array %qE"
-msgstr "в ISO C массив %qs нулевой длины недопустим"
+msgstr "в ISO C массив %qE нулевой длины недопустим"
  
  #: c/c-decl.c:5817
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C forbids zero-size array"
-msgstr "ISO C++ запрещает массивы нулевого размера"
+msgstr "ISO C запрещает массивы нулевого размера"
  
  #: c/c-decl.c:5826
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "size of array %qE is negative"
-msgstr "размер массива %qs отрицательный"
+msgstr "размер массива %qE отрицательный"
  
  #: c/c-decl.c:5828
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "size of unnamed array is negative"
-msgstr "размер массива отрицательный"
+msgstr "Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð±ÐµÐ·Ñ\8bÐ¼Ñ\8fÐ½Ð½Ð¾Ð³Ð¾ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð¾Ñ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹"
  
  #: c/c-decl.c:5952 c/c-decl.c:6561
  #, gcc-internal-format
@@ -33884,9 +35366,9 @@ msgstr "ISO C90 не поддерживает регулируемые элем
  
  #. C99 6.7.5.2p4
  #: c/c-decl.c:5974
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<[*]%> not in a declaration"
-msgstr "пространство имён %qD не допускается в using-декларации"
+msgstr "%<[*]%> не является декларацией"
  
  #: c/c-decl.c:5987
  #, fuzzy, gcc-internal-format
@@ -33907,24 +35389,24 @@ msgid "declaration of multidimensional array must have bounds for all dimensions
  msgstr "декларация многомерного массива %qD должна определять границы для всех размерностей, кроме первой"
  
  #: c/c-decl.c:6100
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE declared as function returning a function"
-msgstr "%qs объявлена как функция, возвращающая функцию"
+msgstr "%qE объявлена как функция, возвращающая функцию"
  
  #: c/c-decl.c:6103
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type name declared as function returning a function"
-msgstr "%qs объявлена как функция, возвращающая функцию"
+msgstr "имя типа объявлено как функция, возвращающая функцию"
  
  #: c/c-decl.c:6110
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE declared as function returning an array"
-msgstr "%qs объявлена как функция, возвращающая массив"
+msgstr "%qE объявлена как функция, возвращающая массив"
  
  #: c/c-decl.c:6113
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type name declared as function returning an array"
-msgstr "%qs объявлена как функция, возвращающая массив"
+msgstr "имя типа объявлено как функция, возвращающая массив"
  
  #: c/c-decl.c:6141
  #, gcc-internal-format
@@ -33949,39 +35431,39 @@ msgid "ISO C forbids qualified function types"
  msgstr "в ISO C употребление квалификаторов в описании типа функции запрещено"
  
  #: c/c-decl.c:6248
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs combined with %<auto%> qualifier for %qE"
-msgstr "несовместимые квалификаторы типа для %q+D"
+msgstr "%qs в сочетании с квалификатором %<auto%> для %qE"
  
  #: c/c-decl.c:6252
  #, gcc-internal-format
  msgid "%qs combined with %<register%> qualifier for %qE"
-msgstr ""
+msgstr "%qs в сочетании с квалификатором %<register%> для %qE"
  
  #: c/c-decl.c:6258
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs specified for auto variable %qE"
-msgstr "неверно задан векторный тип для атрибута %qE"
+msgstr "%qs задано для автоматической переменной %qE"
  
  #: c/c-decl.c:6274
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs specified for parameter %qE"
-msgstr "класс хранения в декларации параметра %qs"
+msgstr "%qs задано для параметра %qE"
  
  #: c/c-decl.c:6277
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs specified for unnamed parameter"
-msgstr "класс хранения в декларации параметра %qs"
+msgstr "%qs задано для безымянного параметра"
  
  #: c/c-decl.c:6283
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs specified for structure field %qE"
-msgstr "класс хранения в декларации поля структуры %qs"
+msgstr "%qs задано для поля структуры %qE"
  
  #: c/c-decl.c:6286
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs specified for structure field"
-msgstr "класс хранения в декларации поля структуры %qs"
+msgstr "%qs задано для поля структуры"
  
  #: c/c-decl.c:6301
  #, fuzzy, gcc-internal-format
@@ -33996,49 +35478,49 @@ msgid "bit-field has atomic type"
  msgstr "неверный тип битового поля %qs"
  
  #: c/c-decl.c:6312
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "alignment specified for typedef %qE"
-msgstr "Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f Ð·Ð°Ð´Ð°Ð²Ð°Ñ\82Ñ\8c Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð´Ð»Ñ\8f %q+D"
+msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð·Ð°Ð´Ð°Ð½Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸ Ñ\82Ð¸Ð¿Ð° %qE"
  
  #: c/c-decl.c:6314
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "alignment specified for %<register%> object %qE"
-msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %qs"
+msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð·Ð°Ð´Ð°Ð½Ð¾ Ð´Ð»Ñ\8f Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð° %<register%> %qE"
  
  #: c/c-decl.c:6319
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "alignment specified for parameter %qE"
-msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %qs"
+msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð·Ð°Ð´Ð°Ð½Ð¾ Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %qE"
  
  #: c/c-decl.c:6321
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "alignment specified for unnamed parameter"
-msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %qs"
+msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð·Ð°Ð´Ð°Ð½Ð¾ Ð´Ð»Ñ\8f Ð±ÐµÐ·Ñ\8bÐ¼Ñ\8fÐ½Ð½Ð¾Ð³Ð¾ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð°"
  
  #: c/c-decl.c:6326
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "alignment specified for bit-field %qE"
-msgstr "Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f Ð·Ð°Ð´Ð°Ð²Ð°Ñ\82Ñ\8c Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð´Ð»Ñ\8f %q+D"
+msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð·Ð°Ð´Ð°Ð½Ð¾ Ð´Ð»Ñ\8f Ð±Ð¸Ñ\82Ð¾Ð²Ð¾Ð³Ð¾ Ð¿Ð¾Ð»Ñ\8f %qE"
  
  #: c/c-decl.c:6328
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "alignment specified for unnamed bit-field"
-msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %qs"
+msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð·Ð°Ð´Ð°Ð½Ð¾ Ð´Ð»Ñ\8f Ð±ÐµÐ·Ñ\8bÐ¼Ñ\8fÐ½Ð½Ð¾Ð³Ð¾ Ð±Ð¸Ñ\82Ð¾Ð²Ð¾Ð³Ð¾ Ð¿Ð¾Ð»Ñ\8f"
  
  #: c/c-decl.c:6331
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "alignment specified for function %qE"
-msgstr "вызов не функции %qD"
+msgstr "выравнивание задано для функции %qE"
  
  #: c/c-decl.c:6338
  #, gcc-internal-format
  msgid "%<_Alignas%> specifiers cannot reduce alignment of %qE"
-msgstr ""
+msgstr "спецификатор %<_Alignas%> не должен уменьшать выравнивание %qE"
  
  #: c/c-decl.c:6341
  #, gcc-internal-format
  msgid "%<_Alignas%> specifiers cannot reduce alignment of unnamed field"
-msgstr ""
+msgstr "спецификатор %<_Alignas%> не должен уменьшать выравнивание безымянного поля"
  
  #: c/c-decl.c:6372
  #, gcc-internal-format
@@ -34046,9 +35528,9 @@ msgid "typedef %q+D declared %<inline%>"
  msgstr "typedef %q+D декларирован %<inline%>"
  
  #: c/c-decl.c:6374
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "typedef %q+D declared %<_Noreturn%>"
-msgstr "typedef %q+D декларирован %<inline%>"
+msgstr "typedef %q+D декларирован как %<_Noreturn%>"
  
  #: c/c-decl.c:6417
  #, gcc-internal-format
@@ -34057,9 +35539,9 @@ msgstr "в ISO C функции с квалификаторами const и volat
  
  #. C99 6.7.2.1p8
  #: c/c-decl.c:6428
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "a member of a structure or union cannot have a variably modified type"
-msgstr "элемент данных не может иметь тип %qT модифицируемого размера"
+msgstr "элемент структуры или объединения не может иметь переменно модифицируемый тип"
  
  #: c/c-decl.c:6445 cp/decl.c:9144
  #, gcc-internal-format
@@ -34077,29 +35559,29 @@ msgid "parameter %q+D declared %<inline%>"
  msgstr "параметр %q+D объявлен %<inline%>"
  
  #: c/c-decl.c:6529
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter %q+D declared %<_Noreturn%>"
-msgstr "параметр %q+D объявлен %<inline%>"
+msgstr "параметр %q+D объявлен %<_Noreturn%>"
  
  #: c/c-decl.c:6542
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "field %qE declared as a function"
-msgstr "поле %qs описано как функция"
+msgstr "поле %qE описано как функция"
  
  #: c/c-decl.c:6549
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "field %qE has incomplete type"
-msgstr "поле %qs имеет неполный тип"
+msgstr "поле %qE имеет неполный тип"
  
  #: c/c-decl.c:6551
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unnamed field has incomplete type"
-msgstr "Ð¸Ð¼Ñ\8f %qT имеет неполный тип"
+msgstr "Ð±ÐµÐ·Ñ\8bÐ¼Ñ\8fÐ½Ð½Ð¾Ðµ Ð¿Ð¾Ð»Ðµ имеет неполный тип"
  
  #: c/c-decl.c:6582 c/c-decl.c:6593 c/c-decl.c:6596
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid storage class for function %qE"
-msgstr "для функции %qs задан неверный класс хранения"
+msgstr "для функции %qE задан неверный класс хранения"
  
  #: c/c-decl.c:6653
  #, gcc-internal-format
@@ -34107,19 +35589,19 @@ msgid "cannot inline function %<main%>"
  msgstr "inline-подстановка функции %<main%> невозможна"
  
  #: c/c-decl.c:6655
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<main%> declared %<_Noreturn%>"
-msgstr "%<extern%> декларация %qs с инициализацией"
+msgstr "функция %<main%> декларирована как %<_Noreturn%>"
  
  #: c/c-decl.c:6666
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C99 does not support %<_Noreturn%>"
-msgstr "ISO C90 не поддерживает тип %<long long%>"
+msgstr "ISO C99 не поддерживает %<_Noreturn%>"
  
  #: c/c-decl.c:6669
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C90 does not support %<_Noreturn%>"
-msgstr "ISO C90 не поддерживает тип %<long long%>"
+msgstr "ISO C90 не поддерживает %<_Noreturn%>"
  
  #: c/c-decl.c:6698
  #, gcc-internal-format
@@ -34132,19 +35614,19 @@ msgid "variable %q+D declared %<inline%>"
  msgstr "переменная %q+D декларирована со спецификатором %<inline%>"
  
  #: c/c-decl.c:6710
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %q+D declared %<_Noreturn%>"
-msgstr "переменная %q+D декларирована со спецификатором %<inline%>"
+msgstr "переменная %q+D декларирована со спецификатором %<_Noreturn%>"
  
  #: c/c-decl.c:6745
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-nested function with variably modified type"
-msgstr "Ð¿ÐµÑ\80ÐµÑ\85Ð¾Ð´ Ð² Ð¾Ð±Ð»Ð°Ñ\81Ñ\82Ñ\8c Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð° с переменно модифицируемым типом"
+msgstr "Ð½Ðµ Ð²Ð»Ð¾Ð¶ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f с переменно модифицируемым типом"
  
  #: c/c-decl.c:6747
  #, gcc-internal-format
  msgid "object with variably modified type must have no linkage"
-msgstr ""
+msgstr "объект с переменно модифицируемым типом не должен иметь привязки"
  
  #: c/c-decl.c:6837 c/c-decl.c:8442
  #, gcc-internal-format
@@ -34162,9 +35644,9 @@ msgid "parameter %u (%q+D) has incomplete type"
  msgstr "параметр %u (%q+D) имеет неполный тип"
  
  #: c/c-decl.c:6888
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "parameter %u has incomplete type"
-msgstr "%Jпараметр %u имеет неполный тип"
+msgstr "параметр %u имеет неполный тип"
  
  #: c/c-decl.c:6899
  #, gcc-internal-format
@@ -34172,9 +35654,9 @@ msgid "parameter %u (%q+D) has void type"
  msgstr "параметр %u (%q+D) имеет тип void"
  
  #: c/c-decl.c:6903
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "parameter %u has void type"
-msgstr "%Jпараметр %u имеет неполный void"
+msgstr "параметр %u имеет тип void"
  
  #: c/c-decl.c:6986
  #, gcc-internal-format
@@ -34202,19 +35684,19 @@ msgid "anonymous %s declared inside parameter list will not be visible outside o
  msgstr ""
  
  #: c/c-decl.c:7174
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "enum type defined here"
-msgstr "это предыдущее определение `%#D'"
+msgstr "перечислимый тип определён здесь"
  
  #: c/c-decl.c:7180
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "struct defined here"
-msgstr "Ñ\8dÑ\82Ð¾ Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ `%#D'"
+msgstr "Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ñ\83Ñ\80Ð° Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð° Ð·Ð´ÐµÑ\81Ñ\8c"
  
  #: c/c-decl.c:7186
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "union defined here"
-msgstr "это предыдущее определение `%#D'"
+msgstr "объединение определено здесь"
  
  #: c/c-decl.c:7259
  #, gcc-internal-format
@@ -34239,7 +35721,7 @@ msgstr "вложенное переопределение %<struct %E%>"
  #: c/c-decl.c:7305 c/c-decl.c:8021
  #, gcc-internal-format
  msgid "defining type in %qs expression is invalid in C++"
-msgstr ""
+msgstr "определение типа в выражении %qs некорректно в C++"
  
  #: c/c-decl.c:7373 cp/decl.c:4608
  #, gcc-internal-format
@@ -34247,14 +35729,14 @@ msgid "declaration does not declare anything"
  msgstr "декларация ничего не описывает"
  
  #: c/c-decl.c:7378
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C99 doesn%'t support unnamed structs/unions"
-msgstr "ISO C не поддерживает безымянные структуры и объединения"
+msgstr "ISO C99 не поддерживает безымянные структуры и объединения"
  
  #: c/c-decl.c:7381
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C90 doesn%'t support unnamed structs/unions"
-msgstr "ISO C не поддерживает безымянные структуры и объединения"
+msgstr "ISO C90 не поддерживает безымянные структуры и объединения"
  
  #: c/c-decl.c:7472 c/c-decl.c:7490 c/c-decl.c:7551
  #, gcc-internal-format
@@ -34292,24 +35774,25 @@ msgid "struct has no members"
  msgstr "структура не содержит элементов"
  
  #: c/c-decl.c:7737 cp/decl.c:11018
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "flexible array member in union"
-msgstr "%Jрегулируемый элемент-массив в объединении"
+msgstr "регулируемый элемент-массив в объединении"
  
  #: c/c-decl.c:7743
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "flexible array member not at end of struct"
-msgstr "%Jрегулируемый элемент-массив - не последний элемент структуры"
+msgstr "регулируемый элемент-массив - не последний элемент структуры"
  
  #: c/c-decl.c:7749
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "flexible array member in otherwise empty struct"
-msgstr "%Jрегулируемый массив - единственный именованный элемент структуры"
+msgstr "регулируемый элемент-массив в структуре, которая иначе была бы пустой"
  
  #: c/c-decl.c:7779
  #, fuzzy, gcc-internal-format
+#| msgid "value passed in %qs is too large"
  msgid "type %qT is too large"
-msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ слишком велико"
+msgstr "Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ, Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð½Ð¾Ðµ Ð² %qs слишком велико"
  
  #: c/c-decl.c:7902
  #, gcc-internal-format
@@ -34343,9 +35826,9 @@ msgid "enumerator value for %qE is not an integer constant"
  msgstr "значение перечислимого типа для %qE не является константой целого типа"
  
  #: c/c-decl.c:8219
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "enumerator value for %qE is not an integer constant expression"
-msgstr "значение перечислимого типа для %qE не является константой целого типа"
+msgstr "значение перечислимого типа для %qE не является целочисленным константным выражением"
  
  #: c/c-decl.c:8243
  #, gcc-internal-format
@@ -34358,9 +35841,9 @@ msgid "ISO C restricts enumerator values to range of %<int%>"
  msgstr "в ISO C значения перечислимого типа ограничены диапазоном типа %<int%>"
  
  #: c/c-decl.c:8337 cp/decl.c:4910 cp/decl.c:13873
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "inline function %qD given attribute noinline"
-msgstr "inline функция %q+D с атрибутом noinline"
+msgstr "inline функция %qD с атрибутом noinline"
  
  #: c/c-decl.c:8355
  #, gcc-internal-format
@@ -34379,29 +35862,29 @@ msgid "%q+D defined as variadic function without prototype"
  msgstr "Предупреждать о глобальных функциях без прототипов"
  
  #: c/c-decl.c:8451
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no previous prototype for %qD"
-msgstr "прототип для %q+D не был предварительно определен"
+msgstr "прототип для %qD не был предварительно определен"
  
  #: c/c-decl.c:8460
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD was used with no prototype before its definition"
-msgstr "%q+D использована без предварительного определения"
+msgstr "%qD использована без прототипа, до её определению"
  
  #: c/c-decl.c:8468 cp/decl.c:14016
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no previous declaration for %qD"
-msgstr "отсутствует предварительная декларация %q+D"
+msgstr "отсутствует предварительная декларация %qD"
  
  #: c/c-decl.c:8478
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD was used with no declaration before its definition"
-msgstr "функция %q+D использована до определения без предварительной декларации"
+msgstr "функция %qD использована до определения без предварительной декларации"
  
  #: c/c-decl.c:8497
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "return type of %qD is not %<int%>"
-msgstr "возвращаемое значение функции %q+D - не %<int%>"
+msgstr "возвращаемое значение функции %qD - не %<int%>"
  
  #: c/c-decl.c:8499
  #, gcc-internal-format
@@ -34409,62 +35892,62 @@ msgid "%<_Atomic%>-qualified return type of %qD"
  msgstr ""
  
  #: c/c-decl.c:8506
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is normally a non-static function"
-msgstr "обычно %q+D является нестатической функцией"
+msgstr "обычно %qD является нестатической функцией"
  
  #: c/c-decl.c:8543
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "old-style parameter declarations in prototyped function definition"
-msgstr "%Jстарый стиль деклараций параметров в определении функции с прототипом"
+msgstr "старый стиль деклараций параметров в определении функции с прототипом"
  
  #: c/c-decl.c:8558
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "traditional C rejects ISO C style function definitions"
-msgstr "%Jв традиционном С не поддерживаются определения функций в стиле ISO C"
+msgstr "в традиционном С не поддерживаются определения функций в стиле ISO C"
  
  #: c/c-decl.c:8574
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter name omitted"
-msgstr "%Jопущено имя параметра"
+msgstr "опущено имя параметра"
  
  #: c/c-decl.c:8611
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "old-style function definition"
-msgstr "%Jопределение функции в старом стиле"
+msgstr "определение функции в старом стиле"
  
  #: c/c-decl.c:8620
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter name missing from parameter list"
-msgstr "%Jв списке параметров пропущено имя параметра"
+msgstr "в списке параметров пропущено имя параметра"
  
  #: c/c-decl.c:8635
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD declared as a non-parameter"
-msgstr "%q+D декларирован как не параметр"
+msgstr "%qD декларирован как не параметр"
  
  #: c/c-decl.c:8641
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "multiple parameters named %qD"
-msgstr "более одного параметра с именем %q+D"
+msgstr "более одного параметра с именем %qD"
  
  #: c/c-decl.c:8650
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter %qD declared with void type"
-msgstr "параметр %q+D объявлен void"
+msgstr "параметр %qD объявлен с типом void"
  
  #: c/c-decl.c:8679 c/c-decl.c:8684
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type of %qD defaults to %<int%>"
-msgstr "по умолчанию для %q+D принят тип %<int%>"
+msgstr "по умолчанию для %qD принят тип %<int%>"
  
  #: c/c-decl.c:8704
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter %qD has incomplete type"
-msgstr "параметр %q+D имеет неполный тип"
+msgstr "параметр %qD имеет неполный тип"
  
  #: c/c-decl.c:8711
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration for parameter %qD but no such parameter"
  msgstr "декларация параметра %q+D, не заданного в списке параметров"
  
@@ -34479,9 +35962,9 @@ msgid "number of arguments doesn%'t match prototype"
  msgstr "число аргументов не соответствует прототипу"
  
  #: c/c-decl.c:8775 c/c-decl.c:8822 c/c-decl.c:8836
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "prototype declaration"
-msgstr "%Hдекларация прототипа"
+msgstr "декларация прототипа"
  
  #: c/c-decl.c:8814
  #, gcc-internal-format
@@ -34509,32 +35992,34 @@ msgid "no return statement in function returning non-void"
  msgstr "в функции, которая должна возвращать значение, отсутствует оператор return"
  
  #: c/c-decl.c:9111 cp/decl.c:14802
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter %qD set but not used"
-msgstr "параметр %qD инициализирован"
+msgstr "параметру %qD присвоено значение, но он не использован"
  
  #. 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:9205
  #, fuzzy, gcc-internal-format
+#| msgid "%<for%> loop initial declarations are only allowed in C99 mode"
  msgid "%<for%> loop initial declarations are only allowed in C99 or C11 mode"
  msgstr "декларация в заголовке %<for%>-цикла поддерживается только в стандарте C99"
  
  #: c/c-decl.c:9210
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "use option -std=c99 or -std=gnu99 to compile your code"
  msgid "use option -std=c99, -std=gnu99, -std=c11 or -std=gnu11 to compile your code"
-msgstr ""
+msgstr "используйте -std=c99 или -std=gnu99 для компиляции вашей программы"
  
  #: c/c-decl.c:9245
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of static variable %qD in %<for%> loop initial declaration"
-msgstr "декларация статической переменной %q+D в заголовке %<for%>-цикла"
+msgstr "декларация статической переменной %qD в заголовке %<for%>-цикла"
  
  #: c/c-decl.c:9249
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %<extern%> variable %qD in %<for%> loop initial declaration"
-msgstr "декларация %<extern%> переменной %q+D в заголовке %<for%>-цикла"
+msgstr "декларация %<extern%> переменной %qD в заголовке %<for%>-цикла"
  
  #: c/c-decl.c:9256
  #, gcc-internal-format
@@ -34552,14 +36037,14 @@ msgid "%<enum %E%> declared in %<for%> loop initial declaration"
  msgstr "декларация %<enum %E%> в заголовке %<for%>-цикла"
  
  #: c/c-decl.c:9269
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of non-variable %qD in %<for%> loop initial declaration"
-msgstr "декларация %q+D, не являющегося переменной, в заголовке %<for%>-цикла"
+msgstr "декларация %qD, не являющегося переменной, в заголовке %<for%>-цикла"
  
  #: c/c-decl.c:9517
  #, gcc-internal-format
  msgid "incompatible address space qualifiers %qs and %qs"
-msgstr ""
+msgstr "несовместимые квалификаторы адресного пространства %qs и %qs"
  
  #: c/c-decl.c:9567 c/c-decl.c:9924 c/c-decl.c:10414
  #, gcc-internal-format
@@ -34587,19 +36072,21 @@ msgid "ISO C90 does not support complex types"
  msgstr "ISO C90 не поддерживает комплексные типы"
  
  #: c/c-decl.c:9861
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C does not support saturating types"
-msgstr "ISO C Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bÐµ ÐºÐ¾Ð¼Ð¿Ð»ÐµÐºÑ\81Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b"
+msgstr "ISO C Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ñ\82Ð¸Ð¿Ñ\8b Ñ\81 Ð½Ð°Ñ\81Ñ\8bÑ\89ÐµÐ½Ð¸ÐµÐ¼"
  
  #: c/c-decl.c:9979
  #, fuzzy, gcc-internal-format
+#| msgid "ISO C does not support %<__int128%> type"
  msgid "ISO C does not support %<__int%d%> types"
-msgstr "ISO C Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bÐµ ÐºÐ¾Ð¼Ð¿Ð»ÐµÐºÑ\81Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b"
+msgstr "ISO C Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ñ\82Ð¸Ð¿ %<__int128%>"
  
  #: c/c-decl.c:9999
  #, fuzzy, gcc-internal-format
+#| msgid "%<__int128%> is not supported for this target"
  msgid "%<__int%d%> is not supported on this target"
-msgstr "-fdata-sections не поддерживается для этой целевой машины"
+msgstr "%<__int128%> не поддерживается для этой целевой машины"
  
  #: c/c-decl.c:10041
  #, fuzzy, gcc-internal-format
@@ -34608,24 +36095,24 @@ msgid "ISO C90 does not support boolean types"
  msgstr "ISO C90 не поддерживает комплексные типы"
  
  #: c/c-decl.c:10215
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C does not support decimal floating point"
-msgstr "ISO C90 не поддерживает тип %<long long%>"
+msgstr "ISO C не поддерживает десятичный тип с плавающей точкой"
  
  #: c/c-decl.c:10238 c/c-decl.c:10504 c/c-parser.c:7446
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "fixed-point types not supported for this target"
-msgstr "-fdata-sections не поддерживается для этой целевой машины"
+msgstr "типы с фиксированной точкой не поддерживаются для этой целевой платформы"
  
  #: c/c-decl.c:10240
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C does not support fixed-point types"
-msgstr "ISO C Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bÐµ ÐºÐ¾Ð¼Ð¿Ð»ÐµÐºÑ\81Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b"
+msgstr "ISO C Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ñ\82Ð¸Ð¿Ñ\8b Ñ\81 Ñ\84Ð¸ÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹"
  
  #: c/c-decl.c:10275
  #, gcc-internal-format
  msgid "C++ lookup of %qD would return a field, not a type"
-msgstr ""
+msgstr "в C++ результатом поиска %qD будет поле, а не тип"
  
  #: c/c-decl.c:10288
  #, gcc-internal-format
@@ -34656,14 +36143,14 @@ msgid "%qE used with %<typedef%>"
  msgstr "спецификатор %<__thread%> использован с %<typedef%>"
  
  #: c/c-decl.c:10375 c/c-parser.c:7023
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C99 does not support %qE"
-msgstr "%s не поддерживает %s"
+msgstr "ISO C99 не поддерживает %qE"
  
  #: c/c-decl.c:10378 c/c-parser.c:7026
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C90 does not support %qE"
-msgstr "ISO C90 не поддерживает тип %<long long%>"
+msgstr "ISO C90 не поддерживает %qE"
  
  #: c/c-decl.c:10390
  #, gcc-internal-format
@@ -34687,13 +36174,14 @@ msgstr "в декларации задано более одного класс
  
  #: c/c-decl.c:10428
  #, fuzzy, gcc-internal-format
+#| msgid "%qs must be used with %qs"
  msgid "%qs used with %qE"
-msgstr "-frepo следует использовать вместе с -c"
+msgstr "%qs следует использовать вместе с %qs"
  
  #: c/c-decl.c:10501
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<_Sat%> is used without %<_Fract%> or %<_Accum%>"
-msgstr "%<@try%> без %<@catch%> или %<@finally%>"
+msgstr "%<_Sat%> использован без %<_Fract%> или %<_Accum%>"
  
  #: c/c-decl.c:10516
  #, gcc-internal-format
@@ -34744,7 +36232,7 @@ msgstr "величина сдвига вправо больше или равн
  #: c/c-parser.c:297
  #, gcc-internal-format
  msgid "identifier %qE conflicts with C++ keyword"
-msgstr ""
+msgstr "идентификатор %qE конфликтует с ключевым словом C++"
  
  #: c/c-parser.c:928 cp/parser.c:2786
  #, gcc-internal-format
@@ -34757,19 +36245,19 @@ msgid "expected end of line"
  msgstr "ожидался конец строки"
  
  #: c/c-parser.c:1421
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C forbids an empty translation unit"
-msgstr "согласно ISO C, входной файл не должен быть пустым"
+msgstr "ISO C не допускает пустых единиц трансляции"
  
  #: c/c-parser.c:1525 c/c-parser.c:9054
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C does not allow extra %<;%> outside of a function"
  msgstr "согласно ISO C, избыточный знак %<;%> после функции не допускается"
  
  #: c/c-parser.c:1658 c/c-parser.c:2410 c/c-parser.c:3809
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unknown type name %qE"
-msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð¾Ðµ Ð¸Ð¼Ñ\8f Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð°: %s"
+msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð¾Ðµ Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð° %qE"
  
  #: c/c-parser.c:1662
  #, gcc-internal-format
@@ -34794,28 +36282,29 @@ msgstr "ожидались спецификаторы декларации"
  
  #: c/c-parser.c:1695
  #, fuzzy, gcc-internal-format
+#| msgid "%<_Noreturn%> in empty declaration"
  msgid "%<__auto_type%> in empty declaration"
-msgstr "%<inline%> в пустой декларации"
+msgstr "%<_Noreturn%> в пустой декларации"
  
  #: c/c-parser.c:1717 c/c-parser.c:3088
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<;%>, identifier or %<(%>"
-msgstr "ожидался идентификатор или %<(%>"
+msgstr "ожидалось %<;%>, идентификатор или %<(%>"
  
  #: c/c-parser.c:1735 cp/parser.c:28588 cp/parser.c:28662
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "prefix attributes are ignored for methods"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð´Ð»Ñ\8f %qE Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
+msgstr "Ð¿Ñ\80ÐµÑ\84Ð¸ÐºÑ\81Ð½Ñ\8bÐµ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b Ð´Ð»Ñ\8f Ð¼ÐµÑ\82Ð¾Ð´Ð¾Ð² Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f"
  
  #: c/c-parser.c:1770
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "prefix attributes are ignored for implementations"
-msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f %qD Ð² ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
+msgstr "Ð¿Ñ\80ÐµÑ\84Ð¸ÐºÑ\81Ð½Ñ\8bÐµ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b Ð´Ð»Ñ\8f Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¹ Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f"
  
  #: c/c-parser.c:1791
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unexpected attribute"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 packed Ð½Ðµ Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð½ÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
  #: c/c-parser.c:1833
  #, gcc-internal-format
@@ -34823,7 +36312,7 @@ msgid "%<__auto_type%> requires a plain identifier as declarator"
  msgstr ""
  
  #: c/c-parser.c:1850
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "data definition has no type or storage class"
  msgstr "определение данных не содержит ни типа, ни класса хранения"
  
@@ -34838,6 +36327,7 @@ msgstr "атрибуты не допускаются при определени
  
  #: c/c-parser.c:1885
  #, fuzzy, gcc-internal-format
+#| msgid "%<typeof%> applied to a bit-field"
  msgid "%<__auto_type%> used with a bit-field initializer"
  msgstr "оператор %<typeof%> применен к битовому полю"
  
@@ -34849,8 +36339,9 @@ msgstr "%<auto%> в пустой декларации на уровне файл
  
  #: c/c-parser.c:2007
  #, fuzzy, gcc-internal-format
+#| msgid "%<auto%> can only be specified for variables or function declarations"
  msgid "%<__auto_type%> may only be used with a single declarator"
-msgstr "%qs допустим только для функций"
+msgstr "%<auto%> можно задавать только для переменных или деклараций функций"
  
  #: c/c-parser.c:2036 cp/parser.c:12447
  #, gcc-internal-format
@@ -34866,19 +36357,19 @@ msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>"
  msgstr "ожидалось %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%>"
  
  #: c/c-parser.c:2058
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C forbids nested functions"
  msgstr "ISO C не поддерживает вложенные функции"
  
  #: c/c-parser.c:2181
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C99 does not support %<_Static_assert%>"
-msgstr "ISO C90 не поддерживает тип %<long long%>"
+msgstr "ISO C99 не поддерживает %<_Static_assert%>"
  
  #: c/c-parser.c:2184
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C90 does not support %<_Static_assert%>"
-msgstr "ISO C90 не поддерживает тип %<long long%>"
+msgstr "ISO C90 не поддерживает %<_Static_assert%>"
  
  #: c/c-parser.c:2209 c/c-parser.c:3877 c/c-parser.c:10261 cp/parser.c:37117
  #, gcc-internal-format
@@ -34886,24 +36377,24 @@ msgid "expected string literal"
  msgstr "ожидался строковый литерал"
  
  #: c/c-parser.c:2217
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expression in static assertion is not an integer"
-msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¼ Ñ\83Ñ\82Ð²ÐµÑ\80Ð¶Ð´ÐµÐ½Ð¸Ð¸ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bм"
  
  #: c/c-parser.c:2226
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expression in static assertion is not an integer constant expression"
-msgstr "размер массива не является целочисленным константным выражением"
+msgstr "выражение в статическом утверждении не является целочисленным константным выражением"
  
  #: c/c-parser.c:2231
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expression in static assertion is not constant"
-msgstr "целочисленное выражение %qE не является константой"
+msgstr "выражение в статическом утверждении не является константным"
  
  #: c/c-parser.c:2236
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "static assertion failed: %E"
-msgstr "Ð\9dÐµ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¾ Ð½ÐµÐ¾Ð±Ñ\85Ð¾Ð´Ð¸Ð¼Ð¾Ðµ Ñ\83Ñ\81Ð»Ð¾Ð²Ð¸Ðµ Ð² ÐºÐ¾Ð´Ðµ CRIS: "
+msgstr "Ð½Ðµ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¾ Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ðµ Ñ\83Ñ\82Ð²ÐµÑ\80Ð¶Ð´ÐµÐ½Ð¸Ðµ: %E"
  
  #: c/c-parser.c:2551
  #, gcc-internal-format
@@ -34917,16 +36408,19 @@ msgstr ""
  
  #: c/c-parser.c:2558
  #, fuzzy, gcc-internal-format
+#| msgid "ISO C99 does not support %<_Alignas%>"
  msgid "ISO C99 does not support the %<_Atomic%> qualifier"
-msgstr "ISO C90 не поддерживает тип %<long long%>"
+msgstr "ISO C99 не поддерживает %<_Alignas%>"
  
  #: c/c-parser.c:2561
  #, fuzzy, gcc-internal-format
+#| msgid "ISO C90 does not support %<_Alignas%>"
  msgid "ISO C90 does not support the %<_Atomic%> qualifier"
-msgstr "ISO C90 не поддерживает тип %<long long%>"
+msgstr "ISO C90 не поддерживает %<_Alignas%>"
  
  #: c/c-parser.c:2588
  #, fuzzy, gcc-internal-format
+#| msgid "%<typeof%> applied to a bit-field"
  msgid "%<_Atomic%> applied to a qualified type"
  msgstr "оператор %<typeof%> применен к битовому полю"
  
@@ -34962,7 +36456,7 @@ msgid "expected %<,%> or %<}%>"
  msgstr "ожидалось %<,%> или %<}%>"
  
  #: c/c-parser.c:2782
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C forbids forward references to %<enum%> types"
  msgstr "ISO C не поддерживает ссылки вперед на %<enum%>-типы"
  
@@ -34972,12 +36466,12 @@ msgid "expected class name"
  msgstr "ожидалось имя класса"
  
  #: c/c-parser.c:2917
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "extra semicolon in struct or union specified"
  msgstr "избыточная точка с запятой в структуре или объединении"
  
  #: c/c-parser.c:2946
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no semicolon at end of struct or union"
  msgstr "отсутствует точка с запятой в конце структуры или объединения"
  
@@ -34987,7 +36481,7 @@ msgid "expected specifier-qualifier-list"
  msgstr "ожидался список спецификаторов и квалификаторов"
  
  #: c/c-parser.c:3061
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C forbids member declarations with no members"
  msgstr "ISO C не поддерживает декларации элементов без элементов"
  
@@ -35002,19 +36496,19 @@ msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%>"
  msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%>"
  
  #: c/c-parser.c:3211
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<typeof%> applied to a bit-field"
  msgstr "оператор %<typeof%> применен к битовому полю"
  
  #: c/c-parser.c:3248
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C99 does not support %<_Alignas%>"
-msgstr "ISO C90 не поддерживает тип %<long long%>"
+msgstr "ISO C99 не поддерживает %<_Alignas%>"
  
  #: c/c-parser.c:3251
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C90 does not support %<_Alignas%>"
-msgstr "ISO C90 не поддерживает тип %<long long%>"
+msgstr "ISO C90 не поддерживает %<_Alignas%>"
  
  #: c/c-parser.c:3486
  #, gcc-internal-format
@@ -35023,11 +36517,12 @@ msgstr "ожидался идентификатор или %<(%>"
  
  #: c/c-parser.c:3547 c/c-parser.c:3576
  #, fuzzy, gcc-internal-format
+#| msgid "Warn for obsolescent usage in a declaration"
  msgid "array notations cannot be used in declaration"
-msgstr "Предупреждать о неявных декларациях функций"
+msgstr "Предупреждать об использовании устаревшего синтаксиса деклараций"
  
  #: c/c-parser.c:3715
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C requires a named argument before %<...%>"
  msgstr "ISO C требует, чтобы перед %<...%> был хотя бы один именованный аргумент"
  
@@ -35037,37 +36532,37 @@ msgid "expected declaration specifiers or %<...%>"
  msgstr "ожидались спецификаторы декларации или %<...%>"
  
  #: c/c-parser.c:3871
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "wide string literal in %<asm%>"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð°Ñ\8f Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ð°Ñ\8f Ñ\88Ð¸Ñ\80Ð¾ÐºÐ°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ° Ð² %<asm%>"
+msgstr "литеральная широкая строка в %<asm%>"
  
  #: c/c-parser.c:4347
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C forbids empty initializer braces"
  msgstr "ISO C не поддерживает пустые фигурные скобки в инициализаторах"
  
  #: c/c-parser.c:4402
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "obsolete use of designated initializer with %<:%>"
  msgstr "устаревший способ задания инициализатора для элемента с %<:%>"
  
  #: c/c-parser.c:4546
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C forbids specifying range of elements to initialize"
  msgstr "ISO C не поддерживает задание диапазонов для инициализации"
  
  #: c/c-parser.c:4558
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C90 forbids specifying subobject to initialize"
  msgstr "ISO C не поддерживает инициализацию подобъектов"
  
  #: c/c-parser.c:4566
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "obsolete use of designated initializer without %<=%>"
-msgstr "Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð¸Ð¹ Ñ\81Ð¿Ð¾Ñ\81Ð¾Ð± Ð·Ð°Ð´Ð°Ð½Ð¸Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ð° Ð´Ð»Ñ\8f Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° Ð±ÐµÐ· %<=%>"
+msgstr "устаревший способ задания инициализатора без %<=%>"
  
  #: c/c-parser.c:4749
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C forbids label declarations"
  msgstr "в ISO C декларации меток запрещены"
  
@@ -35077,22 +36572,22 @@ msgid "expected declaration or statement"
  msgstr "ожидалась декларация или оператор"
  
  #: c/c-parser.c:4785 c/c-parser.c:4813
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C90 forbids mixed declarations and code"
-msgstr "%HISO C90 запрещает смешение деклараций и кода"
+msgstr "ISO C90 запрещает смешение деклараций и кода"
  
  #: c/c-parser.c:4842
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<}%> before %<else%>"
-msgstr "ожидалось %<,%> или %<;%>"
+msgstr "ожидалось %<}%> перед %<else%>"
  
  #: c/c-parser.c:4847 cp/parser.c:10801
  #, gcc-internal-format
  msgid "%<else%> without a previous %<if%>"
-msgstr ""
+msgstr "%<else%> без предшествующего %<if%>"
  
  #: c/c-parser.c:4864
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "label at end of compound statement"
  msgstr "метка в конце составного оператора"
  
@@ -35104,7 +36599,7 @@ msgstr "ожидалось %<:%> или %<...%>"
  #: c/c-parser.c:4952
  #, gcc-internal-format
  msgid "a label can only be part of a statement and a declaration is not a statement"
-msgstr ""
+msgstr "метка может быть частью оператора, а декларация не является оператором"
  
  #: c/c-parser.c:5156 cp/parser.c:10402
  #, gcc-internal-format
@@ -35131,14 +36626,14 @@ msgid "expected statement"
  msgstr "ожидался оператор"
  
  #: c/c-parser.c:5380 cp/parser.c:11907
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest braces around empty body in an %<if%> statement"
-msgstr "%Hпустое тело в операторе if"
+msgstr "рекомендуется заключать в фигурные скобки пустое тело в операторе %<if%>"
  
  #: c/c-parser.c:5414 cp/parser.c:11910
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest braces around empty body in an %<else%> statement"
-msgstr "%Hпустая else-часть"
+msgstr "рекомендуется заключать в фигурные скобки пустое тело в операторе %<else%>"
  
  #: c/c-parser.c:5459
  #, gcc-internal-format
@@ -35146,24 +36641,24 @@ msgid "if statement cannot contain %<Cilk_spawn%>"
  msgstr ""
  
  #: c/c-parser.c:5509 cp/parser.c:10955
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest explicit braces to avoid ambiguous %<else%>"
-msgstr "%Hиспользуйте фигурные скобки во избежание неоднозначной трактовки %<else%>"
+msgstr "используйте фигурные скобки во избежание неоднозначной трактовки %<else%>"
  
  #: c/c-parser.c:5648
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest braces around empty body in %<do%> statement"
-msgstr "%Hпустое тело в операторе if"
+msgstr "рекомендуется заключать в фигурные скобки пустое тело в операторе %<do%>"
  
  #: c/c-parser.c:5777 c/c-parser.c:5807
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "multiple iterating variables in fast enumeration"
-msgstr "Ð·Ð°Ð´Ð°Ð½Ð¾ Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ñ\82Ð¸Ð¿Ð° Ñ\84Ñ\83Ð½ÐºÑ\86ии"
+msgstr "Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85-Ð¸Ñ\82ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð² Ð² Ð±Ñ\8bÑ\81Ñ\82Ñ\80Ð¾Ð¼ Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»ÐµÐ½ии"
  
  #: c/c-parser.c:5831
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid iterating variable in fast enumeration"
-msgstr "некорректный регистр в инструкции"
+msgstr "некорректная переменная-итератор в быстром перечислении"
  
  #: c/c-parser.c:5852 cp/parser.c:11156
  #, gcc-internal-format
@@ -35171,49 +36666,51 @@ msgid "missing loop condition in loop with %<GCC ivdep%> pragma"
  msgstr ""
  
  #: c/c-parser.c:5884
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "missing collection in fast enumeration"
-msgstr "Ð\97Ð°Ð¿Ñ\80ÐµÑ\82Ð¸Ñ\82Ñ\8c Ð²Ñ\8bÐ·Ð¾Ð²Ñ\8b Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹ Ð¾Ñ\82Ð½Ð¾Ñ\81Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾ PC"
+msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\81Ð¾Ñ\81Ñ\82Ð°Ð²Ð½Ð¾Ð¹ Ð¾Ð±Ñ\8aÐµÐºÑ\82 Ð² Ð±Ñ\8bÑ\81Ñ\82Ñ\80Ð¾Ð¼ Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸"
  
  #: c/c-parser.c:6001
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%E qualifier ignored on asm"
-msgstr "ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 %E Ð´Ð»Ñ\8f asm"
+msgstr "ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 %E Ð² asm Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
  
  #: c/c-parser.c:6356
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C forbids omitting the middle term of a ?: expression"
  msgstr "ISO C не поддерживает выражения ?: с пустым выражением между ? и :"
  
  #: c/c-parser.c:6856
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "traditional C rejects the unary plus operator"
  msgstr "в традиционном C унарный плюс не поддерживается"
  
  #: c/c-parser.c:6997
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<sizeof%> applied to a bit-field"
  msgstr "оператор %<sizeof%> применен к битовому полю"
  
  #: c/c-parser.c:7083
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C does not allow %<%E (expression)%>"
-msgstr "ISO C++ не поддерживает назначенные инициализаторы"
+msgstr "ISO C не поддерживает %<%E (выражение)%>"
  
  #: c/c-parser.c:7114
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot take address of %qs"
-msgstr "некорректная попытка взять адрес битового поля %qD"
+msgstr "некорректная попытка взять адрес %qs"
  
  #: c/c-parser.c:7198
  #, fuzzy, gcc-internal-format
+#| msgid "ISO C99 does not support %<_Noreturn%>"
  msgid "ISO C99 does not support %<_Generic%>"
-msgstr "ISO C90 не поддерживает тип %<long long%>"
+msgstr "ISO C99 не поддерживает %<_Noreturn%>"
  
  #: c/c-parser.c:7201
  #, fuzzy, gcc-internal-format
+#| msgid "ISO C90 does not support %<_Noreturn%>"
  msgid "ISO C90 does not support %<_Generic%>"
-msgstr "ISO C90 не поддерживает тип %<long long%>"
+msgstr "ISO C90 не поддерживает %<_Noreturn%>"
  
  #: c/c-parser.c:7267
  #, fuzzy, gcc-internal-format
@@ -35239,8 +36736,9 @@ msgstr ""
  
  #: c/c-parser.c:7299
  #, fuzzy, gcc-internal-format
+#| msgid "originally defined here"
  msgid "original %<default%> is here"
-msgstr "%J  исходное определение находится здесь"
+msgstr "исходное определение находится здесь"
  
  #: c/c-parser.c:7307
  #, gcc-internal-format
@@ -35249,8 +36747,9 @@ msgstr ""
  
  #: c/c-parser.c:7308
  #, fuzzy, gcc-internal-format
+#| msgid "incompatible types in send"
  msgid "compatible type is here"
-msgstr "несовместимые типы в операторе возврата"
+msgstr "несовместимые типы в send"
  
  #: c/c-parser.c:7331
  #, fuzzy, gcc-internal-format
@@ -35258,10 +36757,12 @@ msgstr "несовместимые типы в операторе возврат
  msgid "%<_Generic> selector matches multiple associations"
  msgstr "Генерировать команды множественного чтения/записи"
  
+#
  #: c/c-parser.c:7333
  #, fuzzy, gcc-internal-format
+#| msgid "%J  other type here"
  msgid "other match is here"
-msgstr "  при инициализации здесь"
+msgstr "%J  другой тип здесь"
  
  #: c/c-parser.c:7354
  #, gcc-internal-format
@@ -35274,19 +36775,20 @@ msgid "expected expression"
  msgstr "ожидалось выражение"
  
  #: c/c-parser.c:7536
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "braced-group within expression allowed only inside a function"
  msgstr "фигурные скобки внутри выражений допускаются только в теле функции"
  
  #: c/c-parser.c:7550
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C forbids braced-groups within expressions"
-msgstr "ISO C90 не поддерживает использование групп операторов в фигурных скобках внутри выражений"
+msgstr "ISO C не поддерживает использование групп операторов в фигурных скобках внутри выражений"
  
  #: c/c-parser.c:7598
  #, fuzzy, gcc-internal-format
+#| msgid "ISO C does not support %<__int128%> type"
  msgid "ISO C does not support %<__FUNCTION__%> predefined identifier"
-msgstr "ISO C Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bÐµ ÐºÐ¾Ð¼Ð¿Ð»ÐµÐºÑ\81Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b"
+msgstr "ISO C Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ñ\82Ð¸Ð¿ %<__int128%>"
  
  #: c/c-parser.c:7607
  #, gcc-internal-format
@@ -35295,23 +36797,25 @@ msgstr ""
  
  #: c/c-parser.c:7616
  #, fuzzy, gcc-internal-format
+#| msgid "ISO C does not support %<__int128%> type"
  msgid "ISO C90 does not support %<__func__%> predefined identifier"
-msgstr "ISO C Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bÐµ ÐºÐ¾Ð¼Ð¿Ð»ÐµÐºÑ\81Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b"
+msgstr "ISO C Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ñ\82Ð¸Ð¿ %<__int128%>"
  
  #: c/c-parser.c:7777
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "wrong number of arguments to %<__builtin_choose_expr%>"
-msgstr "слишком мало аргументов в вызове функции %<va_start%>"
+msgstr "неверное число аргументов в вызове %<__builtin_choose_expr%>"
  
  #: c/c-parser.c:7793
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "first argument to %<__builtin_choose_expr%> not a constant"
  msgstr "первый аргумент %<__builtin_choose_expr%> - не константа"
  
  #: c/c-parser.c:7864
  #, fuzzy, gcc-internal-format
+#| msgid "wrong number of arguments to %<__builtin_choose_expr%>"
  msgid "wrong number of arguments to %<__builtin_call_with_static_chain%>"
-msgstr "слишком мало аргументов в вызове функции %<va_start%>"
+msgstr "неверное число аргументов в вызове %<__builtin_choose_expr%>"
  
  #: c/c-parser.c:7877
  #, fuzzy, gcc-internal-format
@@ -35326,24 +36830,24 @@ msgid "second argument to %<__builtin_call_with_static_chain%> must be a pointer
  msgstr "второй аргумент %<__builtin_prefetch%> должен быть константой"
  
  #: c/c-parser.c:7907
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "wrong number of arguments to %<__builtin_complex%>"
-msgstr "слишком мало аргументов в вызове функции %<va_start%>"
+msgstr "неверное число аргументов в вызове %<__builtin_complex%>"
  
  #: c/c-parser.c:7929
  #, gcc-internal-format
  msgid "%<__builtin_complex%> operand not of real binary floating-point type"
-msgstr ""
+msgstr "операнд %<__builtin_complex%> имеет не плавающий тип"
  
  #: c/c-parser.c:7938
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<__builtin_complex%> operands of different types"
-msgstr "Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %<__builtin_longjmp%> Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 1"
+msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b %<__builtin_complex%> Ð¸Ð¼ÐµÑ\8eÑ\82 Ñ\80Ð°Ð·Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b"
  
  #: c/c-parser.c:7986 cp/parser.c:6590
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "wrong number of arguments to %<__builtin_shuffle%>"
-msgstr "слишком мало аргументов в вызове функции %<va_start%>"
+msgstr "неверное число аргументов в вызове аргументов в вызове %<__builtin_shuffle%>"
  
  #: c/c-parser.c:8067 cp/parser.c:6535
  #, gcc-internal-format
@@ -35356,17 +36860,17 @@ msgid "consecutive %<_Cilk_spawn%> keywords are not permitted"
  msgstr ""
  
  #: c/c-parser.c:8145
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "compound literal has variable size"
  msgstr "составной литерал имеет переменный размер"
  
  #: c/c-parser.c:8156
  #, gcc-internal-format
  msgid "compound literal qualified by address-space qualifier"
-msgstr ""
+msgstr "для составной литерал задан квалификатор адресного пространства"
  
  #: c/c-parser.c:8160
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C90 forbids compound literals"
  msgstr "ISO C90 не поддерживает составные литеральные выражения"
  
@@ -35376,119 +36880,123 @@ msgid "%<memset%> used with constant zero length parameter; this could be due to
  msgstr ""
  
  #: c/c-parser.c:8658
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected identifier or %<)%>"
-msgstr "ожидался идентификатор или %<(%>"
+msgstr "ожидался идентификатор или %<)%>"
  
  #: c/c-parser.c:8754
  #, gcc-internal-format
  msgid "extra semicolon"
-msgstr ""
+msgstr "лишняя точка с запятой"
  
  #: c/c-parser.c:9002
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "extra semicolon in method definition specified"
-msgstr "избыточная точка с запятой определении метода"
+msgstr "Ð¸Ð·Ð±Ñ\8bÑ\82Ð¾Ñ\87Ð½Ð°Ñ\8f Ñ\82Ð¾Ñ\87ÐºÐ° Ñ\81 Ð·Ð°Ð¿Ñ\8fÑ\82Ð¾Ð¹ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸ Ð¼ÐµÑ\82Ð¾Ð´Ð°"
  
  #: c/c-parser.c:9134
  #, gcc-internal-format
  msgid "method attributes must be specified at the end only"
-msgstr ""
+msgstr "атрибуты методов задаются только в конце"
  
  #: c/c-parser.c:9154
  #, gcc-internal-format
  msgid "expected %<;%> or %<{%> after method attribute definition"
-msgstr ""
+msgstr "ожидалось %<;%> или %<{%> после определения атрибута метода"
  
  #: c/c-parser.c:9275
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "objective-c method declaration is expected"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¸Ñ\81Ñ\8c Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ñ\8b Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð¼ÐµÑ\82Ð¾Ð´Ð° objective-c"
  
  #: c/c-parser.c:9710
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no type or storage class may be specified here,"
-msgstr "Ð´Ð»Ñ\8f %qs Ð·Ð°Ð´Ð°Ð½ ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð² Ñ\8dÑ\82Ð¾Ð¼ Ð¼ÐµÑ\81Ñ\82Ðµ Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ñ\83ÐºÐ°Ð·Ñ\8bÐ²Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ð½Ð¸ Ñ\82Ð¸Ð¿, Ð½Ð¸ ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f,"
  
  #: c/c-parser.c:9800 c/c-parser.c:9857 cp/parser.c:29491
  #, gcc-internal-format
  msgid "unknown property attribute"
-msgstr ""
+msgstr "неизвестный атрибут свойства"
  
  #: c/c-parser.c:9821 cp/parser.c:29451
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "missing %<=%> (after %<getter%> attribute)"
-msgstr "отсутствует %<(%> после %<#pragma pack%> - директива проигнорирована"
+msgstr "отсутствует %<=%> (после атрибута %<getter%>)"
  
  #: c/c-parser.c:9824 cp/parser.c:29454
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "missing %<=%> (after %<setter%> attribute)"
-msgstr "отсутствует %<(%> после %<#pragma pack%> - директива проигнорирована"
+msgstr "отсутствует %<=%> (после атрибута %<setter%>)"
  
  #: c/c-parser.c:9838 cp/parser.c:29469
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the %<setter%> attribute may only be specified once"
-msgstr "%Jатрибут section недопустим для локальных переменных"
+msgstr "атрибут %<setter%> может быть задан только один раз"
  
  #: c/c-parser.c:9843 cp/parser.c:29475
  #, gcc-internal-format
  msgid "setter name must terminate with %<:%>"
-msgstr ""
+msgstr "имя setter должно заканчиваться %<:%>"
  
  #: c/c-parser.c:9850 cp/parser.c:29483
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the %<getter%> attribute may only be specified once"
-msgstr "%Jатрибут адресного пространства для функций недопустим"
+msgstr "атрибут %<getter%> может быть задан только один раз"
  
  #: c/c-parser.c:10052
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma omp barrier%> may only be used in compound statements"
  msgid "%<#pragma acc update%> may only be used in compound statements"
-msgstr ""
+msgstr "%<#pragma omp barrier%> может использоваться только в составных операторах"
  
  #: c/c-parser.c:10063 cp/parser.c:37195
  #, gcc-internal-format
  msgid "%<#pragma omp barrier%> may only be used in compound statements"
-msgstr ""
+msgstr "%<#pragma omp barrier%> может использоваться только в составных операторах"
  
  #: c/c-parser.c:10074 cp/parser.c:37210
  #, gcc-internal-format
  msgid "%<#pragma omp flush%> may only be used in compound statements"
-msgstr ""
+msgstr "%<#pragma omp flush%> может использоваться только в составных операторах"
  
  #: c/c-parser.c:10085 cp/parser.c:37226
  #, gcc-internal-format
  msgid "%<#pragma omp taskwait%> may only be used in compound statements"
-msgstr ""
+msgstr "%<#pragma omp taskwait%> может использоваться только в составных операторах"
  
  #: c/c-parser.c:10096 cp/parser.c:37242
  #, gcc-internal-format
  msgid "%<#pragma omp taskyield%> may only be used in compound statements"
-msgstr ""
+msgstr "%<#pragma omp taskyield%> может использоваться только в составных операторах"
  
  #: c/c-parser.c:10107 cp/parser.c:37258
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma omp taskyield%> may only be used in compound statements"
  msgid "%<#pragma omp cancel%> may only be used in compound statements"
-msgstr ""
+msgstr "%<#pragma omp taskyield%> может использоваться только в составных операторах"
  
  #: c/c-parser.c:10118 cp/parser.c:37274
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma omp taskwait%> may only be used in compound statements"
  msgid "%<#pragma omp cancellation point%> may only be used in compound statements"
-msgstr ""
+msgstr "%<#pragma omp taskwait%> может использоваться только в составных операторах"
  
  #: c/c-parser.c:10138 cp/parser.c:37347
  #, gcc-internal-format
  msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct"
-msgstr ""
+msgstr "%<#pragma omp section%> может использоваться только в конструкции %<#pragma omp sections%>"
  
  #: c/c-parser.c:10157 cp/parser.c:37366
  #, fuzzy, gcc-internal-format
+#| msgid "for statement expected"
  msgid "for, while or do statement expected"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´ `*' Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 for"
  
  #: c/c-parser.c:10169 cp/parser.c:37185
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<#pragma GCC pch_preprocess%> must be first"
-msgstr "некорректный формат #pragma GCC pch_preprocess, директива проигнорирована"
+msgstr "%<#pragma GCC pch_preprocess%> должна быть первой"
  
  #: c/c-parser.c:10182
  #, gcc-internal-format
@@ -35497,53 +37005,59 @@ msgstr ""
  
  #: c/c-parser.c:10190
  #, fuzzy, gcc-internal-format
+#| msgid "#pragma GCC optimize is not allowed inside functions"
  msgid "%<#pragma grainsize%> must be inside a function"
-msgstr "фигурные скобки внутри выражений допускаются только в теле функции"
+msgstr "#pragma GCC optimize не допускается внутри функций"
  
  #: c/c-parser.c:10501 cp/parser.c:29881
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too many %qs clauses"
-msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð²Ñ\85Ð¾Ð´Ð½Ñ\8bÑ\85 Ñ\84Ð°Ð¹Ð»Ð¾Ð²"
+msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ %qs"
  
  #: c/c-parser.c:10522 cp/parser.c:30426
  #, fuzzy, gcc-internal-format
+#| msgid "expected integer expression before %s'%c'"
  msgid "expected integer expression before ')'"
-msgstr "ожидалось выражение"
+msgstr "ожидалось целочисленное выражение перед %s'%c'"
  
  #: c/c-parser.c:10537
  #, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "expression must be integral"
-msgstr "предикат должен быть идентификатором"
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: c/c-parser.c:10666 c/c-parser.c:10674 cp/parser.c:30009 cp/parser.c:30017
  #, fuzzy, gcc-internal-format
+#| msgid "%q#D is not const"
  msgid "%qD is not a constant"
-msgstr "%q#T не является классом"
+msgstr "%q#D не есть const"
  
  #: c/c-parser.c:10826 c/c-parser.c:17232
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is not a variable"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "%qD не переменная"
  
  #: c/c-parser.c:10830 cp/semantics.c:6715
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not a variable"
  msgid "%qD is not a pointer variable"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "%qD не переменная"
  
  #: c/c-parser.c:10870 cp/parser.c:30504
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "collapse argument needs positive constant integer expression"
-msgstr "сравнение знакового и беззнакового целых выражений"
+msgstr "collapse аргумент требует положительного константного целого выражения"
  
  #: c/c-parser.c:10940 cp/parser.c:30560
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<new%>"
  msgid "expected %<none%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<new%>"
  
  #: c/c-parser.c:10942 cp/parser.c:30562
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<none%> or %<shared%>"
-msgstr "ожидалось %<,%> или %<;%>"
+msgstr "ожидалось %<none%> или %<shared%>"
  
  #: c/c-parser.c:11042 cp/parser.c:30662
  #, fuzzy, gcc-internal-format
@@ -35554,8 +37068,9 @@ msgstr "ожидалось %<;%>, %<,%> или %<)%>"
  #: c/c-parser.c:11062 c/c-parser.c:15921 c/c-parser.c:16006 cp/parser.c:30680
  #: cp/parser.c:34671 cp/parser.c:34759
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<catch%>"
  msgid "expected %<data%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<catch%>"
  
  #: c/c-parser.c:11109 cp/parser.c:30733
  #, gcc-internal-format
@@ -35564,13 +37079,15 @@ msgstr ""
  
  #: c/c-parser.c:11116 cp/parser.c:30740
  #, fuzzy, gcc-internal-format
+#| msgid "too many %qs clauses"
  msgid "too many %<if%> clauses"
-msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð²Ñ\85Ð¾Ð´Ð½Ñ\8bÑ\85 Ñ\84Ð°Ð¹Ð»Ð¾Ð²"
+msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ %qs"
  
  #: c/c-parser.c:11118 cp/parser.c:30742
  #, fuzzy, gcc-internal-format
+#| msgid "too many %qs clauses"
  msgid "too many %<if%> clauses without modifier"
-msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð²Ñ\85Ð¾Ð´Ð½Ñ\8bÑ\85 Ñ\84Ð°Ð¹Ð»Ð¾Ð²"
+msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ %qs"
  
  #: c/c-parser.c:11124 cp/parser.c:30748
  #, gcc-internal-format
@@ -35581,84 +37098,97 @@ msgstr ""
  #: c/c-parser.c:11374 c/c-parser.c:11418 c/c-parser.c:11522 c/c-parser.c:11648
  #: c/c-parser.c:11729 c/c-parser.c:12127 c/c-parser.c:12194 c/c-parser.c:12297
  #: c/c-parser.c:12340 c/c-parser.c:12849
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected integer expression"
-msgstr "ожидалось выражение"
+msgstr "ожидалось целочисленное выражение"
  
  #: c/c-parser.c:11209
  #, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<num_gangs%> value must be positive"
-msgstr "%qD не является элементом типа %qT"
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: c/c-parser.c:11253
  #, gcc-internal-format
  msgid "%<num_threads%> value must be positive"
-msgstr ""
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: c/c-parser.c:11297
  #, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<num_tasks%> value must be positive"
-msgstr "%qD не является элементом типа %qT"
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: c/c-parser.c:11341 cp/semantics.c:6891
  #, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<grainsize%> value must be positive"
-msgstr "%qD не является элементом типа %qT"
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: c/c-parser.c:11386 cp/semantics.c:6920
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L must be nonnegative"
  msgid "%<priority%> value must be non-negative"
-msgstr "%qD не является элементом типа %qT"
+msgstr "'%s' в %L должен быть неотрицательным"
  
  #: c/c-parser.c:11447 c/c-parser.c:11453 cp/parser.c:30959 cp/parser.c:30966
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<throw%>"
  msgid "expected %<tofrom%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<throw%>"
  
  #: c/c-parser.c:11461 c/c-parser.c:11467 cp/parser.c:30975 cp/parser.c:30982
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<class%>"
  msgid "expected %<scalar%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<class%>"
  
  #: c/c-parser.c:11533
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<num_workers%> value must be positive"
-msgstr ""
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: c/c-parser.c:11597 cp/parser.c:30288
  #, fuzzy, gcc-internal-format
+#| msgid "too many arguments"
  msgid "too many %<static%> arguments"
-msgstr "слишком много аргументов для форматирования"
+msgstr "слишком много аргументов"
  
  #: c/c-parser.c:11631 cp/parser.c:30321
  #, fuzzy, gcc-internal-format
+#| msgid "unexpected attribute"
  msgid "unexpected argument"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 packed Ð½Ðµ Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð½ÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
  #: c/c-parser.c:11657
  #, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<%s%> value must be positive"
-msgstr "%qD не является элементом типа %qT"
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: c/c-parser.c:11786 cp/semantics.c:7004
  #, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<tile%> value must be integral"
-msgstr "Ð¿Ñ\80ÐµÐ´Ð¸ÐºÐ°Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð¾м"
+msgstr "Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ %<num_threads%> Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ð¾Ð»Ð¾Ð¶Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bм"
  
  #: c/c-parser.c:11799 cp/semantics.c:7018
  #, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<tile%> value must be positive"
-msgstr "%qD не является элементом типа %qT"
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: c/c-parser.c:11865 cp/parser.c:31039
  #, fuzzy, gcc-internal-format
+#| msgid "collapse argument needs positive constant integer expression"
  msgid "ordered argument needs positive constant integer expression"
-msgstr "сравнение знакового и беззнакового целых выражений"
+msgstr "collapse аргумент требует положительного константного целого выражения"
  
  #: c/c-parser.c:11956
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%>"
-msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%>"
+msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%>"
  
  #: c/c-parser.c:12065 cp/parser.c:31252
  #, fuzzy, gcc-internal-format
@@ -35669,62 +37199,72 @@ msgstr "в декларации заданы спецификаторы %<long%>
  #: c/c-parser.c:12118 cp/parser.c:31268
  #, gcc-internal-format
  msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter"
-msgstr ""
+msgstr "расписание %<runtime%> не имеет параметра %<chunk_size%>"
  
  #: c/c-parser.c:12122 cp/parser.c:31271
  #, gcc-internal-format
  msgid "schedule %<auto%> does not take a %<chunk_size%> parameter"
-msgstr ""
+msgstr "расписание %<auto%> не имеет параметра %<chunk_size%>"
  
  #: c/c-parser.c:12144 cp/parser.c:31291
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid schedule kind"
-msgstr "некорректный операнд const_double"
+msgstr "некорректный тип планирования"
  
  #: c/c-parser.c:12205
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<vector_length%> value must be positive"
-msgstr ""
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: c/c-parser.c:12307
  #, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<num_teams%> value must be positive"
-msgstr "%qD не является элементом типа %qT"
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: c/c-parser.c:12350 cp/semantics.c:6395
  #, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<thread_limit%> value must be positive"
-msgstr "%qD не является элементом типа %qT"
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: c/c-parser.c:12392 cp/semantics.c:6505
  #, fuzzy, gcc-internal-format
+#| msgid "collapse argument needs positive constant integer expression"
  msgid "%<aligned%> clause alignment expression must be positive constant integer expression"
-msgstr "сравнение знакового и беззнакового целых выражений"
+msgstr "collapse аргумент требует положительного константного целого выражения"
  
+#
  #: c/c-parser.c:12453 cp/parser.c:31549
  #, fuzzy, gcc-internal-format
+#| msgid "code model %<large%> not supported yet"
  msgid "using parameters for %<linear%> step is not supported yet"
-msgstr "Ð¼Ð¾Ð´ÐµÐ»Ñ\8c ÐºÐ¾Ð´Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %s Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f Ð² Ñ\80ÐµÐ¶Ð¸Ð¼Ðµ PIC"
+msgstr "Ð¼Ð¾Ð´ÐµÐ»Ñ\8c ÐºÐ¾Ð´Ð° %<large%> Ð¿Ð¾ÐºÐ° Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f"
  
  #: c/c-parser.c:12458
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "schedule chunk size expression must be integral"
  msgid "%<linear%> clause step expression must be integral"
-msgstr ""
+msgstr "schedule chunk size выражение должно быть целочисленным"
  
  #: c/c-parser.c:12496
  #, fuzzy, gcc-internal-format
+#| msgid "collapse argument needs positive constant integer expression"
  msgid "%<safelen%> clause expression must be positive constant integer expression"
-msgstr "сравнение знакового и беззнакового целых выражений"
+msgstr "collapse аргумент требует положительного константного целого выражения"
  
  #: c/c-parser.c:12532
  #, fuzzy, gcc-internal-format
+#| msgid "collapse argument needs positive constant integer expression"
  msgid "%<simdlen%> clause expression must be positive constant integer expression"
-msgstr "сравнение знакового и беззнакового целых выражений"
+msgstr "collapse аргумент требует положительного константного целого выражения"
  
  #: c/c-parser.c:12701 cp/parser.c:31785 cp/parser.c:32008
  #, fuzzy, gcc-internal-format
+#| msgid "invalid schedule kind"
  msgid "invalid depend kind"
-msgstr "некорректный операнд const_double"
+msgstr "некорректный тип планирования"
  
  #: c/c-parser.c:12785 cp/parser.c:31858
  #, fuzzy, gcc-internal-format
@@ -35734,33 +37274,37 @@ msgstr "некорректная маска"
  
  #: c/c-parser.c:12879 cp/parser.c:31955
  #, fuzzy, gcc-internal-format
+#| msgid "invalid schedule kind"
  msgid "invalid dist_schedule kind"
-msgstr "некорректный операнд const_double"
+msgstr "некорректный тип планирования"
  
  #: c/c-parser.c:12948
  #, fuzzy, gcc-internal-format
+#| msgid "invalid schedule kind"
  msgid "invalid proc_bind kind"
-msgstr "некорректный операнд const_double"
+msgstr "некорректный тип планирования"
  
  #: c/c-parser.c:13161 cp/parser.c:32233
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<#pragma omp%> clause"
  msgid "expected %<#pragma acc%> clause"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<{%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8f %<#pragma omp%>"
  
  #: c/c-parser.c:13172 c/c-parser.c:13455 cp/parser.c:32244 cp/parser.c:32560
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs is not valid for %qs"
-msgstr "%qs Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¼ Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ñ\8bÐ¼ Ñ\84Ð°Ð¹Ð»Ð¾Ð¼"
+msgstr "%qs Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¼ Ð´Ð»Ñ\8f %qs"
  
  #: c/c-parser.c:13318 cp/parser.c:32420
  #, fuzzy, gcc-internal-format
+#| msgid "%qs must be used with %qs"
  msgid "%qs must be the first clause of %qs"
-msgstr "-frepo следует использовать вместе с -c"
+msgstr "%qs следует использовать вместе с %qs"
  
  #: c/c-parser.c:13444 cp/parser.c:32549
  #, gcc-internal-format
  msgid "expected %<#pragma omp%> clause"
-msgstr ""
+msgstr "ожидалась конструкция %<#pragma omp%>"
  
  #: c/c-parser.c:13582 cp/parser.c:35185
  #, gcc-internal-format
@@ -35769,8 +37313,9 @@ msgstr ""
  
  #: c/c-parser.c:13592 cp/parser.c:35195
  #, fuzzy, gcc-internal-format
+#| msgid "Array section in '%s' call at %L"
  msgid "array section in %<#pragma acc declare%>"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð² %s"
+msgstr "Ð¡ÐµÐºÑ\86Ð¸Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² '%s' Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ð² %L"
  
  #: c/c-parser.c:13616 cp/parser.c:35219
  #, gcc-internal-format
@@ -35779,18 +37324,22 @@ msgstr ""
  
  #: c/c-parser.c:13627 cp/parser.c:35230
  #, fuzzy, gcc-internal-format
+#| msgid "invalid type in declaration"
  msgid "invalid OpenACC clause at file scope"
-msgstr "Ð¿Ñ\83Ñ\81Ñ\82Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸"
  
  #: c/c-parser.c:13634 cp/parser.c:35237
  #, fuzzy, gcc-internal-format
+#| msgid "declaration of %<extern%> variable %qD in %<for%> loop initial declaration"
  msgid "invalid use of %<extern%> variable %qD in %<#pragma acc declare%>"
-msgstr "декларация %<extern%> переменной %q+D в заголовке %<for%>-цикла"
+msgstr "декларация %<extern%> переменной %qD в заголовке %<for%>-цикла"
  
+#
  #: c/c-parser.c:13642 cp/parser.c:35245
  #, fuzzy, gcc-internal-format
+#| msgid "invalid use of %<--%> on bool variable %qD"
  msgid "invalid use of %<global%> variable %qD in %<#pragma acc declare%>"
-msgstr "некорректное использование %<this%> на внешнем уровне"
+msgstr "некорректное использование %<--%> на булевой переменной %qD"
  
  #: c/c-parser.c:13654 cp/parser.c:35257
  #, gcc-internal-format
@@ -35799,8 +37348,9 @@ msgstr ""
  
  #: c/c-parser.c:13740 cp/parser.c:35340
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<@end%> before %<#pragma%>"
  msgid "expected %<data%> in %<#pragma acc enter data%>"
-msgstr "ожидался строковый литерал"
+msgstr "ожидалось %<@end%> перед %<#pragma%>"
  
  #: c/c-parser.c:13749 cp/parser.c:35350
  #, fuzzy, gcc-internal-format
@@ -35815,8 +37365,9 @@ msgstr ""
  
  #: c/c-parser.c:13970 cp/parser.c:36451
  #, fuzzy, gcc-internal-format
+#| msgid "%<#pragma GCC option%> is not a string"
  msgid "%<#pragma acc routine%> not at file scope"
-msgstr "некорректно употреблять %<#pragma%>"
+msgstr "%<#pragma GCC option%> не является строковым литералом"
  
  #: c/c-parser.c:13987 cp/parser.c:2829
  #, gcc-internal-format
@@ -35825,8 +37376,9 @@ msgstr "%qE не был декларирован"
  
  #: c/c-parser.c:13993
  #, fuzzy, gcc-internal-format
+#| msgid "expected function"
  msgid "expected function name"
-msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
  
  #: c/c-parser.c:14032
  #, gcc-internal-format
@@ -35840,8 +37392,9 @@ msgstr ""
  
  #: c/c-parser.c:14042 cp/parser.c:36671
  #, fuzzy, gcc-internal-format
+#| msgid "%<#pragma GCC pch_preprocess%> must be first"
  msgid "%<#pragma acc routine%> must be applied before %s"
-msgstr "некорректный формат #pragma GCC pch_preprocess, директива проигнорирована"
+msgstr "%<#pragma GCC pch_preprocess%> должна быть первой"
  
  #: c/c-parser.c:14079 cp/parser.c:35541
  #, gcc-internal-format
@@ -35849,24 +37402,25 @@ msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host%> o
  msgstr ""
  
  #: c/c-parser.c:14487 cp/parser.c:32931 cp/parser.c:32957
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid form of %<#pragma omp atomic%>"
-msgstr "некорректный операнд для %<__fpreg%>"
+msgstr "некорректный формат %<#pragma omp atomic%>"
  
  #: c/c-parser.c:14491 cp/parser.c:32988 cp/parser.c:33004
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operator for %<#pragma omp atomic%>"
-msgstr "некорректный операнд для %<__fpreg%>"
+msgstr "некорректный оператор для %<#pragma omp atomic%>"
  
  #: c/c-parser.c:14540 cp/semantics.c:8405 cp/semantics.c:8415
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma omp atomic capture%> uses two different variables for memory"
  msgid "%<#pragma omp atomic capture%> uses two different expressions for memory"
-msgstr ""
+msgstr "в %<#pragma omp atomic capture%> используются две различные переменные для памяти"
  
  #: c/c-parser.c:14605 c/c-parser.c:14627
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<(%> or end of line"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<(%> Ð¸Ð»Ð¸ ÐºÐ¾Ð½ÐµÑ\86 Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸"
  
  #: c/c-parser.c:14665 cp/parser.c:33502
  #, gcc-internal-format
@@ -35879,34 +37433,35 @@ msgid "%<linear%> clause may not be specified together with %<ordered%> clause w
  msgstr ""
  
  #: c/c-parser.c:14695 cp/parser.c:33540 cp/parser.c:37733
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "for statement expected"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´ `*' Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 for"
  
  #: c/c-parser.c:14701 cp/parser.c:33546
  #, fuzzy, gcc-internal-format
+#| msgid "for statement expected"
  msgid "_Cilk_for statement expected"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´ `*' Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 for"
  
  #: c/c-parser.c:14770 cp/semantics.c:7955 cp/semantics.c:8042
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected iteration declaration or initialization"
-msgstr "ожидалась декларация или оператор"
+msgstr "ожидалась декларация итерации или инициализация"
  
  #: c/c-parser.c:14855
  #, gcc-internal-format
  msgid "not enough perfectly nested loops"
-msgstr ""
+msgstr "недостаточно аккуратно вложенные циклы"
  
  #: c/c-parser.c:14914 cp/parser.c:33773
  #, gcc-internal-format
  msgid "collapsed loops not perfectly nested"
-msgstr ""
+msgstr "сливаемые циклы не являются идеально вложенными"
  
  #: c/c-parser.c:14961 cp/parser.c:33589 cp/parser.c:33631 cp/pt.c:14951
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "iteration variable %qD should not be firstprivate"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "итерационная переменная %qD не должна быть firstprivate"
  
  #: c/c-parser.c:15052 cp/parser.c:33840
  #, fuzzy, gcc-internal-format
@@ -35915,19 +37470,22 @@ msgid "%<ordered%> clause with parameter may not be specified on %qs construct"
  msgstr "%<void%>, как единственный параметры не может содержать квалификаторы"
  
  #: c/c-parser.c:15211
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma omp barrier%> may only be used in compound statements"
  msgid "%<#pragma omp ordered%> with %<depend> clause may only be used in compound statements"
-msgstr ""
+msgstr "%<#pragma omp barrier%> может использоваться только в составных операторах"
  
  #: c/c-parser.c:15414 cp/parser.c:34196
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<;%> before %qE"
  msgid "expected %<for%> after %qs"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<;%> перед %qE"
  
  #: c/c-parser.c:15613 cp/parser.c:34390
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<using%>"
  msgid "expected %<point%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<using%>"
  
  #: c/c-parser.c:15821 cp/parser.c:34613
  #, gcc-internal-format
@@ -35940,9 +37498,10 @@ msgid "%<#pragma omp target data%> must contain at least one %<map%> clause"
  msgstr ""
  
  #: c/c-parser.c:15869 cp/parser.c:34838
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma omp taskwait%> may only be used in compound statements"
  msgid "%<#pragma omp target update%> may only be used in compound statements"
-msgstr ""
+msgstr "%<#pragma omp taskwait%> может использоваться только в составных операторах"
  
  #: c/c-parser.c:15882 cp/parser.c:34851
  #, gcc-internal-format
@@ -35950,9 +37509,10 @@ msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%
  msgstr ""
  
  #: c/c-parser.c:15929 cp/parser.c:34679
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma omp barrier%> may only be used in compound statements"
  msgid "%<#pragma omp target enter data%> may only be used in compound statements"
-msgstr ""
+msgstr "%<#pragma omp barrier%> может использоваться только в составных операторах"
  
  #: c/c-parser.c:15955 cp/parser.c:34706
  #, gcc-internal-format
@@ -35965,9 +37525,10 @@ msgid "%<#pragma omp target enter data%> must contain at least one %<map%> claus
  msgstr ""
  
  #: c/c-parser.c:16014 cp/parser.c:34767
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma omp taskwait%> may only be used in compound statements"
  msgid "%<#pragma omp target exit data%> may only be used in compound statements"
-msgstr ""
+msgstr "%<#pragma omp taskwait%> может использоваться только в составных операторах"
  
  #: c/c-parser.c:16042
  #, gcc-internal-format
@@ -35990,9 +37551,10 @@ msgid "%<#pragma omp declare simd%> must be followed by function declaration or
  msgstr ""
  
  #: c/c-parser.c:16366 c/c-parser.c:16394
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma align%> must appear before the declaration of %D, ignoring"
  msgid "%<#pragma omp declare simd%> must be followed by function declaration or definition"
-msgstr ""
+msgstr "%<#pragma align%> должна предшествовать декларации %D, игнорируется"
  
  #: c/c-parser.c:16415
  #, gcc-internal-format
@@ -36021,28 +37583,33 @@ msgstr ""
  
  #: c/c-parser.c:16610 cp/parser.c:35851
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<try%>"
  msgid "expected %<target%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<try%>"
  
  #: c/c-parser.c:16617 cp/parser.c:35858
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<decltype%>"
  msgid "expected %<declare%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<decltype%>"
  
  #: c/c-parser.c:16623 cp/parser.c:35865
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma GCC pop_options%> without a corresponding %<#pragma GCC push_options%>"
  msgid "%<#pragma omp end declare target%> without corresponding %<#pragma omp declare target%>"
-msgstr ""
+msgstr "%<#pragma GCC pop_options%> без соответствующей %<#pragma GCC push_options%>"
  
  #: c/c-parser.c:16651
  #, fuzzy, gcc-internal-format
+#| msgid "a template declaration cannot appear at block scope"
  msgid "%<#pragma omp declare reduction%> not at file or block scope"
-msgstr "декларации Objective-C могут находиться только в глобальной области"
+msgstr "декларация шаблона не может появляться в блоке"
  
  #: c/c-parser.c:16701
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%>"
  msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or identifier"
-msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%>"
+msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%>"
  
  #: c/c-parser.c:16728
  #, gcc-internal-format
@@ -36066,18 +37633,21 @@ msgstr ""
  
  #: c/c-parser.c:16752
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<#pragma omp%> clause before %<decltype%>"
  msgid "previous %<#pragma omp declare reduction%>"
-msgstr "Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q+D"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8f %<#pragma omp%> Ð¿ÐµÑ\80ÐµÐ´ %<decltype%>"
  
  #: c/c-parser.c:16869
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<(%> or end of line"
  msgid "expected %<omp_priv%> or function-name"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<(%> Ð¸Ð»Ð¸ ÐºÐ¾Ð½ÐµÑ\86 Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸"
  
  #: c/c-parser.c:16880
  #, fuzzy, gcc-internal-format
+#| msgid "expected function"
  msgid "expected function-name %<(%>"
-msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f"
  
  #: c/c-parser.c:16899
  #, gcc-internal-format
@@ -36091,19 +37661,19 @@ msgid "expected %<simd%> or %<reduction%> or %<target%>"
  msgstr "ожидалось %<#pragma omp section%> или %<}%>"
  
  #: c/c-parser.c:17234 cp/semantics.c:7428
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE declared %<threadprivate%> after first use"
-msgstr "%q+F объявлена %<static%>, но нигде не определена"
+msgstr "%qE объявлена %<threadprivate%> после первого использования"
  
  #: c/c-parser.c:17236 cp/semantics.c:7430
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "automatic variable %qE cannot be %<threadprivate%>"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "автоматическая переменная %qE не может быть %<threadprivate%>"
  
  #: c/c-parser.c:17240 cp/semantics.c:7432
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<threadprivate%> %qE has incomplete type"
-msgstr "%Jпараметр %u имеет неполный тип"
+msgstr "%<threadprivate%> %qE имеет неполный тип"
  
  #: c/c-parser.c:17271
  #, gcc-internal-format
@@ -36112,8 +37682,9 @@ msgstr ""
  
  #: c/c-parser.c:17277
  #, fuzzy, gcc-internal-format
+#| msgid "#pragma GCC optimize is not allowed inside functions"
  msgid "pragma simd must be inside a function"
-msgstr "фигурные скобки внутри выражений допускаются только в теле функции"
+msgstr "#pragma GCC optimize не допускается внутри функций"
  
  #: c/c-parser.c:17321 cp/parser.c:37504
  #, fuzzy, gcc-internal-format
@@ -36123,9 +37694,9 @@ msgstr "селектор должен быть целой константой 
  
  #: c/c-parser.c:17323 cp/parser.c:37507
  #, fuzzy, gcc-internal-format
-#| msgid "requested alignment is not a power of 2"
+#| msgid "stack size must be an exact power of 2"
  msgid "vectorlength must be a power of 2"
-msgstr "выравнивание не является степенью числа 2"
+msgstr "размер стека должен быть точной степенью 2"
  
  #: c/c-parser.c:17406 cp/parser.c:37614
  #, fuzzy, gcc-internal-format
@@ -36135,8 +37706,9 @@ msgstr "селектор должен быть целой константой 
  
  #: c/c-parser.c:17505 cp/parser.c:37707
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<#pragma omp%> clause"
  msgid "expected %<#pragma simd%> clause"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<{%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8f %<#pragma omp%>"
  
  #: c/c-parser.c:17549 cp/parser.c:37156
  #, fuzzy, gcc-internal-format
@@ -36147,27 +37719,27 @@ msgstr "некорректно употреблять %<#pragma%>"
  #: c/c-parser.c:17849 cp/parser.c:37048
  #, gcc-internal-format
  msgid "%<__transaction_cancel%> without transactional memory support enabled"
-msgstr ""
+msgstr "%<__transaction_cancel%> без включения транзакционной памяти"
  
  #: c/c-parser.c:17855 cp/parser.c:37054
  #, gcc-internal-format
  msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>"
-msgstr ""
+msgstr "%<__transaction_cancel%> внутри %<__transaction_relaxed%>"
  
  #: c/c-parser.c:17864 cp/parser.c:37063
  #, gcc-internal-format
  msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>"
-msgstr ""
+msgstr "внешний %<__transaction_cancel%> не внутри внешнего %<__transaction_atomic%>"
  
  #: c/c-parser.c:17866 cp/parser.c:37066
  #, gcc-internal-format
  msgid "  or a %<transaction_may_cancel_outer%> function"
-msgstr ""
+msgstr "  либо %<transaction_may_cancel_outer%> функция"
  
  #: c/c-parser.c:17872 cp/parser.c:37072
  #, gcc-internal-format
  msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>"
-msgstr ""
+msgstr "%<__transaction_cancel%> не внутри %<__transaction_atomic%>"
  
  #: c/c-parser.c:17940 cp/cp-array-notation.c:1407
  #, fuzzy, gcc-internal-format
@@ -36177,8 +37749,9 @@ msgstr "размер в new для массива должен иметь цел
  
  #: c/c-parser.c:17949 cp/parser.c:7013
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<:%> before numeric constant"
  msgid "expected %<:%> or numeral"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<:%> Ð¸Ð»Ð¸ %<...%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<:%> Ð¿ÐµÑ\80ÐµÐ´ Ñ\87Ð¸Ñ\81Ð»Ð¾Ð²Ð¾Ð¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
  
  #: c/c-parser.c:17960
  #, gcc-internal-format
@@ -36203,8 +37776,9 @@ msgstr ""
  
  #: c/c-parser.c:18038 c/c-parser.c:18041
  #, fuzzy, gcc-internal-format
+#| msgid "expected boolean expression"
  msgid "expected array notation expression"
-msgstr "ожидалось выражение"
+msgstr "ожидалось boolean выражение"
  
  #: c/c-typeck.c:217
  #, fuzzy, gcc-internal-format
@@ -36243,7 +37817,7 @@ msgstr "неправильное использование недоопреде
  #: c/c-typeck.c:329
  #, gcc-internal-format
  msgid "%qT and %qT are in disjoint named address spaces"
-msgstr ""
+msgstr "%qT и %qT - не связанные именованные адресные пространства"
  
  #: c/c-typeck.c:570 c/c-typeck.c:595
  #, gcc-internal-format
@@ -36253,22 +37827,23 @@ msgstr "с точки зрения ISO C типы функций не являю
  #: c/c-typeck.c:739
  #, gcc-internal-format
  msgid "can%'t mix operands of decimal float and vector types"
-msgstr ""
+msgstr "недопустимо смешивание операндов плавающего десятичного и векторного типа"
  
  #: c/c-typeck.c:744
  #, gcc-internal-format
  msgid "can%'t mix operands of decimal float and complex types"
-msgstr ""
+msgstr "недопустимо смешивание операндов плавающего десятичного и комплексного типа"
  
  #: c/c-typeck.c:749
  #, gcc-internal-format
  msgid "can%'t mix operands of decimal float and other float types"
-msgstr ""
+msgstr "недопустимо смешивание операндов плавающего десятичного и другого плавающего типа"
  
  #: c/c-typeck.c:1246
  #, fuzzy, gcc-internal-format
+#| msgid "pointer target types incompatible in C++"
  msgid "pointers to arrays with different qualifiers are incompatible in ISO C"
-msgstr "Ñ\82Ð¸Ð¿ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° `%T::' Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 Ñ\82Ð¸Ð¿Ð¾Ð¼ Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð° %qT"
+msgstr "Ñ\83ÐºÐ°Ð·Ñ\83ÐµÐ¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8b Ð² C++"
  
  #: c/c-typeck.c:1250
  #, gcc-internal-format
@@ -36276,9 +37851,9 @@ msgid "types are not quite compatible"
  msgstr "типы не вполне совместимы"
  
  #: c/c-typeck.c:1254
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "pointer target types incompatible in C++"
-msgstr "Ñ\82Ð¸Ð¿ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° `%T::' Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 Ñ\82Ð¸Ð¿Ð¾Ð¼ Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð° %qT"
+msgstr "Ñ\83ÐºÐ°Ð·Ñ\83ÐµÐ¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8b Ð² C++"
  
  #: c/c-typeck.c:1586
  #, gcc-internal-format
@@ -36288,7 +37863,7 @@ msgstr "типы возвращаемых значений функции нес
  #: c/c-typeck.c:1836
  #, gcc-internal-format
  msgid "converting an array compound literal to a pointer is ill-formed in C++"
-msgstr ""
+msgstr "конвертация составного литерала-массива в указатель не годится в C++"
  
  #: c/c-typeck.c:2347
  #, fuzzy, gcc-internal-format
@@ -36339,9 +37914,9 @@ msgid "rank of the array's index is greater than 1"
  msgstr "выравнивание элементов массива превышает их размер"
  
  #: c/c-typeck.c:2552
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "subscripted value is neither array nor pointer nor vector"
-msgstr "индексируемый объект не является ни массивом, ни указателем"
+msgstr "индексируемый объект не является ни массивом, ни указателем, ни вектором"
  
  #: c/c-typeck.c:2562 cp/typeck.c:3150 cp/typeck.c:3237
  #, gcc-internal-format
@@ -36366,7 +37941,7 @@ msgstr "в ISO C индексирование не-lvalue массива зап
  #: c/c-typeck.c:2738
  #, gcc-internal-format
  msgid "enum constant defined here"
-msgstr ""
+msgstr "константа перечислимого типа определена здесь"
  
  #: c/c-typeck.c:2844 cp/typeck.c:1638
  #, gcc-internal-format
@@ -36375,16 +37950,19 @@ msgstr ""
  
  #: c/c-typeck.c:2994
  #, fuzzy, gcc-internal-format
+#| msgid "called object %qE is not a function"
  msgid "called object %qE is not a function or function pointer"
  msgstr "вызываемый объект %qE не является функцией"
  
  #: c/c-typeck.c:2999
  #, fuzzy, gcc-internal-format
+#| msgid "called object %qE is not a function"
  msgid "called object %qD is not a function or function pointer"
  msgstr "вызываемый объект %qE не является функцией"
  
  #: c/c-typeck.c:3005
  #, fuzzy, gcc-internal-format
+#| msgid "called object %qE is not a function"
  msgid "called object is not a function or function pointer"
  msgstr "вызываемый объект %qE не является функцией"
  
@@ -36397,14 +37975,14 @@ msgid "function called through a non-compatible type"
  msgstr "вызов функции через несовместимый тип"
  
  #: c/c-typeck.c:3040 c/c-typeck.c:3087
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "function with qualified void return type called"
-msgstr "в определении функции задан квалифицированный void-тип возвращаемого значения"
+msgstr "вызов функции, имеющей квалифицированный void-тип возвращаемого значения"
  
  #: c/c-typeck.c:3211
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too many arguments to method %qE"
-msgstr "слишком много аргументов в вызове функции %qE"
+msgstr "слишком много аргументов в вызове метода %qE"
  
  #: c/c-typeck.c:3249
  #, gcc-internal-format, gfc-internal-format
@@ -36447,9 +38025,9 @@ msgid "passing argument %d of %qE as %<float%> rather than %<double%> due to pro
  msgstr "аргумент %d %qE согласно прототипу будет передан как %<float%>, а не %<double%>"
  
  #: c/c-typeck.c:3336
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "passing argument %d of %qE as %qT rather than %qT due to prototype"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %d %qE Ñ\81Ð¾Ð³Ð»Ð°Ñ\81Ð½Ð¾ Ð¿Ñ\80Ð¾Ñ\82Ð¾Ñ\82Ð¸Ð¿Ñ\83 Ð±Ñ\83Ð´ÐµÑ\82 Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½ ÐºÐ°Ðº Ñ\86ÐµÐ»Ð¾Ðµ, Ð° Ð½Ðµ ÐºÐ¾Ð¼Ð¿Ð»ÐµÐºÑ\81Ð½Ð¾Ðµ"
+msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %d Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE ÐºÐ°Ðº %qT, Ð° Ð½Ðµ %qT Ñ\81Ð¾Ð³Ð»Ð°Ñ\81Ð½Ð¾ Ð¿Ñ\80Ð¾Ñ\82Ð¾Ñ\82Ð¸Ð¿Ñ\83"
  
  #: c/c-typeck.c:3358
  #, gcc-internal-format
@@ -36467,19 +38045,19 @@ msgid "passing argument %d of %qE as signed due to prototype"
  msgstr "аргумент %d %qE согласно прототипу будет передан как signed"
  
  #: c/c-typeck.c:3423 cp/call.c:6769
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "implicit conversion from %qT to %qT when passing argument to function"
-msgstr "неявная конверсия из %qT в %qT, запрещенная в C++"
+msgstr "неявная конверсия из %qT в %qT при передаче аргумента функции"
  
  #: c/c-typeck.c:3617 c/c-typeck.c:3622 cp/typeck.c:4534 cp/typeck.c:4776
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "comparison with string literal results in unspecified behavior"
-msgstr "для weak декларации %q+D после первого использования поведение системы не специфицировано"
+msgstr "сравнение со строковым литералом приводит к неопределенному поведению"
  
  #: c/c-typeck.c:3636
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "comparison between %qT and %qT"
-msgstr "сравнение между %q#T и %q#T"
+msgstr "сравнение между %qT и %qT"
  
  #: c/c-typeck.c:3685
  #, gcc-internal-format
@@ -36515,12 +38093,12 @@ msgstr "неверный тип аргумента для унарного `!'"
  #: c/c-typeck.c:4209
  #, gcc-internal-format
  msgid "increment of enumeration value is invalid in C++"
-msgstr ""
+msgstr "инкрементация значения перечислимого типа некорректна в C++"
  
  #: c/c-typeck.c:4212
  #, gcc-internal-format
  msgid "decrement of enumeration value is invalid in C++"
-msgstr ""
+msgstr "декрементация значения перечислимого типа некорректна в C++"
  
  #: c/c-typeck.c:4228
  #, gcc-internal-format
@@ -36539,18 +38117,20 @@ msgstr "неверный тип аргумента декрементации"
  
  #: c/c-typeck.c:4273
  #, fuzzy, gcc-internal-format
+#| msgid "cannot increment a pointer to incomplete type %qT"
  msgid "increment of pointer to an incomplete type %qT"
-msgstr "Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f %s указатель на неполный тип %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¸Ð½ÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c указатель на неполный тип %qT"
  
  #: c/c-typeck.c:4277
  #, fuzzy, gcc-internal-format
+#| msgid "cannot decrement a pointer to incomplete type %qT"
  msgid "decrement of pointer to an incomplete type %qT"
-msgstr "Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f %s указатель на неполный тип %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c указатель на неполный тип %qT"
  
  #: c/c-typeck.c:4381
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "taking address of expression of type %<void%>"
-msgstr "Ð°Ð´Ñ\80ÐµÑ\81 Ð¾Ñ\82 Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹"
+msgstr "Ð²Ð·Ñ\8fÑ\82Ð¸Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð° Ð¾Ñ\82 Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ñ\82Ð¸Ð¿Ð° %<void%>"
  
  #: c/c-typeck.c:4439
  #, gcc-internal-format
@@ -36595,9 +38175,9 @@ msgid "non-lvalue array in conditional expression"
  msgstr "не lvalue-массив в условном выражении"
  
  #: c/c-typeck.c:4799 cp/call.c:5089
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "implicit conversion from %qT to %qT to match other result of conditional"
-msgstr "неявная конверсия из %qT в %qT, запрещенная в C++"
+msgstr "неявная конверсия из %qT в %qT для совместимости с другим результатом условного выражения"
  
  #: c/c-typeck.c:4873
  #, gcc-internal-format
@@ -36605,9 +38185,9 @@ msgid "ISO C forbids conditional expr with only one void side"
  msgstr "в ISO C запрещены условные выражения, где только одна из альтернатив имеет тип void"
  
  #: c/c-typeck.c:4890
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "pointers to disjoint address spaces used in conditional expression"
-msgstr "несоответствие указательных типов в условном выражении"
+msgstr "указатели на не связанные адресные пространства в условном выражении"
  
  #: c/c-typeck.c:4901 c/c-typeck.c:4918
  #, fuzzy, gcc-internal-format
@@ -36632,8 +38212,9 @@ msgstr "несоответствие типов указатель/целое в
  
  #: c/c-typeck.c:5059 cp/typeck.c:6436
  #, fuzzy, gcc-internal-format
+#| msgid "a function call cannot appear in a constant-expression"
  msgid "spawned function call cannot be part of a comma expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "вызов функции не может присутствовать в константном выражении"
  
  #: c/c-typeck.c:5093
  #, gcc-internal-format
@@ -36647,19 +38228,19 @@ msgid "right-hand operand of comma expression has no effect"
  msgstr "левый операнд операции `запятая' не имеет побочных эффектов"
  
  #: c/c-typeck.c:5180
-#, fuzzy
  msgid "cast adds %q#v qualifier to function type"
-msgstr "Ð¿Ñ\80Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ðµ Ñ\82Ð¸Ð¿Ð° Ð´Ð¾Ð±Ð°Ð²Ð»Ñ\8fÐµÑ\82 Ð´Ð¾Ð¿Ð¾Ð»Ð½Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐµ ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ñ\8b к типу функции"
+msgstr "Ð¿Ñ\80Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ðµ Ñ\82Ð¸Ð¿Ð° Ð´Ð¾Ð±Ð°Ð²Ð»Ñ\8fÐµÑ\82 ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 %q#v к типу функции"
  
  #: c/c-typeck.c:5186
  #, fuzzy
+#| msgid "cast discards %q#v qualifier from pointer target type"
  msgid "cast discards %qv qualifier from pointer target type"
-msgstr "приведение типа отменяет квалификаторы указуемого типа"
+msgstr "приведение типа отменяет квалификатор %q#v указуемого типа"
  
  #: c/c-typeck.c:5221
  #, gcc-internal-format
  msgid "to be safe all intermediate pointers in cast from %qT to %qT must be %<const%> qualified"
-msgstr ""
+msgstr "для надежности все промежуточные указатели в приведении типа от %qT к %qT должны быть снабжены квалификатором %<const%>"
  
  #: c/c-typeck.c:5258
  #, gcc-internal-format
@@ -36689,17 +38270,17 @@ msgstr "приведение к типу объединения от типа, 
  #: c/c-typeck.c:5344
  #, gcc-internal-format, gfc-internal-format
  msgid "cast to %s address space pointer from disjoint generic address space pointer"
-msgstr ""
+msgstr "приведение типа к указателю на адресное пространство %s от указателя на не связанное общее адресное пространство"
  
  #: c/c-typeck.c:5349
  #, gcc-internal-format, gfc-internal-format
  msgid "cast to generic address space pointer from disjoint %s address space pointer"
-msgstr ""
+msgstr "приведение типа к указателю на общее адресное пространство от указателя на не связанное адресное пространство %s"
  
  #: c/c-typeck.c:5354
  #, gcc-internal-format, gfc-internal-format
  msgid "cast to %s address space pointer from disjoint %s address space pointer"
-msgstr ""
+msgstr "приведение типа к указателю на адресное пространство %s от указателя на не связанное адресное пространство %s"
  
  #: c/c-typeck.c:5373
  #, gcc-internal-format
@@ -36734,7 +38315,7 @@ msgstr "ISO C запрещает преобразование указателя
  #: c/c-typeck.c:5508
  #, gcc-internal-format
  msgid "defining a type in a cast is invalid in C++"
-msgstr ""
+msgstr "определение типа в приведении типа некорректно в C++"
  
  #: c/c-typeck.c:5550
  #, fuzzy, gcc-internal-format
@@ -36745,7 +38326,7 @@ msgstr "подавление присваивания"
  #: c/c-typeck.c:5673 c/c-typeck.c:6113
  #, gcc-internal-format
  msgid "enum conversion in assignment is invalid in C++"
-msgstr ""
+msgstr "преобразование перечислимого типа в присваивании некорректно в C++"
  
  #: c/c-typeck.c:5865 c/c-typeck.c:5883 c/c-typeck.c:5902
  #, gcc-internal-format
@@ -36769,24 +38350,24 @@ msgstr "инициализация символьного массива стр
  #. compile time.  It is the same as PEDWARN_FOR_QUALIFIERS but uses
  #. warning_at instead of pedwarn.
  #: c/c-typeck.c:5993 c/c-typeck.c:6022 c/c-typeck.c:6051 c/c-typeck.c:6629
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %qT but argument is of type %qT"
-msgstr "формат %q.*s предполагает тип %<%T%s%>, но аргумент %d имеет тип %qT"
+msgstr "ожидался тип %qT, но аргумент имеет тип %qT"
  
  #: c/c-typeck.c:6111
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "enum conversion when passing argument %d of %qE is invalid in C++"
-msgstr "Ð¿Ñ\80Ð¸ Ð¿ÐµÑ\80ÐµÐ´Ð°Ñ\87Ðµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %d %qE: Ñ\83ÐºÐ°Ð·Ñ\83ÐµÐ¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ñ\80Ð°Ð·Ð»Ð¸Ñ\87Ð°Ñ\8eÑ\82Ñ\81Ñ\8f Ð·Ð½Ð°ÐºÐ¾Ð²Ð¾Ñ\81Ñ\82Ñ\8cÑ\8e"
+msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»Ð¸Ð¼Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° Ð¿Ñ\80Ð¸ Ð¿ÐµÑ\80ÐµÐ´Ð°Ñ\87Ðµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %d %qE Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾ Ð² C++"
  
  #: c/c-typeck.c:6115 c/c-typeck.c:8711
  #, gcc-internal-format
  msgid "enum conversion in initialization is invalid in C++"
-msgstr ""
+msgstr "преобразование типов в инициализаторе недопустимо в C++"
  
  #: c/c-typeck.c:6117
  #, gcc-internal-format
  msgid "enum conversion in return is invalid in C++"
-msgstr ""
+msgstr "преобразование типов в операторе return недопустимо в C++"
  
  #: c/c-typeck.c:6148
  #, gcc-internal-format
@@ -36794,44 +38375,36 @@ msgid "cannot pass rvalue to reference parameter"
  msgstr "передача rvalue-выражения в качестве параметра-ссылки запрещена"
  
  #: c/c-typeck.c:6281 c/c-typeck.c:6546
-#, fuzzy
  msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified"
-msgstr "передача аргумента %d %qE добавляет квалификатор к указателю на функцию без квалификаторов"
+msgstr "передача аргумента %d функции %qE добавляет квалификатор %q#v к указателю на функцию без квалификаторов"
  
  #: c/c-typeck.c:6284 c/c-typeck.c:6549
-#, fuzzy
  msgid "assignment makes %q#v qualified function pointer from unqualified"
-msgstr "присваивание добавляет квалификатор к указателю на функцию без квалификаторов"
+msgstr "присваивание добавляет квалификатор %q#v к указателю на функцию без квалификаторов"
  
  #: c/c-typeck.c:6287 c/c-typeck.c:6551
-#, fuzzy
  msgid "initialization makes %q#v qualified function pointer from unqualified"
-msgstr "инициализация добавляет квалификатор к указателю на функцию без квалификаторов"
+msgstr "инициализация добавляет квалификатор %q#v к указателю на функцию без квалификаторов"
  
  #: c/c-typeck.c:6290 c/c-typeck.c:6553
-#, fuzzy
  msgid "return makes %q#v qualified function pointer from unqualified"
-msgstr "возврат значения добавляет квалификатор к указателю на функцию без квалификаторов"
+msgstr "возврат значения добавляет квалификатор %q#v к указателю на функцию без квалификаторов"
  
  #: c/c-typeck.c:6298 c/c-typeck.c:6465 c/c-typeck.c:6508
-#, fuzzy
  msgid "passing argument %d of %qE discards %qv qualifier from pointer target type"
-msgstr "передача аргумента %d %qE отменяет квалификаторы указуемого типа"
+msgstr "передача аргумента %d %qE отменяет квалификатор %qv указуемого типа"
  
  #: c/c-typeck.c:6300 c/c-typeck.c:6467 c/c-typeck.c:6510
-#, fuzzy
  msgid "assignment discards %qv qualifier from pointer target type"
-msgstr "присваивание отменяет квалификаторы указуемого типа"
+msgstr "присваивание отменяет квалификатор %qv указуемого типа"
  
  #: c/c-typeck.c:6302 c/c-typeck.c:6469 c/c-typeck.c:6512
-#, fuzzy
  msgid "initialization discards %qv qualifier from pointer target type"
-msgstr "инициализация отменяет квалификаторы указуемого типа"
+msgstr "инициализация отменяет квалификатор %qv указуемого типа"
  
  #: c/c-typeck.c:6304 c/c-typeck.c:6471 c/c-typeck.c:6514
-#, fuzzy
  msgid "return discards %qv qualifier from pointer target type"
-msgstr "возврат результата отменяет квалификаторы указуемого типа"
+msgstr "возврат результата отменяет квалификатор %qv указуемого типа"
  
  #: c/c-typeck.c:6313
  #, gcc-internal-format
@@ -36844,24 +38417,24 @@ msgid "request for implicit conversion from %qT to %qT not permitted in C++"
  msgstr "неявная конверсия из %qT в %qT, запрещенная в C++"
  
  #: c/c-typeck.c:6387
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "passing argument %d of %qE from pointer to non-enclosed address space"
-msgstr "Ð² Ð¿ÐµÑ\80ÐµÐ´Ð°Ñ\87Ðµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %d %qE: Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f"
+msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ñ\87Ð° Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %d %qE Ð¿Ð¾ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8e Ð½Ð° Ð½Ðµ Ð·Ð°Ð¼ÐºÐ½Ñ\83Ñ\82Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ð¾"
  
  #: c/c-typeck.c:6391
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "assignment from pointer to non-enclosed address space"
-msgstr "приведение указателя к целому другого размера"
+msgstr "присваивание по указателю на не замкнутое адресное пространство"
  
  #: c/c-typeck.c:6395
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "initialization from pointer to non-enclosed address space"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸"
+msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð¾ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8e Ð½Ð° Ð½Ðµ Ð·Ð°Ð¼ÐºÐ½Ñ\83Ñ\82Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ð¾"
  
  #: c/c-typeck.c:6399
  #, gcc-internal-format
  msgid "return from pointer to non-enclosed address space"
-msgstr ""
+msgstr "возврат значения по указателю на не замкнутое адресное пространство"
  
  #: c/c-typeck.c:6417
  #, gcc-internal-format
@@ -36991,19 +38564,19 @@ msgid "return makes integer from pointer without a cast"
  msgstr "при возврате результата указатель преобразуется в целое без приведения типа"
  
  #: c/c-typeck.c:6632
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "incompatible types when assigning to type %qT from type %qT"
-msgstr "несовместимые типы в присваивании %qT -> %qT"
+msgstr "несовместимые типы в присваивании типу %qT значения типа %qT"
  
  #: c/c-typeck.c:6637
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "incompatible types when initializing type %qT using type %qT"
-msgstr "несовместимые типы при инициализации"
+msgstr "несовместимые типы при инициализации типа %qT, используя тип %qT"
  
  #: c/c-typeck.c:6642
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "incompatible types when returning type %qT but %qT was expected"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ %qT -> %qT"
+msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð¿Ñ\80Ð¸ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ñ\82Ð¸Ð¿Ð° %qT Ð²Ð¼ÐµÑ\81Ñ\82Ð¾ Ð¾Ð¶Ð¸Ð´Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
  
  #: c/c-typeck.c:6706
  #, gcc-internal-format
@@ -37021,14 +38594,14 @@ msgid "char-array initialized from wide string"
  msgstr "инициализация символьного массива строкой широких символов"
  
  #: c/c-typeck.c:6962
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "wide character array initialized from non-wide string"
-msgstr "Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ð¾Ð² Ñ\82Ð¸Ð¿Ð° wchar_t Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾Ð¹ Ð¾Ð±Ñ\8bÑ\87Ð½Ñ\8bх символов"
+msgstr "Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ñ\88Ð¸Ñ\80Ð¾ÐºÐ¸Ñ\85 Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ð¾Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ð½Ðµ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾Ð¹ Ñ\88Ð¸Ñ\80Ð¾ÐºÐ¸х символов"
  
  #: c/c-typeck.c:6968
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "wide character array initialized from incompatible wide string"
-msgstr "Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ð¾Ð² Ñ\82Ð¸Ð¿Ð° wchar_t Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾Ð¹ Ð¾Ð±Ñ\8bÑ\87Ð½Ñ\8bх символов"
+msgstr "Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ñ\88Ð¸Ñ\80Ð¾ÐºÐ¸Ñ\85 Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ð¾Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ð¾Ð¹ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾Ð¹ Ñ\88Ð¸Ñ\80Ð¾ÐºÐ¸х символов"
  
  #: c/c-typeck.c:7002
  #, gcc-internal-format
@@ -37047,9 +38620,9 @@ msgid "array initialized from non-constant array expression"
  msgstr "инициализация массива неконстантным выражением"
  
  #: c/c-typeck.c:7129 c/c-typeck.c:7177 c/c-typeck.c:8694
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "initializer element is not a constant expression"
-msgstr "Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
+msgstr "Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÐ¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸ÐµÐ¼"
  
  #: c/c-typeck.c:7171 c/c-typeck.c:8689
  #, gcc-internal-format
@@ -37088,6 +38661,7 @@ msgstr "отсутствуют фигурные скобки вокруг ини
  
  #: c/c-typeck.c:7875
  #, fuzzy, gcc-internal-format
+#| msgid "missing initializer for member %qD"
  msgid "missing initializer for field %qD of %qT"
  msgstr "отсутствует инициализатор для элемента %qD"
  
@@ -37117,9 +38691,9 @@ msgid "array index in initializer not of integer type"
  msgstr "индекс массива в инициализации не целого типа"
  
  #: c/c-typeck.c:8080 c/c-typeck.c:8089
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "array index in initializer is not an integer constant expression"
-msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð½Ðµ Ñ\86ÐµÐ»Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bÐ¼ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÐ¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸ÐµÐ¼"
  
  #: c/c-typeck.c:8094 c/c-typeck.c:8096
  #, gcc-internal-format
@@ -37213,13 +38787,15 @@ msgstr "функция декларированная с атрибутом %<no
  
  #: c/c-typeck.c:9630 cp/cp-array-notation.c:1087
  #, fuzzy, gcc-internal-format
+#| msgid "a transaction expression cannot appear in a constant-expression"
  msgid "array notation expression cannot be used as a return value"
-msgstr "%qE нельзя использовать как функцию"
+msgstr "транзакционное выражение не может присутствовать в константном выражении"
  
  #: c/c-typeck.c:9637 cp/typeck.c:8643
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Logical range in CASE statement at %L is not allowed"
  msgid "use of %<_Cilk_spawn%> in a return statement is not allowed"
-msgstr ""
+msgstr "Логический диапазон в CASE операторе в %L не допускается"
  
  #: c/c-typeck.c:9665 c/c-typeck.c:9669
  #, gcc-internal-format
@@ -37232,9 +38808,9 @@ msgid "%<return%> with a value, in function returning void"
  msgstr "оператор %<return%> <значение> в функции возвращающей void"
  
  #: c/c-typeck.c:9686
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C forbids %<return%> with expression, in function returning void"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 %<return%> <Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ> Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ возвращающей void"
+msgstr "Ð² ISO C Ð·Ð°Ð¿Ñ\80ÐµÑ\89ÐµÐ½ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 %<return%> Ñ\81 Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸ÐµÐ¼ Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸, возвращающей void"
  
  #: c/c-typeck.c:9762
  #, fuzzy, gcc-internal-format
@@ -37253,9 +38829,9 @@ msgid "%<long%> switch expression not converted to %<int%> in ISO C"
  msgstr "в ISO C %<long%>-выражение в операторе switch не преобразуется в %<int%>"
  
  #: c/c-typeck.c:9916 c/c-typeck.c:9924
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "case label is not an integer constant expression"
-msgstr "размер массива не является целочисленным константным выражением"
+msgstr "case-метка не является целочисленным константным выражением"
  
  #: c/c-typeck.c:9930 cp/parser.c:10624
  #, gcc-internal-format
@@ -37288,9 +38864,9 @@ msgid "continue statement not within a loop"
  msgstr "оператор continue вне цикла"
  
  #: c/c-typeck.c:10141 cp/parser.c:11758
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "break statement used with OpenMP for loop"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 break Ð²Ð½Ðµ Ñ\86Ð¸ÐºÐ»Ð° Ð¸Ð»Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° switch"
+msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 break Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½ Ñ\81 OpenMP Ð´Ð»Ñ\8f Ñ\86Ð¸ÐºÐ»Ð°"
  
  #: c/c-typeck.c:10146
  #, fuzzy, gcc-internal-format
@@ -37315,14 +38891,14 @@ msgid "expression statement has incomplete type"
  msgstr "оператор-выражение имеет неполный тип"
  
  #: c/c-typeck.c:11019 c/c-typeck.c:11176 cp/typeck.c:4790
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "comparing vectors with different element types"
-msgstr "Предупреждать о отступлениях от стиля Effective C++"
+msgstr "сравнение векторов с разными типами элементов"
  
  #: c/c-typeck.c:11026 c/c-typeck.c:11183 cp/typeck.c:4802
  #, gcc-internal-format
  msgid "comparing vectors with different number of elements"
-msgstr ""
+msgstr "сравнение векторов с разным числом элементов"
  
  #: c/c-typeck.c:11057 cp/typeck.c:4528
  #, gcc-internal-format
@@ -37332,17 +38908,17 @@ msgstr "сравнение плавающих значений при помощ
  #: c/c-typeck.c:11074 c/c-typeck.c:11094
  #, gcc-internal-format
  msgid "the comparison will always evaluate as %<false%> for the address of %qD will never be NULL"
-msgstr ""
+msgstr "результат сравнения всегда %<false%>, поскольку адрес %qD не может быть NULL"
  
  #: c/c-typeck.c:11080 c/c-typeck.c:11100
  #, gcc-internal-format
  msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL"
-msgstr ""
+msgstr "результат сравнения всегда %<true%>, поскольку адрес %qD не может быть NULL"
  
  #: c/c-typeck.c:11121 c/c-typeck.c:11241
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "comparison of pointers to disjoint address spaces"
-msgstr "Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ Ñ\80Ð°Ð·Ð»Ð¸Ñ\87Ð½Ñ\8bÑ\85 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÑ\85 Ñ\82Ð¸Ð¿Ð¾Ð² Ð±ÐµÐ· Ð¿Ñ\80Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ñ\8f Ñ\82Ð¸Ð¿Ð¾Ð²"
+msgstr "Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¹ Ð½Ð° Ð½ÐµÑ\81Ð²Ñ\8fÐ·Ð°Ð½Ð½Ñ\8bÐµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ñ\8bÐµ Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ð°"
  
  #: c/c-typeck.c:11128 c/c-typeck.c:11134
  #, gcc-internal-format
@@ -37370,9 +38946,9 @@ msgid "ISO C forbids ordered comparisons of pointers to functions"
  msgstr "ISO C разрешает сравнение указателей на функции только на равенство/неравенство"
  
  #: c/c-typeck.c:11236
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ordered comparison of pointer with null pointer"
-msgstr "упорядоченное сравнение указателя с целочисленным нулем"
+msgstr "упорядоченное сравнение указателя с нулевым указателем"
  
  #: c/c-typeck.c:11259 c/c-typeck.c:11262 c/c-typeck.c:11269 c/c-typeck.c:11272
  #: cp/typeck.c:4853 cp/typeck.c:4860
@@ -37381,9 +38957,9 @@ msgid "ordered comparison of pointer with integer zero"
  msgstr "упорядоченное сравнение указателя с целочисленным нулем"
  
  #: c/c-typeck.c:11323 cp/typeck.c:4939
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "implicit conversion from %qT to %qT to match other operand of binary expression"
-msgstr "неявная конверсия из %qT в %qT, запрещенная в C++"
+msgstr "неявная конверсия из %qT в %qT для совместимости с другим операндом бинарного выражения"
  
  #: c/c-typeck.c:11636
  #, gcc-internal-format
@@ -37401,9 +38977,9 @@ msgid "used union type value where scalar is required"
  msgstr "объединение употреблено в контексте, где допустимо только скалярное значение"
  
  #: c/c-typeck.c:11660
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "used vector type where scalar is required"
-msgstr "структурное значение употреблено в контексте, где допустимо только скалярное значение"
+msgstr "векторный тип использован в контексте, где допустимо только скалярное значение"
  
  #: c/c-typeck.c:11850 cp/semantics.c:8512
  #, gcc-internal-format
@@ -37430,20 +39006,23 @@ msgstr "%qD не является шаблонным элементом-функ
  
  #: c/c-typeck.c:11958 cp/semantics.c:4534 cp/semantics.c:6667
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not a variable in clause %qs"
  msgid "%qD is not a variable in %qs clause"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qD не есть переменная в клаузуле %qs"
  
  #: c/c-typeck.c:11962 c/c-typeck.c:13079 cp/semantics.c:4538
  #: cp/semantics.c:6670
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is not a variable in clause %qs"
  msgid "%qE is not a variable in %qs clause"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qE не является переменной в конструкции %qs"
  
  #: c/c-typeck.c:11970 c/c-typeck.c:13086 c/c-typeck.c:13171
  #: cp/semantics.c:4555 cp/semantics.c:6676 cp/semantics.c:6830
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not a variable in clause %qs"
  msgid "%qD is threadprivate variable in %qs clause"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qD не есть переменная в клаузуле %qs"
  
  #: c/c-typeck.c:11992 cp/semantics.c:4586
  #, fuzzy, gcc-internal-format
@@ -37460,8 +39039,9 @@ msgstr "размер в new для массива должен иметь цел
  #: c/c-typeck.c:12026 c/c-typeck.c:12090 c/c-typeck.c:12348
  #: cp/semantics.c:4629 cp/semantics.c:4693
  #, fuzzy, gcc-internal-format
+#| msgid "Array section in '%s' call at %L"
  msgid "zero length array section in %qs clause"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð² %s"
+msgstr "Ð¡ÐµÐºÑ\86Ð¸Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² '%s' Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ð² %L"
  
  #: c/c-typeck.c:12045 cp/semantics.c:4648
  #, gcc-internal-format
@@ -37476,8 +39056,9 @@ msgstr ""
  #: c/c-typeck.c:12062 c/c-typeck.c:12172 cp/semantics.c:4665
  #: cp/semantics.c:4775
  #, fuzzy, gcc-internal-format
+#| msgid "variable length array is used"
  msgid "negative length in array section in %qs clause"
-msgstr "используется массив переменного размера %qD"
+msgstr "используется массив переменного размера"
  
  #: c/c-typeck.c:12079 cp/semantics.c:4682
  #, gcc-internal-format
@@ -37496,19 +39077,22 @@ msgstr ""
  
  #: c/c-typeck.c:12164 cp/semantics.c:4767
  #, fuzzy, gcc-internal-format
+#| msgid "for increment expression has no effect"
  msgid "for pointer type length expression must be specified"
-msgstr "левый операнд операции `запятая' не имеет побочных эффектов"
+msgstr "for инкрементное выражение не имеет эффекта"
  
  #: c/c-typeck.c:12182 c/c-typeck.c:12291 cp/semantics.c:4785
  #: cp/semantics.c:4897
  #, fuzzy, gcc-internal-format
+#| msgid "Copy array sections into a contiguous block on procedure entry"
  msgid "array section is not contiguous in %qs clause"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð\9fÑ\80Ð¸ Ð²Ñ\85Ð¾Ð´Ðµ Ð² Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 ÐºÐ¾Ð¿Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81ÐµÐºÑ\86Ð¸Ð¸ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾Ð² Ð² Ð¿Ð¾Ñ\81Ð»ÐµÐ´Ð¾Ð²Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ð±Ð»Ð¾Ðº"
  
  #: c/c-typeck.c:12190 cp/semantics.c:4793
  #, fuzzy, gcc-internal-format
+#| msgid "%qD does not have integral or enumeration type"
  msgid "%qE does not have pointer or array type"
-msgstr "выражение в деклараторе new должно иметь целый или перечислимый тип"
+msgstr "%qD не имеет целый или перечислимый тип"
  
  #: c/c-typeck.c:12568 c/c-typeck.c:12578
  #, gcc-internal-format
@@ -37518,7 +39102,7 @@ msgstr ""
  #: c/c-typeck.c:12636
  #, gcc-internal-format
  msgid "%qE has invalid type for %<reduction(%s)%>"
-msgstr ""
+msgstr "%qE имеет недопустимый тип для %<reduction(%s)%>"
  
  #: c/c-typeck.c:12645 cp/semantics.c:5704
  #, gcc-internal-format
@@ -37527,8 +39111,9 @@ msgstr ""
  
  #: c/c-typeck.c:12733
  #, fuzzy, gcc-internal-format
+#| msgid "variable length array is used"
  msgid "variable length element type in array %<reduction%> clause"
-msgstr "используется массив переменного размера %qD"
+msgstr "используется массив переменного размера"
  
  #: c/c-typeck.c:12751 c/c-typeck.c:13229 cp/semantics.c:7146
  #, gcc-internal-format
@@ -37538,7 +39123,7 @@ msgstr ""
  #: c/c-typeck.c:12763 cp/semantics.c:7186
  #, gcc-internal-format
  msgid "%qE must be %<threadprivate%> for %<copyin%>"
-msgstr ""
+msgstr "%qE должно быть %<threadprivate%> для %<copyin%>"
  
  #: c/c-typeck.c:12777 cp/semantics.c:5866
  #, gcc-internal-format
@@ -37557,36 +39142,38 @@ msgstr ""
  
  #: c/c-typeck.c:12835 c/c-typeck.c:13164 cp/semantics.c:6017
  #: cp/semantics.c:6823
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a variable in clause %qs"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qE не является переменной в конструкции %qs"
  
  #: c/c-typeck.c:12844 c/c-typeck.c:12871 c/c-typeck.c:12897
  #, gcc-internal-format
  msgid "%qE appears more than once in data clauses"
-msgstr ""
+msgstr "%qE встречается более одного раза в конструкции данных"
  
  #: c/c-typeck.c:12850 c/c-typeck.c:12876 c/c-typeck.c:13120 c/c-typeck.c:13137
  #: cp/semantics.c:6031 cp/semantics.c:6083 cp/semantics.c:6729
  #: cp/semantics.c:6746
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%qD appears more than once in data clauses"
  msgid "%qD appears both in data and map clauses"
-msgstr ""
+msgstr "%qD появляется более одного раза в клаузуле данных"
  
  #: c/c-typeck.c:12864 cp/semantics.c:6072
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a variable in clause %<firstprivate%>"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "%qE не является переменной в конструкции %<firstprivate%>"
  
  #: c/c-typeck.c:12890 cp/semantics.c:6111
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a variable in clause %<lastprivate%>"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "%qE не является переменной в конструкции %<lastprivate%>"
  
  #: c/c-typeck.c:12909 cp/semantics.c:6461
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is not a variable in clause %qs"
  msgid "%qE is not a variable in %<aligned%> clause"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qE не является переменной в конструкции %qs"
  
  #: c/c-typeck.c:12916
  #, fuzzy, gcc-internal-format
@@ -37595,68 +39182,79 @@ msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
  msgstr "тип, заданный в векторном delete, не является ни массивом, ни указателем"
  
  #: c/c-typeck.c:12923
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%qE appears more than once in data clauses"
  msgid "%qE appears more than once in %<aligned%> clauses"
-msgstr ""
+msgstr "%qE встречается более одного раза в конструкции данных"
  
  #: c/c-typeck.c:12978 cp/semantics.c:6543
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is not a variable in clause %qs"
  msgid "%qE is not a variable in %<depend%> clause"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qE не является переменной в конструкции %qs"
  
  #: c/c-typeck.c:13000 cp/semantics.c:6574
  #, fuzzy, gcc-internal-format
+#| msgid "Array section not permitted in '%s' call at %L"
  msgid "array section does not have mappable type in %qs clause"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð¡ÐµÐºÑ\86Ð¸Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\80Ð°Ð·Ñ\80ÐµÑ\88ÐµÐ½Ð° Ð² '%s' Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ð² %L"
  
  #: c/c-typeck.c:13017 c/c-typeck.c:13129 cp/semantics.c:6591
  #: cp/semantics.c:6738
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%qD appears more than once in data clauses"
  msgid "%qD appears more than once in motion clauses"
-msgstr ""
+msgstr "%qD появляется более одного раза в клаузуле данных"
  
  #: c/c-typeck.c:13020 c/c-typeck.c:13131 cp/semantics.c:6594
  #: cp/semantics.c:6740
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%qD appears more than once in data clauses"
  msgid "%qD appears more than once in map clauses"
-msgstr ""
+msgstr "%qD появляется более одного раза в клаузуле данных"
  
  #: c/c-typeck.c:13052 cp/semantics.c:6634
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is not a variable in clause %qs"
  msgid "%qE does not have a mappable type in %qs clause"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qE не является переменной в конструкции %qs"
  
  #: c/c-typeck.c:13105 c/c-typeck.c:13178 cp/semantics.c:6706
  #: cp/semantics.c:6837
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not a variable in clause %qs"
  msgid "%qD does not have a mappable type in %qs clause"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qD не есть переменная в клаузуле %qs"
  
  #: c/c-typeck.c:13115 cp/semantics.c:6025 cp/semantics.c:6078
  #: cp/semantics.c:6117 cp/semantics.c:6724
  #, gcc-internal-format
  msgid "%qD appears more than once in data clauses"
-msgstr ""
+msgstr "%qD появляется более одного раза в клаузуле данных"
  
  #: c/c-typeck.c:13159 cp/semantics.c:6817
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is not a variable in clause %qs"
  msgid "%qE is neither a variable nor a function name in clause %qs"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qE не является переменной в конструкции %qs"
  
  #: c/c-typeck.c:13187 cp/semantics.c:6846
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%qE appears more than once in data clauses"
  msgid "%qE appears more than once on the same %<declare target%> directive"
-msgstr ""
+msgstr "%qE встречается более одного раза в конструкции данных"
  
  #: c/c-typeck.c:13201 cp/semantics.c:6861
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not a variable in clause %qs"
  msgid "%qD is not an argument in %<uniform%> clause"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qD не есть переменная в клаузуле %qs"
  
  #: c/c-typeck.c:13204 cp/semantics.c:6863
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is not a variable in clause %qs"
  msgid "%qE is not an argument in %<uniform%> clause"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qE не является переменной в конструкции %qs"
  
  #: c/c-typeck.c:13219
  #, fuzzy, gcc-internal-format
@@ -37677,7 +39275,7 @@ msgstr ""
  #: c/c-typeck.c:13375 cp/semantics.c:7229
  #, gcc-internal-format
  msgid "%qE is predetermined %qs for %qs"
-msgstr ""
+msgstr "%qE является предопределенным %qs для %qs"
  
  #: c/c-typeck.c:13395 cp/semantics.c:7120
  #, gcc-internal-format
@@ -37708,23 +39306,25 @@ msgstr "первый аргумент %<va_start%> должен иметь ти
  #: c/c-typeck.c:13564
  #, gcc-internal-format
  msgid "C++ requires promoted type, not enum type, in %<va_arg%>"
-msgstr ""
+msgstr "в C++ требуется расширенный тип, а не перечислимый тип в %<va_arg%>"
  
  #. A bad conversion for 'this' must be discarding cv-quals.
  #: cp/call.c:3313
  #, fuzzy, gcc-internal-format
+#| msgid "passing %qT as %<this%> argument of %q#D discards qualifiers"
  msgid "  passing %qT as %<this%> argument discards qualifiers"
-msgstr "передача %qT как `this'-аргумента `%#D' отменяет квалификаторы"
+msgstr "передача %qT как аргумент %<this%> %q#D отменяет квалификаторы"
  
  #: cp/call.c:3317
  #, gcc-internal-format
  msgid "  no known conversion for implicit %<this%> parameter from %qT to %qT"
-msgstr ""
+msgstr "  нет известных преобразований для неявного параметра %<this%> из %qT в %qT"
  
  #: cp/call.c:3324
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "  no known conversion for argument %d from %qT to %qT"
  msgid "  conversion of argument %d would be ill-formed:"
-msgstr "  Ð¿Ñ\80Ð¸ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ð¸Ð· %qT Ð² %qT,"
+msgstr "  Ð½ÐµÑ\82 Ð¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÑ\85 Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¹ Ð´Ð»Ñ\8f Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %d Ð¸Ð· %qT Ð² %qT"
  
  #. Conversion of conversion function return value failed.
  #: cp/call.c:3331
@@ -37734,78 +39334,78 @@ msgid "  no known conversion from %qT to %qT"
  msgstr "  при преобразовании из %qT в %qT,"
  
  #: cp/call.c:3334
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  no known conversion for argument %d from %qT to %qT"
-msgstr "  Ð¿Ñ\80Ð¸ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ð¸Ð· %qT Ð² %qT,"
+msgstr "  Ð½ÐµÑ\82 Ð¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÑ\85 Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¹ Ð´Ð»Ñ\8f Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %d Ð¸Ð· %qT Ð² %qT"
  
  #: cp/call.c:3345 cp/pt.c:6094
  #, 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] ""
-msgstr[2] ""
+msgstr[0] "  кандидат ожидает %d аргумент, %d предоставлено"
+msgstr[1] "  кандидат ожидает %d аргумента, %d предоставлено"
+msgstr[2] "  кандидат ожидает %d аргументов, %d предоставлено"
  
  #: cp/call.c:3370
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s%D(%T, %T, %T) <built-in>"
-msgstr "%s %D(%T, %T, %T) <built-in>"
+msgstr "%s%D(%T, %T, %T) <built-in>"
  
  #: cp/call.c:3375
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s%D(%T, %T) <built-in>"
-msgstr "%s %D(%T, %T) <built-in>"
+msgstr "%s%D(%T, %T) <built-in>"
  
  #: cp/call.c:3379
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s%D(%T) <built-in>"
-msgstr "%s %D(%T) <built-in>"
+msgstr "%s%D(%T) <built-in>"
  
  #: cp/call.c:3383
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s%T <conversion>"
-msgstr "%s %T <conversion>"
+msgstr "%s%T <conversion>"
  
  #: cp/call.c:3385
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s%#D <near match>"
-msgstr "%J%s %+#D <near match>"
+msgstr "%s%#D <near match>"
  
  #: cp/call.c:3387
  #, gcc-internal-format
  msgid "%s%#D <deleted>"
-msgstr ""
+msgstr "%s%#D <deleted>"
  
  #: cp/call.c:3389
  #, gcc-internal-format
  msgid "%s%#D"
-msgstr ""
+msgstr "%s%#D"
  
  #: cp/call.c:3408
  #, gcc-internal-format
  msgid "  return type %qT of explicit conversion function cannot be converted to %qT with a qualification conversion"
-msgstr ""
+msgstr "  возвращаемый тип %qT функции явного преобразования не может быть преобразован в %qT посредством квалификационного преобразования"
  
  #: cp/call.c:3414
  #, gcc-internal-format
  msgid "  conversion from return type %qT of template conversion function specialization to %qT is not an exact match"
-msgstr ""
+msgstr "  преобразование из возвращаемого типа %qT спецификации шаблона функции преобразования в %qT не есть точное соответствие"
  
  #: cp/call.c:3425
  #, gcc-internal-format
  msgid "  substitution of deduced template arguments resulted in errors seen above"
-msgstr ""
+msgstr "  подстановка выведенных аргументов шаблона приводит к ошибкам обнаруженных ранее"
  
  #. Re-run template unification with diagnostics.
  #: cp/call.c:3430
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  template argument deduction/substitution failed:"
-msgstr "некорректный аргумент шаблона %d"
+msgstr "  вывод/подстановка аргумента шаблона неудачна:"
  
  #: cp/call.c:3444
  #, gcc-internal-format
  msgid "  a constructor taking a single argument of its own class type is invalid"
-msgstr ""
+msgstr "  конструктор, принимающий единственный аргумент собственного класса некорректен"
  
  #: cp/call.c:3808
  #, gcc-internal-format
@@ -37813,9 +39413,9 @@ msgid "conversion from %qT to %qT is ambiguous"
  msgstr "преобразование из %qT в %qT неоднозначно"
  
  #: cp/call.c:3935
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion from %qT to %qT not considered for non-type template argument"
-msgstr "Ð·Ð°Ð¿Ñ\80Ð¾Ñ\88ÐµÐ½Ð¾ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¾Ñ\82 %qT Ðº Ð½ÐµÑ\81ÐºÐ°Ð»Ñ\8fÑ\80Ð½Ð¾Ð¼Ñ\83 Ñ\82Ð¸Ð¿Ñ\83 %qT"
+msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT Ð½Ðµ Ñ\80Ð°Ñ\81Ñ\81Ð¼Ð°Ñ\82Ñ\80Ð¸Ð²Ð°ÐµÑ\82Ñ\81Ñ\8f Ð´Ð»Ñ\8f Ð½ÐµÑ\82Ð¸Ð¿Ð¾Ð²Ñ\8bÑ\85 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
  
  #: cp/call.c:4053
  #, gcc-internal-format
@@ -37846,23 +39446,27 @@ msgstr "вызов %<(%T) (%A)%> неоднозначен"
  
  #: cp/call.c:4423
  #, fuzzy, gcc-internal-format
+#| msgid "ambiguous overload for %qs in %<%s %E%>"
  msgid "ambiguous overload for "
-msgstr "%s для %qs в '%s %E'"
+msgstr "неоднозначная перегрузка для %qs в %<%s %E%>"
  
  #: cp/call.c:4424
  #, fuzzy, gcc-internal-format
+#| msgid "no match for %qs in %<%s %E%>"
  msgid "no match for "
-msgstr "%s для %qs в '%s %E'"
+msgstr "нет соответствия для %qs в %<%s %E%>"
  
  #: cp/call.c:4427
  #, fuzzy, gcc-internal-format
+#| msgid "invalid operands to binary %s (have %qT and %qT)"
  msgid " (operand types are %qT, %qT, and %qT)"
-msgstr "неверные операнды бинарной операции %s"
+msgstr "неверные операнды бинарной операции %s (%qT и %qT)"
  
  #: cp/call.c:4429
  #, fuzzy, gcc-internal-format
+#| msgid "invalid operands to binary %s (have %qT and %qT)"
  msgid " (operand types are %qT and %qT)"
-msgstr "неверные операнды бинарной операции %s"
+msgstr "неверные операнды бинарной операции %s (%qT и %qT)"
  
  #: cp/call.c:4431
  #, gcc-internal-format
@@ -37871,53 +39475,63 @@ msgstr ""
  
  #: cp/call.c:4451
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<operator%>"
  msgid "ternary %<operator?:%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<operator%>"
  
  #: cp/call.c:4455
  #, fuzzy, gcc-internal-format
+#| msgid "no match for ternary %<operator?:%> in %<%E ? %E : %E%>"
  msgid "ternary %<operator?:%> in %<%E ? %E : %E%>"
-msgstr "%s для трехиестного 'operator?:' в '%E ? %E : %E'"
+msgstr "нет соответствия для трехместного %<operator?:%> в %<%E ? %E : %E%>"
  
  #: cp/call.c:4464 cp/call.c:4495 cp/call.c:4504
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<operator%>"
  msgid "%<operator%s%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<operator%>"
  
  #: cp/call.c:4467
  #, fuzzy, gcc-internal-format
+#| msgid "no match for %<operator%s%> in %<%E%s%>"
  msgid "%<operator%s%> in %<%E%s%>"
-msgstr "%s для 'operator%s' в '%E%s'"
+msgstr "нет соответствия для %<operator%s%> в %<%E%s%>"
  
  #: cp/call.c:4474
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<operator%>"
  msgid "%<operator[]%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<operator%>"
  
  #: cp/call.c:4477
  #, fuzzy, gcc-internal-format
+#| msgid "no match for %<operator[]%> in %<%E[%E]%>"
  msgid "%<operator[]%> in %<%E[%E]%>"
-msgstr "%s для 'operator[]' в '%E[%E]'"
+msgstr "нет соответствия для %<operator[]%> в %<%E[%E]%>"
  
  #: cp/call.c:4485
  #, fuzzy, gcc-internal-format
+#| msgid "%s"
  msgid "%qs"
  msgstr "%s"
  
  #: cp/call.c:4488
  #, fuzzy, gcc-internal-format
+#| msgid "no match for %qs in %<%s %E%>"
  msgid "%qs in %<%s %E%>"
-msgstr "%s для %qs в '%s %E'"
+msgstr "нет соответствия для %qs в %<%s %E%>"
  
  #: cp/call.c:4498
  #, fuzzy, gcc-internal-format
+#| msgid "no match for %<operator%s%> in %<%E %s %E%>"
  msgid "%<operator%s%> in %<%E %s %E%>"
-msgstr "%s для 'operator%s' в '%E %s %E'"
+msgstr "нет соответствия для %<operator%s%> в %<%E %s %E%>"
  
  #: cp/call.c:4507
  #, fuzzy, gcc-internal-format
+#| msgid "no match for %<operator%s%> in %<%s%E%>"
  msgid "%<operator%s%> in %<%s%E%>"
-msgstr "%s для 'operator%s' в '%s%E'"
+msgstr "нет соответствия для %<operator%s%> в %<%s%E%>"
  
  #: cp/call.c:4616
  #, gcc-internal-format
@@ -37931,23 +39545,24 @@ msgstr ""
  
  #: cp/call.c:4752
  #, fuzzy, gcc-internal-format
+#| msgid "enumeral mismatch in conditional expression: %qT vs %qT"
  msgid "incompatible vector types in conditional expression: %qT, %qT and %qT"
  msgstr "несоответствие перечислимых типов в условном выражении: %qT vs %qT"
  
  #: cp/call.c:4842
  #, gcc-internal-format
  msgid "second operand to the conditional operator is of type %<void%>, but the third operand is neither a throw-expression nor of type %<void%>"
-msgstr ""
+msgstr "второй операнд условного оператора имеет тип %<void%>, но третий операнд не является ни throw-expression, ни элементом типа %<void%>"
  
  #: cp/call.c:4847
  #, gcc-internal-format
  msgid "third operand to the conditional operator is of type %<void%>, but the second operand is neither a throw-expression nor of type %<void%>"
-msgstr ""
+msgstr "третий операнд условного оператора имеет тип %<void%>, но второй операнд не является ни throw-expression, ни элементом типа %<void%>"
  
  #: cp/call.c:4898 cp/call.c:5014 cp/call.c:5157
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "operands to ?: have different types %qT and %qT"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f ?: Ð¸Ð¼ÐµÑ\8eÑ\82 Ñ\80Ð°Ð·Ð»Ð¸Ñ\87Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b"
+msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð´Ð»Ñ\8f ?: Ð¸Ð¼ÐµÑ\8eÑ\82 Ñ\80Ð°Ð·Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b %qT Ð¸ %qT"
  
  #: cp/call.c:4901
  #, gcc-internal-format
@@ -37965,14 +39580,14 @@ msgid "enumeral and non-enumeral type in conditional expression"
  msgstr "перечислимый и неперечислимый тип в условном выражении"
  
  #: cp/call.c:5577
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no %<%D(int)%> declared for postfix %qs, trying prefix operator instead"
-msgstr "нет декларации `%D(int)' для постфиксного %qs, попробуем применить соответствующую префиксную операцию"
+msgstr "нет %<%D(int)%> декларированного для постфиксного %qs, пробуем применить префиксный оператор"
  
  #: cp/call.c:5579
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no %<%D(int)%> declared for postfix %qs"
-msgstr "нет декларации `%D(int)' для постфиксного %qs, попробуем применить соответствующую префиксную операцию"
+msgstr "нет %<%D(int)%> декларированного для постфиксного %qs"
  
  #: cp/call.c:5685
  #, gcc-internal-format
@@ -37991,18 +39606,19 @@ msgstr ""
  
  #: cp/call.c:5994
  #, fuzzy, gcc-internal-format
+#| msgid "non-placement deallocation function %q+D"
  msgid "%qD is a usual (non-placement) deallocation function"
-msgstr "Ð½ÐµÑ\8fÐ²Ð½Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE"
+msgstr "Ð½ÐµÑ\80Ð°Ð·Ð¼ÐµÑ\89ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ð¾Ñ\81Ð²Ð¾Ð±Ð¾Ð¶Ð´ÐµÐ½Ð¸Ñ\8f %q+D"
  
  #: cp/call.c:6111
  #, gcc-internal-format
  msgid "no corresponding deallocation function for %qD"
-msgstr ""
+msgstr "нет соответствующей функции освобождения для %qD"
  
  #: cp/call.c:6117
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no suitable %<operator %s%> for %qT"
-msgstr "нет подходящего `operator %s' для %qT"
+msgstr "нет подходящего operator %s%> для %qT"
  
  #: cp/call.c:6139
  #, fuzzy, gcc-internal-format
@@ -38012,8 +39628,9 @@ msgstr "в данном контексте"
  
  #: cp/call.c:6141
  #, fuzzy, gcc-internal-format
+#| msgid "declared here"
  msgid "declared private here"
-msgstr "%q+D объявлено здесь"
+msgstr "объявлено здесь"
  
  #: cp/call.c:6145
  #, fuzzy, gcc-internal-format
@@ -38023,48 +39640,51 @@ msgstr "в данном контексте"
  
  #: cp/call.c:6147
  #, fuzzy, gcc-internal-format
+#| msgid "declared here"
  msgid "declared protected here"
-msgstr "%q+D объявлено здесь"
+msgstr "объявлено здесь"
  
  #: cp/call.c:6151
  #, fuzzy, gcc-internal-format
+#| msgid "%q+#D is inaccessible"
  msgid "%q#D is inaccessible within this context"
-msgstr "`%+#D' недоступен"
+msgstr "%q+#D недоступен"
  
  #: cp/call.c:6204
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "passing NULL to non-pointer argument %P of %qD"
-msgstr "переданное значение NULL используется для %s %P в %qD"
+msgstr "передача NULL в неуказательный аргумент %P в %qD"
  
  #: cp/call.c:6208
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "converting to non-pointer type %qT from NULL"
-msgstr "%s неуказательному типу %qT значения NULL"
+msgstr "преобразование в неуказательный тип %qT из NULL"
  
  #: cp/call.c:6217
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "converting %<false%> to pointer type for argument %P of %qD"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð´Ð»Ñ\8f Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° `%P' Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qD"
+msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ %<false%> Ð² Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %P Ð² %qD"
  
  #: cp/call.c:6221
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "converting %<false%> to pointer type %qT"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð´Ð»Ñ\8f Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° `%P' Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qD"
+msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ %<false%> Ð² Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT"
  
  #: cp/call.c:6284
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too many braces around initializer for %qT"
-msgstr "отсутствуют фигурные скобки вокруг инициализатора %qT"
+msgstr "слишком много фигурных скобок вокруг инициализатора для %qT"
  
  #: cp/call.c:6295
  #, fuzzy, gcc-internal-format
+#| msgid "cannot convert %qT to %qT in initialization"
  msgid "converting to %qT from %qT requires direct-initialization"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "ошибка преобразования %qT в %qT в инициализации"
  
  #: cp/call.c:6303
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid user-defined conversion from %qT to %qT"
-msgstr "некорректное преобразование из %qT в %qT"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð¾Ðµ Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT"
  
  #: cp/call.c:6320 cp/call.c:6344 cp/call.c:6462 cp/call.c:6554 cp/call.c:6596
  #: cp/call.c:6624
@@ -38080,7 +39700,7 @@ msgstr "некорректное преобразование из %qT в %qT"
  #: cp/call.c:6374 cp/call.c:6381
  #, gcc-internal-format
  msgid "converting to %qT from initializer list would use explicit constructor %qD"
-msgstr ""
+msgstr "преобразование в %qT из списка инициализации будет использовать явный конструктор %qD"
  
  #: cp/call.c:6377
  #, fuzzy, gcc-internal-format
@@ -38089,19 +39709,20 @@ msgid "in C++11 and above a default constructor can be explicit"
  msgstr "только декларации конструкторов могут быть %<explicit%>"
  
  #: cp/call.c:6610
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot bind %qT lvalue to %qT"
-msgstr "недопустимое связывание rvalue %qE с %qT"
+msgstr "недопустимое связывание %qT lvalue с %qT"
  
  #: cp/call.c:6614 cp/call.c:9945
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid initialization of non-const reference of type %qT from an rvalue of type %qT"
-msgstr "некорректная инициализация неконстантной ссылки типа %qT из временного выражения типа %qT"
+msgstr "некорректная инициализация неконстантной ссылки типа %qT из rvalue типа %qT"
  
  #: cp/call.c:6617
  #, fuzzy, gcc-internal-format
+#| msgid "passing %qT as %<this%> argument of %q#D discards qualifiers"
  msgid "binding %qT to reference of type %qT discards qualifiers"
-msgstr "передача %qT как `this'-аргумента `%#D' отменяет квалификаторы"
+msgstr "передача %qT как аргумент %<this%> %q#D отменяет квалификаторы"
  
  #: cp/call.c:6653
  #, gcc-internal-format
@@ -38125,43 +39746,48 @@ msgstr ""
  
  #: cp/call.c:6827
  #, fuzzy, gcc-internal-format
+#| msgid "cannot pass objects of non-trivially-copyable type %q#T through %<...%>"
  msgid "passing objects of non-trivially-copyable type %q#T through %<...%> is conditionally supported"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ´Ð°Ñ\87Ð° Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð° Ð½Ðµ POD-Ñ\82Ð¸Ð¿Ð° %q#T Ñ\87ÐµÑ\80ÐµÐ· %<...%>; Ð²Ñ\8bÐ·Ð¾Ð² Ð·Ð°Ð²ÐµÑ\80Ñ\88Ð¸Ñ\82Ñ\81Ñ\8f Ð°Ð²Ð°Ñ\80Ð¸Ð¹Ð½Ð¾ Ð²Ð¾ Ð²Ñ\80ÐµÐ¼Ñ\8f Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿ÐµÑ\80ÐµÐ´Ð°Ñ\82Ñ\8c Ð¾Ð±Ñ\8aÐµÐºÑ\82Ñ\8b Ð½ÐµÑ\82Ñ\80Ð¸Ð²Ð¸Ð°Ð»Ñ\8cÐ½Ð¾ ÐºÐ¾Ð¿Ð¸Ñ\80Ñ\83ÐµÐ¼Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %q#T Ñ\87ÐµÑ\80ÐµÐ· %<...%>"
  
  #: cp/call.c:6858
  #, fuzzy, gcc-internal-format
+#| msgid "cannot receive objects of non-trivially-copyable type %q#T through %<...%>; "
  msgid "cannot receive reference type %qT through %<...%>"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ð¾Ð»Ñ\83Ñ\87ÐµÐ½Ð¸Ðµ Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð° Ð½Ðµ POD-Ñ\82Ð¸Ð¿Ð° %q#T Ñ\87ÐµÑ\80ÐµÐ· %<...%>; Ð²Ñ\8bÐ·Ð¾Ð² Ð·Ð°Ð²ÐµÑ\80Ñ\88Ð¸Ñ\82Ñ\81Ñ\8f Ð°Ð²Ð°Ñ\80Ð¸Ð¹Ð½Ð¾ Ð²Ð¾ Ð²Ñ\80ÐµÐ¼Ñ\8f Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿Ñ\80Ð¸Ð½Ñ\8fÑ\82Ñ\8c Ð¾Ð±Ñ\8aÐµÐºÑ\82Ñ\8b Ð½ÐµÑ\82Ñ\80Ð¸Ð²Ð¸Ð°Ð»Ñ\8cÐ½Ð¾ ÐºÐ¾Ð¿Ð¸Ñ\80Ñ\83ÐµÐ¼Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %q#T Ñ\87ÐµÑ\80ÐµÐ· %<...%>"
  
  #: cp/call.c:6868
  #, fuzzy, gcc-internal-format
+#| msgid "cannot receive objects of non-trivially-copyable type %q#T through %<...%>; "
  msgid "receiving objects of non-trivially-copyable type %q#T through %<...%> is conditionally-supported"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ð¾Ð»Ñ\83Ñ\87ÐµÐ½Ð¸Ðµ Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð° Ð½Ðµ POD-Ñ\82Ð¸Ð¿Ð° %q#T Ñ\87ÐµÑ\80ÐµÐ· %<...%>; Ð²Ñ\8bÐ·Ð¾Ð² Ð·Ð°Ð²ÐµÑ\80Ñ\88Ð¸Ñ\82Ñ\81Ñ\8f Ð°Ð²Ð°Ñ\80Ð¸Ð¹Ð½Ð¾ Ð²Ð¾ Ð²Ñ\80ÐµÐ¼Ñ\8f Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿Ñ\80Ð¸Ð½Ñ\8fÑ\82Ñ\8c Ð¾Ð±Ñ\8aÐµÐºÑ\82Ñ\8b Ð½ÐµÑ\82Ñ\80Ð¸Ð²Ð¸Ð°Ð»Ñ\8cÐ½Ð¾ ÐºÐ¾Ð¿Ð¸Ñ\80Ñ\83ÐµÐ¼Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %q#T Ñ\87ÐµÑ\80ÐµÐ· %<...%>"
  
  #: cp/call.c:6928
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "recursive evaluation of default argument for %q#D"
-msgstr "повторное определение аргумента по умолчанию для `%#D'"
+msgstr "рекурсивное вычисление подразумеваемого аргумента для %q#D"
  
  #: cp/call.c:6937
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "call to %qD uses the default argument for parameter %P, which is not yet defined"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %d %qD ÐµÑ\89Ðµ Ð½Ðµ Ð±Ñ\8bÐ» Ð¿Ñ\80Ð¾Ð°Ð½Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°н"
+msgstr "Ð²Ñ\8bÐ·Ð¾Ð² %qD Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82 Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %P, ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐ¹ ÐµÑ\89Ðµ Ð½Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»Ðµн"
  
  #: cp/call.c:7039
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument of function call might be a candidate for a format attribute"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8fÑ\85, ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐ¼ Ð¼Ð¾Ð¶Ð½Ð¾ Ð½Ð°Ð·Ð½Ð°Ñ\87Ð¸Ñ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 format"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð²Ñ\8bÐ·Ð¾Ð²Ð° Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð¼Ð¾Ð³ Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ°Ð½Ð´Ð¸Ð´Ð°Ñ\82Ð¾Ð¼ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
  
  #: cp/call.c:7088
  #, fuzzy, gcc-internal-format
+#| msgid "defaulted function %q+D with default argument"
  msgid "use of multiversioned function without a default"
-msgstr "ÐºÐ¾Ð½ÐµÑ\86 Ñ\84Ð°Ð¹Ð»Ð° Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ñ\81 Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼"
  
  #: cp/call.c:7369
  #, fuzzy, gcc-internal-format
+#| msgid "passing %qT as %<this%> argument of %q#D discards qualifiers"
  msgid "passing %qT as %<this%> argument discards qualifiers"
-msgstr "передача %qT как `this'-аргумента `%#D' отменяет квалификаторы"
+msgstr "передача %qT как аргумент %<this%> %q#D отменяет квалификаторы"
  
  #: cp/call.c:7372 cp/call.c:7488 cp/call.c:9175 cp/name-lookup.c:5728
  #, gcc-internal-format
@@ -38174,14 +39800,14 @@ msgid "%qT is not an accessible base of %qT"
  msgstr "%qT не является базовым для %qT"
  
  #: cp/call.c:7484
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "deducing %qT as %qT"
-msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD ÐºÐ°Ðº %s"
+msgstr "Ð²Ñ\8bÐ²Ð¾Ð´ %qT ÐºÐ°Ðº %qT"
  
  #: cp/call.c:7490
  #, gcc-internal-format
  msgid "  (you can disable this with -fno-deduce-init-list)"
-msgstr ""
+msgstr "  (вы можете отключить это посредством -fno-deduce-init-list)"
  
  #: cp/call.c:7866
  #, gcc-internal-format
@@ -38190,8 +39816,9 @@ msgstr "не найдено поле класса в интерфейсном т
  
  #: cp/call.c:8037
  #, fuzzy, gcc-internal-format
+#| msgid "constant refers to itself"
  msgid "constructor delegates to itself"
-msgstr "указатель inlined_to ссылается на себя"
+msgstr "константа ссылается на себя"
  
  #: cp/call.c:8127
  #, gcc-internal-format
@@ -38201,17 +39828,18 @@ msgstr "вызов не функции %qD"
  #: cp/call.c:8173 cp/pt.c:13652 cp/typeck.c:2783
  #, gcc-internal-format
  msgid "cannot call constructor %<%T::%D%> directly"
-msgstr ""
+msgstr "невозможно вызвать конструктор %<%T::%D%> непосредственно"
  
  #: cp/call.c:8175
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "  for a function-style cast, remove the redundant %<::%D%>"
  msgid "for a function-style cast, remove the redundant %<::%D%>"
-msgstr ""
+msgstr "  для приведения типов в функциональном стиле удалите лишние %<::%D%>"
  
  #: cp/call.c:8305
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no matching function for call to %<%T::operator %T(%A)%#V%>"
-msgstr "нет подходящей функции для вызова %<%T::%s(%A)%#V%>"
+msgstr "нет подходящей функции для вызова %<%T::operator %T(%A)%#V%>"
  
  #: cp/call.c:8318
  #, gcc-internal-format
@@ -38229,10 +39857,12 @@ msgstr "нет соответствующей функции для вызова
  msgid "call of overloaded %<%s(%A)%> is ambiguous"
  msgstr "вызов перегруженной %<%s(%A)%> имеет неоднозначную трактовку"
  
+#
  #: cp/call.c:8368
  #, fuzzy, gcc-internal-format
+#| msgid "non-static data member initializers"
  msgid "pure virtual %q#D called from non-static data member initializer"
-msgstr "%qT не имеет нестатического элемента данных с именем %qD"
+msgstr "инициализаторы нестатических элементов данных"
  
  #: cp/call.c:8394
  #, gcc-internal-format
@@ -38260,34 +39890,34 @@ msgid "  because conversion sequence for the argument is better"
  msgstr "  поскольку это дает лучшую последовательность преобразований аргумента"
  
  #: cp/call.c:9399
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "default argument mismatch in overload resolution"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %P Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q+#D"
+msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° Ð¿Ñ\80Ð¸ Ñ\80Ð°Ð·Ñ\80ÐµÑ\88ÐµÐ½Ð¸Ð¸ Ð¿ÐµÑ\80ÐµÐ³Ñ\80Ñ\83Ð·ÐºÐ¸"
  
  #: cp/call.c:9403
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid " candidate 1: %q+#F"
-msgstr "претендент: %+#D"
+msgstr " кандидат 1: %q+#F"
  
  #: cp/call.c:9405
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid " candidate 2: %q+#F"
-msgstr "претендент: %+#D"
+msgstr " кандидат 2: %q+#F"
  
  #: cp/call.c:9450
  #, 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 ""
+msgstr "ISO C++ говорит здесь о неоднозначности, хотя худшее преобразование для первого лучше, чем худшее преобразование для второго:"
  
  #: cp/call.c:9628
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "could not convert %qE from %qT to %qT"
-msgstr "ошибка преобразования %qE в %qT"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qE Ð¸Ð· %qT Ð² %qT"
  
  #: cp/call.c:9822
  #, gcc-internal-format
  msgid "a temporary bound to %qD only persists until the constructor exits"
-msgstr ""
+msgstr "временная граница %qD сохраняется, пока существует конструктор"
  
  #: cp/call.c:9949
  #, gcc-internal-format
@@ -38330,23 +39960,25 @@ msgstr "Java-класс %qT не может иметь нетривиальны
  
  #: cp/class.c:1193
  #, fuzzy, gcc-internal-format
+#| msgid "  %qT is not derived from %qT"
  msgid "%q#D inherited from %qT"
-msgstr "тип %qT не является производным от %qT"
+msgstr "  %qT не является производным от %qT"
  
  #: cp/class.c:1196
  #, fuzzy, gcc-internal-format
+#| msgid "conflicts with previous declaration here"
  msgid "conflicts with version inherited from %qT"
-msgstr "%Jпротиворечит предыдущей декларации здесь"
+msgstr "противоречит предыдущей декларации здесь"
  
  #: cp/class.c:1210
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q+#D cannot be overloaded"
-msgstr "`%#D' и `%#D' не могут быть перегружены"
+msgstr "%q+#D не может быть перегружено"
  
  #: cp/class.c:1211
  #, gcc-internal-format
  msgid "with %q+#D"
-msgstr ""
+msgstr "с %q+#D"
  
  #: cp/class.c:1284
  #, gcc-internal-format
@@ -38354,24 +39986,24 @@ msgid "conflicting access specifications for method %q+D, ignored"
  msgstr "противоречивые спецификации доступа для метода %q+D, игнорируются"
  
  #: cp/class.c:1287
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conflicting access specifications for field %qE, ignored"
-msgstr "противоречивые спецификации доступа для поля %qs, игнорируются"
+msgstr "противоречивые спецификации доступа для поля %qE, игнорируются"
  
  #: cp/class.c:1350 cp/class.c:1358
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q+D invalid in %q#T"
-msgstr "%qD некорректно в %qT"
+msgstr "%q+D некорректно в %q#T"
  
  #: cp/class.c:1351
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  because of local method %q+#D with same name"
-msgstr "  Ð¿Ð¾Ñ\81ÐºÐ¾Ð»Ñ\8cÐºÑ\83 Ð¸Ð¼ÐµÐµÑ\82Ñ\81Ñ\8f Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð¼ÐµÑ\82Ð¾Ð´ `%#D' с тем же именем"
+msgstr "  Ð¸Ð·-Ð·Ð° Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ð¼ÐµÑ\82Ð¾Ð´Ð° %q+#D с тем же именем"
  
  #: cp/class.c:1359
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  because of local member %q+#D with same name"
-msgstr "  Ð¿Ð¾Ñ\81ÐºÐ¾Ð»Ñ\8cÐºÑ\83 Ð¸Ð¼ÐµÐµÑ\82Ñ\81Ñ\8f Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 `%#D' с тем же именем"
+msgstr "  Ð¸Ð·-Ð·Ð° Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° %q+#D с тем же именем"
  
  #: cp/class.c:1414
  #, gcc-internal-format
@@ -38380,8 +40012,9 @@ msgstr ""
  
  #: cp/class.c:1417 cp/class.c:1423 cp/class.c:1429 cp/class.c:1440
  #, fuzzy, gcc-internal-format
+#| msgid "%qD declared here"
  msgid "%qT declared here"
-msgstr "%q+D объявлено здесь"
+msgstr "%qD объявлено здесь"
  
  #: cp/class.c:1421
  #, gcc-internal-format
@@ -38399,9 +40032,9 @@ msgid "%qT does not have the %E ABI tag that %qT (used in the type of %qD) has"
  msgstr ""
  
  #: cp/class.c:1718
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot derive from %<final%> base %qT in derived type %qT"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð±Ð°Ð·Ð¾Ð²Ð¾Ð³Ð¾ %qT Ð² Ð¿Ñ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT Ñ\87ÐµÑ\80ÐµÐ· Ð²Ð¸Ñ\80Ñ\82Ñ\83Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð±Ð°Ð·Ð¾Ð²Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð²Ñ\8bÐ²Ð¾Ð´Ð° Ð¸Ð· %<final%> base %qT Ð² Ð¿Ñ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ð¾Ð¼ Ñ\82Ð¸Ð¿Ðµ %qT"
  
  #: cp/class.c:2164
  #, gcc-internal-format
@@ -38425,18 +40058,21 @@ msgstr "отсутствует уникальное переопределени
  
  #: cp/class.c:2975
  #, fuzzy, gcc-internal-format
+#| msgid "%q+#D cannot be overloaded"
  msgid "%qD can be marked override"
-msgstr "`%#D' и `%#D' не могут быть перегружены"
+msgstr "%q+#D не может быть перегружено"
  
  #: cp/class.c:2987
  #, fuzzy, gcc-internal-format
+#| msgid "%q+#D marked final, but is not virtual"
  msgid "%q+#D marked %<final%>, but is not virtual"
-msgstr "%q+D определена, но нигде не используется"
+msgstr "%q+#D помечен как final, но не является virtual"
  
  #: cp/class.c:2989
  #, fuzzy, gcc-internal-format
+#| msgid "%q+#D marked override, but does not override"
  msgid "%q+#D marked %<override%>, but does not override"
-msgstr "%q+D определена, но нигде не используется"
+msgstr "%q+#D помечен как override, но не делается override"
  
  #: cp/class.c:3059
  #, fuzzy, gcc-internal-format
@@ -38452,33 +40088,39 @@ msgstr "  методом %q+D"
  
  #: cp/class.c:3095 cp/decl2.c:1538
  #, fuzzy, gcc-internal-format
+#| msgid "%q+#D invalid; an anonymous union can only have non-static data members"
  msgid "%q#D invalid; an anonymous union can only have non-static data members"
-msgstr "`%#D' некорректно; в анонимном объединении допустимы только нестатические элементы"
+msgstr "%q+#D некорректно; анонимное объединение может иметь только нестатические элементы данных"
  
  #: cp/class.c:3099
  #, fuzzy, gcc-internal-format
+#| msgid "%q+#D invalid; an anonymous struct can only have non-static data members"
  msgid "%q#D invalid; an anonymous struct can only have non-static data members"
-msgstr "`%#D' некорректно; в анонимном объединении допустимы только нестатические элементы"
+msgstr "%q+#D некорректно; анонимная структура может иметь только нестатические элементы данных"
  
  #: cp/class.c:3111 cp/decl2.c:1545
  #, fuzzy, gcc-internal-format
+#| msgid "private member %q+#D in anonymous union"
  msgid "private member %q#D in anonymous union"
-msgstr "private-элемент `%#D' в анонимном объединении"
+msgstr "private-элемент %q+#D в анонимном объединении"
  
  #: cp/class.c:3114
  #, fuzzy, gcc-internal-format
+#| msgid "private member %q+#D in anonymous struct"
  msgid "private member %q#D in anonymous struct"
-msgstr "private-элемент `%#D' в анонимном объединении"
+msgstr "private-элемент %q+#D в анонимной структуре"
  
  #: cp/class.c:3120 cp/decl2.c:1548
  #, fuzzy, gcc-internal-format
+#| msgid "protected member %q+#D in anonymous union"
  msgid "protected member %q#D in anonymous union"
-msgstr "protected-элемент `%#D' в анонимном объединении"
+msgstr "protected-элемент %q+#D в анонимном объединении"
  
  #: cp/class.c:3123
  #, fuzzy, gcc-internal-format
+#| msgid "protected member %q+#D in anonymous struct"
  msgid "protected member %q#D in anonymous struct"
-msgstr "protected-элемент `%#D' в анонимном объединении"
+msgstr "protected-элемент %q+#D в анонимной структуре"
  
  #: cp/class.c:3302
  #, gcc-internal-format
@@ -38486,9 +40128,9 @@ msgid "the ellipsis in %qD is not inherited"
  msgstr ""
  
  #: cp/class.c:3480
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "bit-field %q+#D with non-integral type"
-msgstr "битовое поле `%#D' не целочисленного типа"
+msgstr "битовое поле %q+#D с нецелым типом"
  
  #: cp/class.c:3496
  #, gcc-internal-format
@@ -38535,7 +40177,7 @@ msgstr "элемент %q+#D с операцией присваивания пу
  #: cp/class.c:3590
  #, gcc-internal-format
  msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "unrestricted объединения допустимы только с -std=c++11 или -std=gnu++11"
  
  #: cp/class.c:3627
  #, gcc-internal-format
@@ -38615,8 +40257,9 @@ msgstr ""
  
  #: cp/class.c:4354
  #, fuzzy, gcc-internal-format
+#| msgid "alignment of %qD is bigger than original declaration"
  msgid "alignment of %qD will increase in -fabi-version=9"
-msgstr "Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ (Ð° Ð½Ðµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f) Ð² декларации"
+msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ %qD Ð±Ð¾Ð»Ñ\8cÑ\88Ðµ Ñ\87ÐµÐ¼ Ð² Ð¸Ñ\81Ñ\85Ð¾Ð´Ð½Ð¾Ð¹ декларации"
  
  #: cp/class.c:4608
  #, gcc-internal-format
@@ -38626,47 +40269,49 @@ msgstr "инициализатор задан для невиртуальног
  #: cp/class.c:5045
  #, gcc-internal-format
  msgid "method overrides both %<transaction_pure%> and %qE methods"
-msgstr ""
+msgstr "метод перебивает оба метода %<transaction_pure%> и %qE"
  
  #: cp/class.c:5066
  #, gcc-internal-format
  msgid "method declared %qE overriding %qE method"
-msgstr ""
+msgstr "описанный метод %qE перебивает метод %qE"
  
  #: cp/class.c:5660 cp/constexpr.c:217
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "enclosing class of constexpr non-static member function %q+#D is not a literal type"
-msgstr "%qs не является именем типа"
+msgstr "объемлющий класс constexpr нестатической функции-элемента %q+#D не является литеральным типом"
  
  #: cp/class.c:5685
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q+T is not literal because:"
-msgstr "%q#T не является классом"
+msgstr "%q+T не является литералом, поскольку:"
  
  #: cp/class.c:5687
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  %q+T has a non-trivial destructor"
-msgstr "базовый класс %q#T имеет невиртуальный деструктор"
+msgstr "  %q+T имеет нетривиальный деструктор"
  
  #: cp/class.c:5692
  #, gcc-internal-format
  msgid "  %q+T is not an aggregate, does not have a trivial default constructor, and has no constexpr constructor that is not a copy or move constructor"
-msgstr ""
+msgstr "  %q+T не агрегат, не имеет тривиальный подразумеваемый конструктор и и не имеет constexpr конструктор, который не является конструктором copy или move"
  
  #: cp/class.c:5727
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  base class %qT of %q+T is non-literal"
-msgstr "%qs не является именем типа"
+msgstr "  базовый класс %qT %q+T не литерал"
  
  #: cp/class.c:5742
  #, fuzzy, gcc-internal-format
+#| msgid "  non-static data member %q+D has non-literal type"
  msgid "  non-static data member %qD has non-literal type"
-msgstr "`%#D' не является нестатическим элементом %qT"
+msgstr "  нестатический элемент данных %q+D имеет нелитеральный тип"
  
  #: cp/class.c:5749
  #, fuzzy, gcc-internal-format
+#| msgid "  non-static data member %q+D has non-literal type"
  msgid "  non-static data member %qD has volatile type"
-msgstr "`%#D' не является нестатическим элементом %qT"
+msgstr "  нестатический элемент данных %q+D имеет нелитеральный тип"
  
  #: cp/class.c:5867
  #, fuzzy, gcc-internal-format
@@ -38691,7 +40336,7 @@ msgstr "нестатический константный элемент %q+#D 
  #: cp/class.c:5928
  #, gcc-internal-format
  msgid "%q+D declared to take const reference, but implicit declaration would take non-const"
-msgstr ""
+msgstr "%q+D декларировано принимать константные ссылки, но неявная декларация будет принимать неконстантные"
  
  #: cp/class.c:6205
  #, gcc-internal-format
@@ -38711,18 +40356,21 @@ msgstr "смещение %q+D несовместимо с ABI и может из
  
  #: cp/class.c:6600
  #, fuzzy, gcc-internal-format
+#| msgid "size of array %qE is too large"
  msgid "size of type %qT is too large (%qE bytes)"
-msgstr "размер массива %qs слишком велик"
+msgstr "размер массива %qE слишком велик"
  
  #: cp/class.c:6805
  #, fuzzy, gcc-internal-format
+#| msgid "flexible array member not at end of struct"
  msgid "zero-size array member %qD not at end of %q#T"
-msgstr "%Jрегулируемый элемент-массив - не последний элемент структуры"
+msgstr "регулируемый элемент-массив - не последний элемент структуры"
  
  #: cp/class.c:6807
  #, fuzzy, gcc-internal-format
+#| msgid "flexible array member in otherwise empty struct"
  msgid "zero-size array member %qD in an otherwise empty %q#T"
-msgstr "%Jрегулируемый массив - единственный именованный элемент структуры"
+msgstr "регулируемый элемент-массив в структуре, которая иначе была бы пустой"
  
  #: cp/class.c:6812 cp/class.c:6835
  #, fuzzy, gcc-internal-format
@@ -38732,18 +40380,21 @@ msgstr "повторное определение %q#T"
  
  #: cp/class.c:6817
  #, fuzzy, gcc-internal-format
+#| msgid "flexible array member not at end of struct"
  msgid "flexible array member %qD not at end of %q#T"
-msgstr "%Jрегулируемый элемент-массив - не последний элемент структуры"
+msgstr "регулируемый элемент-массив - не последний элемент структуры"
  
  #: cp/class.c:6819
  #, fuzzy, gcc-internal-format
+#| msgid "flexible array member in otherwise empty struct"
  msgid "flexible array member %qD in an otherwise empty %q#T"
-msgstr "%Jрегулируемый массив - единственный именованный элемент структуры"
+msgstr "регулируемый элемент-массив в структуре, которая иначе была бы пустой"
  
  #: cp/class.c:6832
  #, fuzzy, gcc-internal-format
+#| msgid "  %q+#D declared here"
  msgid "next member %q#D declared here"
-msgstr "  имя `%#D' объявлено здесь"
+msgstr "  %q+#D декларировано здесь"
  
  #: cp/class.c:6929 cp/decl.c:12941 cp/parser.c:21981
  #, gcc-internal-format
@@ -38757,13 +40408,14 @@ msgstr "%q#T содержит виртуальные функции, но нев
  
  #: cp/class.c:7103
  #, fuzzy, gcc-internal-format
+#| msgid "type transparent class %qT does not have any fields"
  msgid "type transparent %q#T does not have any fields"
  msgstr "в типе прозрачного класса %qT нет никаких полей"
  
  #: cp/class.c:7109
  #, gcc-internal-format
  msgid "type transparent class %qT has base classes"
-msgstr ""
+msgstr "type transparent класс %qT имеет базовые классы"
  
  #: cp/class.c:7113
  #, gcc-internal-format
@@ -38776,9 +40428,10 @@ msgid "type transparent %q#T cannot be made transparent because the type of the
  msgstr ""
  
  #: cp/class.c:7283
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "deducing from brace-enclosed initializer list requires #include <initializer_list>"
  msgid "definition of std::initializer_list does not match #include <initializer_list>"
-msgstr ""
+msgstr "вывод из взятого в скобки списка инизиализатора требует #include <initializer_list>"
  
  #: cp/class.c:7294
  #, gcc-internal-format
@@ -38844,37 +40497,39 @@ msgstr "делает трактовку %qD отличной от %q+#D"
  #: cp/constexpr.c:95
  #, gcc-internal-format
  msgid "the type %qT of constexpr variable %qD is not literal"
-msgstr ""
+msgstr "тип %qT constexpr переменной %qD не литерал"
  
  #: cp/constexpr.c:103
  #, fuzzy, gcc-internal-format
+#| msgid "temporary of non-literal type %qT in a constant expression"
  msgid "variable %qD of non-literal type %qT in %<constexpr%> function"
-msgstr "Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»Ð¸Ð¼Ñ\8bÐ¹ Ð¸ Ð½ÐµÐ¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð² Ñ\83Ñ\81Ð»Ð¾Ð²ном выражении"
+msgstr "Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ð½ÐµÐ»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð² ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82ном выражении"
  
  #: cp/constexpr.c:178
  #, fuzzy, gcc-internal-format
+#| msgid "defaulted constructor calls non-constexpr %q+D"
  msgid "inherited constructor %qD is not constexpr"
-msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ°Ðº virtual"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80 Ð²Ñ\8bÐ·Ñ\8bÐ²Ð°ÐµÑ\82 non-constexpr %q+D"
  
  #: cp/constexpr.c:190
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid type for parameter %d of constexpr function %q+#D"
-msgstr "некорректное использование элемента %q+D в статическом элементе-функции"
+msgstr "некорректный тип для параметра %d constexpr функции %q+#D"
  
  #: cp/constexpr.c:205
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid return type %qT of constexpr function %q+D"
-msgstr "некорректный тип результата для функции `%#D'"
+msgstr "некорректный тип результата %qT constexpr функции %q+D"
  
  #: cp/constexpr.c:227
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#T has virtual base classes"
-msgstr "%q#T Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ»Ð°Ñ\81Ñ\81Ð¾Ð¼"
+msgstr "%q#T Ð¸Ð¼ÐµÐµÑ\82 Ð²Ð¸Ñ\80Ñ\82Ñ\83Ð°Ð»Ñ\8cÐ½Ñ\8bÐµ Ð±Ð°Ð·Ð¾Ð²Ñ\8bÐµ ÐºÐ»Ð°Ñ\81Ñ\81Ñ\8b"
  
  #: cp/constexpr.c:478
  #, gcc-internal-format
  msgid "constexpr constructor does not have empty body"
-msgstr ""
+msgstr "constexpr конструктор не имеет пустое тело"
  
  #: cp/constexpr.c:584
  #, gcc-internal-format
@@ -38882,65 +40537,69 @@ msgid "body of %<constexpr%> constructor cannot be a function-try-block"
  msgstr ""
  
  #: cp/constexpr.c:715
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<constexpr%> constructor for union %qT must initialize exactly one non-static data member"
-msgstr "некорректная инициализация внутри класса статического элемента данных нецелочисленного типа %qT"
+msgstr "%<constexpr%> конструктор для объединения %qT должен инициализировать в точности один нестатический элемент данных"
  
  #: cp/constexpr.c:755
  #, fuzzy, gcc-internal-format
+#| msgid "uninitialized member %qD in %<constexpr%> constructor"
  msgid "member %qD must be initialized by mem-initializer in %<constexpr%> constructor"
-msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 %qD ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
+msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 %qD Ð² %<constexpr%> ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ðµ"
  
  #: cp/constexpr.c:787
  #, gcc-internal-format
  msgid "body of constexpr function %qD not a return-statement"
-msgstr ""
+msgstr "тело constexpr функции %qD не return-statement"
  
  #: cp/constexpr.c:841
  #, fuzzy, gcc-internal-format
+#| msgid "%q+D is not usable as a constexpr function because:"
  msgid "%qD is not usable as a constexpr function because:"
-msgstr "%qD не является функцией шаблоном"
+msgstr "%q+D не может использоваться как constexpr функция поскольку:"
  
  #: cp/constexpr.c:1281 cp/constexpr.c:4572
  #, fuzzy, gcc-internal-format
+#| msgid "internal function"
  msgid "call to internal function"
-msgstr "%qs объявлена как функция, возвращающая функцию"
+msgstr "внутренняя функция"
  
  #: cp/constexpr.c:1299
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expression %qE does not designate a constexpr function"
-msgstr "в декларации friend нет имени класса или функции"
+msgstr "выражение %qE не обозначает constexpr функцию"
  
  #: cp/constexpr.c:1317 cp/constexpr.c:4589
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "call to non-constexpr function %qD"
-msgstr "вызов не функции %qD"
+msgstr "вызов non-constexpr функции %qD"
  
  #: cp/constexpr.c:1379
  #, fuzzy, gcc-internal-format
+#| msgid "%qD called in a constant expression"
  msgid "%qD called in a constant expression before its definition is complete"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "%qD вызвана в константном выражении"
  
  #. The definition of fun was somehow unsuitable.
  #: cp/constexpr.c:1384
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD called in a constant expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "%qD вызвана в константном выражении"
  
  #: cp/constexpr.c:1388
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD used before its definition"
-msgstr "%q+D использована без предварительного определения"
+msgstr "%qD использована до своего определения"
  
  #: cp/constexpr.c:1428
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "call has circular dependency"
-msgstr "циклическая зависимость в протоколе %qs"
+msgstr "вызов имеет циклическую зависимость"
  
  #: cp/constexpr.c:1439
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "constexpr evaluation depth exceeds maximum of %d (use -fconstexpr-depth= to increase the maximum)"
-msgstr "Ð³Ð»Ñ\83Ð±Ð¸Ð½Ð° ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð¿Ñ\80ÐµÐ²Ñ\8bÑ\88Ð°ÐµÑ\82 Ð¼Ð°ÐºÑ\81Ð¸Ð¼Ñ\83Ð¼ %d (Ð·Ð°Ð´Ð°Ð¹Ñ\82Ðµ -ftemplate-depth-NN, Ñ\87Ñ\82Ð¾Ð±Ñ\8b Ñ\83Ð²ÐµÐ»Ð¸Ñ\87Ð¸Ñ\82Ñ\8c Ð¼Ð°ÐºÑ\81Ð¸Ð¼Ñ\83Ð¼) Ð¿Ñ\80Ð¸ ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ %qD"
+msgstr "Ð³Ð»Ñ\83Ð±Ð¸Ð½Ð° Ð¾Ð±Ñ\80Ð°Ð±Ð¾Ñ\82ÐºÐ¸ constexpr Ð¿Ñ\80ÐµÐ²Ñ\8bÑ\88Ð°ÐµÑ\82 Ð¼Ð°ÐºÑ\81Ð¸Ð¼Ñ\83Ð¼ %d (Ð·Ð°Ð´Ð°Ð¹Ñ\82Ðµ -fconstexpr-depth= Ñ\87Ñ\82Ð¾Ð±Ñ\8b Ñ\83Ð²ÐµÐ»Ð¸Ñ\87Ð¸Ñ\82Ñ\8c Ð¼Ð°ÐºÑ\81Ð¸Ð¼Ñ\83Ð¼)"
  
  #: cp/constexpr.c:1511
  #, gcc-internal-format
@@ -38948,9 +40607,9 @@ msgid "constexpr call flows off the end of the function"
  msgstr ""
  
  #: cp/constexpr.c:1591
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q+E is not a constant expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "%q+E не есть константное выражение"
  
  #: cp/constexpr.c:1631
  #, fuzzy, gcc-internal-format
@@ -38977,13 +40636,15 @@ msgstr "целочисленное выражение %qE не является
  
  #: cp/constexpr.c:1942
  #, fuzzy, gcc-internal-format
+#| msgid "array subscript is outside array bounds"
  msgid "array subscript value %qE is outside the bounds of array %qD of type %qT"
-msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð°"
  
  #: cp/constexpr.c:1947
  #, fuzzy, gcc-internal-format
+#| msgid "array subscript is outside array bounds"
  msgid "array subscript value %qE is outside the bounds of array type %qT"
-msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð°"
  
  #: cp/constexpr.c:2036
  #, fuzzy, gcc-internal-format
@@ -38992,19 +40653,19 @@ msgid "accessing uninitialized array element"
  msgstr "отсутствует инициализатор для элемента %qD"
  
  #: cp/constexpr.c:2091 cp/constexpr.c:2175 cp/constexpr.c:3549
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a constant expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "%qE не есть константное выражение"
  
  #: cp/constexpr.c:2097
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "mutable %qD is not usable in a constant expression"
-msgstr "размер массива %qD не является целочисленным константным выражением"
+msgstr "mutable %qD не может использоваться в константном выражении"
  
  #: cp/constexpr.c:2118
  #, gcc-internal-format
  msgid "accessing %qD member instead of initialized %qD member in constant expression"
-msgstr ""
+msgstr "обращение к элементу %qD вместо инициализированного элемента %qD в константном выражении"
  
  #: cp/constexpr.c:2135
  #, fuzzy, gcc-internal-format
@@ -39015,132 +40676,140 @@ msgstr "отсутствует инициализатор для элемент
  #: cp/constexpr.c:2853
  #, gcc-internal-format
  msgid "accessing value of %qE through a %qT glvalue in a constant expression"
-msgstr ""
+msgstr "обращение к значению %qE через %qT glvalue в константном выражении"
  
  #: cp/constexpr.c:2894
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the value of %qD is not usable in a constant expression"
-msgstr "размер массива %qD не является целочисленным константным выражением"
+msgstr "значение %qD не может использоваться в константном выражении"
  
  #: cp/constexpr.c:2901
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD used in its own initializer"
-msgstr "некорректный инициализатор массива"
+msgstr "%qD использована в своем собственном инициализаторе"
  
  #: cp/constexpr.c:2906
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#D is not const"
-msgstr "%q#T не является классом"
+msgstr "%q#D не есть const"
  
  #: cp/constexpr.c:2909
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#D is volatile"
-msgstr "`%+#D' - частный (private) элемент"
+msgstr "%q#D переменная"
  
  #: cp/constexpr.c:2914
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD was not initialized with a constant expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "%qD не была инициализирована константным выражением"
  
  #: cp/constexpr.c:2923
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD was not declared %<constexpr%>"
-msgstr "нет декларации %qD в этой области видимости"
+msgstr "%qD не была декларирована %<constexpr%>"
  
  #: cp/constexpr.c:2926
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD does not have integral or enumeration type"
-msgstr "выражение в деклараторе new должно иметь целый или перечислимый тип"
+msgstr "%qD не имеет целый или перечислимый тип"
  
  #: cp/constexpr.c:3034
  #, fuzzy, gcc-internal-format
+#| msgid "division by zero is not a constant-expression"
  msgid "modification of %qE is not a constant-expression"
-msgstr "размер массива не является целочисленным константным выражением"
+msgstr "деление на ноль не есть константное выражение"
  
  #: cp/constexpr.c:3595 cp/constexpr.c:4941
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "temporary of non-literal type %qT in a constant expression"
-msgstr "Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»Ð¸Ð¼Ñ\8bÐ¹ Ð¸ Ð½ÐµÐ¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð² Ñ\83Ñ\81Ð»Ð¾Ð²ном выражении"
+msgstr "Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ð½ÐµÐ»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð² ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82ном выражении"
  
  #: cp/constexpr.c:3919
  #, fuzzy, gcc-internal-format
+#| msgid "expression %qE is not a constant-expression"
  msgid "a reinterpret_cast is not a constant-expression"
-msgstr "целочисленное выражение %qE не является константой"
+msgstr "выражение %qE не является константным выражением"
  
  #: cp/constexpr.c:3930 cp/constexpr.c:4679
  #, fuzzy, gcc-internal-format
+#| msgid "reinterpret_cast from type %qT to type %qT casts away qualifiers"
  msgid "reinterpret_cast from integer to pointer"
-msgstr "некорректное применение static_cast от типа %qT к типу %qT"
+msgstr "reinterpret_cast от типа %qT к типу %qT отбрасывает квалификаторы"
  
  #: cp/constexpr.c:3990 cp/constexpr.c:4830 cp/constexpr.c:5117
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expression %qE is not a constant-expression"
-msgstr "целочисленное выражение %qE не является константой"
+msgstr "выражение %qE не является константным выражением"
  
  #: cp/constexpr.c:4060
  #, fuzzy, gcc-internal-format
+#| msgid "initializer element is not a constant expression"
  msgid "statement is not a constant-expression"
-msgstr "Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
+msgstr "Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÐ¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸ÐµÐ¼"
  
  #: cp/constexpr.c:4063
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unexpected expression %qE of kind %s"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð½ÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ %qE Ð²Ð¸Ð´Ð° %s"
  
  #: cp/constexpr.c:4133
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%qT cannot be the type of a complete constant expression because it has mutable sub-objects"
  msgid "%qE is not a constant expression because it refers to mutable subobjects of %qT"
-msgstr ""
+msgstr "%qT не может быть типом полного константного выражения поскольку он имеет mutable sub-objects"
  
  #: cp/constexpr.c:4146
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion from pointer type %qT to arithmetic type %qT in a constant-expression"
-msgstr "Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ %qE, Ð¸Ð¼ÐµÑ\8eÑ\89ÐµÐµ Ñ\82Ð¸Ð¿ Ð°Ð±Ñ\81Ñ\82Ñ\80Ð°ÐºÑ\82Ð½Ð¾Ð³Ð¾ ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qT, Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð² throw-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
+msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð² Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ñ\82Ð¸Ð¿ %qT Ð² constant-expression"
  
  #: cp/constexpr.c:4508
  #, gcc-internal-format
  msgid "expression %qE has side-effects"
-msgstr ""
+msgstr "выражение %qE имеет побочные эффекты"
  
  #: cp/constexpr.c:4705
  #, gcc-internal-format
  msgid "address-of an object %qE with thread local or automatic storage is not a constant expression"
-msgstr ""
+msgstr "address-of объекта %qE с поточно-локальным или автоматическим хранением не есть константное выражение"
  
  #: cp/constexpr.c:4737
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is not a constant expression"
  msgid "use of %<this%> in a constant expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "%qE не есть константное выражение"
  
  #: cp/constexpr.c:4842
  #, gcc-internal-format
  msgid "typeid-expression is not a constant expression because %qE is of polymorphic type"
-msgstr ""
+msgstr "typeid-expression не есть константное выражение поскольку %qE полиморфного типа"
  
  #: cp/constexpr.c:4904
  #, fuzzy, gcc-internal-format
+#| msgid "temporary of non-literal type %qT in a constant expression"
  msgid "cast to non-integral type %qT in a constant expression"
-msgstr "Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»Ð¸Ð¼Ñ\8bÐ¹ Ð¸ Ð½ÐµÐ¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð² Ñ\83Ñ\81Ð»Ð¾Ð²ном выражении"
+msgstr "Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ð½ÐµÐ»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð² ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82ном выражении"
  
  #: cp/constexpr.c:4989
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "division by zero is not a constant-expression"
-msgstr "размер массива не является целочисленным константным выражением"
+msgstr "деление на ноль не есть константное выражение"
  
  #: cp/constexpr.c:5094
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is not a constant expression"
  msgid "%<delete[]%> is not a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "%qE не есть константное выражение"
  
  #: cp/constexpr.c:5125
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-constant array initialization"
-msgstr "неконстантный индекс массива в инициализаторе"
+msgstr "неконстантная инициализация массива"
  
  #: cp/constexpr.c:5142
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "unexpected AST of kind %s"
-msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð¾Ðµ Ð¾ÐºÐ¾Ð½Ñ\87Ð°Ð½Ð¸Ðµ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
+msgstr "Ð½ÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð¾Ðµ AST Ð²Ð¸Ð´Ð° %s"
  
  #: cp/cp-array-notation.c:819 cp/cp-array-notation.c:825
  #: cp/cp-array-notation.c:850 cp/cp-array-notation.c:856
@@ -39201,13 +40870,15 @@ msgstr ""
  
  #: cp/cp-cilkplus.c:49
  #, fuzzy, gcc-internal-format
+#| msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
  msgid "throw expressions are not allowed inside loops marked with pragma simd"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ñ\8b-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8b Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ñ\8b-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8b Ð²Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹ Ð¸ Ñ\81Ð¿Ð¸Ñ\81ÐºÐ¾Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
  
  #: cp/cp-cilkplus.c:56
  #, fuzzy, gcc-internal-format
+#| msgid "%s statement is not allowed inside of BLOCK at %C"
  msgid "try statements are not allowed inside loops marked with #pragma simd"
-msgstr "Оператор в %0 некорректен в программной единице BLOCK DATA в %1"
+msgstr "%s оператор не допускается внутри BLOCK в %C"
  
  #: cp/cp-gimplify.c:1350
  #, gcc-internal-format
@@ -39225,9 +40896,9 @@ msgid "in C++11 this throw will terminate because destructors default to noexcep
  msgstr ""
  
  #: cp/cvt.c:89
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t convert from incomplete type %qT to %qT"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80Ð¸ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT в %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT в %qT"
  
  #: cp/cvt.c:99
  #, gcc-internal-format
@@ -39235,24 +40906,24 @@ msgid "conversion of %qE from %qT to %qT is ambiguous"
  msgstr "преобразование %qE из %qT в %qT неоднозначно"
  
  #: cp/cvt.c:382
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "initialization of volatile reference type %q#T from rvalue of type %qT"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ Ñ\82Ð¸Ð¿Ð° %qT Ð¸Ð· Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f типа %qT"
+msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f volatile Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ Ñ\82Ð¸Ð¿Ð° %qT Ð¸Ð· rvalue типа %qT"
  
  #: cp/cvt.c:385
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to volatile reference type %q#T from rvalue of type %qT"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ Ñ\82Ð¸Ð¿Ð° %qT Ð¸Ð· Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f типа %qT"
+msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ðº volatile Ñ\81Ñ\81Ñ\8bÐ»ÐºÐµ Ñ\82Ð¸Ð¿Ð° %qT Ð¸Ð· rvalue типа %qT"
  
  #: cp/cvt.c:388
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "initialization of non-const reference type %q#T from rvalue of type %qT"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð½ÐµÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð¹ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ Ñ\82Ð¸Ð¿Ð° %qT Ð¸Ð· Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f типа %qT"
+msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð½ÐµÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð¹ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ Ñ\82Ð¸Ð¿Ð° %qT Ð¸Ð· rvalue типа %qT"
  
  #: cp/cvt.c:391
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to non-const reference type %q#T from rvalue of type %qT"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð½ÐµÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð¹ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ Ñ\82Ð¸Ð¿Ð° %qT Ð¸Ð· Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f типа %qT"
+msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ðº Ð½ÐµÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð¹ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ Ñ\82Ð¸Ð¿Ð° %qT Ð¸Ð· rvalue типа %qT"
  
  #: cp/cvt.c:467
  #, gcc-internal-format
@@ -39277,7 +40948,7 @@ msgstr "преобразование из %q#T в %q#T"
  #: cp/cvt.c:771
  #, gcc-internal-format
  msgid "the result of the conversion is unspecified because %qE is outside the range of type %qT"
-msgstr ""
+msgstr "результат преобразования не определен, поскольку %qE  вне диапазона типа %qT"
  
  #: cp/cvt.c:782 cp/cvt.c:826
  #, gcc-internal-format
@@ -39286,8 +40957,9 @@ msgstr "%q#T использовано там, где ожидалось %qT"
  
  #: cp/cvt.c:791
  #, fuzzy, gcc-internal-format
+#| msgid "could not convert %qE from %qT to %qT"
  msgid "could not convert %qE from %<void%> to %<bool%>"
-msgstr "ошибка преобразования %qE в %qT"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qE Ð¸Ð· %qT Ð² %qT"
  
  #: cp/cvt.c:842
  #, gcc-internal-format
@@ -39305,239 +40977,239 @@ msgid "pseudo-destructor is not called"
  msgstr "псевдо-деструктор не вызывается"
  
  #: cp/cvt.c:1038
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to void will not access object of incomplete type %qT"
-msgstr "преобразование к неполному типу"
+msgstr "преобразование к void не даст доступ к объекту неполного типа %qT"
  
  #: cp/cvt.c:1042
  #, gcc-internal-format
  msgid "indirection will not access object of incomplete type %qT in second operand of conditional expression"
-msgstr ""
+msgstr "косвенность не даст доступ к объекту неполного типа %qT во втором операнде условного выражения"
  
  #: cp/cvt.c:1047
  #, gcc-internal-format
  msgid "indirection will not access object of incomplete type %qT in third operand of conditional expression"
-msgstr ""
+msgstr "косвенность не даст доступ к объекту неполного типа %qT в третьем операнде условного выражения"
  
  #: cp/cvt.c:1052
  #, gcc-internal-format
  msgid "indirection will not access object of incomplete type %qT in right operand of comma operator"
-msgstr ""
+msgstr "косвенность не даст доступ к объекту неполного типа %qT в правом операнде оператора запятая"
  
  #: cp/cvt.c:1057
  #, gcc-internal-format
  msgid "indirection will not access object of incomplete type %qT in left operand of comma operator"
-msgstr ""
+msgstr "косвенность не даст доступ к объекту неполного типа %qT в левом операнде оператора запятая"
  
  #: cp/cvt.c:1062
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "indirection will not access object of incomplete type %qT in statement"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ %qs Ðº Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð¼Ñ\83 Ñ\82Ð¸Ð¿Ñ\83 %qT "
+msgstr "ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ð¾Ñ\81Ñ\82Ñ\8c Ð½Ðµ Ð´Ð°Ñ\81Ñ\82 Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿ Ðº Ð¾Ð±Ñ\8aÐµÐºÑ\82Ñ\83 Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ"
  
  #: cp/cvt.c:1066
  #, gcc-internal-format
  msgid "indirection will not access object of incomplete type %qT in for increment expression"
-msgstr ""
+msgstr "косвенность не даст доступ к объекту неполного типа %qT в for инкрементном выражении"
  
  #: cp/cvt.c:1082
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to void will not access object of type %qT"
-msgstr "преобразование к неполному типу"
+msgstr "преобразование к void не даст доступ к объекту типа %qT"
  
  #: cp/cvt.c:1086
  #, gcc-internal-format
  msgid "implicit dereference will not access object of type %qT in second operand of conditional expression"
-msgstr ""
+msgstr "неявный переход по указателю не даст доступ к объекту типа %qT во втором операнде условного выражения"
  
  #: cp/cvt.c:1091
  #, gcc-internal-format
  msgid "implicit dereference will not access object of type %qT in third operand of conditional expression"
-msgstr ""
+msgstr "неявный переход по указателю не даст доступ к объекту типа %qT в третьем операнде условного выражения"
  
  #: cp/cvt.c:1096
  #, gcc-internal-format
  msgid "implicit dereference will not access object of type %qT in right operand of comma operator"
-msgstr ""
+msgstr "неявный переход по указателю не даст доступ к объекту типа %qT в правом операнде оператора запятая"
  
  #: cp/cvt.c:1101
  #, gcc-internal-format
  msgid "implicit dereference will not access object of type %qT in left operand of comma operator"
-msgstr ""
+msgstr "неявный переход по указателю не даст доступ к объекту типа %qT в левом операнде оператора запятая"
  
  #: cp/cvt.c:1106
  #, gcc-internal-format
  msgid "implicit dereference will not access object of type %qT in statement"
-msgstr ""
+msgstr "неявный переход по указателю не даст доступ к объекту типа %qT в операторе"
  
  #: cp/cvt.c:1110
  #, gcc-internal-format
  msgid "implicit dereference will not access object of type %qT in for increment expression"
-msgstr ""
+msgstr "неявный переход по указателю не даст доступ к объекту типа %qT в for инкрементном выражении"
  
  #: cp/cvt.c:1124
  #, gcc-internal-format
  msgid "conversion to void will not access object of non-trivially-copyable type %qT"
-msgstr ""
+msgstr "преобразование к void не даст доступ к объекту нетривиально копируемого типа %qT"
  
  #: cp/cvt.c:1129
  #, gcc-internal-format
  msgid "indirection will not access object of non-trivially-copyable type %qT in second operand of conditional expression"
-msgstr ""
+msgstr "косвенность не даст доступ к объекту нетривиально копируемого типа %qT во втором операнде условного выражения"
  
  #: cp/cvt.c:1134
  #, gcc-internal-format
  msgid "indirection will not access object of non-trivially-copyable type %qT in third operand of conditional expression"
-msgstr ""
+msgstr "косвенность не даст доступ к объекту нетривиально копируемого типа %qT в третьем операнде условного выражения"
  
  #: cp/cvt.c:1139
  #, gcc-internal-format
  msgid "indirection will not access object of non-trivially-copyable type %qT in right operand of comma operator"
-msgstr ""
+msgstr "косвенность не даст доступ к объекту нетривиально копируемого типа %qT в правом операнде оператора запятая"
  
  #: cp/cvt.c:1144
  #, gcc-internal-format
  msgid "indirection will not access object of non-trivially-copyable type %qT in left operand of comma operator"
-msgstr ""
+msgstr "косвенность не даст доступ к объекту нетривиально копируемого типа %qT в левом операнде оператора запятая"
  
  #: cp/cvt.c:1149
  #, gcc-internal-format
  msgid "indirection will not access object of non-trivially-copyable type %qT in statement"
-msgstr ""
+msgstr "косвенность не даст доступ к объекту нетривиально копируемого типа %qT в операторе"
  
  #: cp/cvt.c:1154
  #, gcc-internal-format
  msgid "indirection will not access object of non-trivially-copyable type %qT in for increment expression"
-msgstr ""
+msgstr "косвенность не даст доступ к объекту нетривиально копируемого типа %qT в for инкрементном выражении"
  
  #: cp/cvt.c:1192
  #, gcc-internal-format
  msgid "conversion to void will not access object %qE of incomplete type %qT"
-msgstr ""
+msgstr "преобразование к void не даст доступ к объекту %qE неполного типа %qT"
  
  #: cp/cvt.c:1196
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %qE of incomplete type %qT will not be accessed in second operand of conditional expression"
-msgstr "Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿ Ðº Ð¾Ð±Ñ\8aÐµÐºÑ\82Ñ\83 %qE Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð¾Ñ\81Ñ\83Ñ\89ÐµÑ\81Ñ\82Ð²Ð»Ñ\91Ð½ Ð² %s"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qE Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð° Ð²Ð¾ Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¼ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
  
  #: cp/cvt.c:1201
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %qE of incomplete type %qT will not be accessed in third operand of conditional expression"
-msgstr "Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿ Ðº Ð¾Ð±Ñ\8aÐµÐºÑ\82Ñ\83 %qE Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð¾Ñ\81Ñ\83Ñ\89ÐµÑ\81Ñ\82Ð²Ð»Ñ\91Ð½ Ð² %s"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qE Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð° Ð² Ñ\82Ñ\80ÐµÑ\82Ñ\8cÐµÐ¼ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
  
  #: cp/cvt.c:1206
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %qE of incomplete type %qT will not be accessed in right operand of comma operator"
-msgstr "Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿ Ðº Ð¾Ð±Ñ\8aÐµÐºÑ\82Ñ\83 %qE Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð¾Ñ\81Ñ\83Ñ\89ÐµÑ\81Ñ\82Ð²Ð»Ñ\91Ð½ Ð² %s"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qE Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð° Ð² Ð¿Ñ\80Ð°Ð²Ð¾Ð¼ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f"
  
  #: cp/cvt.c:1211
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %qE of incomplete type %qT will not be accessed in left operand of comma operator"
-msgstr "Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿ Ðº Ð¾Ð±Ñ\8aÐµÐºÑ\82Ñ\83 %qE Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð¾Ñ\81Ñ\83Ñ\89ÐµÑ\81Ñ\82Ð²Ð»Ñ\91Ð½ Ð² %s"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qE Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð° Ð² Ð»ÐµÐ²Ð¾Ð¼ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f"
  
  #: cp/cvt.c:1216
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %qE of incomplete type %qT will not be accessed in statement"
-msgstr "Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿ Ðº Ð¾Ð±Ñ\8aÐµÐºÑ\82Ñ\83 %qE Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð¾Ñ\81Ñ\83Ñ\89ÐµÑ\81Ñ\82Ð²Ð»Ñ\91Ð½ Ð² %s"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qE Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð° Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ"
  
  #: cp/cvt.c:1220
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %qE of incomplete type %qT will not be accessed in for increment expression"
-msgstr "Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿ Ðº Ð¾Ð±Ñ\8aÐµÐºÑ\82Ñ\83 %qE Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð¾Ñ\81Ñ\83Ñ\89ÐµÑ\81Ñ\82Ð²Ð»Ñ\91Ð½ Ð² %s"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qE Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð° Ð² for Ð¸Ð½ÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
  
  #: cp/cvt.c:1270
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to void cannot resolve address of overloaded function"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "преобразование к void не может разрешить адрес перегруженной функции"
  
  #: cp/cvt.c:1274
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "second operand of conditional expression cannot resolve address of overloaded function"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "второй операнд условного выражения не может разрешить адрес перегруженной функции"
  
  #: cp/cvt.c:1278
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "third operand of conditional expression cannot resolve address of overloaded function"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "третий операнд условного выражения не может разрешить адрес перегруженной функции"
  
  #: cp/cvt.c:1282
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "right operand of comma operator cannot resolve address of overloaded function"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "правый операнд оператора запятая не может разрешить адрес перегруженной функции"
  
  #: cp/cvt.c:1286
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "left operand of comma operator cannot resolve address of overloaded function"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "левый операнд оператора запятая не может разрешить адрес перегруженной функции"
  
  #: cp/cvt.c:1290
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "statement cannot resolve address of overloaded function"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "оператор не может разрешить адрес перегруженной функции"
  
  #: cp/cvt.c:1294
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "for increment expression cannot resolve address of overloaded function"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "for инкрементное выражение не может разрешить адрес перегруженной функции"
  
  #: cp/cvt.c:1310
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "second operand of conditional expression is a reference, not call, to function %qE"
-msgstr "%s ссылка, а не вызов функции %qE"
+msgstr "второй операнд условного выражения ссылка, а не вызов функции %qE"
  
  #: cp/cvt.c:1315
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "third operand of conditional expression is a reference, not call, to function %qE"
-msgstr "%s ссылка, а не вызов функции %qE"
+msgstr "третий операнд условного выражения ссылка, а не вызов функции %qE"
  
  #: cp/cvt.c:1320
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "right operand of comma operator is a reference, not call, to function %qE"
-msgstr "%s ссылка, а не вызов функции %qE"
+msgstr "правый операнд оператора запятая ссылка, а не вызов функции %qE"
  
  #: cp/cvt.c:1325
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "left operand of comma operator is a reference, not call, to function %qE"
-msgstr "%s ссылка, а не вызов функции %qE"
+msgstr "левый операнд оператора запятая ссылка, а не вызов функции %qE"
  
  #: cp/cvt.c:1330
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "statement is a reference, not call, to function %qE"
-msgstr "%s ссылка, а не вызов функции %qE"
+msgstr "оператор ссылка, а не вызов функции %qE"
  
  #: cp/cvt.c:1335
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "for increment expression is a reference, not call, to function %qE"
-msgstr "%s ссылка, а не вызов функции %qE"
+msgstr "for инкрементное выражение ссылка, а не вызов функции %qE"
  
  #: cp/cvt.c:1362
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "second operand of conditional expression has no effect"
-msgstr "Ð»ÐµÐ²Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ `Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f' Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð¿Ð¾Ð±Ð¾Ñ\87Ð½Ñ\8bÑ\85 Ñ\8dÑ\84Ñ\84ÐµÐºÑ\82Ð¾Ð²"
+msgstr "Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\8dÑ\84Ñ\84ÐµÐºÑ\82Ð°"
  
  #: cp/cvt.c:1367
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "third operand of conditional expression has no effect"
-msgstr "левый операнд операции `запятая' не имеет побочных эффектов"
+msgstr "третий операнд условного выражения ссылка не имеет эффекта"
  
  #: cp/cvt.c:1372
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "right operand of comma operator has no effect"
-msgstr "Ð»ÐµÐ²Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ `Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f' Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð¿Ð¾Ð±Ð¾Ñ\87Ð½Ñ\8bÑ\85 Ñ\8dÑ\84Ñ\84ÐµÐºÑ\82Ð¾Ð²"
+msgstr "Ð¿Ñ\80Ð°Ð²Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\8dÑ\84Ñ\84ÐµÐºÑ\82Ð°"
  
  #: cp/cvt.c:1376
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "left operand of comma operator has no effect"
-msgstr "Ð»ÐµÐ²Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ `Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f' Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð¿Ð¾Ð±Ð¾Ñ\87Ð½Ñ\8bÑ\85 Ñ\8dÑ\84Ñ\84ÐµÐºÑ\82Ð¾Ð²"
+msgstr "Ð»ÐµÐ²Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\8dÑ\84Ñ\84ÐµÐºÑ\82Ð°"
  
  #: cp/cvt.c:1380
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "statement has no effect"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð±ÐµÐ· Ð¿Ð¾Ð±Ð¾Ñ\87Ð½Ð¾Ð³Ð¾ эффекта"
+msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 эффекта"
  
  #: cp/cvt.c:1384
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "for increment expression has no effect"
-msgstr "левый операнд операции `запятая' не имеет побочных эффектов"
+msgstr "for инкрементное выражение не имеет эффекта"
  
  #: cp/cvt.c:1539
  #, gcc-internal-format
@@ -39546,8 +41218,9 @@ msgstr "преобразование NULL к неуказательному ти
  
  #: cp/cvt.c:1654
  #, fuzzy, gcc-internal-format
+#| msgid "  couldn't deduce template parameter %qD"
  msgid "default type conversion can't deduce template argument for %qD"
-msgstr "обнаружено %d параметров шаблона для `%#D'"
+msgstr "  невозможно вывести параметр шаблона %qD"
  
  #: cp/cvt.c:1669
  #, gcc-internal-format
@@ -39560,9 +41233,9 @@ msgid "  candidate conversions include %qD and %qD"
  msgstr "  возможные преобразования - %qD и %qD"
  
  #: cp/cxx-pretty-print.c:2189
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template-parameter-"
-msgstr "параметр шаблона `%#D'"
+msgstr "параметр-шаблона-"
  
  #: cp/decl.c:657
  #, fuzzy, gcc-internal-format
@@ -39588,13 +41261,14 @@ msgstr "предыдущая декларация %q+F"
  
  #: cp/decl.c:1281
  #, fuzzy, gcc-internal-format
+#| msgid "redeclaration %qD differs in %<constexpr%>"
  msgid "redeclaration %q+D differs in %<constexpr%>"
-msgstr "повторная декларация %qT как не-шаблона"
+msgstr "редекларация %qD отличается в %<constexpr%>"
  
  #: cp/decl.c:1282
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "from previous declaration %q+D"
-msgstr "Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q+F"
+msgstr "Ð¸Ð· Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %q+D"
  
  #: cp/decl.c:1311
  #, fuzzy, gcc-internal-format
@@ -39604,18 +41278,19 @@ msgstr "неинициализированная константа %qD"
  
  #: cp/decl.c:1333
  #, fuzzy, gcc-internal-format
+#| msgid "redeclaration of friend %q#D may not have default template arguments"
  msgid "redeclaration of %q#D may not have default arguments"
-msgstr "%qD не может иметь аргументов по умолчанию"
+msgstr "редекларация friend %q#D не может иметь подразумеваемые аргументы шаблона"
  
  #: cp/decl.c:1380
  #, gcc-internal-format
  msgid "literal operator template %q+D conflicts with raw literal operator %qD"
-msgstr ""
+msgstr "шаблон литерального оператора %q+D противоречит сырому литеральному оператору %qD"
  
  #: cp/decl.c:1385
  #, gcc-internal-format
  msgid "raw literal operator %q+D conflicts with literal operator template %qD"
-msgstr ""
+msgstr "сырой литеральный оператор %q+D противоречит шаблону литерального оператора %qD"
  
  #: cp/decl.c:1407
  #, fuzzy, gcc-internal-format
@@ -39642,14 +41317,14 @@ msgid "previous declaration of %qD was inline"
  msgstr "функция %q+D была ранее декларирована как inline"
  
  #: cp/decl.c:1445 cp/decl.c:1523
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "shadowing built-in function %q#D"
-msgstr "перекрытие %s функции %q#D"
+msgstr "перекрытие встроенной функции %q#D"
  
  #: cp/decl.c:1446 cp/decl.c:1524
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "shadowing library function %q#D"
-msgstr "перекрытие %s функции %q#D"
+msgstr "перекрытие библиотечной функции %q#D"
  
  #: cp/decl.c:1454
  #, gcc-internal-format
@@ -39658,14 +41333,15 @@ msgstr "библиотечная функция %q#D декларирована
  
  #: cp/decl.c:1457
  #, fuzzy, gcc-internal-format
+#| msgid "conflicts with built-in declaration %q#D"
  msgid "declaration of %q+#D conflicts with built-in declaration %q#D"
-msgstr "Ð¿Ñ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ñ\82 Ð¿Ñ\80ÐµÐ´Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð¾Ð¹ Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½ÐµÐ¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ `%#D'"
+msgstr "Ð¿Ñ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ñ\82 Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð¾Ð¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %q#D"
  
  #: cp/decl.c:1465
  #, fuzzy, gcc-internal-format
  #| msgid "declaration of %qD shadows a global declaration"
  msgid "redeclaration of %<pragma omp declare reduction%>"
-msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÐ²Ð°ÐµÑ\82 Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ñ\83Ñ\8e Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð°Ñ\86Ð¸Ñ\8e"
+msgstr "декларация %qD перекрывает глобальную декларацию"
  
  #: cp/decl.c:1467
  #, fuzzy, gcc-internal-format
@@ -39675,28 +41351,32 @@ msgstr "предыдущая декларация не-функции %q+#D"
  
  #: cp/decl.c:1518
  #, fuzzy, gcc-internal-format
+#| msgid "ambiguates built-in declaration %q#D"
  msgid "new declaration %q#D ambiguates built-in declaration %q#D"
-msgstr "Ð´ÐµÐ»Ð°ÐµÑ\82 Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð¾Ð¹ Ð¿Ñ\80ÐµÐ´Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»Ñ\91Ð½Ð½Ñ\83Ñ\8e Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8eÑ\8e Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8e `%#D'"
+msgstr "Ð´ÐµÐ»Ð°ÐµÑ\82 Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð¾Ð¹ Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ñ\83Ñ\8e Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8e %#D"
  
  #: cp/decl.c:1609
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#D redeclared as different kind of symbol"
-msgstr "%J%qD повторно декларирован как символ другого вида"
+msgstr "%q#D редекларирован как другой вид символа"
  
  #: cp/decl.c:1613 cp/decl.c:1634 cp/decl.c:1666 cp/name-lookup.c:586
  #, fuzzy, gcc-internal-format
+#| msgid "previous declaration %q+#D"
  msgid "previous declaration %q#D"
-msgstr "предыдущая декларация %q+D"
+msgstr "предыдущая декларация %q+#D"
  
  #: cp/decl.c:1632
  #, fuzzy, gcc-internal-format
+#| msgid "declaration of template %q#D"
  msgid "conflicting declaration of template %q+#D"
-msgstr "декларация шаблона `%#D'"
+msgstr "декларация шаблона %q#D"
  
  #: cp/decl.c:1651
  #, fuzzy, gcc-internal-format
+#| msgid "ambiguates old declaration %q+#D"
  msgid "ambiguating new declaration %q+#D"
-msgstr "делает неоднозначной предыдущую декларацию `%#D'"
+msgstr "делает неоднозначной старую декларацию %q+#D"
  
  #: cp/decl.c:1653 cp/decl.c:1681
  #, fuzzy, gcc-internal-format
@@ -39706,23 +41386,27 @@ msgstr "глобальная декларация %q+#D"
  
  #: cp/decl.c:1663
  #, fuzzy, gcc-internal-format
+#| msgid "conflicting declaration %q#D"
  msgid "conflicting declaration of C function %q+#D"
-msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f '%#D' ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83ÐµÑ\82 Ñ\81 Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸ÐµÐ¹"
+msgstr "Ð¿Ñ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ð²Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q#D"
  
  #: cp/decl.c:1679
  #, fuzzy, gcc-internal-format
+#| msgid "ambiguates old declaration %q+#D"
  msgid "ambiguating new declaration of %q+#D"
-msgstr "делает неоднозначной предыдущую декларацию `%#D'"
+msgstr "делает неоднозначной старую декларацию %q+#D"
  
  #: cp/decl.c:1689
  #, fuzzy, gcc-internal-format
+#| msgid "conflicting declaration %q#D"
  msgid "conflicting declaration %q+#D"
-msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f '%#D' ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83ÐµÑ\82 Ñ\81 Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸ÐµÐ¹"
+msgstr "Ð¿Ñ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ð²Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q#D"
  
  #: cp/decl.c:1691
  #, fuzzy, gcc-internal-format
+#| msgid "previous declaration %q+#D"
  msgid "previous declaration as %q#D"
-msgstr "предыдущая декларация %q+D"
+msgstr "предыдущая декларация %q+#D"
  
  #. [namespace.alias]
  #.
@@ -39733,53 +41417,62 @@ msgstr "предыдущая декларация %q+D"
  #. of the program.
  #: cp/decl.c:1743
  #, fuzzy, gcc-internal-format
+#| msgid "conflicting declaration %q#D"
  msgid "conflicting declaration of namespace %q+D"
-msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f '%#D' ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83ÐµÑ\82 Ñ\81 Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸ÐµÐ¹"
+msgstr "Ð¿Ñ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ð²Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q#D"
  
  #: cp/decl.c:1745
  #, fuzzy, gcc-internal-format
+#| msgid "previous declaration of namespace %q+D here"
  msgid "previous declaration of namespace %qD here"
-msgstr "предыдущая декларация `namespace %D' находится здесь"
+msgstr "предыдущая декларация namespace %q+D здесь"
  
  #: cp/decl.c:1757
  #, fuzzy, gcc-internal-format
+#| msgid "%q+#D previously defined here"
  msgid "%q#D previously defined here"
-msgstr "это предыдущее определение `%#D'"
+msgstr "%q+#D ранее определено здесь"
  
  #: cp/decl.c:1758 cp/name-lookup.c:1168 cp/name-lookup.c:1191
  #, fuzzy, gcc-internal-format
+#| msgid "%q+#D previously declared here"
  msgid "%q#D previously declared here"
-msgstr "это предыдущее определение `%#D'"
+msgstr "%q+#D ранее декларировано здесь"
  
  #: cp/decl.c:1768
  #, fuzzy, gcc-internal-format
+#| msgid "prototype for %q+#D"
  msgid "prototype specified for %q#D"
-msgstr "прототип `%#D'"
+msgstr "прототип для %q+#D"
  
  #: cp/decl.c:1770
  #, fuzzy, gcc-internal-format
+#| msgid "follows non-prototype definition here"
  msgid "previous non-prototype definition here"
-msgstr "%Jзадан позднее, чем непрототипное определение здесь"
+msgstr "следует непрототипное определение здесь"
  
  #: cp/decl.c:1809
  #, fuzzy, gcc-internal-format
+#| msgid "previous declaration of %q+#D with %qL linkage"
  msgid "conflicting declaration of %q+#D with %qL linkage"
-msgstr "предыдущая декларация `%#D' с привязкой %L"
+msgstr "предыдущая декларация %q+#D с %qL привязкой"
  
  #: cp/decl.c:1812
  #, fuzzy, gcc-internal-format
+#| msgid "previous declaration of %q+#D with %qL linkage"
  msgid "previous declaration with %qL linkage"
-msgstr "предыдущая декларация `%#D' с привязкой %L"
+msgstr "предыдущая декларация %q+#D с %qL привязкой"
  
  #: cp/decl.c:1846 cp/decl.c:1854
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "default argument given for parameter %d of %q#D"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %d Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ `%#D'"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð·Ð°Ð´Ð°Ð½ Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %d %q#D"
  
  #: cp/decl.c:1849 cp/decl.c:1857
  #, fuzzy, gcc-internal-format
+#| msgid "after previous specification in %q+#D"
  msgid "previous specification in %q#D here"
-msgstr "после предыдущей спецификации в `%#D'"
+msgstr "после предыдущей спецификации в %q+#D"
  
  #: cp/decl.c:1923
  #, gcc-internal-format
@@ -39788,8 +41481,9 @@ msgstr "избыточная повторная декларация %qD в то
  
  #: cp/decl.c:1934
  #, fuzzy, gcc-internal-format
+#| msgid "deleted definition of %qD"
  msgid "deleted definition of %q+D"
-msgstr "переопределение %q+D"
+msgstr "удаленное определение %qD"
  
  #. From [temp.expl.spec]:
  #.
@@ -39800,64 +41494,65 @@ msgstr "переопределение %q+D"
  #. instantiation to take place, in every translation unit in
  #. which such a use occurs.
  #: cp/decl.c:2341
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "explicit specialization of %qD after first use"
-msgstr "явная специализация %D после первого использования"
+msgstr "явная специализация %qD после первого использования"
  
  #: cp/decl.c:2472
  #, fuzzy, gcc-internal-format
+#| msgid "'setter' attribute of property %qD conflicts with previous declaration"
  msgid "%qD: visibility attribute ignored because it conflicts with previous declaration"
-msgstr "%Jобласть данных %qD противоречит предыдущей декларации"
+msgstr "'setter' атрибут свойства %qD конфликтует с предшествующей декларацией"
  
  #. Reject two definitions.
  #: cp/decl.c:2722 cp/decl.c:2751 cp/decl.c:2784 cp/decl.c:2801 cp/decl.c:2874
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "redefinition of %q#D"
-msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð¾Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ %q#T"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ %q#D"
  
  #: cp/decl.c:2738
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD conflicts with used function"
-msgstr "%q#D конфликтует с предыдущим использованием декларации %q#D"
+msgstr "%qD противоречит использованной функции"
  
  #: cp/decl.c:2748
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#D not declared in class"
-msgstr "отсутствует декларация %qD в %qD"
+msgstr "%q#D не декларировано в классе"
  
  #: cp/decl.c:2762 cp/decl.c:2811
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q+D redeclared inline with %<gnu_inline%> attribute"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%q+D переопределен inline с %<gnu_inline%> атрибутом"
  
  #: cp/decl.c:2765 cp/decl.c:2814
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q+D redeclared inline without %<gnu_inline%> attribute"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%q+D переопределен inline без %<gnu_inline%> атрибута"
  
  #. is_primary=
  #. is_partial=
  #. is_friend_decl=
  #: cp/decl.c:2831
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "redeclaration of friend %q#D may not have default template arguments"
-msgstr "%qD не может иметь аргументов по умолчанию"
+msgstr "редекларация friend %q#D не может иметь подразумеваемые аргументы шаблона"
  
  #: cp/decl.c:2845
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "thread-local declaration of %q#D follows non-thread-local declaration"
-msgstr "локальная для потока декларация %q+D следует после не локальной для потока декларации"
+msgstr "локальная для потока декларация %q#D следует за не локальной для потока декларацией"
  
  #: cp/decl.c:2848
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-thread-local declaration of %q#D follows thread-local declaration"
-msgstr "не локальная для потока декларация %q+D следует после локальной для потока декларации"
+msgstr "не локальная для потока декларация %q#D следует за локальной для потока декларацией"
  
  #: cp/decl.c:2863 cp/decl.c:2882 cp/name-lookup.c:582 cp/name-lookup.c:1166
  #: cp/name-lookup.c:1189
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "redeclaration of %q#D"
-msgstr "декларация %q#D"
+msgstr "редекларация %q#D"
  
  #: cp/decl.c:3031
  #, gcc-internal-format
@@ -39877,17 +41572,19 @@ msgstr "  отсюда"
  #: cp/decl.c:3057 cp/decl.c:3276
  #, gcc-internal-format
  msgid "  exits OpenMP structured block"
-msgstr ""
+msgstr "  покидает OpenMP структурный блок"
  
  #: cp/decl.c:3084
  #, fuzzy, gcc-internal-format
+#| msgid "  crosses initialization of %q+#D"
  msgid "  crosses initialization of %q#D"
-msgstr "  пересекает инициализацию `%#D'"
+msgstr "  пересекает инициализацию %q+#D"
  
  #: cp/decl.c:3087 cp/decl.c:3239
  #, fuzzy, gcc-internal-format
+#| msgid "  enters scope of %q+#D which has non-trivial destructor"
  msgid "  enters scope of %q#D which has non-trivial destructor"
-msgstr "базовый класс %q#T имеет невиртуальный деструктор"
+msgstr "  входит в область действия %q+#D имеющего нетривиальный деструктор"
  
  #: cp/decl.c:3105 cp/decl.c:3247
  #, gcc-internal-format
@@ -39900,9 +41597,9 @@ msgid "  enters catch block"
  msgstr "  входит в catch-блок"
  
  #: cp/decl.c:3120 cp/decl.c:3257
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  enters OpenMP structured block"
-msgstr "  входит в try-блок"
+msgstr "  входит в OpenMP структурный блок"
  
  #: cp/decl.c:3133 cp/decl.c:3251
  #, gcc-internal-format
@@ -39911,13 +41608,14 @@ msgstr ""
  
  #: cp/decl.c:3236
  #, fuzzy, gcc-internal-format
+#| msgid "  skips initialization of %q+#D"
  msgid "  skips initialization of %q#D"
-msgstr "  пропускает инициализацию `%#D'"
+msgstr "  пропускает инициализацию %q+#D"
  
  #: cp/decl.c:3293 cp/parser.c:11755 cp/parser.c:11782
  #, gcc-internal-format
  msgid "invalid exit from OpenMP structured block"
-msgstr ""
+msgstr "некорректный выход из OpenMP структурного блока"
  
  #: cp/decl.c:3325
  #, gcc-internal-format
@@ -39945,24 +41643,24 @@ msgid "no class template named %q#T in %q#T"
  msgstr "шаблон класса с именем %q#T' отсутствует в %q#T"
  
  #: cp/decl.c:3685
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no type named %q#T in %q#T"
-msgstr "шаблон класса с именем %q#T' отсутствует в %q#T"
+msgstr "нет имени типа %q#T в %q#T"
  
  #: cp/decl.c:3697
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "lookup of %qT in %qT is ambiguous"
-msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð¾"
+msgstr "Ð¿Ñ\80Ð¾Ñ\81Ð¼Ð¾Ñ\82Ñ\80 %qT Ð² %qT Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87ÐµÐ½"
  
  #: cp/decl.c:3706
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<typename %T::%D%> names %q#T, which is not a class template"
-msgstr "создание массива элементов типа %qT, являющегося абстрактным классом"
+msgstr "%<typename %T::%D%> именует %q#T, который не является шаблоном класса"
  
  #: cp/decl.c:3713
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<typename %T::%D%> names %q#T, which is not a type"
-msgstr "%<%T::%D%> не является типом"
+msgstr "%<typename %T::%D%> именует %q#T, который не является типом"
  
  #: cp/decl.c:3785
  #, fuzzy, gcc-internal-format
@@ -39971,14 +41669,14 @@ msgid "template parameters do not match template %qD"
  msgstr "параметры не подходят шаблону"
  
  #: cp/decl.c:4518
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "an anonymous struct cannot have function members"
-msgstr "%Jанонимная структура не может иметь элементов-функций"
+msgstr "анонимная struct не может иметь элементов-функций"
  
  #: cp/decl.c:4521
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "an anonymous union cannot have function members"
-msgstr "%Jанонимное объединение не может иметь элементов-функций"
+msgstr "анонимное union не может иметь элементов-функций"
  
  #: cp/decl.c:4539
  #, gcc-internal-format
@@ -39996,14 +41694,14 @@ msgid "member %q+#D with copy assignment operator not allowed in anonymous aggre
  msgstr "элемент %q+#D с операцией присваивания-копирования недопустим в анонимном агрегатном типе"
  
  #: cp/decl.c:4563
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "attribute ignored in declaration of %q#T"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %q+#T Ð¾Ñ\82Ð±Ñ\80Ð¾Ñ\88ÐµÐ½Ñ\8b"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ñ\8b Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %q#T"
  
  #: cp/decl.c:4566
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "attribute for %q#T must follow the %qs keyword"
-msgstr "атрибут для %q+#T должен следовать за ключевым словом %qs"
+msgstr "атрибут для %q#T должен следовать за %qs ключевым словом"
  
  #: cp/decl.c:4589
  #, gcc-internal-format
@@ -40016,9 +41714,9 @@ msgid "redeclaration of C++ built-in type %qT"
  msgstr "повторная декларация внутреннего типа C++ %qT"
  
  #: cp/decl.c:4612
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<auto%> can only be specified for variables or function declarations"
-msgstr "%qs допустим только для функций"
+msgstr "%<auto%> можно задавать только для переменных или деклараций функций"
  
  #: cp/decl.c:4638
  #, gcc-internal-format
@@ -40087,40 +41785,42 @@ msgid "%<typedef%> was ignored in this declaration"
  msgstr "%<typedef%> в этой декларации отброшен"
  
  #: cp/decl.c:4690
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<constexpr%> cannot be used for type declarations"
-msgstr "%<register%> в пустой декларации на уровне файла"
+msgstr "%<constexpr%> не может использоваться для деклараций типов"
  
  #: cp/decl.c:4712
  #, fuzzy, gcc-internal-format
+#| msgid "attributes ignored on template instantiation"
  msgid "attribute ignored in explicit instantiation %q#T"
-msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f %qD Ð² конкретизации шаблона"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f Ð´Ð»Ñ\8f конкретизации шаблона"
  
  #: cp/decl.c:4715
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute can only be applied to class definitions"
  msgid "no attribute can be applied to an explicit instantiation"
-msgstr "атрибут %qs допустим только для определений классов"
+msgstr "%qE атрибут может применяться только к определениям классов"
  
  #: cp/decl.c:4787
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ignoring attributes applied to class type %qT outside of definition"
-msgstr "Ð¾Ñ\82Ð±Ñ\80Ð¾Ñ\88ÐµÐ½Ñ\8b Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b ÐºÐ»Ð°Ñ\81Ñ\81Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ñ\8bÐµ Ð²Ð½Ðµ ÐµÐ³Ð¾ Ð¾Ð±Ñ\8aÑ\8fÐ²ления"
+msgstr "Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð½Ñ\8bÑ\85 Ðº ÐºÐ»Ð°Ñ\81Ñ\81Ñ\83 %qT Ð²Ð½Ðµ Ð¾Ð¿Ñ\80ÐµÐ´Ðµления"
  
  #. A template type parameter or other dependent type.
  #: cp/decl.c:4791
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ignoring attributes applied to dependent type %qT without an associated declaration"
-msgstr "Ð¾Ñ\82Ð±Ñ\80Ð¾Ñ\88ÐµÐ½Ñ\8b Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b ÐºÐ»Ð°Ñ\81Ñ\81Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ñ\8bÐµ Ð²Ð½Ðµ ÐµÐ³Ð¾ Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð½Ñ\8bÑ\85 Ðº Ð·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ð¾Ð¼Ñ\83 Ñ\82Ð¸Ð¿Ñ\83 %qT Ð±ÐµÐ· Ð°Ñ\81Ñ\81Ð¾Ñ\86Ð¸Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸"
  
  #: cp/decl.c:4860 cp/decl2.c:889
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "typedef %qD is initialized (use decltype instead)"
-msgstr "typedef-декларация %qD с инициализацией (используйте конструкцию __typeof__)"
+msgstr "typedef %qD инициализирован (используйте decltype взамен)"
  
  #: cp/decl.c:4868
  #, gcc-internal-format
  msgid "declaration of %q#D has %<extern%> and is initialized"
-msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q#D Ñ\81Ð¾Ð´ÐµÑ\80Ð¶Ð¸Ñ\82 %<extern%> Ð¸ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q#D Ñ\81Ð¾Ð´ÐµÑ\80Ð¶Ð¸Ñ\82 %<extern%> Ð¸ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð°"
  
  #: cp/decl.c:4897
  #, gcc-internal-format
@@ -40129,8 +41829,9 @@ msgstr "определение функции %q#D помечено %<dllimport%
  
  #: cp/decl.c:4921
  #, fuzzy, gcc-internal-format
+#| msgid "%q#D is not a non-static data member of %qT"
  msgid "%q+#D is not a static data member of %q#T"
-msgstr "`%#D' не является нестатическим элементом %qT"
+msgstr "%q#D не есть нестатический элемент данных %qT"
  
  #: cp/decl.c:4930
  #, fuzzy, gcc-internal-format
@@ -40155,9 +41856,9 @@ msgid "duplicate initialization of %qD"
  msgstr "повторная инициализация %qD"
  
  #: cp/decl.c:4961
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD declared %<constexpr%> outside its class"
-msgstr "%q+F объявлена %<static%>, но нигде не определена"
+msgstr "%qD объявлен как %<constexpr%> вне его класса"
  
  #: cp/decl.c:5004
  #, gcc-internal-format
@@ -40166,8 +41867,9 @@ msgstr "декларация %q#D вне класса не является оп
  
  #: cp/decl.c:5037
  #, fuzzy, gcc-internal-format
+#| msgid "%qE undeclared here (not in a function)"
  msgid "%qD declared %<thread_local%> in %<constexpr%> function"
-msgstr "некорректный класс хранения %<__thread%> для функции %qs"
+msgstr "%qE не описан здесь (не в функции)"
  
  #: cp/decl.c:5040
  #, fuzzy, gcc-internal-format
@@ -40186,9 +41888,9 @@ msgid "elements of array %q#D have incomplete type"
  msgstr "элементы массива %q#D имеют неполный тип"
  
  #: cp/decl.c:5118 cp/decl.c:6621
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %q#D has no initializer"
-msgstr "декларация %q#D содержит %<extern%> и инициализацию"
+msgstr "декларация %q#D не имеет инициализатора"
  
  #: cp/decl.c:5120
  #, gcc-internal-format
@@ -40201,19 +41903,19 @@ msgid "%qD declared as reference but not initialized"
  msgstr "переменная %qD декларирована как ссылка, но не инициализирована"
  
  #: cp/decl.c:5211
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "name used in a GNU-style designated initializer for an array"
-msgstr "имя %qD использовано в назначенном инициализаторе массива, являющемся GNU-расширением языка"
+msgstr "имя использовано в определенном в GNU-стиле инициализаторе массива"
  
  #: cp/decl.c:5217
  #, gcc-internal-format
  msgid "name %qD used in a GNU-style designated initializer for an array"
-msgstr "Ð¸Ð¼Ñ\8f %qD Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¾ Ð² Ð½Ð°Ð·Ð½Ð°Ñ\87ÐµÐ½Ð½Ð¾Ð¼ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð°, Ñ\8fÐ²Ð»Ñ\8fÑ\8eÑ\89ÐµÐ¼Ñ\81Ñ\8f GNU-Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸ÐµÐ¼ Ñ\8fÐ·Ñ\8bÐºа"
+msgstr "Ð¸Ð¼Ñ\8f %qD Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð¾Ð¼ Ð² GNU-Ñ\81Ñ\82Ð¸Ð»Ðµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²а"
  
  #: cp/decl.c:5233 cp/typeck2.c:1281 cp/typeck2.c:1391
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-trivial designated initializers not supported"
-msgstr "нетривиальные инициализаторы с метками"
+msgstr "нетривиально определенные инициализаторы не поддерживаются"
  
  #: cp/decl.c:5236
  #, fuzzy, gcc-internal-format
@@ -40240,24 +41942,26 @@ msgstr "массив %qD имеет нулевой размер"
  #. Don't talk about array types here, since we took care of that
  #. message in grokdeclarator.
  #: cp/decl.c:5343
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "storage size of %qD isn%'t known"
-msgstr "размер %q+D в памяти неизвестен"
+msgstr "размер памяти %qD неизвестен"
  
  #: cp/decl.c:5366
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "storage size of %qD isn%'t constant"
-msgstr "размер %q+D в памяти не является константой"
+msgstr "размер памяти %qD не константа"
  
  #: cp/decl.c:5412
  #, fuzzy, gcc-internal-format
+#| msgid "sorry: semantics of inline function static data %q+#D are wrong (you%'ll wind up with multiple copies)"
  msgid "sorry: semantics of inline function static data %q#D are wrong (you%'ll wind up with multiple copies)"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\81ÐµÐ¼Ð°Ð½Ñ\82Ð¸ÐºÐ° Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ñ\85 Ð´Ð°Ð½Ð½Ñ\8bÑ\85 %q+#D inline-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ (Ð¿Ñ\80Ð¸Ð´Ñ\91Ñ\82Ñ\81Ñ\8f Ð·Ð°Ð²Ð¾Ð´Ð¸Ñ\82Ñ\8c Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ ÐºÐ¾Ð¿Ð¸Ð¹)"
+msgstr "Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ð¸Ñ\82Ðµ: Ð¾Ñ\88Ð¸Ð±Ð¾Ñ\87Ð½Ð°Ñ\8f Ñ\81ÐµÐ¼Ð°Ð½Ñ\82Ð¸ÐºÐ° Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ñ\85 Ð´Ð°Ð½Ð½Ñ\8bÑ\85 %q+#D inline-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ (Ð·Ð°Ð¿Ñ\83Ñ\82Ð°ÐµÑ\82ÐµÑ\81Ñ\8c Ñ\81 Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¸Ð¼Ð¸ ÐºÐ¾Ð¿Ð¸Ñ\8fÐ¼Ð¸)"
  
  #: cp/decl.c:5416
  #, fuzzy, gcc-internal-format
+#| msgid "  you can work around this by removing the initializer"
  msgid "you can work around this by removing the initializer"
-msgstr "%J  проблему можно обойти, исключив инициализацию"
+msgstr "  это можно обойти, удалив инициализатор"
  
  #: cp/decl.c:5443
  #, gcc-internal-format
@@ -40266,23 +41970,25 @@ msgstr "неинициализированная константа %qD"
  
  #: cp/decl.c:5447
  #, fuzzy, gcc-internal-format
+#| msgid "uninitialized member %qD in %<constexpr%> constructor"
  msgid "uninitialized variable %qD in %<constexpr%> function"
-msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 %qD ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
+msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 %qD Ð² %<constexpr%> ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ðµ"
  
  #: cp/decl.c:5457
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#T has no user-provided default constructor"
-msgstr "тип %qs имеет конструктор, определённый пользователем"
+msgstr "%q#T не имеет предоставленный пользователем подразумеваемый конструктор"
  
  #: cp/decl.c:5461
  #, gcc-internal-format
  msgid "constructor is not user-provided because it is explicitly defaulted in the class body"
-msgstr ""
+msgstr "конструктор не является предоставленным пользователем, поскольку он явно подразумевался в теле класса"
  
  #: cp/decl.c:5464
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "and the implicitly-defined constructor does not initialize %q+#D"
  msgid "and the implicitly-defined constructor does not initialize %q#D"
-msgstr ""
+msgstr "и неявно определенный конструктор не инициализирует %q+#D"
  
  #: cp/decl.c:5587
  #, gcc-internal-format
@@ -40295,9 +42001,9 @@ msgid "initializer for %qT must be brace-enclosed"
  msgstr "инициализатор для %qT должен быт заключен в фигурные скобки"
  
  #: cp/decl.c:5654
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<[%E] =%> used in a GNU-style designated initializer for class %qT"
-msgstr "имя %qD использовано в назначенном инициализаторе массива, являющемся GNU-расширением языка"
+msgstr "%<[%E] =%> использовано в определенном в GNU-стиле инициализаторе для класса %qT"
  
  #: cp/decl.c:5662
  #, gcc-internal-format
@@ -40306,13 +42012,14 @@ msgstr "%qT не имеет нестатического элемента дан
  
  #: cp/decl.c:5682
  #, fuzzy, gcc-internal-format
+#| msgid "invalid initializer for array member %q#D"
  msgid "invalid initializer for %q#D"
-msgstr "некорректное начальное значение для элемента %qs"
+msgstr "некорректный инициализатор для элемента массива %q#D"
  
  #: cp/decl.c:5712
  #, gcc-internal-format
  msgid "C99 designator %qE outside aggregate initializer"
-msgstr ""
+msgstr "C99 обозначение %qE вне инициализатора агрегата"
  
  #: cp/decl.c:5749 cp/decl.c:5954 cp/typeck2.c:1268 cp/typeck2.c:1477
  #: cp/typeck2.c:1521 cp/typeck2.c:1568
@@ -40331,19 +42038,19 @@ msgid "missing braces around initializer for %qT"
  msgstr "отсутствуют фигурные скобки вокруг инициализатора %qT"
  
  #: cp/decl.c:5977
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "elements of array %q#T have incomplete type"
-msgstr "элементы массива %q#D имеют неполный тип"
+msgstr "элементы массива %q#T имеют неполный тип"
  
  #: cp/decl.c:5985
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable-sized compound literal"
-msgstr "ISO C90 не поддерживает составные литеральные выражения"
+msgstr "составной литерал переменного размера"
  
  #: cp/decl.c:6039
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#D has incomplete type"
-msgstr "%qD имеет неполный тип"
+msgstr "%q#D имеет неполный тип"
  
  #: cp/decl.c:6059
  #, gcc-internal-format
@@ -40351,9 +42058,9 @@ msgid "scalar object %qD requires one element in initializer"
  msgstr "в инициализаторе скалярного объекта %qD должен быть только один элемент"
  
  #: cp/decl.c:6102
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>"
-msgstr "%qD следует инициализировать при помощи конструктора, а не %<{...}%>"
+msgstr "в C++98 %qD следует инициализировать при помощи конструктора, а не %<{...}%>"
  
  #: cp/decl.c:6196
  #, gcc-internal-format
@@ -40366,9 +42073,9 @@ msgid "initializer invalid for static member with constructor"
  msgstr "инициализатор недопустим для статического элемента с конструктором"
  
  #: cp/decl.c:6229
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-constant in-class initialization invalid for static member %qD"
-msgstr "ISO C++ запрещает инициализацию внутри класса неконстантного статического элемента %qD"
+msgstr "неконстантная инициализация внутри класса некорректна для статического элемента %qD"
  
  #: cp/decl.c:6234
  #, gcc-internal-format
@@ -40377,8 +42084,9 @@ msgstr "(запрошена инициализация вне класса)"
  
  #: cp/decl.c:6411
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is initialized with itself"
  msgid "reference %qD is initialized with itself"
-msgstr "%H%qD используется без инициализации в данной функции"
+msgstr "%qD инициализируется самим собой"
  
  #: cp/decl.c:6580
  #, gcc-internal-format
@@ -40399,12 +42107,12 @@ msgstr "перекрытие предыдущей декларации %q#D"
  #: cp/decl.c:6834
  #, gcc-internal-format
  msgid "Java object %qD not allocated with %<new%>"
-msgstr ""
+msgstr "Java объект %qD не размещен посредством %<new%>"
  
  #: cp/decl.c:6882
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-static data member %qD has Java class type"
-msgstr "`%#D' не является нестатическим элементом %qT"
+msgstr "нестатический элемент данных %qD имеет тип Java класса"
  
  #: cp/decl.c:6963
  #, gcc-internal-format
@@ -40418,8 +42126,9 @@ msgstr ""
  
  #: cp/decl.c:7400
  #, fuzzy, gcc-internal-format
+#| msgid "  %q+T has a non-trivial destructor"
  msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor"
-msgstr "базовый класс %q#T имеет невиртуальный деструктор"
+msgstr "  %q+T имеет нетривиальный деструктор"
  
  #: cp/decl.c:7406
  #, gcc-internal-format
@@ -40427,19 +42136,19 @@ msgid "C++11 %<thread_local%> allows dynamic initialization and destruction"
  msgstr ""
  
  #: cp/decl.c:7633
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "initializer fails to determine size of %qT"
-msgstr "при инициализации не удалось определить размер %qD"
+msgstr "при инициализации не удалось определить размер %qT"
  
  #: cp/decl.c:7637
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "array size missing in %qT"
-msgstr "Ð½Ðµ Ð·Ð°Ð´Ð°Ð½ Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð´Ð»Ñ\8f %qD"
+msgstr "Ð½Ðµ Ð·Ð°Ð´Ð°Ð½ Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %qT"
  
  #: cp/decl.c:7640
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "zero-size array %qT"
-msgstr "Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² %qD Ð¸Ð¼ÐµÐµÑ\82 Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð¹ Ñ\80Ð°Ð·Ð¼ÐµÑ\80"
+msgstr "Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð¹ Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° %qT"
  
  #: cp/decl.c:7656
  #, gcc-internal-format
@@ -40452,64 +42161,64 @@ msgid "constructor for alien class %qT cannot be a member"
  msgstr "конструктор чужого класса %qT не может быть элементом"
  
  #: cp/decl.c:7682
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD declared as a %<virtual%> variable"
-msgstr "%qD декларирован как %<virtual%> %s"
+msgstr "%qD декларирована как %<virtual%> переменная"
  
  #: cp/decl.c:7684
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD declared as an %<inline%> variable"
-msgstr "%qD декларирован как %<inline%> %s"
+msgstr "%qD декларирована как %<inline%> переменная"
  
  #: cp/decl.c:7686
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration"
-msgstr "спецификаторы %<const%> и %<volatile%> для функции %qD некорректны в декларации %s"
+msgstr "спецификаторы %<const%> и %<volatile%> для функции %qD некорректны в декларации переменной"
  
  #: cp/decl.c:7691
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD declared as a %<virtual%> parameter"
-msgstr "%qD декларирован как %<virtual%> %s"
+msgstr "%qD декларирован как %<virtual%> параметр"
  
  #: cp/decl.c:7693
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD declared as an %<inline%> parameter"
-msgstr "%qD декларирован как %<inline%> %s"
+msgstr "%qD декларирован как %<inline%> параметр"
  
  #: cp/decl.c:7695
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration"
-msgstr "спецификаторы %<const%> и %<volatile%> для функции %qD некорректны в декларации %s"
+msgstr "спецификаторы %<const%> и %<volatile%> для функции %qD некорректны в декларации параметра"
  
  #: cp/decl.c:7700
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD declared as a %<virtual%> type"
-msgstr "%qD декларирован как %<virtual%> %s"
+msgstr "%qD декларирован как %<virtual%> тип"
  
  #: cp/decl.c:7702
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD declared as an %<inline%> type"
-msgstr "%qD декларирован как %<inline%> %s"
+msgstr "%qD декларирован как %<inline%> тип"
  
  #: cp/decl.c:7704
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration"
-msgstr "спецификаторы %<const%> и %<volatile%> для функции %qD некорректны в декларации %s"
+msgstr "спецификаторы %<const%> и %<volatile%> для функции %qD некорректны в декларации типа"
  
  #: cp/decl.c:7709
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD declared as a %<virtual%> field"
-msgstr "%qD декларирован как %<virtual%> %s"
+msgstr "%qD декларирован как %<virtual%> поле"
  
  #: cp/decl.c:7711
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD declared as an %<inline%> field"
-msgstr "%qD декларирован как %<inline%> %s"
+msgstr "%qD декларирован как %<inline%> поле"
  
  #: cp/decl.c:7713
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration"
-msgstr "спецификаторы %<const%> и %<volatile%> для функции %qD некорректны в декларации %s"
+msgstr "спецификаторы %<const%> и %<volatile%> для функции %qD некорректны в декларации поля"
  
  #: cp/decl.c:7720
  #, gcc-internal-format
@@ -40519,7 +42228,7 @@ msgstr "%q+D декларировано как friend"
  #: cp/decl.c:7726
  #, gcc-internal-format
  msgid "%q+D declared with an exception specification"
-msgstr "%q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¾ Ñ\81Ð¾ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸ÐµÐ¹ Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð¹ Ñ\81Ð¸Ñ\82Ñ\83Ð°Ñ\86Ð¸Ð¸"
+msgstr "%q+D Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¾ Ñ\81Ð¾ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸ÐµÐ¹ Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ð¹"
  
  #: cp/decl.c:7759
  #, gcc-internal-format
@@ -40533,13 +42242,15 @@ msgstr "статическая функция-член %q#D объявлена 
  
  #: cp/decl.c:7809
  #, fuzzy, gcc-internal-format
+#| msgid "%qD declared as a non-parameter"
  msgid "concept %q#D declared with function parameters"
-msgstr "%q+D декларирован как не параметр"
+msgstr "%qD декларирован как не параметр"
  
  #: cp/decl.c:7815
  #, fuzzy, gcc-internal-format
+#| msgid "parameter %qD declared with void type"
  msgid "concept %q#D declared with a deduced return type"
-msgstr "Ð´ÐµÐ»Ð°ÐµÑ\82 Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð¾Ð¹ Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89Ñ\83Ñ\8e Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8e `%#D'"
+msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %qD Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»ÐµÐ½ Ñ\81 Ñ\82Ð¸Ð¿Ð¾Ð¼ void"
  
  #: cp/decl.c:7817
  #, fuzzy, gcc-internal-format
@@ -40549,8 +42260,9 @@ msgstr "Java-метод %qD имеет тип результата %qT, не п
  
  #: cp/decl.c:7888
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<;%> after union definition"
  msgid "concept %qD has no definition"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð² %C"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<;%> Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð¾Ð±Ñ\8aÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ\8f"
  
  #: cp/decl.c:7956
  #, gcc-internal-format
@@ -40595,49 +42307,51 @@ msgid "cannot declare %<::main%> to be static"
  msgstr "недопустимая декларация %<::main%> как статической функции"
  
  #: cp/decl.c:8102
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "static member function %qD cannot have cv-qualifier"
-msgstr "%sэлемент, функция %qD, не может иметь квалификатор метода - %qT"
+msgstr "статическая элемент-функция %qD не может иметь cv-квалификатор"
  
  #: cp/decl.c:8103
  #, gcc-internal-format
  msgid "non-member function %qD cannot have cv-qualifier"
-msgstr ""
+msgstr "не-элемент-функция %qD не может иметь cv-квалификатор"
  
  #: cp/decl.c:8111
  #, fuzzy, gcc-internal-format
+#| msgid "static member function %qD cannot have cv-qualifier"
  msgid "static member function %qD cannot have ref-qualifier"
-msgstr "%sэлемент, функция %qD, не может иметь квалификатор метода - %qT"
+msgstr "статическая элемент-функция %qD не может иметь cv-квалификатор"
  
  #: cp/decl.c:8112
  #, fuzzy, gcc-internal-format
+#| msgid "non-member function %qD cannot have cv-qualifier"
  msgid "non-member function %qD cannot have ref-qualifier"
-msgstr "%sэлемент, функция %qD, не может иметь квалификатор метода - %qT"
+msgstr "не-элемент-функция %qD не может иметь cv-квалификатор"
  
  #: cp/decl.c:8129
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "literal operator with C linkage"
-msgstr "шаблон с привязкой C"
+msgstr "литеральный оператор с C-привязкой"
  
  #: cp/decl.c:8138
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD has invalid argument list"
-msgstr "некорректный аргумент внутренней функции"
+msgstr "%qD имеет некорректный список аргументов"
  
  #: cp/decl.c:8146
  #, gcc-internal-format
  msgid "integer suffix %<%s%> shadowed by implementation"
-msgstr ""
+msgstr "целый суффикс %<%s%> затенен реализацией"
  
  #: cp/decl.c:8152
  #, gcc-internal-format
  msgid "floating point suffix %<%s%> shadowed by implementation"
-msgstr ""
+msgstr "плавающий суффикс %<%s%> затенен реализацией"
  
  #: cp/decl.c:8158
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD must be a non-member function"
-msgstr "%qD должен быть нестатической элементом-функцией"
+msgstr "%qD должен быть не-элемент-функцией"
  
  #: cp/decl.c:8237
  #, gcc-internal-format
@@ -40650,14 +42364,14 @@ msgid "definition of implicitly-declared %qD"
  msgstr "определение неявно декларированного %qD"
  
  #: cp/decl.c:8284
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "definition of explicitly-defaulted %q+D"
-msgstr "определение неявно декларированного %qD"
+msgstr "определение явно подразумеваемого %q+D"
  
  #: cp/decl.c:8285
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q+#D explicitly defaulted here"
-msgstr "это предыдущее определение `%#D'"
+msgstr "%q+#D явно подразумевается здесь"
  
  #: cp/decl.c:8302 cp/decl2.c:787
  #, gcc-internal-format
@@ -40672,8 +42386,9 @@ msgstr "недопустимая декларация %<::main%> как шабл
  
  #: cp/decl.c:8494
  #, fuzzy, gcc-internal-format
+#| msgid "automatic variable %qE cannot be %<threadprivate%>"
  msgid "a non-template variable cannot be %<concept%>"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "автоматическая переменная %qE не может быть %<threadprivate%>"
  
  #: cp/decl.c:8501
  #, gcc-internal-format
@@ -40681,19 +42396,19 @@ msgid "concept must have type %<bool%>"
  msgstr ""
  
  #: cp/decl.c:8614
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "in-class initialization of static data member %q#D of incomplete type"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ ÐºÐ»Ð°Ñ\81Ñ\81Ð° Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° Ð´Ð°Ð½Ð½Ñ\8bÑ\85 Ð½ÐµÑ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
+msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ ÐºÐ»Ð°Ñ\81Ñ\81Ð° Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° Ð´Ð°Ð½Ð½Ñ\8bÑ\85 %q#D Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð°"
  
  #: cp/decl.c:8618
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type"
-msgstr "некорректная инициализация внутри класса статического элемента данных нецелочисленного типа %qT"
+msgstr "%<constexpr%> требуется для инициализации внутри класса статического элемента данных %q#D нецелого типа"
  
  #: cp/decl.c:8621
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "in-class initialization of static data member %q#D of non-literal type"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ ÐºÐ»Ð°Ñ\81Ñ\81Ð° Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° Ð´Ð°Ð½Ð½Ñ\8bÑ\85 Ð½ÐµÑ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
+msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ ÐºÐ»Ð°Ñ\81Ñ\81Ð° Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° Ð´Ð°Ð½Ð½Ñ\8bÑ\85 %q#D Ð½ÐµÐ»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð°"
  
  #: cp/decl.c:8634
  #, gcc-internal-format
@@ -40768,7 +42483,7 @@ msgstr "используется массив переменного разме
  #: cp/decl.c:8869
  #, gcc-internal-format
  msgid "variable length array is used"
-msgstr ""
+msgstr "используется массив переменного размера"
  
  #: cp/decl.c:8920
  #, gcc-internal-format
@@ -40782,44 +42497,44 @@ msgid "%qD declared as array of %qT"
  msgstr "%q+D декларировано как friend"
  
  #: cp/decl.c:8983
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %qD as array of void"
-msgstr "Ð¸Ð¼Ñ\8f %qs Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¾ ÐºÐ°Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð² Ñ\82Ð¸Ð¿а void"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD ÐºÐ°Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²а void"
  
  #: cp/decl.c:8985
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "creating array of void"
-msgstr "создание массива элементов типа %qT"
+msgstr "создание массива void"
  
  #: cp/decl.c:8990
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %qD as array of functions"
-msgstr "Ð¸Ð¼Ñ\8f %qs Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¾ ÐºÐ°Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² функций"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD ÐºÐ°Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° функций"
  
  #: cp/decl.c:8992
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "creating array of functions"
-msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð² Ñ\82Ð¸Ð¿Ð° %qT"
+msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
  
  #: cp/decl.c:8997
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %qD as array of references"
-msgstr "Ð¸Ð¼Ñ\8f %qs Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¾ ÐºÐ°Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD ÐºÐ°Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ðº"
  
  #: cp/decl.c:8999
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "creating array of references"
-msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð² Ñ\82Ð¸Ð¿Ð° %qT"
+msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ðº"
  
  #: cp/decl.c:9004
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %qD as array of function members"
-msgstr "Ð¸Ð¼Ñ\8f %qs Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¾ ÐºÐ°Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² функций"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD ÐºÐ°Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð²-функций"
  
  #: cp/decl.c:9006
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "creating array of function members"
-msgstr "имя %qs описано как массив функций"
+msgstr "создание массива элементов-функций"
  
  #: cp/decl.c:9020
  #, gcc-internal-format
@@ -40889,9 +42604,9 @@ msgid "invalid use of qualified-name %<%D::%D%>"
  msgstr "недопустимое использование квалифицированного имени %<%D::%D%>"
  
  #: cp/decl.c:9366
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#T is not a class or a namespace"
-msgstr "%qT не является классом или пространством имён"
+msgstr "%q#T не является классом или пространством имен"
  
  #: cp/decl.c:9390 cp/decl.c:9487 cp/decl.c:9496 cp/decl.c:10927
  #, gcc-internal-format
@@ -40914,24 +42629,25 @@ msgid "function definition does not declare parameters"
  msgstr "определение функции не объявляет параметры"
  
  #: cp/decl.c:9504
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %qD as %<typedef%>"
-msgstr "шаблонная декларация `%#D'"
+msgstr "декларация %qD как %<typedef%>"
  
  #: cp/decl.c:9509
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %qD as parameter"
-msgstr "декларация %q+D перекрывает параметр"
+msgstr "декларация %qD как параметра"
  
  #: cp/decl.c:9542
  #, fuzzy, gcc-internal-format
+#| msgid "%<constexpr%> cannot appear in a typedef declaration"
  msgid "%<concept%> cannot appear in a typedef declaration"
-msgstr "идентификатор шаблона недопустим в using-декларации"
+msgstr "%<constexpr%> не может встречаться в typedef декларации"
  
  #: cp/decl.c:9548
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<constexpr%> cannot appear in a typedef declaration"
-msgstr "идентификатор шаблона недопустим в using-декларации"
+msgstr "%<constexpr%> не может встречаться в typedef декларации"
  
  #: cp/decl.c:9556
  #, gcc-internal-format
@@ -40956,13 +42672,15 @@ msgstr "ISO C++ запрещает декларации %qs без типа"
  
  #: cp/decl.c:9673
  #, fuzzy, gcc-internal-format
+#| msgid "%<__int128%> is not supported by this target"
  msgid "%<__int%d%> is not supported by this target"
-msgstr "__builtin_saveregs не поддерживается для этой целевой платформы"
+msgstr "%<__int128%> не поддерживается этой целевой платформой"
  
  #: cp/decl.c:9679
  #, fuzzy, gcc-internal-format
+#| msgid "ISO C++ does not support %<__int128%> for %qs"
  msgid "ISO C++ does not support %<__int%d%> for %qs"
-msgstr "ISO C++ не поддерживает %<long long%>"
+msgstr "ISO C++ не поддерживает %<__int128%> для %qs"
  
  #: cp/decl.c:9701 cp/decl.c:9721
  #, gcc-internal-format
@@ -40995,9 +42713,9 @@ msgid "%<long%> or %<short%> invalid for %qs"
  msgstr "%<long%> или %<short%> некорректны для %qs"
  
  #: cp/decl.c:9713
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs"
-msgstr "%<long%> или %<short%> некорректны для %qs"
+msgstr "%<long%>, %<int%>, %<short%> или %<char%> некорректны для %qs"
  
  #: cp/decl.c:9715
  #, gcc-internal-format
@@ -41010,9 +42728,9 @@ msgid "%<long%> and %<short%> specified together for %qs"
  msgstr "%<long%> и %<short%> одновременно заданы для %qs"
  
  #: cp/decl.c:9723
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<short%> or %<long%> invalid for %qs"
-msgstr "%<long%> или %<short%> некорректны для %qs"
+msgstr "%<short%> или %<long%> некорректны для %qs"
  
  #: cp/decl.c:9731
  #, gcc-internal-format
@@ -41042,9 +42760,9 @@ msgid "typedef declaration invalid in parameter declaration"
  msgstr "typedef-декларация не допускается в декларации параметров"
  
  #: cp/decl.c:9867
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "storage class specified for template parameter %qs"
-msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80а %qs"
+msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f Ð·Ð°Ð´Ð°Ð½ Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° Ñ\88Ð°Ð±Ð»Ð¾Ð½а %qs"
  
  #: cp/decl.c:9873
  #, gcc-internal-format
@@ -41053,18 +42771,19 @@ msgstr "спецификаторы класса хранения не допус
  
  #: cp/decl.c:9877
  #, fuzzy, gcc-internal-format
+#| msgid "a parameter cannot be declared %<constexpr%>"
  msgid "a parameter cannot be declared %<concept%>"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð½Ðµ-Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° %qs ÐºÐ°Ðº %<mutable%>"
+msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½ %<constexpr%>"
  
  #: cp/decl.c:9882
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "a parameter cannot be declared %<constexpr%>"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð½Ðµ-Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° %qs ÐºÐ°Ðº %<mutable%>"
+msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½ %<constexpr%>"
  
  #: cp/decl.c:9892
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<virtual%> outside class declaration"
-msgstr "virtual вне декларации класса"
+msgstr "%<virtual%> вне декларации класса"
  
  #: cp/decl.c:9910
  #, gcc-internal-format
@@ -41119,12 +42838,13 @@ msgstr ""
  #: cp/decl.c:10133
  #, gcc-internal-format
  msgid "%qs function uses %<auto%> type specifier without trailing return type"
-msgstr ""
+msgstr "%qs функция использует %<auto%> спецификатор типа без завершающего типа возврата"
  
  #: cp/decl.c:10136
  #, fuzzy, gcc-internal-format
+#| msgid "trailing return type only available with -std=c++11 or -std=gnu++11"
  msgid "deduced return type only available with -std=c++14 or -std=gnu++14"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qs Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+msgstr "Ð·Ð°Ð²ÐµÑ\80Ñ\88Ð°Ñ\8eÑ\89Ð¸Ð¹ Ñ\82Ð¸Ð¿ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿ÐµÐ½ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ñ\81 -std=c++11 Ð¸Ð»Ð¸ -std=gnu++11"
  
  #: cp/decl.c:10142
  #, fuzzy, gcc-internal-format
@@ -41135,19 +42855,19 @@ msgstr "виртуальные функции не могут быть friend-ф
  #: cp/decl.c:10149
  #, gcc-internal-format
  msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>"
-msgstr ""
+msgstr "%qs функция с завершающим типом возврата имеет %qT в качестве своего типа а не обычный %<auto%>"
  
  #. Not using maybe_warn_cpp0x because this should
  #. always be an error.
  #: cp/decl.c:10161
  #, gcc-internal-format
  msgid "trailing return type only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "завершающий тип возврата доступен только с -std=c++11 или -std=gnu++11"
  
  #: cp/decl.c:10164
  #, gcc-internal-format
  msgid "%qs function with trailing return type not declared with %<auto%> type specifier"
-msgstr ""
+msgstr "%qs функция с завершающим типом возврата не декларирована с %<auto%> спецификатором типа"
  
  #: cp/decl.c:10201
  #, gcc-internal-format
@@ -41155,9 +42875,9 @@ msgid "destructor cannot be static member function"
  msgstr "деструктор не может быть статической элементом-функцией"
  
  #: cp/decl.c:10202
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "constructor cannot be static member function"
-msgstr "Ð´Ðµструктор не может быть статической элементом-функцией"
+msgstr "ÐºÐ¾Ð½структор не может быть статической элементом-функцией"
  
  #: cp/decl.c:10206
  #, gcc-internal-format
@@ -41165,9 +42885,9 @@ msgid "destructors may not be cv-qualified"
  msgstr "деструкторы не могут быть cv-квалифицированы"
  
  #: cp/decl.c:10207
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "constructors may not be cv-qualified"
-msgstr "Ð´Ðµструкторы не могут быть cv-квалифицированы"
+msgstr "ÐºÐ¾Ð½структоры не могут быть cv-квалифицированы"
  
  #: cp/decl.c:10215
  #, fuzzy, gcc-internal-format
@@ -41193,14 +42913,15 @@ msgid "friend declaration not in class definition"
  msgstr "friend-декларация вне определения класса"
  
  #: cp/decl.c:10255
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t define friend function %qs in a local class definition"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ friend-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs в определении локального класса"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»Ð¸Ñ\82Ñ\8c friend-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8e %qs в определении локального класса"
  
  #: cp/decl.c:10267
  #, fuzzy, gcc-internal-format
+#| msgid "%qs function cannot have arguments"
  msgid "a conversion function cannot have a trailing return type"
-msgstr "%qD не может иметь аргументов по умолчанию"
+msgstr "%qs функция не может иметь аргументы"
  
  #: cp/decl.c:10278
  #, gcc-internal-format
@@ -41223,14 +42944,14 @@ msgid "cannot declare pointer to %q#T member"
  msgstr "недопустимая декларация указателя на элемент %q#T"
  
  #: cp/decl.c:10366
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot declare reference to qualified function type %qT"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ Ð½Ð° %q#T"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81Ñ\81Ñ\8bÐ»ÐºÑ\83 Ð½Ð° ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qT"
  
  #: cp/decl.c:10367
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot declare pointer to qualified function type %qT"
-msgstr "Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f %s Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qT"
  
  #: cp/decl.c:10437
  #, gcc-internal-format
@@ -41258,9 +42979,9 @@ msgid "cannot define member function %<%T::%s%> within %<%T%>"
  msgstr "недопустимая декларация элемента-функции %<%T::%s%> внутри %<%T%>"
  
  #: cp/decl.c:10568
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot declare member function %<%T::%s%> within %<%T%>"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð°-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %<%T::%s%> внутри %<%T%>"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8e %<%T::%s%> внутри %<%T%>"
  
  #: cp/decl.c:10576
  #, gcc-internal-format
@@ -41284,8 +43005,9 @@ msgstr "параметр не может иметь модифицированн
  
  #: cp/decl.c:10630
  #, fuzzy, gcc-internal-format
+#| msgid "%<virtual%> outside class declaration"
  msgid "%<explicit%> outside class declaration"
-msgstr "virtual вне декларации класса"
+msgstr "%<virtual%> вне декларации класса"
  
  #: cp/decl.c:10633
  #, fuzzy, gcc-internal-format
@@ -41325,14 +43047,14 @@ msgid "const %qs cannot be declared %<mutable%>"
  msgstr "недопустимая декларация константного %qs как %<mutable%>"
  
  #: cp/decl.c:10671
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "reference %qs cannot be declared %<mutable%>"
-msgstr "недопустимая декларация функции %qs как %<mutable%>"
+msgstr "ссылка %qs не может быть декларирована %<mutable%>"
  
  #: cp/decl.c:10707
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "typedef declared %<auto%>"
-msgstr "параметр %q+D объявлен %<inline%>"
+msgstr "typedef декларирован %<auto%>"
  
  #: cp/decl.c:10712
  #, gcc-internal-format
@@ -41340,9 +43062,9 @@ msgid "requires-clause on typedef"
  msgstr ""
  
  #: cp/decl.c:10720
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "typedef name may not be a nested-name-specifier"
-msgstr "%Jдля typedef-имени недопустимы квалификаторы классов"
+msgstr "typedef имя не может быть вложенным спецификатором имени"
  
  #: cp/decl.c:10741
  #, gcc-internal-format
@@ -41391,8 +43113,9 @@ msgstr "абстрактный декларатор %qT использован 
  
  #: cp/decl.c:10935
  #, fuzzy, gcc-internal-format
+#| msgid "value-initialization of function type %qT"
  msgid "requires-clause on declaration of non-function type %qT"
-msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f `%#D', Ð¸Ð¼ÐµÑ\8eÑ\89ÐµÐ³Ð¾ Ñ\82Ð¸Ð¿ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸"
+msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¾Ð½Ð°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
  
  #: cp/decl.c:10953
  #, gcc-internal-format
@@ -41406,14 +43129,14 @@ msgid "%<auto%> parameter not permitted in this context"
  msgstr "%<this%> недопустим в данном контексте"
  
  #: cp/decl.c:10960
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter declared %<auto%>"
-msgstr "параметр %q+D объявлен %<inline%>"
+msgstr "параметр декларирован %<auto%>"
  
  #: cp/decl.c:11006
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-static data member declared %<auto%>"
-msgstr "статический элемент %qD объявлен как %<register%>"
+msgstr "нестатический элемент данных декларирован %<auto%>"
  
  #. Something like struct S { int N::j; };
  #: cp/decl.c:11037
@@ -41422,9 +43145,9 @@ msgid "invalid use of %<::%>"
  msgstr "недопустимое использование %<::%>"
  
  #: cp/decl.c:11059
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of function %qD in invalid context"
-msgstr "декларация C-функции `%#D' противоречит"
+msgstr "декларация функции %qD в неверном контексте"
  
  #: cp/decl.c:11068
  #, fuzzy, gcc-internal-format
@@ -41439,49 +43162,54 @@ msgid "%qD cannot be declared %<virtual%>, since it is always static"
  msgstr "%qD не может быть объявлена виртуальной, поскольку она всегда статическая"
  
  #: cp/decl.c:11093
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected qualified name in friend declaration for destructor %qD"
-msgstr "ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ñ\8b Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ `operator %T'"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ðµ Ð¸Ð¼Ñ\8f Ð² friend Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð´Ð»Ñ\8f Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ð° %qD"
  
  #: cp/decl.c:11100
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %qD as member of %qT"
-msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÐ²Ð°ÐµÑ\82 Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 ÐºÐ»Ð°Ñ\81Ñ\81Ð°, Ð½Ð° ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐ¹ Ñ\83ÐºÐ°Ð·Ñ\8bÐ²Ð°ÐµÑ\82 'this'"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD ÐºÐ°Ðº Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° %qT"
  
  #: cp/decl.c:11106
  #, fuzzy, gcc-internal-format
+#| msgid "a destructor cannot be %<constexpr%>"
  msgid "a destructor cannot be %<concept%>"
-msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ°Ðº virtual"
+msgstr "Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80 Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c %<constexpr%>"
  
  #: cp/decl.c:11111
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "a destructor cannot be %<constexpr%>"
-msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ°Ðº virtual"
+msgstr "Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80 Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c %<constexpr%>"
  
  #: cp/decl.c:11117
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected qualified name in friend declaration for constructor %qD"
-msgstr "ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ñ\8b Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ `operator %T'"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ðµ Ð¸Ð¼Ñ\8f Ð² friend Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð´Ð»Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ð° %qD"
  
  #: cp/decl.c:11125
  #, fuzzy, gcc-internal-format
+#| msgid "a destructor cannot be %<constexpr%>"
  msgid "a constructor cannot be %<concept%>"
-msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ°Ðº virtual"
+msgstr "Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80 Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c %<constexpr%>"
  
  #: cp/decl.c:11130
  #, fuzzy, gcc-internal-format
+#| msgid "constructor cannot be static member function"
  msgid "a concept cannot be a member function"
-msgstr "Ð´Ðµструктор не может быть статической элементом-функцией"
+msgstr "ÐºÐ¾Ð½структор не может быть статической элементом-функцией"
  
  #: cp/decl.c:11139
  #, fuzzy, gcc-internal-format
+#| msgid "variable %qD redeclared as function"
  msgid "specialization of variable template %qD declared as function"
-msgstr "явная специализация не-шаблона %qT"
+msgstr "переменная %qD повторно декларирована как функция"
  
  #: cp/decl.c:11142
  #, fuzzy, gcc-internal-format
+#| msgid "original type declared here"
  msgid "variable template declared here"
-msgstr "%J  исходное определение находится здесь"
+msgstr "исходный тип объявлен здесь"
  
  #: cp/decl.c:11198
  #, fuzzy, gcc-internal-format
@@ -41495,29 +43223,31 @@ msgid "name %qT has incomplete type"
  msgstr "имя %qT имеет неполный тип"
  
  #: cp/decl.c:11213
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is neither function nor member function; cannot be declared friend"
-msgstr "%qs не является ни функцией, ни элементом-функцией; friend-декларация не допускается"
+msgstr "%qE не является ни функцией, ни элементом-функцией; не может быть декларировано как friend"
  
  #: cp/decl.c:11272
  #, fuzzy, gcc-internal-format
+#| msgid "non-static data member %qE declared %<constexpr%>"
  msgid "static data member %qE declared %<concept%>"
-msgstr "статический элемент %qD объявлен как %<register%>"
+msgstr "нестатический элемент данных %qE объявлен как %<constexpr%>"
  
  #: cp/decl.c:11276
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "constexpr static data member %qD must have an initializer"
-msgstr "`%#D' не является нестатическим элементом %qT"
+msgstr "constexpr статический элемент данных %qD должен иметь инициализатор"
  
  #: cp/decl.c:11284
  #, fuzzy, gcc-internal-format
+#| msgid "non-static data member %qE declared %<constexpr%>"
  msgid "non-static data member %qE declared %<concept%>"
-msgstr "статический элемент %qD объявлен как %<register%>"
+msgstr "нестатический элемент данных %qE объявлен как %<constexpr%>"
  
  #: cp/decl.c:11288
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-static data member %qE declared %<constexpr%>"
-msgstr "статический элемент %qD объявлен как %<register%>"
+msgstr "нестатический элемент данных %qE объявлен как %<constexpr%>"
  
  #: cp/decl.c:11338
  #, gcc-internal-format
@@ -41536,13 +43266,14 @@ msgstr "некорректный класс хранения %<__thread%> для
  
  #: cp/decl.c:11347
  #, fuzzy, gcc-internal-format
+#| msgid "storage class %<__thread%> invalid for function %qs"
  msgid "storage class %<thread_local%> invalid for function %qs"
  msgstr "некорректный класс хранения %<__thread%> для функции %qs"
  
  #: cp/decl.c:11352
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "virt-specifiers in %qs not allowed outside a class definition"
-msgstr "спецификация asm не допускается при определении функции"
+msgstr "virt-спецификаторы в %qs не допускаются вне определения класса"
  
  #: cp/decl.c:11363
  #, gcc-internal-format
@@ -41560,14 +43291,14 @@ msgid "virtual non-class function %qs"
  msgstr "виртуальная функция %qs не является элементом класса"
  
  #: cp/decl.c:11382
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs defined in a non-class scope"
-msgstr "атрибут %qE для не классовых типов игнорируется"
+msgstr "%qs определен не в контексте класса"
  
  #: cp/decl.c:11383
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs declared in a non-class scope"
-msgstr "атрибут %qE для не классовых типов игнорируется"
+msgstr "%qs декларирован не в контексте класса"
  
  #: cp/decl.c:11416
  #, gcc-internal-format
@@ -41596,9 +43327,9 @@ msgid "cannot explicitly declare member %q#D to have extern linkage"
  msgstr "недопустимая явная extern-декларация элемента %q#D"
  
  #: cp/decl.c:11477
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of constexpr variable %qD is not a definition"
-msgstr "декларация %q#D вне класса не является определением"
+msgstr "декларация constexpr переменной %qD не является определением"
  
  #: cp/decl.c:11490
  #, gcc-internal-format
@@ -41611,29 +43342,33 @@ msgid "%qs has both %<extern%> and initializer"
  msgstr "для %qs задан спецификатор %<extern%> и инициализатор"
  
  #: cp/decl.c:11641
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "default argument %qE uses %qD"
-msgstr "аргумент по умолчанию %qE использует локальную переменную %qD"
+msgstr "аргумент по умолчанию %qE использует %qD"
  
  #: cp/decl.c:11644
  #, gcc-internal-format
  msgid "default argument %qE uses local variable %qD"
  msgstr "аргумент по умолчанию %qE использует локальную переменную %qD"
  
+#
  #: cp/decl.c:11729
  #, fuzzy, gcc-internal-format
+#| msgid "invalid use of %<virtual%> in template declaration of %q#D"
  msgid "invalid use of cv-qualified type %qT in parameter declaration"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f template-Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ %<virtual%> Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %q#D"
  
+#
  #: cp/decl.c:11733
  #, fuzzy, gcc-internal-format
+#| msgid "invalid use of %<virtual%> in template declaration of %q#D"
  msgid "invalid use of type %<void%> in parameter declaration"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f template-Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ %<virtual%> Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %q#D"
  
  #: cp/decl.c:11746
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter %qD has Java class type"
-msgstr "параметр %q+D имеет неполный тип"
+msgstr "параметр %q+D имеет тип Java класса"
  
  #: cp/decl.c:11774
  #, gcc-internal-format
@@ -41641,14 +43376,14 @@ msgid "parameter %qD invalidly declared method type"
  msgstr "некорректная декларация параметра %qD с типом метода"
  
  #: cp/decl.c:11799
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter %qD includes pointer to array of unknown bound %qT"
-msgstr "параметр %qD включает %s на массив с неизвестной границей %qT"
+msgstr "параметр %qD включает указатель на массив с неизвестной границей %qT"
  
  #: cp/decl.c:11801
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter %qD includes reference to array of unknown bound %qT"
-msgstr "параметр %qD включает %s на массив с неизвестной границей %qT"
+msgstr "параметр %qD включает ссылку на массив с неизвестной границей %qT"
  
  #. [class.copy]
  #.
@@ -41696,34 +43431,34 @@ msgid "%qD must have an argument of class or enumerated type"
  msgstr "%qD должен иметь аргумент типа класс или перечислимого типа"
  
  #: cp/decl.c:12264
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to a reference to void will never use a type conversion operator"
-msgstr "преобразование к %s%s никогда не будет использовать операцию преобразования типа"
+msgstr "преобразование к ссылке на void никогда не будет использовать операцию преобразования типа"
  
  #: cp/decl.c:12266
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to void will never use a type conversion operator"
-msgstr "преобразование к %s%s никогда не будет использовать операцию преобразования типа"
+msgstr "преобразование к void никогда не использует операцию преобразования типа"
  
  #: cp/decl.c:12273
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to a reference to the same type will never use a type conversion operator"
-msgstr "преобразование к %s%s никогда не будет использовать операцию преобразования типа"
+msgstr "преобразование к ссылке на тот же тип никогда не будет использовать операцию преобразования типа"
  
  #: cp/decl.c:12275
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to the same type will never use a type conversion operator"
-msgstr "преобразование к %s%s никогда не будет использовать операцию преобразования типа"
+msgstr "преобразование к тому же типу никогда не будет использовать операцию преобразования типа"
  
  #: cp/decl.c:12283
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to a reference to a base class will never use a type conversion operator"
-msgstr "преобразование к %s%s никогда не будет использовать операцию преобразования типа"
+msgstr "преобразование к ссылке на базовый класс никогда не будет использовать операцию преобразования типа"
  
  #: cp/decl.c:12285
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion to a base class will never use a type conversion operator"
-msgstr "преобразование к %s%s никогда не будет использовать операцию преобразования типа"
+msgstr "преобразование к базовому классу никогда не будет использовать операцию преобразования типа"
  
  #. 13.4.0.3
  #: cp/decl.c:12294
@@ -41802,9 +43537,9 @@ msgid "using template type parameter %qT after %qs"
  msgstr "использование параметра шаблона %qT после %qs"
  
  #: cp/decl.c:12533
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "using alias template specialization %qT after %qs"
-msgstr "Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð°Ñ\8f ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD Ð´Ð»Ñ\8f %q+D"
+msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\81Ð¸Ð½Ð¾Ð½Ð¸Ð¼Ð° Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qT Ð¿Ð¾Ñ\81Ð»Ðµ %qs"
  
  #: cp/decl.c:12536
  #, gcc-internal-format
@@ -41812,9 +43547,9 @@ msgid "using typedef-name %qD after %qs"
  msgstr "использование typedef-имени %qD после %qs"
  
  #: cp/decl.c:12538
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD has a previous declaration here"
-msgstr "%q+D ранее декларирован здесь"
+msgstr "%qD ранее декларирован здесь"
  
  #: cp/decl.c:12546
  #, gcc-internal-format
@@ -41856,8 +43591,9 @@ msgstr "%qT не является шаблоном"
  
  #: cp/decl.c:12653 cp/friend.c:262 cp/tree.c:3713
  #, fuzzy, gcc-internal-format
+#| msgid "previous declaration %q+#D here"
  msgid "previous declaration here"
-msgstr "предыдущей декларации `%#D', которая находится здесь"
+msgstr "предыдущей декларации %q+#D здесь"
  
  #: cp/decl.c:12657
  #, gcc-internal-format
@@ -41907,8 +43643,9 @@ msgstr "Java-класс %qT не может иметь виртуальных б
  
  #: cp/decl.c:12992
  #, fuzzy, gcc-internal-format
+#| msgid "type %qT is not a direct or virtual base of %qT"
  msgid "%qT defined with direct virtual base"
-msgstr "тип %qD не является непосредственной или виртуальной базой для %qT"
+msgstr "тип %qT не является непосредственной или виртуальной базой %qT"
  
  #: cp/decl.c:13010
  #, gcc-internal-format
@@ -41928,27 +43665,27 @@ msgstr "некорректное дублирование базового ти
  #: cp/decl.c:13175
  #, gcc-internal-format
  msgid "scoped/unscoped mismatch in enum %q#T"
-msgstr ""
+msgstr "scoped/unscoped рассогласование в enum %q#T"
  
  #: cp/decl.c:13178 cp/decl.c:13186 cp/decl.c:13198 cp/parser.c:17258
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "previous definition here"
-msgstr "%Jэто предыдущее определение"
+msgstr "предыдущее определение здесь"
  
  #: cp/decl.c:13183
  #, gcc-internal-format
  msgid "underlying type mismatch in enum %q#T"
-msgstr ""
+msgstr "рассогласование основного типа в enum %q#T"
  
  #: cp/decl.c:13195
  #, gcc-internal-format
  msgid "different underlying type in enum %q#T"
-msgstr ""
+msgstr "отличающийся основной тип в enum %q#T"
  
  #: cp/decl.c:13267
  #, gcc-internal-format
  msgid "underlying type %<%T%> of %<%T%> must be an integral type"
-msgstr ""
+msgstr "основной тип %<%T%> %<%T%> должен быть целочисленным типом"
  
  #. DR 377
  #.
@@ -41965,9 +43702,9 @@ msgid "enumerator value for %qD is not an integer constant"
  msgstr "значение перечислимого типа для %qD не является константой целого типа"
  
  #: cp/decl.c:13616
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "incremented enumerator value is too large for %<unsigned long%>"
-msgstr "Ñ\86ÐµÐ»Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð²ÐµÐ»Ð¸ÐºÐ° Ð´Ð»Ñ\8f Ñ\82Ð¸Ð¿Ð° %qs"
+msgstr "Ñ\83Ð²ÐµÐ»Ð¸Ñ\87ÐµÐ½Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ñ\8f Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð²ÐµÐ»Ð¸ÐºÐ¾ Ð´Ð»Ñ\8f %<unsigned long%>"
  
  #: cp/decl.c:13628
  #, gcc-internal-format
@@ -41976,8 +43713,9 @@ msgstr "переполнение в перечисляемых значения
  
  #: cp/decl.c:13648
  #, fuzzy, gcc-internal-format
+#| msgid "enumerator value %E is too large for underlying type %<%T%>"
  msgid "enumerator value %E is outside the range of underlying type %<%T%>"
-msgstr "Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»Ð¸Ð¼Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° Ð´Ð»Ñ\8f %qE Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹ Ñ\86ÐµÐ»Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ñ\8f %qE Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð²ÐµÐ»Ð¸ÐºÐ¾ Ð´Ð»Ñ\8f Ð¾Ñ\81Ð½Ð¾Ð²Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %<%T%>"
  
  #: cp/decl.c:13741
  #, gcc-internal-format
@@ -41985,9 +43723,9 @@ msgid "return type %q#T is incomplete"
  msgstr "тип результата %q#T неполный"
  
  #: cp/decl.c:13743
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "return type has Java class type %q#T"
-msgstr "тип возвращаемого значения не полный"
+msgstr "возвращаемый тип имеет тип Java класса %q#T"
  
  #: cp/decl.c:13915 cp/typeck.c:8820
  #, gcc-internal-format
@@ -41995,22 +43733,24 @@ msgid "%<operator=%> should return a reference to %<*this%>"
  msgstr "%<operator=%> должен возвращать ссылку на %<*this%>"
  
  #: cp/decl.c:14258
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid function declaration"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð°-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "некорректная декларация функции"
  
  #: cp/decl.c:14340
  #, gcc-internal-format
  msgid "parameter %qD declared void"
-msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %qD Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»Ðµн void"
+msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %qD Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°н void"
  
  #: cp/decl.c:14689
  #, fuzzy, gcc-internal-format
+#| msgid "no return statement in function returning non-void"
  msgid "no return statements in function returning %qT"
  msgstr "в функции, которая должна возвращать значение, отсутствует оператор return"
  
  #: cp/decl.c:14691 cp/typeck.c:8701
  #, fuzzy, gcc-internal-format
+#| msgid "function return types not compatible due to %<volatile%>"
  msgid "only plain %<auto%> return type can be deduced to %<void%>"
  msgstr "типы возвращаемых значений функции несовместимы из-за %<volatile%>"
  
@@ -42026,8 +43766,9 @@ msgstr "%qD уже определена в классе %qT"
  
  #: cp/decl.c:15278 cp/decl2.c:5133 cp/decl2.c:5183
  #, fuzzy, gcc-internal-format
+#| msgid "type of %qD defaults to %<int%>"
  msgid "use of %qD before deduction of %<auto%>"
-msgstr "по умолчанию для %q+D принят тип %<int%>"
+msgstr "по умолчанию для %qD принят тип %<int%>"
  
  #: cp/decl2.c:332
  #, gcc-internal-format
@@ -42046,6 +43787,7 @@ msgstr "некорректные типы %<%T[%T]%> для индекса ма
  
  #: cp/decl2.c:466
  #, fuzzy, gcc-internal-format
+#| msgid "deleting array %q#D"
  msgid "deleting array %q#E"
  msgstr "удаление массива %q#D"
  
@@ -42080,9 +43822,9 @@ msgid "Java method %qD has non-Java parameter type %qT"
  msgstr "Java-метод %qD имеет параметр типа %qT, не поддерживаемого Java"
  
  #: cp/decl2.c:658
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template parameter lists provided don%'t match the template parameters of %qD"
-msgstr "параметры не подходят шаблону"
+msgstr "предоставленные списки параметров шаблона не соответствуют параметрам шаблона %qD"
  
  #. [temp.mem]
  #.
@@ -42104,18 +43846,20 @@ msgstr "локальный класс %q#T не должен иметь стат
  
  #: cp/decl2.c:843
  #, fuzzy, gcc-internal-format
+#| msgid "non-static data member %qD has Java class type"
  msgid "static data member %qD in unnamed class"
-msgstr "`%#D' не является нестатическим элементом %qT"
+msgstr "нестатический элемент данных %qD имеет тип Java класса"
  
  #: cp/decl2.c:845
  #, fuzzy, gcc-internal-format
+#| msgid "union defined here"
  msgid "unnamed class defined here"
-msgstr "это предыдущее определение `%#D'"
+msgstr "объединение определено здесь"
  
  #: cp/decl2.c:904
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "explicit template argument list not allowed"
-msgstr "некорректный аргумент шаблона %d"
+msgstr "явный список аргументов шаблона не допускается"
  
  #: cp/decl2.c:910
  #, gcc-internal-format
@@ -42128,9 +43872,9 @@ msgid "%qD is already defined in %qT"
  msgstr "определение %qD уже есть в %qT"
  
  #: cp/decl2.c:979 cp/decl2.c:987
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid initializer for member function %qD"
-msgstr "некорректное начальное значение для элемента %qs"
+msgstr "некорректный инициализатор для элемента-функции %qD"
  
  #: cp/decl2.c:994
  #, fuzzy, gcc-internal-format
@@ -42174,14 +43918,15 @@ msgid "static member %qD cannot be a bit-field"
  msgstr "статический элемент %qD не может быть битовым полем"
  
  #: cp/decl2.c:1134
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "width of bit-field %qD has non-integral type %qT"
-msgstr "битовое поле %qD не целочисленного типа"
+msgstr "ширина битового поля %qD имеет нецелочисленный тип %qT"
  
  #: cp/decl2.c:1458
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not a static data member of a class template"
  msgid "%q+D static data member inside of declare target directive"
-msgstr "`%#D' не является нестатическим элементом %qT"
+msgstr "%qD не является статическим элементом данных шаблона класса"
  
  #: cp/decl2.c:1522
  #, gcc-internal-format
@@ -42231,18 +43976,18 @@ msgstr "%<operator delete%> имеет первый параметр типа %q
  #, fuzzy, gcc-internal-format
  #| msgid "%qT has a field %qD whose type uses the anonymous namespace"
  msgid "%qT has a field %qD whose type has no linkage"
-msgstr "%qT имеет поле %qD, использующее анонимное пространоство имён"
+msgstr "%qT имеет поле %qD, использующее анонимное пространство имён"
  
  #: cp/decl2.c:2576
  #, fuzzy, gcc-internal-format
  #| msgid "%qT has a field %qD whose type uses the anonymous namespace"
  msgid "%qT has a field %qD whose type depends on the type %qT which has no linkage"
-msgstr "%qT имеет поле %qD, использующее анонимное пространоство имён"
+msgstr "%qT имеет поле %qD, использующее анонимное пространство имён"
  
  #: cp/decl2.c:2581
  #, gcc-internal-format
  msgid "%qT has a field %qD whose type uses the anonymous namespace"
-msgstr "%qT имеет поле %qD, использующее анонимное пространоство имён"
+msgstr "%qT имеет поле %qD, использующее анонимное пространство имён"
  
  #: cp/decl2.c:2589
  #, gcc-internal-format
@@ -42253,18 +43998,18 @@ msgstr "%qT объявлен с большей областью видимост
  #, fuzzy, gcc-internal-format
  #| msgid "%qT has a base %qT whose type uses the anonymous namespace"
  msgid "%qT has a base %qT whose type has no linkage"
-msgstr "%qT наследован от %qT, использующего анонимное пространоство имён"
+msgstr "%qT наследован от %qT, использующего анонимное пространство имён"
  
  #: cp/decl2.c:2611
  #, fuzzy, gcc-internal-format
  #| msgid "%qT has a base %qT whose type uses the anonymous namespace"
  msgid "%qT has a base %qT whose type depends on the type %qT which has no linkage"
-msgstr "%qT наследован от %qT, использующего анонимное пространоство имён"
+msgstr "%qT наследован от %qT, использующего анонимное пространство имён"
  
  #: cp/decl2.c:2616
  #, gcc-internal-format
  msgid "%qT has a base %qT whose type uses the anonymous namespace"
-msgstr "%qT наследован от %qT, использующего анонимное пространоство имён"
+msgstr "%qT наследован от %qT, использующего анонимное пространство имён"
  
  #: cp/decl2.c:2623
  #, gcc-internal-format
@@ -42273,8 +44018,9 @@ msgstr "%qT объявлен с большей областью видимост
  
  #: cp/decl2.c:4263
  #, fuzzy, gcc-internal-format
+#| msgid "%q+#D, declared using anonymous type, is used but never defined"
  msgid "%q#D, declared using anonymous type, is used but never defined"
-msgstr "%q+F объявлена %<static%>, но нигде не определена"
+msgstr "%q+#D, декларированное посредством анонимного типа, используется, но не определяется"
  
  #. DRs 132, 319 and 389 seem to indicate types with
  #. no linkage can only be used to declare extern "C"
@@ -42283,12 +44029,12 @@ msgstr "%q+F объявлена %<static%>, но нигде не определ
  #: cp/decl2.c:4272
  #, gcc-internal-format
  msgid "anonymous type with no linkage used to declare variable %q#D with linkage"
-msgstr ""
+msgstr "анонимный тип без привязки использован для декларации переменной %q#D с привязкой"
  
  #: cp/decl2.c:4276
  #, gcc-internal-format
  msgid "anonymous type with no linkage used to declare function %q#D with linkage"
-msgstr ""
+msgstr "анонимный тип без привязки использован для декларации функции %q#D с привязкой"
  
  #: cp/decl2.c:4280
  #, fuzzy, gcc-internal-format
@@ -42298,18 +44044,19 @@ msgstr "%q+#D не ссылается на неквалифицированны
  
  #: cp/decl2.c:4288
  #, fuzzy, gcc-internal-format
+#| msgid "%q+#D, declared using local type %qT, is used but never defined"
  msgid "%q#D, declared using local type %qT, is used but never defined"
-msgstr "%q+F объявлена %<static%>, но нигде не определена"
+msgstr "%q+#D, декларированное посредством локального типа %qT, используется, но не определяется"
  
  #: cp/decl2.c:4292
  #, gcc-internal-format
  msgid "type %qT with no linkage used to declare variable %q#D with linkage"
-msgstr ""
+msgstr "тип %qT без привязки использован для декларации переменной %q#D с привязкой"
  
  #: cp/decl2.c:4295
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type %qT with no linkage used to declare function %q#D with linkage"
-msgstr "предыдущая декларация `%#D' с привязкой %L"
+msgstr "тип %qT без привязки использован для декларации функции %q#D с привязкой"
  
  #: cp/decl2.c:4482 cp/decl2.c:4485
  #, gcc-internal-format
@@ -42332,92 +44079,96 @@ msgstr "отсутствует аргумент по умолчанию для 
  #: cp/decl2.c:5105
  #, gcc-internal-format
  msgid "converting lambda which uses %<...%> to function pointer"
-msgstr ""
+msgstr "преобразование lambda, использующей %<...%>, к указателю на функцию"
  
  #: cp/decl2.c:5112
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use of deleted function %qD"
-msgstr "Ð²Ñ\8bÐ·Ð¾Ð² Ð½Ðµ функции %qD"
+msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\83Ð´Ð°Ð»ÐµÐ½Ð½Ð¾Ð¹ функции %qD"
  
  #: cp/error.c:1450
  #, gcc-internal-format
  msgid "with"
-msgstr ""
+msgstr "с"
  
  #: cp/error.c:3581
  #, gcc-internal-format
  msgid "extended initializer lists only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "расширенные списки инициализации доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3586
  #, gcc-internal-format
  msgid "explicit conversion operators only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "явные операции преобразования доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3591
  #, gcc-internal-format
  msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "вариантные шаблоны доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3596
  #, gcc-internal-format
  msgid "lambda expressions only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "lambda-выражения доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3601
  #, fuzzy, gcc-internal-format
+#| msgid "C++0x auto only available with -std=c++11 or -std=gnu++11"
  msgid "C++11 auto only available with -std=c++11 or -std=gnu++11"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "C++0x auto доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3605
  #, gcc-internal-format
  msgid "scoped enums only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "scoped enums доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3609
  #, gcc-internal-format
  msgid "defaulted and deleted functions only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "сведенные к подразумеваемым и удаленные функции доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3614
  #, gcc-internal-format
  msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "inline namespaces доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3619
  #, gcc-internal-format
  msgid "override controls (override/final) only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "override controls (override/final) доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3624
  #, gcc-internal-format
  msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "инициализаторы нестатических элементов данных доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3629
  #, gcc-internal-format
  msgid "user-defined literals only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "определенные пользователем литералы доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3634
  #, gcc-internal-format
  msgid "delegating constructors only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "делегирующие конструкторы доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3639
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "delegating constructors only available with -std=c++11 or -std=gnu++11"
  msgid "inheriting constructors only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "делегирующие конструкторы доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3644
  #, fuzzy, gcc-internal-format
+#| msgid "C++0x auto only available with -std=c++11 or -std=gnu++11"
  msgid "c++11 attributes only available with -std=c++11 or -std=gnu++11"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "C++0x auto доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/error.c:3649
  #, fuzzy, gcc-internal-format
+#| msgid "user-defined literals only available with -std=c++11 or -std=gnu++11"
  msgid "ref-qualifiers only available with -std=c++11 or -std=gnu++11"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qs Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+msgstr "Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ñ\8bÐµ Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8b Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ñ\8b Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ñ\81 -std=c++11 Ð¸Ð»Ð¸ -std=gnu++11"
  
  #: cp/error.c:3699
  #, gcc-internal-format
@@ -42425,9 +44176,9 @@ msgid "incomplete type %qT used in nested name specifier"
  msgstr "неполный тип %qT использован во вложенном спецификаторе имени"
  
  #: cp/error.c:3703
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "reference to %<%T::%D%> is ambiguous"
-msgstr "использование %qD неоднозначно"
+msgstr "ссылка на %<%T::%D%> неоднозначна"
  
  #: cp/error.c:3708 cp/typeck.c:2339
  #, gcc-internal-format
@@ -42488,43 +44239,47 @@ msgstr "  в throw-выражении"
  
  #: cp/except.c:997
  #, fuzzy, gcc-internal-format
+#| msgid "cannot declare parameter %q+D to be of abstract type %qT"
  msgid "cannot declare catch parameter to be of rvalue reference type %qT"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %qD Ñ\81 типом %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %q+D Ñ\81 Ð°Ð±Ñ\81Ñ\82Ñ\80Ð°ÐºÑ\82Ð½Ñ\8bÐ¼ типом %qT"
  
  #: cp/except.c:1004
  #, fuzzy, gcc-internal-format
+#| msgid "cannot create type information for type %qT because it involves types of variable size"
  msgid "cannot throw expression of type %qT because it involves types of variable size"
-msgstr "создание информации о типе %qT невозможно, поскольку он имеет переменный размер"
+msgstr "невозможно создать информацию о типе для типа %qT поскольку он включает типы переменного размера"
  
  #: cp/except.c:1007
  #, fuzzy, gcc-internal-format
+#| msgid "cannot create type information for type %qT because it involves types of variable size"
  msgid "cannot catch type %qT because it involves types of variable size"
-msgstr "создание информации о типе %qT невозможно, поскольку он имеет переменный размер"
+msgstr "невозможно создать информацию о типе для типа %qT поскольку он включает типы переменного размера"
  
  #: cp/except.c:1094
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "exception of type %qT will be caught"
-msgstr "%Hбудет обработана исключительная ситуация типа %qT"
+msgstr "исключительная ситуация типа %qT будет обработана"
  
  #: cp/except.c:1097
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "   by earlier handler for %qT"
-msgstr "%H   при помощи ранее заданного обработчика для %qT"
+msgstr "   ранее заданным обработчиком для %qT"
  
  #: cp/except.c:1126
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<...%> handler must be the last handler for its try block"
-msgstr "%Hобработчик %<...%> должен быть последним в своем try-блоке"
+msgstr "обработчик %<...%> должен быть последним в своем try-блоке"
  
  #: cp/except.c:1208
  #, gcc-internal-format
  msgid "noexcept-expression evaluates to %<false%> because of a call to %qD"
-msgstr ""
+msgstr "noexcept-expression приводится к %<false%> из-за вызова %qD"
  
  #: cp/except.c:1211
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "but %q+D does not throw; perhaps it should be declared %<noexcept%>"
  msgid "but %qD does not throw; perhaps it should be declared %<noexcept%>"
-msgstr ""
+msgstr "но %q+D не делает throw; возможно его следует декларировать %<noexcept%>"
  
  #: cp/friend.c:149
  #, gcc-internal-format
@@ -42564,9 +44319,9 @@ msgid "%qT is not a member of %qT"
  msgstr "%qT не является элементом %qT"
  
  #: cp/friend.c:337
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qT is not a member class template of %qT"
-msgstr "%qD не является элементом типа %qT"
+msgstr "%qT не является элементом шаблона класса %qT"
  
  #: cp/friend.c:346
  #, gcc-internal-format
@@ -42575,15 +44330,15 @@ msgstr "%qT не вложен в %qT"
  
  #. template <class T> friend class T;
  #: cp/friend.c:360
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template parameter type %qT declared %<friend%>"
-msgstr "параметр шаблона тип %qT объявлен `friend'"
+msgstr "тип параметра шаблона %qT декларирован %<friend%>"
  
  #. template <class T> friend class A; where A is not a template
  #: cp/friend.c:368
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#T is not a template"
-msgstr "%qT не является шаблоном"
+msgstr "%q#T не шаблон"
  
  #: cp/friend.c:391
  #, gcc-internal-format
@@ -42597,8 +44352,9 @@ msgstr "%qT уже friend для %qT"
  
  #: cp/friend.c:441
  #, fuzzy, gcc-internal-format
+#| msgid "friend declaration %q#D declares a non-template function"
  msgid "friend declaration %qD may not have virt-specifiers"
-msgstr "friend-декларация `%#D' объявляет нешаблонную функцию"
+msgstr "friend декларация %q#D декларирует нешаблонную функцию"
  
  #: cp/friend.c:534
  #, gcc-internal-format
@@ -42606,44 +44362,46 @@ msgid "member %qD declared as friend before type %qT defined"
  msgstr "элемент %qD объявлен другом до определения типа %qT"
  
  #: cp/friend.c:583
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "friend declaration %qD in local class without prior declaration"
-msgstr "%Jсекция, заданная для %qD, противоречит предшествующей декларации"
+msgstr "friend декларация %qD в локальном классе без предшествующей декларации"
  
  #: cp/friend.c:606
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "friend declaration %q#D declares a non-template function"
-msgstr "friend-декларация `%#D' объявляет нешаблонную функцию"
+msgstr "friend декларация %q#D декларирует нешаблонную функцию"
  
  #: cp/friend.c:610
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "(if this is not what you intended, make sure the function template has already been declared and add <> after the function name here) "
-msgstr "(ÐµÑ\81Ð»Ð¸ Ñ\8dÑ\82Ð¾ Ð½Ðµ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð²Ð°Ñ\88Ð¸Ð¼ Ð½Ð°Ð¼ÐµÑ\80ÐµÐ½Ð¸Ñ\8fÐ¼, Ñ\83Ð±ÐµÐ´Ð¸Ñ\82ÐµÑ\81Ñ\8c, Ñ\87Ñ\82Ð¾ Ñ\88Ð°Ð±Ð»Ð¾Ð½ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ñ\83Ð¶Ðµ Ð±Ñ\8bÐ» Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»ÐµÐ½ Ð¸ Ð´Ð¾Ð±Ð°Ð²Ñ\8cÑ\82Ðµ <> Ð¿Ð¾Ñ\81Ð»Ðµ Ð¸Ð¼ÐµÐ½Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð·Ð´ÐµÑ\81Ñ\8c). -Wno-non-template-friend Ð¾Ñ\82Ð¼ÐµÐ½Ñ\8fÐµÑ\82 Ñ\8dÑ\82Ð¾ Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ðµ"
+msgstr "(ÐµÑ\81Ð»Ð¸ Ñ\8dÑ\82Ð¾ Ð½Ðµ Ñ\82Ð¾, Ñ\87Ñ\82Ð¾ Ð²Ñ\8b Ð¸Ð¼ÐµÐ»Ð¸ Ð² Ð²Ð¸Ð´Ñ\83, Ñ\83Ð±ÐµÐ´Ð¸Ñ\82ÐµÑ\81Ñ\8c, Ñ\87Ñ\82Ð¾ Ñ\88Ð°Ð±Ð»Ð¾Ð½ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ñ\83Ð¶Ðµ Ð±Ñ\8bÐ» Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ð¸ Ð´Ð¾Ð±Ð°Ð²Ñ\8cÑ\82Ðµ <> Ð¿Ð¾Ñ\81Ð»Ðµ Ð¸Ð¼ÐµÐ½Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð·Ð´ÐµÑ\81Ñ\8c) "
  
  #: cp/init.c:383
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "value-initialization of incomplete type %qT"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ %qs Ðº Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð¼Ñ\83 Ñ\82Ð¸Ð¿Ñ\83 %qT "
+msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
  
  #: cp/init.c:452
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot value-initialize array of unknown bound %qT"
-msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %qD Ð²ÐºÐ»Ñ\8eÑ\87Ð°ÐµÑ\82 %s Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² с неизвестной границей %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° с неизвестной границей %qT"
  
  #: cp/init.c:491
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "value-initialization of function type %qT"
-msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f `%#D', Ð¸Ð¼ÐµÑ\8eÑ\89ÐµÐ³Ð¾ Ñ\82Ð¸Ð¿ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸"
+msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¾Ð½Ð°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
  
  #: cp/init.c:497
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "value-initialization of reference type %qT"
-msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f `%#D', Ð¸Ð¼ÐµÑ\8eÑ\89ÐµÐ³Ð¾ Ñ\82Ð¸Ð¿ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸"
+msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ñ\87Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
  
+#
  #: cp/init.c:556
  #, fuzzy, gcc-internal-format
+#| msgid "non-static data member initializers"
  msgid "recursive instantiation of non-static data member initializer for %qD"
-msgstr "%qT не имеет нестатического элемента данных с именем %qD"
+msgstr "инициализаторы нестатических элементов данных"
  
  #: cp/init.c:580
  #, gcc-internal-format
@@ -42651,35 +44409,36 @@ msgid "constructor required before non-static data member for %qD has been parse
  msgstr ""
  
  #: cp/init.c:618
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD should be initialized in the member initialization list"
  msgstr "%qD следует инициализировать в списке инициализации элементов"
  
  #: cp/init.c:639
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is initialized with itself"
-msgstr "%H%qD используется без инициализации в данной функции"
+msgstr "%qD инициализируется самим собой"
  
  #: cp/init.c:742
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid initializer for array member %q#D"
-msgstr "некорректное начальное значение для элемента %qs"
+msgstr "некорректный инициализатор для элемента массива %q#D"
  
  #: cp/init.c:756 cp/init.c:780 cp/init.c:2234 cp/method.c:1230
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "uninitialized const member in %q#T"
-msgstr "не инициализирован константный элемент %qD"
+msgstr "неинициализированный const элемент в %q#T"
  
  #: cp/init.c:758 cp/init.c:775 cp/init.c:782 cp/init.c:2219 cp/init.c:2247
  #: cp/method.c:1233 cp/method.c:1244
  #, fuzzy, gcc-internal-format
+#| msgid "%qD should be initialized"
  msgid "%q#D should be initialized"
-msgstr "%q+D будет инициализирован после"
+msgstr "%qD должен быть инициализирован"
  
  #: cp/init.c:773 cp/init.c:2206 cp/method.c:1241
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "uninitialized reference member in %q#T"
-msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82-Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ° %qD"
+msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ñ\87Ð½Ñ\8bÐ¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð² %q#T"
  
  #: cp/init.c:950
  #, fuzzy, gcc-internal-format
@@ -42694,8 +44453,9 @@ msgstr "базовый класс %qT будет инициализирован
  
  #: cp/init.c:957
  #, fuzzy, gcc-internal-format
+#| msgid "  %q+#D"
  msgid "  %q#D"
-msgstr "  `%#D'"
+msgstr "  %q+#D"
  
  #: cp/init.c:959
  #, gcc-internal-format
@@ -42703,29 +44463,29 @@ msgid "  base %qT"
  msgstr "  базового класса %qT"
  
  #: cp/init.c:961
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  when initialized here"
-msgstr "  Ð¿Ñ\80Ð¸ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ здесь"
+msgstr "  ÐµÑ\81Ð»Ð¸ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½ здесь"
  
  #: cp/init.c:978
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "multiple initializations given for %qD"
-msgstr "повторные инициализации для %qD"
+msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ñ\8bÐµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð·Ð°Ð´Ð°Ð½Ñ\8b Ð´Ð»Ñ\8f %qD"
  
  #: cp/init.c:982
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "multiple initializations given for base %qT"
-msgstr "повторные инициализации для базового класса %qT"
+msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ñ\8bÐµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð·Ð°Ð´Ð°Ð½Ñ\8b Ð´Ð»Ñ\8f Ð±Ð°Ð·Ð¾Ð²Ð¾Ð³Ð¾ ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qT"
  
  #: cp/init.c:1067
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "initializations for multiple members of %qT"
  msgstr "инициализации для нескольких элементов %qT"
  
  #: cp/init.c:1146
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "base class %q#T should be explicitly initialized in the copy constructor"
-msgstr "базовый класс `%#T' должен быть явно инициализирован в копирующем конструкторе"
+msgstr "базовый класс %q#T должен быть явно инициализирован в копирующем конструкторе"
  
  #: cp/init.c:1365 cp/init.c:1384
  #, gcc-internal-format
@@ -42733,14 +44493,14 @@ msgid "class %qT does not have any field named %qD"
  msgstr "в классе %qT нет поля с именем %qD"
  
  #: cp/init.c:1371
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#D is a static data member; it can only be initialized at its definition"
-msgstr "`%#D' - статический элемент; он может быть инициализирован только в месте определения"
+msgstr "%q#D есть статический элемент данных; он может быть инициализирован только при своем определении"
  
  #: cp/init.c:1378
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#D is not a non-static data member of %qT"
-msgstr "`%#D' не является нестатическим элементом %qT"
+msgstr "%q#D не есть нестатический элемент данных %qT"
  
  #: cp/init.c:1417
  #, gcc-internal-format
@@ -42758,14 +44518,14 @@ msgid "%qD is both a direct base and an indirect virtual base"
  msgstr "%qD - непосредственный базовый тип, а также косвенный виртуальный базовый тип"
  
  #: cp/init.c:1480
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type %qT is not a direct or virtual base of %qT"
-msgstr "тип %qD не является непосредственной или виртуальной базой для %qT"
+msgstr "тип %qT не является непосредственной или виртуальной базой %qT"
  
  #: cp/init.c:1483
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type %qT is not a direct base of %qT"
-msgstr "тип %qD не является непосредственной базой для %qT"
+msgstr "тип %qT не является непосредственной базой %qT"
  
  #: cp/init.c:1568
  #, gcc-internal-format
@@ -42773,9 +44533,9 @@ msgid "bad array initializer"
  msgstr "некорректный инициализатор массива"
  
  #: cp/init.c:1864 cp/semantics.c:3194
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qT is not a class type"
-msgstr "%q#T не является классом"
+msgstr "%qT не является классовым типом"
  
  #: cp/init.c:1920
  #, gcc-internal-format
@@ -42800,32 +44560,36 @@ msgstr "некорректное использование нестатичес
  #: cp/init.c:2203
  #, gcc-internal-format
  msgid "uninitialized reference member in %q#T using %<new%> without new-initializer"
-msgstr ""
+msgstr "неинициализированный ссылочный элемент в %q#T использующий %<new%> без new-инициализатора"
  
  #: cp/init.c:2211
  #, fuzzy, gcc-internal-format
+#| msgid "uninitialized reference member in %q#T using %<new%> without new-initializer"
  msgid "uninitialized reference member in base %q#T of %q#T using %<new%> without new-initializer"
-msgstr "Ð½ÐµÐ¿Ñ\80Ð¾Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð² %<new%> Ð¾Ñ\82 %q#T"
+msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ñ\87Ð½Ñ\8bÐ¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð² %q#T Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ñ\8eÑ\89Ð¸Ð¹ %<new%> Ð±ÐµÐ· new-Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ð°"
  
  #: cp/init.c:2215
  #, fuzzy, gcc-internal-format
+#| msgid "uninitialized reference member in %q#T"
  msgid "uninitialized reference member in base %q#T of %q#T"
-msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82-Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ° %qD"
+msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ñ\87Ð½Ñ\8bÐ¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð² %q#T"
  
  #: cp/init.c:2231
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "uninitialized const member in %q#T using %<new%> without new-initializer"
-msgstr "Ð½ÐµÐ¿Ñ\80Ð¾Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð² %<new%> Ð¾Ñ\82 %q#T"
+msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ const Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð² %q#T Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ñ\8eÑ\89Ð¸Ð¹ %<new%> Ð±ÐµÐ· new-Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ð°"
  
  #: cp/init.c:2239
  #, fuzzy, gcc-internal-format
+#| msgid "uninitialized const member in %q#T using %<new%> without new-initializer"
  msgid "uninitialized const member in base %q#T of %q#T using %<new%> without new-initializer"
-msgstr "Ð½ÐµÐ¿Ñ\80Ð¾Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð² %<new%> Ð¾Ñ\82 %q#T"
+msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ const Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð² %q#T Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ñ\8eÑ\89Ð¸Ð¹ %<new%> Ð±ÐµÐ· new-Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ð°"
  
  #: cp/init.c:2243
  #, fuzzy, gcc-internal-format
+#| msgid "uninitialized const member in %q#T"
  msgid "uninitialized const member in base %q#T of %q#T"
-msgstr "не инициализирован константный элемент %qD"
+msgstr "неинициализированный const элемент в %q#T"
  
  #: cp/init.c:2518
  #, gcc-internal-format
@@ -42844,18 +44608,21 @@ msgstr ""
  
  #: cp/init.c:2655
  #, fuzzy, gcc-internal-format
+#| msgid "integer overflow in expression"
  msgid "integer overflow in array size"
  msgstr "переполнение при вычислении целочисленного выражения"
  
  #: cp/init.c:2665
  #, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "array size in new-expression must be constant"
-msgstr "аргумент %qD не является константой"
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/init.c:2679
  #, fuzzy, gcc-internal-format
+#| msgid "variably modified field at file scope"
  msgid "variably modified type not allowed in new-expression"
-msgstr "Ð¸Ð¼Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ Ð¸Ð»Ð¸ Ð¿Ð¾Ð»Ñ\8f %qs Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»ÐµÐ½Ð¾ void"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾ Ð¼Ð¾Ð´Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ðµ Ð¿Ð¾Ð»Ðµ Ð½Ð° Ñ\83Ñ\80Ð¾Ð²Ð½Ðµ Ñ\84Ð°Ð¹Ð»Ð°"
  
  #: cp/init.c:2710
  #, gcc-internal-format
@@ -42885,9 +44652,9 @@ msgid "%qD is not a function returning a pointer"
  msgstr "%qD не является шаблоном функции"
  
  #: cp/init.c:2882
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "Java class %q#T object allocated using placement new"
-msgstr "Java-класс %qT не может иметь несколько базовых классов"
+msgstr "объект Java-класса %q#T размещен посредством размещающего new"
  
  #: cp/init.c:2926
  #, gcc-internal-format
@@ -42900,9 +44667,9 @@ msgid "request for member %qD is ambiguous"
  msgstr "запрос элемента %qD неоднозначен"
  
  #: cp/init.c:3162
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parenthesized initializer in array new"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b Ð¿Ð¾Ñ\81Ð»Ðµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ð° Ð² Ñ\81ÐºÐ¾Ð±ÐºÐ°Ñ\85 Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ñ\8b"
+msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80 Ñ\81Ð¾ Ñ\81ÐºÐ¾Ð±ÐºÐ°Ð¼Ð¸ Ð² new Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð°"
  
  #: cp/init.c:3400
  #, gcc-internal-format
@@ -42925,9 +44692,9 @@ msgid "call to Java constructor, while %<jclass%> undefined"
  msgstr "вызов Java-конструкторов, хотя %<jclass%> не определен"
  
  #: cp/init.c:3503
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t find %<class$%> in %qT"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 %<class$%> в %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð½Ð°Ð¹Ñ\82Ð¸ %<class$%> в %qT"
  
  #: cp/init.c:3563
  #, fuzzy, gcc-internal-format
@@ -42937,8 +44704,9 @@ msgstr "в вызове оператора delete обнаружена возм
  
  #: cp/init.c:3567
  #, fuzzy, gcc-internal-format
+#| msgid "neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined"
  msgid "neither the destructor nor the class-specific operator delete [] will be called, even if they are declared when the class is defined"
-msgstr "ни деструктор, ни специфический для класса оператор delete не будут вызваны, даже если они декларированы в определении класса."
+msgstr "ни деструктор, ни специфический для класса оператор delete не будут вызваны, даже если они декларированы в определении класса"
  
  #: cp/init.c:4059
  #, gcc-internal-format
@@ -42961,19 +44729,21 @@ msgid "possible problem detected in invocation of delete operator:"
  msgstr "в вызове оператора delete обнаружена возможная проблема:"
  
  #: cp/init.c:4380
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "neither the destructor nor the class-specific operator delete will be called, even if they are declared when the class is defined"
-msgstr "ни деструктор, ни специфический для класса оператор delete не будут вызваны, даже если они декларированы в определении класса."
+msgstr "ни деструктор, ни специфический для класса оператор delete не будут вызваны, даже если они декларированы в определении класса"
  
  #: cp/init.c:4395
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behaviour"
  msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
-msgstr ""
+msgstr "удаление объекта абстрактного класса типа %qT, имеющего нетривиальный деструктор, вызовет неопределенное поведение"
  
  #: cp/init.c:4400
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behaviour"
  msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
-msgstr ""
+msgstr "удаление объекта полиморфного класса типа %qT, имеющего нетривиальный деструктор, вызовет неопределенное поведение"
  
  #: cp/init.c:4701
  #, gcc-internal-format
@@ -42992,28 +44762,30 @@ msgstr ""
  
  #: cp/lambda.c:481
  #, fuzzy, gcc-internal-format
+#| msgid "compound literal has variable size"
  msgid "because the array element type %qT has variable size"
  msgstr "составной литерал имеет переменный размер"
  
  #: cp/lambda.c:492
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot capture %qE by reference"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ Ð½Ð° %q#T"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð·Ð°Ñ\85Ð²Ð°Ñ\82Ð¸Ñ\82Ñ\8c %qE Ð¿Ð¾ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐµ"
  
  #: cp/lambda.c:500
  #, fuzzy, gcc-internal-format
+#| msgid "invalid use of incomplete type %q#T"
  msgid "capture by copy of incomplete type %qT"
-msgstr "Ð½ÐµÐ¿Ñ\80Ð°Ð²Ð¸Ð»Ñ\8cÐ½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÐ´Ð¾Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð¾Ð³Ð¾ typedef %qD"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %q#T"
  
  #: cp/lambda.c:524
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "already captured %qD in lambda expression"
-msgstr "неверные операнды бинарной операции %s"
+msgstr "уже захваченное %qD в lambda выражении"
  
  #: cp/lambda.c:723
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<this%> was not captured for this lambda function"
-msgstr "имя %<this%> недоступно для статических элементов-функций"
+msgstr "%<this%> не было захвачено для этой lambda функции"
  
  #: cp/lex.c:325
  #, gcc-internal-format, gfc-internal-format
@@ -43073,17 +44845,17 @@ msgstr "(с ключом %<-fpermissive%>, G++ примет данный код,
  #: cp/mangle.c:2147
  #, gcc-internal-format
  msgid "mangling typeof, use decltype instead"
-msgstr ""
+msgstr "разборка typeof, используйте decltype взамен"
  
  #: cp/mangle.c:2151
  #, gcc-internal-format
  msgid "mangling __underlying_type"
-msgstr ""
+msgstr "разборка __underlying_type"
  
  #: cp/mangle.c:2438
  #, gcc-internal-format
  msgid "mangling unknown fixed point type"
-msgstr ""
+msgstr "разборка неизвестного типа с фиксированной точкой"
  
  #: cp/mangle.c:3011
  #, gcc-internal-format
@@ -43093,22 +44865,23 @@ msgstr ""
  #: cp/mangle.c:3016
  #, gcc-internal-format, gfc-internal-format
  msgid "mangling %C"
-msgstr ""
+msgstr "разборка %C"
  
  #: cp/mangle.c:3093
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "omitted middle operand to %<?:%> operand cannot be mangled"
-msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ ÐºÐ¾Ð´Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¿Ñ\80Ð¾Ð¿Ñ\83Ñ\89ÐµÐ½Ð½Ð¾Ð³Ð¾ Ñ\81Ñ\80ÐµÐ´Ð½ÐµÐ³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð° %<?:%>"
+msgstr "Ð¾Ð¿Ñ\83Ñ\89ÐµÐ½ Ñ\81Ñ\80ÐµÐ´Ð½Ð¸Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ %<?:%> Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ñ\80Ð°Ð·Ð¾Ð±Ñ\80Ð°Ð½"
  
  #: cp/mangle.c:3157
  #, gcc-internal-format
  msgid "string literal in function template signature"
-msgstr ""
+msgstr "строковый литерал в сигнатуре шаблона функции"
  
  #: cp/mangle.c:3640
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "-fabi-version=6 (or =0) avoids this error with a change in mangling"
  msgid "a later -fabi-version= (or =0) avoids this error with a change in mangling"
-msgstr ""
+msgstr "-fabi-version=6 (или =0) избегает этой ошибки изменением в разборке"
  
  #: cp/mangle.c:3667
  #, fuzzy, gcc-internal-format
@@ -43134,50 +44907,54 @@ msgid "the mangled name of the initialization guard variable for%qD changes betw
  msgstr ""
  
  #: cp/method.c:705 cp/method.c:1186
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-static const member %q#D, can%'t use default assignment operator"
-msgstr "нестатический константный элемент `%#D', использование операции присваивания по умолчанию недопустимо"
+msgstr "нестатический константный элемент %q#D, использование операции присваивания по умолчанию недопустимо"
  
  #: cp/method.c:711 cp/method.c:1192
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-static reference member %q#D, can%'t use default assignment operator"
-msgstr "нестатический элемент-ссылка `%#D', использование операции присваивания по умолчанию недопустимо"
+msgstr "нестатический элемент-ссылка %q#D, использование операции присваивания по умолчанию недопустимо"
  
  #: cp/method.c:829
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "synthesized method %qD first required here "
-msgstr "%Hсинтезированный метод %qD впервые потребовался здесь "
+msgstr "синтезированный метод %qD впервые потребовался здесь "
  
  #: cp/method.c:1135
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "union member %q+D with non-trivial %qD"
-msgstr "неинициализированный элемент %qD константного типа %qT"
+msgstr "элемент объединения %q+D с нетривиальным %qD"
  
  #: cp/method.c:1145
  #, fuzzy, gcc-internal-format
+#| msgid "defaulted constructor calls non-constexpr %q+D"
  msgid "defaulted constructor calls non-constexpr %qD"
-msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ°Ðº virtual"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80 Ð²Ñ\8bÐ·Ñ\8bÐ²Ð°ÐµÑ\82 non-constexpr %q+D"
  
  #: cp/method.c:1209
  #, fuzzy, gcc-internal-format
+#| msgid "initializer for %q+#D is invalid"
  msgid "initializer for %q#D is invalid"
-msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° %qD"
+msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80 Ð´Ð»Ñ\8f %q+#D Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½"
  
  #: cp/method.c:1261
  #, fuzzy, gcc-internal-format
+#| msgid "defaulted default constructor does not initialize %q+#D"
  msgid "defaulted default constructor does not initialize %q#D"
-msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ°Ðº virtual"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80 Ð½Ðµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ñ\83ÐµÑ\82 %q+#D"
  
  #: cp/method.c:1272
  #, fuzzy, gcc-internal-format
+#| msgid "non-static data member %qD has Java class type"
  msgid "copying non-static data member %q#D of rvalue reference type"
-msgstr "`%#D' не является нестатическим элементом %qT"
+msgstr "нестатический элемент данных %qD имеет тип Java класса"
  
  #. A trivial constructor doesn't have any NSDMI.
  #: cp/method.c:1439
  #, gcc-internal-format
  msgid "defaulted default constructor does not initialize any non-static data member"
-msgstr ""
+msgstr "подразумеваемый конструктор не инициализирует нестатические элементы данных"
  
  #: cp/method.c:1516
  #, gcc-internal-format
@@ -43187,65 +44964,69 @@ msgstr ""
  #: cp/method.c:1622
  #, gcc-internal-format
  msgid "a lambda closure type has a deleted default constructor"
-msgstr ""
+msgstr "тип замыкания lambda имеет удаленный подразумеваемый конструктор"
  
  #: cp/method.c:1625
  #, gcc-internal-format
  msgid "a lambda closure type has a deleted copy assignment operator"
-msgstr ""
+msgstr "тип замыкания lambda имеет удаленный оператор присваивания с копированием"
  
  #: cp/method.c:1636
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%q+#D is implicitly declared as deleted because %qT declares a move constructor or move assignment operator"
  msgid "%q#D is implicitly declared as deleted because %qT declares a move constructor or move assignment operator"
-msgstr ""
+msgstr "%q+#D неявно продекларирован как удаленный поскольку %qT декларирует перемещающий конструктор или оператор присваивания с перемещением"
  
  #: cp/method.c:1656
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%q+#D is implicitly deleted because the default definition would be ill-formed:"
  msgid "%q#D is implicitly deleted because the default definition would be ill-formed:"
-msgstr ""
+msgstr "%q+#D является неявно удаленным поскольку подразумеваемое определение будет синтаксически некорректным:"
  
  #: cp/method.c:1665
  msgid "%q#F is implicitly deleted because its exception-specification does not match the implicit exception-specification %qX"
  msgstr ""
  
  #: cp/method.c:1983
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "defaulted declaration %q+D"
-msgstr "Ð´Ð»Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q+D"
  
  #: cp/method.c:1985
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "does not match expected signature %qD"
-msgstr "Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð½Ðµ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð´ÐµÑ\80ÐµÐ²Ñ\83 Ñ\80ÐµÐ³Ð¸Ð¾Ð½Ð¾Ð²"
+msgstr "Ð½Ðµ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¾Ð¶Ð¸Ð´Ð°ÐµÐ¼Ð¾Ð¹ Ñ\81Ð¸Ð³Ð½Ð°Ñ\82Ñ\83Ñ\80Ðµ %qD"
  
  #: cp/method.c:2017
+#, fuzzy
+#| msgid "function %q+D defaulted on its first declaration with an exception-specification that differs from the implicit declaration %q#D"
  msgid "function %q+D defaulted on its redeclaration with an exception-specification that differs from the implicit exception-specification %qX"
-msgstr ""
+msgstr "функция %q+D подразумевается при ее первой декларации со спецификацией обработки исключений, которая отличается от неявной декларации %q#D"
  
  #: cp/method.c:2039
  #, gcc-internal-format
  msgid "explicitly defaulted function %q+D cannot be declared as constexpr because the implicit declaration is not constexpr:"
-msgstr ""
+msgstr "явно подразумеваемая функция %q+D не может быть декларирована как constexpr поскольку неявная декларация не есть constexpr:"
  
  #: cp/method.c:2085
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "a template cannot be defaulted"
-msgstr "декларация %q+#D недопустима,"
+msgstr "шаблон не может быть подразумеваемым"
  
  #: cp/method.c:2113
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD cannot be defaulted"
-msgstr "декларация %q+#D недопустима,"
+msgstr "%qD не может быть подразумеваемым"
  
  #: cp/method.c:2122
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "defaulted function %q+D with default argument"
-msgstr "ÐºÐ¾Ð½ÐµÑ\86 Ñ\84Ð°Ð¹Ð»Ð° Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D Ñ\81 Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼"
  
  #: cp/name-lookup.c:584
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#D conflicts with a previous declaration"
-msgstr "%q#D ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83ÐµÑ\82 Ñ\81 Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89Ð¸Ð¼ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸ÐµÐ¼ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %q#D"
+msgstr "%q#D ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83ÐµÑ\82 Ñ\81 Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸ÐµÐ¹"
  
  #: cp/name-lookup.c:797
  #, gcc-internal-format
@@ -43269,19 +45050,20 @@ msgid "as %qD"
  msgstr "как %qD"
  
  #: cp/name-lookup.c:869 cp/name-lookup.c:885
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %q#D with C language linkage"
-msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q+D Ð±ÐµÐ· Ð¿Ñ\80Ð¸Ð²Ñ\8fÐ·ÐºÐ¸"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q#D Ñ\81 Ð¿Ñ\80Ð¸Ð²Ñ\8fÐ·ÐºÐ¾Ð¹ Ñ\8fÐ·Ñ\8bÐºÐ° C"
  
  #: cp/name-lookup.c:872 cp/name-lookup.c:887
  #, fuzzy, gcc-internal-format
+#| msgid "conflicts with previous declaration %q+#D"
  msgid "conflicts with previous declaration %q#D"
-msgstr "противоречит предыдущей декларации `%#D'"
+msgstr "противоречит предыдущей декларации %q+#D"
  
  #: cp/name-lookup.c:875
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "due to different exception specifications"
-msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð´Ð»Ñ\8f Ð¿Ñ\80Ð¾Ð²ÐµÑ\80ÐºÐ¸ Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÑ\85 Ñ\81Ð¸Ñ\82Ñ\83Ð°Ñ\86ий"
+msgstr "Ð¸Ð·-Ð·Ð° Ñ\80Ð°Ð·Ð»Ð¸Ñ\87Ð½Ñ\8bÑ\85 Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¹ Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87ÐµÐ½ий"
  
  #: cp/name-lookup.c:986
  #, gcc-internal-format
@@ -43295,9 +45077,9 @@ msgid "previous external decl of %q#D"
  msgstr "предыдущая внешняя декларация %q+#D"
  
  #: cp/name-lookup.c:1077
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "extern declaration of %q#D doesn%'t match"
-msgstr "нет соответствия с внешней декларацией %q#D"
+msgstr "extern декларация %q#D не соответствует"
  
  #: cp/name-lookup.c:1079
  #, fuzzy, gcc-internal-format
@@ -43311,9 +45093,9 @@ msgid "declaration of %q#D shadows a parameter"
  msgstr "декларация %q#D перекрывает параметр"
  
  #: cp/name-lookup.c:1204
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %qD shadows a lambda capture"
-msgstr "декларация %q+D перекрывает параметр"
+msgstr "декларация %qD затеняет lambda capture"
  
  #: cp/name-lookup.c:1208
  #, gcc-internal-format
@@ -43322,8 +45104,9 @@ msgstr "декларация %qD перекрывает декларирован
  
  #: cp/name-lookup.c:1251
  #, fuzzy, gcc-internal-format
+#| msgid "declaration of %qD as member of %qT"
  msgid "declaration of %qD shadows a member of %qT"
-msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÐ²Ð°ÐµÑ\82 Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 ÐºÐ»Ð°Ñ\81Ñ\81Ð°, Ð½Ð° ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐ¹ Ñ\83ÐºÐ°Ð·Ñ\8bÐ²Ð°ÐµÑ\82 'this'"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD ÐºÐ°Ðº Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° %qT"
  
  #: cp/name-lookup.c:1406
  #, gcc-internal-format
@@ -43343,9 +45126,9 @@ msgid "  matches this %qD under old rules"
  msgstr "  соответствует декларации %q+D по старым правилам"
  
  #: cp/name-lookup.c:1429 cp/name-lookup.c:1437
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "name lookup of %qD changed for ISO %<for%> scoping"
-msgstr "Ð¿Ð¾Ð¸Ñ\81Ðº Ð¸Ð¼ÐµÐ½Ð¸ %qD Ð¸Ð·Ð¼ÐµÐ½ÐµÐ½ Ð² Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ð¸ Ñ\81 Ð½Ð¾Ð²Ð¾Ð¹ Ñ\82Ñ\80Ð°ÐºÑ\82Ð¾Ð²ÐºÐ¾Ð¹ ISO Ð´Ð»Ñ\8f Ð¾Ð±Ð»Ð°Ñ\81Ñ\82Ð¸ %<for%>"
+msgstr "Ð¿Ð¾Ð¸Ñ\81Ðº Ð¸Ð¼ÐµÐ½Ð¸ %qD Ð¿Ñ\80Ð¸Ð²ÐµÐ´ÐµÐ½ Ð² Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\81 Ð¿Ñ\80Ð°Ð²Ð¸Ð»Ð°Ð¼Ð¸ Ð²Ð¸Ð´Ð¸Ð¼Ð¾Ñ\81Ñ\82Ð¸ ISO %<for%>"
  
  #: cp/name-lookup.c:1431
  #, gcc-internal-format
@@ -43359,9 +45142,9 @@ msgid "  using obsolete binding at %qD"
  msgstr "  используется устаревшая привязка в %q+D"
  
  #: cp/name-lookup.c:1447
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "(if you use %<-fpermissive%> G++ will accept your code)"
-msgstr "(G++ примет такой код с ключом `-fpermissive')"
+msgstr "(если вы используете %<-fpermissive%> G++ примет ваш код)"
  
  #: cp/name-lookup.c:1502
  #, gcc-internal-format
@@ -43473,24 +45256,26 @@ msgid "%qD should have been declared inside %qD"
  msgstr "%qD следовало объявить внутри %qD"
  
  #: cp/name-lookup.c:3645
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD attribute requires a single NTBS argument"
-msgstr "аргументом атрибута %qs должна быть целая константа"
+msgstr "%qD атрибут требует единственный NTBS аргумент"
  
  #: cp/name-lookup.c:3652
  #, gcc-internal-format
  msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols"
-msgstr ""
+msgstr "%qD атрибут не имеет смысла поскольку элементы анонимного пространства имен получают локальные символы"
  
  #: cp/name-lookup.c:3662
  #, fuzzy, gcc-internal-format
+#| msgid "ignoring attributes on template argument %qT"
  msgid "ignoring %qD attribute on non-inline namespace"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°"
+msgstr "Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qT"
  
  #: cp/name-lookup.c:3668
  #, fuzzy, gcc-internal-format
+#| msgid "ignoring attributes on template argument %qT"
  msgid "ignoring %qD attribute on anonymous namespace"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°"
+msgstr "Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qT"
  
  #: cp/name-lookup.c:3687 cp/name-lookup.c:4100
  #, gcc-internal-format
@@ -43508,32 +45293,32 @@ msgid "strong using only meaningful at namespace scope"
  msgstr "strong имеет смысл только в пределах namespace"
  
  #: cp/name-lookup.c:4092
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "current namespace %qD does not enclose strongly used namespace %qD"
-msgstr "декларация %qD в %qD, который не объемлет %qD"
+msgstr "текущее пространство имен %qD не включает строго используемое пространство имен %qD"
  
  #: cp/name-lookup.c:4438
  #, gcc-internal-format
  msgid "maximum limit of %d namespaces searched for %qE"
-msgstr ""
+msgstr "максимальное число %d пространств имен просмотрено для %qE"
  
  #: cp/name-lookup.c:4448
  #, gcc-internal-format
  msgid "suggested alternative:"
  msgid_plural "suggested alternatives:"
-msgstr[0] ""
-msgstr[1] ""
-msgstr[2] ""
+msgstr[0] "предлагаемый вариант:"
+msgstr[1] "предлагаемые варианты:"
+msgstr[2] "предлагаемые варианты:"
  
  #: cp/name-lookup.c:4452
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  %qE"
-msgstr "  `%#D'"
+msgstr "  %qE"
  
  #: cp/name-lookup.c:5727
  #, gcc-internal-format
  msgid "argument dependent lookup finds %q+D"
-msgstr ""
+msgstr "зависимый от аргумента просмотр находит %q+D"
  
  #: cp/name-lookup.c:6261
  #, gcc-internal-format
@@ -43546,14 +45331,14 @@ msgid "XXX leaving pop_everything ()\n"
  msgstr "XXX выход из pop_everything ()\n"
  
  #: cp/optimize.c:577
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "making multiple clones of %qD"
-msgstr "повторное определение %q#T"
+msgstr "порождение множества клонов %qD"
  
  #: cp/parser.c:824
  #, gcc-internal-format
  msgid "identifier %qE is a keyword in C++11"
-msgstr ""
+msgstr "идентификатор %qE является ключевым словом в C++11"
  
  #: cp/parser.c:1311 cp/parser.c:1324
  #, gcc-internal-format
@@ -43588,9 +45373,9 @@ msgid "%<::%E%> has not been declared"
  msgstr "%<::%E%> не был декларирован"
  
  #: cp/parser.c:2823
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "request for member %qE in non-class type %qT"
-msgstr "запрос элемента %qD в %qE, имеющего не классовый тип %qT"
+msgstr "запрос элемента %qE в неклассовом типе %qT"
  
  #: cp/parser.c:2826 cp/parser.c:17206
  #, gcc-internal-format
@@ -43598,49 +45383,49 @@ msgid "%<%T::%E%> has not been declared"
  msgstr "%<%T::%E%> не был декларирован"
  
  #: cp/parser.c:2836
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<%E::%E%> is not a type"
-msgstr "%<%T::%D%> не является типом"
+msgstr "%<%E::%E%> не тип"
  
  #: cp/parser.c:2840
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<%E::%E%> is not a class or namespace"
-msgstr "%qT не является классом или пространством имён"
+msgstr "%<%E::%E%> не класс или пространство имен"
  
  #: cp/parser.c:2845
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<%E::%E%> is not a class, namespace, or enumeration"
-msgstr "%qT не является классом или пространством имён"
+msgstr "%<%E::%E%> не класс, пространство имен или перечисление"
  
  #: cp/parser.c:2858
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<::%E%> is not a type"
-msgstr "%<%T::%D%> не является типом"
+msgstr "%<::%E%> не тип"
  
  #: cp/parser.c:2861
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<::%E%> is not a class or namespace"
-msgstr "%qT не является классом или пространством имён"
+msgstr "%<::%E%> не класс или пространство имен"
  
  #: cp/parser.c:2865
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<::%E%> is not a class, namespace, or enumeration"
-msgstr "%qT не является классом или пространством имён"
+msgstr "%<::%E%> не класс, пространство имен или перечисление"
  
  #: cp/parser.c:2877
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a type"
-msgstr "%qD не является типом"
+msgstr "%qE не тип"
  
  #: cp/parser.c:2880
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a class or namespace"
-msgstr "%qT не является классом или пространством имён"
+msgstr "%qE не класс или пространство имен"
  
  #: cp/parser.c:2884
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a class, namespace, or enumeration"
-msgstr "%qT не является классом или пространством имён"
+msgstr "%qE не класс, пространство имен или перечисление"
  
  #: cp/parser.c:2947
  #, gcc-internal-format
@@ -43654,6 +45439,7 @@ msgstr "(возможно, пропущена точка с запятой по
  
  #: cp/parser.c:2975
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is not a template"
  msgid "%qE is not a class template"
  msgstr "%qE не является шаблоном"
  
@@ -43668,79 +45454,79 @@ msgid "invalid template-id"
  msgstr "некорректный идентификатор шаблона"
  
  #: cp/parser.c:3013
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "floating-point literal cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "плавающий литерал не может появляться в константном выражении"
  
  #: cp/parser.c:3017 cp/pt.c:16071
  #, gcc-internal-format
  msgid "a cast to a type other than an integral or enumeration type cannot appear in a constant-expression"
-msgstr ""
+msgstr "приведение к типу, отличному от целого или перечисления, не может появляться в константном выражении"
  
  #: cp/parser.c:3022
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<typeid%> operator cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "оператор %<typeid%> не может присутствовать в константном выражении"
  
  #: cp/parser.c:3026
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-constant compound literals cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "неконстантные составные литералы не могут присутствовать в константном выражении"
  
  #: cp/parser.c:3030
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "a function call cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "вызов функции не может присутствовать в константном выражении"
  
  #: cp/parser.c:3034
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "an increment cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "инкремент не может присутствовать в константном выражении"
  
  #: cp/parser.c:3038
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "an decrement cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "декремент не может присутствовать в константном выражении"
  
  #: cp/parser.c:3042
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "an array reference cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "ссылка на массив не может присутствовать в константном выражении"
  
  #: cp/parser.c:3046
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the address of a label cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "адрес метки не может присутствовать в константном выражении"
  
  #: cp/parser.c:3050
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "calls to overloaded operators cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "вызовы перегруженных операторов не могут присутствовать в константном выражении"
  
  #: cp/parser.c:3054
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "an assignment cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "присваивание не может присутствовать в константном выражении"
  
  #: cp/parser.c:3057
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "a comma operator cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "операция запятая не может присутствовать в константном выражении"
  
  #: cp/parser.c:3061
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "a call to a constructor cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "вызов конструктора не может присутствовать в константном выражении"
  
  #: cp/parser.c:3065
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "a transaction expression cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "транзакционное выражение не может присутствовать в константном выражении"
  
  #: cp/parser.c:3111
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs cannot appear in a constant-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "%qs не может присутствовать в константном выражении"
  
  #: cp/parser.c:3144
  #, gcc-internal-format
@@ -43754,9 +45540,9 @@ msgstr "некорректное использование деструктор
  
  #. Something like 'unsigned A a;'
  #: cp/parser.c:3152
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid combination of multiple type-specifiers"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f ÐºÐ¾Ð¼Ð±Ð¸Ð½Ð°Ñ\86Ð¸Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð¾Ð² Ñ\82Ð¸Ð¿Ð°"
  
  #. Issue an error message.
  #: cp/parser.c:3156
@@ -43767,22 +45553,25 @@ msgstr "%qE не является именем типа"
  #: cp/parser.c:3165
  #, gcc-internal-format
  msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
-msgstr ""
+msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
  
  #: cp/parser.c:3168
  #, fuzzy, gcc-internal-format
+#| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
  msgid "C++11 %<noexcept%> only available with -std=c++11 or -std=gnu++11"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
  
  #: cp/parser.c:3173
  #, fuzzy, gcc-internal-format
+#| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
  msgid "C++11 %<thread_local%> only available with -std=c++11 or -std=gnu++11"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
  
  #: cp/parser.c:3176
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "C++11 %<constexpr%> only available with -std=c++11 or -std=gnu++11"
  msgid "%<concept%> only available with -fconcepts"
-msgstr ""
+msgstr "C++11 %<constexpr%> доступно только с -std=c++11 или -std=gnu++11"
  
  #: cp/parser.c:3202
  #, gcc-internal-format
@@ -43791,79 +45580,84 @@ msgstr "(возможно, подразумевалось %<typename %T::%E%>)"
  
  #: cp/parser.c:3220
  #, fuzzy, gcc-internal-format
+#| msgid "%qE in namespace %qE does not name a type"
  msgid "%qE in namespace %qE does not name a template type"
-msgstr "%qs не является именем типа"
+msgstr "%qE в пространстве имен %qE не именует тип"
  
  #: cp/parser.c:3224
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE in namespace %qE does not name a type"
-msgstr "%qs не является именем типа"
+msgstr "%qE в пространстве имен %qE не именует тип"
  
  #. A<T>::A<T>()
  #: cp/parser.c:3233
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<%T::%E%> names the constructor, not the type"
-msgstr "%<%T::%D%> обозначает конструктор в %qT"
+msgstr "%<%T::%E%> именует конструктор, а не тип"
  
  #: cp/parser.c:3236
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "and %qT has no template constructors"
-msgstr "тип %qs не имеет подходящего конструктора"
+msgstr "и %qT не имеет шаблонных конструкторов"
  
  #: cp/parser.c:3241
  #, gcc-internal-format
  msgid "need %<typename%> before %<%T::%E%> because %qT is a dependent scope"
-msgstr ""
+msgstr "требуется %<typename%> перед %<%T::%E%> поскольку %qT зависимый контекст"
  
  #: cp/parser.c:3248
  #, fuzzy, gcc-internal-format
+#| msgid "%qE in %q#T does not name a type"
  msgid "%qE in %q#T does not name a template type"
-msgstr "%qs не является именем типа"
+msgstr "%qE в %q#T не именует тип"
  
  #: cp/parser.c:3252
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE in %q#T does not name a type"
-msgstr "%qs не является именем типа"
+msgstr "%qE в %q#T не именует тип"
  
  #: cp/parser.c:3852
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected string-literal"
  msgstr "ожидался строковый литерал"
  
  #: cp/parser.c:3918
  #, gcc-internal-format
  msgid "inconsistent user-defined literal suffixes %qD and %qD in string literal"
-msgstr ""
+msgstr "противоречивые определенные пользователем литеральные суффиксы %qD и %qD в строковом литерале"
  
  #: cp/parser.c:3966
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "a wide string is invalid in this context"
-msgstr "Ñ\81Ñ\82Ð°Ð½Ð´Ð°Ñ\80Ñ\82Ð½Ñ\8bÐµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð² Ð´Ð°Ð½Ð½Ð¾Ð¼ ÐºÐ¾Ð½Ñ\82ÐµÐºÑ\81Ñ\82Ðµ Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8b"
+msgstr "Ñ\88Ð¸Ñ\80Ð¾ÐºÐ°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ° Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð° Ð² Ð´Ð°Ð½Ð½Ð¾Ð¼ ÐºÐ¾Ð½Ñ\82ÐµÐºÑ\81Ñ\82Ðµ"
  
  #: cp/parser.c:4081
  #, gcc-internal-format
  msgid "unable to find character literal operator %qD with %qT argument"
-msgstr ""
+msgstr "невозможно найти оператор символьного литерала %qD с аргументом %qT"
  
  #: cp/parser.c:4182
  #, fuzzy, gcc-internal-format
+#| msgid "floating constant exceeds range of %qT"
  msgid "integer literal exceeds range of %qT type"
-msgstr "плавающая константа превышает диапазон для %<%s%>"
+msgstr "плавающая константа превышает диапазон для %qT"
  
  #: cp/parser.c:4189
  #, fuzzy, gcc-internal-format
+#| msgid "floating constant exceeds range of %qT"
  msgid "floating literal exceeds range of %qT type"
-msgstr "плавающая константа превышает диапазон для %<%s%>"
+msgstr "плавающая константа превышает диапазон для %qT"
  
  #: cp/parser.c:4193
  #, fuzzy, gcc-internal-format
+#| msgid "floating constant truncated to zero"
  msgid "floating literal truncated to zero"
-msgstr "Ð´ÐµÐ»ÐµÐ½Ð¸Ðµ Ð½Ð° Ð½Ð¾Ð»Ñ\8c Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ñ\8b"
+msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82aÐ½Ñ\82a Ñ\81 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹ Ñ\83Ñ\81ÐµÑ\87ÐµÐ½Ð° Ð´Ð¾ Ð½Ñ\83Ð»Ñ\8f"
  
  #: cp/parser.c:4233
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unable to find numeric literal operator %qD"
-msgstr "не найден регистр класса %qs для выталкивания в память"
+msgstr "невозможно найти оператор числового литерала %qD"
  
  #: cp/parser.c:4235
  #, gcc-internal-format
@@ -43873,22 +45667,24 @@ msgstr ""
  #: cp/parser.c:4287
  #, gcc-internal-format
  msgid "unable to find string literal operator %qD with %qT, %qT arguments"
-msgstr ""
+msgstr "невозможно найти оператор строкового литерала %qD с аргументами %qT, %qT"
  
  #: cp/parser.c:4347 cp/parser.c:12311
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected declaration"
-msgstr "Ð¿Ñ\83Ñ\81Ñ\82Ð°Ñ\8f декларация"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c декларация"
  
  #: cp/parser.c:4609 cp/parser.c:4624
  #, fuzzy, gcc-internal-format
+#| msgid "expected operator"
  msgid "expected binary operator"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80"
  
  #: cp/parser.c:4630
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<...%>"
  msgid "expected ..."
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<...%>"
  
  #: cp/parser.c:4640
  #, fuzzy, gcc-internal-format
@@ -43898,18 +45694,20 @@ msgstr "%s - список выражений рассматривается ка
  
  #: cp/parser.c:4643
  #, fuzzy, gcc-internal-format
+#| msgid "a transaction expression cannot appear in a constant-expression"
  msgid "conditional expression in operand of fold-expression"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "транзакционное выражение не может присутствовать в константном выражении"
  
  #: cp/parser.c:4651
  #, fuzzy, gcc-internal-format
+#| msgid "type mismatch in vector shift expression"
  msgid "mismatched operator in fold-expression"
-msgstr "несоответствие типов в условном выражении"
+msgstr "несоответствие типов в векторном выражении сдвига"
  
  #: cp/parser.c:4755
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "fixed-point types not supported in C++"
-msgstr "-fdata-sections не поддерживается для этой целевой машины"
+msgstr "типы с фиксированной точкой не поддерживаются в C++"
  
  #: cp/parser.c:4836
  #, gcc-internal-format
@@ -43917,19 +45715,20 @@ msgid "ISO C++ forbids braced-groups within expressions"
  msgstr "ISO C++ запрещает конструкции в фигурных скобках внутри выражений"
  
  #: cp/parser.c:4848
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "statement-expressions are not allowed outside functions nor in template-argument lists"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ñ\8b-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8b Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ñ\8b-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8b Ð²Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹ Ð¸ Ñ\81Ð¿Ð¸Ñ\81ÐºÐ¾Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
  
  #: cp/parser.c:4887
  #, fuzzy, gcc-internal-format
+#| msgid "lambda expressions only available with -std=c++11 or -std=gnu++11"
  msgid "fold-expressions only available with -std=c++1z or -std=gnu++1z"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "lambda-выражения доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/parser.c:4945 cp/parser.c:5116 cp/parser.c:5294
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected primary-expression"
-msgstr "ожидалось выражение"
+msgstr "ожидалось primary-expression"
  
  #: cp/parser.c:4975
  #, gcc-internal-format
@@ -43937,9 +45736,9 @@ msgid "%<this%> may not be used in this context"
  msgstr "%<this%> недопустим в данном контексте"
  
  #: cp/parser.c:5111
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "a template declaration cannot appear at block scope"
-msgstr "декларации Objective-C могут находиться только в глобальной области"
+msgstr "декларация шаблона не может появляться в блоке"
  
  #: cp/parser.c:5269
  #, gcc-internal-format
@@ -43947,24 +45746,25 @@ msgid "local variable %qD may not appear in this context"
  msgstr "локальная переменная %qD недопустима в данном контексте"
  
  #: cp/parser.c:5446
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected id-expression"
-msgstr "ожидалось выражение"
+msgstr "ожидалось id-выражение"
  
  #: cp/parser.c:5578
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "scope %qT before %<~%> is not a class-name"
-msgstr "%qT не является классом или пространством имён"
+msgstr "область видимости %qT до %<~%> не является именем класса"
  
  #: cp/parser.c:5607 cp/parser.c:7560
  #, fuzzy, gcc-internal-format
+#| msgid "C++0x auto only available with -std=c++11 or -std=gnu++11"
  msgid "%<~auto%> only available with -std=c++14 or -std=gnu++14"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "C++0x auto доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/parser.c:5718
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %<~%T%> as member of %qT"
-msgstr "декларация %qD перекрывает элемент класса, на который указывает 'this'"
+msgstr "декларация %<~%T%> как элемента %qT"
  
  #: cp/parser.c:5733
  #, gcc-internal-format
@@ -43974,22 +45774,22 @@ msgstr "typedef-имя %qD использовано как декларатор
  #: cp/parser.c:5768
  #, gcc-internal-format
  msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization"
-msgstr ""
+msgstr "суффиксы литеральных операторов без предшествующего %<_%> зарезервированы для будущей стандартизации"
  
  #: cp/parser.c:5779 cp/parser.c:19182
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected unqualified-id"
-msgstr "ожидался список спецификаторов и квалификаторов"
+msgstr "ожидался unqualified-id"
  
  #: cp/parser.c:5886
  #, gcc-internal-format
  msgid "found %<:%> in nested-name-specifier, expected %<::%>"
-msgstr ""
+msgstr "найдено %<:%> во вложенном спецификаторе имени, ожидалось %<::%>"
  
  #: cp/parser.c:5955
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "decltype evaluates to %qT, which is not a class or enumeration type"
-msgstr "создание массива элементов типа %qT, являющегося абстрактным классом"
+msgstr "decltype обработано до %qT, что не является классом или перечислимым типом"
  
  #: cp/parser.c:5981
  #, fuzzy, gcc-internal-format
@@ -43999,28 +45799,29 @@ msgstr "неполный тип %qT использован во вложенно
  
  #: cp/parser.c:5989
  #, fuzzy, gcc-internal-format
+#| msgid "expected nested-name-specifier"
  msgid "variable template-id %qD in nested-name-specifier"
-msgstr "ожидались спецификаторы декларации"
+msgstr "ожидался вложенный спецификатор имени"
  
  #: cp/parser.c:6093 cp/typeck.c:2610 cp/typeck.c:2613 cp/typeck.c:2633
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is not a template"
-msgstr "%qs не является шаблоном"
+msgstr "%qD не является шаблоном"
  
  #: cp/parser.c:6171
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected nested-name-specifier"
-msgstr "ожидались спецификаторы декларации"
+msgstr "ожидался вложенный спецификатор имени"
  
  #: cp/parser.c:6372 cp/parser.c:8540
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "types may not be defined in casts"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы нельзя определять в приведении типов"
  
  #: cp/parser.c:6453
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "types may not be defined in a %<typeid%> expression"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы нельзя определять в %<typeid%> выражении"
  
  #: cp/parser.c:6511
  #, gcc-internal-format
@@ -44054,29 +45855,29 @@ msgid "invalid use of %qD"
  msgstr "некорректное использование %qD"
  
  #: cp/parser.c:7314
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<%D::%D%> is not a class member"
-msgstr "`%D::%D' не является элементом %qT"
+msgstr "%<%D::%D%> не является элементом класса"
  
  #: cp/parser.c:7612
  #, gcc-internal-format
  msgid "non-scalar type"
-msgstr ""
+msgstr "нескалярный тип"
  
  #: cp/parser.c:7711
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ does not allow %<alignof%> with a non-type"
-msgstr "ISO C++ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ð½Ð°Ð·Ð½Ð°Ñ\87ÐµÐ½Ð½Ñ\8bÐµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ñ\8b"
+msgstr "ISO C++ Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82 %<alignof%> Ñ\81 Ð½Ðµ-Ñ\82Ð¸Ð¿Ð¾Ð¼"
  
  #: cp/parser.c:7796
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "types may not be defined in %<noexcept%> expressions"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы не могут быть определены в %<noexcept%> выражениях"
  
  #: cp/parser.c:8074
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "types may not be defined in a new-expression"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы не могут быть определены в new-выражении"
  
  #: cp/parser.c:8090
  #, gcc-internal-format
@@ -44095,13 +45896,14 @@ msgstr ""
  
  #: cp/parser.c:8171
  #, fuzzy, gcc-internal-format
+#| msgid "Expected expression type"
  msgid "expected expression-list or type-id"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ñ\82Ð¸Ð¿ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
  
  #: cp/parser.c:8200
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "types may not be defined in a new-type-id"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы не могут быть определены в new-type-id"
  
  #: cp/parser.c:8328
  #, gcc-internal-format
@@ -44116,42 +45918,44 @@ msgstr "использование устаревшей конструкции 
  #: cp/parser.c:8783
  #, gcc-internal-format
  msgid "%<>>%> operator is treated as two right angle brackets in C++11"
-msgstr ""
+msgstr "оператор %<>>%> трактуется в C++11 как две правые угловые скобки"
  
  #: cp/parser.c:8786
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "suggest parentheses around %<>>%> expression"
-msgstr "рекомендуется окружать скобками выражение &&, используемое в операнде ||"
+msgstr "рекомендуется окружать скобками выражение %<>>%>"
  
  #: cp/parser.c:8982
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ does not allow ?: with omitted middle operand"
-msgstr "ISO C++ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ð½Ð°Ð·Ð½Ð°Ñ\87ÐµÐ½Ð½Ñ\8bÐµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ñ\8b"
+msgstr "ISO C++ Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82 ?: Ñ\81 Ð¾Ð¿Ñ\83Ñ\89ÐµÐ½Ð½Ñ\8bÐ¼ Ñ\81Ñ\80ÐµÐ´Ð½Ð¸Ð¼ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð¼"
  
  #: cp/parser.c:9690
  #, gcc-internal-format
  msgid "lambda-expression in unevaluated context"
-msgstr ""
+msgstr "lambda-expression в необрабатываемом контексте"
  
  #: cp/parser.c:9699
  #, fuzzy, gcc-internal-format
+#| msgid "lambda-expression in unevaluated context"
  msgid "lambda-expression in template-argument"
-msgstr "ожидался оператор"
+msgstr "lambda-expression в необрабатываемом контексте"
  
  #: cp/parser.c:9850
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected end of capture-list"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f ÐºÐ¾Ð½ÐµÑ\86 capture-list"
  
  #: cp/parser.c:9864
  #, gcc-internal-format
  msgid "explicit by-copy capture of %<this%> redundant with by-copy capture default"
-msgstr ""
+msgstr "явное by-copy capture %<this%> избыточно с by-copy capture умолчанием"
  
  #: cp/parser.c:9908
  #, fuzzy, gcc-internal-format
+#| msgid "lambda expressions only available with -std=c++11 or -std=gnu++11"
  msgid "lambda capture initializers only available with -std=c++14 or -std=gnu++14"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "lambda-выражения доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/parser.c:9915
  #, gcc-internal-format
@@ -44159,49 +45963,52 @@ msgid "empty initializer for lambda init-capture"
  msgstr ""
  
  #: cp/parser.c:9938
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "capture of non-variable %qD "
-msgstr "инкрементация переменной %qD, доступной только на чтение"
+msgstr "capture непеременной %qD "
  
  #: cp/parser.c:9941 cp/parser.c:9951 cp/semantics.c:3371 cp/semantics.c:3381
  #, fuzzy, gcc-internal-format
+#| msgid "%q+#D declared here"
  msgid "%q#D declared here"
-msgstr "%q+D объявлено здесь"
+msgstr "%q+#D декларировано здесь"
  
  #: cp/parser.c:9947
  #, gcc-internal-format
  msgid "capture of variable %qD with non-automatic storage duration"
-msgstr ""
+msgstr "capture переменной  %qD с неавтоматическим сроком хранения"
  
  #: cp/parser.c:9985
  #, gcc-internal-format
  msgid "explicit by-copy capture of %qD redundant with by-copy capture default"
-msgstr ""
+msgstr "явное by-copy capture %qD избыточно с by-copy capture умолчанием"
  
  #: cp/parser.c:9990
  #, gcc-internal-format
  msgid "explicit by-reference capture of %qD redundant with by-reference capture default"
-msgstr ""
+msgstr "явное by-reference capture %qD избыточно с by-reference capture умолчанием"
  
  #: cp/parser.c:10037
  #, fuzzy, gcc-internal-format
+#| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
  msgid "lambda templates are only available with -std=c++14 or -std=gnu++14"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qs Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+msgstr "Ð²Ð°Ñ\80Ð¸Ð°Ð½Ñ\82Ð½Ñ\8bÐµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ñ\8b Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ñ\8b Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ñ\81 -std=c++11 Ð¸Ð»Ð¸ -std=gnu++11"
  
  #: cp/parser.c:10067
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "default argument specified for lambda parameter"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %d Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ `%#D'"
+msgstr "Ð·Ð°Ð´Ð°Ð½ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f lambda-Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð°"
  
  #: cp/parser.c:10546
  #, fuzzy, gcc-internal-format
+#| msgid "attributes after parenthesized initializer ignored"
  msgid "attributes at the beginning of statement are ignored"
  msgstr "атрибуты после инициализатора в скобках проигнорированы"
  
  #: cp/parser.c:10574
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected labeled-statement"
-msgstr "ожидался оператор"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¿Ð¾Ð¼ÐµÑ\87ÐµÐ½Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80"
  
  #: cp/parser.c:10612
  #, gcc-internal-format
@@ -44211,67 +46018,70 @@ msgstr "case-метка %qE вне оператора switch"
  #: cp/parser.c:10697
  #, gcc-internal-format
  msgid "need %<typename%> before %qE because %qT is a dependent scope"
-msgstr ""
+msgstr "требуется %<typename%> перед %qE поскольку %qT зависимый контекст"
  
  #: cp/parser.c:10706
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<%T::%D%> names the constructor, not the type"
-msgstr "%<%T::%D%> обозначает конструктор в %qT"
+msgstr "%<%T::%D%> обозначает конструктор, а не тип"
  
  #: cp/parser.c:10753
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "compound-statement in constexpr function"
-msgstr "%qD не является функцией шаблоном"
+msgstr "составной оператор в constexpr функции"
  
  #: cp/parser.c:10995 cp/parser.c:26946
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected selection-statement"
-msgstr "ожидалась декларация или оператор"
+msgstr "ожидался selection-statement"
  
  #: cp/parser.c:11028
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "types may not be defined in conditions"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы нельзя определять в условиях"
  
  #: cp/parser.c:11408
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "range-based %<for%> expression of type %qT has incomplete type"
-msgstr "оператор-выражение имеет неполный тип"
+msgstr "range-based %<for%> выражение типа %qT имеет неполный тип"
  
  #: cp/parser.c:11446
  #, gcc-internal-format
  msgid "range-based %<for%> expression of type %qT has an %<end%> member but not a %<begin%>"
-msgstr ""
+msgstr "range-based %<for%> выражение типа %qT имеет %<end%> элемент без %<begin%>"
  
  #: cp/parser.c:11452
  #, gcc-internal-format
  msgid "range-based %<for%> expression of type %qT has a %<begin%> member but not an %<end%>"
-msgstr ""
+msgstr "range-based %<for%> выражение типа %qT имеет %<begin%> элемент без %<end%>"
  
  #: cp/parser.c:11504
  #, gcc-internal-format
  msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT"
-msgstr ""
+msgstr "противоречивые begin/end типы в range-based %<for%> операторе: %qT и %qT"
  
  #: cp/parser.c:11639 cp/parser.c:26949
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected iteration-statement"
-msgstr "ожидалась декларация или оператор"
+msgstr "ожидался iteration-statement"
  
  #: cp/parser.c:11687
  #, fuzzy, gcc-internal-format
+#| msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11"
  msgid "range-based %<for%> loops only available with -std=c++11 or -std=gnu++11"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "unrestricted объединения допустимы только с -std=c++11 или -std=gnu++11"
  
  #: cp/parser.c:11761
  #, fuzzy, gcc-internal-format
+#| msgid "break statement used with OpenMP for loop"
  msgid "break statement used with Cilk Plus for loop"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 break Ð²Ð½Ðµ Ñ\86Ð¸ÐºÐ»Ð° Ð¸Ð»Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° switch"
+msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 break Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½ Ñ\81 OpenMP Ð´Ð»Ñ\8f Ñ\86Ð¸ÐºÐ»Ð°"
  
  #: cp/parser.c:11818
  #, fuzzy, gcc-internal-format
+#| msgid "compound-statement in constexpr function"
  msgid "%<goto%> in %<constexpr%> function"
-msgstr "%qD не является функцией шаблоном"
+msgstr "составной оператор в constexpr функции"
  
  #. Issue a warning about this use of a GNU extension.
  #: cp/parser.c:11826
@@ -44280,9 +46090,9 @@ msgid "ISO C++ forbids computed gotos"
  msgstr "ISO C++ не поддерживает вычисляемые goto"
  
  #: cp/parser.c:11839 cp/parser.c:26952
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected jump-statement"
-msgstr "ожидался оператор"
+msgstr "ожидался оператор перехода"
  
  #: cp/parser.c:11996 cp/parser.c:22324
  #, gcc-internal-format
@@ -44292,12 +46102,12 @@ msgstr "избыточная %<;%>"
  #: cp/parser.c:12236
  #, gcc-internal-format
  msgid "%<__label__%> not at the beginning of a block"
-msgstr ""
+msgstr "%<__label__%> не в начале блока"
  
  #: cp/parser.c:12398
  #, gcc-internal-format
  msgid "inconsistent deduction for %qT: %qT and then %qT"
-msgstr ""
+msgstr "противоречивый вывод для %qT: %qT и затем %qT"
  
  #: cp/parser.c:12419
  #, gcc-internal-format
@@ -44315,21 +46125,21 @@ msgid "multiple declarations in range-based %<for%> loop"
  msgstr ""
  
  #: cp/parser.c:12634
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<friend%> used outside of class"
-msgstr "%qD может быть задан только внутри класса"
+msgstr "%<friend%> использовано вне класса"
  
  #. Complain about `auto' as a storage specifier, if
  #. we're complaining about C++0x compatibility.
  #: cp/parser.c:12698
  #, gcc-internal-format
  msgid "%<auto%> changes meaning in C++11; please remove it"
-msgstr ""
+msgstr "%<auto%> меняет смысл в C++11; пожалуйста удалите его"
  
  #: cp/parser.c:12734
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "decl-specifier invalid in condition"
-msgstr "спецификатор pure в определении функции"
+msgstr "decl-specifier некорректен в условии"
  
  #: cp/parser.c:12826
  #, gcc-internal-format
@@ -44339,57 +46149,60 @@ msgstr "определение класса не должно содержать
  #: cp/parser.c:12894 cp/parser.c:22731
  #, gcc-internal-format
  msgid "templates may not be %<virtual%>"
-msgstr ""
+msgstr "шаблоны не могут быть %<virtual%>"
  
  #: cp/parser.c:12934
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid linkage-specification"
-msgstr "некорректная спецификация базового класса"
+msgstr "некорректная linkage-specification"
  
  #: cp/parser.c:13021
  #, fuzzy, gcc-internal-format
+#| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
  msgid "static_assert without a message only available with -std=c++1z or -std=gnu++1z"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "inline namespaces доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/parser.c:13215
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "types may not be defined in %<decltype%> expressions"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы нельзя определять в %<decltype%> выражениях"
  
  #: cp/parser.c:13358
  #, fuzzy, gcc-internal-format
+#| msgid "types may not be defined in a new-type-id"
  msgid "types may not be defined in a conversion-type-id"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы не могут быть определены в new-type-id"
  
  #: cp/parser.c:13385
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of %<auto%> in conversion operator"
-msgstr "некорректное использование %<this%> в функции, не являющейся элементом"
+msgstr "некорректное использование %<auto%> в операторе преобразования"
  
  #: cp/parser.c:13389
  #, fuzzy, gcc-internal-format
+#| msgid "invalid use of %<auto%> in conversion operator"
  msgid "use of %<auto%> in member template conversion operator can never be deduced"
-msgstr "некорректное использование %<this%> в функции, не являющейся элементом"
+msgstr "некорректное использование %<auto%> в операторе преобразования"
  
  #: cp/parser.c:13478
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "only constructors take member initializers"
-msgstr "Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ð¾Ð² Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð° Ð±Ð°Ð·Ð¾Ð²Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f"
+msgstr "Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ñ\8b Ð±ÐµÑ\80Ñ\83Ñ\82 Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ñ\8b Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð²"
  
  #: cp/parser.c:13500
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot expand initializer for member %<%D%>"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80 Ð´Ð»Ñ\8f Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° %qD"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80Ð¸Ñ\82Ñ\8c Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80 Ð´Ð»Ñ\8f Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° %<%D%>"
  
  #: cp/parser.c:13512
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "mem-initializer for %qD follows constructor delegation"
-msgstr "static-декларация %q+D после неstatic-декларации"
+msgstr "mem-initializer для %qD следует за constructor delegation"
  
  #: cp/parser.c:13524
  #, gcc-internal-format
  msgid "constructor delegation follows mem-initializer for %qD"
-msgstr ""
+msgstr "constructor delegation следует за mem-initializer для %qD"
  
  #: cp/parser.c:13576
  #, gcc-internal-format
@@ -44402,29 +46215,31 @@ msgid "keyword %<typename%> not allowed in this context (a qualified member init
  msgstr "ключевое слово %<typename%> запрещено в этом контексте (инициализатор квалифицированного элемента неявно является типом)"
  
  #: cp/parser.c:14005
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "missing space between %<\"\"%> and suffix identifier"
  msgid "unexpected keyword; remove space between quotes and suffix identifier"
-msgstr ""
+msgstr "отсутствует пробел между %<\"\"%> и суффикс-идентификатором"
  
  #: cp/parser.c:14011
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected suffix identifier"
-msgstr "ожидался идентификатор"
+msgstr "ожидался суффикс-идентификатор"
  
  #: cp/parser.c:14020
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected empty string after %<operator%> keyword"
-msgstr "ожидался строковый литерал"
+msgstr "ожидалась пустая строка после ключевого слова %<operator%>"
  
  #: cp/parser.c:14026
  #, fuzzy, gcc-internal-format
+#| msgid "invalid operands in ternary operation"
  msgid "invalid encoding prefix in literal operator"
-msgstr "неверные операнды бинарной операции %s"
+msgstr "неверные операнды тернарной операции"
  
  #: cp/parser.c:14049
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected operator"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80"
  
  #. Warn that we do not support `export'.
  #: cp/parser.c:14094
@@ -44434,13 +46249,16 @@ msgstr "ключевое слово %<export%> не реализовано; иг
  
  #: cp/parser.c:14264
  #, fuzzy, gcc-internal-format
+#| msgid "invalid template non-type parameter"
  msgid "invalid constrained type parameter"
-msgstr "Ð½ÐµÐ¿Ñ\80Ð°Ð²Ð¸Ð»Ñ\8cÐ½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÐ´Ð¾Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð¾Ð³Ð¾ typedef %qD"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð½ÐµÑ\82Ð¸Ð¿Ð¾Ð²Ñ\8bÐ¹ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
  
+#
  #: cp/parser.c:14272
  #, fuzzy, gcc-internal-format
+#| msgid "invalid catch parameter"
  msgid "cv-qualified type parameter"
-msgstr "некорректный параметр %qs"
+msgstr "некорректный catch параметр"
  
  #: cp/parser.c:14357
  #, gcc-internal-format
@@ -44449,28 +46267,29 @@ msgstr ""
  
  #: cp/parser.c:14421
  #, fuzzy, gcc-internal-format
+#| msgid "invalid use of template template parameter %qT"
  msgid "invalid use of %<auto%> in default template argument"
-msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° `%#D'"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qT"
  
  #: cp/parser.c:14656 cp/parser.c:14739 cp/parser.c:20599
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template parameter pack %qD cannot have a default argument"
-msgstr "%qD не может иметь аргументов по умолчанию"
+msgstr "pack параметр шаблона %qD не может иметь аргумент по умолчанию"
  
  #: cp/parser.c:14660 cp/parser.c:14743
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template parameter packs cannot have default arguments"
-msgstr "параметры шаблона не могут быть friend"
+msgstr "pack параметры шаблона не могут иметь аргументы по умолчанию"
  
  #: cp/parser.c:14809
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected template-id"
-msgstr "ожидался оператор"
+msgstr "ожидался template-id"
  
  #: cp/parser.c:14862 cp/parser.c:26910
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<<%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<<%>"
  
  #: cp/parser.c:14869
  #, gcc-internal-format
@@ -44484,19 +46303,20 @@ msgstr "%<<:%> - альтернативное написание %<[%>. Вста
  
  #: cp/parser.c:14877
  #, fuzzy, gcc-internal-format
+#| msgid "(if you use %<-fpermissive%> G++ will accept your code)"
  msgid "(if you use %<-fpermissive%> or %<-std=c++11%>, or %<-std=gnu++11%> G++ will accept your code)"
-msgstr "(G++ примет такой код с ключом `-fpermissive')"
+msgstr "(если вы используете %<-fpermissive%> G++ примет ваш код)"
  
  #: cp/parser.c:14984
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parse error in template argument list"
-msgstr "список аргументов шаблона не должен начинаться с `<::'"
+msgstr "ошибка разбора в списке аргументов шаблона"
  
  #. The name does not name a template.
  #: cp/parser.c:15053 cp/parser.c:15174 cp/parser.c:15389
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected template-name"
-msgstr "ожидался оператор"
+msgstr "ожидалось template-name"
  
  #. Explain what went wrong.
  #: cp/parser.c:15099
@@ -44510,29 +46330,29 @@ msgid "use %<%T::template %D%> to indicate that it is a template"
  msgstr "используйте нотацию %<%T::template %D%> для указания о том, что это шаблон"
  
  #: cp/parser.c:15241
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected parameter pack before %<...%>"
-msgstr "ожидались спецификаторы декларации или %<...%>"
+msgstr "ожидался pack параметр перед %<...%>"
  
  #: cp/parser.c:15350 cp/parser.c:15368 cp/parser.c:15535
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected template-argument"
-msgstr "ожидался оператор"
+msgstr "ожидался template-argument"
  
  #: cp/parser.c:15510
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid non-type template argument"
-msgstr "некорректный тип аргумента"
+msgstr "некорректный нетиповый аргумент шаблона"
  
  #: cp/parser.c:15637
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "explicit instantiation shall not use %<inline%> specifier"
-msgstr "явная конкретизация типа %qT, не являющегося шаблоном"
+msgstr "явная конкретизация не должна использовать %<inline%> спецификатор"
  
  #: cp/parser.c:15641
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "explicit instantiation shall not use %<constexpr%> specifier"
-msgstr "явная конкретизация типа %qT, не являющегося шаблоном"
+msgstr "явная конкретизация не должна использовать %<constexpr%> спецификатор"
  
  #: cp/parser.c:15700
  #, gcc-internal-format
@@ -44540,19 +46360,21 @@ msgid "template specialization with C linkage"
  msgstr "специализация шаблона с привязкой C"
  
  #: cp/parser.c:15920
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected type specifier"
-msgstr "ожидались спецификаторы декларации"
+msgstr "ожидался спецификатор типа"
  
  #: cp/parser.c:16100
  #, fuzzy, gcc-internal-format
+#| msgid "defaulted and deleted functions only available with -std=c++11 or -std=gnu++11"
  msgid "use of %<auto%> in lambda parameter declaration only available with -std=c++14 or -std=gnu++14"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "сведенные к подразумеваемым и удаленные функции доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/parser.c:16106
  #, fuzzy, gcc-internal-format
+#| msgid "defaulted and deleted functions only available with -std=c++11 or -std=gnu++11"
  msgid "use of %<auto%> in parameter declaration only available with -std=c++14 or -std=gnu++14"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "сведенные к подразумеваемым и удаленные функции доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/parser.c:16111
  #, fuzzy, gcc-internal-format
@@ -44561,49 +46383,50 @@ msgid "ISO C++ forbids use of %<auto%> in parameter declaration"
  msgstr "в ISO C упреждающие декларации параметров запрещены"
  
  #: cp/parser.c:16255
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected template-id for type"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f template-id Ð´Ð»Ñ\8f Ñ\82Ð¸Ð¿Ð°"
  
  #: cp/parser.c:16282
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected type-name"
-msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
  
  #: cp/parser.c:16631
  #, gcc-internal-format
  msgid "elaborated-type-specifier for a scoped enum must not use the %<%D%> keyword"
-msgstr ""
+msgstr "elaborated-type-specifier для scoped enum не должен использовать ключевое слово %<%D%>"
  
  #: cp/parser.c:16840
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration %qD does not declare anything"
-msgstr "декларация ничего не описывает"
+msgstr "декларация %qD ничего не декларирует"
  
  #: cp/parser.c:16927
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "attributes ignored on uninstantiated type"
-msgstr "атрибут %qE для не классовых типов игнорируется"
+msgstr "атрибуты игнорируются для неконкретизированного типа"
  
  #: cp/parser.c:16931
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "attributes ignored on template instantiation"
-msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 Ñ\85Ñ\80Ð°Ð½ÐµÐ½Ð¸Ñ\8f %qD Ð² конкретизации шаблона"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f Ð´Ð»Ñ\8f конкретизации шаблона"
  
  #: cp/parser.c:16936
  #, gcc-internal-format
  msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration"
-msgstr ""
+msgstr "атрибуты игнорируются для elaborated-type-specifier который не является forward декларацией"
  
  #: cp/parser.c:17070
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is an enumeration template"
-msgstr "%qD не является шаблоном функции"
+msgstr "%qD является шаблоном перечисления"
  
  #: cp/parser.c:17081
  #, fuzzy, gcc-internal-format
+#| msgid "%qD does not have integral or enumeration type"
  msgid "%qD does not name an enumeration in %qT"
-msgstr "выражение в деклараторе new должно иметь целый или перечислимый тип"
+msgstr "%qD не имеет целый или перечислимый тип"
  
  #: cp/parser.c:17096
  #, gcc-internal-format
@@ -44611,14 +46434,14 @@ msgid "anonymous scoped enum is not allowed"
  msgstr ""
  
  #: cp/parser.c:17151
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<;%> or %<{%>"
-msgstr "ожидалось %<,%> или %<;%>"
+msgstr "ожидалось %<;%> или %<{%>"
  
  #: cp/parser.c:17200
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot add an enumerator list to a template instantiation"
-msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð°Ð²Ñ\82Ð¾Ð¼Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÑ\83Ñ\8e ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð¾Ð²"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´Ð¾Ð±Ð°Ð²Ð¸Ñ\82Ñ\8c enumerator Ñ\81Ð¿Ð¸Ñ\81Ð¾Ðº Ðº ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
  
  #: cp/parser.c:17214
  #, fuzzy, gcc-internal-format
@@ -44627,9 +46450,9 @@ msgid "nested name specifier %qT for enum declaration does not name a class or n
  msgstr "в декларации friend нет имени класса или функции"
  
  #: cp/parser.c:17226 cp/parser.c:21835
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "declaration of %qD in namespace %qD which does not enclose %qD"
-msgstr "декларация %qD в %qD, который не объемлет %qD"
+msgstr "декларация %qD в пространстве имен %qD, которое не включает %qD"
  
  #: cp/parser.c:17231 cp/parser.c:21840
  #, gcc-internal-format
@@ -44643,38 +46466,41 @@ msgstr "повторное определение %q#T"
  
  #: cp/parser.c:17269
  #, fuzzy, gcc-internal-format
+#| msgid "ISO C++ forbids incrementing an enum"
  msgid "ISO C++ forbids empty anonymous enum"
-msgstr "ISO C++ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 %sÐ°Ñ\86Ð¸Ñ\8e Ð¿Ð¾ Ð¾Ñ\82Ð½Ð¾Ñ\88ÐµÐ½Ð¸Ñ\8e Ðº Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»Ð¸Ð¼Ð¾Ð¼Ñ\83 Ñ\82Ð¸Ð¿Ñ\83"
+msgstr "ISO C++ Ð·Ð°Ð¿Ñ\80ÐµÑ\89Ð°ÐµÑ\82 Ð¸Ð½ÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ enum"
  
  #: cp/parser.c:17289
  #, gcc-internal-format
  msgid "opaque-enum-specifier without name"
-msgstr ""
+msgstr "opaque-enum-specifier без имени"
  
  #: cp/parser.c:17292
  #, gcc-internal-format
  msgid "opaque-enum-specifier must use a simple identifier"
-msgstr ""
+msgstr "opaque-enum-specifier должен использовать простой идентификатор"
  
  #: cp/parser.c:17470
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is not a namespace-name"
-msgstr "%qT не является пространством имён"
+msgstr "%qD не есть namespace-name"
  
  #: cp/parser.c:17471
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected namespace-name"
-msgstr "ожидалось имя класса"
+msgstr "ожидалось namespace-name"
  
  #: cp/parser.c:17549
  #, fuzzy, gcc-internal-format
+#| msgid "%<namespace%> definition is not allowed here"
  msgid "a nested namespace definition cannot have attributes"
-msgstr "#pragma %s уже зарегистрирована"
+msgstr "%<namespace%> определение здесь не допускается"
  
  #: cp/parser.c:17552
  #, fuzzy, gcc-internal-format
+#| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
  msgid "nested namespace definitions only available with -std=c++1z or -std=gnu++1z"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "inline namespaces доступны только с -std=c++11 или -std=gnu++11"
  
  #: cp/parser.c:17555
  #, fuzzy, gcc-internal-format
@@ -44684,9 +46510,9 @@ msgstr "Предупреждать об inline-функциях, подстан
  
  #: cp/parser.c:17563
  #, fuzzy, gcc-internal-format
-#| msgid "expected identifier"
+#| msgid "expected identifier before %qE"
  msgid "nested identifier required"
-msgstr "ожидался идентификатор"
+msgstr "ожидался идентификатор перед %qE"
  
  #: cp/parser.c:17591
  #, fuzzy, gcc-internal-format
@@ -44695,9 +46521,9 @@ msgid "namespace %qD entered"
  msgstr "использование пространства имён %qD в качестве выражения"
  
  #: cp/parser.c:17643
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<namespace%> definition is not allowed here"
-msgstr "#pragma %s уже зарегистрирована"
+msgstr "%<namespace%> определение здесь не допускается"
  
  #: cp/parser.c:17798
  #, gcc-internal-format
@@ -44707,22 +46533,23 @@ msgstr "идентификатор шаблона недопустим в using-
  #: cp/parser.c:17844
  #, gcc-internal-format
  msgid "access declarations are deprecated in favour of using-declarations; suggestion: add the %<using%> keyword"
-msgstr ""
+msgstr "декларациям доступа следует предпочесть using-declarations; предлагается: добавьте ключевое слово %<using%>"
  
  #: cp/parser.c:17909
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "types may not be defined in alias template declarations"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы нельзя определять в алиасных декларациях шаблонов"
  
  #: cp/parser.c:18062
  #, fuzzy, gcc-internal-format
+#| msgid "compound-statement in constexpr function"
  msgid "%<asm%> in %<constexpr%> function"
-msgstr "%qD не является функцией шаблоном"
+msgstr "составной оператор в constexpr функции"
  
  #: cp/parser.c:18428
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "a function-definition is not allowed here"
-msgstr "#pragma %s уже зарегистрирована"
+msgstr "function-definition здесь не допускается"
  
  #: cp/parser.c:18439
  #, gcc-internal-format
@@ -44737,18 +46564,18 @@ msgstr "атрибуты не допускаются при определени
  #: cp/parser.c:18494
  #, gcc-internal-format
  msgid "expected constructor, destructor, or type conversion"
-msgstr ""
+msgstr "ожидался конструктор, деструктор или преобразование типа"
  
  #. Anything else is an error.
  #: cp/parser.c:18533 cp/parser.c:20790
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected initializer"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸Ðºатор"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·атор"
  
  #: cp/parser.c:18614
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "initializer provided for function"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f friend-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs"
+msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80 Ð·Ð°Ð´Ð°Ð½ Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
  
  #: cp/parser.c:18648
  #, gcc-internal-format
@@ -44762,24 +46589,24 @@ msgid "non-function %qD declared as implicit template"
  msgstr "функция %q+D повторно декларирована как inline"
  
  #: cp/parser.c:19102
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "array bound is not an integer constant"
-msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ð¾Ð¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
  
  #: cp/parser.c:19228
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot define member of dependent typedef %qT"
-msgstr "создание указателя на элемент ссылочного типа %qT"
+msgstr "невозможно определить элемент зависимого typedef %qT"
  
  #: cp/parser.c:19232
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<%T::%E%> is not a type"
-msgstr "%<%T::%D%> не является типом"
+msgstr "%<%T::%E%> не является типом"
  
  #: cp/parser.c:19260
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of constructor as a template"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÑ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° Ð´Ð°Ð½Ð½Ñ\8bÑ\85 '%E'"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ð° ÐºÐ°Ðº Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
  
  #: cp/parser.c:19262
  #, gcc-internal-format
@@ -44791,46 +46618,48 @@ msgstr "используйте %<%T::%D%> вместо %<%T::%D%> для име
  #. information about its original syntactic
  #. form.
  #: cp/parser.c:19279
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid declarator"
-msgstr "некорректная декларация %q+D"
+msgstr "некорректная декларация"
  
  #. But declarations with qualified-ids can't appear in a
  #. function.
  #: cp/parser.c:19349
  #, fuzzy, gcc-internal-format
+#| msgid "invalid type in declaration"
  msgid "qualified-id in declaration"
-msgstr "%J%qD использовано до декларации"
+msgstr "некорректный тип в декларации"
  
  #: cp/parser.c:19374
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected declarator"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¸Ñ\81Ñ\8c Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ñ\8b Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f"
  
  #: cp/parser.c:19477
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is a namespace"
-msgstr "%qT не является пространством имён"
+msgstr "%qD является пространством имён"
  
  #: cp/parser.c:19479
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot form pointer to member of non-class %q#T"
-msgstr "создание указателя на элемент не классового типа %qT"
+msgstr "невозможно сформировать указатель на элемент не класса %q#T"
  
  #: cp/parser.c:19500
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected ptr-operator"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f ptr-operator"
  
  #: cp/parser.c:19559
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "duplicate cv-qualifier"
-msgstr "повтор case-значения,"
+msgstr "повторный cv-qualifier"
  
  #: cp/parser.c:19613
  #, fuzzy, gcc-internal-format
+#| msgid "duplicate cv-qualifier"
  msgid "multiple ref-qualifiers"
-msgstr "повтор case-значения,"
+msgstr "повторный cv-qualifier"
  
  #: cp/parser.c:19650
  #, gcc-internal-format
@@ -44838,39 +46667,40 @@ msgid "%E requires %<-fgnu-tm%>"
  msgstr ""
  
  #: cp/parser.c:19706
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "duplicate virt-specifier"
-msgstr "повтор case-значения,"
+msgstr "повторный virt-specifier"
  
  #: cp/parser.c:19936 cp/typeck2.c:529 cp/typeck2.c:1950
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of %<auto%>"
-msgstr "недопустимое использование %<::%>"
+msgstr "недопустимое использование %<auto%>"
  
  #: cp/parser.c:19957
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "types may not be defined in template arguments"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы нельзя определять в аргументах шаблона"
  
  #: cp/parser.c:19962
  #, fuzzy, gcc-internal-format
+#| msgid "invalid non-type template argument"
  msgid "invalid use of %<auto%> in template argument"
-msgstr "некорректный тип аргумента"
+msgstr "некорректный нетиповый аргумент шаблона"
  
  #: cp/parser.c:20050
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected type-specifier"
-msgstr "ожидался идентификатор"
+msgstr "ожидался type-specifier"
  
  #: cp/parser.c:20356
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<,%> or %<...%>"
-msgstr "ожидалось %<:%> или %<...%>"
+msgstr "ожидалось %<,%> или %<...%>"
  
  #: cp/parser.c:20431
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "types may not be defined in parameter types"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы нельзя определять в типах параметров"
  
  #: cp/parser.c:20583
  #, gcc-internal-format
@@ -44878,19 +46708,19 @@ msgid "default arguments are only permitted for function parameters"
  msgstr "аргументы по умолчанию разрешены только для параметров функций"
  
  #: cp/parser.c:20601
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter pack %qD cannot have a default argument"
-msgstr "%qD не может иметь аргументов по умолчанию"
+msgstr "parameter pack %qD не может иметь подразумеваемый аргумент"
  
  #: cp/parser.c:20607
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template parameter pack cannot have a default argument"
-msgstr "%qD не может иметь аргументов по умолчанию"
+msgstr "pack параметр шаблона не может иметь аргумент по умолчанию"
  
  #: cp/parser.c:20609
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter pack cannot have a default argument"
-msgstr "%qD не может иметь аргументов по умолчанию"
+msgstr "parameter pack не может иметь подразумеваемый аргумент"
  
  #: cp/parser.c:20993
  #, gcc-internal-format
@@ -44898,74 +46728,74 @@ msgid "ISO C++ does not allow designated initializers"
  msgstr "ISO C++ не поддерживает назначенные инициализаторы"
  
  #: cp/parser.c:21007
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ does not allow C99 designated initializers"
-msgstr "ISO C++ не поддерживает назначенные инициализаторы"
+msgstr "ISO C++ не поддерживает C99 назначенные инициализаторы"
  
  #: cp/parser.c:21127 cp/parser.c:21253
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected class-name"
-msgstr "ожидалось имя класса"
+msgstr "ожидалось class-name"
  
  #: cp/parser.c:21440
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<;%> after class definition"
-msgstr "%q+D: inline-декларация после определения"
+msgstr "ожидалось %<;%> после определения класса"
  
  #: cp/parser.c:21442
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<;%> after struct definition"
-msgstr "%q+D: inline-декларация после определения"
+msgstr "ожидалось %<;%> после определения структуры"
  
  #: cp/parser.c:21444
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<;%> after union definition"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð² %C"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<;%> Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð¾Ð±Ñ\8aÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ñ\8f"
  
  #: cp/parser.c:21783
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<{%> or %<:%>"
-msgstr "ожидалось %<,%> или %<;%>"
+msgstr "ожидалось %<{%> или %<:%>"
  
  #: cp/parser.c:21794
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot specify %<override%> for a class"
-msgstr "нет файла для класса %s"
+msgstr "невозможно задать %<override%> для класса"
  
  #: cp/parser.c:21802
  #, gcc-internal-format
  msgid "global qualification of class name is invalid"
-msgstr ""
+msgstr "global квалификация имени класса некорректна"
  
  #: cp/parser.c:21809
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "qualified name does not name a class"
-msgstr "Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ friend Ð½ÐµÑ\82 Ð¸Ð¼ÐµÐ½Ð¸ ÐºÐ»Ð°Ñ\81Ñ\81Ð° Ð¸Ð»Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ðµ Ð¸Ð¼Ñ\8f Ð½Ðµ Ð¸Ð¼ÐµÐ½Ñ\83ÐµÑ\82 ÐºÐ»Ð°Ñ\81Ñ\81"
  
  #: cp/parser.c:21821
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid class name in declaration of %qD"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f template-Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ð¼Ñ\8f ÐºÐ»Ð°Ñ\81Ñ\81Ð° Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %qD"
  
  #: cp/parser.c:21854
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "extra qualification not allowed"
-msgstr "избыточные квалификаторы проигнориованы"
+msgstr "избыточная квалификация не допускается"
  
  #: cp/parser.c:21866
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "an explicit specialization must be preceded by %<template <>%>"
-msgstr "перед явной специализацией должно быть 'template <>'"
+msgstr "перед явной специализацией должно быть %<template <>%>"
  
  #: cp/parser.c:21896
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "function template %qD redeclared as a class template"
-msgstr "не шаблон %qD использован как шаблон"
+msgstr "шаблон функции %qD редекларирован как шаблон класса"
  
  #: cp/parser.c:21927
  #, gcc-internal-format
  msgid "could not resolve typename type"
-msgstr ""
+msgstr "невозможно разрешить typename type"
  
  #: cp/parser.c:21983
  #, gcc-internal-format
@@ -44973,9 +46803,9 @@ msgid "previous definition of %q+#T"
  msgstr "предыдущее определение %q+#T"
  
  #: cp/parser.c:22074 cp/parser.c:26955
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected class-key"
-msgstr "ожидалось имя класса"
+msgstr "ожидалось class-key"
  
  #: cp/parser.c:22098
  #, gcc-internal-format
@@ -44984,13 +46814,14 @@ msgstr ""
  
  #: cp/parser.c:22102
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<class%>, %<typename%>, or %<template%>"
  msgid "expected %<class%> or %<typename%>"
-msgstr "ожидалось %<,%>, %<;%> или %<}%>"
+msgstr "ожидалось %<class%>, %<typename%> или %<template%>"
  
  #: cp/parser.c:22344
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "in C++03 a class-key must be used when declaring a friend"
-msgstr "в декларации friend должно быть использовано ключевое слово класса"
+msgstr "в C++03 class-key должен использоваться при декларировании friend"
  
  #: cp/parser.c:22362
  #, gcc-internal-format
@@ -45009,73 +46840,78 @@ msgstr "спецификатор pure в определении функции"
  
  #: cp/parser.c:22639
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<;%> at end of member declaration"
  msgid "stray %<,%> at end of member declaration"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<;%> Ð² ÐºÐ¾Ð½Ñ\86Ðµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð°"
  
  #: cp/parser.c:22651
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<;%> at end of member declaration"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<;%> Ð² ÐºÐ¾Ð½Ñ\86Ðµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð°"
  
  #: cp/parser.c:22725
  #, gcc-internal-format
  msgid "invalid pure specifier (only %<= 0%> is allowed)"
-msgstr ""
+msgstr "некорректный спецификатор pure (только %<= 0%> допускается)"
  
  #: cp/parser.c:22760
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "a brace-enclosed initializer is not allowed here"
-msgstr "#pragma %s уже зарегистрирована"
+msgstr "инициализатор в фигурных скобках здесь не допускается"
  
  #: cp/parser.c:22889
  #, gcc-internal-format
  msgid "%<virtual%> specified more than once in base-specified"
-msgstr ""
+msgstr "%<virtual%> задано более одного раза в base-specified"
  
  #: cp/parser.c:22909
  #, gcc-internal-format
  msgid "more than one access specifier in base-specified"
-msgstr ""
+msgstr "более одного спецификатора access в base-specified"
  
  #: cp/parser.c:22933
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "keyword %<typename%> not allowed outside of templates"
-msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ `typename' Ð²Ð½Ðµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
+msgstr "ÐºÐ»Ñ\8eÑ\87ÐµÐ²Ð¾Ðµ Ñ\81Ð»Ð¾Ð²Ð¾ %<typename%> Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f Ð²Ð½Ðµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð¾Ð²"
  
  #: cp/parser.c:22936
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)"
-msgstr "ключевое слово `typename' запрещено в этом контексте (инициализатор квалифицированного элемента неявно является типом)"
+msgstr "ключевое слово %<typename%> запрещено в этом контексте (базовый класс неявно является типом)"
  
  #: cp/parser.c:23029 cp/parser.c:23111
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "types may not be defined in an exception-specification"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы нельзя определять в exception-specification"
  
  #: cp/parser.c:23093
  #, gcc-internal-format
  msgid "dynamic exception specifications are deprecated in C++0x; use %<noexcept%> instead"
-msgstr ""
+msgstr "динамические спецификации исключений не рекомендуются в C++0x; использийте вместо этого %<noexcept%>"
  
  #: cp/parser.c:23153
  #, fuzzy, gcc-internal-format
+#| msgid "invalid use of %<auto%> in conversion operator"
  msgid "invalid use of %<auto%> in exception-specification"
-msgstr "некорректное использование %<this%> в функции, не являющейся элементом"
+msgstr "некорректное использование %<auto%> в операторе преобразования"
  
+#
  #: cp/parser.c:23192
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not %<constexpr%>"
  msgid "%<try%> in %<constexpr%> function"
-msgstr "%qD не является типом"
+msgstr "%qD не есть %<constexpr%>"
  
  #: cp/parser.c:23305
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "types may not be defined in exception-declarations"
-msgstr "в описании возвращаемого типа нельзя определять новые типы"
+msgstr "типы нельзя определять в exception-declarations"
  
  #: cp/parser.c:23917
  #, fuzzy, gcc-internal-format
+#| msgid "expected identifier before string constant"
  msgid "expected an identifier for the attribute name"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð¸Ð»Ð¸ %<(%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð¿ÐµÑ\80ÐµÐ´ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾Ð²Ð¾Ð¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
  
  #: cp/parser.c:23936
  #, gcc-internal-format
@@ -45093,24 +46929,26 @@ msgid "attribute deprecated can appear at most once in an attribute-list"
  msgstr ""
  
  #: cp/parser.c:24273
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<@required%> is not available in Objective-C 1.0"
  msgid "%<requires%> only available with -fconcepts"
-msgstr ""
+msgstr "%<@required%> недоступно в Objective-C 1.0"
  
  #: cp/parser.c:24305
  #, fuzzy, gcc-internal-format
+#| msgid "a transaction expression cannot appear in a constant-expression"
  msgid "a requires expression cannot appear outside a template"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "транзакционное выражение не может присутствовать в константном выражении"
  
  #: cp/parser.c:25001
  #, gcc-internal-format
  msgid "specializing member %<%T::%E%> requires %<template<>%> syntax"
-msgstr ""
+msgstr "специализация элемента %<%T::%E%> требует %<template<>%> синтаксис"
  
  #: cp/parser.c:25006
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid declaration of %<%T::%E%>"
-msgstr "некорректная декларация %q+D"
+msgstr "некорректная декларация %<%T::%E%>"
  
  #: cp/parser.c:25010
  #, gcc-internal-format
@@ -45132,19 +46970,21 @@ msgid "named return values are no longer supported"
  msgstr "именованные возвращаемые значения больше не поддерживаются"
  
  #: cp/parser.c:25508
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "literal operator template %qD has invalid parameter list.  Expected non-type template argument pack <char...>"
  msgid "literal operator template %qD has invalid parameter list.  Expected non-type template argument pack <char...> or <typename CharT, CharT...>"
-msgstr ""
+msgstr "шаблон литерального оператора %qD имеет некорректный список параметров. Ожидался нетиповый pack аргумент шаблона <char...>"
  
  #: cp/parser.c:25513
  #, gcc-internal-format
  msgid "literal operator template %qD has invalid parameter list.  Expected non-type template argument pack <char...>"
-msgstr ""
+msgstr "шаблон литерального оператора %qD имеет некорректный список параметров. Ожидался нетиповый pack аргумент шаблона <char...>"
  
  #: cp/parser.c:25582
  #, fuzzy, gcc-internal-format
+#| msgid "Enable multiply instructions"
  msgid "empty introduction-list"
-msgstr "Включить инструкции умножения с накоплением с нечётким результатом"
+msgstr "Включить инструкции умножения"
  
  #: cp/parser.c:25606
  #, fuzzy, gcc-internal-format
@@ -45153,9 +46993,9 @@ msgid "no matching concept for template-introduction"
  msgstr "нет подходящего шаблона для %qD"
  
  #: cp/parser.c:25628
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid declaration of member template in local class"
-msgstr "некорректная декларация шаблона-элемента `%#D' в локальном классе"
+msgstr "некорректная декларация шаблона элемента в локальном классе"
  
  #: cp/parser.c:25637
  #, gcc-internal-format
@@ -45163,14 +47003,14 @@ msgid "template with C linkage"
  msgstr "шаблон с привязкой C"
  
  #: cp/parser.c:25656
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid explicit specialization"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð±Ð°Ð·Ð¾Ð²Ð¾Ð³Ð¾ ÐºÐ»Ð°Ñ\81Ñ\81Ð°"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\8fÐ²Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f"
  
  #: cp/parser.c:25757
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template declaration of %<typedef%>"
-msgstr "шаблонная декларация `%#D'"
+msgstr "шаблонная декларация %<typedef%>"
  
  #: cp/parser.c:25808
  #, fuzzy, gcc-internal-format
@@ -45179,14 +47019,14 @@ msgid "a class template declaration must not declare anything else"
  msgstr "декларация ничего не описывает"
  
  #: cp/parser.c:25854
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "explicit template specialization cannot have a storage class"
-msgstr "явная специализация в не-namespace области %qD"
+msgstr "явная специализация шаблона не может иметь класс хранения"
  
  #: cp/parser.c:26124
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<>>%> should be %<> >%> within a nested template argument list"
-msgstr "%H%<>>%> должно быть %<> >%> внутри списка аргументов вложенного шаблона"
+msgstr "%<>>%> должно быть %<> >%> внутри списка аргументов вложенного шаблона"
  
  #: cp/parser.c:26137
  #, gcc-internal-format
@@ -45199,187 +47039,191 @@ msgid "%<sizeof...%> argument must be surrounded by parentheses"
  msgstr ""
  
  #: cp/parser.c:26590
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of %qD in linkage specification"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð±Ð°Ð·Ð¾Ð²Ð¾Ð³Ð¾ ÐºÐ»Ð°Ñ\81Ñ\81Ð°"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ %qD Ð² Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð¿Ñ\80Ð¸Ð²Ñ\8fÐ·ÐºÐ¸"
  
  #: cp/parser.c:26605
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<__thread%> before %qD"
-msgstr "%<__thread%> перед %<extern%>"
+msgstr "%<__thread%> перед %qD"
  
  #: cp/parser.c:26739
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ 1998 does not support %<long long%>"
-msgstr "ISO C++ не поддерживает %<long long%>"
+msgstr "ISO C++ 1998 не поддерживает %<long long%>"
  
+#
  #: cp/parser.c:26747
  #, fuzzy, gcc-internal-format
+#| msgid "both %<_Sat%> and %<char%> in declaration specifiers"
  msgid "both %<__thread%> and %<thread_local%> specified"
-msgstr "в декларации использованы спецификаторы %<short%> и %<char%>"
+msgstr "в спецификаторах декларации заданы и %<_Sat%> и %<char%>"
  
  #: cp/parser.c:26749
  #, fuzzy, gcc-internal-format
+#| msgid "duplicate %qE"
  msgid "duplicate %qD"
  msgstr "дублирование %qE"
  
  #: cp/parser.c:26771
  #, gcc-internal-format
  msgid "duplicate %qs"
-msgstr "дублирование %s"
+msgstr "дублирование %qs"
  
  #: cp/parser.c:26813
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<new%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<new%>"
  
  #: cp/parser.c:26816
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<delete%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<delete%>"
  
  #: cp/parser.c:26819
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<return%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<return%>"
  
  #: cp/parser.c:26825
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<extern%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<extern%>"
  
  #: cp/parser.c:26828
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<static_assert%>"
-msgstr "ожидался оператор"
+msgstr "ожидалось %<static_assert%>"
  
  #: cp/parser.c:26831
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<decltype%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<decltype%>"
  
  #: cp/parser.c:26834
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<operator%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<operator%>"
  
  #: cp/parser.c:26837
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<class%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<class%>"
  
  #: cp/parser.c:26840
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<template%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<template%>"
  
  #: cp/parser.c:26843
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<namespace%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<namespace%>"
  
  #: cp/parser.c:26846
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<using%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<using%>"
  
  #: cp/parser.c:26849
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<asm%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<asm%>"
  
  #: cp/parser.c:26852
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<try%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<try%>"
  
  #: cp/parser.c:26855
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<catch%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<catch%>"
  
  #: cp/parser.c:26858
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<throw%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<throw%>"
  
  #: cp/parser.c:26861
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<__label__%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<__label__%>"
  
  #: cp/parser.c:26864
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<@try%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<@try%>"
  
  #: cp/parser.c:26867
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<@synchronized%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<@synchronized%>"
  
  #: cp/parser.c:26870
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<@throw%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<@throw%>"
  
  #: cp/parser.c:26873
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<__transaction_atomic%>"
-msgstr "ожидался оператор"
+msgstr "ожидалось %<__transaction_atomic%>"
  
  #: cp/parser.c:26876
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<__transaction_relaxed%>"
-msgstr "ожидался оператор"
+msgstr "ожидалось %<__transaction_relaxed%>"
  
  #: cp/parser.c:26907
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<::%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<::%>"
  
  #: cp/parser.c:26919
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<...%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<...%>"
  
  #: cp/parser.c:26922
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<*%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<*%>"
  
  #: cp/parser.c:26925
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<~%>"
-msgstr "ожидалось %<{%>"
+msgstr "ожидалось %<~%>"
  
  #: cp/parser.c:26931
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<:%> or %<::%>"
-msgstr "ожидалось %<:%> или %<...%>"
+msgstr "ожидалось %<:%> или %<::%>"
  
  #: cp/parser.c:26959
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %<class%>, %<typename%>, or %<template%>"
-msgstr "ожидалось %<,%>, %<;%> или %<}%>"
+msgstr "ожидалось %<class%>, %<typename%> или %<template%>"
  
  #: cp/parser.c:27220
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs tag used in naming %q#T"
-msgstr "определение %qD уже есть в %qT"
+msgstr "%qs tag использован в именовании %q#T"
  
  #: cp/parser.c:27225
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#T was previously declared here"
-msgstr "это предыдущее определение `%#D'"
+msgstr "%q#T был ранее декларирован здесь"
  
  #: cp/parser.c:27244
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD redeclared with different access"
-msgstr "%J%qD повторно декларирован как символ другого вида"
+msgstr "%qD редекларирован с другим доступом"
  
  #: cp/parser.c:27265
  #, fuzzy, gcc-internal-format
+#| msgid "%<template%> (as a disambiguator) is only allowed within templates"
  msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates"
  msgstr "слово %<template%> (для снятия неоднозначности) допускается только внутри шаблонов"
  
@@ -45395,13 +47239,14 @@ msgstr "неверное положение %<@%D%> конструкции Objec
  
  #: cp/parser.c:27804
  #, fuzzy, gcc-internal-format
+#| msgid "objective-c++ message argument(s) are expected"
  msgid "objective-c++ message receiver expected"
-msgstr "ожидались спецификаторы декларации"
+msgstr "ожидались objective-c++ аргумент(ы) сообщения"
  
  #: cp/parser.c:27874
  #, gcc-internal-format
  msgid "objective-c++ message argument(s) are expected"
-msgstr ""
+msgstr "ожидались objective-c++ аргумент(ы) сообщения"
  
  #: cp/parser.c:27904
  #, gcc-internal-format
@@ -45411,52 +47256,53 @@ msgstr "в конструкции %<@encode%> в качестве аргумен
  #: cp/parser.c:28310
  #, gcc-internal-format
  msgid "invalid Objective-C++ selector name"
-msgstr ""
+msgstr "некорректное Objective-C++ имя селектора"
  
  #: cp/parser.c:28385 cp/parser.c:28403
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "objective-c++ method declaration is expected"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¸Ñ\81Ñ\8c Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ñ\8b Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c objective-c++ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð¼ÐµÑ\82Ð¾Ð´Ð°"
  
  #: cp/parser.c:28397 cp/parser.c:28462
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "method attributes must be specified at the end"
-msgstr "%Jатрибут section недопустим для локальных переменных"
+msgstr "атрибуты метода должны задаваться в конце"
  
  #: cp/parser.c:28505
  #, gcc-internal-format
  msgid "stray %qs between Objective-C++ methods"
-msgstr ""
+msgstr "случайное %qs между Objective-C++ методами"
  
  #: cp/parser.c:28711 cp/parser.c:28718 cp/parser.c:28725
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid type for instance variable"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾ Ð·Ð°Ð´Ð°Ð½ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° %qE"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f instance Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹"
  
  #: cp/parser.c:28838
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "identifier expected after %<@protocol%>"
-msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ %<@protocol%>"
  
  #: cp/parser.c:29009
  #, gcc-internal-format
  msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword"
-msgstr ""
+msgstr "атрибуты нельзя задавать до %<@%D%> Objective-C++ ключевого слова"
  
  #: cp/parser.c:29016
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "prefix attributes are ignored before %<@%D%>"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qE Ð´Ð»Ñ\8f %qE Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
+msgstr "Ð¿Ñ\80ÐµÑ\84Ð¸ÐºÑ\81Ð½Ñ\8bÐµ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f Ð´Ð¾ %<@%D%>"
  
  #: cp/parser.c:29289 cp/parser.c:29296 cp/parser.c:29303
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid type for property"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f property"
  
  #: cp/parser.c:30443
  #, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "%<wait%> expression must be integral"
-msgstr "%qD не является элементом типа %qT"
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/parser.c:31137
  #, fuzzy, gcc-internal-format
@@ -45467,12 +47313,13 @@ msgstr "неверный инициализатор"
  #: cp/parser.c:33335
  #, gcc-internal-format
  msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
-msgstr ""
+msgstr "скобочная инициализация не допускается в OpenMP %<for%> цикле"
  
  #: cp/parser.c:33338
  #, fuzzy, gcc-internal-format
+#| msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop"
  msgid "parenthesized initialization is not allowed in for-loop"
-msgstr "#pragma %s уже зарегистрирована"
+msgstr "скобочная инициализация не допускается в OpenMP %<for%> цикле"
  
  #: cp/parser.c:33408
  #, gcc-internal-format
@@ -45480,19 +47327,20 @@ msgid "%<_Cilk_for%> allows expression instead of declaration only in C, not in
  msgstr ""
  
  #: cp/parser.c:33636 cp/pt.c:14958
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "iteration variable %qD should not be reduction"
-msgstr "регистровая переменная %qs использована во вложенной функции"
+msgstr "итерационная переменная %qD не должна быть reduction"
  
  #: cp/parser.c:33721
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "not enough collapsed for loops"
-msgstr "Ð½ÐµÐ´Ð¾Ñ\81Ñ\82Ð°Ñ\82Ð¾Ñ\87Ð½Ð°Ñ\8f Ð¸Ð½Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\86Ð¸Ñ\8f Ð¾ Ñ\82Ð¸Ð¿Ðµ"
+msgstr "Ð½ÐµÐ´Ð¾Ñ\81Ñ\82Ð°Ñ\82Ð¾Ñ\87Ð½Ð¾ Ñ\81Ð¶Ð°Ñ\82Ð¾ Ð´Ð»Ñ\8f Ñ\86Ð¸ÐºÐ»Ð¾Ð²"
  
  #: cp/parser.c:34003
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma omp barrier%> may only be used in compound statements"
  msgid "%<#pragma omp ordered%> with %<depend%> clause may only be used in compound statements"
-msgstr ""
+msgstr "%<#pragma omp barrier%> может использоваться только в составных операторах"
  
  #: cp/parser.c:34795
  #, gcc-internal-format
@@ -45518,8 +47366,9 @@ msgstr "неверный инициализатор"
  
  #: cp/parser.c:35990
  #, fuzzy, gcc-internal-format
+#| msgid "expected id-expression"
  msgid "expected id-expression (arguments)"
-msgstr "ожидалось выражение"
+msgstr "ожидалось id-выражение"
  
  #: cp/parser.c:36002
  #, gcc-internal-format
@@ -45528,8 +47377,9 @@ msgstr ""
  
  #: cp/parser.c:36083
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%>"
  msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%> or identifier"
-msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%>"
+msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%>"
  
  #: cp/parser.c:36102
  #, fuzzy, gcc-internal-format
@@ -45548,9 +47398,10 @@ msgid "function or array type %qT in %<#pragma omp declare reduction%>"
  msgstr ""
  
  #: cp/parser.c:36132 cp/pt.c:11838 cp/semantics.c:5372
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "expected %<#pragma omp%> clause before %<decltype%>"
  msgid "reference type %qT in %<#pragma omp declare reduction%>"
-msgstr ""
+msgstr "ожидалась конструкция %<#pragma omp%> перед %<decltype%>"
  
  #: cp/parser.c:36135 cp/semantics.c:5378
  #, gcc-internal-format
@@ -45569,8 +47420,9 @@ msgstr ""
  
  #: cp/parser.c:36535
  #, fuzzy, gcc-internal-format
+#| msgid "%<#pragma GCC option%> is not a string"
  msgid "%<#pragma acc routine%> does not refer to a function"
-msgstr "некорректно употреблять %<#pragma%>"
+msgstr "%<#pragma GCC option%> не является строковым литералом"
  
  #. cancel-and-throw is unimplemented.
  #: cp/parser.c:36873
@@ -45581,17 +47433,17 @@ msgstr ""
  #: cp/parser.c:36916 cp/semantics.c:8579
  #, gcc-internal-format
  msgid "%<__transaction_relaxed%> without transactional memory support enabled"
-msgstr ""
+msgstr "%<__transaction_relaxed%> без включения поддержки транзакционной памяти"
  
  #: cp/parser.c:36918 cp/semantics.c:8581
  #, gcc-internal-format
  msgid "%<__transaction_atomic%> without transactional memory support enabled"
-msgstr ""
+msgstr "%<__transaction_atomic%> без включения поддержки транзакционной памяти"
  
  #: cp/parser.c:37114
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "junk at end of %<#pragma GCC pch_preprocess%>"
-msgstr "мусор в конце директивы %<#pragma pack%>"
+msgstr "мусор в конце директивы %<#pragma GCC pch_preprocess%>"
  
  #: cp/parser.c:37147
  #, fuzzy, gcc-internal-format
@@ -45601,18 +47453,21 @@ msgstr "некорректные ограничения для операнда"
  
  #: cp/parser.c:37356
  #, fuzzy, gcc-internal-format
+#| msgid "#pragma GCC optimize is not allowed inside functions"
  msgid "%<#pragma GCC ivdep%> must be inside a function"
-msgstr "фигурные скобки внутри выражений допускаются только в теле функции"
+msgstr "#pragma GCC optimize не допускается внутри функций"
  
  #: cp/parser.c:37377
  #, fuzzy, gcc-internal-format
+#| msgid "#pragma GCC optimize is not allowed inside functions"
  msgid "%<#pragma simd%> must be inside a function"
-msgstr "фигурные скобки внутри выражений допускаются только в теле функции"
+msgstr "#pragma GCC optimize не допускается внутри функций"
  
  #: cp/parser.c:37389
  #, fuzzy, gcc-internal-format
+#| msgid "#pragma GCC optimize is not allowed inside functions"
  msgid "%<#pragma cilk grainsize%> must be inside a function"
-msgstr "фигурные скобки внутри выражений допускаются только в теле функции"
+msgstr "#pragma GCC optimize не допускается внутри функций"
  
  #: cp/parser.c:37401
  #, gcc-internal-format
@@ -45620,25 +47475,27 @@ msgid "-fcilkplus must be enabled to use %<#pragma cilk grainsize%>"
  msgstr ""
  
  #: cp/parser.c:37458
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "inter-module optimizations not implemented for C++"
-msgstr "Ð¼ÐµÐ¶Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8cÐ½Ñ\8bÐµ Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð¿Ð¾ÐºÐ° Ð½Ðµ Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð¾Ð²Ð°Ð½Ñ\8b"
+msgstr "Ð¼ÐµÐ¶Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8cÐ½Ñ\8bÐµ Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð½Ðµ Ñ\80ÐµÐ°Ð»Ð¸Ð·Ð¾Ð²Ð°Ð½Ñ\8b Ð´Ð»Ñ\8f C++"
  
  #: cp/parser.c:37568
  #, fuzzy, gcc-internal-format
+#| msgid "Expected variable name at %C"
  msgid "expected variable-name"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f ÐºÐ»Ð°Ñ\81Ñ\81Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ Ð² %C"
  
  #: cp/parser.c:37632
  #, fuzzy, gcc-internal-format
-#| msgid "expected %<,%> or %<)%>"
+#| msgid "expected %<,%> or %<)%> before %qE"
  msgid "expected %<,%> or %<)%> after %qE"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<,%> Ð¸Ð»Ð¸ %<)%>"
+msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<,%> Ð¸Ð»Ð¸ %<)%> Ð¿ÐµÑ\80ÐµÐ´ %qE"
  
  #: cp/parser.c:38025
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "templates may not be %<virtual%>"
  msgid "implicit templates may not be %<virtual%>"
-msgstr ""
+msgstr "шаблоны не могут быть %<virtual%>"
  
  #: cp/pt.c:295
  #, gcc-internal-format
@@ -45661,9 +47518,9 @@ msgid "enclosing class templates are not explicitly specialized"
  msgstr "объемлющие шаблоны классов не были явно специализированы"
  
  #: cp/pt.c:786
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "specialization of %qD must appear at namespace scope"
-msgstr "Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %qD Ð² Ð´Ñ\80Ñ\83Ð³Ð¾Ð¹ namespace-Ð¾Ð±Ð»Ð°Ñ\81Ñ\82Ð¸"
+msgstr "Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %qD Ð´Ð¾Ð»Ð¶Ð½Ð° Ð¿Ð¾Ñ\8fÐ²Ð»Ñ\8fÑ\82Ñ\8cÑ\81Ñ\8f Ð² Ð¿Ñ\80ÐµÐ´ÐµÐ»Ð°Ñ\85 Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ð° Ð¸Ð¼ÐµÐ½"
  
  #: cp/pt.c:795
  #, gcc-internal-format
@@ -45672,23 +47529,25 @@ msgstr "специализация %qD в другой namespace-области"
  
  #: cp/pt.c:797 cp/pt.c:1024
  #, fuzzy, gcc-internal-format
+#| msgid "  from definition of %q+#D"
  msgid "  from definition of %q#D"
-msgstr "%Jпереопрелеление %qD"
+msgstr "  из определения %q+#D"
  
  #: cp/pt.c:814
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "explicit instantiation of %qD in namespace %qD (which does not enclose namespace %qD)"
-msgstr "декларация %qD в %qD, который не объемлет %qD"
+msgstr "явная конкретизация %qD в пространстве имен %qD (которое не включает пространство имен %qD)"
  
  #: cp/pt.c:935
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "name of class shadows template template parameter %qD"
-msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° `%#D'"
+msgstr "Ð¸Ð¼Ñ\8f ÐºÐ»Ð°Ñ\81Ñ\81Ð° Ð·Ð°Ñ\82ÐµÐ½Ñ\8fÐµÑ\82 Ñ\88Ð°Ð±Ð»Ð¾Ð½ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD"
  
  #: cp/pt.c:946
  #, fuzzy, gcc-internal-format
+#| msgid "partial specialization of alias template %qD"
  msgid "specialization of alias template %qD"
-msgstr "Ñ\8fÐ²Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð½Ðµ-Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qT"
+msgstr "Ñ\87Ð°Ñ\81Ñ\82Ð¸Ñ\87Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð°Ð»Ð¸Ð°Ñ\81Ð½Ð¾Ð³Ð¾ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD"
  
  #: cp/pt.c:949 cp/pt.c:1086
  #, gcc-internal-format
@@ -45713,24 +47572,26 @@ msgid "specialization %qT after instantiation %qT"
  msgstr "специализация %qT после конкретизации %qT"
  
  #: cp/pt.c:1082
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template specialization of %qD not allowed by ISO C++"
-msgstr "специализация шаблона с привязкой C"
+msgstr "специализация шаблона %qD не допускается ISO C++"
  
  #: cp/pt.c:1544
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "specialization of %qD after instantiation"
-msgstr "Ñ\8fÐ²Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %D Ð¿Ð¾Ñ\81Ð»Ðµ Ð¿ÐµÑ\80Ð²Ð¾Ð³Ð¾ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f"
+msgstr "Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %qD Ð¿Ð¾Ñ\81Ð»Ðµ ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð¸Ð·Ð°Ñ\86Ð¸Ð¸"
  
  #: cp/pt.c:1943
  #, fuzzy, gcc-internal-format
+#| msgid "candidate is: %+#D"
  msgid "candidate is: %#D"
  msgstr "претендент: %+#D"
  
  #: cp/pt.c:1950 cp/semantics.c:5226
  #, fuzzy, gcc-internal-format
+#| msgid "%s %+#D"
  msgid "%s %#D"
-msgstr "%s %+#T"
+msgstr "%s %+#D"
  
  #: cp/pt.c:2091
  #, gcc-internal-format
@@ -45739,18 +47600,19 @@ msgstr "%qD не является шаблоном функции"
  
  #: cp/pt.c:2096
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not a variable"
  msgid "%qD is not a variable template"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "%qD не переменная"
  
  #: cp/pt.c:2350
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template-id %qD for %q+D does not match any template declaration"
-msgstr "Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½ ÐºÐ°Ðº Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\82Ð¾Ñ\80"
+msgstr "Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD Ð´Ð»Ñ\8f %q+D Ð½Ðµ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð½Ð¸ÐºÐ°ÐºÐ¾Ð¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
  
  #: cp/pt.c:2353
  #, gcc-internal-format
  msgid "saw %d %<template<>%>, need %d for specializing a member function template"
-msgstr ""
+msgstr "разбор %d %<template<>%>, требуется %d для специализации шаблона элемента-функции"
  
  #: cp/pt.c:2364
  #, gcc-internal-format
@@ -45759,11 +47621,13 @@ msgstr "неоднозначная конкретизация шаблона %qD
  
  #: cp/pt.c:2574
  #, fuzzy, gcc-internal-format
+#| msgid "variadic templates only available with -std=c++11 or -std=gnu++11"
  msgid "variable templates only available with -std=c++14 or -std=gnu++14"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qs Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+msgstr "Ð²Ð°Ñ\80Ð¸Ð°Ð½Ñ\82Ð½Ñ\8bÐµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ñ\8b Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ñ\8b Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ñ\81 -std=c++11 Ð¸Ð»Ð¸ -std=gnu++11"
  
  #: cp/pt.c:2583
  #, fuzzy, gcc-internal-format
+#| msgid "wrong number of template arguments (%d, should be %d)"
  msgid "too many template headers for %D (should be %d)"
  msgstr "неправильное число аргументов шаблона (%d, а должно быть %d)"
  
@@ -45777,32 +47641,32 @@ msgstr ""
  #: cp/pt.c:2677 cp/pt.c:2736
  #, gcc-internal-format
  msgid "template-id %qD in declaration of primary template"
-msgstr ""
+msgstr "template-id %qD в декларации первичного шаблона"
  
  #: cp/pt.c:2690
  #, gcc-internal-format
  msgid "template parameter list used in explicit instantiation"
-msgstr ""
+msgstr "список параметров шаблона использован в явной конкретизации"
  
  #: cp/pt.c:2696
  #, gcc-internal-format
  msgid "definition provided for explicit instantiation"
-msgstr ""
+msgstr "определение представленное для явной конкретизации"
  
  #: cp/pt.c:2704
  #, gcc-internal-format
  msgid "too many template parameter lists in declaration of %qD"
-msgstr ""
+msgstr "слишком много списков параметров шаблона в декларации %qD"
  
  #: cp/pt.c:2707
  #, gcc-internal-format
  msgid "too few template parameter lists in declaration of %qD"
-msgstr ""
+msgstr "слишком мало списков параметров шаблона в декларации %qD"
  
  #: cp/pt.c:2709
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "explicit specialization of %qD must be introduced by %<template <>%>"
-msgstr "перед явной специализацией должно быть 'template <>'"
+msgstr "перед явной специализацией %qD должно быть %<template <>%>"
  
  #: cp/pt.c:2715
  #, fuzzy, gcc-internal-format
@@ -45812,18 +47676,20 @@ msgstr "явная специализация не-шаблона %qT"
  
  #: cp/pt.c:2746
  #, fuzzy, gcc-internal-format
+#| msgid "function template partial specialization %qD is not allowed"
  msgid "non-type partial specialization %qD is not allowed"
-msgstr "Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ñ\81 Ð¿Ñ\80Ð¸Ð²Ñ\8fÐ·ÐºÐ¾Ð¹ C"
+msgstr "Ñ\87Ð°Ñ\81Ñ\82Ð¸Ñ\87Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qD Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f"
  
  #: cp/pt.c:2749
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "function template partial specialization %qD is not allowed"
  msgid "non-class, non-variable partial specialization %qD is not allowed"
-msgstr ""
+msgstr "частичная специализация шаблона функции %qD не допускается"
  
  #: cp/pt.c:2782
  #, gcc-internal-format
  msgid "default argument specified in explicit specialization"
-msgstr ""
+msgstr "задан подразумеваемый аргумент в явной специализации"
  
  #: cp/pt.c:2813
  #, gcc-internal-format
@@ -45841,12 +47707,12 @@ msgstr "%qD не является функцией шаблоном"
  #: cp/pt.c:2878
  #, gcc-internal-format
  msgid "specialization of implicitly-declared special member function"
-msgstr ""
+msgstr "специализация неявно декларированного специального элемента-функции"
  
  #: cp/pt.c:2922
  #, gcc-internal-format
  msgid "no member function %qD declared in %qT"
-msgstr ""
+msgstr "никакая элемент-функция %qD не декларирована в %qT"
  
  #: cp/pt.c:2954
  #, gcc-internal-format
@@ -45862,32 +47728,32 @@ msgstr "явная специализация не-шаблона %qT"
  #: cp/pt.c:3654
  #, gcc-internal-format
  msgid "base initializer expansion %<%T%> contains no parameter packs"
-msgstr ""
+msgstr "расширение базового инициализатора %<%T%> не содержит packs параметров"
  
  #: cp/pt.c:3718
  #, gcc-internal-format
  msgid "expansion pattern %<%T%> contains no argument packs"
-msgstr ""
+msgstr "образец расширения %<%T%> не содержит packs аргументов"
  
  #: cp/pt.c:3720
  #, gcc-internal-format
  msgid "expansion pattern %<%E%> contains no argument packs"
-msgstr ""
+msgstr "образец расширения %<%E%> не содержит packs аргументов"
  
  #: cp/pt.c:3764
  #, gcc-internal-format
  msgid "parameter packs not expanded with %<...%>:"
-msgstr ""
+msgstr "packs параметров не расширены с %<...%>:"
  
  #: cp/pt.c:3779 cp/pt.c:4513
  #, gcc-internal-format
  msgid "        %qD"
-msgstr ""
+msgstr "        %qD"
  
  #: cp/pt.c:3781
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "        <anonymous>"
-msgstr "<anonymous>"
+msgstr "        <anonymous>"
  
  #: cp/pt.c:3905
  #, fuzzy, gcc-internal-format
@@ -45903,34 +47769,39 @@ msgstr "декларация %q+D перекрывает параметр"
  
  #: cp/pt.c:3910
  #, fuzzy, gcc-internal-format
+#| msgid "template parameter type %qT declared %<friend%>"
  msgid "template parameter %qD declared here"
-msgstr "параметр шаблона тип %qT объявлен `friend'"
+msgstr "тип параметра шаблона %qT декларирован %<friend%>"
  
  #: cp/pt.c:4449
  #, fuzzy, gcc-internal-format
+#| msgid "partial specialization of alias template %qD"
  msgid "specialization of variable concept %q#D"
-msgstr "Ñ\8fÐ²Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð½Ðµ-Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qT"
+msgstr "Ñ\87Ð°Ñ\81Ñ\82Ð¸Ñ\87Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð°Ð»Ð¸Ð°Ñ\81Ð½Ð¾Ð³Ð¾ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD"
  
  #: cp/pt.c:4508
  #, fuzzy, gcc-internal-format
+#| msgid "template parameters not used in partial specialization:"
  msgid "template parameters not deducible in partial specialization:"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ friend-Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD"
+msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ñ\8b Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f Ð² Ñ\87Ð°Ñ\81Ñ\82Ð¸Ñ\87Ð½Ð¾Ð¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸:"
  
  #: cp/pt.c:4532
  #, fuzzy, gcc-internal-format
-#| msgid "partial specialization %qT declared %<friend%>"
+#| msgid "partial specialization %qT does not specialize any template arguments"
  msgid "partial specialization %q+D does not specialize any template arguments"
-msgstr "Ñ\87Ð°Ñ\81Ñ\82Ð¸Ñ\87Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %qT Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»ÐµÐ½Ð° %<friend%>"
+msgstr "Ñ\87Ð°Ñ\81Ñ\82Ð¸Ñ\87Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %qT Ð½Ðµ Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ñ\83ÐµÑ\82 Ð½Ð¸ÐºÐ°ÐºÐ¸Ðµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
  
  #: cp/pt.c:4535
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "partial specialization %qT does not specialize any template arguments"
  msgid "partial specialization %q+D does not specialize any template arguments and is not more constrained than"
-msgstr ""
+msgstr "частичная специализация %qT не специализирует никакие аргументы шаблона"
  
  #: cp/pt.c:4537 cp/pt.c:4548
  #, fuzzy, gcc-internal-format
+#| msgid "previously declared here"
  msgid "primary template here"
-msgstr "это предыдущее определение `%#D'"
+msgstr "предыдущая декларация здесь"
  
  #: cp/pt.c:4545
  #, gcc-internal-format
@@ -45940,89 +47811,93 @@ msgstr ""
  #: cp/pt.c:4595
  #, gcc-internal-format
  msgid "parameter pack argument %qE must be at the end of the template argument list"
-msgstr ""
+msgstr "parameter pack аргумент %qE должен быть в конце списка аргументов шаблона"
  
  #: cp/pt.c:4598
  #, gcc-internal-format
  msgid "parameter pack argument %qT must be at the end of the template argument list"
-msgstr ""
+msgstr "parameter pack аргумент %qT должен быть в конце списка аргументов шаблона"
  
  #: cp/pt.c:4619
  #, gcc-internal-format
  msgid "template argument %qE involves template parameter(s)"
-msgstr ""
+msgstr "аргумент шаблона %qE включает параметр(ы) шаблона"
  
  #: cp/pt.c:4665
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type %qT of template argument %qE depends on a template parameter"
  msgid_plural "type %qT of template argument %qE depends on template parameters"
-msgstr[0] "несоответствия типа/значения в аргументе %d в списке параметров шаблона для %qD"
-msgstr[1] "несоответствия типа/значения в аргументе %d в списке параметров шаблона для %qD"
-msgstr[2] ""
+msgstr[0] "тип %qT аргумента шаблона %qE зависит от параметра шаблона"
+msgstr[1] "тип %qT аргумента шаблона %qE зависит от параметров шаблона"
+msgstr[2] "тип %qT аргумента шаблона %qE зависит от параметров шаблона"
  
  #: cp/pt.c:4718
  #, fuzzy, gcc-internal-format
+#| msgid "ambiguous class template instantiation for %q#T"
  msgid "declaration of %qD ambiguates earlier template instantiation for %qD"
  msgstr "неоднозначная конкретизация шаблона класса для %q#T"
  
  #: cp/pt.c:4722
  #, fuzzy, gcc-internal-format
+#| msgid "partial specialization of %qT after instantiation of %qT"
  msgid "partial specialization of %qD after instantiation of %qD"
-msgstr "специализация %qT после конкретизации %qT"
+msgstr "Ñ\87Ð°Ñ\81Ñ\82Ð¸Ñ\87Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %qT Ð¿Ð¾Ñ\81Ð»Ðµ ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ %qT"
  
  #: cp/pt.c:4898
  #, gcc-internal-format
  msgid "no default argument for %qD"
-msgstr ""
+msgstr "нет подразумеваемого аргумента для %qD"
  
  #. A primary class template can only have one
  #. parameter pack, at the end of the template
  #. parameter list.
  #: cp/pt.c:4920
  #, fuzzy, gcc-internal-format
+#| msgid "parameter pack %qE must be at the end of the template parameter list"
  msgid "parameter pack %q+D must be at the end of the template parameter list"
-msgstr "%Jв списке параметров пропущено имя параметра"
+msgstr "parameter pack %qE должен быть в конце списка параметров шаблона"
  
  #: cp/pt.c:4956
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "default template arguments may not be used in function template friend re-declaration"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ friend-Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð½Ðµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ð² Ñ\80ÐµÐ´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ friend Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
  
  #: cp/pt.c:4959
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "default template arguments may not be used in function template friend declarations"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ friend-Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð½Ðµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ friend Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
  
  #: cp/pt.c:4962
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "default template arguments may not be used in function templates without -std=c++11 or -std=gnu++11"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ friend-Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð½Ðµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ð² Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°Ñ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹ Ð±ÐµÐ· -std=c++11 Ð¸Ð»Ð¸ -std=gnu++11"
  
  #: cp/pt.c:4965
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "default template arguments may not be used in partial specializations"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ friend-Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð½Ðµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ð² Ñ\87Ð°Ñ\81Ñ\82Ð¸Ñ\87Ð½Ñ\8bÑ\85 Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8fÑ\85"
  
  #: cp/pt.c:4968 cp/pt.c:5026
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "default argument for template parameter for class enclosing %qD"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° Ñ\82Ð¸Ð¿Ð° %qT Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %qT"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð´Ð»Ñ\8f ÐºÐ»Ð°Ñ\81Ñ\81Ð° Ð²ÐºÐ»Ñ\8eÑ\87Ð°Ñ\8eÑ\89ÐµÐ³Ð¾ %qD"
  
  #: cp/pt.c:5122
  #, fuzzy, gcc-internal-format
  #| msgid "parameter %qD declared void"
  msgid "template %qD declared"
-msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %qD Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»Ðµн void"
+msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %qD Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°н void"
  
  #: cp/pt.c:5129
  #, gcc-internal-format
  msgid "template class without a name"
-msgstr ""
+msgstr "шаблон класса без имени"
  
  #: cp/pt.c:5137
  #, fuzzy, gcc-internal-format
+#| msgid "non-member function %qD cannot have cv-qualifier"
  msgid "member template %qD may not have virt-specifiers"
-msgstr "%sэлемент, функция %qD, не может иметь квалификатор метода - %qT"
+msgstr "не-элемент-функция %qD не может иметь cv-квалификатор"
  
  #. [basic.stc.dynamic.allocation]
  #.
@@ -46035,24 +47910,24 @@ msgid "invalid template declaration of %qD"
  msgstr "некорректная template-декларация %qD"
  
  #: cp/pt.c:5288
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template definition of non-template %q#D"
-msgstr "определение шаблона для не-шаблона `%#D'"
+msgstr "определение шаблона для не-шаблона %q#D"
  
  #: cp/pt.c:5331
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expected %d levels of template parms for %q#D, got %d"
-msgstr "ожидалось %d уровней параметров шаблона для `%#D', обнаружено %d"
+msgstr "ожидалось %d уровней параметров шаблона для %q#D, дано %d"
  
  #: cp/pt.c:5345
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "got %d template parameters for %q#D"
-msgstr "Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶ÐµÐ½Ð¾ %d Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð¾Ð² Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð´Ð»Ñ\8f `%#D'"
+msgstr "Ð´Ð°Ð½Ð¾ %d Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð¾Ð² Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð´Ð»Ñ\8f %q#D"
  
  #: cp/pt.c:5348
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "got %d template parameters for %q#T"
-msgstr "Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶Ðµно %d параметров шаблона для %q#T"
+msgstr "Ð´Ð°но %d параметров шаблона для %q#T"
  
  #: cp/pt.c:5350
  #, gcc-internal-format, gfc-internal-format
@@ -46060,14 +47935,14 @@ msgid "  but %d required"
  msgstr "  вместо требуемых %d"
  
  #: cp/pt.c:5371
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template arguments to %qD do not match original template %qD"
-msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ñ\8b Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð½Ðµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð±Ñ\8bÑ\82Ñ\8c friend"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð´Ð»Ñ\8f %qD Ð½Ðµ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\82 Ð¿ÐµÑ\80Ð²Ð¾Ð½Ð°Ñ\87Ð°Ð»Ñ\8cÐ½Ð¾Ð¼Ñ\83 Ñ\88Ð°Ð±Ð»Ð¾Ð½Ñ\83 %qD"
  
  #: cp/pt.c:5375
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use template<> for an explicit specialization"
-msgstr "Ð¾Ð±Ñ\8aÐµÐ¼Ð»Ñ\8eÑ\89Ð¸Ðµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ñ\8b ÐºÐ»Ð°Ñ\81Ñ\81Ð¾Ð² Ð½Ðµ Ð±Ñ\8bÐ»Ð¸ Ñ\8fÐ²Ð½Ð¾ Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ñ\8b"
+msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ template<> Ð´Ð»Ñ\8f Ñ\8fÐ²Ð½Ð¾Ð¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸"
  
  #: cp/pt.c:5513
  #, gcc-internal-format
@@ -46075,252 +47950,262 @@ msgid "%qT is not a template type"
  msgstr "%qT не является шаблонным типом"
  
  #: cp/pt.c:5526
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template specifiers not specified in declaration of %qD"
-msgstr "в декларации %qs по умолчанию установлен тип `int'"
+msgstr "спецификаторы шаблона не заданы в декларации %qD"
  
  #: cp/pt.c:5537
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "redeclared with %d template parameter"
  msgid_plural "redeclared with %d template parameters"
-msgstr[0] "использование %qD без параметров шаблона"
-msgstr[1] "использование %qD без параметров шаблона"
-msgstr[2] ""
+msgstr[0] "редекларировано с %d параметром шаблона"
+msgstr[1] "редекларировано с %d параметрами шаблона"
+msgstr[2] "редекларировано с %d параметрами шаблона"
  
  #: cp/pt.c:5541
  #, fuzzy, gcc-internal-format
+#| msgid "previous declaration %q+D used %d template parameter"
+#| msgid_plural "previous declaration %q+D used %d template parameters"
  msgid "previous declaration %qD used %d template parameter"
  msgid_plural "previous declaration %qD used %d template parameters"
-msgstr[0] "Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ `%#D', ÐºÐ¾Ñ\82Ð¾Ñ\80Ð°Ñ\8f Ð½Ð°Ñ\85Ð¾Ð´Ð¸Ñ\82Ñ\81Ñ\8f Ð·Ð´ÐµÑ\81Ñ\8c"
-msgstr[1] "Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ `%#D', ÐºÐ¾Ñ\82Ð¾Ñ\80Ð°Ñ\8f Ð½Ð°Ñ\85Ð¾Ð´Ð¸Ñ\82Ñ\81Ñ\8f Ð·Ð´ÐµÑ\81Ñ\8c"
-msgstr[2] ""
+msgstr[0] "Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q+D Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð»Ð° %d Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
+msgstr[1] "Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q+D Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð»Ð° %d Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð¾Ð² Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
+msgstr[2] "предыдущая декларация %q+D использовала %d параметров шаблона"
  
  #: cp/pt.c:5578
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template parameter %q+#D"
-msgstr "параметр шаблона `%#D'"
+msgstr "параметр шаблона %q+#D"
  
  #: cp/pt.c:5579
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "redeclared here as %q#D"
-msgstr "повторно объявлен здесь как `%#D'"
+msgstr "редекларирован здесь как %q#D"
  
  #. We have in [temp.param]:
  #.
  #. A template-parameter may not be given default arguments
  #. by two different declarations in the same scope.
  #: cp/pt.c:5589
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "redefinition of default argument for %q#D"
-msgstr "повторное определение аргумента по умолчанию для `%#D'"
+msgstr "редекларация аргумента по умолчанию для %q#D"
  
  #: cp/pt.c:5591
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "original definition appeared here"
-msgstr "%J  исходное определение находится здесь"
+msgstr "исходное определение находится здесь"
  
  #: cp/pt.c:5616
  #, fuzzy, gcc-internal-format
+#| msgid "redeclaration %qD differs in %<constexpr%>"
  msgid "redeclaration %q#D with different constraints"
-msgstr "повторная декларация %qT как не-шаблона"
+msgstr "редекларация %qD отличается в %<constexpr%>"
  
  #: cp/pt.c:5619
  #, fuzzy, gcc-internal-format
+#| msgid "original definition appeared here"
  msgid "original declaration appeared here"
-msgstr "%J  исходное определение находится здесь"
+msgstr "исходное определение находится здесь"
  
  #: cp/pt.c:5872 cp/pt.c:5923
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a valid template argument for type %qT"
-msgstr "%qE не является корректным аргументом шаблона"
+msgstr "%E не является корректным аргументом шаблона для типа %qT"
  
  #: cp/pt.c:5875
  #, gcc-internal-format
  msgid "it must be the address of a function with external linkage"
-msgstr ""
+msgstr "это должно быть адресом функции с внешней привязкой"
  
  #: cp/pt.c:5878
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "it must be the address of a function with external linkage"
  msgid "it must be the name of a function with external linkage"
-msgstr ""
+msgstr "это должно быть адресом функции с внешней привязкой"
  
  #: cp/pt.c:5890
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a valid template argument for type %qT because %qD has no linkage"
-msgstr "строковый литерал %E  не является корректным аргументом шаблона, потому что это адрес статического объекта"
+msgstr "%E не является корректным аргументом шаблона для типа %qT поскольку %qD не имеет привязки"
  
  #: cp/pt.c:5894
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a valid template argument for type %qT because %qD does not have external linkage"
-msgstr "строковый литерал %E  не является корректным аргументом шаблона, потому что это адрес статического объекта"
+msgstr "%E не является корректным аргументом шаблона для типа %qT поскольку %qD не имеет внешней привязки"
  
  #: cp/pt.c:5925
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "it must be a pointer-to-member of the form %<&X::Y%>"
-msgstr "(указатель на элемент можно получить только при помощи %<&%E%>)"
+msgstr "это должно быть указателем на элемент вида %<&X::Y%>"
  
  #: cp/pt.c:5976
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  couldn't deduce template parameter %qD"
-msgstr "обнаружено %d параметров шаблона для `%#D'"
+msgstr "  невозможно вывести параметр шаблона %qD"
  
  #: cp/pt.c:5991
  #, gcc-internal-format
  msgid "  types %qT and %qT have incompatible cv-qualifiers"
-msgstr ""
+msgstr "  типы %qT и %qT имеют несовместимые cv-qualifiers"
  
  #: cp/pt.c:6000
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  mismatched types %qT and %qT"
-msgstr "сравнение между типами `%#T' и `%#T'"
+msgstr "  несоответствие типов %qT и %qT"
  
  #: cp/pt.c:6009
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  template parameter %qD is not a parameter pack, but argument %qD is"
-msgstr "%qD не может иметь аргументов по умолчанию"
+msgstr "  параметр шаблона %qD не есть parameter pack, но аргумент %qD таковым является"
  
  #: cp/pt.c:6020
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  template argument %qE does not match pointer-to-member constant %qE"
-msgstr "параметры шаблона не могут быть friend"
+msgstr "  аргумент шаблона %qE не соответствует указателю на элемент константе %qE"
  
  #: cp/pt.c:6030
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  %qE is not equivalent to %qE"
-msgstr "%qs не является корректным выходным файлом"
+msgstr "  %qE не эквивалентно %qE"
  
  #: cp/pt.c:6039
  #, gcc-internal-format
  msgid "  inconsistent parameter pack deduction with %qT and %qT"
-msgstr ""
+msgstr "  противоречивый вывод parameter pack с %qT и %qT"
  
  #: cp/pt.c:6051
  #, gcc-internal-format
  msgid "  deduced conflicting types for parameter %qT (%qT and %qT)"
-msgstr ""
+msgstr "  выведены конфликтующие типы для параметра %qT (%qT и %qT)"
  
  #: cp/pt.c:6055
  #, gcc-internal-format
  msgid "  deduced conflicting values for non-type parameter %qE (%qE and %qE)"
-msgstr ""
+msgstr "  выведены конфликтующие значения для нетипового параметра %qE (%qE и %qE)"
  
  #: cp/pt.c:6066
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  variable-sized array type %qT is not a valid template argument"
-msgstr "%qE не является корректным аргументом шаблона"
+msgstr "  тип массива переменного размера %qT не есть корректный аргумент шаблона"
  
  #: cp/pt.c:6077
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  member function type %qT is not a valid template argument"
-msgstr "%qE не является корректным аргументом шаблона"
+msgstr "  тип элемента-функции %qT не есть корректный аргумент шаблона"
  
  #: cp/pt.c:6089
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "  candidate expects %d argument, %d provided"
+#| msgid_plural "  candidate expects %d arguments, %d provided"
  msgid "  candidate expects at least %d argument, %d provided"
  msgid_plural "  candidate expects at least %d arguments, %d provided"
-msgstr[0] ""
-msgstr[1] ""
-msgstr[2] ""
+msgstr[0] "  кандидат ожидает %d аргумент, %d предоставлено"
+msgstr[1] "  кандидат ожидает %d аргумента, %d предоставлено"
+msgstr[2] "  кандидат ожидает %d аргументов, %d предоставлено"
  
  #: cp/pt.c:6120
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  cannot convert %qE (type %qT) to type %qT"
-msgstr "некорректное преобразование от типа %qT к типу %qT"
+msgstr "  невозможно преобразовать %qE (типа %qT) к типу %qT"
  
  #: cp/pt.c:6133
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  %qT is an ambiguous base class of %qT"
-msgstr "%qT является неоднозначной базой %qT"
+msgstr "  %qT является неоднозначным базовым классом %qT"
  
  #: cp/pt.c:6137
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  %qT is not derived from %qT"
-msgstr "тип %qT не является производным от %qT"
+msgstr "  %qT не является производным от %qT"
  
  #: cp/pt.c:6148
  #, gcc-internal-format
  msgid "  template parameters of a template template argument are inconsistent with other deduced template arguments"
-msgstr ""
+msgstr "  параметры шаблона для шаблона аргумента шаблона несовместимы с другими выведенными аргументами шаблона"
  
  #: cp/pt.c:6158
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  can't deduce a template for %qT from non-template type %qT"
-msgstr "нельзя %s указатель на неполный тип %qT"
+msgstr "  невозможно вывести шаблон для %qT из нешаблонного типа %qT"
  
  #: cp/pt.c:6168
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  template argument %qE does not match %qD"
-msgstr "параметры шаблона не могут быть friend"
+msgstr "  аргумент шаблона %qE не соответствует %qD"
  
  #: cp/pt.c:6177
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  could not resolve address from overloaded function %qE"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "  невозможно разрешить адрес из перегруженной функции %qE"
  
  #: cp/pt.c:6216
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a valid template argument for type %qT because string literals can never be used in this context"
-msgstr "строковый литерал %E  не является корректным аргументом шаблона, потому что это адрес статического объекта"
+msgstr "%qE не есть корректный аргумент шаблона для типа %qT поскольку строковые литералы не могут быть использованы в этом контексте"
  
  #: cp/pt.c:6379
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "in template argument for type %qT "
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f `%#D' Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %qT"
+msgstr "Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð´Ð»Ñ\8f Ñ\82Ð¸Ð¿Ð° %qT "
  
  #: cp/pt.c:6426
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
-msgstr "%qE не является корректным аргументом шаблона"
+msgstr "%qD не есть корректный аргумент шаблона поскольку %qD переменная, а не адрес переменной"
  
  #: cp/pt.c:6434
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not a valid template argument because %qD is a variable, not the address of a variable"
  msgid "%qE is not a valid template argument for %qT because it is not the address of a variable"
-msgstr "%qE не является корректным аргументом шаблона"
+msgstr "%qD не есть корректный аргумент шаблона поскольку %qD переменная, а не адрес переменной"
  
  #: cp/pt.c:6452
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a valid template argument of type %qT because %qE is not a variable"
-msgstr "%qE не является корректным аргументом шаблона"
+msgstr "%qE не есть корректный аргумент шаблона типа %qT поскольку %qE не переменная"
  
  #: cp/pt.c:6459
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a valid template argument of type %qT because %qD does not have external linkage"
-msgstr "строковый литерал %E  не является корректным аргументом шаблона, потому что это адрес статического объекта"
+msgstr "%qE не есть корректный аргумент шаблона типа %qT поскольку %qD не имеет внешней привязки"
  
  #: cp/pt.c:6467
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a valid template argument of type %qT because %qD has no linkage"
-msgstr "%qE не является корректным аргументом шаблона"
+msgstr "%qE не есть корректный аргумент шаблона типа %qT поскольку %qD не имеет привязки"
  
  #: cp/pt.c:6497
  #, gcc-internal-format
  msgid "%qE is not a valid template argument for type %qT because of conflicts in cv-qualification"
-msgstr ""
+msgstr "%qE не есть корректный аргумент шаблона для типа %qT из-за конфликтов в cv-qualification"
  
  #: cp/pt.c:6505
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a valid template argument for type %qT because it is not an lvalue"
-msgstr "%qE не является корректным аргументом шаблона"
+msgstr "%qE не есть корректный аргумент шаблона для типа %qT поскольку он не есть lvalue"
  
  #: cp/pt.c:6523
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#D is not a valid template argument for type %qT because a reference variable does not have a constant address"
-msgstr "%qE не является корректным аргументом шаблона"
+msgstr "%q#D не есть корректный аргумент шаблона для типа %qT поскольку ссылочная переменная не имеет постоянного адреса"
  
  #: cp/pt.c:6533
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is not a valid template argument for type %qT because it is not an object with external linkage"
  msgid "%qE is not a valid template argument for type %qT because it is not an object with linkage"
-msgstr "строковый литерал %E  не является корректным аргументом шаблона, потому что это адрес статического объекта"
+msgstr "%qE не есть корректный аргумент шаблона для типа %qT поскольку он не является объектом с внешней привязкой"
  
  #: cp/pt.c:6544
  #, fuzzy, gcc-internal-format
+#| msgid "%qE is not a valid template argument for type %qT because object %qD has not external linkage"
  msgid "%qE is not a valid template argument for type %qT because object %qD does not have linkage"
-msgstr "строковый литерал %E  не является корректным аргументом шаблона, потому что это адрес статического объекта"
+msgstr "%qE не есть корректный аргумент шаблона для типа %qT поскольку объект %qD не имеет внешней привязки"
  
  #: cp/pt.c:6590
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a valid template argument for type %qT because it is a pointer"
-msgstr "%qE не является корректным аргументом шаблона"
+msgstr "%qE не есть корректный аргумент шаблона для типа %qT поскольку он является указателем"
  
  #: cp/pt.c:6592
  #, gcc-internal-format
@@ -46328,9 +48213,9 @@ msgid "try using %qE instead"
  msgstr "попробуйте задать %qE"
  
  #: cp/pt.c:6634 cp/pt.c:6665
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not a valid template argument for type %qT because it is of type %qT"
-msgstr "%qE не является корректным аргументом шаблона"
+msgstr "%qE не есть корректный аргумент шаблона для типа %qT поскольку он имеет тип %qT"
  
  #: cp/pt.c:6640
  #, gcc-internal-format
@@ -46338,19 +48223,19 @@ msgid "standard conversions are not allowed in this context"
  msgstr "стандартные преобразования в данном контексте недопустимы"
  
  #: cp/pt.c:6952
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ignoring attributes on template argument %qT"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°"
+msgstr "Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qT"
  
  #: cp/pt.c:7059
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "injected-class-name %qD used as template template argument"
-msgstr "параметр шаблона `%#D'"
+msgstr "injected-class-name %qD использовано как шаблон аргумента шаблона"
  
  #: cp/pt.c:7088
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of destructor %qE as a type"
-msgstr "некорректное использование деструктора %qD в качестве типа"
+msgstr "некорректное использование деструктора %qE в качестве типа"
  
  #: cp/pt.c:7093
  #, gcc-internal-format
@@ -46388,9 +48273,9 @@ msgid "  expected a class template, got %qT"
  msgstr "  ожидался шаблон класса, обнаружено %qT"
  
  #: cp/pt.c:7188
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  expected a template of type %qD, got %qT"
-msgstr "  ожидался шаблон типа %qD, обнаружено %qD"
+msgstr "  ожидался шаблон типа %qD, обнаружено %qT"
  
  #: cp/pt.c:7202
  #, fuzzy, gcc-internal-format
@@ -46407,9 +48292,9 @@ msgstr "  ожидался тип, обнаружено %qE"
  #. Not sure if this is reachable, but it doesn't hurt
  #. to be robust.
  #: cp/pt.c:7237
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type mismatch in nontype parameter pack"
-msgstr "несоответствие типов в условном выражении"
+msgstr "несоответствие типов в нетиповом parameter pack"
  
  #: cp/pt.c:7263
  #, gcc-internal-format
@@ -46440,13 +48325,15 @@ msgstr "задано для %q+D"
  
  #: cp/pt.c:7572
  #, fuzzy, gcc-internal-format
+#| msgid "default argument for template parameter for class enclosing %qD"
  msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° Ñ\82Ð¸Ð¿Ð° %qT Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %qT"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð´Ð»Ñ\8f ÐºÐ»Ð°Ñ\81Ñ\81Ð° Ð²ÐºÐ»Ñ\8eÑ\87Ð°Ñ\8eÑ\89ÐµÐ³Ð¾ %qD"
  
  #: cp/pt.c:7576
  #, fuzzy, gcc-internal-format
+#| msgid "default argument given for parameter %d of %q#D"
  msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %d Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ `%#D'"
+msgstr "Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð·Ð°Ð´Ð°Ð½ Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %d %q#D"
  
  #: cp/pt.c:7668
  #, gcc-internal-format
@@ -46459,9 +48346,9 @@ msgid "provided for %q+D"
  msgstr "задано для %q+D"
  
  #: cp/pt.c:7999
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#D is not a function template"
-msgstr "%qD не является шаблоном функции"
+msgstr "%q#D не является шаблоном функции"
  
  #: cp/pt.c:8166
  #, gcc-internal-format
@@ -46481,13 +48368,15 @@ msgstr "обнаружена несогласованность внутренн
  
  #: cp/pt.c:8683
  #, fuzzy, gcc-internal-format
+#| msgid "constructors may not be cv-qualified"
  msgid "constraints for %qD not satisfied"
-msgstr "Ð´Ðµструкторы не могут быть cv-квалифицированы"
+msgstr "ÐºÐ¾Ð½структоры не могут быть cv-квалифицированы"
  
  #: cp/pt.c:9075
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth= to increase the maximum) substituting %qS"
  msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth= to increase the maximum)"
-msgstr "глубина конкретизации шаблона превышает максимум %d (задайте -ftemplate-depth-NN, чтобы увеличить максимум) при конкретизации %qD"
+msgstr "глубина конкретизации шаблона превышает максимум %d (задайте -ftemplate-depth= чтобы увеличить максимум) при подстановке %qS"
  
  #: cp/pt.c:10655
  #, gcc-internal-format
@@ -46497,17 +48386,18 @@ msgstr ""
  #: cp/pt.c:10946
  #, gcc-internal-format
  msgid "mismatched argument pack lengths while expanding %<%T%>"
-msgstr ""
+msgstr "несоответствие длин argument pack при расширении %<%T%>"
  
  #: cp/pt.c:10950
  #, gcc-internal-format
  msgid "mismatched argument pack lengths while expanding %<%E%>"
-msgstr ""
+msgstr "несоответствие длин argument pack при расширении %<%E%>"
  
  #: cp/pt.c:11501
  #, fuzzy, gcc-internal-format
+#| msgid "redefinition of default argument for %q#D"
  msgid "  when instantiating default argument for call to %D"
-msgstr "повторное определение аргумента по умолчанию для `%#D'"
+msgstr "редекларация аргумента по умолчанию для %q#D"
  
  #. It may seem that this case cannot occur, since:
  #.
@@ -46523,9 +48413,9 @@ msgstr "повторное определение аргумента по умо
  #. is an attempt to declare a variable with function
  #. type.
  #: cp/pt.c:12336
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %qD has function type"
-msgstr "переменная %qs инициализирована, хотя имеет неполный тип"
+msgstr "переменная %qD имеет тип функции"
  
  #: cp/pt.c:12508
  #, gcc-internal-format
@@ -46538,14 +48428,14 @@ msgid "in declaration %q+D"
  msgstr "в декларации %q+D"
  
  #: cp/pt.c:12621
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "function returning an array"
-msgstr "Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÑ\82 Ð°Ð³Ñ\80ÐµÐ³Ð°Ñ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ"
+msgstr "Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÑ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²"
  
  #: cp/pt.c:12623
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "function returning a function"
-msgstr "%qs объявлена как функция, возвращающая функцию"
+msgstr "функция возвращает функцию"
  
  #: cp/pt.c:12663
  #, gcc-internal-format
@@ -46558,24 +48448,26 @@ msgid "forming reference to void"
  msgstr "создание ссылки на void"
  
  #: cp/pt.c:13253
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "forming pointer to reference type %qT"
-msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ %s на ссылочный тип %qT"
+msgstr "Ñ\84Ð¾Ñ\80Ð¼Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f на ссылочный тип %qT"
  
  #: cp/pt.c:13255
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "forming reference to reference type %qT"
-msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ %s на ссылочный тип %qT"
+msgstr "Ñ\84Ð¾Ñ\80Ð¼Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ на ссылочный тип %qT"
  
  #: cp/pt.c:13268
  #, fuzzy, gcc-internal-format
+#| msgid "cannot declare pointer to qualified function type %qT"
  msgid "forming pointer to qualified function type %qT"
-msgstr "Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f %s Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qT"
  
  #: cp/pt.c:13271
  #, fuzzy, gcc-internal-format
+#| msgid "cannot declare reference to qualified function type %qT"
  msgid "forming reference to qualified function type %qT"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ Ð½Ð° %q#T"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81Ñ\81Ñ\8bÐ»ÐºÑ\83 Ð½Ð° ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qT"
  
  #: cp/pt.c:13319
  #, gcc-internal-format
@@ -46588,9 +48480,9 @@ msgid "creating pointer to member reference type %qT"
  msgstr "создание указателя на элемент ссылочного типа %qT"
  
  #: cp/pt.c:13331
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "creating pointer to member of type void"
-msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ñ\87Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
+msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ñ\82Ð¸Ð¿Ð° void"
  
  #: cp/pt.c:13397
  #, gcc-internal-format
@@ -46605,12 +48497,12 @@ msgstr "%qT не является типом class, struct или union"
  #: cp/pt.c:13465
  #, gcc-internal-format
  msgid "%qT resolves to %qT, which is not an enumeration type"
-msgstr ""
+msgstr "%qT разрешается в %qT, который не является перечислимым типом"
  
  #: cp/pt.c:13473
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qT resolves to %qT, which is is not a class type"
-msgstr "создание массива элементов типа %qT, являющегося абстрактным классом"
+msgstr "%qT разрешается в %qT, который не является классовым типом"
  
  #: cp/pt.c:13602
  #, gcc-internal-format
@@ -46618,14 +48510,14 @@ msgid "use of %qs in template"
  msgstr "использование %qs в шаблоне"
  
  #: cp/pt.c:13754
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "qualifying type %qT does not match destructor name ~%qT"
-msgstr "квалифицированный тип %qT не соответствует имени деструктора `~%T'"
+msgstr "квалифицированный тип %qT не соответствует имени деструктора ~%qT"
  
  #: cp/pt.c:13769
  #, gcc-internal-format
  msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type"
-msgstr ""
+msgstr "зависимое имя %qE разбирается как не тип, но конкретизация дает тип"
  
  #: cp/pt.c:13771
  #, gcc-internal-format
@@ -46633,44 +48525,45 @@ msgid "say %<typename %E%> if a type is meant"
  msgstr "задайте %<typename %E%>, если подразумевается тип"
  
  #: cp/pt.c:13986
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "using invalid field %qD"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ðµ Ð¿Ð¾Ð»Ðµ %qs"
+msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ð³Ð¾ Ð¿Ð¾Ð»Ñ\8f %qD"
  
  #: cp/pt.c:14444 cp/pt.c:15770
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of pack expansion expression"
-msgstr "Ð½ÐµÐ¿Ñ\80Ð°Ð²Ð¸Ð»Ñ\8cÐ½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ void-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ pack expansion expression"
  
  #: cp/pt.c:14448 cp/pt.c:15774
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use %<...%> to expand argument pack"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b %<...%>.)"
+msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ %<...%> Ð´Ð»Ñ\8f Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ñ\8f argument pack"
  
  #: cp/pt.c:16549
  #, gcc-internal-format
  msgid "%qD was not declared in this scope, and no declarations were found by argument-dependent lookup at the point of instantiation"
-msgstr ""
+msgstr "%qD не декларирован в этом контексте, и не было найдено деклараций при зависимом от аргументов поиске в точке конкретизации"
  
  #: cp/pt.c:16561
  #, gcc-internal-format
  msgid "declarations in dependent base %qT are not found by unqualified lookup"
-msgstr ""
+msgstr "декларации в зависимой базе %qT не найдены при неквалифицированном поиске"
  
  #: cp/pt.c:16566
  #, gcc-internal-format
  msgid "use %<this->%D%> instead"
-msgstr ""
+msgstr "используйте %<this->%D%>"
  
  #: cp/pt.c:16569
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use %<%T::%D%> instead"
-msgstr "%<%T::%D%> не является типом"
+msgstr "используйте %<%T::%D%>"
  
  #: cp/pt.c:16574
  #, fuzzy, gcc-internal-format
+#| msgid "%q+D declared here, later in the translation unit"
  msgid "%qD declared here, later in the translation unit"
-msgstr "%H%qE не описан в этой области (не в функции)"
+msgstr "%q+D декларировано здесь, позднее в единице компиляции"
  
  #: cp/pt.c:16847
  #, gcc-internal-format
@@ -46683,19 +48576,19 @@ msgid "%qD is not a class or namespace"
  msgstr "%qD не является классом или пространством имён"
  
  #: cp/pt.c:17213
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qT is/uses anonymous type"
-msgstr "в %qT используется анонимный тип"
+msgstr "%qT есть/использует анонимный тип"
  
  #: cp/pt.c:17215
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template argument for %qD uses local type %qT"
-msgstr "аргумент по умолчанию для `%#D' имеет тип %qT"
+msgstr "аргумент шаблона для %qD использует локальный тип %qT"
  
  #: cp/pt.c:17225
  #, gcc-internal-format
  msgid "%qT is a variably modified type"
-msgstr ""
+msgstr "%qT есть переменно модифицированный тип"
  
  #: cp/pt.c:17240
  #, gcc-internal-format
@@ -46709,28 +48602,31 @@ msgstr "  при конкретизации %qD"
  
  #: cp/pt.c:21035
  #, fuzzy, gcc-internal-format
+#| msgid "ambiguous class template instantiation for %q#T"
  msgid "ambiguous template instantiation for %q#T"
  msgstr "неоднозначная конкретизация шаблона класса для %q#T"
  
  #: cp/pt.c:21037
  #, fuzzy, gcc-internal-format
+#| msgid "ambiguous class template instantiation for %q#T"
  msgid "ambiguous template instantiation for %q#D"
  msgstr "неоднозначная конкретизация шаблона класса для %q#T"
  
  #: cp/pt.c:21043
  #, fuzzy
+#| msgid "%s %+#D"
  msgid "%s %#S"
-msgstr "%s %+#T"
+msgstr "%s %+#D"
  
  #: cp/pt.c:21067 cp/pt.c:21154
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "explicit instantiation of non-template %q#D"
-msgstr "явная конкретизация `%#D', не являющегося шаблоном"
+msgstr "явная конкретизация нешаблона %q#D"
  
  #: cp/pt.c:21086
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is not a static data member of a class template"
-msgstr "`%#D' не является нестатическим элементом %qT"
+msgstr "%qD не является статическим элементом данных шаблона класса"
  
  #: cp/pt.c:21092 cp/pt.c:21149
  #, gcc-internal-format
@@ -46738,24 +48634,24 @@ msgid "no matching template for %qD found"
  msgstr "нет подходящего шаблона для %qD"
  
  #: cp/pt.c:21097
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type %qT for explicit instantiation %qD does not match declared type %qT"
-msgstr "Ñ\8fÐ²Ð½Ð°Ñ\8f ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ñ\82Ð¸Ð¿Ð° %qT, Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÑ\8eÑ\89ÐµÐ³Ð¾Ñ\81Ñ\8f Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð¾Ð¼"
+msgstr "Ñ\82Ð¸Ð¿ %qT Ð´Ð»Ñ\8f Ñ\8fÐ²Ð½Ð¾Ð¹ ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ %qD Ð½Ðµ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð¼Ñ\83 Ñ\82Ð¸Ð¿Ñ\83 %qT"
  
  #: cp/pt.c:21105
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "explicit instantiation of %q#D"
-msgstr "явная конкретизация `%#D'"
+msgstr "явная конкретизация %q#D"
  
  #: cp/pt.c:21141
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "duplicate explicit instantiation of %q#D"
-msgstr "повторная явная конкретизация `%#D'"
+msgstr "повторная явная конкретизация %q#D"
  
  #: cp/pt.c:21164 cp/pt.c:21261
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations"
-msgstr "ISO C++ запрещает использование %<extern%> в явной конкретизации"
+msgstr "ISO C++ 1998 запрещает использование %<extern%> в явной конкретизации"
  
  #: cp/pt.c:21169 cp/pt.c:21278
  #, gcc-internal-format
@@ -46763,9 +48659,9 @@ msgid "storage class %qD applied to template instantiation"
  msgstr "класс хранения %qD в конкретизации шаблона"
  
  #: cp/pt.c:21237
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "explicit instantiation of non-class template %qD"
-msgstr "явная конкретизация `%#D', не являющегося шаблоном"
+msgstr "явная конкретизация неклассового шаблона %qD"
  
  #: cp/pt.c:21239
  #, gcc-internal-format
@@ -46800,24 +48696,24 @@ msgid "explicit instantiation of %qD but no definition available"
  msgstr "явная конкретизация %qD без определения"
  
  #: cp/pt.c:22083
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "template instantiation depth exceeds maximum of %d instantiating %q+D, possibly from virtual table generation (use -ftemplate-depth= to increase the maximum)"
-msgstr "глубина конкретизации шаблона превышает максимум %d (задайте -ftemplate-depth-NN, чтобы увеличить максимум) при конкретизации %qD"
+msgstr "глубина конкретизации шаблона превышает максимум %d при конкретизации %q+D, возможно при генерации виртуальной таблицы (задайте -ftemplate-depth= чтобы увеличить максимум)"
  
  #: cp/pt.c:22425
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid template non-type parameter"
-msgstr "Ð½ÐµÐ¿Ñ\80Ð°Ð²Ð¸Ð»Ñ\8cÐ½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÐ´Ð¾Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð¾Ð³Ð¾ typedef %qD"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð½ÐµÑ\82Ð¸Ð¿Ð¾Ð²Ñ\8bÐ¹ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð°"
  
  #: cp/pt.c:22427
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q#T is not a valid type for a template non-type parameter"
-msgstr "`%#T' не является корректным типом для константного параметра шаблона"
+msgstr "%q#T не является корректным типом для нетипового параметра шаблона"
  
  #: cp/pt.c:23789
  #, gcc-internal-format
  msgid "deducing from brace-enclosed initializer list requires #include <initializer_list>"
-msgstr ""
+msgstr "вывод из взятого в скобки списка инизиализатора требует #include <initializer_list>"
  
  #: cp/pt.c:23950
  #, gcc-internal-format
@@ -46836,13 +48732,14 @@ msgstr ""
  
  #: cp/pt.c:24010
  #, fuzzy, gcc-internal-format
+#| msgid "unable to deduce %qT from %qE"
  msgid "unable to deduce lambda return type from %qE"
-msgstr "эмуляция %qs невозможна"
+msgstr "невозможно вывести %qT из %qE"
  
  #: cp/pt.c:24012
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unable to deduce %qT from %qE"
-msgstr "эмуляция %qs невозможна"
+msgstr "невозможно вывести %qT из %qE"
  
  #: cp/pt.c:24033
  #, gcc-internal-format
@@ -46878,9 +48775,9 @@ msgid "mysterious repository information in %s"
  msgstr "некорректная информация в репозитории %s"
  
  #: cp/repo.c:221
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t create repository information file %qs"
-msgstr "ошибка при создании файла репозитория %qs"
+msgstr "ошибка при создании информационного файла репозитория %qs"
  
  #: cp/rtti.c:287
  #, gcc-internal-format
@@ -46893,29 +48790,30 @@ msgid "must #include <typeinfo> before using typeid"
  msgstr "необходимо включить #include <typeinfo> до использования идентификатора типа"
  
  #: cp/rtti.c:395
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot create type information for type %qT because it involves types of variable size"
-msgstr "создание информации о типе %qT невозможно, поскольку он имеет переменный размер"
+msgstr "невозможно создать информацию о типе для типа %qT поскольку он включает типы переменного размера"
  
  #: cp/rtti.c:485
  #, fuzzy, gcc-internal-format
+#| msgid "cannot declare pointer to qualified function type %qT"
  msgid "typeid of qualified function type %qT"
-msgstr "Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f %s Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qT"
  
  #: cp/rtti.c:666 cp/rtti.c:681
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "dynamic_cast of %q#D to %q#T can never succeed"
-msgstr "dynamic_cast для преобразования `%#D' в `%#T' никогда не будет успешным"
+msgstr "dynamic_cast %q#D к %q#T никогда не будет успешным"
  
  #: cp/rtti.c:692
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<dynamic_cast%> not permitted with -fno-rtti"
-msgstr "использование идентификатора типа с ключом -fno-rtti недопустимо"
+msgstr "%<dynamic_cast%> не разрешено с -fno-rtti"
  
  #: cp/rtti.c:771
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot dynamic_cast %qE (of type %q#T) to type %q#T (%s)"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ dynamic_cast Ð´Ð»Ñ\8f Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qE (Ñ\82Ð¸Ð¿Ð° `%#T') Ðº Ñ\82Ð¸Ð¿Ñ\83 `%#T' (%s)"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ dynamic_cast %qE (Ñ\82Ð¸Ð¿Ð° %q#T) Ðº Ñ\82Ð¸Ð¿Ñ\83 %q#T (%s)"
  
  #: cp/search.c:248
  #, gcc-internal-format
@@ -46955,9 +48853,9 @@ msgid "conflicting return type specified for %q+#D"
  msgstr "задан несовместимый тип результата для %q+#D"
  
  #: cp/search.c:2087
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "looser throw specifier for %q+#F"
-msgstr "Ð´Ð»Ñ\8f `%#F' Ð·Ð°Ð´Ð°Ð½ Ð±Ð¾Ð»ÐµÐµ Ñ\81Ð»Ð°Ð±Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð¹ Ñ\81Ð¸Ñ\82Ñ\83Ð°Ñ\86Ð¸Ð¸,"
+msgstr "Ð½ÐµÑ\82Ð¾Ñ\87Ð½Ñ\8bÐ¹ throw Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð´Ð»Ñ\8f %q+#F"
  
  #: cp/search.c:2088
  #, gcc-internal-format
@@ -46971,8 +48869,9 @@ msgstr "заданы несовместимые атрибуты типа для
  
  #: cp/search.c:2115
  #, fuzzy, gcc-internal-format
+#| msgid "expected %<__transaction_atomic%>"
  msgid "%qD declared %<transaction_safe_dynamic%>"
-msgstr "ожидался оператор"
+msgstr "ожидалось %<__transaction_atomic%>"
  
  #: cp/search.c:2117
  #, fuzzy, gcc-internal-format
@@ -46981,34 +48880,34 @@ msgid "overriding %qD declared %<transaction_safe%>"
  msgstr "переменная %q+D декларирована со спецификатором %<inline%>"
  
  #: cp/search.c:2124
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "deleted function %q+D"
-msgstr "для декларации шаблона %qD"
+msgstr "удаленная функция %q+D"
  
  #: cp/search.c:2125
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "overriding non-deleted function %q+D"
-msgstr "Ð²Ð¸Ñ\80Ñ\82Ñ\83Ð°Ð»Ñ\8cÐ½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %qs Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð¼ ÐºÐ»Ð°Ñ\81Ñ\81Ð°"
+msgstr "Ð¿ÐµÑ\80ÐµÐ±Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÑ\83Ð´Ð°Ð»ÐµÐ½Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q+D"
  
  #: cp/search.c:2130
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-deleted function %q+D"
-msgstr "Ð²Ñ\8bÐ·Ð¾Ð² Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qD"
+msgstr "Ð½ÐµÑ\83Ð´Ð°Ð»ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %q+D"
  
  #: cp/search.c:2131
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "overriding deleted function %q+D"
-msgstr "Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÑ\82Ð¸Ðµ %s Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q#D"
+msgstr "Ð¿ÐµÑ\80ÐµÐ±Ð¸Ð²Ð°Ð½Ð¸Ðµ Ñ\83Ð´Ð°Ð»ÐµÐ½Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q+D"
  
  #: cp/search.c:2137
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "virtual function %q+D"
-msgstr "виртуальная функция %qs не является элементом класса"
+msgstr "виртуальная функция %q+D"
  
  #: cp/search.c:2138
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "overriding final function %q+D"
-msgstr "Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÑ\82Ð¸Ðµ %s Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q#D"
+msgstr "Ð¿ÐµÑ\80ÐµÐ±Ð¸Ð²Ð°Ð½Ð¸Ðµ Ñ\84Ð¸Ð½Ð°Ð»Ñ\8cÐ½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q+D"
  
  #. A static member function cannot match an inherited
  #. virtual member function.
@@ -47033,9 +48932,9 @@ msgid "type of asm operand %qE could not be determined"
  msgstr "невозможно определить тип операнда %qE для оператора asm"
  
  #: cp/semantics.c:1573
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "__label__ declarations are only allowed in function scopes"
-msgstr "декларации Objective-C могут находиться только в глобальной области"
+msgstr "__label__ декларации допускаются только в контекстах функций"
  
  #: cp/semantics.c:1760
  #, fuzzy, gcc-internal-format
@@ -47066,12 +48965,12 @@ msgstr "некорректное использование %<this%> на вне
  #: cp/semantics.c:2590
  #, gcc-internal-format
  msgid "invalid qualifying scope in pseudo-destructor name"
-msgstr ""
+msgstr "некорректный квалифицированный контекст в имени псевдодеструктора"
  
  #: cp/semantics.c:2598 cp/typeck.c:2530
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "qualified type %qT does not match destructor name ~%qT"
-msgstr "квалифицированный тип %qT не соответствует имени деструктора `~%T'"
+msgstr "квалифицированный тип %qT не соответствует имени деструктора ~%qT"
  
  #: cp/semantics.c:2620
  #, gcc-internal-format
@@ -47081,7 +48980,7 @@ msgstr "%qE не имеет тип %qT"
  #: cp/semantics.c:2691
  #, gcc-internal-format
  msgid "compound literal of non-object type %qT"
-msgstr ""
+msgstr "составной литерал необъектного типа %qT"
  
  #: cp/semantics.c:2808
  #, gcc-internal-format
@@ -47091,12 +48990,12 @@ msgstr "параметры шаблона, являющиеся типами, д
  #: cp/semantics.c:2858
  #, gcc-internal-format
  msgid "invalid use of type %qT as a default value for a template template-parameter"
-msgstr ""
+msgstr "некорректное использование типа %qT как подразумеваемого значения для шаблона параметра шаблона"
  
  #: cp/semantics.c:2861
  #, gcc-internal-format
  msgid "invalid default argument for a template template parameter"
-msgstr ""
+msgstr "некорректный подразумеваемый аргумент для шаблона параметра шаблона"
  
  #: cp/semantics.c:2878
  #, gcc-internal-format
@@ -47115,13 +49014,14 @@ msgstr "некорректная спецификация базового кл
  
  #: cp/semantics.c:3348
  #, fuzzy, gcc-internal-format
+#| msgid "protected member %q+#D in anonymous union"
  msgid "cannot capture member %qD of anonymous union"
-msgstr "protected-элемент `%#D' в анонимном объединении"
+msgstr "protected-элемент %q+#D в анонимном объединении"
  
  #: cp/semantics.c:3361 cp/semantics.c:9260
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is not captured"
-msgstr "%qD не является типом"
+msgstr "%qD не захватывается"
  
  #: cp/semantics.c:3366
  #, gcc-internal-format
@@ -47135,18 +49035,19 @@ msgstr ""
  
  #: cp/semantics.c:3379
  #, fuzzy, gcc-internal-format
+#| msgid "use of %<auto%> variable from containing function"
  msgid "use of local variable with automatic storage from containing function"
-msgstr "использование %s в объемлющей функции"
+msgstr "использование %<auto%> переменной из внутренней функции"
  
  #: cp/semantics.c:3380
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "use of parameter from containing function"
-msgstr "использование %s в объемлющей функции"
+msgstr "использование параметра из внутренней функции"
  
  #: cp/semantics.c:3548
  #, gcc-internal-format
  msgid "template parameter %qD of type %qT is not allowed in an integral constant expression because it is not of integral or enumeration type"
-msgstr ""
+msgstr "параметр шаблона %qD типа %qT не допускается в целочисленном константном выражении поскольку он не целого или перечислимого типа"
  
  #: cp/semantics.c:3635
  #, gcc-internal-format
@@ -47167,7 +49068,7 @@ msgstr "запрос элемента %qD неоднозначен в сетке
  #: cp/semantics.c:3672
  #, gcc-internal-format
  msgid "%qD cannot appear in a constant-expression"
-msgstr ""
+msgstr "%qD не может появляться в константном выражении"
  
  #: cp/semantics.c:3797
  #, gcc-internal-format
@@ -47175,20 +49076,20 @@ msgid "type of %qE is unknown"
  msgstr "тип %qE неизвестен"
  
  #: cp/semantics.c:3825
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qT is not an enumeration type"
-msgstr "%qT не является пространством имён"
+msgstr "%qT не имеет перечислимый тип"
  
  #. Parameter packs can only be used in templates
  #: cp/semantics.c:3980
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "Parameter pack __bases only valid in template declaration"
-msgstr "спецификаторы класса хранения не допускаются в декларациях параметров"
+msgstr "Parameter pack __bases допустим только в декларации шаблона"
  
  #: cp/semantics.c:4009
  #, gcc-internal-format
  msgid "cannot apply %<offsetof%> to destructor %<~%T%>"
-msgstr ""
+msgstr "невозможно применить %<offsetof%> к деструктору %<~%T%>"
  
  #: cp/semantics.c:4018
  #, gcc-internal-format
@@ -47196,9 +49097,9 @@ msgid "second operand of %<offsetof%> is neither a single identifier nor a seque
  msgstr ""
  
  #: cp/semantics.c:4026
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot apply %<offsetof%> to member function %qD"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÑ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° %qD"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½Ð¸Ñ\82Ñ\8c %<offsetof%> Ðº Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ñ\83-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qD"
  
  #: cp/semantics.c:4042
  #, gcc-internal-format
@@ -47225,8 +49126,9 @@ msgstr ""
  
  #: cp/semantics.c:5544
  #, fuzzy, gcc-internal-format
+#| msgid "%qE has invalid type for %<reduction%>"
  msgid "%qE has const type for %<reduction%>"
-msgstr "неверное употребление спецификатора %<restrict%>"
+msgstr "%qE имеет неверный тип для %<reduction%>"
  
  #: cp/semantics.c:5656
  #, gcc-internal-format
@@ -47245,113 +49147,131 @@ msgstr ""
  
  #: cp/semantics.c:5911
  #, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "linear step expression must be integral"
-msgstr "предикат должен быть идентификатором"
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/semantics.c:6014
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is not a variable in clause %qs"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qD не есть переменная в клаузуле %qs"
  
  #: cp/semantics.c:6070
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is not a variable in clause %<firstprivate%>"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "%qD не есть переменная в клаузуле %<firstprivate%>"
  
  #: cp/semantics.c:6109
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD is not a variable in clause %<lastprivate%>"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "%qD не есть переменная в клаузуле %<lastprivate%>"
  
  #: cp/semantics.c:6154
  #, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "%<gang%> static expression must be integral"
-msgstr "предикат должен быть идентификатором"
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/semantics.c:6168
  #, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<gang%> static value must bepositive"
-msgstr "%qD не является элементом типа %qT"
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: cp/semantics.c:6200
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "%<gang%> num expression must be integral"
-msgstr ""
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/semantics.c:6203
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "%<vector%> length expression must be integral"
-msgstr ""
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/semantics.c:6207
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "%<worker%> num expression must be integral"
-msgstr ""
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/semantics.c:6211
  #, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "%qs expression must be integral"
-msgstr "предикат должен быть идентификатором"
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/semantics.c:6229
  #, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<gang%> num value must be positive"
-msgstr "%qD не является элементом типа %qT"
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: cp/semantics.c:6233
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<vector%> length value must bepositive"
-msgstr ""
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: cp/semantics.c:6238
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%<worker%> num value must bepositive"
-msgstr ""
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: cp/semantics.c:6243
  #, fuzzy, gcc-internal-format
+#| msgid "%<num_threads%> value must be positive"
  msgid "%qs value must be positive"
-msgstr "%qD не является элементом типа %qT"
+msgstr "значение %<num_threads%> должно быть положительным"
  
  #: cp/semantics.c:6290
  #, gcc-internal-format
  msgid "schedule chunk size expression must be integral"
-msgstr ""
+msgstr "schedule chunk size выражение должно быть целочисленным"
  
  #: cp/semantics.c:6322
  #, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "%qs length expression must be integral"
-msgstr "предикат должен быть идентификатором"
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/semantics.c:6335
  #, fuzzy, gcc-internal-format
+#| msgid "collapse argument needs positive constant integer expression"
  msgid "%qs length expression must be positive constant integer expression"
-msgstr "сравнение знакового и беззнакового целых выражений"
+msgstr "collapse аргумент требует положительного константного целого выражения"
  
  #: cp/semantics.c:6354
  #, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "%<async%> expression must be integral"
-msgstr "предикат должен быть идентификатором"
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/semantics.c:6382
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "%<thread_limit%> expression must be integral"
-msgstr ""
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/semantics.c:6411
  #, fuzzy, gcc-internal-format
+#| msgid "slice end must be integer"
  msgid "%<device%> id must be integral"
-msgstr "Ð¿Ñ\80ÐµÐ´Ð¸ÐºÐ°Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð¾м"
+msgstr "ÐºÐ¾Ð½ÐµÑ\86 Ð²Ñ\8bÑ\80ÐµÐ·ÐºÐ¸ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\86ÐµÐ»Ñ\8bм"
  
  #: cp/semantics.c:6432
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "schedule chunk size expression must be integral"
  msgid "%<dist_schedule%> chunk size expression must be integral"
-msgstr ""
+msgstr "schedule chunk size выражение должно быть целочисленным"
  
  #: cp/semantics.c:6459
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not a variable in clause %qs"
  msgid "%qD is not a variable in %<aligned%> clause"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qD не есть переменная в клаузуле %qs"
  
  #: cp/semantics.c:6473
  #, gcc-internal-format
@@ -47359,19 +49279,22 @@ msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a referen
  msgstr ""
  
  #: cp/semantics.c:6479
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%qD appears more than once in data clauses"
  msgid "%qD appears more than once in %<aligned%> clauses"
-msgstr ""
+msgstr "%qD появляется более одного раза в клаузуле данных"
  
  #: cp/semantics.c:6492
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "schedule chunk size expression must be integral"
  msgid "%<aligned%> clause alignment expression must be integral"
-msgstr ""
+msgstr "schedule chunk size выражение должно быть целочисленным"
  
  #: cp/semantics.c:6541
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not a variable in clause %qs"
  msgid "%qD is not a variable in %<depend%> clause"
-msgstr "%qT не является базовым для %qT"
+msgstr "%qD не есть переменная в клаузуле %qs"
  
  #: cp/semantics.c:6809
  #, gcc-internal-format
@@ -47380,23 +49303,27 @@ msgstr ""
  
  #: cp/semantics.c:6813
  #, fuzzy, gcc-internal-format
+#| msgid "too many %qs clauses"
  msgid "template %qE in clause %qs"
-msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð²Ñ\85Ð¾Ð´Ð½Ñ\8bÑ\85 Ñ\84Ð°Ð¹Ð»Ð¾Ð²"
+msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹ %qs"
  
  #: cp/semantics.c:6878
  #, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "%<grainsize%> expression must be integral"
-msgstr "предикат должен быть идентификатором"
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/semantics.c:6907
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "%<priority%> expression must be integral"
-msgstr ""
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/semantics.c:6936
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "num_threads expression must be integral"
  msgid "%<num_tasks%> expression must be integral"
-msgstr ""
+msgstr "num_threads выражение должно быть целочисленным"
  
  #: cp/semantics.c:6965
  #, gcc-internal-format
@@ -47406,62 +49333,67 @@ msgstr ""
  #: cp/semantics.c:7421
  #, gcc-internal-format
  msgid "%<threadprivate%> %qD is not file, namespace or block scope variable"
-msgstr ""
+msgstr "%<threadprivate%> %qD не есть переменная файла, пространства имен или контекста блока"
  
  #: cp/semantics.c:7435
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<threadprivate%> %qE directive not in %qT definition"
-msgstr "%Jпараметр %u имеет неполный тип"
+msgstr "%<threadprivate%> %qE директива не в %qT определении"
  
  #: cp/semantics.c:7640
  #, gcc-internal-format
  msgid "difference between %qE and %qD does not have integer type"
-msgstr ""
+msgstr "разность между %qE и %qD не имеет целый тип"
  
  #: cp/semantics.c:8060
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma omp atomic update%> uses two different variables for memory"
  msgid "%<#pragma omp simd%> used with class iteration variable %qE"
-msgstr ""
+msgstr "в %<#pragma omp atomic update%> используются две различные переменные для памяти"
  
  #: cp/semantics.c:8402 cp/semantics.c:8412
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%<#pragma omp atomic update%> uses two different variables for memory"
  msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
-msgstr ""
+msgstr "в %<#pragma omp atomic update%> используются две различные переменные для памяти"
  
  #: cp/semantics.c:8705
  #, fuzzy, gcc-internal-format
+#| msgid "static assertion failed: %E"
  msgid "static assertion failed"
-msgstr "Ð\9dÐµ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¾ Ð½ÐµÐ¾Ð±Ñ\85Ð¾Ð´Ð¸Ð¼Ð¾Ðµ Ñ\83Ñ\81Ð»Ð¾Ð²Ð¸Ðµ Ð² ÐºÐ¾Ð´Ðµ CRIS: "
+msgstr "Ð½Ðµ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¾ Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ðµ Ñ\83Ñ\82Ð²ÐµÑ\80Ð¶Ð´ÐµÐ½Ð¸Ðµ: %E"
  
  #: cp/semantics.c:8707
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "static assertion failed: %s"
-msgstr "Ð\9dÐµ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¾ Ð½ÐµÐ¾Ð±Ñ\85Ð¾Ð´Ð¸Ð¼Ð¾Ðµ Ñ\83Ñ\81Ð»Ð¾Ð²Ð¸Ðµ Ð² ÐºÐ¾Ð´Ðµ CRIS: "
+msgstr "Ð½ÐµÑ\83Ð´Ð°Ñ\87Ð° static assertion: %s"
  
  #: cp/semantics.c:8712
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-constant condition for static assertion"
-msgstr "неstatic-декларация %q+D после static-декларации"
+msgstr "неконстантное условие для static assertion"
  
  #: cp/semantics.c:8742
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "argument to decltype must be an expression"
-msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qT Ð² ÐºÐ°Ñ\87ÐµÑ\81Ñ\82Ð²Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 decltype Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸ÐµÐ¼"
  
  #: cp/semantics.c:8770
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "decltype cannot resolve address of overloaded function"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "decltype не может разрешить адрес перегруженной функции"
  
  #: cp/semantics.c:9299
  #, fuzzy, gcc-internal-format
+#| msgid "third operand of conditional expression has no effect"
  msgid "operand of fold expression has no unexpanded parameter packs"
-msgstr "левый операнд операции `запятая' не имеет побочных эффектов"
+msgstr "третий операнд условного выражения ссылка не имеет эффекта"
  
  #: cp/semantics.c:9352
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "template argument %qE involves template parameter(s)"
  msgid "both arguments in binary fold have unexpanded parameter packs"
-msgstr ""
+msgstr "аргумент шаблона %qE включает параметр(ы) шаблона"
  
  #: cp/semantics.c:9354
  #, gcc-internal-format
@@ -47469,29 +49401,30 @@ msgid "no unexpanded parameter packs in binary fold"
  msgstr ""
  
  #: cp/tree.c:1140
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qV qualifiers cannot be applied to %qT"
-msgstr "квалификаторы `%V' не могут быть применены к %qT"
+msgstr "квалификаторы %qV не могут быть применены к %qT"
  
  #: cp/tree.c:1631
  #, fuzzy, gcc-internal-format
+#| msgid "expression %qE is not a constant-expression"
  msgid "lambda-expression in a constant expression"
-msgstr "целочисленное выражение %qE не является константой"
+msgstr "выражение %qE не является константным выражением"
  
  #: cp/tree.c:3567
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute can only be applied to Java class definitions"
-msgstr "атрибут %qs допустим только для определений Java-классов"
+msgstr "%qE атрибут может применяться только к определениям Java классов"
  
  #: cp/tree.c:3596
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute can only be applied to class definitions"
-msgstr "атрибут %qs допустим только для определений классов"
+msgstr "%qE атрибут может применяться только к определениям классов"
  
  #: cp/tree.c:3602
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is obsolete; g++ vtables are now COM-compatible by default"
-msgstr "%qs устарел; таблицы виртуальных функций g++ теперь COM-совместимы по умолчанию"
+msgstr "%qE устарело; g++ vtables теперь COM-совместимы по умолчанию"
  
  #: cp/tree.c:3629
  #, gcc-internal-format
@@ -47499,9 +49432,9 @@ msgid "requested init_priority is not an integer constant"
  msgstr "заданный init_priority не является целой константой"
  
  #: cp/tree.c:3651
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can only use %qE attribute on file-scope definitions of objects of class type"
-msgstr "атрибут %qs может использоваться только для определений объектов типа class на уровне файла"
+msgstr "%qE атрибут может использоваться только для определений объектов типа class на уровне файла"
  
  #: cp/tree.c:3659
  #, gcc-internal-format
@@ -47514,29 +49447,33 @@ msgid "requested init_priority is reserved for internal use"
  msgstr "заданный init_priority зарезервировано для внутреннего использования"
  
  #: cp/tree.c:3680
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE attribute is not supported on this platform"
-msgstr "атрибут %qs не поддерживается на данной платформе"
+msgstr "%qE атрибут не поддерживается на данной платформе"
  
  #: cp/tree.c:3707
  #, fuzzy, gcc-internal-format
+#| msgid "declaration of %qD as member of %qT"
  msgid "redeclaration of %qD adds abi tag %E"
-msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÐ²Ð°ÐµÑ\82 Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 ÐºÐ»Ð°Ñ\81Ñ\81Ð°, Ð½Ð° ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐ¹ Ñ\83ÐºÐ°Ð·Ñ\8bÐ²Ð°ÐµÑ\82 'this'"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD ÐºÐ°Ðº Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° %qT"
  
  #: cp/tree.c:3727
  #, fuzzy, gcc-internal-format
+#| msgid "%qD attribute requires a single NTBS argument"
  msgid "the %qE attribute requires arguments"
-msgstr "аргументом атрибута %qs должна быть целая константа"
+msgstr "%qD атрибут требует единственный NTBS аргумент"
  
  #: cp/tree.c:3738
  #, fuzzy, gcc-internal-format
+#| msgid "argument of %qE attribute is not a string constant"
  msgid "arguments to the %qE attribute must be narrow string literals"
-msgstr "аргумент атрибута %qs не является строковой константой"
+msgstr "аргумент %qE атрибута не строковая константа"
  
  #: cp/tree.c:3751 cp/tree.c:3764
  #, fuzzy, gcc-internal-format
+#| msgid "argument of %qE attribute is not a string constant"
  msgid "arguments to the %qE attribute must contain valid identifiers"
-msgstr "аргумент атрибута %qs не является строковой константой"
+msgstr "аргумент %qE атрибута не строковая константа"
  
  #: cp/tree.c:3753
  #, fuzzy, gcc-internal-format
@@ -47552,38 +49489,44 @@ msgstr "%<%T::%D%> не является корректным декларато
  
  #: cp/tree.c:3790
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute ignored on non-class types"
  msgid "%qE attribute applied to non-class, non-enum type %qT"
  msgstr "атрибут %qE для не классовых типов игнорируется"
  
  #: cp/tree.c:3796
  #, fuzzy, gcc-internal-format
+#| msgid "ignoring attributes applied to %qT after definition"
  msgid "%qE attribute applied to %qT after its definition"
-msgstr "Ð¾Ñ\82Ð±Ñ\80Ð¾Ñ\88ÐµÐ½Ñ\8b Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b ÐºÐ»Ð°Ñ\81Ñ\81Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ñ\8bÐµ Ð²Ð½Ðµ ÐµÐ³Ð¾ Ð¾Ð±Ñ\8aÑ\8fÐ²ления"
+msgstr "Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ñ\8b Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b, Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð½Ñ\8bÐµ Ðº %qT Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿Ñ\80ÐµÐ´Ðµления"
  
  #: cp/tree.c:3803
  #, fuzzy, gcc-internal-format
+#| msgid "ignoring attributes applied to %qT after definition"
  msgid "ignoring %qE attribute applied to template instantiation %qT"
-msgstr "Ð¾Ñ\82Ð±Ñ\80Ð¾Ñ\88ÐµÐ½Ñ\8b Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b ÐºÐ»Ð°Ñ\81Ñ\81Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ñ\8bÐµ Ð²Ð½Ðµ ÐµÐ³Ð¾ Ð¾Ð±Ñ\8aÑ\8fÐ²ления"
+msgstr "Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ñ\8b Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b, Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð½Ñ\8bÐµ Ðº %qT Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿Ñ\80ÐµÐ´Ðµления"
  
  #: cp/tree.c:3810
  #, fuzzy, gcc-internal-format
+#| msgid "ignoring attributes applied to %qT after definition"
  msgid "ignoring %qE attribute applied to template specialization %qT"
-msgstr "Ð¾Ñ\82Ð±Ñ\80Ð¾Ñ\88ÐµÐ½Ñ\8b Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b ÐºÐ»Ð°Ñ\81Ñ\81Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ñ\8bÐµ Ð²Ð½Ðµ ÐµÐ³Ð¾ Ð¾Ð±Ñ\8aÑ\8fÐ²ления"
+msgstr "Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ñ\8b Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b, Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð½Ñ\8bÐµ Ðº %qT Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿Ñ\80ÐµÐ´Ðµления"
  
  #: cp/tree.c:3832
  #, fuzzy, gcc-internal-format
+#| msgid "%qE attribute only applies to functions, not %s"
  msgid "%qE attribute applied to non-function, non-variable %qD"
-msgstr "%J%qE: атрибут допустим только для функций"
+msgstr "атрибут %qE применим только к функциям, а не к %s"
  
  #: cp/tree.c:3838
  #, fuzzy, gcc-internal-format
+#| msgid "%s attribute applied to %s %s at %L"
  msgid "%qE attribute applied to extern \"C\" declaration %qD"
-msgstr "%J%qE: атрибут допустим только для функций"
+msgstr "%s атрибут применен к %s %s в %L"
  
  #: cp/tree.c:4539
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "zero as null pointer constant"
-msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð½Ð¾Ð»Ñ\8c ÐºÐ°Ðº ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð¿Ñ\83Ñ\81Ñ\82Ð¾Ð¹ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c"
  
  #: cp/tree.c:4552
  #, gcc-internal-format, gfc-internal-format
@@ -47591,59 +49534,59 @@ msgid "lang_* check: failed in %s, at %s:%d"
  msgstr "lang_* check: ошибка в %s, в %s:%d"
  
  #: cp/typeck.c:461
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "comparison between distinct pointer types %qT and %qT lacks a cast"
-msgstr "%s между разными указательными типами %qT и %qT: отсутствует приведение"
+msgstr "сравнение между различными указательными типами %qT и %qT без приведения типов"
  
  #: cp/typeck.c:467
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion between distinct pointer types %qT and %qT lacks a cast"
-msgstr "%s между разными указательными типами %qT и %qT: отсутствует приведение"
+msgstr "преобразование между различными указательными типами %qT и %qT без приведения типов"
  
  #: cp/typeck.c:473
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conditional expression between distinct pointer types %qT and %qT lacks a cast"
-msgstr "%s между разными указательными типами %qT и %qT: отсутствует приведение"
+msgstr "условное выражение между различными указательными типами %qT и %qT без приведения типов"
  
  #: cp/typeck.c:610
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ forbids comparison between pointer of type %<void *%> and pointer-to-function"
-msgstr "ISO C++ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 %s Ð¼ÐµÐ¶Ð´Ñ\83 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ %<void *%> and Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ð½Ð° функцию"
+msgstr "ISO C++ Ð·Ð°Ð¿Ñ\80ÐµÑ\89Ð°ÐµÑ\82 Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ðµ Ð¼ÐµÐ¶Ð´Ñ\83 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ñ\82Ð¸Ð¿Ð° %<void *%> Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ð½Ðµ функцию"
  
  #: cp/typeck.c:615
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ forbids conversion between pointer of type %<void *%> and pointer-to-function"
-msgstr "ISO C++ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 %s Ð¼ÐµÐ¶Ð´Ñ\83 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ %<void *%> and Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ð½Ð° функцию"
+msgstr "ISO C++ Ð·Ð°Ð¿Ñ\80ÐµÑ\89Ð°ÐµÑ\82 Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¼ÐµÐ¶Ð´Ñ\83 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ñ\82Ð¸Ð¿Ð° %<void *%> Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ð½Ðµ функцию"
  
  #: cp/typeck.c:620
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ forbids conditional expression between pointer of type %<void *%> and pointer-to-function"
-msgstr "ISO C++ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 %s Ð¼ÐµÐ¶Ð´Ñ\83 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ %<void *%> and Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ð½Ð° функцию"
+msgstr "ISO C++ Ð·Ð°Ð¿Ñ\80ÐµÑ\89Ð°ÐµÑ\82 Ñ\83Ñ\81Ð»Ð¾Ð²Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð¼ÐµÐ¶Ð´Ñ\83 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ñ\82Ð¸Ð¿Ð° %<void *%> Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ð½Ðµ функцию"
  
  #: cp/typeck.c:691
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "comparison between distinct pointer-to-member types %qT and %qT lacks a cast"
-msgstr "%s между разными указательными типами %qT и %qT: отсутствует приведение"
+msgstr "сравнение между различными pointer-to-member типами %qT и %qT без приведения типов"
  
  #: cp/typeck.c:696
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conversion between distinct pointer-to-member types %qT and %qT lacks a cast"
-msgstr "%s между разными указательными типами %qT и %qT: отсутствует приведение"
+msgstr "преобразование между различными pointer-to-member типами %qT и %qT без приведения типов"
  
  #: cp/typeck.c:701
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conditional expression between distinct pointer-to-member types %qT and %qT lacks a cast"
-msgstr "%s между разными указательными типами %qT и %qT: отсутствует приведение"
+msgstr "условное выражение между различными pointer-to-member типами %qT и %qT без приведения типов"
  
  #: cp/typeck.c:1427
  #, gcc-internal-format
  msgid "canonical types differ for identical types %T and %T"
-msgstr ""
+msgstr "канонические типы различаются для идентичных типов %T and %T"
  
  #: cp/typeck.c:1434
  #, gcc-internal-format
  msgid "same canonical type node for different types %T and %T"
-msgstr ""
+msgstr "общий узел канонического типа для различных типов %T и %T"
  
  #: cp/typeck.c:1562
  #, gcc-internal-format
@@ -47651,24 +49594,24 @@ msgid "invalid application of %qs to a member function"
  msgstr "некорректное применение %qs к элементу-функции"
  
  #: cp/typeck.c:1650
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid application of %<sizeof%> to a bit-field"
-msgstr "недопустимое применение %<sizeof%> к типу функции"
+msgstr "недопустимое применение %<sizeof%> к битовому полю"
  
  #: cp/typeck.c:1658
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ forbids applying %<sizeof%> to an expression of function type"
-msgstr "недопустимое применение %<sizeof%> к типу функции"
+msgstr "ISO C++ запрещает применение %<sizeof%> к выражению функционального типа"
  
  #: cp/typeck.c:1709
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid application of %<__alignof%> to a bit-field"
-msgstr "недопустимое применение %<sizeof%> к типу функции"
+msgstr "недопустимое применение %<__alignof%> к битовому полю"
  
  #: cp/typeck.c:1720
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ forbids applying %<__alignof%> to an expression of function type"
-msgstr "ISO C++ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ð²Ð·Ñ\8fÑ\82Ð¸Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð° Ð¾Ñ\82 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %<::main%>"
+msgstr "ISO C++ Ð·Ð°Ð¿Ñ\80ÐµÑ\89Ð°ÐµÑ\82 Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ %<__alignof%> Ðº Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8e Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¾Ð½Ð°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð°"
  
  #: cp/typeck.c:1836
  #, fuzzy, gcc-internal-format
@@ -47677,24 +49620,25 @@ msgid "invalid use of non-static member function of type %qT"
  msgstr "некорректное использование нестатической функции-элемента %qD"
  
  #: cp/typeck.c:2001
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "taking address of temporary array"
-msgstr "Ð°Ð´Ñ\80ÐµÑ\81 Ð¾Ñ\82 Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹"
+msgstr "Ð²Ð·Ñ\8fÑ\82Ð¸Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð° Ð¾Ñ\82 Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð³Ð¾ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð°"
  
  #: cp/typeck.c:2164
  #, fuzzy, gcc-internal-format
+#| msgid "deprecated conversion from string constant to %qT"
  msgid "ISO C++ forbids converting a string constant to %qT"
-msgstr "преобразование строковой константы к типу %qT не будет поддерживаться в будущих версиях компилятора"
+msgstr "устаревшее преобразование из строковой константы в %qT"
  
  #: cp/typeck.c:2168
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "deprecated conversion from string constant to %qT"
-msgstr "преобразование строковой константы к типу %qT не будет поддерживаться в будущих версиях компилятора"
+msgstr "устаревшее преобразование из строковой константы в %qT"
  
  #: cp/typeck.c:2302 cp/typeck.c:2703
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "request for member %qD in %qE, which is of pointer type %qT (maybe you meant to use %<->%> ?)"
-msgstr "запрос элемента %qD в %qE, имеющего не классовый тип %qT"
+msgstr "запрос на элемент %qD в %qE, который имеет указательный тип %qT (возможно вы хотели использовать %<->%> ?)"
  
  #: cp/typeck.c:2306 cp/typeck.c:2707
  #, gcc-internal-format
@@ -47702,19 +49646,20 @@ msgid "request for member %qD in %qE, which is of non-class type %qT"
  msgstr "запрос элемента %qD в %qE, имеющего не классовый тип %qT"
  
  #: cp/typeck.c:2337
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of nonstatic data member %qE"
-msgstr "некорректное использование нестатического элемента данных '%E'"
+msgstr "некорректное использование нестатического элемента данных %qE"
  
  #: cp/typeck.c:2396
  #, fuzzy, gcc-internal-format
+#| msgid "invalid access to non-static data member %qD  of NULL object"
  msgid "invalid access to non-static data member %qD in virtual base of NULL object"
-msgstr "некорректный доступ к нестатическому элементу данных %qD NULL-объекта"
+msgstr "некорректный доступ к нестатическому элементу данных %qD NULL объекта"
  
  #: cp/typeck.c:2545
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "object type %qT does not match destructor name ~%qT"
-msgstr "ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT Ð½Ðµ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¸Ð¼ÐµÐ½Ð¸ Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ð° `~%T'"
+msgstr "Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT Ð½Ðµ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¸Ð¼ÐµÐ½Ð¸ Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ð° ~%qT"
  
  #: cp/typeck.c:2554
  #, gcc-internal-format
@@ -47722,9 +49667,9 @@ msgid "the type being destroyed is %qT, but the destructor refers to %qT"
  msgstr "разрушаемый тип %qT, а деструктор относится к %qT"
  
  #: cp/typeck.c:2747 cp/typeck.c:2759
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<%D::%D%> is not a member of %qT"
-msgstr "`%D::%D' не является элементом %qT"
+msgstr "%<%D::%D%> не является элементом %qT"
  
  #: cp/typeck.c:2796
  #, gcc-internal-format
@@ -47754,19 +49699,19 @@ msgid "%qT is not a pointer-to-object type"
  msgstr "%qT не является типом указателя на объект"
  
  #: cp/typeck.c:3040
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of array indexing on pointer to member"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ %qs к указателю на элемент"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð½Ð´ÐµÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° к указателю на элемент"
  
  #: cp/typeck.c:3043
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of unary %<*%> on pointer to member"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ %qs к указателю на элемент"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\83Ð½Ð°Ñ\80Ð½Ð¾Ð¹ %<*%> к указателю на элемент"
  
  #: cp/typeck.c:3046
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of implicit conversion on pointer to member"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ %qs к указателю на элемент"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÑ\8fÐ²Ð½Ð¾Ð³Ð¾ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f к указателю на элемент"
  
  #: cp/typeck.c:3049
  #, gcc-internal-format
@@ -47811,9 +49756,9 @@ msgid "ISO C++ forbids calling %<::main%> from within program"
  msgstr "ISO C++ запрещает использование %<::main%> из программы"
  
  #: cp/typeck.c:3571
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "must use %<.*%> or %<->*%> to call pointer-to-member function in %<%E (...)%>, e.g. %<(... ->* %E) (...)%>"
-msgstr "необходимо использовать .* или ->* для вызова по указателю на элемент-функцию в `%E (...)'"
+msgstr "необходимо использовать %<.*%> или %<->*%> для вызова pointer-to-member функции в %<%E (...)%>, например %<(... ->* %E) (...)%>"
  
  #: cp/typeck.c:3588
  #, gcc-internal-format
@@ -47822,53 +49767,55 @@ msgstr "%qE нельзя использовать как функцию"
  
  #: cp/typeck.c:3591
  #, fuzzy, gcc-internal-format
+#| msgid "%qE cannot be used as a function"
  msgid "%qD cannot be used as a function"
  msgstr "%qE нельзя использовать как функцию"
  
  #: cp/typeck.c:3594
  #, fuzzy, gcc-internal-format
+#| msgid "%qE cannot be used as a function"
  msgid "expression cannot be used as a function"
  msgstr "%qE нельзя использовать как функцию"
  
  #: cp/typeck.c:3643
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too many arguments to constructor %q#D"
-msgstr "слишком много аргументов для %s `%+#D'"
+msgstr "слишком много аргументов для конструктора %q#D"
  
  #: cp/typeck.c:3644
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too few arguments to constructor %q#D"
-msgstr "слишком мало аргументов для %s `%+#D'"
+msgstr "слишком мало аргументов для конструктора %q#D"
  
  #: cp/typeck.c:3649
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too many arguments to member function %q#D"
-msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE"
+msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð´Ð»Ñ\8f Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð°-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q#D"
  
  #: cp/typeck.c:3650
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too few arguments to member function %q#D"
-msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð°Ð»Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE"
+msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð°Ð»Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð´Ð»Ñ\8f Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð°-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q#D"
  
  #: cp/typeck.c:3656
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too many arguments to function %q#D"
-msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE"
+msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q#D"
  
  #: cp/typeck.c:3657
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too few arguments to function %q#D"
-msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð°Ð»Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE"
+msgstr "Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð°Ð»Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %q#D"
  
  #: cp/typeck.c:3667
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too many arguments to method %q#D"
-msgstr "слишком много аргументов для %s `%+#D'"
+msgstr "слишком много аргументов для метода %q#D"
  
  #: cp/typeck.c:3668
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "too few arguments to method %q#D"
-msgstr "слишком мало аргументов для %s `%+#D'"
+msgstr "слишком мало аргументов для метода %q#D"
  
  #: cp/typeck.c:3671
  #, gcc-internal-format
@@ -47891,14 +49838,15 @@ msgid "parameter %P has incomplete type %qT"
  msgstr "параметр %P имеет неполный тип %qT"
  
  #: cp/typeck.c:3993
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "the address of %qD will never be NULL"
-msgstr "Ð°Ð´Ñ\80ÐµÑ\81 %qD Ð²Ñ\81ÐµÐ³Ð´Ð° Ð±Ñ\83Ð´ÐµÑ\82 %<Ð¸Ñ\81Ñ\82Ð¸Ð½Ð°%>"
+msgstr "Ð°Ð´Ñ\80ÐµÑ\81 %qD Ð½Ð¸ÐºÐ¾Ð³Ð´Ð° Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 NULL"
  
  #: cp/typeck.c:4004
  #, fuzzy, gcc-internal-format
+#| msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL"
  msgid "the compiler can assume that the address of %qD will never be NULL"
-msgstr "адрес %qD всегда будет %<истина%>"
+msgstr "результат сравнения всегда %<true%>, поскольку адрес %qD не может быть NULL"
  
  #: cp/typeck.c:4123 cp/typeck.c:4134
  #, gcc-internal-format
@@ -47911,24 +49859,24 @@ msgid "NULL used in arithmetic"
  msgstr "NULL в арифметическом выражении"
  
  #: cp/typeck.c:4503
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "left rotate count is negative"
-msgstr "%s величина сдвига для rotate отрицательная"
+msgstr "счетчик циклического сдвига влево отрицателен"
  
  #: cp/typeck.c:4504
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "right rotate count is negative"
-msgstr "%s величина сдвига для rotate отрицательная"
+msgstr "счетчик циклического сдвига вправо отрицателен"
  
  #: cp/typeck.c:4510
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "left rotate count >= width of type"
-msgstr "%s величина сдвига для rotate >= ширина типа"
+msgstr "счетчик циклического сдвига влево >= ширины типа"
  
  #: cp/typeck.c:4511
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "right rotate count >= width of type"
-msgstr "%s величина сдвига для rotate >= ширина типа"
+msgstr "счетчик циклического сдвига вправо >= ширины типа"
  
  #: cp/typeck.c:4582 cp/typeck.c:4590 cp/typeck.c:4869 cp/typeck.c:4877
  #, gcc-internal-format
@@ -47937,13 +49885,15 @@ msgstr "ISO C++ не поддерживает сравнение между ук
  
  #: cp/typeck.c:4792 cp/typeck.c:4804
  #, fuzzy, gcc-internal-format
+#| msgid "no type named %q#T in %q#T"
  msgid "operand types are %qT and %qT"
-msgstr "шаблон класса с именем %q#T' отсутствует в %q#T"
+msgstr "нет имени типа %q#T в %q#T"
  
  #: cp/typeck.c:4830
  #, fuzzy, gcc-internal-format
+#| msgid "could not find interface for class %qE"
  msgid "could not find an integer type of the same size as %qT"
-msgstr "нет файла для класса %s"
+msgstr "невозможно найти интерфейс для класса %qE"
  
  #: cp/typeck.c:4894
  #, gcc-internal-format
@@ -47951,9 +49901,9 @@ msgid "unordered comparison on non-floating point argument"
  msgstr "аргумент неупорядоченного сравнения - не плавающее значение"
  
  #: cp/typeck.c:4949
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid operands of types %qT and %qT to binary %qO"
-msgstr "некорректные операнды типов %qT и %qT для бинарной операции `%O'"
+msgstr "некорректные операнды типов %qT и %qT для бинарной операции %qO"
  
  #: cp/typeck.c:5249
  #, gcc-internal-format
@@ -47976,35 +49926,35 @@ msgid "invalid use of a pointer to an incomplete type in pointer arithmetic"
  msgstr "некорректное использование указателя на неполный тип в вычислениях с указателями"
  
  #: cp/typeck.c:5359
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "taking address of constructor %qE"
-msgstr "Ð°Ð´Ñ\80ÐµÑ\81 Ð¾Ñ\82 Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹"
+msgstr "Ð²Ð·Ñ\8fÑ\82Ð¸Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð° Ð¾Ñ\82 ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ð° %qE"
  
  #: cp/typeck.c:5360
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "taking address of destructor %qE"
-msgstr "Ð°Ð´Ñ\80ÐµÑ\81 Ð¾Ñ\82 Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹"
+msgstr "Ð²Ð·Ñ\8fÑ\82Ð¸Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð° Ð¾Ñ\82 Ð´ÐµÑ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ð° %qE"
  
  #: cp/typeck.c:5376
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of %qE to form a pointer-to-member-function"
-msgstr "некорректное использование '%E' для образования указателя на элемент-функцию. Используйте квалифицированный идентификатор."
+msgstr "некорректное использование %qE для образования указателя на элемент-функцию"
  
  #: cp/typeck.c:5379
  #, gcc-internal-format
  msgid "  a qualified-id is required"
-msgstr ""
+msgstr "  qualified-id требуется"
  
  #: cp/typeck.c:5386
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parentheses around %qE cannot be used to form a pointer-to-member-function"
-msgstr "нельзя использовать скобки вокруг '%E' для образования указателя на элемент-функцию."
+msgstr "нельзя использовать скобки вокруг %qE для образования указателя на элемент-функцию"
  
  #. An expression like &memfn.
  #: cp/typeck.c:5545
  #, gcc-internal-format
  msgid "ISO C++ forbids taking the address of an unqualified or parenthesized non-static member function to form a pointer to member function.  Say %<&%T::%D%>"
-msgstr "ISO C++ не поддерживает взятие адреса от неквалифицированного элемента-функцииили элемента в скобках для формирования указателя на элемент-функцию.Используйте синтаксис %<&%T::%D%>"
+msgstr "ISO C++ не поддерживает взятие адреса от неквалифицированного элемента-функции или элемента в скобках для формирования указателя на элемент-функцию.Используйте синтаксис %<&%T::%D%>"
  
  #: cp/typeck.c:5550
  #, gcc-internal-format
@@ -48018,9 +49968,9 @@ msgid "taking address of temporary"
  msgstr "адрес от временной переменной"
  
  #: cp/typeck.c:5589
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "taking address of xvalue (rvalue reference)"
-msgstr "Ð°Ð´Ñ\80ÐµÑ\81 Ð¾Ñ\82 Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹"
+msgstr "Ð²Ð·Ñ\8fÑ\82Ð¸Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð° Ð¾Ñ\82 xvalue (rvalue Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ°)"
  
  #: cp/typeck.c:5606
  #, gcc-internal-format
@@ -48030,7 +49980,7 @@ msgstr "ISO C++ не поддерживает взятие адреса от ф
  #: cp/typeck.c:5661
  #, gcc-internal-format
  msgid "ISO C++ forbids taking the address of a cast to a non-lvalue expression"
-msgstr "ISO C++  не поддерживает взятие адреса от приведения к не-lvalue-выражению"
+msgstr "ISO C++ не поддерживает взятие адреса от приведения к не-lvalue-выражению"
  
  #: cp/typeck.c:5689
  #, gcc-internal-format
@@ -48038,39 +49988,39 @@ msgid "cannot create pointer to reference member %qD"
  msgstr "нельзя создать указатель на элемент-ссылку %qD"
  
  #: cp/typeck.c:5967
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ forbids incrementing an enum"
-msgstr "ISO C++ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 %sÐ°Ñ\86Ð¸Ñ\8e Ð¿Ð¾ Ð¾Ñ\82Ð½Ð¾Ñ\88ÐµÐ½Ð¸Ñ\8e Ðº Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»Ð¸Ð¼Ð¾Ð¼Ñ\83 Ñ\82Ð¸Ð¿Ñ\83"
+msgstr "ISO C++ Ð·Ð°Ð¿Ñ\80ÐµÑ\89Ð°ÐµÑ\82 Ð¸Ð½ÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ enum"
  
  #: cp/typeck.c:5968
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ forbids decrementing an enum"
-msgstr "ISO C++ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 %sÐ°Ñ\86Ð¸Ñ\8e Ð¿Ð¾ Ð¾Ñ\82Ð½Ð¾Ñ\88ÐµÐ½Ð¸Ñ\8e Ðº Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»Ð¸Ð¼Ð¾Ð¼Ñ\83 Ñ\82Ð¸Ð¿Ñ\83"
+msgstr "ISO C++ Ð·Ð°Ð¿Ñ\80ÐµÑ\89Ð°ÐµÑ\82 Ð´ÐµÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ enum"
  
  #: cp/typeck.c:5984
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot increment a pointer to incomplete type %qT"
-msgstr "Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f %s указатель на неполный тип %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¸Ð½ÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c указатель на неполный тип %qT"
  
  #: cp/typeck.c:5985
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot decrement a pointer to incomplete type %qT"
-msgstr "Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f %s указатель на неполный тип %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c указатель на неполный тип %qT"
  
  #: cp/typeck.c:5996
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ forbids incrementing a pointer of type %qT"
-msgstr "ISO C++ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 %sÐ°Ñ\86Ð¸Ñ\8e Ð¿Ð¾ Ð¾Ñ\82Ð½Ð¾Ñ\88ÐµÐ½Ð¸Ñ\8e Ðº Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8e Ð½Ð° Ñ\82Ð¸Ð¿ %qT"
+msgstr "ISO C++ Ð·Ð°Ð¿Ñ\80ÐµÑ\89Ð°ÐµÑ\82 Ð¸Ð½ÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ñ\82Ð¸Ð¿Ð° %qT"
  
  #: cp/typeck.c:5997
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "ISO C++ forbids decrementing a pointer of type %qT"
-msgstr "ISO C++ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 %sÐ°Ñ\86Ð¸Ñ\8e Ð¿Ð¾ Ð¾Ñ\82Ð½Ð¾Ñ\88ÐµÐ½Ð¸Ñ\8e Ðº Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8e Ð½Ð° Ñ\82Ð¸Ð¿ %qT"
+msgstr "ISO C++ Ð·Ð°Ð¿Ñ\80ÐµÑ\89Ð°ÐµÑ\82 Ð´ÐµÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ñ\82Ð¸Ð¿Ð° %qT"
  
  #: cp/typeck.c:6032
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of Boolean expression as operand to %<operator--%>"
-msgstr "Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð·Ð°Ð´Ð°Ð½Ð¾ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Boolean Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f ÐºÐ°Ðº Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð° %<operator--%>"
  
  #: cp/typeck.c:6194
  #, gcc-internal-format
@@ -48078,34 +50028,34 @@ msgid "cannot take the address of %<this%>, which is an rvalue expression"
  msgstr "нельзя взять адрес от %<this%>, поскольку это rvalue-выражение"
  
  #: cp/typeck.c:6216
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "address of explicit register variable %qD requested"
-msgstr "Ð·Ð°Ð¿Ñ\80Ð¾Ñ\88ÐµÐ½ Ð°Ð´Ñ\80ÐµÑ\81 Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qs"
+msgstr "Ð·Ð°Ð¿Ñ\80Ð¾Ñ\88ÐµÐ½ Ð°Ð´Ñ\80ÐµÑ\81 Ñ\8fÐ²Ð½Ð¾Ð¹ Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²Ð¾Ð¹ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qD"
  
  #: cp/typeck.c:6221
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "address requested for %qD, which is declared %<register%>"
-msgstr "Ð²Ð·Ñ\8fÑ\82Ð¸Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð° Ð¾Ñ\82 %qD, Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»ÐµÐ½Ð½Ð¾Ð³Ð¾ ÐºÐ°Ðº `register'"
+msgstr "Ð·Ð°Ð¿Ñ\80Ð¾Ñ\88ÐµÐ½ Ð°Ð´Ñ\80ÐµÑ\81 Ð´Ð»Ñ\8f %qD, ÐºÐ¾Ñ\82Ð¾Ñ\80Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº %<register%>"
  
  #: cp/typeck.c:6302
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "list-initializer for non-class type must not be parenthesized"
-msgstr "инициализатор для %qT должен быт заключен в фигурные скобки"
+msgstr "list-initializer для неклассового типа не должен быть заключен в скобки"
  
  #: cp/typeck.c:6314
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expression list treated as compound expression in initializer"
-msgstr "%s - список выражений рассматривается как составное выражение"
+msgstr "список выражений рассматривается как составное выражение в инициализаторе"
  
  #: cp/typeck.c:6318
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expression list treated as compound expression in mem-initializer"
-msgstr "%s - список выражений рассматривается как составное выражение"
+msgstr "список выражений рассматривается как составное выражение в mem-initializer"
  
  #: cp/typeck.c:6322
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "expression list treated as compound expression in functional cast"
-msgstr "%s - список выражений рассматривается как составное выражение"
+msgstr "список выражений рассматривается как составное выражение в функциональном приведении типов"
  
  #: cp/typeck.c:6359
  #, gcc-internal-format, gfc-internal-format
@@ -48115,27 +50065,29 @@ msgstr "%s - список выражений рассматривается ка
  #: cp/typeck.c:6456
  #, gcc-internal-format
  msgid "no context to resolve type of %qE"
-msgstr ""
+msgstr "нет контекста для разрешения типа %qE"
  
  #: cp/typeck.c:6489
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cast from type %qT to type %qT casts away qualifiers"
-msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT Ð¾Ñ\82Ð¼ÐµÐ½Ñ\8fет квалификаторы"
+msgstr "Ð¿Ñ\80Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ðµ Ð¾Ñ\82 Ñ\82Ð¸Ð¿Ð° %qT Ðº Ñ\82Ð¸Ð¿Ñ\83 %qT Ð¾Ñ\82Ð±Ñ\80Ð°Ñ\81Ñ\8bÐ²Ð°ет квалификаторы"
  
  #: cp/typeck.c:6495
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "static_cast from type %qT to type %qT casts away qualifiers"
-msgstr "некорректное применение static_cast от типа %qT к типу %qT"
+msgstr "static_cast от типа %qT к типу %qT отбрасывает квалификаторы"
  
  #: cp/typeck.c:6501
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "reinterpret_cast from type %qT to type %qT casts away qualifiers"
-msgstr "некорректное применение static_cast от типа %qT к типу %qT"
+msgstr "reinterpret_cast от типа %qT к типу %qT отбрасывает квалификаторы"
  
+#
  #: cp/typeck.c:6524
  #, fuzzy, gcc-internal-format
+#| msgid "%qT uses local type %qT"
  msgid "useless cast to type %qT"
-msgstr "нелокальная функция %q#D использует локальный тип %qT"
+msgstr "%qT использует локальный тип %qT"
  
  #: cp/typeck.c:6895
  #, gcc-internal-format
@@ -48148,14 +50100,14 @@ msgid "converting from %qT to %qT"
  msgstr "преобразование из %qT в %qT"
  
  #: cp/typeck.c:6973
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid cast of an rvalue expression of type %qT to type %qT"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ reinterpret_cast Ð¾Ñ\82 rvalue-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f типа %qT к типу %qT"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ðµ rvalue Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ð¸Ð· типа %qT к типу %qT"
  
  #: cp/typeck.c:7043
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cast from %qT to %qT loses precision"
-msgstr "reinterpret_cast от %qT к %qT снижает точность"
+msgstr "приведение из типа %qT к типу %qT теряет точность"
  
  #: cp/typeck.c:7083
  #, gcc-internal-format
@@ -48169,9 +50121,9 @@ msgid "casting between pointer-to-function and pointer-to-object is conditionall
  msgstr "ISO C++ не поддерживает приведение типа указателя на функцию к указателю на объект"
  
  #: cp/typeck.c:7115
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid cast from type %qT to type %qT"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ const_cast Ð¾Ñ\82 типа %qT к типу %qT"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ðµ Ð¸Ð· типа %qT к типу %qT"
  
  #: cp/typeck.c:7176
  #, gcc-internal-format
@@ -48209,9 +50161,9 @@ msgid "  in evaluation of %<%Q(%#T, %#T)%>"
  msgstr "  в вычислении %<%Q(%#T, %#T)%>"
  
  #: cp/typeck.c:7738
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "assigning to an array from an initializer list"
-msgstr "Ð½ÐµÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÐ¹ Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ðµ"
+msgstr "Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ñ\83 Ð¸Ð· Ñ\81Ð¿Ð¸Ñ\81ÐºÐ° Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ð°"
  
  #: cp/typeck.c:7764
  #, gcc-internal-format
@@ -48219,14 +50171,14 @@ msgid "incompatible types in assignment of %qT to %qT"
  msgstr "несовместимые типы в присваивании %qT -> %qT"
  
  #: cp/typeck.c:7778
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "array used as initializer"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð°"
+msgstr "Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½ ÐºÐ°Ðº Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80"
  
  #: cp/typeck.c:7780
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid array assignment"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð»ÐµÐ²Ð°Ñ\8f Ñ\87Ð°Ñ\81Ñ\82Ñ\8c Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð°"
  
  #: cp/typeck.c:7910
  #, gcc-internal-format
@@ -48249,39 +50201,39 @@ msgid "invalid conversion to type %qT from type %qT"
  msgstr "некорректное преобразование к типу %qT от типа %qT"
  
  #: cp/typeck.c:8347
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot convert %qT to %qT for argument %qP to %qD"
-msgstr "ошибка преобразования %qT в %qT для аргумента `%P' функции %qD"
+msgstr "ошибка преобразования %qT в %qT для аргумента %qP функции %qD"
  
  #: cp/typeck.c:8353
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot convert %qT to %qT in default argument"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð´Ð»Ñ\8f Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° `%P' Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qD"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð² Ð¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ð¾Ð¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ"
  
  #: cp/typeck.c:8357
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot convert %qT to %qT in argument passing"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð² %s"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð¿Ñ\80Ð¸ Ð¿ÐµÑ\80ÐµÐ´Ð°Ñ\87Ðµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð²"
  
  #: cp/typeck.c:8361
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot convert %qT to %qT"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "ошибка преобразования %qT в %qT"
  
  #: cp/typeck.c:8365
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot convert %qT to %qT in initialization"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "ошибка преобразования %qT в %qT в инициализации"
  
  #: cp/typeck.c:8369
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot convert %qT to %qT in return"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð² %s"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð¿Ñ\80Ð¸ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ðµ"
  
  #: cp/typeck.c:8373
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot convert %qT to %qT in assignment"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "ошибка преобразования %qT в %qT в присваивании"
  
  #: cp/typeck.c:8386
  #, fuzzy, gcc-internal-format
@@ -48290,34 +50242,35 @@ msgid "class type %qT is incomplete"
  msgstr "тип результата %q#T неполный"
  
  #: cp/typeck.c:8404
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter %qP of %qD might be a candidate for a format attribute"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\83 %d %qE, Ð²ÐµÑ\80Ð¾Ñ\8fÑ\82Ð½Ð¾, Ð¼Ð¾Ð¶Ð½Ð¾ Ð½Ð°Ð·Ð½Ð°Ñ\87Ð¸Ñ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 format"
+msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %qP %qD Ð¼Ð¾Ð³ Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ°Ð½Ð´Ð¸Ð´Ð°Ñ\82Ð¾Ð¼ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
  
  #: cp/typeck.c:8408
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "parameter might be a candidate for a format attribute"
-msgstr "тип результата, вероятно, может быть задан с атрибутом format"
+msgstr "параметр мог быть кандидатом для атрибута формата"
  
  #: cp/typeck.c:8413
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "target of conversion might be a candidate for a format attribute"
-msgstr "Предупреждать о функциях, которым можно назначить атрибут format"
+msgstr "цель преобразования могла быть кандидатом для атрибута формата"
  
  #: cp/typeck.c:8418
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "target of initialization might be a candidate for a format attribute"
-msgstr "Предупреждать о функциях, которым можно назначить атрибут format"
+msgstr "цель инициализации могла быть кандидатом для атрибута формата"
  
  #: cp/typeck.c:8428
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "left-hand side of assignment might be a candidate for a format attribute"
-msgstr "Ð»ÐµÐ²Ð¾Ð¹ Ñ\87Ð°Ñ\81Ñ\82Ð¸ Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ñ\8f, Ð²ÐµÑ\80Ð¾Ñ\8fÑ\82Ð½Ð¾, Ð¼Ð¾Ð¶Ð½Ð¾ Ð½Ð°Ð·Ð½Ð°Ñ\87Ð¸Ñ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 format"
+msgstr "Ð»ÐµÐ²Ð°Ñ\8f Ñ\87Ð°Ñ\81Ñ\82Ñ\8c Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ñ\8f Ð¼Ð¾Ð³Ð»Ð° Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ°Ð½Ð´Ð¸Ð´Ð°Ñ\82Ð¾Ð¼ Ð´Ð»Ñ\8f Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
  
  #: cp/typeck.c:8523
  #, fuzzy, gcc-internal-format
+#| msgid "in passing argument %P of %q+D"
  msgid "in passing argument %P of %qD"
-msgstr "при передаче аргумента %P функции `%+D'"
+msgstr "при передаче аргумента %P функции %q+D"
  
  #: cp/typeck.c:8582
  #, gcc-internal-format
@@ -48373,18 +50326,20 @@ msgstr "return без значения в функции, возвращающе
  
  #: cp/typeck.c:8707
  #, fuzzy, gcc-internal-format
+#| msgid "<brace-enclosed initializer list>"
  msgid "returning initializer list"
-msgstr "фигурные скобки вокруг скалярного инициализатора"
+msgstr "<инициализатор в фигурных скобках>"
  
  #: cp/typeck.c:8726
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "inconsistent types %qT and %qT deduced for lambda return type"
-msgstr "Ð² Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¸Ð¸ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° Ð½ÐµÐ»Ñ\8cÐ·Ñ\8f Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»Ñ\8fÑ\82Ñ\8c Ð½Ð¾Ð²Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b"
+msgstr "Ð¿Ñ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ð²Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b %qT Ð¸ %qT Ð²Ñ\8bÐ²ÐµÐ´ÐµÐ½Ñ\8b Ð´Ð»Ñ\8f Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° lambda"
  
  #: cp/typeck.c:8729
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "inconsistent deduction for %qT: %qT and then %qT"
  msgid "inconsistent deduction for auto return type: %qT and then %qT"
-msgstr ""
+msgstr "противоречивый вывод для %qT: %qT и затем %qT"
  
  #: cp/typeck.c:8764
  #, gcc-internal-format
@@ -48400,12 +50355,12 @@ msgstr "%<operator new%> не должен возвращать NULL, если 
  #: cp/typeck.c:9403
  #, gcc-internal-format
  msgid "using temporary as lvalue"
-msgstr ""
+msgstr "использование временного как lvalue"
  
  #: cp/typeck.c:9405
  #, gcc-internal-format
  msgid "using xvalue (rvalue reference) as lvalue"
-msgstr ""
+msgstr "использование xvalue (rvalue ссылка) как lvalue"
  
  #: cp/typeck2.c:48
  #, gcc-internal-format
@@ -48413,85 +50368,86 @@ msgid "type %qT is not a base type for type %qT"
  msgstr "тип %qT не является базовым для типа %qT"
  
  #: cp/typeck2.c:103
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "assignment of constant field %qD"
-msgstr "Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qD, Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð¾Ð¹ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð½Ð° Ñ\87Ñ\82ÐµÐ½Ð¸Ðµ"
+msgstr "Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð³Ð¾ Ð¿Ð¾Ð»Ñ\8f %qD"
  
  #: cp/typeck2.c:105
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "constant field %qD used as %<asm%> output"
-msgstr "Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð½Ð°Ñ\8f Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð½Ð° Ñ\87Ñ\82ÐµÐ½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qD Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð° ÐºÐ°Ðº Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ %<asm%>"
+msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ðµ Ð¿Ð¾Ð»Ðµ %qD Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¾ ÐºÐ°Ðº %<asm%> Ð²Ñ\8bÐ²Ð¾Ð´"
  
  #: cp/typeck2.c:107
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "increment of constant field %qD"
-msgstr "инкрементация переменной %qD, доступной только на чтение"
+msgstr "инкремент константного поля %qD"
  
  #: cp/typeck2.c:109
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "decrement of constant field %qD"
-msgstr "декрементация переменной %qD, доступной только на чтение"
+msgstr "декремент константного поля %qD"
  
  #: cp/typeck2.c:116
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "assignment of read-only reference %qD"
-msgstr "присваивание элементу %qD, доступному только на чтение"
+msgstr "присваивание доступной только на чтение ссылки %qD"
  
  #: cp/typeck2.c:118
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "read-only reference %qD used as %<asm%> output"
-msgstr "доступный только на чтение элемент %qD использован как выходной операнд %<asm%>"
+msgstr "доступная только на чтение ссылка %qD использована как %<asm%> вывод"
  
  #: cp/typeck2.c:120
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "increment of read-only reference %qD"
-msgstr "инкрементация элемента %qD, доступного только на чтение"
+msgstr "инкремент доступной только на чтение ссылки %qD"
  
  #: cp/typeck2.c:122
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "decrement of read-only reference %qD"
-msgstr "декрементация элемента %qD, доступного только на чтение"
+msgstr "декремент доступной только на чтение ссылки %qD"
  
  #: cp/typeck2.c:320
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot declare variable %q+D to be of abstract type %qT"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %qD Ñ\81 типом %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\83Ñ\8e %q+D Ñ\81 Ð°Ð±Ñ\81Ñ\82Ñ\80Ð°ÐºÑ\82Ð½Ñ\8bÐ¼ типом %qT"
  
  #: cp/typeck2.c:325
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot declare parameter %q+D to be of abstract type %qT"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %qD Ñ\81 типом %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %q+D Ñ\81 Ð°Ð±Ñ\81Ñ\82Ñ\80Ð°ÐºÑ\82Ð½Ñ\8bÐ¼ типом %qT"
  
  #: cp/typeck2.c:328
  #, fuzzy, gcc-internal-format
+#| msgid "cannot declare parameter %q+D to be of abstract type %qT"
  msgid "cannot declare parameter to be of abstract type %qT"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %qD Ñ\81 типом %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %q+D Ñ\81 Ð°Ð±Ñ\81Ñ\82Ñ\80Ð°ÐºÑ\82Ð½Ñ\8bÐ¼ типом %qT"
  
  #: cp/typeck2.c:332
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot declare field %q+D to be of abstract type %qT"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð¾Ð»Ñ\8f %qD Ñ\81 типом %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð¾Ð»Ðµ %q+D Ñ\81 Ð°Ð±Ñ\81Ñ\82Ñ\80Ð°ÐºÑ\82Ð½Ñ\8bÐ¼ типом %qT"
  
  #: cp/typeck2.c:336
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid abstract return type for member function %q+#D"
-msgstr "некорректный тип результата для элемента-функции `%#D'"
+msgstr "некорректный абстрактный тип результата для элемента-функции %q+#D"
  
  #: cp/typeck2.c:338
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid abstract return type for function %q+#D"
-msgstr "некорректный тип результата для функции `%#D'"
+msgstr "некорректный абстрактный тип результата для функции %q+#D"
  
  #. Here we do not have location information.
  #: cp/typeck2.c:341
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid abstract type %qT for %qE"
-msgstr "некорректный тип параметра %qT"
+msgstr "некорректный абстрактный тип %qT для %qE"
  
  #: cp/typeck2.c:343
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid abstract type for %q+D"
-msgstr "некорректный тип параметра %qT"
+msgstr "некорректный абстрактный тип для %q+D"
  
  #: cp/typeck2.c:348
  #, gcc-internal-format
@@ -48506,8 +50462,9 @@ msgstr "некорректное приведение к типу функции
  
  #: cp/typeck2.c:354
  #, fuzzy, gcc-internal-format
+#| msgid "invalid cast of an rvalue expression of type %qT to type %qT"
  msgid "invalid new-expression of abstract class type %qT"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ reinterpret_cast Ð¾Ñ\82 rvalue-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f типа %qT к типу %qT"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ðµ rvalue Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ð¸Ð· типа %qT к типу %qT"
  
  #: cp/typeck2.c:357
  #, fuzzy, gcc-internal-format
@@ -48529,18 +50486,19 @@ msgstr "выражение %qE, имеющее тип абстрактного 
  
  #: cp/typeck2.c:367
  #, fuzzy, gcc-internal-format
+#| msgid "cannot declare parameter %q+D to be of abstract type %qT"
  msgid "cannot declare catch parameter to be of abstract class type %qT"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° %qD Ñ\81 типом %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %q+D Ñ\81 Ð°Ð±Ñ\81Ñ\82Ñ\80Ð°ÐºÑ\82Ð½Ñ\8bÐ¼ типом %qT"
  
  #: cp/typeck2.c:371
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot allocate an object of abstract type %qT"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80Ð¸ Ð²Ñ\8bÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸ Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸ Ð¿Ð¾Ð´ Ð¾Ð±Ñ\8aÐµÐºÑ\82 Ñ\82Ð¸Ð¿Ð° %qT,"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\81Ñ\82Ð¸Ñ\82Ñ\8c Ð¾Ð±Ñ\8aÐµÐºÑ\82 Ð°Ð±Ñ\81Ñ\82Ñ\80Ð°ÐºÑ\82Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
  
  #: cp/typeck2.c:381
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "  because the following virtual functions are pure within %qT:"
-msgstr "  поскольку следующие виртуальные функции являются абстрактными:"
+msgstr "  поскольку следующие виртуальные функции являются чистыми в пределах %qT:"
  
  #: cp/typeck2.c:387
  #, gcc-internal-format
@@ -48555,73 +50513,78 @@ msgstr "определение %qD вне пространства имён, о
  
  #: cp/typeck2.c:443
  #, fuzzy, gcc-internal-format
+#| msgid "forward declaration of %q+#T"
  msgid "forward declaration of %q#T"
-msgstr "декларация `%#D'"
+msgstr "forward декларация %q+#T"
  
  #: cp/typeck2.c:445
  #, fuzzy, gcc-internal-format
+#| msgid "declaration of %q+#T"
  msgid "declaration of %q#T"
-msgstr "декларация `%#D'"
+msgstr "декларация %q+#T"
  
  #: cp/typeck2.c:472
  #, fuzzy, gcc-internal-format
+#| msgid "%q#D has incomplete type"
  msgid "%qD has incomplete type"
-msgstr "%qD имеет неполный тип"
+msgstr "%q#D имеет неполный тип"
  
  #: cp/typeck2.c:487
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of incomplete type %q#T"
-msgstr "Ð½ÐµÐ¿Ñ\80Ð°Ð²Ð¸Ð»Ñ\8cÐ½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÐ´Ð¾Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð¾Ð³Ð¾ typedef %qD"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÐ¿Ð¾Ð»Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %q#T"
  
  #: cp/typeck2.c:495
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of %qT"
-msgstr "некорректное использование %qD"
+msgstr "некорректное использование %qT"
  
  #: cp/typeck2.c:517
  #, fuzzy, gcc-internal-format
+#| msgid "invalid use of member function (did you forget the %<()%> ?)"
  msgid "invalid use of member function %qD (did you forget the %<()%> ?)"
-msgstr "некорректное использование нестатической функции-элемента %qD"
+msgstr "некорректное использование функции-элемента (вы забыли %<()%> ?)"
  
  #: cp/typeck2.c:521
  #, fuzzy, gcc-internal-format
+#| msgid "invalid use of member (did you forget the %<&%> ?)"
  msgid "invalid use of member %qD (did you forget the %<&%> ?)"
-msgstr "некорректное использование нестатической функции-элемента %qD"
+msgstr "некорректное использование элемента (вы забыли %<()%> ?)"
  
  #: cp/typeck2.c:532
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of template type parameter %qT"
-msgstr "Ð½ÐµÐ¿Ñ\80Ð°Ð²Ð¸Ð»Ñ\8cÐ½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÐ´Ð¾Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð¾Ð³Ð¾ typedef %qD"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° Ñ\82Ð¸Ð¿Ð° %qT"
  
  #: cp/typeck2.c:537
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of template template parameter %qT"
-msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° `%#D'"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qT"
  
  #: cp/typeck2.c:543
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of dependent type %qT"
-msgstr "Ð½ÐµÐ¿Ñ\80Ð°Ð²Ð¸Ð»Ñ\8cÐ½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð½ÐµÐ´Ð¾Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð¾Ð³Ð¾ typedef %qD"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð·Ð°Ð²Ð¸Ñ\81Ð¸Ð¼Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° %qT"
  
  #: cp/typeck2.c:550
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid use of brace-enclosed initializer list"
-msgstr "фигурные скобки вокруг скалярного инициализатора"
+msgstr "некорректное использование списка инициализатора в фигурных скобках"
  
  #: cp/typeck2.c:558
  #, gcc-internal-format
  msgid "address of overloaded function with no contextual type information"
-msgstr ""
+msgstr "адрес перегруженной функции без контекстной информации о типе"
  
  #: cp/typeck2.c:562
  #, gcc-internal-format
  msgid "overloaded function with no contextual type information"
-msgstr ""
+msgstr "перегруженная функция без контекстной информации о типе"
  
  #: cp/typeck2.c:565
  #, gcc-internal-format
  msgid "insufficient contextual information to determine type"
-msgstr ""
+msgstr "недостаточно контекстной информации для определения типа"
  
  #: cp/typeck2.c:785
  #, gcc-internal-format
@@ -48629,19 +50592,20 @@ msgid "constructor syntax used, but no constructor declared for type %qT"
  msgstr "использован синтаксис конструктора для типа %qT, который не имеет конструкторов"
  
  #: cp/typeck2.c:945
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "narrowing conversion of %qE from %qT to %qT inside { } is ill-formed in C++11"
-msgstr "преобразование %qE из %qT в %qT неоднозначно"
+msgstr "сужающее преобразование %qE из %qT в %qT внутри { } считается неверно оформленным в C++11"
  
  #: cp/typeck2.c:955 cp/typeck2.c:968
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "narrowing conversion of %qE from %qT to %qT inside { }"
-msgstr "преобразование %qE из %qT в %qT неоднозначно"
+msgstr "сужающее преобразование %qE из %qT в %qT внутри { }"
  
  #: cp/typeck2.c:958
  #, fuzzy, gcc-internal-format
+#| msgid "expression in static assertion is not an integer constant expression"
  msgid " the expression has a constant value but is not a C++ constant-expression"
-msgstr "размер массива не является целочисленным константным выражением"
+msgstr "выражение в статическом утверждении не является целочисленным константным выражением"
  
  #: cp/typeck2.c:1044
  #, gcc-internal-format
@@ -48649,9 +50613,9 @@ msgid "int-array initialized from non-wide string"
  msgstr "инициализация массива int строкой не широких символов"
  
  #: cp/typeck2.c:1050
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "int-array initialized from incompatible wide string"
-msgstr "инициализация массива int строкой не широких символов"
+msgstr "инициализация массива int строкой несовместимой ширины"
  
  #: cp/typeck2.c:1071
  #, gcc-internal-format
@@ -48661,12 +50625,12 @@ msgstr "слишком длинная строка инициализации д
  #: cp/typeck2.c:1124
  #, gcc-internal-format
  msgid "cannot initialize aggregate of type %qT with a compound literal"
-msgstr ""
+msgstr "невозможно инициализировать агрегат типа %qT составным литералом"
  
  #: cp/typeck2.c:1142
  #, gcc-internal-format
  msgid "array must be initialized with a brace-enclosed initializer"
-msgstr ""
+msgstr "массив должен быть инициализирован инициализатором в фигурных скобках"
  
  #: cp/typeck2.c:1425 cp/typeck2.c:1452
  #, gcc-internal-format
@@ -48685,9 +50649,9 @@ msgid "member %qD with uninitialized reference fields"
  msgstr "элемент %qD - неинициализированная ссылка"
  
  #: cp/typeck2.c:1543
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no field %qD found in union being initialized"
-msgstr "Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ñ\83ÐµÐ¼Ð¾Ð¼ Ð¾Ð±Ñ\8aÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ð¸ Ð½ÐµÑ\82 Ð¿Ð¾Ð»Ñ\8f %qD"
+msgstr "Ð¿Ð¾Ð»Ðµ %qD Ð½Ðµ Ð½Ð°Ð¹Ð´ÐµÐ½Ð¾ Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ñ\83ÐµÐ¼Ð¾Ð¼ Ð¾Ð±Ñ\8aÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ð¸"
  
  #: cp/typeck2.c:1554
  #, gcc-internal-format
@@ -48700,9 +50664,9 @@ msgid "circular pointer delegation detected"
  msgstr "обнаружено циклическое делегирование указателей"
  
  #: cp/typeck2.c:1750
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "base operand of %<->%> has non-pointer type %qT"
-msgstr "базовый операнд `->' имеет неуказательный тип %qT"
+msgstr "базовый операнд %<->%> имеет неуказательный тип %qT"
  
  #: cp/typeck2.c:1776
  #, gcc-internal-format
@@ -48720,14 +50684,14 @@ msgid "%qE cannot be used as a member pointer, since it is of type %qT"
  msgstr "%qE не может использоваться как элемент, поскольку имеет тип %qT"
  
  #: cp/typeck2.c:1814
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot apply member pointer %qE to %qE, which is of non-class type %qT"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ð²Ð·Ñ\8fÑ\82Ð¸Ðµ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° %qE Ð¾Ñ\82 %qE, ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐ¹ Ð¸Ð¼ÐµÐµÑ\82 Ð½ÐµÐ°Ð³Ñ\80ÐµÐ³Ð°Ñ\82Ð½ый тип %qT"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿Ñ\80Ð¸Ð¼ÐµÐ½Ð¸Ñ\82Ñ\8c Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð½Ñ\8bÐ¹ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c %qE Ðº %qE, ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐ¹ Ð¸Ð¼ÐµÐµÑ\82 Ð½ÐµÐºÐ»Ð°Ñ\81Ñ\81Ð¾Ð²ый тип %qT"
  
  #: cp/typeck2.c:1836
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "pointer to member type %qT incompatible with object type %qT"
-msgstr "Ñ\82Ð¸Ð¿ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° `%T::' Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 Ñ\82Ð¸Ð¿Ð¾Ð¼ Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð° %qT"
+msgstr "Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð½Ñ\8bÐ¼ Ñ\82Ð¸Ð¿Ð¾Ð¼ %qT"
  
  #: cp/typeck2.c:1895
  #, fuzzy, gcc-internal-format
@@ -48742,24 +50706,24 @@ msgid "pointer-to-member-function type %qT requires an lvalue"
  msgstr "в арифметическом выражении использован указатель на элемент-функцию"
  
  #: cp/typeck2.c:1943
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "functional cast to array type %qT"
-msgstr "некорректное приведение к типу функции %qT"
+msgstr "функциональное приведение к массивному типу %qT"
  
  #: cp/typeck2.c:1964
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid value-initialization of reference type"
-msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f `%#D', Ð¸Ð¼ÐµÑ\8eÑ\89ÐµÐ³Ð¾ Ñ\82Ð¸Ð¿ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ñ\87Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð°"
  
  #: cp/typeck2.c:2191
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "call to function %qD which throws incomplete type %q#T"
-msgstr "вызов функции %qD, которая вызывает исключение неполного типа `%#T'"
+msgstr "вызов функции %qD, которая вызывает исключение неполного типа %q#T"
  
  #: cp/typeck2.c:2194
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "call to function which throws incomplete type %q#T"
-msgstr "вызов функции, которая вызывает исключение неполного типа `%#T'"
+msgstr "вызов функции, которая вызывает исключение неполного типа %q#T"
  
  #: cp/vtable-class-hierarchy.c:719
  #, gcc-internal-format
@@ -48779,12 +50743,13 @@ msgstr ""
  #: fortran/arith.c:45
  #, gcc-internal-format, gfc-internal-format
  msgid "Conversion of an Infinity or Not-a-Number at %L to INTEGER"
-msgstr ""
+msgstr "Преобразование бесконечности или нечисла в %L к INTEGER"
  
  #: fortran/arith.c:117 fortran/arith.c:1965
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "gfc_arith_error(): Bad error code"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: fortran/arith.c:150
  #, gcc-internal-format
@@ -48792,9 +50757,10 @@ msgid "Fix min_int calculation"
  msgstr ""
  
  #: fortran/arith.c:530
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "gfc_range_check(): Bad type"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: fortran/arith.c:603
  #, gcc-internal-format
@@ -48833,13 +50799,14 @@ msgstr ""
  
  #: fortran/arith.c:924 fortran/arith.c:949
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: Noninteger exponent in an initialization expression at %L"
  msgid "Noninteger exponent in an initialization expression at %L"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Fortran 2003: Нецелый показатель степени в инициализационном выражении в %L"
  
  #: fortran/arith.c:935
  #, gcc-internal-format, gfc-internal-format
  msgid "Raising a negative REAL at %L to a REAL power is prohibited"
-msgstr ""
+msgstr "Возведение отрицательного REAL в %L в REAL степень запрещено"
  
  #: fortran/arith.c:963
  #, fuzzy, gcc-internal-format
@@ -48849,8 +50816,9 @@ msgstr "ia64_print_operand: некорректный код"
  
  #: fortran/arith.c:1029
  #, fuzzy, gcc-internal-format
+#| msgid "Bad operator"
  msgid "compare_real(): Bad operator"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80"
  
  #: fortran/arith.c:1064
  #, gcc-internal-format
@@ -48870,37 +50838,40 @@ msgstr ""
  #: fortran/arith.c:1933
  #, gcc-internal-format, gfc-internal-format
  msgid "Arithmetic OK converting %s to %s at %L"
-msgstr ""
+msgstr "Арифметическое OK при преобразовании %s в %s в %L"
  
  #: fortran/arith.c:1937
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Arithmetic overflow converting %s to %s at %L. This check can be disabled with the option -fno-range-check"
  msgid "Arithmetic overflow converting %s to %s at %L. This check can be disabled with the option %<-fno-range-check%>"
-msgstr ""
+msgstr "Арифметическое переполнение при преобразовании %s в %s в %L. Эта проверка может быть выключена опцией -fno-range-check"
  
  #: fortran/arith.c:1942
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Arithmetic underflow converting %s to %s at %L. This check can be disabled with the option -fno-range-check"
  msgid "Arithmetic underflow converting %s to %s at %L. This check can be disabled with the option %<-fno-range-check%>"
-msgstr ""
+msgstr "Арифметическая потеря значимости при преобразовании %s в %s в %L. Эта проверка может быть выключена опцией -fno-range-check"
  
  #: fortran/arith.c:1947
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Arithmetic NaN converting %s to %s at %L. This check can be disabled with the option -fno-range-check"
  msgid "Arithmetic NaN converting %s to %s at %L. This check can be disabled with the option %<-fno-range-check%>"
-msgstr ""
+msgstr "Арифметическое NaN при преобразовании %s в %s в %L. Эта проверка может быть выключена опцией -fno-range-check"
  
  #: fortran/arith.c:1952
  #, gcc-internal-format, gfc-internal-format
  msgid "Division by zero converting %s to %s at %L"
-msgstr ""
+msgstr "Деление на ноль при преобразовании %s в %s в %L"
  
  #: fortran/arith.c:1956
  #, gcc-internal-format, gfc-internal-format
  msgid "Array operands are incommensurate converting %s to %s at %L"
-msgstr ""
+msgstr "Массивные операнды несоразмерны при преобразовании %s в %s в %L"
  
  #: fortran/arith.c:1960
  #, gcc-internal-format, gfc-internal-format
  msgid "Integer outside symmetric range implied by Standard Fortran converting %s to %s at %L"
-msgstr ""
+msgstr "Целое вне симметричного диапазона предписанного Standard Fortran при преобразовании %s в %s в %L"
  
  #: fortran/arith.c:2046 fortran/arith.c:2155 fortran/arith.c:2215
  #: fortran/arith.c:2267 fortran/arith.c:2327 fortran/arith.c:2396
@@ -48908,117 +50879,126 @@ msgstr ""
  #, fuzzy, gcc-internal-format
  #| msgid "Conversion from %s to %s at %L"
  msgid "Conversion from %qs to %qs at %L"
-msgstr "Ð¿реобразование из %s в %s в %L"
+msgstr "Ð\9fреобразование из %s в %s в %L"
  
  #: fortran/arith.c:2075 fortran/arith.c:2108 fortran/arith.c:2147
  #: fortran/arith.c:2205 fortran/arith.c:2257 fortran/arith.c:2317
  #: fortran/arith.c:2386
  #, fuzzy, gcc-internal-format
+#| msgid "Change of value in conversion from  %s to %s at %L"
  msgid "Change of value in conversion from %qs to %qs at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT"
+msgstr "Ð\98Ð·Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ð² Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ð¸Ð· %s Ð² %s Ð² %L"
  
  #: fortran/arith.c:2303 fortran/arith.c:2372
  #, fuzzy, gcc-internal-format
+#| msgid "Possible change of value in conversion from %s to %s at %L"
  msgid "Non-zero imaginary part discarded in conversion from %qs to %qs at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT"
+msgstr "Ð\92Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ðµ Ð¸Ð·Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ð² Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ð¸Ð· %s Ð² %s Ð² %L"
  
  #: fortran/arith.c:2455
  #, fuzzy, gcc-internal-format
+#| msgid "Change of value in conversion from  %s to %s at %L"
  msgid "Change of value in conversion from  %qs to %qs at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT"
+msgstr "Ð\98Ð·Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ð² Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ð¸Ð· %s Ð² %s Ð² %L"
  
  #: fortran/arith.c:2528
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The Hollerith constant at %L is too long to convert to %s"
  msgid "The Hollerith constant at %L is too long to convert to %qs"
-msgstr ""
+msgstr "Hollerith константа в %L слишком длинна для преобразования в %s"
  
  #: fortran/array.c:95
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected array subscript at %C"
-msgstr ""
+msgstr "Ожидался индекс массива в %C"
  
  #: fortran/array.c:104
  #, fuzzy, gcc-internal-format
+#| msgid "Unexpected '*' in coarray subscript at %C"
  msgid "Unexpected %<*%> in coarray subscript at %C"
-msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð¾Ðµ Ð¾ÐºÐ¾Ð½Ñ\87Ð°Ð½Ð¸Ðµ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð°Ñ\8f '*' Ð² Ð¸Ð½Ð´ÐµÐºÑ\81Ðµ ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %C"
  
  #: fortran/array.c:128
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Strides not allowed in coarray subscript at %C"
-msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½ Ð² Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ð½Ð¾Ð¹ ÐµÐ´Ð¸Ð½Ð¸Ñ\86Ðµ BLOCK DATA Ð² %1"
+msgstr "Ð¨Ð°Ð³ Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f Ð² Ð¸Ð½Ð´ÐµÐºÑ\81Ðµ ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %C"
  
  #: fortran/array.c:136
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected array subscript stride at %C"
-msgstr ""
+msgstr "Ожидался шаг в индексе комассива в %C"
  
  #: fortran/array.c:193
  #, gcc-internal-format, gfc-internal-format
  msgid "Invalid form of array reference at %C"
-msgstr ""
+msgstr "Некорректная форма ссылки на массив в %C"
  
  #: fortran/array.c:198 fortran/array.c:271
  #, gcc-internal-format, gfc-internal-format
  msgid "Array reference at %C cannot have more than %d dimensions"
-msgstr ""
+msgstr "Ссылка на массив в %C не может иметь больше чем %d измерений"
  
  #: fortran/array.c:213 fortran/array.c:625 fortran/check.c:2642
  #: fortran/check.c:4950 fortran/check.c:4988 fortran/check.c:5030
  #: fortran/check.c:5229 fortran/match.c:1680 fortran/match.c:2787
  #: fortran/match.c:2982 fortran/match.c:3178 fortran/simplify.c:4733
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Coarrays disabled at %C, use -fcoarray= to enable"
  msgid "Coarrays disabled at %C, use %<-fcoarray=%> to enable"
-msgstr ""
+msgstr "Комассивы выключены в %C, используйте -fcoarray= для включения"
  
  #: fortran/array.c:219
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected coarray designator at %C"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85, Ð²Ñ\81Ñ\82Ñ\80ÐµÑ\82Ð¸Ð²Ñ\88Ð¸Ñ\85Ñ\81Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð²"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð¾Ðµ Ð¾Ð±Ð¾Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %C"
  
  #: fortran/array.c:234
  #, gcc-internal-format, gfc-internal-format
  msgid "Too few codimensions at %C, expected %d not %d"
-msgstr ""
+msgstr "Слишком мало коизмерений в %C, ожидалось %d а не %d"
  
  #: fortran/array.c:240
  #, gcc-internal-format, gfc-internal-format
  msgid "Too many codimensions at %C, expected %d not %d"
-msgstr ""
+msgstr "Слишком много коизмерений в %C, ожидалось %d а не %d"
  
  #: fortran/array.c:250 fortran/array.c:258
  #, fuzzy, gcc-internal-format
+#| msgid "Unexpected '*' for codimension %d of %d at %C"
  msgid "Unexpected %<*%> for codimension %d of %d at %C"
-msgstr "Ð\9eÐ¶Ð¸Ð´Ð°ÐµÑ\82Ñ\81Ñ\8f Ð´Ñ\80Ñ\83Ð³Ð°Ñ\8f Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð½Ð¾Ñ\81Ñ\82Ñ\8c Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸ %C"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð°Ñ\8f '*' Ð´Ð»Ñ\8f ÐºÐ¾Ð¸Ð·Ð¼ÐµÑ\80ÐµÐ½Ð¸Ñ\8f %d Ð¸Ð· %d Ð² %C"
  
  #: fortran/array.c:253
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid form of coarray reference at %C"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %s"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\84Ð¾Ñ\80Ð¼Ð° Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ Ð½Ð° ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² %C"
  
  #: fortran/array.c:265
  #, gcc-internal-format, gfc-internal-format
  msgid "Invalid codimension %d at %C, only %d codimensions exist"
-msgstr ""
+msgstr "Некорректное коизмерение %d в %C, только %d коизмерений существует"
  
  #: fortran/array.c:317
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L in this context must be constant"
  msgid "Variable %qs at %L in this context must be constant"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %qD Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f константой"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f '%s' Ð² %L Ð² Ñ\8dÑ\82Ð¾Ð¼ ÐºÐ¾Ð½Ñ\82ÐµÐºÑ\81Ñ\82Ðµ Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c константой"
  
  #: fortran/array.c:320
  #, gcc-internal-format, gfc-internal-format
  msgid "Expression at %L in this context must be constant"
-msgstr ""
+msgstr "Выражение в %L в этом контексте должна быть константой"
  
  #: fortran/array.c:418
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected expression in array specification at %C"
-msgstr ""
+msgstr "Ожидалось выражение в спецификации массива в %C"
  
  #: fortran/array.c:431 fortran/array.c:463
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Expected scalar initialization expression at %C"
  msgid "Expecting a scalar INTEGER expression at %C, found %s"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80Ð½Ð¾Ðµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¾Ð½Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² %C"
  
  #: fortran/array.c:500
  #, gcc-internal-format, gfc-internal-format
@@ -49026,29 +51006,29 @@ msgid "Assumed-rank array at %C"
  msgstr ""
  
  #: fortran/array.c:534
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Bad array specification for implied-shape array at %C"
-msgstr "Нет определения метки для оператора FORMAT в %0"
+msgstr "Некорректная спецификация массива для неявно оформленного массива в %C"
  
  #: fortran/array.c:550 fortran/array.c:663
  #, gcc-internal-format, gfc-internal-format
  msgid "Bad array specification for an explicitly shaped array at %C"
-msgstr ""
+msgstr "Некорректная спецификация массива для явно оформленного массива в %C"
  
  #: fortran/array.c:560 fortran/array.c:673
  #, gcc-internal-format, gfc-internal-format
  msgid "Bad array specification for assumed shape array at %C"
-msgstr ""
+msgstr "Некорректная спецификация массива для массива предполагаемой формы в %C"
  
  #: fortran/array.c:574 fortran/array.c:687
  #, gcc-internal-format, gfc-internal-format
  msgid "Bad specification for deferred shape array at %C"
-msgstr ""
+msgstr "Некорректная спецификация для массива отложенной формы в %C"
  
  #: fortran/array.c:584 fortran/array.c:691
  #, gcc-internal-format, gfc-internal-format
  msgid "Bad specification for assumed size array at %C"
-msgstr ""
+msgstr "Некорректная спецификация для массива предполагаемого размера в %C"
  
  #: fortran/array.c:596 fortran/array.c:703
  #, gcc-internal-format, gfc-internal-format
@@ -49058,27 +51038,31 @@ msgstr "Ожидается другая размерность массива в
  #: fortran/array.c:602 fortran/array.c:631 fortran/array.c:709
  #, gcc-internal-format, gfc-internal-format
  msgid "Array specification at %C has more than %d dimensions"
-msgstr ""
+msgstr "Спецификация массива в %C имеет больше чем %d измерений"
  
  #: fortran/array.c:608
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Array specification at %C has more than %d dimensions"
  msgid "Array specification at %C with more than 7 dimensions"
-msgstr ""
+msgstr "Спецификация массива в %C имеет больше чем %d измерений"
  
  #: fortran/array.c:620
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: Coarray declaration at %C"
  msgid "Coarray declaration at %C"
-msgstr "Ожидается другая размерность массива в определении %C"
+msgstr "Fortran 2008: Декларация комассива в %C"
  
  #: fortran/array.c:717
  #, fuzzy, gcc-internal-format
+#| msgid "Upper bound of last coarray dimension must be '*' at %C"
  msgid "Upper bound of last coarray dimension must be %<*%> at %C"
-msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð½Ð¾Ñ\81Ñ\82Ð¸ %d Ð²Ñ\8bÑ\85Ð¾Ð´Ð¸Ñ\82 Ð·Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ñ\8b Ð² %L"
+msgstr "Ð\92ÐµÑ\80Ñ\85Ð½Ñ\8fÑ\8f Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ð° Ð¿Ð¾Ñ\81Ð»ÐµÐ´Ð½ÐµÐ³Ð¾ Ð¸Ð·Ð¼ÐµÑ\80ÐµÐ½Ð¸Ñ\8f ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c '*' Ð² %C"
  
  #: fortran/array.c:785
  #, fuzzy, gcc-internal-format
+#| msgid "Data target at %L shall not have a coindex"
  msgid "The assumed-rank array %qs at %L shall not have a codimension"
-msgstr "стандартные преобразования в данном контексте недопустимы"
+msgstr "Целевые данные в %L не должны иметь коиндекс"
  
  #: fortran/array.c:869
  #, gcc-internal-format
@@ -49086,34 +51070,37 @@ msgid "gfc_compare_array_spec(): Array spec clobbered"
  msgstr ""
  
  #: fortran/array.c:945
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "DO-iterator '%s' at %L is inside iterator of the same name"
  msgid "DO-iterator %qs at %L is inside iterator of the same name"
-msgstr ""
+msgstr "DO-iterator '%s' в %L находится внутри итератора с тем же именем"
  
  #: fortran/array.c:1037 fortran/array.c:1217
  #, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in array constructor at %C"
-msgstr ""
+msgstr "Синтаксическая ошибка в конструкторе массива в %C"
  
  #: fortran/array.c:1090
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: [...] style array constructors at %C"
  msgid "[...] style array constructors at %C"
-msgstr ""
+msgstr "Fortran 2003: [...] стиль конструкторов массива в %C"
  
  #: fortran/array.c:1113
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: Array constructor including type specification at %C"
  msgid "Array constructor including type specification at %C"
-msgstr "Спецификация нулевого размера в %0 некорректна"
+msgstr "Fortran 2003: Конструктор массива включающий спецификацию типа в %C"
  
  #: fortran/array.c:1122 fortran/match.c:3608
  #, gcc-internal-format, gfc-internal-format
  msgid "Type-spec at %L cannot contain a deferred type parameter"
-msgstr ""
+msgstr "Type-spec в %L не может содержать параметр отложенного типа"
  
  #: fortran/array.c:1149
  #, gcc-internal-format, gfc-internal-format
  msgid "Empty array constructor at %C is not allowed"
-msgstr ""
+msgstr "Пустой конструктор массива в %C не допускается"
  
  #: fortran/array.c:1188 fortran/array.c:1198
  #, fuzzy, gcc-internal-format, gfc-internal-format
@@ -49124,32 +51111,37 @@ msgstr "несовместимый тип аргумента %d функции %
  #: fortran/array.c:1264
  #, gcc-internal-format, gfc-internal-format
  msgid "Element in %s array constructor at %L is %s"
-msgstr ""
+msgstr "Элемент в %s конструкторе массива в %L есть %s"
  
  #: fortran/array.c:1595
  #, gcc-internal-format, gfc-internal-format
  msgid "Iterator step at %L cannot be zero"
-msgstr ""
+msgstr "Шаг итератора в %L не может быть нулевым"
  
  #: fortran/array.c:1732
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit.   See -fmax-array-constructor option"
  msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit.   See %<-fmax-array-constructor%> option"
-msgstr ""
+msgstr "Число элементов в конструкторе массива в %L требует увеличения допустимой %d верхней границы. См. опцию -fmax-array-constructor"
  
  #: fortran/array.c:1902
  #, gcc-internal-format, gfc-internal-format
  msgid "AC-IMPLIED-DO initial expression references control variable at %L"
  msgstr ""
  
+#
  #: fortran/array.c:1909
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "expresion reference type error at %L"
  msgid "AC-IMPLIED-DO final expression references control variable at %L"
-msgstr "создание %s на ссылочный тип %qT"
+msgstr "ошибка типа ссылки на выражение в %L"
  
+#
  #: fortran/array.c:1916
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "expresion reference type error at %L"
  msgid "AC-IMPLIED-DO step expression references control variable at %L"
-msgstr "создание %s на ссылочный тип %qT"
+msgstr "ошибка типа ссылки на выражение в %L"
  
  #: fortran/array.c:1928
  #, gcc-internal-format, gfc-internal-format
@@ -49159,7 +51151,7 @@ msgstr ""
  #: fortran/array.c:2011
  #, gcc-internal-format, gfc-internal-format
  msgid "Different CHARACTER lengths (%d/%d) in array constructor at %L"
-msgstr ""
+msgstr "Разные CHARACTER длины (%d/%d) в конструкторе массива в %L"
  
  #: fortran/array.c:2129
  #, gcc-internal-format
@@ -49199,199 +51191,233 @@ msgstr ""
  
  #: fortran/check.c:46
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be a scalar"
  msgid "%qs argument of %qs intrinsic at %L must be a scalar"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть скаляром"
  
  #: fortran/check.c:62
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
  msgid "%qs argument of %qs intrinsic at %L must be %s"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть %s"
  
  #: fortran/check.c:89
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be a numeric type"
  msgid "%qs argument of %qs intrinsic at %L must be a numeric type"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть числовым типом"
  
  #: fortran/check.c:104
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or REAL"
  msgid "%qs argument of %qs intrinsic at %L must be INTEGER or REAL"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть INTEGER или REAL"
  
  #: fortran/check.c:121
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be REAL or COMPLEX"
  msgid "%qs argument of %qs intrinsic at %L must be REAL or COMPLEX"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть REAL или COMPLEX"
  
  #: fortran/check.c:138
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or PROCEDURE"
  msgid "%qs argument of %qs intrinsic at %L must be INTEGER or PROCEDURE"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть INTEGER или PROCEDURE"
  
  #: fortran/check.c:167 fortran/check.c:6373
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be a constant"
  msgid "%qs argument of %qs intrinsic at %L must be a constant"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть константой"
  
  #: fortran/check.c:176
  #, gcc-internal-format, gfc-internal-format
  msgid "Invalid kind for %s at %L"
-msgstr ""
+msgstr "Некорректный вид для %s в %L"
  
  #: fortran/check.c:195
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be double precision"
  msgid "%qs argument of %qs intrinsic at %L must be double precision"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть двойной точности"
  
  #: fortran/check.c:218
  #, fuzzy, gcc-internal-format
+#| msgid "Expected coarray variable as '%s' argument to the %s intrinsic at %L"
  msgid "Expected coarray variable as %qs argument to the %s intrinsic at %L"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qs Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð½Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f ÐºÐ°Ðº '%s' Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %s Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð² %L"
  
  #: fortran/check.c:235
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be a logical array"
  msgid "%qs argument of %qs intrinsic at %L must be a logical array"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть логическим массивом"
  
  #: fortran/check.c:261
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be an array"
  msgid "%qs argument of %qs intrinsic at %L must be an array"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть массивом"
  
  #: fortran/check.c:282
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L must be nonnegative"
  msgid "%qs at %L must be nonnegative"
-msgstr "%qD не является элементом типа %qT"
+msgstr "'%s' в %L должен быть неотрицательным"
  
  #: fortran/check.c:313
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The absolute value of SHIFT at %L must be less than or equal to BIT_SIZE('%s')"
  msgid "The absolute value of SHIFT at %L must be less than or equal to BIT_SIZE(%qs)"
-msgstr ""
+msgstr "Абсолютная величина SHIFT в %L должна быть меньше или равна BIT_SIZE('%s')"
  
  #: fortran/check.c:324
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L must be less than or equal to BIT_SIZE('%s')"
  msgid "%qs at %L must be less than or equal to BIT_SIZE(%qs)"
-msgstr ""
+msgstr "'%s' в %L должна быть меньше или равна BIT_SIZE('%s')"
  
  #: fortran/check.c:334
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L must be less than BIT_SIZE('%s')"
  msgid "%qs at %L must be less than BIT_SIZE(%qs)"
-msgstr "%qD не является элементом типа %qT"
+msgstr "'%s' в %L должна быть меньше чем BIT_SIZE('%s')"
  
  #: fortran/check.c:361
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L must be less than or equal to the BIT_SIZE of INTEGER(KIND=%d)"
  msgid "%qs at %L must be less than or equal to the BIT_SIZE of INTEGER(KIND=%d)"
-msgstr ""
+msgstr "'%s' в %L должна быть меньше или равна BIT_SIZE от INTEGER(KIND=%d)"
  
  #: fortran/check.c:387
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s + %s' at %L must be less than or equal to BIT_SIZE('%s')"
  msgid "%<%s + %s%> at %L must be less than or equal to BIT_SIZE(%qs)"
-msgstr ""
+msgstr "'%s + %s' в %L должна быть меньше или равна BIT_SIZE('%s')"
  
  #: fortran/check.c:413
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be the same type and kind as '%s'"
  msgid "%qs argument of %qs intrinsic at %L must be the same type and kind as %qs"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть того же типа и вида что и '%s'"
  
  #: fortran/check.c:430
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be of rank %d"
  msgid "%qs argument of %qs intrinsic at %L must be of rank %d"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть ранга %d"
  
  #: fortran/check.c:445
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must not be OPTIONAL"
  msgid "%qs argument of %qs intrinsic at %L must not be OPTIONAL"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L не должен быть OPTIONAL"
  
  #: fortran/check.c:466
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE"
  msgid "%qs argument of %qs intrinsic at %L must be ALLOCATABLE"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть ALLOCATABLE"
  
  #: fortran/check.c:484
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be of kind %d"
  msgid "%qs argument of %qs intrinsic at %L must be of kind %d"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть вида %d"
  
  #: fortran/check.c:522
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L cannot be INTENT(IN)"
  msgid "%qs argument of %qs intrinsic at %L cannot be INTENT(IN)"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L не может быть INTENT(IN)"
  
  #: fortran/check.c:543
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be a variable"
  msgid "%qs argument of %qs intrinsic at %L must be a variable"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть переменной"
  
  #: fortran/check.c:592
  #, fuzzy, gcc-internal-format
+#| msgid "'dim' argument of '%s' intrinsic at %L is not a valid codimension index"
  msgid "%<dim%> argument of %qs intrinsic at %L is not a valid codimension index"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'dim' аргумент '%s' встроенной функции в %L не есть корректный индекс коизмерения"
  
  #: fortran/check.c:642
  #, fuzzy, gcc-internal-format
+#| msgid "'dim' argument of %s intrinsic at %L is not a valid dimension index"
  msgid "%<dim%> argument of %qs intrinsic at %L is not a valid dimension index"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'dim' аргумент встроенной функции %s в %L не есть корректный индекс измерения"
  
  #: fortran/check.c:745
  #, gcc-internal-format, gfc-internal-format
  msgid "Unequal character lengths (%ld/%ld) in %s at %L"
-msgstr ""
+msgstr "Неравные character длины (%ld/%ld) в %s в %L"
  
  #: fortran/check.c:867 fortran/check.c:6317
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' and '%s' arguments of '%s' intrinsic at %L must have the same type"
  msgid "%qs and %qs arguments of %qs intrinsic at %L must have the same type"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' и '%s' аргументы '%s' встроенной функции в %L должны иметь одинаковый тип"
  
  #: fortran/check.c:876 fortran/check.c:2279 fortran/check.c:2405
  #: fortran/check.c:2479 fortran/check.c:2906
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: Different type kinds at %L"
  msgid "Different type kinds at %L"
-msgstr ""
+msgstr "Расширение: Различные виды типов в %L"
  
  #: fortran/check.c:912
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER"
  msgid "%qs argument of %qs intrinsic at %L must be a POINTER"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть POINTER"
  
  #: fortran/check.c:921 fortran/check.c:957 fortran/check.c:3424
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L shall not be coindexed"
  msgid "%qs argument of %qs intrinsic at %L shall not be coindexed"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L не должен быть коиндексирован"
  
  #: fortran/check.c:939
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be a pointer or target VARIABLE or FUNCTION"
  msgid "%qs argument of %qs intrinsic at %L must be a pointer or target VARIABLE or FUNCTION"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть указателем или целевой VARIABLE или FUNCTION"
  
  #: fortran/check.c:948
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER or a TARGET"
  msgid "%qs argument of %qs intrinsic at %L must be a POINTER or a TARGET"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть POINTER или TARGET"
  
  #: fortran/check.c:973
  #, gcc-internal-format, gfc-internal-format
  msgid "Array section with a vector subscript at %L shall not be the target of a pointer"
-msgstr ""
+msgstr "Секция массива с векторным индексом в %L не должна быть целью указателя"
  
  #: fortran/check.c:984
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "NULL pointer at %L is not permitted as actual argument of '%s' intrinsic function"
  msgid "NULL pointer at %L is not permitted as actual argument of %qs intrinsic function"
-msgstr ""
+msgstr "NULL указатель в %L не разрешен в качестве фактического аргумента '%s' встроенной функции"
  
  #: fortran/check.c:1027
  #, gcc-internal-format, gfc-internal-format
  msgid "ATOM argument at %L to intrinsic function %s shall be an integer of ATOMIC_INT_KIND or a logical of ATOMIC_LOGICAL_KIND"
-msgstr ""
+msgstr "ATOM аргумент в %L для встроенной функции %s должен быть целым ATOMIC_INT_KIND или логическим ATOMIC_LOGICAL_KIND"
  
  #: fortran/check.c:1035
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "ATOM argument at %L of the %s intrinsic function shall be a coarray or coindexed"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "ATOM аргумент в %L для %s встроенной функции должен быть комассивом или коиндексированным"
  
  #: fortran/check.c:1042
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be the same type and kind as '%s'"
  msgid "%qs argument of %qs intrinsic at %L shall have the same type as %qs at %L"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть того же типа и вида что и '%s'"
  
  #: fortran/check.c:1060 fortran/check.c:1205
  #, fuzzy, gcc-internal-format, gfc-internal-format
@@ -49400,24 +51426,26 @@ msgid "STAT= argument to %s at %L"
  msgstr "Слишком много аргументов %s в %L"
  
  #: fortran/check.c:1079 fortran/check.c:1145 fortran/check.c:1242
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "ATOM argument of the %s intrinsic function at %L shall be definable"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "ATOM аргумент для %s встроенной функции в %L должен быть определяемым"
  
  #: fortran/check.c:1093 fortran/check.c:1225
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "ATOM argument at %L to intrinsic function %s shall be an integer of ATOMIC_INT_KIND or a logical of ATOMIC_LOGICAL_KIND"
  msgid "ATOM argument at %L to intrinsic function %s shall be an integer of ATOMIC_INT_KIND"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "ATOM аргумент в %L для встроенной функции %s должен быть целым ATOMIC_INT_KIND или логическим ATOMIC_LOGICAL_KIND"
  
  #: fortran/check.c:1113
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "VALUE argument of the %s intrinsic function at %L shall be definable"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "VALUE аргумент для %s встроенной функции в %L должен быть определяемым"
  
  #: fortran/check.c:1152 fortran/check.c:1249
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "ATOM argument of the %s intrinsic function at %L shall be definable"
  msgid "OLD argument of the %s intrinsic function at %L shall be definable"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "ATOM аргумент для %s встроенной функции в %L должен быть определяемым"
  
  #: fortran/check.c:1167
  #, gcc-internal-format, gfc-internal-format
@@ -49426,28 +51454,33 @@ msgstr ""
  
  #: fortran/check.c:1177
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "ATOM argument of the %s intrinsic function at %L shall be definable"
  msgid "COUNT argument of the EVENT_QUERY intrinsic function at %L shall be definable"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "ATOM аргумент для %s встроенной функции в %L должен быть определяемым"
  
  #: fortran/check.c:1190
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "ATOM argument of the %s intrinsic function at %L shall be definable"
  msgid "COUNT argument of the EVENT_QUERY intrinsic function at %L shall have at least the range of the default integer"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "ATOM аргумент для %s встроенной функции в %L должен быть определяемым"
  
  #: fortran/check.c:1269
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: Negative argument N at %L"
  msgid "Negative argument N at %L"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: Ð\9eÑ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 N Ð² %L"
  
  #: fortran/check.c:1441 fortran/check.c:1898
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must not be present if 'x' is COMPLEX"
  msgid "%qs argument of %qs intrinsic at %L must not be present if %<x%> is COMPLEX"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L не должен присутствовать если 'x' есть COMPLEX"
  
  #: fortran/check.c:1450 fortran/check.c:1907
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must have a type of either REAL or INTEGER"
  msgid "%qs argument of %qs intrinsic at %L must have a type of either REAL or INTEGER"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен иметь тип либо REAL либо INTEGER"
  
  #: fortran/check.c:1464 fortran/check.c:1470
  #, gcc-internal-format, gfc-internal-format
@@ -49461,23 +51494,27 @@ msgstr ""
  
  #: fortran/check.c:1500
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L shall not be coindexed"
  msgid "The A argument at %L to the intrinsic %s shall not be coindexed"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L не должен быть коиндексирован"
  
  #: fortran/check.c:1523
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "STAT= argument at %L must be a scalar INTEGER variable"
  msgid "The stat= argument at %L must be a kind=4 integer variable"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "STAT= аргумент в %L должна быть скалярной INTEGER переменной"
  
  #: fortran/check.c:1539
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "STAT= argument at %L must be a scalar INTEGER variable"
  msgid "The errmsg= argument at %L must be a default-kind character variable"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "STAT= аргумент в %L должна быть скалярной INTEGER переменной"
  
  #: fortran/check.c:1547
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Coarrays disabled at %C, use -fcoarray= to enable"
  msgid "Coarrays disabled at %L, use %<-fcoarray=%> to enable"
-msgstr ""
+msgstr "Комассивы выключены в %C, используйте -fcoarray= для включения"
  
  #: fortran/check.c:1562
  #, gcc-internal-format, gfc-internal-format
@@ -49486,8 +51523,9 @@ msgstr ""
  
  #: fortran/check.c:1581
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Actual argument to '%s' at %L must be polymorphic"
  msgid "The A argument at %L of CO_REDUCE shall not be polymorphic"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ð¾Ð»Ð¸Ð¼Ð¾Ñ\80Ñ\84Ð½Ñ\8bм"
  
  #: fortran/check.c:1588
  #, gcc-internal-format, gfc-internal-format
@@ -49496,16 +51534,18 @@ msgstr ""
  
  #: fortran/check.c:1602
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Argument of %s at %L must be of length one"
  msgid "OPERATOR argument at %L must be a PURE function"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %s Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð´Ð»Ð¸Ð½Ñ\8b Ð¾Ð´Ð¸Ð½"
  
  #. None of the intrinsics fulfills the criteria of taking two arguments,
  #. returning the same type and kind as the arguments and being permitted
  #. as actual argument.
  #: fortran/check.c:1612
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Intrinsic function '%s' at %L is not permitted in an initialization expression"
  msgid "Intrinsic function %s at %L is not permitted for CO_REDUCE"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Встроенная функция '%s' в %L не разрешена в инициализационном выражении"
  
  #: fortran/check.c:1629
  #, gcc-internal-format, gfc-internal-format
@@ -49559,296 +51599,348 @@ msgstr ""
  
  #: fortran/check.c:1744
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L shall not be coindexed"
  msgid "%qs argument of %qs intrinsic at %L shall be of type integer, real or character"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L не должен быть коиндексирован"
  
  #: fortran/check.c:1792 fortran/check.c:2324 fortran/check.c:2427
  #: fortran/check.c:2628 fortran/check.c:2673 fortran/check.c:3984
  #: fortran/check.c:4118 fortran/check.c:4173 fortran/check.c:5215
  #: fortran/check.c:5344
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: '%s' intrinsic with KIND argument at %L"
  msgid "%qs intrinsic with KIND argument at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "Fortran 2003: '%s' встроенная функция с KIND аргументом в %L"
  
  #: fortran/check.c:1839 fortran/check.c:2090
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L has invalid shape in dimension %d (%ld/%ld)"
  msgid "%qs argument of %qs intrinsic at %L has invalid shape in dimension %d (%ld/%ld)"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L имеет некорректную форму в измерении %d (%ld/%ld)"
  
  #: fortran/check.c:1854 fortran/check.c:2105 fortran/check.c:2133
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of intrinsic '%s' at %L of must have rank %d or be a scalar"
  msgid "%qs argument of intrinsic %qs at %L of must have rank %d or be a scalar"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен иметь ранг %d или быть скаляром"
  
  #: fortran/check.c:1957 fortran/check.c:3000 fortran/check.c:3008
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be numeric or LOGICAL"
  msgid "%qs argument of %qs intrinsic at %L must be numeric or LOGICAL"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть числовым или LOGICAL"
  
  #: fortran/check.c:1971
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Different shape for arguments '%s' and '%s' at %L for intrinsic 'dot_product'"
  msgid "Different shape for arguments %qs and %qs at %L for intrinsic %<dot_product%>"
-msgstr ""
+msgstr "Разная форма для аргументов '%s' и '%s' в %L для встроенной функции 'dot_product'"
  
  #: fortran/check.c:1991 fortran/check.c:1999
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be default real"
  msgid "%qs argument of %qs intrinsic at %L must be default real"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть подразумеваемым вещественным"
  
  #: fortran/check.c:2020
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'I' at %L and 'J' at %L cannot both be BOZ literal constants"
  msgid "%<I%> at %L and %<J%>' at %L cannot both be BOZ literal constants"
-msgstr ""
+msgstr "'I' в %L и 'J' в %L не могут обе быть BOZ литеральными константами"
  
  #: fortran/check.c:2151
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "GNU extension: non-default INTEGER kind argument to %s intrinsic at %L"
  msgid "non-default INTEGER kind argument to %s intrinsic at %L"
-msgstr ""
+msgstr "GNU расширение: неподразумеваемый INTEGER вида аргумент '%s' встроенной функции в %L"
  
  #: fortran/check.c:2211
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2008: COMPLEX argument '%s' argument of '%s' intrinsic at %L"
  msgid "COMPLEX argument %qs of %qs intrinsic at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "Fortran 2008: COMPLEX аргумент '%s' аргумент '%s' встроенной функции в %L"
  
  #: fortran/check.c:2375
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of %s at %L must be of length one"
-msgstr ""
+msgstr "Аргумент %s в %L должен быть длины один"
  
  #: fortran/check.c:2434
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be the same kind as '%s'"
  msgid "%qs argument of %qs intrinsic at %L must be the same kind as %qs"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть того же вида что и '%s'"
  
  #: fortran/check.c:2524
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "SIZE at %L must be positive"
-msgstr "%qD не является элементом типа %qT"
+msgstr "SIZE в %L должен быть положительным"
  
  #: fortran/check.c:2536
  #, gcc-internal-format, gfc-internal-format
  msgid "The absolute value of SHIFT at %L must be less than or equal to SIZE at %L"
-msgstr ""
+msgstr "Абсолютная величина SHIFT в %L должна быть меньше или равна SIZE в %L"
  
  #: fortran/check.c:2597
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be a numeric type"
  msgid "%qs argument of %qs intrinsic at %L must be of intrinsic type"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть числовым типом"
  
  #: fortran/check.c:2604
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be a constant"
  msgid "%qs argument of %qs intrinsic at %L must be a data entity"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть константой"
  
  #: fortran/check.c:2815
  #, fuzzy, gcc-internal-format
+#| msgid "Intrinsic '%s' at %L must have at least two arguments"
  msgid "Intrinsic %qs at %L must have at least two arguments"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð¸Ð¼ÐµÑ\82Ñ\8c Ð¿Ð¾ ÐºÑ\80Ð°Ð¹Ð½ÐµÐ¹ Ð¼ÐµÑ\80Ðµ Ð´Ð²Ð° Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°"
  
  #: fortran/check.c:2863
  #, fuzzy, gcc-internal-format
+#| msgid "Missing argument to '%s' at %C"
  msgid "Missing %qs argument to the %s intrinsic at %L"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° '%s'"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %C"
  
  #: fortran/check.c:2878
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "arguments '%s' and '%s' for intrinsic %s"
  msgid "Duplicate argument %qs at %L to intrinsic %s"
-msgstr ""
+msgstr "аргументы '%s' и '%s' для внутренней функции %s"
  
  #: fortran/check.c:2883
  #, fuzzy, gcc-internal-format
+#| msgid "arguments '%s' and '%s' for intrinsic %s"
  msgid "Unknown argument %qs at %L to intrinsic %s"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
+msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b '%s' Ð¸ '%s' Ð´Ð»Ñ\8f Ð²Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½ÐµÐ¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %s"
  
  #: fortran/check.c:2912
  #, fuzzy, gcc-internal-format
+#| msgid "'a%d' argument of '%s' intrinsic at %L must be %s(%d)"
  msgid "%<a%d%> argument of %qs intrinsic at %L must be %s(%d)"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'a%d' аргумент '%s' встроенной функции в %L должен быть %s(%d)"
  
  #: fortran/check.c:2943
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: '%s' intrinsic with CHARACTER argument at %L"
  msgid "%qs intrinsic with CHARACTER argument at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "Fortran 2003: '%s' встроенная функция с CHARACTER аргументом в %L"
  
  #: fortran/check.c:2950
  #, fuzzy, gcc-internal-format
+#| msgid "'a1' argument of '%s' intrinsic at %L must be INTEGER, REAL or CHARACTER"
  msgid "%<a1%> argument of %qs intrinsic at %L must be INTEGER, REAL or CHARACTER"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'a1' аргумент '%s' встроенной функции в %L должен быть INTEGER, REAL или CHARACTER"
  
  #: fortran/check.c:3017
  #, fuzzy, gcc-internal-format
+#| msgid "Argument types of '%s' intrinsic at %L must match (%s/%s)"
  msgid "Argument types of %qs intrinsic at %L must match (%s/%s)"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð¢Ð¸Ð¿Ñ\8b Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² '%s' Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ñ\8b Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¾Ð²Ð°Ñ\82Ñ\8c (%s/%s)"
  
  #: fortran/check.c:3031
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Different shape on dimension 1 for arguments '%s' and '%s' at %L for intrinsic matmul"
  msgid "Different shape on dimension 1 for arguments %qs and %qs at %L for intrinsic matmul"
-msgstr ""
+msgstr "Разная форма по измерению 1 для аргументов '%s' и '%s' в %L для встроенной функции matmul"
  
  #: fortran/check.c:3050
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Different shape on dimension 2 for argument '%s' and dimension 1 for argument '%s' at %L for intrinsic matmul"
  msgid "Different shape on dimension 2 for argument %qs and dimension 1 for argument %qs at %L for intrinsic matmul"
-msgstr ""
+msgstr "Разная форма по измерению 2 для аргументов '%s' и '%s' в %L для встроенной функции matmul"
  
  #: fortran/check.c:3059
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be of rank 1 or 2"
  msgid "%qs argument of %qs intrinsic at %L must be of rank 1 or 2"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть ранга 1 или 2"
  
  #: fortran/check.c:3234
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER"
  msgid "%qs argument of %qs intrinsic at %L must be INTEGER"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть INTEGER"
  
  #: fortran/check.c:3294
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L shall not be coindexed"
  msgid "The FROM argument to MOVE_ALLOC at %L shall not be coindexed"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L не должен быть коиндексирован"
  
  #: fortran/check.c:3305
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L shall not be coindexed"
  msgid "The TO argument to MOVE_ALLOC at %L shall not be coindexed"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L не должен быть коиндексирован"
  
  #: fortran/check.c:3312
  #, gcc-internal-format, gfc-internal-format
  msgid "The TO arguments in MOVE_ALLOC at %L must be polymorphic if FROM is polymorphic"
-msgstr ""
+msgstr "TO аргументы в MOVE_ALLOC в %L должны быть полиморфными если FROM является полиморфным"
  
  #: fortran/check.c:3323
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "the '%s' and '%s' arguments of '%s' intrinsic at %L must have the same rank %d/%d"
  msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same rank %d/%d"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' и '%s' аргументы '%s' встроенной функции в %L должны иметь одинаковый ранг %d/%d"
  
  #: fortran/check.c:3332
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "the '%s' and '%s' arguments of '%s' intrinsic at %L must have the same rank %d/%d"
  msgid "The FROM and TO arguments of the MOVE_ALLOC intrinsic at %L must have the same corank %d/%d"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' и '%s' аргументы '%s' встроенной функции в %L должны иметь одинаковый ранг %d/%d"
  
  #: fortran/check.c:3359
  #, fuzzy, gcc-internal-format
+#| msgid "Argument 'S' of NEAREST at %L shall not be zero"
  msgid "Argument %<S%> of NEAREST at %L shall not be zero"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 'S' NEAREST Ð² %L Ð½Ðµ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð½Ñ\83Ð»ÐµÐ¼"
  
  #: fortran/check.c:3409
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
  msgid "%qs argument of %qs intrinsic at %L must be a POINTER, ALLOCATABLE or procedure pointer"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть POINTER, ALLOCATABLE или процедурным указателем"
  
  #: fortran/check.c:3417
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: NULL intrinsic with allocatable MOLD at %L"
  msgid "NULL intrinsic with allocatable MOLD at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "Fortran 2003: NULL встроенная функция с размещаемым MOLD в %L"
  
  #: fortran/check.c:3496 fortran/check.c:5291
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must provide at least as many elements as there are .TRUE. values in '%s' (%ld/%d)"
  msgid "%qs argument of %qs intrinsic at %L must provide at least as many elements as there are .TRUE. values in %qs (%ld/%d)"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен предоставлять по крайней мере столько элементов, сколько есть .TRUE. значений в '%s' (%ld/%d)"
  
  #: fortran/check.c:3554
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be of a dummy variable"
  msgid "%qs argument of %qs intrinsic at %L must be of a dummy variable"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть формальной переменной"
  
  #: fortran/check.c:3562
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be of an OPTIONAL dummy variable"
  msgid "%qs argument of %qs intrinsic at %L must be of an OPTIONAL dummy variable"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть OPTIONAL формальной переменной"
  
  #: fortran/check.c:3581
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must not be a subobject of '%s'"
  msgid "%qs argument of %qs intrinsic at %L must not be a subobject of %qs"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L не должен быть подобъектом '%s'"
  
  #: fortran/check.c:3629
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "The argument of the RANK intrinsic at %L must be a data object"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 RANK Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð¾Ð¼ Ð´Ð°Ð½Ð½Ñ\8bÑ\85"
  
  #: fortran/check.c:3733
  #, fuzzy, gcc-internal-format
+#| msgid "'shape' argument of 'reshape' intrinsic at %L must be an array of constant size"
  msgid "%<shape%> argument of %<reshape%> intrinsic at %L must be an array of constant size"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'shape' аргумент 'reshape' встроенной функции в %L должен быть массивом константного размера"
  
  #: fortran/check.c:3743
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L is empty"
  msgid "%qs argument of %qs intrinsic at %L is empty"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L пуст"
  
  #: fortran/check.c:3750
  #, fuzzy, gcc-internal-format
+#| msgid "'shape' argument of 'reshape' intrinsic at %L has more than %d elements"
  msgid "%<shape%> argument of %<reshape%> intrinsic at %L has more than %d elements"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'shape' аргумент 'reshape' встроенной функции в %L имеет больше чем %d элементов"
  
  #: fortran/check.c:3767
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L has negative element (%d)"
  msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L имеет отрицательный элемент (%d)"
  
  #: fortran/check.c:3799
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Complex argument of LOG at %L cannot be zero"
  msgid "Element %d of actual argument of RESHAPE at %L cannot be negative"
-msgstr ""
+msgstr "Complex аргумент LOG в %L не может быть нулевым"
  
  #: fortran/check.c:3837
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L has wrong number of elements (%d/%d)"
  msgid "%qs argument of %qs intrinsic at %L has wrong number of elements (%d/%d)"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L имеет неверное число элементов (%d/%d)"
  
  #: fortran/check.c:3855
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L has out-of-range dimension (%d)"
  msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L имеет измерение вне диапазона (%d)"
  
  #: fortran/check.c:3864
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L has invalid permutation of dimensions (dimension '%d' duplicated)"
  msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L имеет некорректную перестановку измерений (измерение '%d' дублировано)"
  
  #: fortran/check.c:3900
  #, gcc-internal-format, gfc-internal-format
  msgid "Without padding, there are not enough elements in the intrinsic RESHAPE source at %L to match the shape"
-msgstr ""
+msgstr "Без дополнения не хватает элементов во встроенной функции RESHAPE source в %L чтобы соответствовать форме"
  
  #: fortran/check.c:3917 fortran/check.c:3936
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be %s"
  msgid "%qs argument of %qs intrinsic at %L cannot be of type %s"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть %s"
  
  #: fortran/check.c:3927 fortran/check.c:3946
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be of an extensible type"
  msgid "%qs argument of %qs intrinsic at %L must be of an extensible type"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть расширяемого типа"
  
  #: fortran/check.c:4045
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Fortran 2008: SELECTED_REAL_KIND with neither 'P' nor 'R' argument at %L"
  msgid "SELECTED_REAL_KIND with neither %<P%> nor %<R%> argument at %L"
-msgstr ""
+msgstr "Fortran 2008: SELECTED_REAL_KIND с аргументом не 'P' и не 'R' в %L"
  
  #: fortran/check.c:4076
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2008: '%s' intrinsic with RADIX argument at %L"
  msgid "%qs intrinsic with RADIX argument at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "Fortran 2008: '%s' встроенная функция с RADIX аргументом в %L"
  
  #: fortran/check.c:4111
  #, fuzzy, gcc-internal-format
+#| msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array"
  msgid "%<source%> argument of %<shape%> intrinsic at %L must not be an assumed size array"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'source' аргумент 'shape' встроенной функции в %L не должен быть массивом предполагаемого размера"
  
  #: fortran/check.c:4188 fortran/check.c:6356
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L may not be a procedure"
  msgid "%qs argument of %qs intrinsic at %L shall not be a procedure"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L не может быть процедурой"
  
  #: fortran/check.c:4201 fortran/check.c:4340 fortran/check.c:6348
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L shall not be coindexed"
  msgid "%qs argument of %qs intrinsic at %L shall not be TYPE(*)"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L не должен быть коиндексирован"
  
  #: fortran/check.c:4212 fortran/check.c:4352
  #, fuzzy, gcc-internal-format
+#| msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array"
  msgid "%qs argument of %qs intrinsic at %L shall not be an assumed-size array"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'source' аргумент 'shape' встроенной функции в %L не должен быть массивом предполагаемого размера"
  
  #: fortran/check.c:4282
  #, gcc-internal-format
@@ -49857,8 +51949,9 @@ msgstr ""
  
  #: fortran/check.c:4331
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be an interoperable data entity"
  msgid "%qs argument of %qs intrinsic at %L must be an interoperable data entity: %s"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть интероперабельной сущностью данных"
  
  #: fortran/check.c:4370
  #, gcc-internal-format, gfc-internal-format
@@ -49877,18 +51970,21 @@ msgstr ""
  
  #: fortran/check.c:4420
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "argument %d of %qE must be a pointer type"
  msgid "Argument FPTR at %L to C_F_POINTER must be a pointer"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "аргумент %d для %qE должен быть указателем"
  
  #: fortran/check.c:4427
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Actual argument to '%s' at %L must be polymorphic"
  msgid "FPTR argument at %L to C_F_POINTER shall not be polymorphic"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ð¾Ð»Ð¸Ð¼Ð¾Ñ\80Ñ\84Ð½Ñ\8bм"
  
  #: fortran/check.c:4434
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Pointer object at %C shall not be coindexed"
  msgid "Argument FPTR at %L to C_F_POINTER shall not be coindexed"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð£ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ð¾Ð±Ñ\8aÐµÐºÑ\82 Ð² %C Ð½Ðµ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ¾Ð¸Ð½Ð´ÐµÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
  
  #: fortran/check.c:4441
  #, gcc-internal-format, gfc-internal-format
@@ -49921,14 +52017,15 @@ msgid "Argument CPTR at %L to C_F_PROCPOINTER shall have the type TYPE(C_FUNPTR)
  msgstr ""
  
  #: fortran/check.c:4509
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Argument FPTR at %L to C_F_PROCPOINTER shall be a procedure pointer"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr ""
  
  #: fortran/check.c:4516
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Pointer object at %C shall not be coindexed"
  msgid "Argument FPTR at %L to C_F_PROCPOINTER shall not be coindexed"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð£ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ð¾Ð±Ñ\8aÐµÐºÑ\82 Ð² %C Ð½Ðµ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ¾Ð¸Ð½Ð´ÐµÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
  
  #: fortran/check.c:4522
  #, gcc-internal-format, gfc-internal-format
@@ -49937,13 +52034,15 @@ msgstr ""
  
  #: fortran/check.c:4536
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Pointer object at %C shall not be coindexed"
  msgid "Argument X at %L to C_FUNLOC shall not be coindexed"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð£ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ð¾Ð±Ñ\8aÐµÐºÑ\82 Ð² %C Ð½Ðµ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ¾Ð¸Ð½Ð´ÐµÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
  
  #: fortran/check.c:4551
  #, fuzzy, gcc-internal-format
+#| msgid "Function result '%s' at %L has no IMPLICIT type"
  msgid "Function result %qs at %L is invalid as X argument to C_FUNLOC"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð ÐµÐ·Ñ\83Ð»Ñ\8cÑ\82Ð°Ñ\82 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s' Ð² %L Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 IMPLICIT Ñ\82Ð¸Ð¿Ð°"
  
  #: fortran/check.c:4559
  #, gcc-internal-format, gfc-internal-format
@@ -49952,18 +52051,21 @@ msgstr ""
  
  #: fortran/check.c:4565
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "User operator procedure '%s' at %L must be a FUNCTION"
  msgid "Noninteroperable procedure at %L to C_FUNLOC"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82ÐµÐ»Ñ\8cÑ\81ÐºÐ¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° '%s' Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c FUNCTION"
  
  #: fortran/check.c:4579
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Pointer object at %C shall not be coindexed"
  msgid "Argument X at %L to C_LOC shall not be coindexed"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð£ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ð¾Ð±Ñ\8aÐµÐºÑ\82 Ð² %C Ð½Ðµ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ¾Ð¸Ð½Ð´ÐµÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
  
  #: fortran/check.c:4585
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Actual argument to '%s' at %L must be polymorphic"
  msgid "X argument at %L to C_LOC shall not be polymorphic"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ð¾Ð»Ð¸Ð¼Ð¾Ñ\80Ñ\84Ð½Ñ\8bм"
  
  #: fortran/check.c:4596
  #, fuzzy, gcc-internal-format, gfc-internal-format
@@ -49973,18 +52075,20 @@ msgstr "Компонент в %C должен иметь атрибут POINTER"
  
  #: fortran/check.c:4604
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Argument 'S' of NEAREST at %L shall not be zero"
  msgid "Argument X at %L to C_LOC shall be not be a zero-sized string"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 'S' NEAREST Ð² %L Ð½Ðµ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð½Ñ\83Ð»ÐµÐ¼"
  
  #: fortran/check.c:4613
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Actual argument to '%s' at %L must be polymorphic"
  msgid "Argument at %L to C_LOC shall not be polymorphic"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ð¾Ð»Ð¸Ð¼Ð¾Ñ\80Ñ\84Ð½Ñ\8bм"
  
  #: fortran/check.c:4620
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Noninteroperable array at %L as argument to C_LOC: %s"
-msgstr "отсутствует аргумент ключа %qs"
+msgstr ""
  
  #: fortran/check.c:4631
  #, gcc-internal-format, gfc-internal-format
@@ -49993,33 +52097,37 @@ msgstr ""
  
  #: fortran/check.c:4636
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Array section in '%s' call at %L"
  msgid "Array section at %L to C_LOC"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð² %s"
+msgstr "Ð¡ÐµÐºÑ\86Ð¸Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² '%s' Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ð² %L"
  
  #: fortran/check.c:4664
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "GNU extension: non double precision REAL argument to %s intrinsic at %L"
  msgid "non double precision REAL argument to %s intrinsic at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "GNU расширение: не двойной точности REAL аргумент для '%s' встроенной функции в %L"
  
  #: fortran/check.c:4677
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be less than rank %d"
  msgid "%qs argument of %qs intrinsic at %L must be less than rank %d"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть меньше чем ранг %d"
  
  #: fortran/check.c:4696
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L is not a valid dimension index"
  msgid "%qs argument of %qs intrinsic at %L is not a valid dimension index"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L не есть корректный индекс измерения"
  
  #: fortran/check.c:4959
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s argument to IMAGE_INDEX must be a rank one array at %L"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "'%s' аргумент для IMAGE_INDEX должен быть массивом ранга один в %L"
  
  #: fortran/check.c:4970
  #, gcc-internal-format, gfc-internal-format
  msgid "The number of array elements of the SUB argument to IMAGE_INDEX at %L shall be %d (corank) not %d"
-msgstr ""
+msgstr "Число элементов массива SUB аргумента для IMAGE_INDEX в %L должно быть %d (коранг) а не %d"
  
  #: fortran/check.c:5003
  #, gcc-internal-format, gfc-internal-format
@@ -50027,14 +52135,16 @@ msgid "DISTANCE= argument to NUM_IMAGES at %L"
  msgstr ""
  
  #: fortran/check.c:5016
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "MOLD argument to NULL required at %L"
  msgid "FAILED= argument to NUM_IMAGES at %L"
-msgstr ""
+msgstr "MOLD аргумент в NULL требуется в %L"
  
  #: fortran/check.c:5039
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "DIM argument without ARRAY argument not allowed for THIS_IMAGE intrinsic at %L"
  msgid "DIM argument without COARRAY argument not allowed for THIS_IMAGE intrinsic at %L"
-msgstr ""
+msgstr "DIM аргумент без ARRAY аргумента не допускается для THIS_IMAGE встроенной функции в %L"
  
  #: fortran/check.c:5046
  #, gcc-internal-format, gfc-internal-format
@@ -50043,8 +52153,9 @@ msgstr ""
  
  #: fortran/check.c:5057
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unexpected junk in formal argument list at %C"
  msgid "Unexpected DIM argument with noncoarray argument at %L"
-msgstr "Неожиданное окончание строки формата"
+msgstr "Неожиданный мусор в списке формальных аргументов в %C"
  
  #: fortran/check.c:5075
  #, gcc-internal-format, gfc-internal-format
@@ -50053,28 +52164,32 @@ msgstr ""
  
  #: fortran/check.c:5155
  #, fuzzy, gcc-internal-format
+#| msgid "'MOLD' argument of 'TRANSFER' intrinsic at %L must not be %s"
  msgid "%<MOLD%> argument of %<TRANSFER%> intrinsic at %L must not be %s"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'MOLD' аргумент 'TRANSFER' встроенной функции в %L не должен быть %s"
  
  #: fortran/check.c:5183
  #, gcc-internal-format, gfc-internal-format
  msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %ld < result size %ld"
-msgstr ""
+msgstr "Встроенная функция TRANSFER в %L имеет частично неопределенный результат: исходный размер %ld < размера результата %ld"
  
  #: fortran/check.c:5305
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must have the same rank as '%s' or be a scalar"
  msgid "%qs argument of %qs intrinsic at %L must have the same rank as %qs or be a scalar"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен иметь тот же ранг что и '%s' или быть скаляром"
  
  #: fortran/check.c:5318
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' and '%s' arguments of '%s' intrinsic at %L must have identical shape."
  msgid "%qs and %qs arguments of %qs intrinsic at %L must have identical shape."
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' и '%s' аргументы '%s' встроенной функции в %L должны иметь идентичную форму."
  
  #: fortran/check.c:5576 fortran/check.c:5608
  #, fuzzy, gcc-internal-format
+#| msgid "Size of '%s' argument of '%s' intrinsic at %L too small (%i/%i)"
  msgid "Size of %qs argument of %qs intrinsic at %L too small (%i/%i)"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð Ð°Ð·Ð¼ÐµÑ\80 '%s' Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° '%s' Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð² %L Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð°Ð» (%i/%i)"
  
  #: fortran/check.c:5616
  #, gcc-internal-format, gfc-internal-format
@@ -50093,9 +52208,9 @@ msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
  msgstr "неправильное число аргументов шаблона (%d, а должно быть %d)"
  
  #: fortran/check.c:5686
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "COUNT argument to SYSTEM_CLOCK at %L has non-default kind"
-msgstr "аргумент `asm' - не константная строка"
+msgstr ""
  
  #: fortran/check.c:5705
  #, gcc-internal-format, gfc-internal-format
@@ -50103,24 +52218,26 @@ msgid "Real COUNT_RATE argument to SYSTEM_CLOCK at %L"
  msgstr ""
  
  #: fortran/check.c:5715
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "COUNT_RATE argument to SYSTEM_CLOCK at %L has non-default kind"
-msgstr "аргумент `asm' - не константная строка"
+msgstr ""
  
  #: fortran/check.c:5732
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "COUNT_MAX argument to SYSTEM_CLOCK at %L has non-default kind"
-msgstr "аргумент `asm' - не константная строка"
+msgstr ""
  
  #: fortran/check.c:5949
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be of a kind not wider than the default kind (%d)"
  msgid "%qs argument of %qs intrinsic at %L must be of a kind not wider than the default kind (%d)"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть вида не шире чем подразумеваемый вид (%d)"
  
  #: fortran/check.c:6301 fortran/check.c:6309
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or LOGICAL"
  msgid "%qs argument of %qs intrinsic at %L must be INTEGER or LOGICAL"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть INTEGER или LOGICAL"
  
  #: fortran/check.c:6340
  #, gcc-internal-format, gfc-internal-format
@@ -50130,39 +52247,43 @@ msgstr ""
  #: fortran/class.c:614
  #, gcc-internal-format, gfc-internal-format
  msgid "Assumed size polymorphic objects or components, such as that at %C, have not yet been implemented"
-msgstr ""
+msgstr "Предполагаемый размер полиморфных объектов или компонентов таких как в %C пока не реализован"
  
  #. Since the extension field is 8 bit wide, we can only have
  #. up to 255 extension levels.
  #: fortran/class.c:725 fortran/decl.c:8176
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Maximum extension level reached with type '%s' at %L"
  msgid "Maximum extension level reached with type %qs at %L"
-msgstr ""
+msgstr "Максимальный уровень расширения достигнут с типом '%s' в %L"
  
  #: fortran/class.c:2764 fortran/class.c:2838
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' of '%s' is PRIVATE at %L"
  msgid "%qs of %qs is PRIVATE at %L"
-msgstr ""
+msgstr "'%s' от '%s' является PRIVATE в %L"
  
  #: fortran/cpp.c:450
  #, fuzzy, gcc-internal-format
+#| msgid "To enable preprocessing, use -cpp"
  msgid "To enable preprocessing, use %<-cpp%>"
-msgstr "Ð¢Ñ\80Ð°Ð´Ð¸Ñ\86Ð¸Ð¾Ð½Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ"
+msgstr "Ð\94Ð»Ñ\8f Ð²ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ñ\8f Ð¿Ñ\80ÐµÐ¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83Ð¹Ñ\82Ðµ -cpp"
  
  #: fortran/cpp.c:548 fortran/cpp.c:559 fortran/cpp.c:666
  #, fuzzy, gcc-internal-format
+#| msgid "opening output file %s: %s"
  msgid "opening output file %qs: %s"
-msgstr "при открытии выходного файла %s: %m"
+msgstr "при открытии выходного файла %s: %s"
  
  #: fortran/data.c:65
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "non-constant array in DATA statement %L"
-msgstr "Ð½ÐµÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÐ¹ Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ðµ"
+msgstr "Ð½ÐµÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÐ¹ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² DATA Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ %L"
  
  #: fortran/data.c:137
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "failure to simplify substring reference in DATA statement at %L"
-msgstr "Ð\92Ñ\8bÑ\85Ð¾Ð´ Ð·Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ñ\8b Ð² Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÐµ Ð¸Ð»Ð¸ Ð¾Ð±Ñ\80Ð°Ñ\89ÐµÐ½Ð¸Ð¸ Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ñ\83 Ð´Ð»Ñ\8f `%A' Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %0"
+msgstr "Ð\9dÐµ Ñ\83Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ñ\83Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ð¸Ñ\82Ñ\8c Ñ\81Ñ\81Ñ\8bÐ»ÐºÑ\83 Ð½Ð° Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÑ\83 Ð² DATA Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %L"
  
  #: fortran/data.c:170
  #, gcc-internal-format, gfc-internal-format
@@ -50171,26 +52292,29 @@ msgstr ""
  
  #: fortran/data.c:176
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Initialization string starting at %L was truncated to fit the variable (%d/%d)"
  msgid "Initialization string at %L was truncated to fit the variable (%d/%d)"
-msgstr "строка инициализации усечена в соответствии с размером переменной в %L"
+msgstr "строка инициализации начинающаяся в %L была усечена чтобы подойти переменной (%d/%d)"
  
  #: fortran/data.c:266
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L already is initialized at %L"
  msgid "%qs at %L already is initialized at %L"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "'%s' в %L уже инициализирован в %L"
  
  #: fortran/data.c:290
  #, gcc-internal-format, gfc-internal-format
  msgid "Data element below array lower bound at %L"
-msgstr ""
+msgstr "Элемент данных ниже нижней границы массива в %L"
  
  #: fortran/data.c:307 fortran/data.c:396
  #, gcc-internal-format, gfc-internal-format
  msgid "Data element above array upper bound at %L"
-msgstr ""
+msgstr "Элемент данных выше верхней границы массива в %L"
  
  #: fortran/data.c:337 fortran/data.c:503
  #, fuzzy, gcc-internal-format
+#| msgid "Extension: re-initialization of '%s' at %L"
  msgid "re-initialization of %qs at %L"
  msgstr "Расширение: повторная инициализация '%s' в %L"
  
@@ -50201,53 +52325,59 @@ msgstr ""
  
  #: fortran/decl.c:278
  #, fuzzy, gcc-internal-format
+#| msgid "Host associated variable '%s' may not be in the DATA statement at %C"
  msgid "Host associated variable %qs may not be in the DATA statement at %C"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\90Ñ\81Ñ\81Ð¾Ñ\86Ð¸Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð°Ñ\8f Ñ\81 Ñ\85Ð¾Ñ\81Ñ\82Ð¾Ð¼ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f '%s' Ð½Ðµ Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð² DATA Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:285
  #, fuzzy, gcc-internal-format
+#| msgid "Extension: initialization of common block variable '%s' in DATA statement at %C"
  msgid "initialization of common block variable %qs in DATA statement at %C"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ Ð¸Ð· common Ð±Ð»Ð¾ÐºÐ° '%s' Ð² DATA Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:396
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' must be a PARAMETER in DATA statement at %C"
  msgid "Symbol %qs must be a PARAMETER in DATA statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» '%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c PARAMETER Ð² DATA Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:421
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid initializer %s in Data statement at %C"
-msgstr "Ð\9fÑ\80Ð¾Ð¿Ñ\83Ñ\89ÐµÐ½Ð° Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80 %s Ð² Data Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:523
  #, gcc-internal-format, gfc-internal-format
  msgid "Initialization at %C is not allowed in a PURE procedure"
-msgstr ""
+msgstr "Инициализация в %C не допускается в PURE процедуре"
  
  #: fortran/decl.c:560
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
  msgid "DATA statement at %C cannot appear within an INTERFACE"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "ENTRY оператор в %C не может появляться внутри INTERFACE"
  
  #: fortran/decl.c:592
  #, gcc-internal-format, gfc-internal-format
  msgid "DATA statement at %C is not allowed in a PURE procedure"
-msgstr ""
+msgstr "DATA оператор в %C не допускается в PURE процедуре"
  
  #: fortran/decl.c:619
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Data target at %L shall not have a coindex"
  msgid "The assumed-rank array at %C shall not have a codimension"
-msgstr "стандартные преобразования в данном контексте недопустимы"
+msgstr "Целевые данные в %L не должны иметь коиндекс"
  
  #: fortran/decl.c:687
  #, gcc-internal-format, gfc-internal-format
  msgid "Bad INTENT specification at %C"
-msgstr ""
+msgstr "Некорректная INTENT спецификация в %C"
  
  #: fortran/decl.c:708
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: deferred type parameter at %C"
  msgid "deferred type parameter at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: отложенный параметр типа в %C"
  
  #: fortran/decl.c:780
  #, gcc-internal-format, gfc-internal-format
@@ -50256,63 +52386,74 @@ msgstr ""
  
  #: fortran/decl.c:806
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Obsolescent feature: Old-style character length at %C"
  msgid "Old-style character length at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð°Ñ\8f Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ñ\8c: Ð¡Ñ\82Ð°Ñ\80Ñ\8bÐ¹ Ñ\81Ñ\82Ð¸Ð»Ñ\8c Ð´Ð»Ð¸Ð½Ñ\8b Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð² %C"
  
  #: fortran/decl.c:837
  #, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in character length specification at %C"
-msgstr ""
+msgstr "Синтаксическая ошибка в спецификации длины строки в %C"
  
  #: fortran/decl.c:990
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' at %C is already defined at %L"
  msgid "Procedure %qs at %C is already defined at %L"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Процедура '%s' в %C уже определена в %L"
  
  #: fortran/decl.c:998
  #, fuzzy, gcc-internal-format
+#| msgid "Name '%s' at %C is already defined as a generic interface at %L"
  msgid "Name %qs at %C is already defined as a generic interface at %L"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Имя '%s' в %C уже определено как обобщенный интерфейс в %L"
  
  #: fortran/decl.c:1011
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' at %C has an explicit interface and must not have attributes declared at %L"
  msgid "Procedure %qs at %C has an explicit interface and must not have attributes declared at %L"
-msgstr ""
+msgstr "Процедура '%s' в %C имеет явный интерфейс и не должна иметь атрибуты декларированные в %L"
  
  #: fortran/decl.c:1082
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' at %L must have the BIND(C) attribute to be C interoperable"
  msgid "Procedure %qs at %L must have the BIND(C) attribute to be C interoperable"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸й"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð¸Ð¼ÐµÑ\82Ñ\8c BIND(C) Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ñ\87Ñ\82Ð¾Ð±Ñ\8b Ð±Ñ\8bÑ\82Ñ\8c C-Ñ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ð¾й"
  
  #: fortran/decl.c:1109
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L is a dummy argument to the BIND(C) procedure '%s' but is not C interoperable because derived type '%s' is not C interoperable"
  msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because derived type %qs is not C interoperable"
-msgstr ""
+msgstr "Переменная '%s' в %L является формальным аргументом BIND(C) процедуры '%s' но не является C-совместимой поскольку производный тип '%s' не является C-совместимым"
  
  #: fortran/decl.c:1116
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L is a dummy argument to the BIND(C) procedure '%s' but is not C interoperable because it is polymorphic"
  msgid "Variable %qs at %L is a dummy argument to the BIND(C) procedure %qs but is not C interoperable because it is polymorphic"
-msgstr ""
+msgstr "Переменная '%s' в %L является формальным аргументом BIND(C) процедуры '%s' но не является C-совместимой поскольку та полиморфна"
  
  #: fortran/decl.c:1123
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L is a parameter to the BIND(C) procedure '%s' but may not be C interoperable"
  msgid "Variable %qs at %L is a dummy argument of the BIND(C) procedure %qs but may not be C interoperable"
-msgstr ""
+msgstr "Переменная '%s' в %L является параметром BIND(C) процедуры '%s' но может не быть C-совместимой"
  
  #: fortran/decl.c:1138
  #, fuzzy, gcc-internal-format
+#| msgid "Character argument '%s' at %L must be length 1 because procedure '%s' is BIND(C)"
  msgid "Character argument %qs at %L must be length 1 because procedure %qs is BIND(C)"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Character аргумент '%s' в %L должен быть длины 1 поскольку процедура '%s' является BIND(C)"
  
  #: fortran/decl.c:1151
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "TS29113: Variable '%s' at %L with OPTIONAL attribute in procedure '%s' which is BIND(C)"
  msgid "Variable %qs at %L with ALLOCATABLE attribute in procedure %qs with BIND(C)"
-msgstr ""
+msgstr "TS29113: Переменная '%s' в %L с OPTIONAL атрибутом в процедуре '%s' являющейся BIND(C)"
  
  #: fortran/decl.c:1159
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "TS29113: Variable '%s' at %L with OPTIONAL attribute in procedure '%s' which is BIND(C)"
  msgid "Variable %qs at %L with POINTER attribute in procedure %qs with BIND(C)"
-msgstr ""
+msgstr "TS29113: Переменная '%s' в %L с OPTIONAL атрибутом в процедуре '%s' являющейся BIND(C)"
  
  #: fortran/decl.c:1168
  #, gcc-internal-format
@@ -50320,64 +52461,71 @@ msgid "Scalar variable %qs at %L with POINTER or ALLOCATABLE in procedure %qs wi
  msgstr ""
  
  #: fortran/decl.c:1177
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L cannot have both the OPTIONAL and the VALUE attribute because procedure '%s' is BIND(C)"
  msgid "Variable %qs at %L cannot have both the OPTIONAL and the VALUE attribute because procedure %qs is BIND(C)"
-msgstr ""
+msgstr "Переменная '%s' в %L не может иметь оба атрибута OPTIONAL и VALUE поскольку процедура '%s' является BIND(C)"
  
  #: fortran/decl.c:1184
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "TS29113: Variable '%s' at %L with OPTIONAL attribute in procedure '%s' which is BIND(C)"
  msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND(C)"
-msgstr ""
+msgstr "TS29113: Переменная '%s' в %L с OPTIONAL атрибутом в процедуре '%s' являющейся BIND(C)"
  
  #: fortran/decl.c:1195
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Assumed-shape array '%s' at %L cannot be an argument to the procedure '%s' at %L because the procedure is BIND(C)"
  msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
-msgstr ""
+msgstr "Массив предполагаемого размера '%s' в %L не может быть аргументом процедуры '%s' в %L поскольку процедура является BIND(C)"
  
  #: fortran/decl.c:1244
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %L already has basic type of %s"
  msgid "Symbol %qs at %C also declared as a type at %L"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 тип %s"
+msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» '%s' Ð² %L Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð±Ð°Ð·Ð¾Ð²Ñ\8bÐ¹ тип %s"
  
  #: fortran/decl.c:1303
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' in common block '%s' at %C must be declared with a C interoperable kind since common block '%s' is BIND(C)"
  msgid "Variable %qs in common block %qs at %C must be declared with a C interoperable kind since common block %qs is BIND(C)"
-msgstr ""
+msgstr "Переменная '%s' в common блоке '%s' в %C должна быть декларирована с C совместимым видом поскольку common блок '%s' является BIND(C)"
  
  #: fortran/decl.c:1348
  #, gcc-internal-format, gfc-internal-format
  msgid "CHARACTER expression at %L is being truncated (%d/%d)"
-msgstr ""
+msgstr "CHARACTER выражение в %L усекается (%d/%d)"
  
  #: fortran/decl.c:1355
  #, gcc-internal-format, gfc-internal-format
  msgid "The CHARACTER elements of the array constructor at %L must have the same length (%d/%d)"
-msgstr ""
+msgstr "CHARACTER элементы конструктора массива в %L должны иметь одинаковую длину (%d/%d)"
  
  #: fortran/decl.c:1445
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Initializer not allowed for PARAMETER '%s' at %C"
  msgid "Initializer not allowed for PARAMETER %qs at %C"
-msgstr ""
+msgstr "Инициализатор не допускается для PARAMETER '%s' в %C"
  
  #: fortran/decl.c:1455
  #, gcc-internal-format, gfc-internal-format
  msgid "PARAMETER at %L is missing an initializer"
-msgstr ""
+msgstr "PARAMETER в %L остался без инициализатора"
  
  #: fortran/decl.c:1465
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %C with an initializer already appears in a DATA statement"
  msgid "Variable %qs at %C with an initializer already appears in a DATA statement"
-msgstr ""
+msgstr "Переменная '%s' в %C с инициализатором уже появлялась в DATA операторе"
  
  #: fortran/decl.c:1558
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Can't initialize implied-shape array at %L with scalar"
-msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¼Ð½Ð¾Ð³Ð¾Ð¼ÐµÑ\80Ð½Ð¾Ð³Ð¾ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð¿Ñ\80Ð¸ Ð¿Ð¾Ð¼Ð¾Ñ\89Ð¸ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾ра"
+msgstr "Ð\9dÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð²Ñ\8bÐ²Ð¾Ð´Ð¸Ð¼Ð¾Ð¹ Ñ\84Ð¾Ñ\80Ð¼Ñ\8b Ð² %L Ñ\81 Ð¿Ð¾Ð¼Ð¾Ñ\89Ñ\8cÑ\8e Ñ\81ÐºÐ°Ð»Ñ\8fра"
  
  #: fortran/decl.c:1593
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Non-constant lower bound in implied-shape declaration at %L"
-msgstr "синтаксическая ошибка в списке параметров макроса"
+msgstr "Неконстантная нижняя граница декларации выводимой формы в %L"
  
  #: fortran/decl.c:1678
  #, gcc-internal-format, gfc-internal-format
@@ -50387,63 +52535,67 @@ msgstr "Компонент в %C должен иметь атрибут POINTER"
  #: fortran/decl.c:1686
  #, gcc-internal-format, gfc-internal-format
  msgid "Array component of structure at %C must have explicit or deferred shape"
-msgstr ""
+msgstr "Компонент-массив структуры в %C должен иметь явную или отложенную форму"
  
  #: fortran/decl.c:1767
  #, gcc-internal-format, gfc-internal-format
  msgid "Pointer array component of structure at %C must have a deferred shape"
-msgstr ""
+msgstr "Компонент-массив указателей структуры в %C должен иметь отложенную форму"
  
  #: fortran/decl.c:1776
  #, gcc-internal-format, gfc-internal-format
  msgid "Allocatable component of structure at %C must have a deferred shape"
-msgstr ""
+msgstr "Размещаемый компонент структуры в %C должен иметь отложенную форму"
  
  #: fortran/decl.c:1785
  #, gcc-internal-format, gfc-internal-format
  msgid "Array component of structure at %C must have an explicit shape"
-msgstr ""
+msgstr "Компонент-массив структуры в %C должен иметь явную форму"
  
  #: fortran/decl.c:1839
  #, gcc-internal-format, gfc-internal-format
  msgid "NULL() initialization at %C is ambiguous"
-msgstr ""
+msgstr "NULL() инициализация в %C неоднозначна"
  
  #: fortran/decl.c:1856
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NULL() initialization at %C is ambiguous"
  msgid "NULL() initialization at %C may not have MOLD"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "NULL() инициализация в %C неоднозначна"
  
  #: fortran/decl.c:1873
  #, gcc-internal-format, gfc-internal-format
  msgid "Initialization of pointer at %C is not allowed in a PURE procedure"
-msgstr ""
+msgstr "Инициализация указателя в %C не допускается в PURE процедуре"
  
  #: fortran/decl.c:1894
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Error in pointer initialization at %C"
-msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %qD"
+msgstr "Ð\9eÑ\88Ð¸Ð±ÐºÐ° Ð² Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð² %C"
  
  #: fortran/decl.c:1901
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: non-NULL pointer initialization at %C"
  msgid "non-NULL pointer initialization at %C"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Fortran 2008: не-NULL инициализация указателя в %C"
  
  #: fortran/decl.c:1924
  #, fuzzy, gcc-internal-format
-#| msgid "section attribute not allowed for %q+D"
+#| msgid "Function name '%s' not allowed at %C"
  msgid "Function name %qs not allowed at %C"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 section Ð´Ð»Ñ\8f %q+D Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼"
+msgstr "Ð\98Ð¼Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s' Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f Ð² %C"
  
  #: fortran/decl.c:1991
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Non-PARAMETER symbol '%s' at %L can't be implied-shape"
  msgid "Non-PARAMETER symbol %qs at %L can't be implied-shape"
-msgstr ""
+msgstr "Не-PARAMETER символ '%s' в %L не может быть выводимой формы"
  
  #: fortran/decl.c:2001
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: Implied-shape array at %L"
  msgid "Implied-shape array at %L"
-msgstr "недопустимая инициализация многомерного массива при помощи инициализатора"
+msgstr "Fortran 2008: Массив выводимой формы в %L"
  
  #: fortran/decl.c:2054
  #, gcc-internal-format
@@ -50451,9 +52603,9 @@ msgid "%qs at %C is a redefinition of the declaration in the corresponding inter
  msgstr ""
  
  #: fortran/decl.c:2083 fortran/decl.c:6950
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate array spec for Cray pointee at %C"
-msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %D"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð´Ð»Ñ\8f Cray Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð² %C"
  
  #: fortran/decl.c:2091
  #, gcc-internal-format
@@ -50462,103 +52614,108 @@ msgstr ""
  
  #: fortran/decl.c:2154
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: Old-style initialization at %C"
  msgid "Old-style initialization at %C"
-msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %qD"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: Ð¡Ñ\82Ð°Ñ\80Ð¾Ð¼Ð¾Ð´Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð² %C"
  
  #: fortran/decl.c:2159
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "invalid value-initialization of reference type"
  msgid "Invalid old style initialization for derived type component at %C"
-msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f `%#D', Ð¸Ð¼ÐµÑ\8eÑ\89ÐµÐ³Ð¾ Ñ\82Ð¸Ð¿ Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ñ\87Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð°"
  
  #: fortran/decl.c:2176 fortran/decl.c:5265
  #, gcc-internal-format, gfc-internal-format
  msgid "Initialization at %C isn't for a pointer variable"
-msgstr ""
+msgstr "Инициализация в %C не для указательной переменной"
  
  #: fortran/decl.c:2189
  #, fuzzy, gcc-internal-format
+#| msgid "Pointer initialization at %C requires '=>', not '='"
  msgid "Pointer initialization at %C requires %<=>%>, not %<=%>"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð\98Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð² %C Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 '=>', Ð° Ð½Ðµ '='"
  
  #: fortran/decl.c:2198 fortran/decl.c:8325
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected an initialization expression at %C"
-msgstr ""
+msgstr "Ожидалось инициализационное выражение в %C"
  
  #: fortran/decl.c:2205
  #, gcc-internal-format, gfc-internal-format
  msgid "Initialization of variable at %C is not allowed in a PURE procedure"
-msgstr ""
+msgstr "Инициализация переменной в %C не допускается в PURE процедуре"
  
  #: fortran/decl.c:2222
  #, gcc-internal-format, gfc-internal-format
  msgid "Initialization of allocatable component at %C is not allowed"
-msgstr ""
+msgstr "Инициализация размещаемого компонента в %C не допускается"
  
  #: fortran/decl.c:2276 fortran/decl.c:2312
  #, gcc-internal-format, gfc-internal-format
  msgid "Old-style type declaration %s*%d not supported at %C"
-msgstr ""
+msgstr "Старомодная декларация типа %s*%d не поддерживается в %C"
  
  #: fortran/decl.c:2318
  #, gcc-internal-format, gfc-internal-format
  msgid "Nonstandard type declaration %s*%d at %C"
-msgstr ""
+msgstr "Нестандартная декларация типа %s*%d в %C"
  
  #: fortran/decl.c:2369 fortran/decl.c:2445
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Missing right parenthesis at %C"
-msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¾Ñ\82ÐºÑ\80Ñ\8bÐ²Ð°Ñ\8eÑ\89Ð°Ñ\8f Ñ\81ÐºÐ¾Ð±ÐºÐ°"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¿Ñ\80Ð°Ð²Ð°Ñ\8f Ñ\81ÐºÐ¾Ð±ÐºÐ° Ð² %C"
  
  #: fortran/decl.c:2382 fortran/decl.c:2516
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected initialization expression at %C"
-msgstr ""
+msgstr "Явное инициализационное выражение в %C"
  
  #: fortran/decl.c:2390 fortran/decl.c:2522
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected scalar initialization expression at %C"
-msgstr ""
+msgstr "Ожидалось скалярное инициализационное выражение в %C"
  
  #: fortran/decl.c:2421
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Kind %d not supported for type %s at %C"
-msgstr "режим округления для поддерживается для плавающих вычислений VAX"
+msgstr "Вид %d не поддерживается для типа %s в %C"
  
  #: fortran/decl.c:2434
  #, gcc-internal-format, gfc-internal-format
  msgid "C kind type parameter is for type %s but type at %L is %s"
-msgstr ""
+msgstr "C вид параметра типа задан для типа %s но тип в %L есть %s"
  
  #: fortran/decl.c:2443
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Missing right parenthesis or comma at %C"
-msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¾Ñ\82ÐºÑ\80Ñ\8bÐ²Ð°Ñ\8eÑ\89Ð°Ñ\8f Ñ\81ÐºÐ¾Ð±ÐºÐ°"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¿Ñ\80Ð°Ð²Ð°Ñ\8f Ñ\81ÐºÐ¾Ð±ÐºÐ° Ð¸Ð»Ð¸ Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² %C"
  
  #: fortran/decl.c:2542
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Kind %d is not supported for CHARACTER at %C"
-msgstr "режим округления для поддерживается для плавающих вычислений VAX"
+msgstr "Вид %d не поддерживается для CHARACTER в %C"
  
  #: fortran/decl.c:2674
  #, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in CHARACTER declaration at %C"
-msgstr ""
+msgstr "Синтаксическая ошибка в CHARACTER декларации в %C"
  
  #: fortran/decl.c:2759
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: BYTE type at %C"
  msgid "BYTE type at %C"
-msgstr ""
+msgstr "Расширение: BYTE тип в %C"
  
  #: fortran/decl.c:2764
  #, gcc-internal-format, gfc-internal-format
  msgid "BYTE type used at %C is not available on the target machine"
-msgstr ""
+msgstr "BYTE тип использованный в %C не доступен на целевой машине"
  
  #: fortran/decl.c:2786
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "By-value argument at %L is not allowed in this context"
  msgid "Assumed type at %C is not allowed for components"
-msgstr "стандартные преобразования в данном контексте недопустимы"
+msgstr "Аргумент по значению в %L не допускается в этом контексте"
  
  #: fortran/decl.c:2789
  #, gcc-internal-format, gfc-internal-format
@@ -50567,19 +52724,22 @@ msgstr ""
  
  #: fortran/decl.c:2812 fortran/decl.c:2843 fortran/decl.c:2872
  #: fortran/decl.c:3051
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: TYPE with intrinsic-type-spec at %C"
  msgid "TYPE with intrinsic-type-spec at %C"
-msgstr ""
+msgstr "Fortran 2008: TYPE с intrinsic-type-spec в %C"
  
  #: fortran/decl.c:2868
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: DOUBLE COMPLEX at %C"
  msgid "DOUBLE COMPLEX at %C"
-msgstr ""
+msgstr "Расширение: DOUBLE COMPLEX в %C"
  
  #: fortran/decl.c:2942
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: CLASS statement at %C"
  msgid "CLASS statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: CLASS оператор в %C"
  
  #: fortran/decl.c:2977 fortran/decl.c:2990 fortran/decl.c:3446
  #: fortran/decl.c:3454
@@ -50589,14 +52749,15 @@ msgid "Type name %qs at %C is ambiguous"
  msgstr "Имя типа '%s' в %C неоднозначно"
  
  #: fortran/decl.c:3005
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Type name '%s' at %C conflicts with previously declared entity at %L, which has the same name"
  msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
-msgstr ""
+msgstr "Имя типа '%s' в %C конфликтует с ранее декларированной сущностью в %L, которая имеет то же имя"
  
  #: fortran/decl.c:3122
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate IMPLICIT NONE statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ IMPLICIT NONE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/decl.c:3131
  #, gcc-internal-format, gfc-internal-format
@@ -50606,122 +52767,134 @@ msgstr ""
  #: fortran/decl.c:3190
  #, gcc-internal-format, gfc-internal-format
  msgid "Missing character range in IMPLICIT at %C"
-msgstr ""
+msgstr "Отсутствует символьный диапазон в IMPLICIT в %C"
  
  #: fortran/decl.c:3236
  #, gcc-internal-format, gfc-internal-format
  msgid "Letters must be in alphabetic order in IMPLICIT statement at %C"
-msgstr ""
+msgstr "Буквы должны быть в алфавитном порядке в IMPLICIT операторе в %C"
  
  #: fortran/decl.c:3289
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "SAVE statement at %C follows blanket SAVE statement"
  msgid "IMPLICIT statement at %C following an IMPLICIT NONE (type) statement"
-msgstr "оператор PUBLIC или PRIVATE в %1 несовместим с оператором PUBLIC или PRIVATE в %0"
+msgstr "SAVE оператор в %C следует за общим SAVE оператором"
  
  #: fortran/decl.c:3299
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Empty IMPLICIT statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ IMPLICIT Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/decl.c:3405
  #, gcc-internal-format, gfc-internal-format
  msgid "IMPORT statement at %C only permitted in an INTERFACE body"
-msgstr ""
+msgstr "IMPORT оператор в %C допустим только в INTERFACE теле"
  
  #: fortran/decl.c:3412
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "IMPORT statement at %C only permitted in an INTERFACE body"
  msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
-msgstr ""
+msgstr "IMPORT оператор в %C допустим только в INTERFACE теле"
  
  #: fortran/decl.c:3417
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Empty IMPLICIT statement at %C"
  msgid "IMPORT statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ IMPLICIT Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/decl.c:3431
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expecting list of named entities at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°ÐµÑ\82Ñ\81Ñ\8f Ñ\81Ð¿Ð¸Ñ\81Ð¾Ðº Ð¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð½Ñ\8bÑ\85 Ñ\81Ñ\83Ñ\89Ð½Ð¾Ñ\81Ñ\82ÐµÐ¹ Ð² %C"
  
  #: fortran/decl.c:3460
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Cannot IMPORT '%s' from host scoping unit at %C - does not exist."
  msgid "Cannot IMPORT %qs from host scoping unit at %C - does not exist."
-msgstr ""
+msgstr "Невозможно IMPORT '%s' из единицы компиляции уровня хоста в %C - не существует."
  
  #: fortran/decl.c:3467
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' is already IMPORTed from host scoping unit at %C."
  msgid "%qs is already IMPORTed from host scoping unit at %C"
-msgstr ""
+msgstr "'%s' уже IMPORTed из единицы компиляции уровня хоста в %C."
  
  #: fortran/decl.c:3510
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in IMPORT statement at %C"
-msgstr "синтаксическая ошибка при разборе `%s'"
+msgstr "Синтаксическая ошибка в IMPORT операторе в %C"
  
  #: fortran/decl.c:3809
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Missing codimension specification at %C"
-msgstr "Отсутствует спецификатор %A в операторе в %0"
+msgstr "Отсутствует спецификатор коизмерения в %C"
  
  #: fortran/decl.c:3811
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Missing dimension specification at %C"
-msgstr "Отсутствует спецификатор %A в операторе в %0"
+msgstr "Отсутствует спецификатор измерения в %C"
  
  #: fortran/decl.c:3894
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate %s attribute at %L"
-msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð¾Ðµ Ñ\83Ð¿Ð¾Ñ\82Ñ\80ÐµÐ±Ð»ÐµÐ½Ð¸Ðµ `restrict'"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ %s Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ð² %L"
  
  #: fortran/decl.c:3913
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ALLOCATABLE attribute at %C in a TYPE definition"
  msgid "ALLOCATABLE attribute at %C in a TYPE definition"
-msgstr "атрибуты не допускаются при определении функции"
+msgstr "Fortran 2003: ALLOCATABLE атрибут в %C в TYPE определении"
  
  #: fortran/decl.c:3922
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Attribute at %L is not allowed in a TYPE definition"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f Ð¿Ñ\80Ð¸ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86ии"
+msgstr "Ð\90Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ð² %L Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f Ð² TYPE Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½ии"
  
  #: fortran/decl.c:3940
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: Attribute %s at %L in a TYPE definition"
  msgid "Attribute %s at %L in a TYPE definition"
-msgstr "атрибуты не допускаются при определении функции"
+msgstr "Fortran 2003: Атрибут %s в %L в TYPE определении"
  
  #: fortran/decl.c:3950
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s attribute at %L is not allowed outside of the specification part of a module"
-msgstr "%Jатрибут section для `%D' недопустим"
+msgstr "%s атрибут в %L не допускается вне спецификационной части модуля"
  
  #: fortran/decl.c:3964
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ASYNCHRONOUS attribute at %C"
  msgid "ASYNCHRONOUS attribute at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: ASYNCHRONOUS атрибут в %C"
  
  #: fortran/decl.c:3975
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: CONTIGUOUS attribute at %C"
  msgid "CONTIGUOUS attribute at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: CONTIGUOUS атрибут в %C"
  
  #: fortran/decl.c:4022 fortran/decl.c:7246
  #, gcc-internal-format, gfc-internal-format
  msgid "PROTECTED at %C only allowed in specification part of a module"
-msgstr ""
+msgstr "PROTECTED в %C допускается только в спецификационной части модуля"
  
  #: fortran/decl.c:4028
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: PROTECTED attribute at %C"
  msgid "PROTECTED attribute at %C"
-msgstr "повторное употребление `restrict'"
+msgstr "Fortran 2003: PROTECTED атрибут в %C"
  
  #: fortran/decl.c:4057
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: VALUE attribute at %C"
  msgid "VALUE attribute at %C"
-msgstr "%Jinline функция %qD с атрибутом noinline"
+msgstr "Fortran 2003: VALUE атрибут в %C"
  
  #: fortran/decl.c:4064
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: VOLATILE attribute at %C"
  msgid "VOLATILE attribute at %C"
-msgstr "%Jinline функция %qD с атрибутом noinline"
+msgstr "Fortran 2003: VOLATILE атрибут в %C"
  
  #: fortran/decl.c:4071
  #, gcc-internal-format
@@ -50731,69 +52904,79 @@ msgstr ""
  #: fortran/decl.c:4111
  #, gcc-internal-format, gfc-internal-format
  msgid "Multiple identifiers provided with single NAME= specifier at %C"
-msgstr ""
+msgstr "Несколько идентификаторов задано с одним NAME= спецификатором в %C"
  
  #: fortran/decl.c:4209
  #, fuzzy, gcc-internal-format
+#| msgid "Implicitly declared BIND(C) function '%s' at %L may not be C interoperable"
  msgid "Implicitly declared BIND(C) function %qs at %L may not be C interoperable"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "Неявно декларированная BIND(C) функция '%s' в %L может не быть C совместимой"
  
  #: fortran/decl.c:4231
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' in common block '%s' at %L may not be a C interoperable kind though common block '%s' is BIND(C)"
  msgid "Variable %qs in common block %qs at %L may not be a C interoperable kind though common block %qs is BIND(C)"
-msgstr ""
+msgstr "Переменная '%s' в common блоке '%s' в %L может не быть C совместимого вида хотя common блок '%s' есть BIND(C)"
  
  #: fortran/decl.c:4240
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Type declaration '%s' at %L is not C interoperable but it is BIND(C)"
  msgid "Type declaration %qs at %L is not C interoperable but it is BIND(C)"
-msgstr ""
+msgstr "Декларация типа '%s' at %L не является C совместимой но входит в BIND(C)"
  
  #: fortran/decl.c:4244
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L may not be a C interoperable kind but it is bind(c)"
  msgid "Variable %qs at %L may not be a C interoperable kind but it is BIND(C)"
-msgstr ""
+msgstr "Переменная '%s' в %L может не быть C совместимого вида но входит в bind(c)"
  
  #: fortran/decl.c:4256
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' in common block '%s' at %L cannot be declared with BIND(C) since it is not a global"
  msgid "Variable %qs in common block %qs at %L cannot be declared with BIND(C) since it is not a global"
-msgstr ""
+msgstr "Переменная '%s' в common блоке '%s' в %L не может быть декларирована с BIND(C) поскольку она не является глобальной"
  
  #: fortran/decl.c:4270
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes"
  msgid "Variable %qs at %L cannot have both the POINTER and BIND(C) attributes"
-msgstr "Ð¾Ñ\82Ð¼ÐµÐ½Ð° Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %qD Ð² Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ðµ Ð¸Ð¼Ñ\91Ð½ %qD"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð¸Ð¼ÐµÑ\82Ñ\8c Ð¾Ð±Ð° Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° POINTER Ð¸ BIND(C)"
  
  #: fortran/decl.c:4278
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
  msgid "Variable %qs at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
-msgstr "Ð¾Ñ\82Ð¼ÐµÐ½Ð° Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %qD Ð² Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ðµ Ð¸Ð¼Ñ\91Ð½ %qD"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð¸Ð¼ÐµÑ\82Ñ\8c Ð¾Ð±Ð° Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° ALLOCATABLE Ð¸ BIND(C)"
  
  #: fortran/decl.c:4290
  #, fuzzy, gcc-internal-format
+#| msgid "Return type of BIND(C) function '%s' at %L cannot be an array"
  msgid "Return type of BIND(C) function %qs at %L cannot be an array"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "Возвращаемый тип BIND(C) функции '%s' в %L не может быть массивом"
  
  #: fortran/decl.c:4298
  #, fuzzy, gcc-internal-format
+#| msgid "Return type of BIND(C) function '%s' at %L cannot be a character string"
  msgid "Return type of BIND(C) function %qs at %L cannot be a character string"
-msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80 Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð¼-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ðµй"
+msgstr "Ð\92Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÐ¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ BIND(C) Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c character Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾й"
  
  #. Use gfc_warning_now because we won't say that the symbol fails
  #. just because of this.
  #: fortran/decl.c:4309
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %L is marked PRIVATE but has been given the binding label '%s'"
  msgid "Symbol %qs at %L is marked PRIVATE but has been given the binding label %qs"
-msgstr ""
+msgstr "Символ '%s' в %L помечен как PRIVATE но получил связывающую метку '%s'"
  
  #: fortran/decl.c:4383
  #, gcc-internal-format, gfc-internal-format
  msgid "Need either entity or common block name for attribute specification statement at %C"
-msgstr ""
+msgstr "Требуется имя либо сущности либо common блока для оператора спецификации атрибутов в %C"
  
  #: fortran/decl.c:4428
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Missing entity or common block name for attribute specification statement at %C"
-msgstr "Отсутствует спецификатор %A в операторе в %0"
+msgstr "Отсутствует имя сущности или common блока для оператора спецификации атрибутов в %C"
  
  #: fortran/decl.c:4435
  #, fuzzy, gcc-internal-format
@@ -50803,53 +52986,58 @@ msgstr "отсутствует число"
  
  #: fortran/decl.c:4464
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Empty IMPLICIT statement at %C"
  msgid "BIND(C) statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ IMPLICIT Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/decl.c:4542
  #, gcc-internal-format, gfc-internal-format
  msgid "Derived type at %C has not been previously defined and so cannot appear in a derived type definition"
-msgstr ""
+msgstr "Производный тип в %C не был ранее определен и поэтому не может появляться в определении производного типа"
  
  #: fortran/decl.c:4574
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in data declaration at %C"
-msgstr "синтаксическая ошибка в списке параметров макроса"
+msgstr "Синтаксическая ошибка в декларации данных в %C"
  
  #: fortran/decl.c:4615
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "MODULE prefix at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr ""
  
  #: fortran/decl.c:4660
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: IMPURE procedure at %C"
  msgid "IMPURE procedure at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: IMPURE процедура в %C"
  
  #: fortran/decl.c:4672
  #, gcc-internal-format, gfc-internal-format
  msgid "PURE and IMPURE must not appear both at %C"
-msgstr ""
+msgstr "PURE и IMPURE не должны оба появляться в %C"
  
  #: fortran/decl.c:4756 fortran/primary.c:1779
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Expected alternate return label at %C"
  msgid "Alternate-return argument at %C"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ð¼ÐµÑ\82ÐºÐ° Ð°Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ð¾Ð³Ð¾ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² %C"
  
  #: fortran/decl.c:4802
  #, fuzzy, gcc-internal-format
+#| msgid "Name '%s' at %C is the name of the procedure"
  msgid "Name %qs at %C is the name of the procedure"
-msgstr "`%D' не является элементом типа `%T'"
+msgstr "Имя '%s' в %C есть имя процедуры"
  
  #: fortran/decl.c:4814
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk in formal argument list at %C"
-msgstr "Неожиданное окончание строки формата"
+msgstr "Неожиданный мусор в списке формальных аргументов в %C"
  
  #: fortran/decl.c:4831
  #, fuzzy, gcc-internal-format
+#| msgid "Duplicate symbol '%s' in formal argument list at %C"
  msgid "Duplicate symbol %qs in formal argument list at %C"
-msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð¾Ðµ Ð¾ÐºÐ¾Ð½Ñ\87Ð°Ð½Ð¸Ðµ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ñ\8fÑ\8eÑ\89Ð¸Ð¹Ñ\81Ñ\8f Ñ\81Ð¸Ð¼Ð²Ð¾Ð» '%s' Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² %C"
  
  #: fortran/decl.c:4870
  #, gcc-internal-format, gfc-internal-format
@@ -50857,191 +53045,202 @@ msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
  msgstr ""
  
  #: fortran/decl.c:4876
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr ""
  
  #: fortran/decl.c:4915
  #, gcc-internal-format, gfc-internal-format
  msgid "RESULT variable at %C must be different than function name"
-msgstr ""
+msgstr "RESULT переменная в %C должна отличаться от имени функции"
  
  #: fortran/decl.c:4992
  #, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after function declaration at %C"
-msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f в %C"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ в %C"
  
  #: fortran/decl.c:5002 fortran/decl.c:6095
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: BIND(C) attribute at %L may not be specified for an internal procedure"
  msgid "BIND(C) attribute at %L may not be specified for an internal procedure"
-msgstr "оператор SAVE или атрибут в %1 несовместим с оператором SAVE или атрибутом в %0"
+msgstr "Fortran 2008: BIND(C) атрибут в %L не может быть специфицирован для внутренней процедуры"
  
  #: fortran/decl.c:5204
  #, gcc-internal-format, gfc-internal-format
  msgid "BIND(C) attribute at %C requires an interface with BIND(C)"
-msgstr ""
+msgstr "BIND(C) атрибут в %C требует интерфейс с BIND(C)"
  
  #: fortran/decl.c:5211
  #, gcc-internal-format, gfc-internal-format
  msgid "BIND(C) procedure with NAME may not have POINTER attribute at %C"
-msgstr ""
+msgstr "BIND(C) процедура с NAME не может иметь POINTER атрибут в %C"
  
  #: fortran/decl.c:5217
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Dummy procedure at %C may not have BIND(C) attribute with NAME"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Формальным процедура в %C не может иметь BIND(C) атрибут с NAME"
  
  #: fortran/decl.c:5240
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' at %L already has basic type of %s"
  msgid "Procedure %qs at %L already has basic type of %s"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 тип %s"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' Ð² %L Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð±Ð°Ð·Ð¾Ð²Ñ\8bÐ¹ тип %s"
  
  #: fortran/decl.c:5286 fortran/decl.c:5474 fortran/decl.c:8806
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in PROCEDURE statement at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ PROCEDURE Ð² %C"
  
  #: fortran/decl.c:5335 fortran/decl.c:8708
  #, fuzzy, gcc-internal-format
+#| msgid "Expected '::' after binding-attributes at %C"
  msgid "Expected %<::%> after binding-attributes at %C"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85, Ð²Ñ\81Ñ\82Ñ\80ÐµÑ\82Ð¸Ð²Ñ\88Ð¸Ñ\85Ñ\81Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð²"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c '::' Ð¿Ð¾Ñ\81Ð»Ðµ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð² Ñ\81Ð²Ñ\8fÐ·Ñ\8bÐ²Ð°Ð½Ð¸Ñ\8f Ð² %C"
  
  #: fortran/decl.c:5342
  #, gcc-internal-format, gfc-internal-format
  msgid "NOPASS or explicit interface required at %C"
-msgstr ""
+msgstr "NOPASS или явный интерфейс требуются в %C"
  
  #: fortran/decl.c:5346
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: Procedure pointer component at %C"
  msgid "Procedure pointer component at %C"
-msgstr "Недопустимое число в операторе FORMAT в %0"
+msgstr "Fortran 2003: Компонент указателя на процедуру в %C"
  
  #: fortran/decl.c:5418
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in procedure pointer component at %C"
-msgstr "синтаксическая ошибка при разборе `%s'"
+msgstr "Синтаксическая ошибка в компоненте указателя на процедуру в %C"
  
  #: fortran/decl.c:5436
  #, gcc-internal-format, gfc-internal-format
  msgid "PROCEDURE at %C must be in a generic interface"
-msgstr ""
+msgstr "PROCEDURE в %C должна быть в generic интерфейсе"
  
  #: fortran/decl.c:5445 fortran/decl.c:7837
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: double colon in MODULE PROCEDURE statement at %L"
  msgid "double colon in MODULE PROCEDURE statement at %L"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: двойное двоеточие в MODULE PROCEDURE операторе в %L"
  
  #: fortran/decl.c:5515
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: PROCEDURE statement at %C"
  msgid "PROCEDURE statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: PROCEDURE оператор в %C"
  
  #: fortran/decl.c:5587
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected formal argument list in function definition at %C"
-msgstr "Ð\92 Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸ Ð² %C Ð¾Ð¶Ð¸Ð´Ð°ÐµÑ\82Ñ\81Ñ\8f Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\81Ð¿Ð¸Ñ\81Ð¾Ðº Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð²"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ñ\81Ð¿Ð¸Ñ\81Ð¾Ðº Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð² %C"
  
  #: fortran/decl.c:5611 fortran/decl.c:5615 fortran/decl.c:5867
  #: fortran/decl.c:5871 fortran/decl.c:6063 fortran/decl.c:6067
  #: fortran/symbol.c:1712
  #, gcc-internal-format, gfc-internal-format
  msgid "BIND(C) attribute at %L can only be used for variables or common blocks"
-msgstr ""
+msgstr "BIND(C) атрибут в %L может использоваться только для переменных или common блоков"
  
  #: fortran/decl.c:5769
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Empty IMPLICIT statement at %C"
  msgid "ENTRY statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ IMPLICIT Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/decl.c:5778
  #, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear within a PROGRAM"
-msgstr ""
+msgstr "ENTRY оператор в %C не может появляться внутри PROGRAM"
  
  #: fortran/decl.c:5781
  #, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear within a MODULE"
-msgstr ""
+msgstr "ENTRY оператор в %C не может появляться внутри MODULE"
  
  #: fortran/decl.c:5784
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "ENTRY statement at %C cannot appear within a MODULE"
  msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "ENTRY оператор в %C не может появляться внутри MODULE"
  
  #: fortran/decl.c:5787
  #, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear within a BLOCK DATA"
-msgstr ""
+msgstr "ENTRY оператор в %C не может появляться внутри BLOCK DATA"
  
  #: fortran/decl.c:5791 fortran/decl.c:5832
  #, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear within an INTERFACE"
-msgstr ""
+msgstr "ENTRY оператор в %C не может появляться внутри INTERFACE"
  
  #: fortran/decl.c:5795
  #, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear within a DERIVED TYPE block"
-msgstr ""
+msgstr "ENTRY оператор в %C не может появляться внутри DERIVED TYPE блока"
  
  #: fortran/decl.c:5799
  #, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear within an IF-THEN block"
-msgstr ""
+msgstr "ENTRY оператор в %C не может появляться внутри IF-THEN блока"
  
  #: fortran/decl.c:5804
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear within a DO block"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "ENTRY оператор в %C не может появляться внутри DO блока"
  
  #: fortran/decl.c:5808
  #, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear within a SELECT block"
-msgstr ""
+msgstr "ENTRY оператор в %C не может появляться внутри SELECT блока"
  
  #: fortran/decl.c:5812
  #, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear within a FORALL block"
-msgstr ""
+msgstr "ENTRY оператор в %C не может появляться внутри FORALL блока"
  
  #: fortran/decl.c:5816
  #, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear within a WHERE block"
-msgstr ""
+msgstr "ENTRY оператор в %C не может появляться внутри WHERE блока"
  
  #: fortran/decl.c:5820
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear within a contained subprogram"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "ENTRY оператор в %C не может появляться внутри внутренней подпрограммы"
  
  #: fortran/decl.c:5824
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unexpected END statement at %C"
  msgid "Unexpected ENTRY statement at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ END Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/decl.c:5845
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear in a contained procedure"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "ENTRY оператор в %C не может появляться внутри внутренней процедуры"
  
  #: fortran/decl.c:5896 fortran/decl.c:6102
  #, gcc-internal-format, gfc-internal-format
  msgid "Missing required parentheses before BIND(C) at %C"
-msgstr ""
+msgstr "Отсутствуют обязательные скобки перед BIND(C) в %C"
  
  #: fortran/decl.c:6164 fortran/decl.c:6171
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Invalid C name in NAME= specifier at %C"
  msgid "Invalid C identifier in NAME= specifier at %C"
-msgstr "Ð\9fÑ\80Ð¾Ð¿Ñ\83Ñ\89ÐµÐ½Ð° Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ C Ð¸Ð¼Ñ\8f Ð² NAME= Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:6211
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in NAME= specifier for binding label at %C"
-msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² NAME= Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ðµ Ð´Ð»Ñ\8f Ñ\81Ð²Ñ\8fÐ·Ñ\8bÐ²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð¼ÐµÑ\82ÐºÐ¸ Ð² %C"
  
  #: fortran/decl.c:6227
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "ASYNCHRONOUS= specifier at %L must be an initialization expression"
  msgid "NAME= specifier at %C should be a constant expression"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "ASYNCHRONOUS= спецификатор в %L должен быть инициализационным выражением"
  
  #: fortran/decl.c:6235
  #, gcc-internal-format, gfc-internal-format
@@ -51049,110 +53248,115 @@ msgid "NAME= specifier at %C should be a scalar of default character kind"
  msgstr ""
  
  #: fortran/decl.c:6254
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Missing closing paren for binding label at %C"
-msgstr "Отсутствует формальный параметр"
+msgstr "Отсутствует закрывающая скобка для связывающей метки в %C"
  
  #: fortran/decl.c:6260
  #, gcc-internal-format, gfc-internal-format
  msgid "No binding name is allowed in BIND(C) at %C"
-msgstr ""
+msgstr "Связывающее имя не допускается в BIND(C) в %C"
  
  #: fortran/decl.c:6266
  #, gcc-internal-format, gfc-internal-format
  msgid "For dummy procedure %s, no binding name is allowed in BIND(C) at %C"
-msgstr ""
+msgstr "Для формальной процедуры %s связывающее имя не допускается в BIND(C) в %C"
  
  #: fortran/decl.c:6295
  #, gcc-internal-format, gfc-internal-format
  msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C"
-msgstr ""
+msgstr "NAME не допускается в BIND(C) для ABSTRACT INTERFACE в %C"
  
  #: fortran/decl.c:6520
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected END statement at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ END Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/decl.c:6529
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: END statement instead of %s statement at %L"
  msgid "END statement instead of %s statement at %L"
-msgstr "Недопустимое число в операторе FORMAT в %0"
+msgstr "Fortran 2008: END оператор вместо %s оператора в %L"
  
  #. We would have required END [something].
  #: fortran/decl.c:6538
  #, gcc-internal-format, gfc-internal-format
  msgid "%s statement expected at %L"
-msgstr ""
+msgstr "%s оператор ожидался в %L"
  
  #: fortran/decl.c:6549
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Expecting %s statement at %C"
  msgid "Expecting %s statement at %L"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°ÐµÑ\82Ñ\81Ñ\8f %s Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/decl.c:6569
  #, fuzzy, gcc-internal-format
+#| msgid "Expected block name of '%s' in %s statement at %C"
  msgid "Expected block name of %qs in %s statement at %L"
-msgstr "Ð\9dÐµÑ\82 Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð¼ÐµÑ\82ÐºÐ¸ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° FORMAT Ð² %0"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ð±Ð»Ð¾ÐºÐ° Ð¾Ñ\82 '%s' Ð² %s Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:6586
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected terminating name at %C"
-msgstr ""
+msgstr "Ожидалось завершающее имя в %C"
  
  #: fortran/decl.c:6600 fortran/decl.c:6608
  #, fuzzy, gcc-internal-format
+#| msgid "Expected label '%s' for %s statement at %C"
  msgid "Expected label %qs for %s statement at %C"
-msgstr "Ð\9dÐµÑ\82 Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð¼ÐµÑ\82ÐºÐ¸ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° FORMAT Ð² %0"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ð¼ÐµÑ\82ÐºÐ° '%s' Ð´Ð»Ñ\8f %s Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/decl.c:6707
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Missing array specification at %L in DIMENSION statement"
-msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 %A Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %0"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %L Ð² DIMENSION Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ"
  
  #: fortran/decl.c:6715
  #, gcc-internal-format, gfc-internal-format
  msgid "Dimensions specified for %s at %L after its initialisation"
-msgstr ""
+msgstr "Измерение специфицировано для %s в %L после его инициализации"
  
  #: fortran/decl.c:6723
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Missing array specification at %L in CODIMENSION statement"
-msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 %A Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %0"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %L Ð² CODIMENSION Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ"
  
  #: fortran/decl.c:6732
  #, gcc-internal-format, gfc-internal-format
  msgid "Array specification must be deferred at %L"
-msgstr ""
+msgstr "Спецификация массива должна быть отложенной в %L"
  
  #: fortran/decl.c:6830
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected character in variable list at %C"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85, Ð²Ñ\81Ñ\82Ñ\80ÐµÑ\82Ð¸Ð²Ñ\88Ð¸Ñ\85Ñ\81Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð²"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð¼Ð²Ð¾Ð» Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85 Ð² %C"
  
  #: fortran/decl.c:6867
  #, fuzzy, gcc-internal-format
+#| msgid "Expected '(' at %C"
  msgid "Expected %<(%> at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c '(' Ð² %C"
  
  #: fortran/decl.c:6881 fortran/decl.c:6921
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected variable name at %C"
-msgstr ""
+msgstr "Ожидалось имя переменной в %C"
  
  #: fortran/decl.c:6897
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Cray pointer at %C must be an integer"
-msgstr "предикат должен быть идентификатором"
+msgstr "Cray указатель в %C должен быть целым"
  
  #: fortran/decl.c:6901
  #, gcc-internal-format, gfc-internal-format
  msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes"
-msgstr ""
+msgstr "Cray указатель в %C имеет %d байт точности; адреса памяти требуют %d байт"
  
  #: fortran/decl.c:6907
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected \",\" at %C"
-msgstr ""
+msgstr "Ожидалась \",\" в %C"
  
  #: fortran/decl.c:6946
  #, gcc-internal-format
@@ -51162,447 +53366,480 @@ msgstr ""
  #: fortran/decl.c:6970
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected \")\" at %C"
-msgstr ""
+msgstr "Ожидалась \")\" в %C"
  
  #: fortran/decl.c:6982
  #, fuzzy, gcc-internal-format
+#| msgid "Expected \",\" or end of statement at %C"
  msgid "Expected %<,%> or end of statement at %C"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85, Ð²Ñ\81Ñ\82Ñ\80ÐµÑ\82Ð¸Ð²Ñ\88Ð¸Ñ\85Ñ\81Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð²"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c \",\" Ð¸Ð»Ð¸ Ð¾ÐºÐ¾Ð½Ñ\87Ð°Ð½Ð¸Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/decl.c:7008
  #, gcc-internal-format, gfc-internal-format
  msgid "INTENT is not allowed inside of BLOCK at %C"
-msgstr ""
+msgstr "INTENT не допускается внутри BLOCK в %C"
  
  #: fortran/decl.c:7040
  #, gcc-internal-format, gfc-internal-format
  msgid "OPTIONAL is not allowed inside of BLOCK at %C"
-msgstr ""
+msgstr "OPTIONAL не допускается внутри BLOCK в %C"
  
  #: fortran/decl.c:7059
  #, gcc-internal-format, gfc-internal-format
  msgid "Cray pointer declaration at %C requires -fcray-pointer flag"
-msgstr ""
+msgstr "Декларация Cray указателя в %C требует -fcray-pointer флаг"
  
  #: fortran/decl.c:7098
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: CONTIGUOUS statement at %C"
  msgid "CONTIGUOUS statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: CONTIGUOUS оператор в %C"
  
  #: fortran/decl.c:7196
  #, gcc-internal-format, gfc-internal-format
  msgid "Access specification of the %s operator at %C has already been specified"
-msgstr ""
+msgstr "Спецификация доступа %s оператора в %C уже была специфицирована"
  
  #: fortran/decl.c:7213
  #, gcc-internal-format, gfc-internal-format
  msgid "Access specification of the .%s. operator at %C has already been specified"
-msgstr ""
+msgstr "Спецификация доступа .%s. оператора в %C уже была специфицирована"
  
  #: fortran/decl.c:7252
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: PROTECTED statement at %C"
  msgid "PROTECTED statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: PROTECTED оператор в %C"
  
  #: fortran/decl.c:7290
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in PROTECTED statement at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² PROTECTED Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:7314
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "PRIVATE statement at %C is only allowed in the specification part of a module"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "PRIVATE оператор в %C допустим только в спецификационной части модуля"
  
  #: fortran/decl.c:7351
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "PUBLIC statement at %C is only allowed in the specification part of a module"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "PUBLIC оператор в %C допустим только в спецификационной части модуля"
  
  #: fortran/decl.c:7379
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected variable name at %C in PARAMETER statement"
-msgstr ""
+msgstr "Ожидалось имя переменной в %C в PARAMETER операторе"
  
  #: fortran/decl.c:7386
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected = sign in PARAMETER statement at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ð·Ð½Ð°Ðº Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f = Ð·Ð½Ð°Ðº Ð² PARAMETER Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:7392
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected expression at %C in PARAMETER statement"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85, Ð²Ñ\81Ñ\82Ñ\80ÐµÑ\82Ð¸Ð²Ñ\88Ð¸Ñ\85Ñ\81Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð²"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² %C Ð² PARAMETER Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ"
  
  #: fortran/decl.c:7412
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Initializing already initialized variable at %C"
-msgstr "строка инициализации усечена в соответствии с размером переменной в %L"
+msgstr "Инициализация уже инициализированной переменной в %C"
  
  #: fortran/decl.c:7447
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected characters in PARAMETER statement at %C"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85, Ð²Ñ\81Ñ\82Ñ\80ÐµÑ\82Ð¸Ð²Ñ\88Ð¸Ñ\85Ñ\81Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð²"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐµ Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ñ\8b Ð² PARAMETER Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:7471
  #, gcc-internal-format, gfc-internal-format
  msgid "Blanket SAVE statement at %C follows previous SAVE statement"
-msgstr ""
+msgstr "Общий SAVE оператор в %C следует за предыдущим SAVE оператором"
  
  #: fortran/decl.c:7482
  #, gcc-internal-format, gfc-internal-format
  msgid "SAVE statement at %C follows blanket SAVE statement"
-msgstr ""
+msgstr "SAVE оператор в %C следует за общим SAVE оператором"
  
  #: fortran/decl.c:7528
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in SAVE statement at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² SAVE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:7542
  #, gcc-internal-format, gfc-internal-format
  msgid "VALUE is not allowed inside of BLOCK at %C"
-msgstr ""
+msgstr "VALUE не допускается внутри BLOCK в %C"
  
  #: fortran/decl.c:7546
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: VALUE statement at %C"
  msgid "VALUE statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: VALUE оператор в %C"
  
  #: fortran/decl.c:7584
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in VALUE statement at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² VALUE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:7595
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: VOLATILE statement at %C"
  msgid "VOLATILE statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: VOLATILE оператор в %C"
  
  #: fortran/decl.c:7618
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Specifying VOLATILE for coarray variable '%s' at %C, which is use-/host-associated"
  msgid "Specifying VOLATILE for coarray variable %qs at %C, which is use-/host-associated"
-msgstr ""
+msgstr "Указание VOLATILE для комассивной переменной '%s' в %C, которая является use-/host-associated"
  
  #: fortran/decl.c:7643
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in VOLATILE statement at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² VOLATILE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:7654
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ASYNCHRONOUS statement at %C"
  msgid "ASYNCHRONOUS statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: ASYNCHRONOUS оператор в %C"
  
  #: fortran/decl.c:7694
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in ASYNCHRONOUS statement at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² ASYNCHRONOUS Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:7719
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "MODULE PROCEDURE declaration at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr ""
  
  #: fortran/decl.c:7812
  #, gcc-internal-format, gfc-internal-format
  msgid "MODULE PROCEDURE at %C must be in a generic module interface"
-msgstr ""
+msgstr "MODULE PROCEDURE в %C должна быть в generic module interface"
  
  #: fortran/decl.c:7870
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Intrinsic procedure at %L cannot be a MODULE PROCEDURE"
-msgstr "Внешняя процедура `%A' передана как фактический аргумент в %0, но не декларирована явно как EXTERNAL"
+msgstr "Встроенная процедура в %L не может быть MODULE PROCEDURE"
  
  #: fortran/decl.c:7919
  #, gcc-internal-format, gfc-internal-format
  msgid "Ambiguous symbol in TYPE definition at %C"
-msgstr ""
+msgstr "Неоднозначный символ в TYPE определении в %C"
  
  #: fortran/decl.c:7928
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %C has already been host associated"
  msgid "Symbol %qs at %C has not been previously defined"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Символ '%s' в %C уже был host ассоциирован"
  
  #: fortran/decl.c:7934
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' in EXTENDS expression at %C is not a derived type"
  msgid "%qs in EXTENDS expression at %C is not a derived type"
-msgstr ""
+msgstr "'%s' в EXTENDS выражении в %C не есть производный тип"
  
  #: fortran/decl.c:7941
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' cannot be extended at %C because it is BIND(C)"
  msgid "%qs cannot be extended at %C because it is BIND(C)"
-msgstr ""
+msgstr "'%s' не может быть расширено в %C поскольку оно BIND(C)"
  
  #: fortran/decl.c:7948
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' cannot be extended at %C because it is a SEQUENCE type"
  msgid "%qs cannot be extended at %C because it is a SEQUENCE type"
-msgstr "%qD не может быть локально-поточным, поскольку имеет не-POD тип %qT"
+msgstr "'%s' не может быть расширено в %C поскольку оно SEQUENCE тип"
  
  #: fortran/decl.c:7971
  #, gcc-internal-format, gfc-internal-format
  msgid "Derived type at %C can only be PRIVATE in the specification part of a module"
-msgstr ""
+msgstr "Производный тип в %C может быть только PRIVATE в спецификационной части модуля"
  
  #: fortran/decl.c:7983
  #, gcc-internal-format, gfc-internal-format
  msgid "Derived type at %C can only be PUBLIC in the specification part of a module"
-msgstr ""
+msgstr "Производный тип в %C может быть только PUBLIC в спецификационной части модуля"
  
  #: fortran/decl.c:8004
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "ABSTRACT type '%s' used at %L"
  msgid "ABSTRACT type at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "ABSTRACT тип '%s' использован в %L"
  
  #: fortran/decl.c:8068
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected :: in TYPE definition at %C"
-msgstr ""
+msgstr "Ожидалось :: в TYPE определении в %C"
  
  #: fortran/decl.c:8079
  #, fuzzy, gcc-internal-format
+#| msgid "Type name '%s' at %C cannot be the same as an intrinsic type"
  msgid "Type name %qs at %C cannot be the same as an intrinsic type"
-msgstr "Имя типа в %0 не совпадает с именем, заданным в %1"
+msgstr "Имя типа в '%s' в %C не может быть тем же что у встроенного типа"
  
  #: fortran/decl.c:8089
  #, fuzzy, gcc-internal-format
+#| msgid "Derived type name '%s' at %C already has a basic type of %s"
  msgid "Derived type name %qs at %C already has a basic type of %s"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %s"
+msgstr "Ð\98Ð¼Ñ\8f Ð¿Ñ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð±Ð°Ð·Ð¾Ð²Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð² %s"
  
  #: fortran/decl.c:8106
  #, fuzzy, gcc-internal-format
+#| msgid "Derived type definition of '%s' at %C has already been defined"
  msgid "Derived type definition of %qs at %C has already been defined"
-msgstr "Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ %qD Ñ\83Ð¶Ðµ ÐµÑ\81Ñ\82Ñ\8c Ð² %qT"
+msgstr "Ð\9eÐ¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° '%s' at %C Ñ\83Ð¶Ðµ Ð±Ñ\8bÐ»Ð¾ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¾"
  
  #: fortran/decl.c:8211
  #, gcc-internal-format, gfc-internal-format
  msgid "Cray Pointee at %C cannot be assumed shape array"
-msgstr ""
+msgstr "Cray указуемое в %C не может быть массивом предполагаемой формы"
  
  #: fortran/decl.c:8231
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ENUM and ENUMERATOR at %C"
  msgid "ENUM and ENUMERATOR at %C"
-msgstr ""
+msgstr "Fortran 2003: ENUM и ENUMERATOR в %C"
  
  #: fortran/decl.c:8263
  #, gcc-internal-format, gfc-internal-format
  msgid "Enumerator exceeds the C integer type at %C"
-msgstr ""
+msgstr "Перечислитель превосходит целый тип C в %C"
  
  #: fortran/decl.c:8342
  #, gcc-internal-format, gfc-internal-format
  msgid "ENUMERATOR %L not initialized with integer expression"
-msgstr ""
+msgstr "ENUMERATOR %L не инициализирован целым выражением"
  
  #: fortran/decl.c:8390
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "ENUM definition statement expected before %C"
-msgstr "перед `*' должно быть имя типа"
+msgstr "ENUM оператор определения ожидался до %C"
  
  #: fortran/decl.c:8426
  #, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in ENUMERATOR definition at %C"
-msgstr ""
+msgstr "Синтаксическая ошибка в ENUMERATOR определении в %C"
  
  #: fortran/decl.c:8473 fortran/decl.c:8488
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate access-specifier at %C"
-msgstr "Ð¿Ð¾Ñ\81Ð»Ðµ Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð² `%#D'"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿Ð° Ð² %C"
  
  #: fortran/decl.c:8508
  #, gcc-internal-format, gfc-internal-format
  msgid "Binding attributes already specify passing, illegal NOPASS at %C"
-msgstr ""
+msgstr "Связывающие атрибуты уже специфицировали passing, некоректный NOPASS в %C"
  
  #: fortran/decl.c:8528
  #, gcc-internal-format, gfc-internal-format
  msgid "Binding attributes already specify passing, illegal PASS at %C"
-msgstr ""
+msgstr "Связывающие атрибуты уже специфицировали passing, некоректный PASS в %C"
  
  #: fortran/decl.c:8555
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate POINTER attribute at %C"
-msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð¾Ðµ Ñ\83Ð¿Ð¾Ñ\82Ñ\80ÐµÐ±Ð»ÐµÐ½Ð¸Ðµ `restrict'"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ POINTER Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ð² %C"
  
  #: fortran/decl.c:8573
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate NON_OVERRIDABLE at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ NON_OVERRIDABLE Ð² %C"
  
  #: fortran/decl.c:8589
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate DEFERRED at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ DEFERRED Ð² %C"
  
  #: fortran/decl.c:8602
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected access-specifier at %C"
-msgstr "  ожидался шаблон класса, обнаружено %qT"
+msgstr "Ожидался спецификатор доступа в %C"
  
  #: fortran/decl.c:8604
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected binding attribute at %C"
-msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 packed Ð½Ðµ Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ñ\81Ð²Ñ\8fÐ·Ñ\8bÐ²Ð°Ñ\8eÑ\89Ð¸Ð¹ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ð² %C"
  
  #: fortran/decl.c:8612
  #, gcc-internal-format, gfc-internal-format
  msgid "NON_OVERRIDABLE and DEFERRED can't both appear at %C"
-msgstr ""
+msgstr "NON_OVERRIDABLE и DEFERRED не могут оба появляться в %C"
  
  #: fortran/decl.c:8624
  #, gcc-internal-format, gfc-internal-format
  msgid "POINTER attribute is required for procedure pointer component at %C"
-msgstr ""
+msgstr "POINTER атрибут требуется для компонента указателя на процедуру в %C"
  
  #: fortran/decl.c:8666
  #, fuzzy, gcc-internal-format
+#| msgid "Interface-name expected after '(' at %C"
  msgid "Interface-name expected after %<(%> at %C"
-msgstr "Ожидался идентификатор"
+msgstr "Interface-name ожидалось после '(' в %C"
  
  #: fortran/decl.c:8672
  #, fuzzy, gcc-internal-format
+#| msgid "')' expected at %C"
  msgid "%<)%> expected at %C"
-msgstr "  ожидался тип, обнаружено %qE"
+msgstr "')' ожидалась в %C"
  
  #: fortran/decl.c:8692
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Interface must be specified for DEFERRED binding at %C"
-msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°"
+msgstr "Ð\98Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ð´Ð»Ñ\8f DEFERRED Ñ\81Ð²Ñ\8fÐ·Ñ\8bÐ²Ð°Ð½Ð¸Ñ\8f Ð² %C"
  
  #: fortran/decl.c:8697
  #, gcc-internal-format, gfc-internal-format
  msgid "PROCEDURE(interface) at %C should be declared DEFERRED"
-msgstr ""
+msgstr "PROCEDURE(interface) at %C следует декларировать DEFERRED"
  
  #: fortran/decl.c:8720
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected binding name at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ñ\81Ð²Ñ\8fÐ·Ñ\8bÐ²Ð°Ñ\8eÑ\89ÐµÐµ Ð¸Ð¼Ñ\8f Ð² %C"
  
  #: fortran/decl.c:8724
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: PROCEDURE list at %C"
  msgid "PROCEDURE list at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: PROCEDURE список в %C"
  
  #: fortran/decl.c:8736
  #, fuzzy, gcc-internal-format
+#| msgid "'=> target' is invalid for DEFERRED binding at %C"
  msgid "%<=> target%> is invalid for DEFERRED binding at %C"
-msgstr "Спецификация нулевого размера в %0 некорректна"
+msgstr "'=> target' некорректно для DEFERRED связывания в %C"
  
  #: fortran/decl.c:8742
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'::' needed in PROCEDURE binding with explicit target at %C"
  msgid "%<::%> needed in PROCEDURE binding with explicit target at %C"
-msgstr ""
+msgstr "'::' требуется в PROCEDURE связывании с явной целью в %C"
  
  #: fortran/decl.c:8752
  #, fuzzy, gcc-internal-format
+#| msgid "Expected binding target after '=>' at %C"
  msgid "Expected binding target after %<=>%> at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ñ\86ÐµÐ»Ñ\8c Ñ\81Ð²Ñ\8fÐ·Ñ\8bÐ²Ð°Ð½Ð¸Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ '=>' Ð² %C"
  
  #: fortran/decl.c:8769
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Type '%s' containing DEFERRED binding at %C is not ABSTRACT"
  msgid "Type %qs containing DEFERRED binding at %C is not ABSTRACT"
-msgstr ""
+msgstr "Тип '%s' содержащий DEFERRED связывание в %C не есть ABSTRACT"
  
  #: fortran/decl.c:8780
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "There is already a procedure with binding name '%s' for the derived type '%s' at %C"
  msgid "There is already a procedure with binding name %qs for the derived type %qs at %C"
-msgstr ""
+msgstr "Уже есть процедура со связывающим именем '%s' для производного типа '%s' в %C"
  
  #: fortran/decl.c:8829
  #, gcc-internal-format, gfc-internal-format
  msgid "GENERIC at %C must be inside a derived-type CONTAINS"
-msgstr ""
+msgstr "GENERIC в %C должно быть внутри производного типа CONTAINS"
  
  #: fortran/decl.c:8849
  #, fuzzy, gcc-internal-format
+#| msgid "Expected '::' at %C"
  msgid "Expected %<::%> at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c '::' Ð² %C"
  
  #: fortran/decl.c:8861
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected generic name or operator descriptor at %C"
-msgstr "Ð\9eÐ¶Ð¸Ð´Ð°ÐµÑ\82Ñ\81Ñ\8f Ð´Ñ\80Ñ\83Ð³Ð°Ñ\8f Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð½Ð¾Ñ\81Ñ\82Ñ\8c Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸ %C"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c generic Ð¸Ð¼Ñ\8f Ð¸Ð»Ð¸ Ð´ÐµÑ\81ÐºÑ\80Ð¸Ð¿Ñ\82Ð¾Ñ\80 Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/decl.c:8881
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Invalid form of PROGRAM statement at %C"
  msgid "Malformed GENERIC statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\84Ð¾Ñ\80Ð¼Ð° PROGRAM Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/decl.c:8892
  #, fuzzy, gcc-internal-format
+#| msgid "Expected '=>' at %C"
  msgid "Expected %<=>%> at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c '=>' Ð² %C"
  
  #: fortran/decl.c:8934
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "There's already a non-generic procedure with binding name '%s' for the derived type '%s' at %C"
  msgid "There's already a non-generic procedure with binding name %qs for the derived type %qs at %C"
-msgstr ""
+msgstr "Уже есть non-generic процедура со связывающим именем '%s' для производного типа '%s' в %C"
  
  #: fortran/decl.c:8942
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Binding at %C must have the same access as already defined binding '%s'"
  msgid "Binding at %C must have the same access as already defined binding %qs"
-msgstr ""
+msgstr "Связывание в %C должно иметь тот же доступ что и уже определенное связывание '%s'"
  
  #: fortran/decl.c:8991
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected specific binding name at %C"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85, Ð²Ñ\81Ñ\82Ñ\80ÐµÑ\82Ð¸Ð²Ñ\88Ð¸Ñ\85Ñ\81Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð²"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð½Ð¾Ðµ Ñ\81Ð²Ñ\8fÐ·Ñ\8bÐ²Ð°Ñ\8eÑ\89ÐµÐµ Ð¸Ð¼Ñ\8f Ð² %C"
  
  #: fortran/decl.c:9001
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' already defined as specific binding for the generic '%s' at %C"
  msgid "%qs already defined as specific binding for the generic %qs at %C"
-msgstr "ошибка в аргументах spec-функции '%s'"
+msgstr "'%s' уже определено как конкретное связывание для generic '%s' в %C"
  
  #: fortran/decl.c:9019
  #, gcc-internal-format, gfc-internal-format
  msgid "Junk after GENERIC binding at %C"
-msgstr ""
+msgstr "Мусор после GENERIC связывания в %C"
  
  #: fortran/decl.c:9054
  #, gcc-internal-format, gfc-internal-format
  msgid "FINAL declaration at %C must be inside a derived type CONTAINS section"
-msgstr ""
+msgstr "FINAL декларация в %C должна быть внутри секции CONTAINS производного типа"
  
  #: fortran/decl.c:9065
  #, gcc-internal-format, gfc-internal-format
  msgid "Derived type declaration with FINAL at %C must be in the specification part of a MODULE"
-msgstr ""
+msgstr "Декларация производного типа с FINAL в %C должна быть в спецификационной части модуля"
  
  #: fortran/decl.c:9087
  #, gcc-internal-format, gfc-internal-format
  msgid "Empty FINAL at %C"
-msgstr ""
+msgstr "Пустое FINAL в %C"
  
  #: fortran/decl.c:9094
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected module procedure name at %C"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8cÐ½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b Ð² %C"
  
  #: fortran/decl.c:9104
  #, fuzzy, gcc-internal-format
+#| msgid "Expected \",\" at %C"
  msgid "Expected %<,%> at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c \",\" Ð² %C"
  
  #: fortran/decl.c:9110
  #, fuzzy, gcc-internal-format
+#| msgid "Unknown procedure name \"%s\" at %C"
  msgid "Unknown procedure name %qs at %C"
-msgstr "Неизвестный оператор '%s' в %%L"
+msgstr "Неизвестное име процедуры \"%s\" в %C"
  
  #: fortran/decl.c:9123
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %C is already defined as FINAL procedure!"
  msgid "%qs at %C is already defined as FINAL procedure!"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "'%s' в %C уже определена как FINAL процедура!"
  
  #: fortran/decl.c:9193
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85, Ð²Ñ\81Ñ\82Ñ\80ÐµÑ\82Ð¸Ð²Ñ\88Ð¸Ñ\85Ñ\81Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð²"
+msgstr "Ð\9dÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ð² !GCC$ ATTRIBUTES Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/decl.c:9239
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² !GCC$ ATTRIBUTES Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/dependency.c:191
  #, gcc-internal-format
@@ -51617,7 +53854,7 @@ msgstr ""
  #: fortran/dependency.c:958
  #, gcc-internal-format, gfc-internal-format
  msgid "INTENT(%s) actual argument at %L might interfere with actual argument at %L."
-msgstr ""
+msgstr "INTENT(%s) фактические аргументы в %L могут противоречить фактическим аргументам в %L."
  
  #: fortran/dump-parse-tree.c:179
  #, gcc-internal-format
@@ -51630,9 +53867,10 @@ msgid "show_array_ref(): Unknown array reference"
  msgstr ""
  
  #: fortran/dump-parse-tree.c:290
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "show_ref(): Bad component code"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: fortran/dump-parse-tree.c:554
  #, gcc-internal-format
@@ -51645,14 +53883,15 @@ msgid "show_expr(): Don't know how to show expr"
  msgstr ""
  
  #: fortran/dump-parse-tree.c:2532
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "show_code_node(): Bad statement code"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: fortran/error.c:337
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "    Included at %s:%d:"
-msgstr "    Включённом в %s:%d\n"
+msgstr "    Включённом в %s:%d:"
  
  #: fortran/error.c:423
  #, gcc-internal-format
@@ -51665,9 +53904,10 @@ msgid "gfc_get_constant_expr(): locus %<where%> cannot be NULL"
  msgstr ""
  
  #: fortran/expr.c:347
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "gfc_copy_expr(): Bad expr node"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: fortran/expr.c:494
  #, gcc-internal-format
@@ -51685,9 +53925,9 @@ msgid "simplify_intrinsic_op(): Bad operator"
  msgstr ""
  
  #: fortran/expr.c:1231
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Index in dimension %d is out of bounds at %L"
-msgstr "Ð¸ндекс размерности %d выходит за границы в %L"
+msgstr "Ð\98ндекс размерности %d выходит за границы в %L"
  
  #: fortran/expr.c:1419 fortran/expr.c:1470
  #, gcc-internal-format, gfc-internal-format
@@ -51697,332 +53937,373 @@ msgstr "индекс размерности %d выходит за границ
  #: fortran/expr.c:1546
  #, gcc-internal-format, gfc-internal-format
  msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit.   See -fmax-array-constructor option"
-msgstr ""
+msgstr "Число элементов в конструкторе массива в %L требует увеличения допустимой %d верхней границы. См. опцию -fmax-array-constructor"
  
  #: fortran/expr.c:2074
  #, gcc-internal-format, gfc-internal-format
  msgid "elemental function arguments at %C are not compliant"
-msgstr ""
+msgstr "аргументы элементной функции в %C ненадлежащие"
  
  #: fortran/expr.c:2118
  #, gcc-internal-format, gfc-internal-format
  msgid "Numeric or CHARACTER operands are required in expression at %L"
-msgstr ""
+msgstr "Числовые или CHARACTER операнды требуются в выражении в %L"
  
  #: fortran/expr.c:2143
  #, gcc-internal-format, gfc-internal-format
  msgid "Concatenation operator in expression at %L must have two CHARACTER operands"
-msgstr ""
+msgstr "Оператор конкатенации в выражении в %L должен иметь два CHARACTER операнда"
  
  #: fortran/expr.c:2150
  #, gcc-internal-format, gfc-internal-format
  msgid "Concat operator at %L must concatenate strings of the same kind"
-msgstr ""
+msgstr "Оператор конкатенации в выражении в %L должен конкатенировать строки одного вида"
  
  #: fortran/expr.c:2160
  #, gcc-internal-format, gfc-internal-format
  msgid ".NOT. operator in expression at %L must have a LOGICAL operand"
-msgstr ""
+msgstr ".NOT. оператор в выражении в %L должен иметь LOGICAL операнд"
  
  #: fortran/expr.c:2176
  #, gcc-internal-format, gfc-internal-format
  msgid "LOGICAL operands are required in expression at %L"
-msgstr ""
+msgstr "LOGICAL операнды требуются в выражении в %L"
  
  #: fortran/expr.c:2187
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Only intrinsic operators can be used in expression at %L"
-msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ Ð² %1 Ð² ÐºÐ¾Ð½Ñ\86Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ð² %0"
+msgstr "Ð¢Ð¾Ð»Ñ\8cÐºÐ¾ Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ñ\8b Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ð² Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ð² %L"
  
  #: fortran/expr.c:2195
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Numeric operands are required in expression at %L"
-msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ Ð² %1 Ð² ÐºÐ¾Ð½Ñ\86Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ð² %0"
+msgstr "Ð§Ð¸Ñ\81Ð»Ð¾Ð²Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ñ\82Ñ\80ÐµÐ±Ñ\83Ñ\8eÑ\82Ñ\81Ñ\8f Ð² Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ð² %L"
  
  #: fortran/expr.c:2218
  #, fuzzy, gcc-internal-format
+#| msgid "Invalid initialization expression for ALLOCATABLE component '%s' in structure constructor at %L"
  msgid "Invalid initialization expression for ALLOCATABLE component %qs in structure constructor at %L"
-msgstr "функция возвращает агрегатное значение"
+msgstr "Некорректное инициализационное выражение для ALLOCATABLE компонента '%s' в конструкторе структуры в %L"
  
  #: fortran/expr.c:2329
  #, fuzzy, gcc-internal-format
+#| msgid "Assumed or deferred character length variable '%s'  in constant expression at %L"
  msgid "Assumed or deferred character length variable %qs  in constant expression at %L"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Предполагаемая или отложенная переменная character длины '%s' в константном выражении в %L"
  
  #: fortran/expr.c:2395
  #, fuzzy, gcc-internal-format
+#| msgid "transformational intrinsic '%s' at %L is not permitted in an initialization expression"
  msgid "transformational intrinsic %qs at %L is not permitted in an initialization expression"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "трансформационная встроенная функция '%s' в %L не разрешена в инициализационном выражении"
  
  #: fortran/expr.c:2426
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: Evaluation of nonstandard initialization expression at %L"
  msgid "Evaluation of nonstandard initialization expression at %L"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Расширение: Обработка нестандартного инициализационного выражения в %L"
  
  #: fortran/expr.c:2503 fortran/resolve.c:2569
  #, fuzzy, gcc-internal-format
+#| msgid "Function '%s' in initialization expression at %L must be an intrinsic function"
  msgid "Function %qs in initialization expression at %L must be an intrinsic function"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Функция '%s' в инициализационном выражении в %L должна быть встроенной функцией"
  
  #: fortran/expr.c:2515
  #, fuzzy, gcc-internal-format
+#| msgid "Intrinsic function '%s' at %L is not permitted in an initialization expression"
  msgid "Intrinsic function %qs at %L is not permitted in an initialization expression"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Встроенная функция '%s' в %L не разрешена в инициализационном выражении"
  
  #: fortran/expr.c:2550
  #, fuzzy, gcc-internal-format
+#| msgid "PARAMETER '%s' is used at %L before its definition is complete"
  msgid "PARAMETER %qs is used at %L before its definition is complete"
-msgstr "%q+D использована без предварительного определения"
+msgstr "PARAMETER '%s' использован в %L до завершения его определения"
  
  #: fortran/expr.c:2570
  #, fuzzy, gcc-internal-format
+#| msgid "Assumed size array '%s' at %L is not permitted in an initialization expression"
  msgid "Assumed size array %qs at %L is not permitted in an initialization expression"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Массив предполагаемого размера '%s' в %L не разрешен в инициализационном выражении"
  
  #: fortran/expr.c:2576
  #, fuzzy, gcc-internal-format
+#| msgid "Assumed shape array '%s' at %L is not permitted in an initialization expression"
  msgid "Assumed shape array %qs at %L is not permitted in an initialization expression"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Массив предполагаемой формы '%s' в %L не разрешен в инициализационном выражении"
  
  #: fortran/expr.c:2582
  #, fuzzy, gcc-internal-format
+#| msgid "Deferred array '%s' at %L is not permitted in an initialization expression"
  msgid "Deferred array %qs at %L is not permitted in an initialization expression"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Отложенный массив '%s' в %L не разрешен в инициализационном выражении"
  
  #: fortran/expr.c:2588
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Array '%s' at %L is a variable, which does not reduce to a constant expression"
  msgid "Array %qs at %L is a variable, which does not reduce to a constant expression"
-msgstr ""
+msgstr "Массив '%s' в %L является переменной, которая не сводится к константному выражению"
  
  #: fortran/expr.c:2598
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Parameter '%s' at %L has not been declared or is a variable, which does not reduce to a constant expression"
  msgid "Parameter %qs at %L has not been declared or is a variable, which does not reduce to a constant expression"
-msgstr ""
+msgstr "Parameter '%s' at %L не был декларирован или является переменной, которая не сводится к константному выражению"
  
  #: fortran/expr.c:2652
  #, fuzzy, gcc-internal-format
+#| msgid "Expected expression type"
  msgid "check_init_expr(): Unknown expression type"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ñ\82Ð¸Ð¿ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
  
  #: fortran/expr.c:2778
  #, fuzzy, gcc-internal-format
+#| msgid "Specification function '%s' at %L cannot be a statement function"
  msgid "Specification function %qs at %L cannot be a statement function"
-msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80 Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð¼-функцией"
+msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¾Ð½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80-функцией"
  
  #: fortran/expr.c:2785
  #, fuzzy, gcc-internal-format
+#| msgid "Specification function '%s' at %L cannot be an internal function"
  msgid "Specification function %qs at %L cannot be an internal function"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "Спецификационная функция '%s' в %L не может быть внутренней функцией"
  
  #: fortran/expr.c:2792
  #, fuzzy, gcc-internal-format
+#| msgid "Specification function '%s' at %L must be PURE"
  msgid "Specification function %qs at %L must be PURE"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %s"
+msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¾Ð½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c PURE"
  
  #: fortran/expr.c:2799
  #, fuzzy, gcc-internal-format
+#| msgid "Specification function '%s' at %L cannot be RECURSIVE"
  msgid "Specification function %qs at %L cannot be RECURSIVE"
-msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80 Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð¼-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸ÐµÐ¹"
+msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¾Ð½Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c RECURSIVE"
  
  #: fortran/expr.c:2946
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy argument '%s' not allowed in expression at %L"
  msgid "Dummy argument %qs not allowed in expression at %L"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Формальный аргумент '%s' не допускается в выражении в %L"
  
  #: fortran/expr.c:2953
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy argument '%s' at %L cannot be OPTIONAL"
  msgid "Dummy argument %qs at %L cannot be OPTIONAL"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð¤Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c OPTIONAL"
  
  #: fortran/expr.c:2960
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy argument '%s' at %L cannot be INTENT(OUT)"
  msgid "Dummy argument %qs at %L cannot be INTENT(OUT)"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð¤Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c INTENT(OUT)"
  
  #: fortran/expr.c:2989
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' cannot appear in the expression at %L"
  msgid "Variable %qs cannot appear in the expression at %L"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Переменная '%s' не может появляться в выражении в %L"
  
  #: fortran/expr.c:3020
  #, fuzzy, gcc-internal-format
+#| msgid "Expected expression type"
  msgid "check_restricted(): Unknown expression type"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ñ\82Ð¸Ð¿ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
  
  #: fortran/expr.c:3040
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expression at %L must be of INTEGER type, found %s"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
+msgstr "Ð\92Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c INTEGER Ñ\82Ð¸Ð¿Ð°, Ð½Ð°Ð¹Ð´ÐµÐ½Ð¾ %s"
  
  #: fortran/expr.c:3052
  #, fuzzy, gcc-internal-format
+#| msgid "Function '%s' at %L must be PURE"
  msgid "Function %qs at %L must be PURE"
-msgstr "Функция '%s' в %C уже имеет тип %s"
+msgstr "Функция '%s' в %L должна быть PURE"
  
  #: fortran/expr.c:3061
  #, gcc-internal-format, gfc-internal-format
  msgid "Expression at %L must be scalar"
-msgstr ""
+msgstr "Выражение в %L должно быть скалярным"
  
  #: fortran/expr.c:3095
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Incompatible ranks in %s (%d and %d) at %L"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ `%s'"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\80Ð°Ð½Ð³Ð¸ Ð² %s (%d Ð¸ %d) Ð² %L"
  
  #: fortran/expr.c:3109
  #, gcc-internal-format, gfc-internal-format
  msgid "Different shape for %s at %L on dimension %d (%d and %d)"
-msgstr ""
+msgstr "Иная форма для %s в %L по измерению %d (%d и %d)"
  
  #: fortran/expr.c:3201
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L is not a VALUE"
  msgid "%qs at %L is not a VALUE"
-msgstr "%q+D не является функцией,"
+msgstr "'%s' в %L не есть VALUE"
  
  #: fortran/expr.c:3208
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Incompatible ranks %d and %d in assignment at %L"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ %qs"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\80Ð°Ð½Ð³Ð¸ %d Ð¸ %d Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ð² %L"
  
  #: fortran/expr.c:3215
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Variable type is UNKNOWN in assignment at %L"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ %qs"
+msgstr "Ð¢Ð¸Ð¿ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ UNKNOWN Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ð² %L"
  
  #: fortran/expr.c:3227
  #, gcc-internal-format, gfc-internal-format
  msgid "NULL appears on right-hand side in assignment at %L"
-msgstr ""
+msgstr "NULL появляется в правой части присваивания в %L"
  
  #: fortran/expr.c:3237
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "POINTER valued function appears on right-hand side of assignment at %L"
  msgid "POINTER-valued function appears on right-hand side of assignment at %L"
-msgstr ""
+msgstr "Возвращающая POINTER функция появляется в правой части присваивания в %L"
  
  #: fortran/expr.c:3247
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Extension: BOZ literal at %L used to initialize non-integer variable '%s'"
  msgid "BOZ literal at %L used to initialize non-integer variable %qs"
-msgstr ""
+msgstr "Расширение: BOZ литерал в %L использован для инициализации нецелой переменной '%s'"
  
  #: fortran/expr.c:3252 fortran/resolve.c:9542
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: BOZ literal at %L outside a DATA statement and outside INT/REAL/DBLE/CMPLX"
  msgid "BOZ literal at %L outside a DATA statement and outside INT/REAL/DBLE/CMPLX"
-msgstr ""
+msgstr "Расширение: BOZ литерал в %L вне DATA оператора и вне INT/REAL/DBLE/CMPLX"
  
  #: fortran/expr.c:3263 fortran/resolve.c:9553
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "BOZ literal at %L is bitwise transferred non-integer symbol '%s'"
  msgid "BOZ literal at %L is bitwise transferred non-integer symbol %qs"
-msgstr ""
+msgstr "BOZ литерал в %L есть побитно преобразованный нецелый символ '%s'"
  
  #: fortran/expr.c:3271 fortran/resolve.c:9562
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Arithmetic underflow of bit-wise transferred BOZ at %L. This check can be disabled with the option -fno-range-check"
  msgid "Arithmetic underflow of bit-wise transferred BOZ at %L. This check can be disabled with the option %<-fno-range-check%>"
-msgstr ""
+msgstr "Арифметическая потеря значимости побитно преобразованного BOZ at %L. Эту проверку можно выключить опцией -fno-range-check"
  
  #: fortran/expr.c:3275 fortran/resolve.c:9566
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Arithmetic overflow of bit-wise transferred BOZ at %L. This check can be disabled with the option -fno-range-check"
  msgid "Arithmetic overflow of bit-wise transferred BOZ at %L. This check can be disabled with the option %<-fno-range-check%>"
-msgstr ""
+msgstr "Арифметическая переполнение побитно преобразованного BOZ at %L. Эту проверку можно выключить опцией -fno-range-check"
  
  #: fortran/expr.c:3279 fortran/resolve.c:9570
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Arithmetic NaN of bit-wise transferred BOZ at %L. This check can be disabled with the option -fno-range-check"
  msgid "Arithmetic NaN of bit-wise transferred BOZ at %L. This check can be disabled with the option %<-fno-range-check%>"
-msgstr ""
+msgstr "Арифметическое NaN побитно преобразованного BOZ at %L. Эту проверку можно выключить опцией -fno-range-check"
  
  #: fortran/expr.c:3301
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Incompatible types in DATA statement at %L; attempted conversion of %s to %s"
-msgstr "Несовместимые типы в присваивании в %L, %s к %s"
+msgstr "Несовместимые типы в DATA операторе в %L; попытка преобразования %s в %s"
  
  #: fortran/expr.c:3337
  #, gcc-internal-format, gfc-internal-format
  msgid "Pointer assignment target is not a POINTER at %L"
-msgstr ""
+msgstr "Цель указательного присваивания не есть POINTER в %L"
  
  #: fortran/expr.c:3345
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' in the pointer assignment at %L cannot be an l-value since it is a procedure"
  msgid "%qs in the pointer assignment at %L cannot be an l-value since it is a procedure"
-msgstr ""
+msgstr "'%s' в указательном присваивании в %L не может быть l-value поскольку это процедура"
  
  #: fortran/expr.c:3368
  #, fuzzy, gcc-internal-format
+#| msgid "Expected bounds specification for '%s' at %L"
  msgid "Expected bounds specification for %qs at %L"
-msgstr "Ð¿Ð¾Ñ\81Ð»Ðµ Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð² `%#D'"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð³Ñ\80Ð°Ð½Ð¸Ñ\86 Ð´Ð»Ñ\8f '%s' Ð² %L"
  
  #: fortran/expr.c:3373
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: Bounds specification for '%s' in pointer assignment at %L"
  msgid "Bounds specification for %qs in pointer assignment at %L"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Fortran 2003: Спецификация границ для '%s' в указательном присваивании в %L"
  
  #: fortran/expr.c:3386
  #, gcc-internal-format, gfc-internal-format
  msgid "Lower bound has to be present at %L"
-msgstr ""
+msgstr "Нижняя граница должна присутствовать в %L"
  
  #: fortran/expr.c:3392
  #, gcc-internal-format, gfc-internal-format
  msgid "Stride must not be present at %L"
-msgstr ""
+msgstr "Шаг не может присутствовать в %L"
  
  #: fortran/expr.c:3404
  #, gcc-internal-format, gfc-internal-format
  msgid "Either all or none of the upper bounds must be specified at %L"
-msgstr ""
+msgstr "Все или никакие верхние границы должны быть специфицированы в %L"
  
  #: fortran/expr.c:3430
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Pointer object at %L shall not have a coindex"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Указательный объект в %L не должен иметь коиндекс"
  
  #: fortran/expr.c:3451
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid procedure pointer assignment at %L"
-msgstr "Несовместимые типы при присваивании указателей в %L"
+msgstr "Некорректное присваивание указателя на процедуру в %L"
  
  #: fortran/expr.c:3475
  #, fuzzy, gcc-internal-format
+#| msgid "Statement function '%s' is invalid in procedure pointer assignment at %L"
  msgid "Function result %qs is invalid as proc-target in procedure pointer assignment at %L"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð° Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 Ð² %L"
  
  #: fortran/expr.c:3484
  #, fuzzy, gcc-internal-format
+#| msgid "Abstract interface '%s' is invalid in procedure pointer assignment at %L"
  msgid "Abstract interface %qs is invalid in procedure pointer assignment at %L"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\90Ð±Ñ\81Ñ\82Ñ\80Ð°ÐºÑ\82Ð½Ñ\8bÐ¹ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81 '%s' Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½ Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 Ð² %L"
  
  #: fortran/expr.c:3494
  #, fuzzy, gcc-internal-format
+#| msgid "Statement function '%s' is invalid in procedure pointer assignment at %L"
  msgid "Statement function %qs is invalid in procedure pointer assignment at %L"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð° Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 Ð² %L"
  
  #: fortran/expr.c:3500
  #, fuzzy, gcc-internal-format
+#| msgid "Internal procedure '%s' is invalid in procedure pointer assignment at %L"
  msgid "Internal procedure %qs is invalid in procedure pointer assignment at %L"
-msgstr "Внешняя процедура `%A' передана как фактический аргумент в %0, но не декларирована явно как EXTERNAL"
+msgstr "Внутренняя процедура '%s' некорректна в присваивании указателя на процедуру в %L"
  
  #: fortran/expr.c:3507
  #, fuzzy, gcc-internal-format
+#| msgid "Internal procedure '%s' is invalid in procedure pointer assignment at %L"
  msgid "Intrinsic %qs at %L is invalid in procedure pointer assignment"
-msgstr "Внешняя процедура `%A' передана как фактический аргумент в %0, но не декларирована явно как EXTERNAL"
+msgstr "Внутренняя процедура '%s' некорректна в присваивании указателя на процедуру в %L"
  
  #: fortran/expr.c:3515
  #, fuzzy, gcc-internal-format
+#| msgid "Nonintrinsic elemental procedure '%s' is invalid in procedure pointer assigment at %L"
  msgid "Nonintrinsic elemental procedure %qs is invalid in procedure pointer assignment at %L"
-msgstr "Ð\92Ð½ÐµÑ\88Ð½Ñ\8fÑ\8f Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° `%A' Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð° ÐºÐ°Ðº Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0, Ð½Ð¾ Ð½Ðµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° Ñ\8fÐ²Ð½Ð¾ ÐºÐ°Ðº EXTERNAL"
+msgstr "Ð\9dÐµÐ²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð½Ð°Ñ\8f Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð° Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 Ð² %L"
  
  #: fortran/expr.c:3538
  #, gcc-internal-format, gfc-internal-format
  msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calling convention"
-msgstr ""
+msgstr "Несоответствие в присваивании указателя на процедуру в %L: несоответствие в соглашении о вызове"
  
  #: fortran/expr.c:3594 fortran/expr.c:3601 fortran/resolve.c:2448
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "NOPASS or explicit interface required at %C"
  msgid "Explicit interface required for %qs at %L: %s"
-msgstr ""
+msgstr "NOPASS или явный интерфейс требуются в %C"
  
  #: fortran/expr.c:3609
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Interface mismatch in procedure pointer assignment at %L: %s"
-msgstr "Ð\9dÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð¿Ñ\80Ð¸ Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¹ Ð² %L"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81Ð¾Ð² Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 Ð² %L: %s"
  
  #: fortran/expr.c:3618
  #, gcc-internal-format
@@ -52035,179 +54316,196 @@ msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type wit
  msgstr ""
  
  #: fortran/expr.c:3640
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Different types in pointer assignment at %L; attempted assignment of %s to %s"
-msgstr "Ð\9dÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð¿Ñ\80Ð¸ Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¹ Ð² %L"
+msgstr "Ð Ð°Ð·Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ð° Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð² %L; Ð¿Ð¾Ð¿Ñ\8bÑ\82ÐºÐ° Ð¿Ñ\80Ð¸Ñ\81Ð²Ð¾Ð¸Ñ\82Ñ\8c %s Ð² %s"
  
  #: fortran/expr.c:3649
  #, gcc-internal-format, gfc-internal-format
  msgid "Different kind type parameters in pointer assignment at %L"
-msgstr ""
+msgstr "Разные виды типовых параметров в присваивании указателя в %L"
  
  #: fortran/expr.c:3656
  #, gcc-internal-format, gfc-internal-format
  msgid "Different ranks in pointer assignment at %L"
-msgstr ""
+msgstr "Разные ранги в присваивании указателя в %L"
  
  #: fortran/expr.c:3675
  #, gcc-internal-format, gfc-internal-format
  msgid "Rank remapping target is smaller than size of the pointer (%ld < %ld) at %L"
-msgstr ""
+msgstr "Цель переотображения ранга меньше чем размер указателя (%ld < %ld) в %L"
  
  #: fortran/expr.c:3688
  #, gcc-internal-format, gfc-internal-format
  msgid "Rank remapping target must be rank 1 or simply contiguous at %L"
-msgstr ""
+msgstr "Цель переотображения ранга должна быть ранга 1 или просто непрерывна в %L"
  
  #: fortran/expr.c:3692
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: Rank remapping target is not rank 1 at %L"
  msgid "Rank remapping target is not rank 1 at %L"
-msgstr ""
+msgstr "Fortran 2008: Цель переотображения ранга не ранга 1 в %L"
  
  #: fortran/expr.c:3716
  #, gcc-internal-format, gfc-internal-format
  msgid "Target expression in pointer assignment at %L must deliver a pointer result"
-msgstr ""
+msgstr "Целевое выражение в присваивании указателя в %L должна выдавать указательный результат"
  
  #: fortran/expr.c:3724
  #, gcc-internal-format, gfc-internal-format
  msgid "Pointer assignment target is neither TARGET nor POINTER at %L"
-msgstr ""
+msgstr "Цель присваивания указателя не TARGET и не POINTER в %L"
  
  #: fortran/expr.c:3731
  #, gcc-internal-format, gfc-internal-format
  msgid "Bad target in pointer assignment in PURE procedure at %L"
-msgstr ""
+msgstr "Некорректная цель в присваивании указателя в PURE процедуре в %L"
  
  #: fortran/expr.c:3740
  #, gcc-internal-format, gfc-internal-format
  msgid "Pointer assignment with vector subscript on rhs at %L"
-msgstr ""
+msgstr "Присваивание указателя с индексом вектора в правой части в %L"
  
  #: fortran/expr.c:3748
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Pointer assignment target has PROTECTED attribute at %L"
-msgstr "Ð\9fÑ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ðµ Ðº Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8e в %L"
+msgstr "Ð¦ÐµÐ»Ñ\8c Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ñ\8f Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð¸Ð¼ÐµÐµÑ\82 PROTECTED Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 в %L"
  
  #: fortran/expr.c:3761
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Data target at %L shall not have a coindex"
-msgstr "стандартные преобразования в данном контексте недопустимы"
+msgstr "Целевые данные в %L не должны иметь коиндекс"
  
  #: fortran/expr.c:3802
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Target expression in pointer assignment at %L must deliver a pointer result"
  msgid "Pointer at %L in pointer assignment might outlive the pointer target"
-msgstr ""
+msgstr "Целевое выражение в присваивании указателя в %L должна выдавать указательный результат"
  
  #: fortran/expr.c:3878
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Pointer initialization target at %L must not be ALLOCATABLE "
  msgid "Pointer initialization target at %L must not be ALLOCATABLE"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¦ÐµÐ»Ñ\8c Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð² %L Ð½Ðµ Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c ALLOCATABLE "
  
  #: fortran/expr.c:3884
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Pointer initialization target at %C must have the TARGET attribute"
  msgid "Pointer initialization target at %L must have the TARGET attribute"
-msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ð² %C Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 POINTER"
+msgstr "Ð¦ÐµÐ»Ñ\8c Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð² %C Ð´Ð¾Ð»Ð¶Ð½Ð° Ð¸Ð¼ÐµÑ\82Ñ\8c TARGET Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
  #: fortran/expr.c:3899 fortran/resolve.c:1341
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Pointer initialization target at %L must have the SAVE attribute"
-msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ð² %C Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 POINTER"
+msgstr "Ð¦ÐµÐ»Ñ\8c Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð¸Ð¼ÐµÑ\82Ñ\8c SAVE Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
  #: fortran/expr.c:3911
  #, gcc-internal-format, gfc-internal-format
  msgid "Procedure pointer initialization target at %L may not be a procedure pointer"
-msgstr ""
+msgstr "Цель инициализации указателя на процедуру в %L не может быть указателем на процедуру"
  
  #: fortran/expr.c:4800
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Fortran 2008: Указательные функции в контексте определения переменных (%s) в %L"
  
  #: fortran/expr.c:4808
  #, gcc-internal-format, gfc-internal-format
  msgid "Non-variable expression in variable definition context (%s) at %L"
-msgstr ""
+msgstr "Non-variable выражение в контексте определения переменных (%s) в %L"
  
  #: fortran/expr.c:4816
  #, fuzzy, gcc-internal-format
+#| msgid "Named constant '%s' in variable definition context (%s) at %L"
  msgid "Named constant %qs in variable definition context (%s) at %L"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\98Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° '%s' Ð² ÐºÐ¾Ð½Ñ\82ÐµÐºÑ\81Ñ\82Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85 (%s) Ð² %L"
  
  #: fortran/expr.c:4825
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' in variable definition context (%s) at %L is not a variable"
  msgid "%qs in variable definition context (%s) at %L is not a variable"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' в контексте определения переменных (%s) в %L не есть переменная"
  
  #: fortran/expr.c:4836
  #, gcc-internal-format, gfc-internal-format
  msgid "Non-POINTER in pointer association context (%s) at %L"
-msgstr ""
+msgstr "Non-POINTER в контексте ассоциации указателей (%s) в %L"
  
  #: fortran/expr.c:4845
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Named constant '%s' in variable definition context (%s) at %L"
  msgid "Type inaccessible in variable definition context (%s) at %L"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\98Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° '%s' Ð² ÐºÐ¾Ð½Ñ\82ÐµÐºÑ\81Ñ\82Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85 (%s) Ð² %L"
  
  #: fortran/expr.c:4858
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "LOCK_TYPE in variable definition context (%s) at %L"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "LOCK_TYPE в контексте определения переменных (%s) в %L"
  
  #: fortran/expr.c:4871
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "LOCK_TYPE in variable definition context (%s) at %L"
  msgid "LOCK_EVENT in variable definition context (%s) at %L"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "LOCK_TYPE в контексте определения переменных (%s) в %L"
  
  #: fortran/expr.c:4900
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy argument '%s' with INTENT(IN) in pointer association context (%s) at %L"
  msgid "Dummy argument %qs with INTENT(IN) in pointer association context (%s) at %L"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Формальный аргумент '%s' с INTENT(IN) в контексте ассоциации указателей (%s) в %L"
  
  #: fortran/expr.c:4908
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy argument '%s' with INTENT(IN) in variable definition context (%s) at %L"
  msgid "Dummy argument %qs with INTENT(IN) in variable definition context (%s) at %L"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Формальный аргумент '%s' с INTENT(IN) в контексте определения переменных (%s) в %L"
  
  #: fortran/expr.c:4921
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' is PROTECTED and can not appear in a pointer association context (%s) at %L"
  msgid "Variable %qs is PROTECTED and can not appear in a pointer association context (%s) at %L"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Переменная '%s' является PROTECTED и не может появляться в контексте ассоциации указателей (%s) в %L"
  
  #: fortran/expr.c:4929
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' is PROTECTED and can not appear in a variable definition context (%s) at %L"
  msgid "Variable %qs is PROTECTED and can not appear in a variable definition context (%s) at %L"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Переменная '%s' является PROTECTED и не может появляться в контексте определения переменных (%s) в %L"
  
  #: fortran/expr.c:4941
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' can not appear in a variable definition context (%s) at %L in PURE procedure"
  msgid "Variable %qs can not appear in a variable definition context (%s) at %L in PURE procedure"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Переменная '%s' не может появляться в контексте определения переменных (%s) в %L"
  
  #: fortran/expr.c:5000
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L associated to vector-indexed target can not be used in a variable definition context (%s)"
  msgid "%qs at %L associated to vector-indexed target can not be used in a variable definition context (%s)"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "'%s' в %L ассоциированное с векторно индексированной целью не может использоваться в контексте определения переменных (%s)"
  
  #: fortran/expr.c:5004
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L associated to expression can not be used in a variable definition context (%s)"
  msgid "%qs at %L associated to expression can not be used in a variable definition context (%s)"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "'%s' в %L ассоциированное с выражением не может использоваться в контексте определения переменных (%s)"
  
  #: fortran/expr.c:5015
  #, fuzzy, gcc-internal-format
+#| msgid "Associate-name '%s' can not appear in a variable definition context (%s) at %L because its target at %L can not, either"
  msgid "Associate-name %qs can not appear in a variable definition context (%s) at %L because its target at %L can not, either"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Имя ассоциации '%s' не может появляться в контексте определения переменных (%s) в %L поскольку его цель в %L также не может"
  
  #: fortran/expr.c:5057
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "'%s' at %L associated to expression can not be used in a variable definition context (%s)"
  msgid "Elements with the same value at %L and %L in vector subscript in a variable definition context (%s)"
-msgstr ""
+msgstr "'%s' в %L ассоциированное с выражением не может использоваться в контексте определения переменных (%s)"
  
  #: fortran/f95-lang.c:248
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "can't open input file: %s"
-msgstr "ошибка открытия входного файла %qs"
+msgstr "ошибка открытия входного файла: %s"
  
  #: fortran/frontend-passes.c:297
  #, gcc-internal-format
@@ -52217,39 +54515,45 @@ msgstr ""
  #: fortran/frontend-passes.c:693 fortran/trans-array.c:1044
  #: fortran/trans-array.c:6167 fortran/trans-array.c:7518
  #: fortran/trans-intrinsic.c:6278
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Creating array temporary at %L"
-msgstr "создание массива элементов типа %qT"
+msgstr "Создание временного массива в %L"
  
  #: fortran/frontend-passes.c:717 fortran/frontend-passes.c:720
  #, fuzzy, gcc-internal-format
+#| msgid "Removing call to function '%s' at %L"
  msgid "Removing call to function %qs at %L"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "Удаление вызова функции '%s' в %L"
  
  #: fortran/frontend-passes.c:1695
  #, fuzzy, gcc-internal-format
+#| msgid "invalid operands in gimple comparison"
  msgid "illegal OP in optimize_comparison"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86ии"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð² gimple Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½ии"
  
  #: fortran/frontend-passes.c:1887
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
  msgid "Variable %qs at %L set to undefined value inside loop  beginning at %L as INTENT(OUT) argument to subroutine %qs"
-msgstr ""
+msgstr "Переменная '%s' в %C не может быть переопределена внутри цикла начинающегося в %L"
  
  #: fortran/frontend-passes.c:1894
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
  msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
-msgstr ""
+msgstr "Переменная '%s' в %C не может быть переопределена внутри цикла начинающегося в %L"
  
  #: fortran/frontend-passes.c:1959
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
  msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
-msgstr ""
+msgstr "Переменная '%s' в %C не может быть переопределена внутри цикла начинающегося в %L"
  
  #: fortran/frontend-passes.c:1965
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
  msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
-msgstr ""
+msgstr "Переменная '%s' в %C не может быть переопределена внутри цикла начинающегося в %L"
  
  #: fortran/frontend-passes.c:2213 fortran/trans-expr.c:1522
  #, gcc-internal-format, gfc-internal-format
@@ -52262,129 +54566,136 @@ msgid "Scalarization using DIMEN_RANGE unimplemented"
  msgstr ""
  
  #: fortran/gfortranspec.c:145
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "overflowed output arg list for %qs"
-msgstr "переполнение списка выходных аргументов для `%s'"
+msgstr "переполнение списка выходных аргументов для %qs"
  
  #: fortran/gfortranspec.c:299
  #, gcc-internal-format
  msgid "no input files; unwilling to write output files"
-msgstr "Ð½ÐµÑ\82 Ð²Ñ\85Ð¾Ð´Ð½Ñ\8bÑ\85 Ñ\84Ð°Ð¹Ð»Ð¾Ð²; Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ñ\8bÐµ Ñ\84Ð°Ð¹Ð»Ñ\8b Ð½Ðµ Ð±Ñ\83Ð´Ñ\83Ñ\82 Ð·Ð°Ð¿Ð¸Ñ\81Ð°Ð½ы"
+msgstr "Ð½ÐµÑ\82 Ð²Ñ\85Ð¾Ð´Ð½Ñ\8bÑ\85 Ñ\84Ð°Ð¹Ð»Ð¾Ð²; Ð½ÐµÑ\82 Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ð¸ Ð·Ð°Ð¿Ð¸Ñ\81Ð°Ñ\82Ñ\8c Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ñ\8bÐµ Ñ\84Ð°Ð¹Ð»ы"
  
  #: fortran/interface.c:176
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in generic specification at %C"
-msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² generic Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð² %C"
  
  #: fortran/interface.c:203
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error: Trailing garbage in INTERFACE statement at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82ÐµÐºÑ\81Ñ\82 Ð¿Ð¾Ñ\81Ð»Ðµ Ñ\87Ð¸Ñ\81Ð»Ð° Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ°: Ð\9cÑ\83Ñ\81Ð¾Ñ\80 Ð² Ñ\85Ð²Ð¾Ñ\81Ñ\82Ðµ INTERFACE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/interface.c:222
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy procedure '%s' at %C cannot have a generic interface"
  msgid "Dummy procedure %qs at %C cannot have a generic interface"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Формальная процедура '%s' в %C не может иметь generic интерфейс"
  
  #: fortran/interface.c:255
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ABSTRACT INTERFACE at %C"
  msgid "ABSTRACT INTERFACE at %C"
-msgstr "Недопустимое число в операторе FORMAT в %0"
+msgstr "Fortran 2003: ABSTRACT INTERFACE в %C"
  
  #: fortran/interface.c:262
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in ABSTRACT INTERFACE statement at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² ABSTRACT INTERFACE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/interface.c:293
  #, gcc-internal-format, gfc-internal-format
  msgid "Syntax error: Trailing garbage in END INTERFACE statement at %C"
-msgstr ""
+msgstr "Синтаксическая ошибка: Мусор в хвосте END INTERFACE оператора в %C"
  
  #: fortran/interface.c:306
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected a nameless interface at %C"
-msgstr "  ожидался шаблон класса, обнаружено %qT"
+msgstr "Ожидался безымянный интерфейс в %C"
  
  #: fortran/interface.c:319
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Expected 'END INTERFACE ASSIGNMENT (=)' at %C"
  msgid "Expected %<END INTERFACE ASSIGNMENT (=)%> at %C"
-msgstr ""
+msgstr "Ожидалось 'END INTERFACE ASSIGNMENT (=)' в %C"
  
  #: fortran/interface.c:350
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Expecting 'END INTERFACE OPERATOR (.%s.)' at %C"
  msgid "Expecting %<END INTERFACE OPERATOR (%s)%> at %C, "
-msgstr ""
+msgstr "Ожидался 'END INTERFACE OPERATOR (.%s.)' в %C"
  
  #: fortran/interface.c:353
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Expecting 'END INTERFACE OPERATOR (%s)' at %C, but got %s"
  msgid "Expecting %<END INTERFACE OPERATOR (%s)%> at %C, but got %s"
-msgstr ""
+msgstr "Ожидался 'END INTERFACE OPERATOR (%s)' в %C, а получено %s"
  
  #: fortran/interface.c:367
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Expecting 'END INTERFACE OPERATOR (.%s.)' at %C"
  msgid "Expecting %<END INTERFACE OPERATOR (.%s.)%> at %C"
-msgstr ""
+msgstr "Ожидался 'END INTERFACE OPERATOR (.%s.)' в %C"
  
  #: fortran/interface.c:378
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Expecting 'END INTERFACE %s' at %C"
  msgid "Expecting %<END INTERFACE %s%> at %C"
-msgstr ""
+msgstr "Ожидалось 'END INTERFACE %s' в %C"
  
  #: fortran/interface.c:662
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Alternate return cannot appear in operator interface at %L"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Альтернативный возврат не может появляться в интерфейсе оператора в %L"
  
  #: fortran/interface.c:691
  #, gcc-internal-format, gfc-internal-format
  msgid "Assignment operator interface at %L must have two arguments"
-msgstr ""
+msgstr "Интерфейс оператора присваивания в %L должен иметь два аргумента"
  
  #: fortran/interface.c:694
  #, gcc-internal-format, gfc-internal-format
  msgid "Operator interface at %L has the wrong number of arguments"
-msgstr ""
+msgstr "Интерфейс оператора в %L имеет неверное число аргументов"
  
  #: fortran/interface.c:707
  #, gcc-internal-format, gfc-internal-format
  msgid "Assignment operator interface at %L must be a SUBROUTINE"
-msgstr ""
+msgstr "Интерфейс оператора присваивания в %L должен быть SUBROUTINE"
  
  #: fortran/interface.c:725
  #, gcc-internal-format, gfc-internal-format
  msgid "Assignment operator interface at %L must not redefine an INTRINSIC type assignment"
-msgstr ""
+msgstr "Интерфейс оператора присваивания в %L не должен переопределять присваивание INTRINSIC типа"
  
  #: fortran/interface.c:734
  #, gcc-internal-format, gfc-internal-format
  msgid "Intrinsic operator interface at %L must be a FUNCTION"
-msgstr ""
+msgstr "Интерфейс встроенного оператора в %L должен быть FUNCTION"
  
  #: fortran/interface.c:745
  #, gcc-internal-format, gfc-internal-format
  msgid "First argument of defined assignment at %L must be INTENT(OUT) or INTENT(INOUT)"
-msgstr ""
+msgstr "Первый аргумент определенного присваивания в %L должен быть INTENT(OUT) или INTENT(INOUT)"
  
  #: fortran/interface.c:752
  #, gcc-internal-format, gfc-internal-format
  msgid "Second argument of defined assignment at %L must be INTENT(IN)"
-msgstr ""
+msgstr "Второй аргумент определенного присваивания в %L должен быть INTENT(IN)"
  
  #: fortran/interface.c:761 fortran/resolve.c:15373
  #, gcc-internal-format, gfc-internal-format
  msgid "First argument of operator interface at %L must be INTENT(IN)"
-msgstr ""
+msgstr "Первый аргумент интерфейса оператора в %L должен быть INTENT(IN)"
  
  #: fortran/interface.c:768 fortran/resolve.c:15391
  #, gcc-internal-format, gfc-internal-format
  msgid "Second argument of operator interface at %L must be INTENT(IN)"
-msgstr ""
+msgstr "Второй аргумент интерфейса оператора в %L должен быть INTENT(IN)"
  
  #: fortran/interface.c:873
  #, gcc-internal-format, gfc-internal-format
  msgid "Operator interface at %L conflicts with intrinsic interface"
-msgstr ""
+msgstr "Интерфейс оператора в %L конфликтует со встроенным интерфейсом"
  
  #: fortran/interface.c:1205 fortran/interface.c:1264
  #, gcc-internal-format, gfc-internal-format
@@ -52403,98 +54714,114 @@ msgstr ""
  
  #: fortran/interface.c:1591
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' in %s at %L has no explicit interface"
  msgid "Procedure %qs in %s at %L has no explicit interface"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' Ð² %s Ð² %L Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\8fÐ²Ð½Ð¾Ð³Ð¾ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81Ð°"
  
  #: fortran/interface.c:1594
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' in %s at %L is neither function nor subroutine"
  msgid "Procedure %qs in %s at %L is neither function nor subroutine"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' Ð² %s Ð² %L Ð½Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ð¸ Ð½Ðµ Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ð°"
  
  #: fortran/interface.c:1606
  #, gcc-internal-format, gfc-internal-format
  msgid "In %s at %L procedures must be either all SUBROUTINEs or all FUNCTIONs"
-msgstr ""
+msgstr "В %s в %L процедуры должны быть либо все SUBROUTINEs либо все FUNCTIONs"
  
  #: fortran/interface.c:1610
  #, gcc-internal-format, gfc-internal-format
  msgid "In %s at %L procedures must be all FUNCTIONs as the generic name is also the name of a derived type"
-msgstr ""
+msgstr "В %s в %L процедуры должны быть все FUNCTIONs поскольку generic имя есть также имя производного типа"
  
  #: fortran/interface.c:1618
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2008: Internal procedure '%s' in %s at %L"
  msgid "Internal procedure %qs in %s at %L"
-msgstr "Внешняя процедура `%A' передана как фактический аргумент в %0, но не декларирована явно как EXTERNAL"
+msgstr "Fortran 2008: Внутренняя процедура '%s' в %s в %L"
  
  #: fortran/interface.c:1675 fortran/interface.c:1679
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Ambiguous interfaces '%s' and '%s' in %s at %L"
  msgid "Ambiguous interfaces %qs and %qs in %s at %L"
-msgstr ""
+msgstr "Неоднозначные интерфейсы '%s' и '%s' в %s в %L"
  
  #: fortran/interface.c:1683
  #, fuzzy, gcc-internal-format
+#| msgid "Although not referenced, '%s' has ambiguous interfaces at %L"
  msgid "Although not referenced, %qs has ambiguous interfaces at %L"
-msgstr "ссылка %qs неоднозначна: имеется в интерфейсе %qs и в интерфейсе %qs"
+msgstr "Хотя без ссылки, '%s' имеет неоднозначные интерфейсы в %L"
  
  #: fortran/interface.c:1718
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L is not a module procedure"
  msgid "%qs at %L is not a module procedure"
-msgstr "`%D' не является элементом типа `%T'"
+msgstr "'%s' в %L не есть процедура модуля"
  
  #: fortran/interface.c:1922
  #, fuzzy, gcc-internal-format
+#| msgid "Assumed shape array at %L must be a dummy argument"
  msgid "The assumed-rank array at %L requires that the dummy argument %qs has assumed-rank"
-msgstr "Ð\90Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² %0 Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9cÐ°Ñ\81Ñ\81Ð¸Ð² Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð¹ Ñ\84Ð¾Ñ\80Ð¼Ñ\8b Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼"
  
  #: fortran/interface.c:1927
  #, fuzzy, gcc-internal-format
+#| msgid "Rank mismatch in argument '%s' at %L (scalar and rank-%d)"
  msgid "Rank mismatch in argument %qs at %L (scalar and rank-%d)"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\80Ð°Ð½Ð³Ð¾Ð² Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ '%s' Ð² %L (Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80 Ð¸ Ñ\80Ð°Ð½Ð³--%d)"
  
  #: fortran/interface.c:1932
  #, fuzzy, gcc-internal-format
+#| msgid "Rank mismatch in argument '%s' at %L (rank-%d and scalar)"
  msgid "Rank mismatch in argument %qs at %L (rank-%d and scalar)"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\80Ð°Ð½Ð³Ð¾Ð² Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ '%s' Ð² %L (Ñ\80Ð°Ð½Ð³--%d Ð¸ Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80)"
  
  #: fortran/interface.c:1937
  #, fuzzy, gcc-internal-format
+#| msgid "Rank mismatch in argument '%s' at %L (rank-%d and rank-%d)"
  msgid "Rank mismatch in argument %qs at %L (rank-%d and rank-%d)"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\80Ð°Ð½Ð³Ð¾Ð² Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ '%s' Ð² %L (Ñ\80Ð°Ð½Ð³--%d Ð¸ Ñ\80Ð°Ð½Ð³--%d)"
  
  #: fortran/interface.c:1980
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid procedure argument at %L"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qs"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b Ð² %L"
  
  #: fortran/interface.c:1988 fortran/interface.c:2015
  #, fuzzy, gcc-internal-format
+#| msgid "Interface mismatch in dummy procedure '%s' at %L: %s"
  msgid "Interface mismatch in dummy procedure %qs at %L: %s"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81Ð° Ð² Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ðµ '%s' Ð² %L: %s"
  
  #: fortran/interface.c:2026
  #, fuzzy, gcc-internal-format
+#| msgid "Actual argument to contiguous pointer dummy '%s' at %L must be simply contigous"
  msgid "Actual argument to contiguous pointer dummy %qs at %L must be simply contiguous"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f Ð½ÐµÐ¿Ñ\80ÐµÑ\80Ñ\8bÐ²Ð½Ð¾Ð³Ð¾ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ð¾ Ð½ÐµÐ¿Ñ\80ÐµÑ\80Ñ\8bÐ²Ð½Ñ\8bм"
  
  #: fortran/interface.c:2041
  #, fuzzy, gcc-internal-format
+#| msgid "Type mismatch in argument '%s' at %L; passed %s to %s"
  msgid "Type mismatch in argument %qs at %L; passed %s to %s"
-msgstr "Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ñ\8f Ñ\82Ð¸Ð¿Ð°/Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ %d Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð¾Ð² Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð´Ð»Ñ\8f %qD"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ñ\82Ð¸Ð¿Ð° Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ '%s' Ð² %L; Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %s Ð² %s"
  
  #: fortran/interface.c:2050
  #, fuzzy, gcc-internal-format
+#| msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument '%s' due to VOLATILE attribute"
  msgid "Assumed-type actual argument at %L requires that dummy argument %qs is of assumed type"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð¹ Ñ\84Ð¾Ñ\80Ð¼Ñ\8b Ð² %L Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 non-assumed-shape Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼ '%s' Ð¸Ð·-Ð·Ð° VOLATILE Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð°"
  
  #: fortran/interface.c:2066
  #, fuzzy, gcc-internal-format
+#| msgid "Actual argument to '%s' at %L must be polymorphic"
  msgid "Actual argument to %qs at %L must be polymorphic"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ð¾Ð»Ð¸Ð¼Ð¾Ñ\80Ñ\84Ð½Ñ\8bм"
  
  #: fortran/interface.c:2079
  #, fuzzy, gcc-internal-format
+#| msgid "Actual argument to '%s' at %L must have the same declared type"
  msgid "Actual argument to %qs at %L must have the same declared type"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ñ\82Ð¾Ñ\82 Ð¶Ðµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
  
  #: fortran/interface.c:2094
  #, gcc-internal-format
@@ -52503,98 +54830,114 @@ msgstr ""
  
  #: fortran/interface.c:2105
  #, fuzzy, gcc-internal-format
+#| msgid "Actual argument to '%s' at %L must be a coarray"
  msgid "Actual argument to %qs at %L must be a coarray"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾м"
  
  #: fortran/interface.c:2124
  #, fuzzy, gcc-internal-format
+#| msgid "Corank mismatch in argument '%s' at %L (%d and %d)"
  msgid "Corank mismatch in argument %qs at %L (%d and %d)"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ ÐºÐ¾Ñ\80Ð°Ð½Ð³Ð¾Ð² Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ðµ '%s' Ð² %L (%d Ð¸ %d)"
  
  #: fortran/interface.c:2142
  #, fuzzy, gcc-internal-format
+#| msgid "Actual argument to '%s' at %L must be simply contiguous"
  msgid "Actual argument to %qs at %L must be simply contiguous or an element of such an array"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ð¾ Ð½ÐµÐ¿Ñ\80ÐµÑ\80Ñ\8bÐ²Ð½Ñ\8bм"
  
  #: fortran/interface.c:2157
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Actual argument to non-INTENT(INOUT) dummy '%s' at %L, which is LOCK_TYPE or has a LOCK_TYPE component"
  msgid "Actual argument to non-INTENT(INOUT) dummy %qs at %L, which is LOCK_TYPE or has a LOCK_TYPE component"
-msgstr ""
+msgstr "Фактический аргумент для non-INTENT(INOUT) формального параметра '%s' в %L, который есть LOCK_TYPE или имеет LOCK_TYPE компонент"
  
  #: fortran/interface.c:2172
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Actual argument to non-INTENT(INOUT) dummy '%s' at %L, which is LOCK_TYPE or has a LOCK_TYPE component"
  msgid "Actual argument to non-INTENT(INOUT) dummy %qs at %L, which is EVENT_TYPE or has a EVENT_TYPE component"
-msgstr ""
+msgstr "Фактический аргумент для non-INTENT(INOUT) формального параметра '%s' в %L, который есть LOCK_TYPE или имеет LOCK_TYPE компонент"
  
  #: fortran/interface.c:2191
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Dummy argument '%s' has to be a pointer or assumed-shape array without CONTIGUOUS attribute - as actual argument at %L is not simply contiguous and both are ASYNCHRONOUS or VOLATILE"
  msgid "Dummy argument %qs has to be a pointer, assumed-shape or assumed-rank array without CONTIGUOUS attribute - as actual argument at %L is not simply contiguous and both are ASYNCHRONOUS or VOLATILE"
-msgstr ""
+msgstr "Формальный аргумент '%s' должен быть указателем или массивом предполагаемой формы без CONTIGUOUS атрибута - поскольку фактический аргумент в %L не является просто непрерывным и оба являются ASYNCHRONOUS или VOLATILE"
  
  #: fortran/interface.c:2204
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Passing coarray at %L to allocatable, noncoarray, INTENT(OUT) dummy argument '%s'"
  msgid "Passing coarray at %L to allocatable, noncoarray, INTENT(OUT) dummy argument %qs"
-msgstr ""
+msgstr "Передача комассива в %L в allocatable, noncoarray, INTENT(OUT) формальный аргумент '%s'"
  
  #: fortran/interface.c:2211
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Passing coarray at %L to allocatable, noncoarray dummy argument '%s', which is invalid if the allocation status is modified"
  msgid "Passing coarray at %L to allocatable, noncoarray dummy argument %qs, which is invalid if the allocation status is modified"
-msgstr ""
+msgstr "Передача комассива в %L в allocatable, noncoarray формальный аргумент '%s', что некорректно если статус размещения модифицирован"
  
  #: fortran/interface.c:2274
  #, fuzzy, gcc-internal-format
+#| msgid "Polymorphic scalar passed to array dummy argument '%s' at %L"
  msgid "Polymorphic scalar passed to array dummy argument %qs at %L"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s в %L"
+msgstr "Ð\9fÐ¾Ð»Ð¸Ð¼Ð¾Ñ\80Ñ\84Ð½Ñ\8bÐ¹ Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80 Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½ Ð² Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² '%s' в %L"
  
  #: fortran/interface.c:2283
  #, fuzzy, gcc-internal-format
+#| msgid "Element of assumed-shaped or pointer array passed to array dummy argument '%s' at %L"
  msgid "Element of assumed-shaped or pointer array passed to array dummy argument %qs at %L"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s в %L"
+msgstr "ÐÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð¹ Ñ\84Ð¾Ñ\80Ð¼Ñ\8b Ð¸Ð»Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ð³Ð¾ Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½ Ð² Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² '%s' в %L"
  
  #: fortran/interface.c:2295
  #, fuzzy, gcc-internal-format
+#| msgid "Extension: Scalar non-default-kind, non-C_CHAR-kind CHARACTER actual argument with array dummy argument '%s' at %L"
  msgid "Extension: Scalar non-default-kind, non-C_CHAR-kind CHARACTER actual argument with array dummy argument %qs at %L"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: Ð¡ÐºÐ°Ð»Ñ\8fÑ\80Ð½Ñ\8bÐ¹ Ð½ÐµÐ¿Ð¾Ð´Ñ\80Ð°Ð·Ñ\83Ð¼ÐµÐ²Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ð²Ð¸Ð´Ð°, non-C_CHAR-kind CHARACTER Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ñ\81 Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾Ð¼ '%s' Ð² %L"
  
  #: fortran/interface.c:2303
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: Scalar CHARACTER actual argument with array dummy argument '%s' at %L"
  msgid "Fortran 2003: Scalar CHARACTER actual argument with array dummy argument %qs at %L"
-msgstr "передано %qT для %s %P в %qD"
+msgstr "Fortran 2003: Скалярный CHARACTER фактический аргумент с формальным аргументом массивом '%s' в %L"
  
  #: fortran/interface.c:2632
  #, fuzzy, gcc-internal-format
+#| msgid "Keyword argument '%s' at %L is not in the procedure"
  msgid "Keyword argument %qs at %L is not in the procedure"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Аргумент с ключевым словом '%s' в %L не в процедуре"
  
  #: fortran/interface.c:2640
  #, fuzzy, gcc-internal-format
+#| msgid "Keyword argument '%s' at %L is already associated with another actual argument"
  msgid "Keyword argument %qs at %L is already associated with another actual argument"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ñ\81 ÐºÐ»Ñ\8eÑ\87ÐµÐ²Ñ\8bÐ¼ Ñ\81Ð»Ð¾Ð²Ð¾Ð¼ '%s' Ð² %L Ñ\83Ð¶Ðµ Ð°Ñ\81Ñ\81Ð¾Ñ\86Ð¸Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ñ\81 Ð´Ñ\80Ñ\83Ð³Ð¸Ð¼ Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼"
  
  #: fortran/interface.c:2650
  #, gcc-internal-format, gfc-internal-format
  msgid "More actual than formal arguments in procedure call at %L"
-msgstr ""
+msgstr "Больше фактических чем формальных аргументов в вызове процедуры в %L"
  
  #: fortran/interface.c:2662 fortran/interface.c:3032
  #, gcc-internal-format, gfc-internal-format
  msgid "Missing alternate return spec in subroutine call at %L"
-msgstr ""
+msgstr "Отсутствует спецификация альтернативного возврата в вызове подпрограммы в %L"
  
  #: fortran/interface.c:2670
  #, gcc-internal-format, gfc-internal-format
  msgid "Unexpected alternate return spec in subroutine call at %L"
-msgstr ""
+msgstr "Неожиданная спецификация альтернативного возврата в вызове подпрограммы в %L"
  
  #: fortran/interface.c:2697
  #, fuzzy, gcc-internal-format
+#| msgid "Unexpected NULL() intrinsic at %L to dummy '%s'"
  msgid "Unexpected NULL() intrinsic at %L to dummy %qs"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð°Ñ\8f NULL() Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ð² %L Ð² Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 '%s'"
  
  #: fortran/interface.c:2700
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Fortran 2008: Null pointer at %L to non-pointer dummy '%s'"
  msgid "Fortran 2008: Null pointer at %L to non-pointer dummy %qs"
-msgstr ""
+msgstr "Fortran 2008: Пустой указатель в %L в неуказательный формальный параметр '%s'"
  
  #: fortran/interface.c:2724
  #, gcc-internal-format, gfc-internal-format
@@ -52603,108 +54946,129 @@ msgstr ""
  
  #: fortran/interface.c:2746
  #, fuzzy, gcc-internal-format
+#| msgid "Character length mismatch (%ld/%ld) between actual argument and pointer or allocatable dummy argument '%s' at %L"
  msgid "Character length mismatch (%ld/%ld) between actual argument and pointer or allocatable dummy argument %qs at %L"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ character Ð´Ð»Ð¸Ð½ (%ld/%ld) Ð¼ÐµÐ¶Ð´Ñ\83 Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼ Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¼ Ð¸Ð»Ð¸ Ñ\80Ð°Ð·Ð¼ÐµÑ\89Ð°ÐµÐ¼Ñ\8bÐ¼ Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼ '%s' Ð² %L"
  
  #: fortran/interface.c:2754
  #, fuzzy, gcc-internal-format
+#| msgid "Character length mismatch (%ld/%ld) between actual argument and assumed-shape dummy argument '%s' at %L"
  msgid "Character length mismatch (%ld/%ld) between actual argument and assumed-shape dummy argument %qs at %L"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ character Ð´Ð»Ð¸Ð½ (%ld/%ld) Ð¼ÐµÐ¶Ð´Ñ\83 Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼ Ð¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼ Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð¹ Ñ\84Ð¾Ñ\80Ð¼Ñ\8b '%s' Ð² %L"
  
  #: fortran/interface.c:2768
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Actual argument at %L to allocatable or pointer dummy argument '%s' must have a deferred length type parameter if and only if the dummy has one"
  msgid "Actual argument at %L to allocatable or pointer dummy argument %qs must have a deferred length type parameter if and only if the dummy has one"
-msgstr ""
+msgstr "Фактический аргумент в %L в размещаемый или указательный формальный аргумент '%s' должен иметь типовый параметр отложенной длины тогда и только тогда когда таковой имеется у формального"
  
  #: fortran/interface.c:2785
  #, fuzzy, gcc-internal-format
+#| msgid "Character length of actual argument shorter than of dummy argument '%s' (%lu/%lu) at %L"
  msgid "Character length of actual argument shorter than of dummy argument %qs (%lu/%lu) at %L"
-msgstr "передано %qT для %s %P в %qD"
+msgstr "Character длина фактического аргумента короче чем у формального аргумента '%s' (%lu/%lu) в %L"
  
  #: fortran/interface.c:2790
  #, fuzzy, gcc-internal-format
+#| msgid "Actual argument contains too few elements for dummy argument '%s' (%lu/%lu) at %L"
  msgid "Actual argument contains too few elements for dummy argument %qs (%lu/%lu) at %L"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ñ\81Ð¾Ð´ÐµÑ\80Ð¶Ð¸Ñ\82 Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð°Ð»Ð¾ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð² Ð´Ð»Ñ\8f Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° '%s' (%lu/%lu) Ð² %L"
  
  #: fortran/interface.c:2809
  #, fuzzy, gcc-internal-format
+#| msgid "Expected a procedure pointer for argument '%s' at %L"
  msgid "Expected a procedure pointer for argument %qs at %L"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 Ð´Ð»Ñ\8f Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° '%s' Ð² %L"
  
  #: fortran/interface.c:2825
  #, fuzzy, gcc-internal-format
+#| msgid "Expected a procedure for argument '%s' at %L"
  msgid "Expected a procedure for argument %qs at %L"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° Ð´Ð»Ñ\8f Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° '%s' Ð² %L"
  
  #: fortran/interface.c:2839
  #, fuzzy, gcc-internal-format
+#| msgid "Actual argument for '%s' cannot be an assumed-size array at %L"
  msgid "Actual argument for %qs cannot be an assumed-size array at %L"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾Ð¼ Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° Ð² %L"
  
  #: fortran/interface.c:2848
  #, fuzzy, gcc-internal-format
+#| msgid "Actual argument for '%s' must be a pointer at %L"
  msgid "Actual argument for %qs must be a pointer at %L"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ð² %L"
  
  #: fortran/interface.c:2858
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Fortran 2008: Non-pointer actual argument at %L to pointer dummy '%s'"
  msgid "Fortran 2008: Non-pointer actual argument at %L to pointer dummy %qs"
-msgstr ""
+msgstr "Fortran 2008: Неуказательный фактический аргумент в %L в указательный формальный параметр '%s'"
  
  #: fortran/interface.c:2868
  #, fuzzy, gcc-internal-format
+#| msgid "Coindexed actual argument at %L to pointer dummy '%s'"
  msgid "Coindexed actual argument at %L to pointer dummy %qs"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð\9aÐ¾Ð¸Ð½Ð´ÐµÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %L Ð² Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 '%s'"
  
  #: fortran/interface.c:2881
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Coindexed actual argument at %L to allocatable dummy '%s' requires INTENT(IN)"
  msgid "Coindexed actual argument at %L to allocatable dummy %qs requires INTENT(IN)"
-msgstr ""
+msgstr "Коиндексированный фактический аргумент в %L в размещаемый формальный параметр '%s' требует INTENT(IN)"
  
  #: fortran/interface.c:2895
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Coindexed ASYNCHRONOUS or VOLATILE actual argument at %L requires that dummy '%s' has neither ASYNCHRONOUS nor VOLATILE"
  msgid "Coindexed ASYNCHRONOUS or VOLATILE actual argument at %L requires that dummy %qs has neither ASYNCHRONOUS nor VOLATILE"
-msgstr ""
+msgstr "Коиндексированный ASYNCHRONOUS или VOLATILE фактический аргумент в %L требует чтобы формальный параметр '%s' не имел ни ASYNCHRONOUS ни VOLATILE"
  
  #: fortran/interface.c:2909
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Coindexed actual argument at %L with allocatable ultimate component to dummy '%s' requires either VALUE or INTENT(IN)"
  msgid "Coindexed actual argument at %L with allocatable ultimate component to dummy %qs requires either VALUE or INTENT(IN)"
-msgstr ""
+msgstr "Коиндексированный фактический аргумент в %L с размещаемым окончательным компонентом для формального параметра '%s' требует либо VALUE либо INTENT(IN)"
  
  #: fortran/interface.c:2921
  #, fuzzy, gcc-internal-format
+#| msgid "Actual CLASS array argument for '%s' must be a full array at %L"
  msgid "Actual CLASS array argument for %qs must be a full array at %L"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 CLASS array Ð´Ð»Ñ\8f '%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ð¾Ð»Ð½Ñ\8bÐ¼ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾Ð¼ Ð² %L"
  
  #: fortran/interface.c:2931
  #, fuzzy, gcc-internal-format
+#| msgid "Actual argument for '%s' must be ALLOCATABLE at %L"
  msgid "Actual argument for %qs must be ALLOCATABLE at %L"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c ALLOCATABLE Ð² %L"
  
  #: fortran/interface.c:2960
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument '%s'"
  msgid "Array-section actual argument with vector subscripts at %L is incompatible with INTENT(OUT), INTENT(INOUT), VOLATILE or ASYNCHRONOUS attribute of the dummy argument %qs"
-msgstr ""
+msgstr "Фактический аргумент секция массива с векторными индексами в %L несовместим с INTENT(OUT), INTENT(INOUT), VOLATILE или ASYNCHRONOUS атрибутом формального аргумента '%s'"
  
  #: fortran/interface.c:2978
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument '%s' due to VOLATILE attribute"
  msgid "Assumed-shape actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
-msgstr ""
+msgstr "Фактический аргумент предполагаемой формы в %L несовместим с non-assumed-shape формальным аргументом '%s' из-за VOLATILE атрибута"
  
  #: fortran/interface.c:2990
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument '%s' due to VOLATILE attribute"
  msgid "Array-section actual argument at %L is incompatible with the non-assumed-shape dummy argument %qs due to VOLATILE attribute"
-msgstr ""
+msgstr "Фактический аргумент секция массива в %L несовместим с non-assumed-shape формальным аргументом '%s' из-за VOLATILE атрибута"
  
  #: fortran/interface.c:3009
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument '%s' due to VOLATILE attribute"
  msgid "Pointer-array actual argument at %L requires an assumed-shape or pointer-array dummy argument %qs due to VOLATILE attribute"
-msgstr ""
+msgstr "Фактический аргумент pointer-array в %L требует assumed-shape или pointer-array формальный аргумент '%s' из-за VOLATILE атрибута"
  
  #: fortran/interface.c:3039
  #, fuzzy, gcc-internal-format
+#| msgid "Missing actual argument for argument '%s' at %L"
  msgid "Missing actual argument for argument %qs at %L"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° '%s' Ð² %L"
  
  #: fortran/interface.c:3156
  #, gcc-internal-format
@@ -52722,9 +55086,10 @@ msgid "check_some_aliasing(): corrupted data"
  msgstr ""
  
  #: fortran/interface.c:3221
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Same actual argument associated with INTENT(%s) argument '%s' and INTENT(%s) argument '%s' at %L"
  msgid "Same actual argument associated with INTENT(%s) argument %qs and INTENT(%s) argument %qs at %L"
-msgstr ""
+msgstr "Один и тот же фактический аргумент ассоциирован с INTENT(%s) аргументом '%s' и INTENT(%s) аргументом '%s' в %L"
  
  #: fortran/interface.c:3251
  #, gcc-internal-format
@@ -52734,102 +55099,117 @@ msgstr ""
  #: fortran/interface.c:3271
  #, gcc-internal-format, gfc-internal-format
  msgid "Procedure argument at %L is local to a PURE procedure and has the POINTER attribute"
-msgstr ""
+msgstr "Аргумент процедуры в %L локален в PURE процедуре и имеет POINTER атрибут"
  
  #: fortran/interface.c:3283
  #, gcc-internal-format, gfc-internal-format
  msgid "Coindexed actual argument at %L in PURE procedure is passed to an INTENT(%s) argument"
-msgstr ""
+msgstr "Коиндексированный фактический аргумент в %L в процедуре PURE передан в аргумент INTENT(%s)"
  
  #: fortran/interface.c:3293
  #, gcc-internal-format, gfc-internal-format
  msgid "Coindexed actual argument at %L in PURE procedure is passed to a POINTER dummy argument"
-msgstr ""
+msgstr "Коиндексированный фактический аргумент в %L в PURE процедуре передан в POINTER формальный аргумент"
  
  #: fortran/interface.c:3304
  #, fuzzy, gcc-internal-format
+#| msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument '%s'"
  msgid "Coindexed polymorphic actual argument at %L is passed polymorphic dummy argument %qs"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð\9aÐ¾Ð¸Ð½Ð´ÐµÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ð¿Ð¾Ð»Ð¸Ð¼Ð¾Ñ\80Ñ\84Ð½Ñ\8bÐ¹ Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %L Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½ Ð² Ð¿Ð¾Ð»Ð¸Ð¼Ð¾Ñ\80Ñ\84Ð½Ñ\8bÐ¹ Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s'"
  
  #: fortran/interface.c:3332 fortran/interface.c:3342
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' called at %L is not explicitly declared"
  msgid "Procedure %qs called at %L is not explicitly declared"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' Ð²Ñ\8bÐ·Ð²Ð°Ð½Ð½Ð°Ñ\8f Ð² %L Ð½Ðµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° Ñ\8fÐ²Ð½Ð¾"
  
  #: fortran/interface.c:3338
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' called with an implicit interface at %L"
  msgid "Procedure %qs called with an implicit interface at %L"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' Ð²Ñ\8bÐ·Ð²Ð°Ð½Ð° Ñ\81 Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÐ¼ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81Ð¾Ð¼ Ð² %L"
  
  #: fortran/interface.c:3352
  #, fuzzy, gcc-internal-format
+#| msgid "The pointer object '%s' at %L must have an explicit function interface or be declared as array"
  msgid "The pointer object %qs at %L must have an explicit function interface or be declared as array"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Указательный объект '%s' в %L должен иметь явный функциональный интерфейс или быть декларированным как массив"
  
  #: fortran/interface.c:3360
  #, fuzzy, gcc-internal-format
+#| msgid "The allocatable object '%s' at %L must have an explicit function interface or be declared as array"
  msgid "The allocatable object %qs at %L must have an explicit function interface or be declared as array"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Размещаемый объект '%s' в %L должен иметь явный функциональный интерфейс или быть декларированным как массив"
  
  #: fortran/interface.c:3368
  #, fuzzy, gcc-internal-format
+#| msgid "Allocatable function '%s' at %L must have an explicit function interface"
  msgid "Allocatable function %qs at %L must have an explicit function interface"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Размещаемая функция '%s' в %L должна иметь явный функциональный интерфейс"
  
  #: fortran/interface.c:3378
  #, fuzzy, gcc-internal-format
+#| msgid "Keyword argument requires explicit interface for procedure '%s' at %L"
  msgid "Keyword argument requires explicit interface for procedure %qs at %L"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ñ\81 ÐºÐ»Ñ\8eÑ\87ÐµÐ²Ñ\8bÐ¼ Ñ\81Ð»Ð¾Ð²Ð¾Ð¼ Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ñ\8fÐ²Ð½Ñ\8bÐ¹ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81 Ð´Ð»Ñ\8f Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b '%s' Ð² %L"
  
  #: fortran/interface.c:3387
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Symbol '%s' at %L already has an explicit interface"
  msgid "Assumed-type argument %s at %L requires an explicit interface"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» '%s' Ð² %L Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\8fÐ²Ð½Ñ\8bÐ¹ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81"
  
  #: fortran/interface.c:3400
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure '%s'"
  msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
-msgstr ""
+msgstr "Фактический аргумент LOCK_TYPE или с LOCK_TYPE компонентом в %L требует явный интерфейс для процедуры '%s'"
  
  #: fortran/interface.c:3413
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure '%s'"
  msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
-msgstr ""
+msgstr "Фактический аргумент LOCK_TYPE или с LOCK_TYPE компонентом в %L требует явный интерфейс для процедуры '%s'"
  
  #: fortran/interface.c:3422
  #, gcc-internal-format, gfc-internal-format
  msgid "MOLD argument to NULL required at %L"
-msgstr ""
+msgstr "MOLD аргумент в NULL требуется в %L"
  
  #: fortran/interface.c:3430
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Keyword argument requires explicit interface for procedure '%s' at %L"
  msgid "Assumed-rank argument requires an explicit interface at %L"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ñ\81 ÐºÐ»Ñ\8eÑ\87ÐµÐ²Ñ\8bÐ¼ Ñ\81Ð»Ð¾Ð²Ð¾Ð¼ Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ñ\8fÐ²Ð½Ñ\8bÐ¹ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81 Ð´Ð»Ñ\8f Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b '%s' Ð² %L"
  
  #: fortran/interface.c:3468
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure pointer component '%s' called with an implicit interface at %L"
  msgid "Procedure pointer component %qs called with an implicit interface at %L"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 '%s' Ð²Ñ\8bÐ·Ð²Ð°Ð½ Ñ\81 Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÐ¼ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81Ð¾Ð¼ Ð² %L"
  
  #: fortran/interface.c:3479
  #, fuzzy, gcc-internal-format
+#| msgid "Keyword argument requires explicit interface for procedure pointer component '%s' at %L"
  msgid "Keyword argument requires explicit interface for procedure pointer component %qs at %L"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ñ\81 ÐºÐ»Ñ\8eÑ\87ÐµÐ²Ñ\8bÐ¼ Ñ\81Ð»Ð¾Ð²Ð¾Ð¼ Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ñ\8fÐ²Ð½Ñ\8bÐ¹ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81 Ð´Ð»Ñ\8f ÐºÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82Ð° Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 '%s' Ð² %L"
  
  #: fortran/interface.c:3564
  #, gcc-internal-format, gfc-internal-format
  msgid "MOLD= required in NULL() argument at %L: Ambiguity between specific functions %s and %s"
-msgstr ""
+msgstr "MOLD= требуется в NULL() аргументе в %L: Неоднозначность между конкретными функциями %s и %s"
  
  #: fortran/interface.c:3634
  #, fuzzy, gcc-internal-format
+#| msgid "%q+D aliased to undefined symbol %qE"
  msgid "Unable to find symbol %qs"
-msgstr "%q+D - алиас неопределенного символа %qs"
+msgstr "%q+D - алиас неопределенного символа %qE"
  
  #: fortran/interface.c:4001
  #, fuzzy, gcc-internal-format
+#| msgid "Entity '%s' at %C is already present in the interface"
  msgid "Entity %qs at %L is already present in the interface"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Сущность '%s' в %C уже присутствует в интерфейсе"
  
  #: fortran/interface.c:4117
  #, gcc-internal-format
@@ -52838,113 +55218,135 @@ msgstr ""
  
  #: fortran/interface.c:4212
  #, fuzzy, gcc-internal-format
+#| msgid "Can't overwrite GENERIC '%s' at %L"
  msgid "Can't overwrite GENERIC %qs at %L"
-msgstr "Не удалось преобразовать %s в %s в %L"
+msgstr "Не удалось переписать GENERIC '%s' в %L"
  
  #: fortran/interface.c:4224
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L overrides a procedure binding declared NON_OVERRIDABLE"
  msgid "%qs at %L overrides a procedure binding declared NON_OVERRIDABLE"
-msgstr ""
+msgstr "'%s' в %L перебивает связывание процедуры декларированной NON_OVERRIDABLE"
  
  #: fortran/interface.c:4232
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
  msgid "%qs at %L must not be DEFERRED as it overrides a non-DEFERRED binding"
-msgstr ""
+msgstr "'%s' в %L не должно быть DEFERRED поскольку это перебивает non-DEFERRED связывание"
  
  #: fortran/interface.c:4240
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L overrides a PURE procedure and must also be PURE"
  msgid "%qs at %L overrides a PURE procedure and must also be PURE"
-msgstr ""
+msgstr "'%s' в %L перебивает PURE процедуру и должна также быть PURE"
  
  #: fortran/interface.c:4249
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
  msgid "%qs at %L overrides an ELEMENTAL procedure and must also be ELEMENTAL"
-msgstr ""
+msgstr "'%s' в %L перебивает ELEMENTAL процедуру и должна также быть ELEMENTAL"
  
  #: fortran/interface.c:4255
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
  msgid "%qs at %L overrides a non-ELEMENTAL procedure and must not be ELEMENTAL, either"
-msgstr ""
+msgstr "'%s' в %L перебивает non-ELEMENTAL процедуру и не должна быть ELEMENTAL, также"
  
  #: fortran/interface.c:4264
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
  msgid "%qs at %L overrides a SUBROUTINE and must also be a SUBROUTINE"
-msgstr ""
+msgstr "'%s' в %L перебивает SUBROUTINE и должна также быть SUBROUTINE"
  
  #: fortran/interface.c:4275
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L overrides a FUNCTION and must also be a FUNCTION"
  msgid "%qs at %L overrides a FUNCTION and must also be a FUNCTION"
-msgstr ""
+msgstr "'%s' в %L перебивает FUNCTION и должна также быть FUNCTION"
  
  #: fortran/interface.c:4283
  #, fuzzy, gcc-internal-format
+#| msgid "Argument mismatch for the overriding procedure '%s' at %L: %s"
  msgid "Result mismatch for the overriding procedure %qs at %L: %s"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð´Ð»Ñ\8f Ð¿ÐµÑ\80ÐµÐ±Ð¸Ð²Ð°ÐµÐ¼Ð¾Ð¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b '%s' Ð² %L: %s"
  
  #: fortran/interface.c:4294
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L overrides a PUBLIC procedure and must not be PRIVATE"
  msgid "%qs at %L overrides a PUBLIC procedure and must not be PRIVATE"
-msgstr ""
+msgstr "'%s' в %L перебивает PUBLIC процедуру и не должна быть PRIVATE"
  
  #: fortran/interface.c:4324
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Dummy argument '%s' of '%s' at %L should be named '%s' as to match the corresponding argument of the overridden procedure"
  msgid "Dummy argument %qs of %qs at %L should be named %qs as to match the corresponding argument of the overridden procedure"
-msgstr ""
+msgstr "Формальный аргумент '%s' от '%s' в %L должен именоваться '%s' чтобы подходить соответствующему аргументу перебиваемой процедуры"
  
  #: fortran/interface.c:4335
  #, fuzzy, gcc-internal-format
+#| msgid "Argument mismatch for the overriding procedure '%s' at %L: %s"
  msgid "Argument mismatch for the overriding procedure %qs at %L: %s"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð´Ð»Ñ\8f Ð¿ÐµÑ\80ÐµÐ±Ð¸Ð²Ð°ÐµÐ¼Ð¾Ð¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b '%s' Ð² %L: %s"
  
  #: fortran/interface.c:4344
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L must have the same number of formal arguments as the overridden procedure"
  msgid "%qs at %L must have the same number of formal arguments as the overridden procedure"
-msgstr ""
+msgstr "'%s' at %L должен иметь то же число формальных аргументов что и перебиваемая процедура"
  
  #: fortran/interface.c:4353
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L overrides a NOPASS binding and must also be NOPASS"
  msgid "%qs at %L overrides a NOPASS binding and must also be NOPASS"
-msgstr ""
+msgstr "'%s' в %L перебивает NOPASS связывание и должен также быть NOPASS"
  
  #: fortran/interface.c:4364
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L overrides a binding with PASS and must also be PASS"
  msgid "%qs at %L overrides a binding with PASS and must also be PASS"
-msgstr ""
+msgstr "'%s' в %L перебивает связывание с PASS и должен также быть PASS"
  
  #: fortran/interface.c:4371
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Passed-object dummy argument of '%s' at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
  msgid "Passed-object dummy argument of %qs at %L must be at the same position as the passed-object dummy argument of the overridden procedure"
-msgstr ""
+msgstr "Passed-object фиктивный аргумент от '%s' в %L должен быть на той же позиции что и passed-object формальный аргумент перебиваемой процедуры"
  
  #: fortran/intrinsic.c:196
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NULL pointer at %L is not permitted as actual argument of '%s' intrinsic function"
  msgid "Variable with NO_ARG_CHECK attribute at %L is only permitted as argument to the intrinsic functions C_LOC and PRESENT"
-msgstr ""
+msgstr "NULL указатель в %L не разрешен в качестве фактического аргумента '%s' встроенной функции"
  
  #: fortran/intrinsic.c:211
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NULL pointer at %L is not permitted as actual argument of '%s' intrinsic function"
  msgid "Assumed-type argument at %L is not permitted as actual argument to the intrinsic %s"
-msgstr "Функция-оператор `%A', определенная в %0, не используется"
+msgstr "NULL указатель в %L не разрешен в качестве фактического аргумента '%s' встроенной функции"
  
  #: fortran/intrinsic.c:218
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NULL pointer at %L is not permitted as actual argument of '%s' intrinsic function"
  msgid "Assumed-type argument at %L is only permitted as first actual argument to the intrinsic %s"
-msgstr "Функция-оператор `%A', определенная в %0, не используется"
+msgstr "NULL указатель в %L не разрешен в качестве фактического аргумента '%s' встроенной функции"
  
  #: fortran/intrinsic.c:225
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NULL pointer at %L is not permitted as actual argument of '%s' intrinsic function"
  msgid "Assumed-rank argument at %L is only permitted as actual argument to intrinsic inquiry functions"
-msgstr "Функция-оператор `%A', определенная в %0, не используется"
+msgstr "NULL указатель в %L не разрешен в качестве фактического аргумента '%s' встроенной функции"
  
  #: fortran/intrinsic.c:232
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NULL pointer at %L is not permitted as actual argument of '%s' intrinsic function"
  msgid "Assumed-rank argument at %L is only permitted as first actual argument to the intrinsic inquiry function %s"
-msgstr ""
+msgstr "NULL указатель в %L не разрешен в качестве фактического аргумента '%s' встроенной функции"
  
  #: fortran/intrinsic.c:280
  #, fuzzy, gcc-internal-format
+#| msgid "too many arguments"
  msgid "do_check(): too many args"
-msgstr "слишком много аргументов для форматирования"
+msgstr "слишком много аргументов"
  
  #: fortran/intrinsic.c:360
  #, gcc-internal-format
@@ -52952,9 +55354,10 @@ msgid "add_sym(): Bad sizing mode"
  msgstr ""
  
  #: fortran/intrinsic.c:1077
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The intrinsic '%s' at %L is not included in the selected standard but %s and '%s' will be treated as if declared EXTERNAL.  Use an appropriate -std=* option or define -fall-intrinsics to allow this intrinsic."
  msgid "The intrinsic %qs at %L is not included in the selected standard but %s and %qs will be treated as if declared EXTERNAL.  Use an appropriate -std=* option or define -fall-intrinsics to allow this intrinsic."
-msgstr ""
+msgstr "Встроенная '%s' в %L не включена в выбранный стандарт но %s и '%s' будут трактоваться как декларированные EXTERNAL. Используйте подходящую -std=* опцию или определите -fall-intrinsics чтобы допустить эту встроенную."
  
  #: fortran/intrinsic.c:1112
  #, gcc-internal-format
@@ -52963,38 +55366,43 @@ msgstr ""
  
  #: fortran/intrinsic.c:3871
  #, fuzzy, gcc-internal-format
+#| msgid "Too many arguments in call to '%s' at %L"
  msgid "Too many arguments in call to %qs at %L"
-msgstr "слишком много аргументов для %s `%+#D'"
+msgstr "Слишком много аргументов в вызове '%s' в %L"
  
  #: fortran/intrinsic.c:3886
  #, gcc-internal-format, gfc-internal-format
  msgid "The argument list functions %%VAL, %%LOC or %%REF are not allowed in this context at %L"
-msgstr ""
+msgstr "Функции списка аргументов %%VAL, %%LOC или %%REF не допускаются в этом контексте в %L"
  
  #: fortran/intrinsic.c:3889
  #, fuzzy, gcc-internal-format
+#| msgid "Can't find keyword named '%s' in call to '%s' at %L"
  msgid "Can't find keyword named %qs in call to %qs at %L"
-msgstr "слишком много аргументов для %s `%+#D'"
+msgstr "Не удалось найти ключевое слово '%s' в вызове '%s' в %L"
  
  #: fortran/intrinsic.c:3896
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' appears twice in call to '%s' at %L"
  msgid "Argument %qs appears twice in call to %qs at %L"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð¿Ð¾Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ð´Ð²Ð°Ð¶Ð´Ñ\8b Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ '%s' Ð² %L"
  
  #: fortran/intrinsic.c:3910
  #, fuzzy, gcc-internal-format
+#| msgid "Missing actual argument '%s' in call to '%s' at %L"
  msgid "Missing actual argument %qs in call to %qs at %L"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ '%s' Ð² %L"
  
  #: fortran/intrinsic.c:3925
  #, gcc-internal-format, gfc-internal-format
  msgid "ALTERNATE RETURN not permitted at %L"
-msgstr ""
+msgstr "ALTERNATE RETURN не разрешается в %L"
  
  #: fortran/intrinsic.c:3982
  #, fuzzy, gcc-internal-format
+#| msgid "Type of argument '%s' in call to '%s' at %L should be %s, not %s"
  msgid "Type of argument %qs in call to %qs at %L should be %s, not %s"
-msgstr "слишком много аргументов для %s `%+#D'"
+msgstr "Тип аргумента '%s' в вызове '%s' в %L должен быть %s, а не %s"
  
  #: fortran/intrinsic.c:4088
  #, gcc-internal-format
@@ -53008,8 +55416,9 @@ msgstr ""
  
  #: fortran/intrinsic.c:4213
  #, fuzzy, gcc-internal-format
+#| msgid "too many arguments"
  msgid "init_arglist(): too many arguments"
-msgstr "слишком много аргументов для форматирования"
+msgstr "слишком много аргументов"
  
  #: fortran/intrinsic.c:4363
  #, gcc-internal-format
@@ -53018,43 +55427,48 @@ msgstr ""
  
  #: fortran/intrinsic.c:4372
  #, fuzzy, gcc-internal-format
+#| msgid "Intrinsic '%s' (is %s) is used at %L"
  msgid "Intrinsic %qs (is %s) is used at %L"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð² %s"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f '%s' (ÐµÑ\81Ñ\82Ñ\8c %s) Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð° Ð² %L"
  
  #: fortran/intrinsic.c:4443
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: Function '%s' as initialization expression at %L"
  msgid "Function %qs as initialization expression at %L"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Fortran 2003: Функция '%s' как инициализационное выражение в %L"
  
  #: fortran/intrinsic.c:4519
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: Elemental function as initialization expression with non-integer/non-character arguments at %L"
  msgid "Elemental function as initialization expression with non-integer/non-character arguments at %L"
-msgstr ""
+msgstr "Fortran 2003: Элементная функция как инициализационное выражение с non-integer/non-character аргументами в %L"
  
  #: fortran/intrinsic.c:4590
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Subroutine call to '%s' in DO CONCURRENT block at %L is not PURE"
  msgid "Subroutine call to intrinsic %qs in DO CONCURRENT block at %L is not PURE"
-msgstr ""
+msgstr "Вызов подпрограммы '%s' в DO CONCURRENT блоке в %L не есть PURE"
  
  #: fortran/intrinsic.c:4597
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Subroutine call to intrinsic '%s' at %L is not PURE"
  msgid "Subroutine call to intrinsic %qs at %L is not PURE"
-msgstr ""
+msgstr "Подпрограммный вызов встроенной '%s' в %L не есть PURE"
  
  #: fortran/intrinsic.c:4673
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Extension: Conversion from %s to %s at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: Ð\9fÑ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %s Ð² %s Ð² %L"
  
  #: fortran/intrinsic.c:4709 fortran/intrinsic.c:4726
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Possible change of value in conversion from %s to %s at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT"
+msgstr "Ð\92Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ðµ Ð¸Ð·Ð¼ÐµÐ½ÐµÐ½Ð¸Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ð² Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ð¸Ð· %s Ð² %s Ð² %L"
  
  #: fortran/intrinsic.c:4714 fortran/intrinsic.c:4735
  #, gcc-internal-format, gfc-internal-format
  msgid "Conversion from %s to %s at %L"
-msgstr "Ð¿реобразование из %s в %s в %L"
+msgstr "Ð\9fреобразование из %s в %s в %L"
  
  #: fortran/intrinsic.c:4788
  #, gcc-internal-format, gfc-internal-format
@@ -53068,109 +55482,118 @@ msgid "Can't convert %qs to %qs at %L"
  msgstr "Не удалось преобразовать %s в %s в %L"
  
  #: fortran/intrinsic.c:4883
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' declared at %L may shadow the intrinsic of the same name.  In order to call the intrinsic, explicit INTRINSIC declarations may be required."
  msgid "%qs declared at %L may shadow the intrinsic of the same name.  In order to call the intrinsic, explicit INTRINSIC declarations may be required."
-msgstr ""
+msgstr "'%s' декларированная в %L может затенять встроенную с тем же именем. Чтобы вызвать встроенную, явная INTRINSIC декларация может потребоваться."
  
  #: fortran/intrinsic.c:4889
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' declared at %L is also the name of an intrinsic.  It can only be called via an explicit interface or if declared EXTERNAL."
  msgid "%qs declared at %L is also the name of an intrinsic.  It can only be called via an explicit interface or if declared EXTERNAL."
-msgstr ""
+msgstr "'%s' декларированная в %L есть также имя встроенной. Она может быть вызвана только посредством явного интерфейса или будучи декларированной EXTERNAL."
  
  #: fortran/io.c:167 fortran/primary.c:920
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Extension: backslash character at %C"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: backslash Ñ\81Ð¸Ð¼Ð²Ð¾Ð» Ð² %C"
  
  #: fortran/io.c:203 fortran/io.c:206
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Extension: Tab character in format at %C"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: Tab Ñ\81Ð¸Ð¼Ð²Ð¾Ð» Ð² Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ðµ Ð² %C"
  
  #: fortran/io.c:454
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: DP format specifier not allowed at %C"
  msgid "DP format specifier not allowed at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: DP спецификатор формата не допускается в %C"
  
  #: fortran/io.c:461
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: DC format specifier not allowed at %C"
  msgid "DC format specifier not allowed at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: DC спецификатор формата не допускается в %C"
  
  #: fortran/io.c:650
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: X descriptor requires leading space count at %L"
  msgid "X descriptor requires leading space count at %L"
-msgstr ""
+msgstr "Расширение: X дескриптор требует предшествующий счетчик пробелов в %L"
  
  #: fortran/io.c:679
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: $ descriptor at %L"
  msgid "$ descriptor at %L"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: $ Ð´ÐµÑ\81ÐºÑ\80Ð¸Ð¿Ñ\82Ð¾Ñ\80 Ð² %L"
  
  #: fortran/io.c:683
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "$ should be the last specifier in format at %L"
-msgstr "\"void\" должен быть единственным \"параметром\""
+msgstr "$ должен быть последним спецификатором в формате в %L"
  
  #: fortran/io.c:781
  #, gcc-internal-format, gfc-internal-format
  msgid "Extension: Missing positive width after L descriptor at %L"
-msgstr ""
+msgstr "Расширение: Отсутствует положительная ширина после L дескриптора в %L"
  
  #: fortran/io.c:825
  #, fuzzy, gcc-internal-format
+#| msgid "%s in format string at %L"
  msgid "%<G0%> in format at %L"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "%s в форматной строке в %L"
  
  #: fortran/io.c:853
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Positive width required in format specifier %s at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
+msgstr "Ð\9fÐ¾Ð»Ð¾Ð¶Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð°Ñ\8f Ñ\88Ð¸Ñ\80Ð¸Ð½Ð° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð² Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ðµ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° %s Ð² %L"
  
  #: fortran/io.c:869 fortran/io.c:876
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Period required in format specifier %s at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
+msgstr "Ð¢Ð¾Ñ\87ÐºÐ° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð² Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ðµ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° %s Ð² %L"
  
  #: fortran/io.c:948
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Period required in format specifier at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
+msgstr "Ð¢Ð¾Ñ\87ÐºÐ° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð² Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ðµ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° Ð² %L"
  
  #: fortran/io.c:970
  #, gcc-internal-format, gfc-internal-format
  msgid "The H format specifier at %L is a Fortran 95 deleted feature"
-msgstr ""
+msgstr "H спецификатор формата в %L есть удаленная возможность Fortran 95"
  
  #: fortran/io.c:1058 fortran/io.c:1120
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: Missing comma at %L"
  msgid "Missing comma at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² %L"
  
  #: fortran/io.c:1138
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s in format string at %L"
-msgstr "формат %s, аргумент %s (аргумент %d)"
+msgstr "%s в форматной строке в %L"
  
  #: fortran/io.c:1176
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Extraneous characters in format at %L"
-msgstr "Лишняя запятая в операторе FORMAT в %0"
+msgstr "Лишние символы в формате в %L"
  
  #: fortran/io.c:1198
  #, gcc-internal-format, gfc-internal-format
  msgid "Format statement in module main block at %C"
-msgstr ""
+msgstr "Оператор формата в главном блоке модуля в %C"
  
  #: fortran/io.c:1207
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
  msgid "FORMAT statement at %C cannot appear within an INTERFACE"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "ENTRY оператор в %C не может появляться внутри INTERFACE"
  
  #: fortran/io.c:1213
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Missing format label at %C"
-msgstr "Отсутствует формальный параметр"
+msgstr "Отсутствует метка формата в %C"
  
  #: fortran/io.c:1261
  #, gcc-internal-format, gfc-internal-format
@@ -53183,304 +55606,328 @@ msgid "%s requires a scalar-default-char-expr at %L"
  msgstr ""
  
  #: fortran/io.c:1298 fortran/io.c:1329 fortran/io.c:1395
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid value for %s specification at %C"
-msgstr "Ð¿Ð¾Ñ\81Ð»Ðµ Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð² `%#D'"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð´Ð»Ñ\8f %s Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð² %C"
  
  #: fortran/io.c:1304 fortran/io.c:1335
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate %s specification at %C"
-msgstr "Ð¿Ð¾Ñ\81Ð»Ðµ Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð² `%#D'"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f %s Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð² %C"
  
  #: fortran/io.c:1342
  #, gcc-internal-format, gfc-internal-format
  msgid "Variable %s cannot be INTENT(IN) at %C"
-msgstr ""
+msgstr "Переменная %s не может быть INTENT(IN) в %C"
  
  #: fortran/io.c:1350
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Variable %s cannot be assigned in PURE procedure at %C"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 SAVE Ð¸Ð»Ð¸ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ð² %1 Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð¼ SAVE Ð¸Ð»Ð¸ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð¼ Ð² %0"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %s Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ñ\80Ð¸Ñ\81Ð²Ð¾ÐµÐ½Ð° Ð² PURE Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ðµ Ð² %C"
  
  #: fortran/io.c:1401
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate %s label specification at %C"
-msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð¼ÐµÑ\82ÐºÐ¸ %qs"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f %s Ð¼ÐµÑ\82ÐºÐ¸ Ð² %C"
  
  #: fortran/io.c:1421
  #, gcc-internal-format, gfc-internal-format
  msgid "Constant expression in FORMAT tag at %L must be of type default CHARACTER"
-msgstr ""
+msgstr "Константное выражение в FORMAT теге в %L должно быть типа default CHARACTER"
  
  #: fortran/io.c:1439
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "FORMAT tag at %L must be of type default-kind CHARACTER or of INTEGER"
-msgstr "%qD не является элементом типа %qT"
+msgstr "FORMAT тег в %L должен быть типа default-kind CHARACTER или INTEGER"
  
  #: fortran/io.c:1445
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Deleted feature: ASSIGNED variable in FORMAT tag at %L"
  msgid "ASSIGNED variable in FORMAT tag at %L"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð£Ð´Ð°Ð»ÐµÐ½Ð½Ð°Ñ\8f Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ñ\8c: ASSIGNED Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ð² FORMAT Ñ\82ÐµÐ³Ðµ Ð² %L"
  
  #: fortran/io.c:1450
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L has not been assigned a format label"
  msgid "Variable %qs at %L has not been assigned a format label"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 SAVE Ð¸Ð»Ð¸ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ð² %1 Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð¼ SAVE Ð¸Ð»Ð¸ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð¼ Ð² %0"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ '%s' Ð² %L Ð½Ðµ Ð±Ñ\8bÐ»Ð° Ð¿Ñ\80Ð¸Ñ\81Ð²Ð¾ÐµÐ½Ð° Ð¼ÐµÑ\82ÐºÐ° Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
  
  #: fortran/io.c:1457
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Scalar '%s' in FORMAT tag at %L is not an ASSIGNED variable"
  msgid "Scalar %qs in FORMAT tag at %L is not an ASSIGNED variable"
-msgstr ""
+msgstr "Скаляр '%s' в FORMAT теге в %L не есть ASSIGNED переменная"
  
  #: fortran/io.c:1469
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: Non-character in FORMAT tag at %L"
  msgid "Non-character in FORMAT tag at %L"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: Non-character Ð² FORMAT Ñ\82ÐµÐ³Ðµ Ð² %L"
  
  #: fortran/io.c:1475
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Non-character assumed shape array element in FORMAT tag at %L"
-msgstr "Лишняя запятая в операторе FORMAT в %0"
+msgstr "Non-character элемент массива предполагаемой формы в FORMAT теге в %L"
  
  #: fortran/io.c:1482
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Non-character assumed size array element in FORMAT tag at %L"
-msgstr "Лишняя запятая в операторе FORMAT в %0"
+msgstr "Non-character элемент массива предполагаемого размера в FORMAT теге в %L"
  
  #: fortran/io.c:1489
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Non-character pointer array element in FORMAT tag at %L"
-msgstr "Лишняя запятая в операторе FORMAT в %0"
+msgstr "Non-character элемент указательного массива в FORMAT теге в %L"
  
  #: fortran/io.c:1515
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s tag at %L must be of type %s"
-msgstr "%qD не является элементом типа %qT"
+msgstr "%s тег в %L должен быть типа %s"
  
  #: fortran/io.c:1522
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s tag at %L must be a character string of default kind"
-msgstr "%qD не является элементом типа %qT"
+msgstr "%s тег в %L должен быть строкой символов подразумеваемого вида"
  
  #: fortran/io.c:1529
  #, gcc-internal-format, gfc-internal-format
  msgid "%s tag at %L must be scalar"
-msgstr ""
+msgstr "%s тег в %L должен быть скаляром"
  
  #: fortran/io.c:1535
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: IOMSG tag at %L"
  msgid "IOMSG tag at %L"
-msgstr ""
+msgstr "Fortran 2003: IOMSG тег в %L"
  
  #: fortran/io.c:1543
  #, gcc-internal-format, gfc-internal-format
  msgid "Fortran 95 requires default INTEGER in %s tag at %L"
-msgstr ""
+msgstr "Fortran 95 требует подразумеваемый INTEGER в %s теге в %L"
  
  #: fortran/io.c:1552
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: Nondefault LOGICAL in %s tag at %L"
  msgid "Non-default LOGICAL kind in %s tag at %L"
-msgstr "Недопустимое число в операторе FORMAT в %0"
+msgstr "Fortran 2008: Неподразумеваемый LOGICAL в %s теге в %L"
  
  #: fortran/io.c:1559
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "UNIT not specified at %L"
  msgid "NEWUNIT specifier at %L"
-msgstr "дважды задан ключ -I-"
+msgstr "UNIT не специфицировано в %L"
  
  #: fortran/io.c:1577
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: CONVERT tag at %L"
  msgid "CONVERT tag at %L"
-msgstr ""
+msgstr "Расширение: CONVERT тег в %L"
  
  #: fortran/io.c:1766
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: %s specifier in %s statement at %C has value '%s'"
  msgid "Fortran 2003: %s specifier in %s statement at %C has value %qs"
-msgstr "оператор break вне цикла или оператора switch"
+msgstr "Fortran 2003: %s спецификатор в %s операторе в %C имеет значение '%s'"
  
  #: fortran/io.c:1774 fortran/io.c:1801
  #, fuzzy, gcc-internal-format
+#| msgid "%s specifier in %s statement at %C has invalid value '%s'"
  msgid "%s specifier in %s statement at %C has value %qs"
-msgstr "оператор break вне цикла или оператора switch"
+msgstr "%s спецификатор в %s операторе в %C имеет некорректное значение '%s'"
  
  #: fortran/io.c:1793
  #, fuzzy, gcc-internal-format
+#| msgid "Extension: %s specifier in %s statement at %C has value '%s'"
  msgid "Extension: %s specifier in %s statement at %C has value %qs"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 break Ð²Ð½Ðµ Ñ\86Ð¸ÐºÐ»Ð° Ð¸Ð»Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° switch"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: %s Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð² %s Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C Ð¸Ð¼ÐµÐµÑ\82 Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ '%s'"
  
  #: fortran/io.c:1815 fortran/io.c:1823
  #, fuzzy, gcc-internal-format
+#| msgid "%s specifier in %s statement at %C has invalid value '%s'"
  msgid "%s specifier in %s statement at %C has invalid value %qs"
-msgstr "оператор break вне цикла или оператора switch"
+msgstr "%s спецификатор в %s операторе в %C имеет некорректное значение '%s'"
  
  #: fortran/io.c:1876
  #, gcc-internal-format, gfc-internal-format
  msgid "OPEN statement not allowed in PURE procedure at %C"
-msgstr ""
+msgstr "OPEN оператор не допускается в PURE процедуре в %C"
  
  #: fortran/io.c:1889
  #, gcc-internal-format, gfc-internal-format
  msgid "UNIT specifier not allowed with NEWUNIT at %C"
-msgstr ""
+msgstr "UNIT спецификатор не допускается с NEWUNIT в %C"
  
  #: fortran/io.c:1899
  #, gcc-internal-format, gfc-internal-format
  msgid "NEWUNIT specifier must have FILE= or STATUS='scratch' at %C"
-msgstr ""
+msgstr "NEWUNIT спецификатор должен иметь FILE= или STATUS='scratch' в %C"
  
  #: fortran/io.c:1907
  #, gcc-internal-format, gfc-internal-format
  msgid "OPEN statement at %C must have UNIT or NEWUNIT specified"
-msgstr ""
+msgstr "OPEN оператор в %C должен иметь UNIT или NEWUNIT специфицированными"
  
  #: fortran/io.c:1945
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ASYNCHRONOUS= at %C not allowed in Fortran 95"
  msgid "ASYNCHRONOUS= at %C not allowed in Fortran 95"
-msgstr ""
+msgstr "Fortran 2003: ASYNCHRONOUS= в %C не допускается в Fortran 95"
  
  #: fortran/io.c:1966 fortran/io.c:3461
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: BLANK= at %C not allowed in Fortran 95"
  msgid "BLANK= at %C not allowed in Fortran 95"
-msgstr ""
+msgstr "Fortran 2003: BLANK= в %C не допускается в Fortran 95"
  
  #: fortran/io.c:1987 fortran/io.c:3437
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: DECIMAL= at %C not allowed in Fortran 95"
  msgid "DECIMAL= at %C not allowed in Fortran 95"
-msgstr ""
+msgstr "Fortran 2003: DECIMAL= в %C не допускается в Fortran 95"
  
  #: fortran/io.c:2025
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ENCODING= at %C not allowed in Fortran 95"
  msgid "ENCODING= at %C not allowed in Fortran 95"
-msgstr ""
+msgstr "Fortran 2003: ENCODING= в %C не допускается в Fortran 95"
  
  #: fortran/io.c:2088 fortran/io.c:3510
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ROUND= at %C not allowed in Fortran 95"
  msgid "ROUND= at %C not allowed in Fortran 95"
-msgstr ""
+msgstr "Fortran 2003: ROUND= в %C не допускается в Fortran 95"
  
  #: fortran/io.c:2111
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: SIGN= at %C not allowed in Fortran 95"
  msgid "SIGN= at %C not allowed in Fortran 95"
-msgstr ""
+msgstr "Fortran 2003: SIGN= в %C не допускается в Fortran 95"
  
  #: fortran/io.c:2332
  #, gcc-internal-format, gfc-internal-format
  msgid "CLOSE statement not allowed in PURE procedure at %C"
-msgstr ""
+msgstr "CLOSE оператор не допускается в PURE процедуре в %C"
  
  #: fortran/io.c:2394
  #, gcc-internal-format, gfc-internal-format
  msgid "CLOSE statement at %L requires a UNIT number"
-msgstr ""
+msgstr "CLOSE оператор в %L требует UNIT номер"
  
  #: fortran/io.c:2402
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "UNIT number in CLOSE statement at %L must be non-negative"
-msgstr "оператор-выражение имеет неполный тип"
+msgstr "UNIT номер в CLOSE операторе в %L должен быть неотрицательным"
  
  #: fortran/io.c:2500 fortran/match.c:2639
  #, gcc-internal-format, gfc-internal-format
  msgid "%s statement not allowed in PURE procedure at %C"
-msgstr ""
+msgstr "%s оператор не допускается в PURE процедуре в %C"
  
  #: fortran/io.c:2534
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "UNIT number in statement at %L must be non-negative"
  msgid "UNIT number missing in statement at %L"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "UNIT номер в операторе в %L должен быть неотрицательным"
  
  #: fortran/io.c:2542 fortran/io.c:2979
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "UNIT number in statement at %L must be non-negative"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "UNIT номер в операторе в %L должен быть неотрицательным"
  
  #: fortran/io.c:2575
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: FLUSH statement at %C"
  msgid "FLUSH statement at %C"
-msgstr "ожидалось имя типа"
+msgstr "Fortran 2003: FLUSH оператор в %C"
  
  #: fortran/io.c:2630
  #, gcc-internal-format, gfc-internal-format
  msgid "Duplicate UNIT specification at %C"
-msgstr ""
+msgstr "Повторная UNIT спецификация в %C"
  
  #: fortran/io.c:2704
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate format specification at %C"
-msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %D"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð° Ð² %C"
  
  #: fortran/io.c:2721
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' in namelist '%s' is INTENT(IN) at %C"
  msgid "Symbol %qs in namelist %qs is INTENT(IN) at %C"
-msgstr ""
+msgstr "Символ '%s' в списке имен '%s' является INTENT(IN) в %C"
  
  #: fortran/io.c:2757
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate NML specification at %C"
-msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %D"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð°Ñ\8f NML Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð² %C"
  
  #: fortran/io.c:2766
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %C must be a NAMELIST group name"
  msgid "Symbol %qs at %C must be a NAMELIST group name"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Символ '%s' в %C должен быть именем NAMELIST группы"
  
  #: fortran/io.c:2836
  #, gcc-internal-format, gfc-internal-format
  msgid "END tag at %C not allowed in output statement"
-msgstr ""
+msgstr "END тег в %C не допускается в операторе вывода"
  
  #: fortran/io.c:2913
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "UNIT not specified at %L"
-msgstr "дважды задан ключ -I-"
+msgstr "UNIT не специфицировано в %L"
  
  #: fortran/io.c:2925
  #, gcc-internal-format, gfc-internal-format
  msgid "UNIT specification at %L must be an INTEGER expression or a CHARACTER variable"
-msgstr ""
+msgstr "UNIT спецификация в %L должна быть INTEGER выражением или CHARACTER переменной"
  
  #: fortran/io.c:2947
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid form of WRITE statement at %L, UNIT required"
-msgstr "Ð\9fÑ\80Ð¾Ð¿Ñ\83Ñ\89ÐµÐ½Ð° Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\84Ð¾Ñ\80Ð¼Ð° WRITE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %L, UNIT Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
  
  #: fortran/io.c:2958
  #, gcc-internal-format, gfc-internal-format
  msgid "Internal unit with vector subscript at %L"
-msgstr ""
+msgstr "Внутренняя единица с векторным индексом в %L"
  
  #: fortran/io.c:2972
  #, gcc-internal-format, gfc-internal-format
  msgid "External IO UNIT cannot be an array at %L"
-msgstr ""
+msgstr "Внешняя IO UNIT не может быть массивом в %L"
  
  #: fortran/io.c:3000
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "NAMELIST '%s' in READ statement at %L contains the symbol '%s' which may not appear in a variable definition context"
  msgid "NAMELIST %qs in READ statement at %L contains the symbol %qs which may not appear in a variable definition context"
-msgstr ""
+msgstr "NAMELIST '%s' в READ операторе в %L содержит символ '%s' который не может появляться в контексте определения переменной"
  
  #: fortran/io.c:3010
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: Comma before i/o item list at %L"
  msgid "Comma before i/o item list at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: Ð\97Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ´ i/o Ñ\81Ð¿Ð¸Ñ\81ÐºÐ¾Ð¼ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð² Ð² %L"
  
  #: fortran/io.c:3020
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "ERR tag label %d at %L not defined"
-msgstr "метка %qD используется, но не определяется"
+msgstr "ERR тег метка %d в %L не определена"
  
  #: fortran/io.c:3032
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "END tag label %d at %L not defined"
-msgstr "метка %qD используется, но не определяется"
+msgstr "END тег метка %d в %L не определена"
  
  #: fortran/io.c:3044
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "EOR tag label %d at %L not defined"
-msgstr "метка %qD используется, но не определяется"
+msgstr "ERR тег метка %d в %L не определена"
  
  #: fortran/io.c:3054
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "FORMAT label %d at %L not defined"
-msgstr "метка %qD используется, но не определяется"
+msgstr "FORMAT метка %d в %L не определена"
  
  #: fortran/io.c:3085
  #, gcc-internal-format
@@ -53488,841 +55935,910 @@ msgid "io_kind_name(): bad I/O-kind"
  msgstr ""
  
  #: fortran/io.c:3174
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in I/O iterator at %C"
-msgstr "синтаксическая ошибка в списке параметров макроса"
+msgstr "Синтаксическая ошибка в I/O итераторе в %C"
  
  #: fortran/io.c:3205
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected variable in READ statement at %C"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ð² READ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/io.c:3211
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected expression in %s statement at %C"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85, Ð²Ñ\81Ñ\82Ñ\80ÐµÑ\82Ð¸Ð²Ñ\88Ð¸Ñ\85Ñ\81Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð²"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² %s Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #. A general purpose syntax error.
  #: fortran/io.c:3268 fortran/io.c:3886 fortran/gfortran.h:2718
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in %s statement at %C"
-msgstr "Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80Ð¸ Ñ\80Ð°Ð·Ð±Ð¾Ñ\80Ðµ `%s'"
+msgstr "Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² %s Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/io.c:3352
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: Internal file at %L with namelist"
  msgid "Internal file at %L with namelist"
-msgstr ""
+msgstr "Fortran 2003: Внутренний файл в %L со списком имен"
  
  #: fortran/io.c:3408
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "ASYNCHRONOUS= specifier at %L must be an initialization expression"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "ASYNCHRONOUS= спецификатор в %L должен быть инициализационным выражением"
  
  #: fortran/io.c:3486
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: PAD= at %C not allowed in Fortran 95"
  msgid "PAD= at %C not allowed in Fortran 95"
-msgstr "пространство имён %qD не допускается в using-декларации"
+msgstr "Fortran 2003: PAD= в %C не допускается в Fortran 95"
  
  #: fortran/io.c:3562
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: DELIM= at %C not allowed in Fortran 95"
  msgid "DELIM= at %C not allowed in Fortran 95"
-msgstr ""
+msgstr "Fortran 2003: DELIM= в %C не допускается в Fortran 95"
  
  #: fortran/io.c:3714
  #, gcc-internal-format, gfc-internal-format
  msgid "PRINT namelist at %C is an extension"
-msgstr ""
+msgstr "PRINT список имен в %C является расширением"
  
  #: fortran/io.c:3857
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected comma in I/O list at %C"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² I/O Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð² %C"
  
  #: fortran/io.c:3920
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "PRINT statement at %C not allowed within PURE procedure"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "PRINT оператор в %C не допускается внутри PURE процедуры"
  
  #: fortran/io.c:4083 fortran/io.c:4143
  #, gcc-internal-format, gfc-internal-format
  msgid "INQUIRE statement not allowed in PURE procedure at %C"
-msgstr ""
+msgstr "INQUIRE оператор не допускается в PURE процедуре в %C"
  
  #: fortran/io.c:4111
  #, gcc-internal-format, gfc-internal-format
  msgid "IOLENGTH tag invalid in INQUIRE statement at %C"
-msgstr ""
+msgstr "IOLENGTH тег некорректен в INQUIRE операторе в %C"
  
  #: fortran/io.c:4121 fortran/trans-io.c:1303
  #, gcc-internal-format, gfc-internal-format
  msgid "INQUIRE statement at %L cannot contain both FILE and UNIT specifiers"
-msgstr ""
+msgstr "INQUIRE оператор в %L не может содержать оба спецификатора FILE и UNIT"
  
  #: fortran/io.c:4128
  #, gcc-internal-format, gfc-internal-format
  msgid "INQUIRE statement at %L requires either FILE or UNIT specifier"
-msgstr ""
+msgstr "INQUIRE оператор в %L требует либо FILE либо UNIT спецификатор"
  
  #: fortran/io.c:4137
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "UNIT number in statement at %L must be non-negative"
  msgid "UNIT number in INQUIRE statement at %L can not be -1"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "UNIT номер в операторе в %L должен быть неотрицательным"
  
  #: fortran/io.c:4151
  #, gcc-internal-format, gfc-internal-format
  msgid "INQUIRE statement at %L requires a PENDING= specifier with the ID= specifier"
-msgstr ""
+msgstr "INQUIRE оператор в %L требует PENDING= спецификатор с ID= спецификатором"
  
  #: fortran/io.c:4327
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: WAIT at %C not allowed in Fortran 95"
  msgid "WAIT at %C not allowed in Fortran 95"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "Fortran 2003: WAIT в %C не допускается в Fortran 95"
  
  #: fortran/io.c:4333
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "WAIT statement not allowed in PURE procedure at %C"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "WAIT оператор не допускается в PURE процедуре в %C"
  
  #: fortran/match.c:109
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "gfc_op2string(): Bad code"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: fortran/match.c:166
  #, fuzzy, gcc-internal-format
+#| msgid "Missing ')' in statement at or before %L"
  msgid "Missing %<)%> in statement at or before %L"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´ `*' Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 ')' Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² Ð¸Ð»Ð¸ Ð´Ð¾ %L"
  
  #: fortran/match.c:171
  #, fuzzy, gcc-internal-format
+#| msgid "Missing '(' in statement at or before %L"
  msgid "Missing %<(%> in statement at or before %L"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´ `*' Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 '(' Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² Ð¸Ð»Ð¸ Ð´Ð¾ %L"
  
  #: fortran/match.c:368
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Integer too large at %C"
-msgstr "Целое в %0 слишком велико"
+msgstr "Целое слишком велико в %C"
  
  #: fortran/match.c:461 fortran/parse.c:973
  #, gcc-internal-format, gfc-internal-format
  msgid "Too many digits in statement label at %C"
-msgstr ""
+msgstr "Слишком много цифр в метке оператора в %C"
  
  #: fortran/match.c:467
  #, gcc-internal-format, gfc-internal-format
  msgid "Statement label at %C is zero"
-msgstr ""
+msgstr "Метка оператора в %C нулевая"
  
  #: fortran/match.c:500
  #, fuzzy, gcc-internal-format
+#| msgid "Label name '%s' at %C is ambiguous"
  msgid "Label name %qs at %C is ambiguous"
-msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ `%D' неоднозначно"
+msgstr "Ð\98Ð¼Ñ\8f Ð¼ÐµÑ\82ÐºÐ¸ '%s' Ð² %C неоднозначно"
  
  #: fortran/match.c:506
  #, fuzzy, gcc-internal-format
+#| msgid "Duplicate construct label '%s' at %C"
  msgid "Duplicate construct label %qs at %C"
-msgstr "Ð´Ñ\83Ð±Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¼ÐµÑ\82ÐºÐ¸ `%D'"
+msgstr "Ð\94Ñ\83Ð±Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¼ÐµÑ\82ÐºÐ¸ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸ '%s' at %C"
  
  #: fortran/match.c:540
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid character in name at %C"
-msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð»Ñ\8cÐ½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð¹ Ð´Ð»Ð¸Ð½Ñ\8b Ð² %0"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð¼Ð²Ð¾Ð» Ð² Ð¸Ð¼ÐµÐ½Ð¸ Ð² %C"
  
  #: fortran/match.c:553
  #, gcc-internal-format, gfc-internal-format
  msgid "Name at %C is too long"
-msgstr ""
+msgstr "Имя в %C слишком длинное"
  
  #: fortran/match.c:564
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Invalid character '$' at %C. Use -fdollar-ok to allow it as an extension"
  msgid "Invalid character %<$%> at %L. Use %<-fdollar-ok%> to allow it as an extension"
-msgstr ""
+msgstr "Некорректный символ '$' в %C. Используйте -fdollar-ok чтобы допустить его как расширение"
  
  #: fortran/match.c:882
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Loop variable at %C cannot be a coarray"
  msgid "Loop variable at %C cannot be an array"
-msgstr "Ð½Ðµ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ %qs Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ñ\81Ð¾Ð´ÐµÑ\80Ð¶Ð°Ñ\82Ñ\8c Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ñ\8b"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ñ\86Ð¸ÐºÐ»Ð° Ð² %C Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾Ð¼"
  
  #: fortran/match.c:889
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Loop variable at %C cannot be a coarray"
-msgstr "Ð½Ðµ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ %qs Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ñ\81Ð¾Ð´ÐµÑ\80Ð¶Ð°Ñ\82Ñ\8c Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ñ\8b"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ñ\86Ð¸ÐºÐ»Ð° Ð² %C Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾Ð¼"
  
  #: fortran/match.c:895
  #, gcc-internal-format, gfc-internal-format
  msgid "Loop variable at %C cannot be a sub-component"
-msgstr ""
+msgstr "Переменная цикла в %C не может быть подкомпонентом"
  
  #: fortran/match.c:929
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected a step value in iterator at %C"
-msgstr ""
+msgstr "Ожидалось значение шага в итераторе в %C"
  
  #: fortran/match.c:941
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in iterator at %C"
-msgstr "синтаксическая ошибка в списке параметров макроса"
+msgstr "Синтаксическая ошибка в итераторе в %C"
  
  #: fortran/match.c:1109
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "gfc_match(): Bad match code %c"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: fortran/match.c:1182
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid form of PROGRAM statement at %C"
-msgstr "Ð\9fÑ\80Ð¾Ð¿Ñ\83Ñ\89ÐµÐ½Ð° Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\84Ð¾Ñ\80Ð¼Ð° PROGRAM Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/match.c:1312 fortran/match.c:1392
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Obsolescent feature: Arithmetic IF statement at %C"
  msgid "Arithmetic IF statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð°Ñ\8f Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ñ\8c: Ð\90Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ IF Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/match.c:1367
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in IF-expression at %C"
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² IF-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ð² %C"
  
  #: fortran/match.c:1378
  #, gcc-internal-format, gfc-internal-format
  msgid "Block label not appropriate for arithmetic IF statement at %C"
-msgstr ""
+msgstr "Метка блока не годится для арифметического IF оператора в %C"
  
  #: fortran/match.c:1415
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Block label is not appropriate for IF statement at %C"
-msgstr "Ð\9dÐµÑ\82 Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð¼ÐµÑ\82ÐºÐ¸ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° FORMAT Ð² %0"
+msgstr "Ð\9cÐµÑ\82ÐºÐ° Ð±Ð»Ð¾ÐºÐ° Ð½Ðµ Ð³Ð¾Ð´Ð¸Ñ\82Ñ\81Ñ\8f Ð´Ð»Ñ\8f IF Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/match.c:1503
  #, gcc-internal-format, gfc-internal-format
  msgid "Cannot assign to a named constant at %C"
-msgstr ""
+msgstr "Невозможно присвоить именованной константе в %C"
  
  #: fortran/match.c:1513
  #, gcc-internal-format, gfc-internal-format
  msgid "Unclassifiable statement in IF-clause at %C"
-msgstr ""
+msgstr "Неклассифицируемый оператор в IF-клаузуле в %C"
  
  #: fortran/match.c:1520
  #, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in IF-clause at %C"
-msgstr ""
+msgstr "Синтаксическая ошибка в IF-клаузуле в %C"
  
  #: fortran/match.c:1563
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after ELSE statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ ELSE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/match.c:1569 fortran/match.c:1604
  #, fuzzy, gcc-internal-format
+#| msgid "Label '%s' at %C doesn't match IF label '%s'"
  msgid "Label %qs at %C doesn't match IF label %qs"
-msgstr "Ð¼ÐµÑ\82ÐºÐ° %qD Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð°, Ð½Ð¾ Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9cÐµÑ\82ÐºÐ° '%s' Ð² %C Ð½Ðµ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 IF Ð¼ÐµÑ\82ÐºÐµ '%s'"
  
  #: fortran/match.c:1598
  #, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after ELSE IF statement at %C"
-msgstr ""
+msgstr "Неожиданный мусор после ELSE IF оператора в %C"
  
  #: fortran/match.c:1662
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Image control statement CRITICAL at %C in PURE procedure"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ CRITICAL Ð² %C Ð² PURE Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ðµ"
  
  #: fortran/match.c:1668
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Image control statement CRITICAL at %C in DO CONCURRENT block"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ CRITICAL Ð² %C Ð² DO CONCURRENT Ð±Ð»Ð¾ÐºÐµ"
  
  #: fortran/match.c:1675
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: CRITICAL statement at %C"
  msgid "CRITICAL statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: CRITICAL оператор в %C"
  
  #: fortran/match.c:1687
  #, gcc-internal-format, gfc-internal-format
  msgid "Nested CRITICAL block at %C"
-msgstr ""
+msgstr "Вложенный CRITICAL блок в %C"
  
  #: fortran/match.c:1739
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected association list at %C"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ñ\81Ð¿Ð¸Ñ\81Ð¾Ðº Ð°Ñ\81Ñ\81Ð¾Ñ\86Ð¸Ð°Ñ\86Ð¸Ð¹ Ð² %C"
  
  #: fortran/match.c:1752
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected association at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ð°Ñ\81Ñ\81Ð¾Ñ\86Ð¸Ð°Ñ\86Ð¸Ñ\8f Ð² %C"
  
  #: fortran/match.c:1761
  #, fuzzy, gcc-internal-format
+#| msgid "Duplicate name '%s' in association at %C"
  msgid "Duplicate name %qs in association at %C"
-msgstr "Ð¿Ð¾Ñ\81Ð»Ðµ Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð² `%#D'"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80ÐµÐ½Ð¸Ðµ Ð¸Ð¼ÐµÐ½Ð¸ '%s' Ð² Ð°Ñ\81Ñ\81Ð¾Ñ\86Ð¸Ð°Ñ\86Ð¸Ð¸ Ð² %C"
  
  #: fortran/match.c:1769
  #, gcc-internal-format, gfc-internal-format
  msgid "Association target at %C must not be coindexed"
-msgstr ""
+msgstr "Цель ассоциации в %C не должна быть коиндексирована"
  
  #: fortran/match.c:1787
  #, fuzzy, gcc-internal-format
+#| msgid "Expected ')' or ',' at %C"
  msgid "Expected %<)%> or %<,%> at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c ')' Ð¸Ð»Ð¸ ',' Ð² %C"
  
  #: fortran/match.c:1805
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Junk after ASSOCIATE statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9cÑ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ ASSOCIATE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/match.c:1874
  #, fuzzy, gcc-internal-format
+#| msgid "Derived type '%s' at %L may not be ABSTRACT"
  msgid "Derived type %qs at %L may not be ABSTRACT"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Производный тип '%s' в %L не может быть ABSTRACT"
  
  #: fortran/match.c:1937
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid type-spec at %C"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ñ\82Ð¸Ð¿Ð° Ð² %C"
  
  #: fortran/match.c:2036
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in FORALL iterator at %C"
-msgstr "синтаксическая ошибка в списке параметров макроса"
+msgstr "Синтаксическая ошибка в FORALL итераторе в %C"
  
  #: fortran/match.c:2301
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: DO CONCURRENT construct at %C"
  msgid "DO CONCURRENT construct at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: DO CONCURRENT конструкция в %C"
  
  #: fortran/match.c:2426
  #, fuzzy, gcc-internal-format
+#| msgid "Name '%s' in %s statement at %C is unknown"
  msgid "Name %qs in %s statement at %C is unknown"
-msgstr "Ð\9dÐµÑ\82 Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð¼ÐµÑ\82ÐºÐ¸ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° FORMAT Ð² %0"
+msgstr "Ð\98Ð¼Ñ\8f '%s' Ð² %s Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð¾"
  
  #: fortran/match.c:2434
  #, fuzzy, gcc-internal-format
+#| msgid "Name '%s' in %s statement at %C is not a construct name"
  msgid "Name %qs in %s statement at %C is not a construct name"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 continue Ð²Ð½Ðµ Ñ\86Ð¸ÐºÐ»Ð°"
+msgstr "Ð\98Ð¼Ñ\8f '%s' Ð² %s Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ð¸Ð¼ÐµÐ½ÐµÐ¼ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
  
  #: fortran/match.c:2446
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s statement at %C leaves CRITICAL construct"
-msgstr "оператор continue вне цикла"
+msgstr "%s оператор в %C покидает CRITICAL конструкцию"
  
  #. F2008, C821 & C845.
  #: fortran/match.c:2454
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s statement at %C leaves DO CONCURRENT construct"
-msgstr "оператор continue вне цикла"
+msgstr "%s оператор в %C покидает DO CRITICAL конструкцию"
  
  #: fortran/match.c:2466
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s statement at %C is not within a construct"
-msgstr "оператор continue вне цикла"
+msgstr "%s оператор в %C не внутри конструкции"
  
  #: fortran/match.c:2469
  #, fuzzy, gcc-internal-format
+#| msgid "%s statement at %C is not within construct '%s'"
  msgid "%s statement at %C is not within construct %qs"
-msgstr "оператор break вне цикла или оператора switch"
+msgstr "%s оператор в %C не внутри конструкции '%s'"
  
  #: fortran/match.c:2494
  #, fuzzy, gcc-internal-format
+#| msgid "CYCLE statement at %C is not applicable to non-loop construct '%s'"
  msgid "CYCLE statement at %C is not applicable to non-loop construct %qs"
-msgstr "оператор break вне цикла или оператора switch"
+msgstr "CYCLE оператор в %C не применим к нециклической конструкции '%s'"
  
  #: fortran/match.c:2499
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: EXIT statement with no do-construct-name at %C"
  msgid "EXIT statement with no do-construct-name at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: EXIT оператор без do-construct-name в %C"
  
  #: fortran/match.c:2505
  #, fuzzy, gcc-internal-format
+#| msgid "%s statement at %C is not applicable to construct '%s'"
  msgid "%s statement at %C is not applicable to construct %qs"
-msgstr "оператор break вне цикла или оператора switch"
+msgstr "%s оператор в %C не применим к конструкции '%s'"
  
  #: fortran/match.c:2513
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%s statement at %C leaving OpenMP structured block"
  msgid "%s statement at %C leaving OpenACC structured block"
-msgstr "оператор continue вне цикла"
+msgstr "%s оператор в %C покидающий OpenMP структурный блок"
  
  #: fortran/match.c:2538
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "EXIT statement at %C terminating !$OMP DO loop"
  msgid "EXIT statement at %C terminating !$ACC LOOP loop"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "EXIT оператор в %C терминирующий !$OMP DO цикл"
  
  #: fortran/match.c:2543
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "CYCLE statement at %C to non-innermost collapsed !$OMP DO loop"
  msgid "CYCLE statement at %C to non-innermost collapsed !$ACC LOOP loop"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "CYCLE оператор в %C для не самого внутреннего сжатого !$OMP DO цикла"
  
  #: fortran/match.c:2568
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "EXIT statement at %C terminating !$OMP DO loop"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "EXIT оператор в %C терминирующий !$OMP DO цикл"
  
  #: fortran/match.c:2573
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "CYCLE statement at %C to non-innermost collapsed !$OMP DO loop"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "CYCLE оператор в %C для не самого внутреннего сжатого !$OMP DO цикла"
  
  #: fortran/match.c:2633
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Image control statement %s at %C in PURE procedure"
  msgid "%s statement at %C in PURE procedure"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ %s Ð² %C Ð² PURE Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ðµ"
  
  #: fortran/match.c:2649
  #, gcc-internal-format, gfc-internal-format
  msgid "Image control statement STOP at %C in CRITICAL block"
-msgstr ""
+msgstr "Оператор управления внешним видом STOP в %C в CRITICAL блоке"
  
  #: fortran/match.c:2654
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Image control statement STOP at %C in DO CONCURRENT block"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ STOP Ð² %C Ð² DO CONCURRENT Ð±Ð»Ð¾ÐºÐµ"
  
  #: fortran/match.c:2662
  #, gcc-internal-format, gfc-internal-format
  msgid "STOP code at %L must be either INTEGER or CHARACTER type"
-msgstr ""
+msgstr "STOP код в %L должен быть либо INTEGER либо CHARACTER типа"
  
  #: fortran/match.c:2669
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "STOP code at %L must be scalar"
-msgstr "Начало или конец подстроки в %0 вне диапазона, заданного в определении"
+msgstr "STOP код в %L должен быть скаляром"
  
  #: fortran/match.c:2677
  #, gcc-internal-format, gfc-internal-format
  msgid "STOP code at %L must be default character KIND=%d"
-msgstr ""
+msgstr "STOP код в %L должен быть default character KIND=%d"
  
  #: fortran/match.c:2685
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "STOP code at %L must be default integer KIND=%d"
-msgstr "предикат должен быть идентификатором"
+msgstr "STOP код в %L должен быть default integer KIND=%d"
  
  #: fortran/match.c:2731
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unexpected CASE statement at %C"
  msgid "PAUSE statement at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ CASE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/match.c:2752
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: ERROR STOP statement at %C"
  msgid "ERROR STOP statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: ERROR STOP оператор в %C"
  
  #: fortran/match.c:2778
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Image control statement %s at %C in PURE procedure"
  msgid "Image control statement EVENT %s at %C in PURE procedure"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ %s Ð² %C Ð² PURE Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ðµ"
  
  #: fortran/match.c:2793
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Image control statement %s at %C in CRITICAL block"
  msgid "Image control statement EVENT %s at %C in CRITICAL block"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ %s Ð² %C Ð² CRITICAL Ð±Ð»Ð¾ÐºÐµ"
  
  #: fortran/match.c:2800
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Image control statement %s at %C in DO CONCURRENT block"
  msgid "Image control statement EVENT %s at %C in DO CONCURRENT block"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ %s Ð² %C Ð² DO CONCURRENT Ð±Ð»Ð¾ÐºÐµ"
  
  #: fortran/match.c:2830 fortran/match.c:3025 fortran/match.c:3237
  #: fortran/match.c:3747 fortran/match.c:4084
  #, gcc-internal-format, gfc-internal-format
  msgid "Redundant STAT tag found at %L "
-msgstr ""
+msgstr "Избыточный STAT тег найден в %L "
  
  #: fortran/match.c:2851 fortran/match.c:3046 fortran/match.c:3257
  #: fortran/match.c:3773 fortran/match.c:4109
  #, gcc-internal-format, gfc-internal-format
  msgid "Redundant ERRMSG tag found at %L "
-msgstr ""
+msgstr "Избыточный ERRMSG тег найден в %L "
  
  #: fortran/match.c:2872
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Redundant STAT tag found at %L "
  msgid "Redundant UNTIL_COUNT tag found at %L "
-msgstr ""
+msgstr "Избыточный STAT тег найден в %L "
  
  #: fortran/match.c:2938
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Empty IMPLICIT statement at %C"
  msgid "EVENT POST statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ IMPLICIT Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/match.c:2948
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Empty IMPLICIT statement at %C"
  msgid "EVENT WAIT statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ IMPLICIT Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/match.c:2973
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Image control statement %s at %C in PURE procedure"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ %s Ð² %C Ð² PURE Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ðµ"
  
  #: fortran/match.c:2988
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Image control statement %s at %C in CRITICAL block"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ %s Ð² %C Ð² CRITICAL Ð±Ð»Ð¾ÐºÐµ"
  
  #: fortran/match.c:2995
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Image control statement %s at %C in DO CONCURRENT block"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ %s Ð² %C Ð² DO CONCURRENT Ð±Ð»Ð¾ÐºÐµ"
  
  #: fortran/match.c:3067
  #, gcc-internal-format, gfc-internal-format
  msgid "Redundant ACQUIRED_LOCK tag found at %L "
-msgstr ""
+msgstr "Избыточный ACQUIRED_LOCK тег найден в %L "
  
  #: fortran/match.c:3132
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: LOCK statement at %C"
  msgid "LOCK statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: LOCK оператор в %C"
  
  #: fortran/match.c:3142
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: UNLOCK statement at %C"
  msgid "UNLOCK statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: UNLOCK оператор в %C"
  
  #: fortran/match.c:3167
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Image control statement SYNC at %C in PURE procedure"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ SYNC Ð² %C Ð² PURE Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ðµ"
  
  #: fortran/match.c:3173
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: SYNC statement at %C"
  msgid "SYNC statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: SYNC оператор в %C"
  
  #: fortran/match.c:3185
  #, gcc-internal-format, gfc-internal-format
  msgid "Image control statement SYNC at %C in CRITICAL block"
-msgstr ""
+msgstr "Оператор управления внешним видом SYNC в %C в CRITICAL блоке"
  
  #: fortran/match.c:3191
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Image control statement SYNC at %C in DO CONCURRENT block"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ SYNC Ð² %C Ð² DO CONCURRENT Ð±Ð»Ð¾ÐºÐµ"
  
  #: fortran/match.c:3371
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Deleted feature: ASSIGN statement at %C"
  msgid "ASSIGN statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð£Ð´Ð°Ð»ÐµÐ½Ð½Ð°Ñ\8f Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ñ\8c: ASSIGN Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/match.c:3415
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Deleted feature: Assigned GOTO statement at %C"
  msgid "Assigned GOTO statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð£Ð´Ð°Ð»ÐµÐ½Ð½Ð°Ñ\8f Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ñ\8c: Assigned GOTO Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/match.c:3459 fortran/match.c:3510
  #, gcc-internal-format, gfc-internal-format
  msgid "Statement label list in GOTO at %C cannot be empty"
-msgstr ""
+msgstr "Список меток операторов в GOTO в %C не может быть пустым"
  
  #: fortran/match.c:3520
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Obsolescent feature: Computed GOTO at %C"
  msgid "Computed GOTO at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð£Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð°Ñ\8f Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ñ\8c: Ð\92Ñ\8bÑ\87Ð¸Ñ\81Ð»Ñ\8fÐµÐ¼Ñ\8bÐ¹ GOTO Ð² %C"
  
  #: fortran/match.c:3592
  #, gcc-internal-format, gfc-internal-format
  msgid "Error in type-spec at %L"
-msgstr ""
+msgstr "Ошибка в спецификации типа в %L"
  
  #: fortran/match.c:3602
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: typespec in ALLOCATE at %L"
  msgid "typespec in ALLOCATE at %L"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: typespec в ALLOCATE в %L"
  
  #: fortran/match.c:3645
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Bad allocate-object at %C for a PURE procedure"
-msgstr "Некорректная операция с указателем в PURE процедуре в %L"
+msgstr "Некорректный allocate-object в %C для PURE процедуры"
  
  #: fortran/match.c:3669
  #, gcc-internal-format, gfc-internal-format
  msgid "ALLOCATE of coarray at %C in DO CONCURRENT block"
-msgstr ""
+msgstr "ALLOCATE комассива в %C в DO CONCURRENT блоке"
  
  #: fortran/match.c:3674
  #, gcc-internal-format, gfc-internal-format
  msgid "ALLOCATE of coarray at %C in CRITICAL block"
-msgstr ""
+msgstr "ALLOCATE комассива в %C в CRITICAL блоке"
  
  #: fortran/match.c:3696
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Allocate-object at %L is not a nonprocedure pointer or an allocatable variable"
  msgid "Allocate-object at %L is neither a data pointer nor an allocatable variable"
-msgstr "Функция-оператор `%A', определенная в %0, не используется"
+msgstr "Allocate-object в %L не есть непроцедурный указатель или размещаемая переменная"
  
  #: fortran/match.c:3708
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Type of entity at %L is type incompatible with typespec"
-msgstr "тип элемента `%T::' несовместим с типом объекта %qT"
+msgstr "Тип сущности в %L есть тип несовместимый с typespec"
  
  #: fortran/match.c:3716
  #, gcc-internal-format, gfc-internal-format
  msgid "Kind type parameter for entity at %L differs from the kind type parameter of the typespec"
-msgstr ""
+msgstr "Вид параметра типа для сущности в %L отличается от вида параметра типа из typespec"
  
  #: fortran/match.c:3730
  #, gcc-internal-format, gfc-internal-format
  msgid "Shape specification for allocatable scalar at %C"
-msgstr ""
+msgstr "Спецификация формы для размещаемого скаляра в %C"
  
  #: fortran/match.c:3767
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ERRMSG tag at %L"
  msgid "ERRMSG tag at %L"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: ERRMSG тег в %L"
  
  #: fortran/match.c:3790
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: SOURCE tag at %L"
  msgid "SOURCE tag at %L"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: SOURCE тег в %L"
  
  #: fortran/match.c:3796
  #, gcc-internal-format, gfc-internal-format
  msgid "Redundant SOURCE tag found at %L "
-msgstr ""
+msgstr "Избыточный SOURCE тег найден в %L "
  
  #: fortran/match.c:3803
  #, gcc-internal-format, gfc-internal-format
  msgid "SOURCE tag at %L conflicts with the typespec at %L"
-msgstr ""
+msgstr "SOURCE тег в %L конфликтует с typespec в %L"
  
  #: fortran/match.c:3809
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: SOURCE tag at %L with more than a single allocate object"
  msgid "SOURCE tag at %L with more than a single allocate object"
-msgstr ""
+msgstr "Fortran 2008: SOURCE тег в %L с более чем одним размещаемым объектом"
  
  #: fortran/match.c:3827
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: MOLD tag at %L"
  msgid "MOLD tag at %L"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: MOLD тег в %L"
  
  #: fortran/match.c:3833
  #, gcc-internal-format, gfc-internal-format
  msgid "Redundant MOLD tag found at %L "
-msgstr ""
+msgstr "Избыточный MOLD тег найден в %L "
  
  #: fortran/match.c:3840
  #, gcc-internal-format, gfc-internal-format
  msgid "MOLD tag at %L conflicts with the typespec at %L"
-msgstr ""
+msgstr "MOLD тег в %L конфликтует с typespec в %L"
  
  #: fortran/match.c:3866
  #, gcc-internal-format, gfc-internal-format
  msgid "MOLD tag at %L conflicts with SOURCE tag at %L"
-msgstr ""
+msgstr "MOLD тег в %L конфликтует с SOURCE тегом в %L"
  
  #: fortran/match.c:3874
  #, gcc-internal-format, gfc-internal-format
  msgid "Allocate-object at %L with a deferred type parameter requires either a type-spec or SOURCE tag or a MOLD tag"
-msgstr ""
+msgstr "Allocate-object в %L с параметром отложенного типа требует либо type-spec либо SOURCE тег либо MOLD тег"
  
  #: fortran/match.c:3886
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Allocate-object at %L with a deferred type parameter requires either a type-spec or SOURCE tag or a MOLD tag"
  msgid "Unlimited polymorphic allocate-object at %L requires either a type-spec or SOURCE tag or a MOLD tag"
-msgstr ""
+msgstr "Allocate-object в %L с параметром отложенного типа требует либо type-spec либо SOURCE тег либо MOLD тег"
  
  #: fortran/match.c:3948
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Pointer object at %C shall not be coindexed"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Указательный объект в %C не должен быть коиндексирован"
  
  #: fortran/match.c:4034
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Illegal allocate-object at %C for a PURE procedure"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼ы"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ allocate-object Ð² %C Ð´Ð»Ñ\8f PURE Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80ы"
  
  #: fortran/match.c:4044
  #, gcc-internal-format, gfc-internal-format
  msgid "DEALLOCATE of coarray at %C in DO CONCURRENT block"
-msgstr ""
+msgstr "DEALLOCATE комассива в %C в DO CONCURRENT блоке"
  
  #: fortran/match.c:4051
  #, gcc-internal-format, gfc-internal-format
  msgid "DEALLOCATE of coarray at %C in CRITICAL block"
-msgstr ""
+msgstr "DEALLOCATE комассива в %C в CRITICAL блоке"
  
  #: fortran/match.c:4067
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Allocate-object at %C is not a nonprocedure pointer or an allocatable variable"
  msgid "Allocate-object at %C is not a nonprocedure pointer nor an allocatable variable"
-msgstr "Функция-оператор `%A', определенная в %0, не используется"
+msgstr "Allocate-object в %C не есть непроцедурный указатель или размещаемая переменная"
  
  #: fortran/match.c:4104
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ERRMSG at %L"
  msgid "ERRMSG at %L"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: ERRMSG в %L"
  
  #: fortran/match.c:4161
  #, gcc-internal-format, gfc-internal-format
  msgid "Image control statement RETURN at %C in CRITICAL block"
-msgstr ""
+msgstr "Оператор управления внешним видом RETURN в %C в CRITICAL блоке"
  
  #: fortran/match.c:4167
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Image control statement RETURN at %C in DO CONCURRENT block"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ð²Ð¸Ð´Ð¾Ð¼ RETURN Ð² %C Ð² DO CONCURRENT Ð±Ð»Ð¾ÐºÐµ"
  
  #: fortran/match.c:4176
  #, gcc-internal-format, gfc-internal-format
  msgid "Alternate RETURN statement at %C is only allowed within a SUBROUTINE"
-msgstr ""
+msgstr "Alternate RETURN оператор в %C допускается только внутри SUBROUTINE"
  
  #: fortran/match.c:4207
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: RETURN statement in main program at %C"
  msgid "RETURN statement in main program at %C"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 RETURN Ð² %0 Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: RETURN Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ðµ Ð² %C"
  
  #: fortran/match.c:4235
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected component reference at %C"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ð° ÐºÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ð² %C"
  
  #: fortran/match.c:4244
  #, gcc-internal-format, gfc-internal-format
  msgid "Junk after CALL at %C"
-msgstr ""
+msgstr "Мусор после CALL в %C"
  
  #: fortran/match.c:4255
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected type-bound procedure or procedure pointer component at %C"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c type-bound Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° Ð¸Ð»Ð¸ ÐºÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 Ð² %C"
  
  #: fortran/match.c:4476
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in common block name at %C"
-msgstr "синтаксическая ошибка в списке параметров макроса"
+msgstr "Синтаксическая ошибка в имени common блока в %C"
  
  #. If we find an error, just print it and continue,
  #. cause it's just semantic, and we can see if there
  #. are more errors.
  #: fortran/match.c:4543
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L in common block '%s' at %C must be declared with a C interoperable kind since common block '%s' is bind(c)"
  msgid "Variable %qs at %L in common block %qs at %C must be declared with a C interoperable kind since common block %qs is bind(c)"
-msgstr ""
+msgstr "Переменная '%s' в %L в common блоке '%s' at %C должна быть декларирована с C совместимым видом поскольку common блок '%s' есть bind(c)"
  
  #: fortran/match.c:4552
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' in common block '%s' at %C can not be bind(c) since it is not global"
  msgid "Variable %qs in common block %qs at %C can not be bind(c) since it is not global"
-msgstr ""
+msgstr "Переменная '%s' в common блоке '%s' at %C не может быть bind(c) поскольку она не является глобальной"
  
  #: fortran/match.c:4559
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %C is already in a COMMON block"
  msgid "Symbol %qs at %C is already in a COMMON block"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Символ '%s' в %C уже в COMMON блоке"
  
  #: fortran/match.c:4567
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Initialized symbol '%s' at %C can only be COMMON in BLOCK DATA"
  msgid "Initialized symbol %qs at %C can only be COMMON in BLOCK DATA"
-msgstr ""
+msgstr "Инициализированный символ '%s' в %C может быть только COMMON в BLOCK DATA"
  
  #: fortran/match.c:4583
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Array specification for symbol '%s' in COMMON at %C must be explicit"
  msgid "Array specification for symbol %qs in COMMON at %C must be explicit"
-msgstr ""
+msgstr "Спецификация массива для символа '%s' в COMMON в %C должна быть явной"
  
  #: fortran/match.c:4593
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' in COMMON at %C cannot be a POINTER array"
  msgid "Symbol %qs in COMMON at %C cannot be a POINTER array"
-msgstr ""
+msgstr "Символ '%s' в COMMON в %C не может быть POINTER массивом"
  
  #: fortran/match.c:4639
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s', in COMMON block '%s' at %C is being indirectly equivalenced to another COMMON block '%s'"
  msgid "Symbol %qs, in COMMON block %qs at %C is being indirectly equivalenced to another COMMON block %qs"
-msgstr ""
+msgstr "Символ '%s' в COMMON блоке '%s' в %C становится косвенно эквивалентным другому COMMON блоку '%s'"
  
  #: fortran/match.c:4767
  #, fuzzy, gcc-internal-format
+#| msgid "Namelist group name '%s' at %C already has a basic type of %s"
  msgid "Namelist group name %qs at %C already has a basic type of %s"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 тип %s"
+msgstr "Ð\98Ð¼Ñ\8f NAMELIST Ð³Ñ\80Ñ\83Ð¿Ð¿Ñ\8b '%s' at %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð±Ð°Ð·Ð¾Ð²Ñ\8bÐ¹ тип %s"
  
  #: fortran/match.c:4775
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Namelist group name '%s' at %C already is USE associated and cannot be respecified."
  msgid "Namelist group name %qs at %C already is USE associated and cannot be respecified."
-msgstr ""
+msgstr "Имя NAMELIST группы '%s' at %C уже USE ассоциировано и не может быть респецифицировано."
  
  #: fortran/match.c:4801
  #, fuzzy, gcc-internal-format
+#| msgid "Assumed size array '%s' in namelist '%s' at %C is not allowed"
  msgid "Assumed size array %qs in namelist %qs at %C is not allowed"
-msgstr "Ð\90Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð\9cÐ°Ñ\81Ñ\81Ð¸Ð² Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° '%s' Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¸Ð¼ÐµÐ½ '%s' Ð² %C Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f"
  
  #: fortran/match.c:4935
  #, gcc-internal-format, gfc-internal-format
  msgid "Derived type component %C is not a permitted EQUIVALENCE member"
-msgstr ""
+msgstr "Компонент производного типа %C не есть разрешенный EQUIVALENCE член"
  
  #: fortran/match.c:4943
  #, gcc-internal-format, gfc-internal-format
  msgid "Array reference in EQUIVALENCE at %C cannot be an array section"
-msgstr ""
+msgstr "Ссылка на массив в EQUIVALENCE в %C не может быть секцией массива"
  
  #: fortran/match.c:4971
  #, gcc-internal-format, gfc-internal-format
  msgid "EQUIVALENCE at %C requires two or more objects"
-msgstr ""
+msgstr "EQUIVALENCE в %C требует два или более объектов"
  
  #: fortran/match.c:4985
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Attempt to indirectly overlap COMMON blocks %s and %s by EQUIVALENCE at %C"
-msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ COMMON-Ð¾Ð±Ð»Ð°Ñ\81Ñ\82Ð¸ Ð¿Ð¾ Ñ\81Ñ\80Ð°Ð²Ð½ÐµÐ½Ð¸Ñ\8e Ñ\81 Ð¸Ñ\81Ñ\85Ð¾Ð´Ð½Ñ\8bÐ¼ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð¾Ð¼ Ð¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²Ð¾Ð¼ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° EQUIVALENCE Ð´Ð»Ñ\8f `%A'"
+msgstr "Ð\9fÐ¾Ð¿Ñ\8bÑ\82ÐºÐ° ÐºÐ¾Ñ\81Ð²ÐµÐ½Ð½Ð¾ Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÑ\82Ñ\8c COMMON Ð±Ð»Ð¾ÐºÐ¸ %s Ð¸ %s Ð¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²Ð¾Ð¼ EQUIVALENCE Ð² %C"
  
  #: fortran/match.c:4998
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expecting a comma in EQUIVALENCE at %C"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°ÐµÑ\82Ñ\81Ñ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² EQUIVALENCE Ð² %C"
  
  #: fortran/match.c:5114
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Statement function at %L is recursive"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ð² %L Ñ\80ÐµÐºÑ\83Ñ\80Ñ\81Ð¸Ð²Ð½Ð°"
  
  #: fortran/match.c:5124
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
  msgid "Statement function at %L cannot appear within an INTERFACE"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "ENTRY оператор в %C не может появляться внутри INTERFACE"
  
  #: fortran/match.c:5129
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Statement function at %L is recursive"
  msgid "Statement function at %C"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ð² %L Ñ\80ÐµÐºÑ\83Ñ\80Ñ\81Ð¸Ð²Ð½Ð°"
  
  #: fortran/match.c:5254 fortran/match.c:5270
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Expression in CASE statement at %L must be scalar"
  msgid "Expression in CASE selector at %L cannot be %s"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
+msgstr "Ð\92Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² CASE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80Ð¾Ð¼"
  
  #: fortran/match.c:5292
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected initialization expression in CASE at %C"
-msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð°Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8f Ð¼ÐµÐ¶Ð´Ñ\83 Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8fÐ¼Ð¸ Ð² %0 Ð¸ Ð² %1"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¾Ð½Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² CASE Ð² %C"
  
  #: fortran/match.c:5324
  #, fuzzy, gcc-internal-format
+#| msgid "Expected block name '%s' of SELECT construct at %C"
  msgid "Expected block name %qs of SELECT construct at %C"
-msgstr "  ожидался шаблон класса, обнаружено %qT"
+msgstr "Ожидалось имя блока '%s' SELECT конструкции в %C"
  
  #: fortran/match.c:5604
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Syntax error in PROTECTED statement at %C"
  msgid "parse error in SELECT TYPE statement at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² PROTECTED Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/match.c:5628
  #, gcc-internal-format, gfc-internal-format
  msgid "Selector in SELECT TYPE at %C is not a named variable; use associate-name=>"
-msgstr ""
+msgstr "Селектор в SELECT TYPE в %C не есть именованная переменная; используйте associate-name=>"
  
  #: fortran/match.c:5662
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected CASE statement at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ CASE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/match.c:5714
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in CASE specification at %C"
-msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² CASE Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð² %C"
  
  #: fortran/match.c:5732
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected TYPE IS statement at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ TYPE IS Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/match.c:5764
  #, gcc-internal-format, gfc-internal-format
@@ -54330,50 +56846,53 @@ msgid "The type-spec shall not specify a sequence derived type or a type with th
  msgstr ""
  
  #: fortran/match.c:5776
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in TYPE IS specification at %C"
-msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² TYPE IS Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð² %C"
  
  #: fortran/match.c:5852
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in CLASS IS specification at %C"
-msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² CLASS IS Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð² %C"
  
  #: fortran/match.c:5970
  #, gcc-internal-format, gfc-internal-format
  msgid "ELSEWHERE statement at %C not enclosed in WHERE block"
-msgstr ""
+msgstr "ELSEWHERE оператор в %C не заключен в WHERE блок"
  
  #: fortran/match.c:6008
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Label '%s' at %C doesn't match WHERE label '%s'"
  msgid "Label %qs at %C doesn't match WHERE label %qs"
-msgstr ""
+msgstr "Метка '%s' в %C не соответствует WHERE метке '%s'"
  
  #: fortran/matchexp.c:72
  #, fuzzy, gcc-internal-format
+#| msgid "Bad character '%c' in OPERATOR name at %C"
  msgid "Bad character %qc in OPERATOR name at %C"
-msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð»Ñ\8cÐ½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð¹ Ð´Ð»Ð¸Ð½Ñ\8b Ð² %0"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð¼Ð²Ð¾Ð» '%c' Ð² OPERATOR Ð¸Ð¼ÐµÐ½Ð¸ Ð² %C"
  
  #: fortran/matchexp.c:80
  #, fuzzy, gcc-internal-format
+#| msgid "The name '%s' cannot be used as a defined operator at %C"
  msgid "The name %qs cannot be used as a defined operator at %C"
-msgstr "\"%s\" нельзя использовать как имя макроса, поскольку это имя операции C++"
+msgstr "Имя '%s' не может быть использовано как определенный оператор в %C"
  
  #: fortran/matchexp.c:173
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected a right parenthesis in expression at %C"
-msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ð±Ð¸Ð½Ð°Ñ\80Ð½Ð°Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8f Ð¼ÐµÐ¶Ð´Ñ\83 Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8fÐ¼Ð¸ Ð² %0 Ð¸ Ð² %1"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ð¿Ñ\80Ð°Ð²Ð°Ñ\8f Ñ\81ÐºÐ¾Ð±ÐºÐ° Ð² Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ð² %C"
  
  #: fortran/matchexp.c:281
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected exponent in expression at %C"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c Ñ\8dÐºÑ\81Ð¿Ð¾Ð½ÐµÐ½Ñ\82Ð° Ð² Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ð² %C"
  
  #: fortran/matchexp.c:319 fortran/matchexp.c:324 fortran/matchexp.c:428
  #: fortran/matchexp.c:433
  #, gcc-internal-format, gfc-internal-format
  msgid "Extension: Unary operator following arithmetic operator (use parentheses) at %C"
-msgstr ""
+msgstr "Расширение: Унарный оператор следущий за арифметическим оператором (используйте скобки) в %C"
  
  #: fortran/matchexp.c:665
  #, gcc-internal-format
@@ -54391,9 +56910,10 @@ msgid "gfc_typename(): Undefined type"
  msgstr ""
  
  #: fortran/misc.c:187
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "gfc_code2string(): Bad code"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: fortran/module.c:240
  #, gcc-internal-format
@@ -54407,66 +56927,72 @@ msgstr ""
  
  #: fortran/module.c:539
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: module nature in USE statement at %C"
  msgid "module nature in USE statement at %C"
-msgstr "Недопустимое число в операторе FORMAT в %0"
+msgstr "Fortran 2003: природа модуля в USE операторе в %C"
  
  #: fortran/module.c:551
  #, gcc-internal-format, gfc-internal-format
  msgid "Module nature in USE statement at %C shall be either INTRINSIC or NON_INTRINSIC"
-msgstr ""
+msgstr "Природа модуля в USE операторе в %C должна быть либо INTRINSIC либо NON_INTRINSIC"
  
  #: fortran/module.c:564
  #, gcc-internal-format, gfc-internal-format
  msgid "\"::\" was expected after module nature at %C but was not found"
-msgstr ""
+msgstr "\"::\" ожидалось после природы модуля в %C но не было найдено"
  
  #: fortran/module.c:574
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: \"USE :: module\" at %C"
  msgid "\"USE :: module\" at %C"
-msgstr ""
+msgstr "Fortran 2003: \"USE :: module\" в %C"
  
  #: fortran/module.c:633
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Missing generic specification in USE statement at %C"
-msgstr "Отсутствует спецификатор %A в операторе в %0"
+msgstr "Отсутствует generic спецификация в USE операторе в %C"
  
  #: fortran/module.c:641
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: Renaming operators in USE statements at %C"
  msgid "Renaming operators in USE statements at %C"
-msgstr "Недопустимое число в операторе FORMAT в %0"
+msgstr "Fortran 2003: Операторы переименования в USE операторе в %C"
  
  #: fortran/module.c:682
  #, fuzzy, gcc-internal-format
+#| msgid "The name '%s' at %C has already been used as an external module name."
  msgid "The name %qs at %C has already been used as an external module name."
-msgstr "Имя типа в %0 не совпадает с именем, заданным в %1"
+msgstr "Имя '%s' в %C уже было использовано как имя внешнего модуля."
  
  #: fortran/module.c:744
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "in declaration %q+D"
  msgid "SUBMODULE declaration at %C"
-msgstr "Ð\9eÐ¶Ð¸Ð´Ð°ÐµÑ\82Ñ\81Ñ\8f Ð´Ñ\80Ñ\83Ð³Ð°Ñ\8f Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð½Ð¾Ñ\81Ñ\82Ñ\8c Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸ %C"
+msgstr "Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %q+D"
  
  #: fortran/module.c:814
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Syntax error in SAVE statement at %C"
  msgid "Syntax error in SUBMODULE statement at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² SAVE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/module.c:1159
  #, fuzzy, gcc-internal-format
  #| msgid "Reading module %s at line %d column %d: %s"
  msgid "Reading module %qs at line %d column %d: %s"
-msgstr "Чтение модуля %s в строке %d символ %d: %s"
+msgstr "Чтение модуля %s в строке %d колонке %d: %s"
  
  #: fortran/module.c:1163
  #, fuzzy, gcc-internal-format
  #| msgid "Writing module %s at line %d column %d: %s"
  msgid "Writing module %qs at line %d column %d: %s"
-msgstr "Запись модуля %s в строке %d символ %d: %s"
+msgstr "Запись модуля %s в строке %d колонке %d: %s"
  
  #: fortran/module.c:1167
  #, fuzzy, gcc-internal-format
  #| msgid "Module %s at line %d column %d: %s"
  msgid "Module %qs at line %d column %d: %s"
-msgstr "Модуль %s в строке %d символ %d: %s"
+msgstr "Модуль %s в строке %d колонке %d: %s"
  
  #: fortran/module.c:1562
  #, gcc-internal-format
@@ -54474,9 +57000,9 @@ msgid "require_atom(): bad atom type required"
  msgstr ""
  
  #: fortran/module.c:1611
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Error writing modules file: %s"
-msgstr "%s:ошибка записи в выходной файл '%s'\n"
+msgstr "Ошибка записи в файл модулей: %s"
  
  #: fortran/module.c:1655
  #, gcc-internal-format
@@ -54501,7 +57027,7 @@ msgstr ""
  #: fortran/module.c:3637
  #, gcc-internal-format, gfc-internal-format
  msgid "Namelist %s cannot be renamed by USE association to %s"
-msgstr ""
+msgstr "Список имен %s не может быть переименован путем USE ассоциации в %s"
  
  #: fortran/module.c:4757
  #, gcc-internal-format, gfc-internal-format
@@ -54514,24 +57040,28 @@ msgid "Previous !$OMP DECLARE REDUCTION from module %s at %L"
  msgstr ""
  
  #: fortran/module.c:4948
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' of module '%s', imported at %C, is also the name of the current program unit"
  msgid "%qs of module %qs, imported at %C, is also the name of the current program unit"
-msgstr ""
+msgstr "'%s' от модуля '%s', импортированного в %C, есть также имя текущей программной единицы"
  
  #: fortran/module.c:5309
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' referenced at %L not found in module '%s'"
  msgid "Symbol %qs referenced at %L not found in module %qs"
-msgstr "Ð\9cÐµÑ\82ÐºÐ° %A Ñ\83Ð¶Ðµ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð° Ð² %1 Ð° Ð·Ð°Ñ\82ÐµÐ¼ Ð¿ÐµÑ\80ÐµÐ¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð° Ð² %0"
+msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» '%s' Ð²Ñ\81Ñ\82Ñ\80ÐµÑ\87Ð°Ñ\8eÑ\89Ð¸Ð¹Ñ\81Ñ\8f Ð² %L Ð½Ðµ Ð½Ð°Ð¹Ð´ÐµÐ½ Ð² Ð¼Ð¾Ð´Ñ\83Ð»Ðµ '%s'"
  
  #: fortran/module.c:5316
  #, fuzzy, gcc-internal-format
+#| msgid "User operator '%s' referenced at %L not found in module '%s'"
  msgid "User operator %qs referenced at %L not found in module %qs"
-msgstr "ÐÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð\9fÐ¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82ÐµÐ»Ñ\8cÑ\81ÐºÐ¸Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 '%s' Ð²Ñ\81Ñ\82Ñ\80ÐµÑ\87Ð°Ñ\8eÑ\89Ð¸Ð¹Ñ\81Ñ\8f Ð² %L Ð½Ðµ Ð½Ð°Ð¹Ð´ÐµÐ½ Ð² Ð¼Ð¾Ð´Ñ\83Ð»Ðµ '%s'"
  
  #: fortran/module.c:5321
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Intrinsic operator '%s' referenced at %L not found in module '%s'"
  msgid "Intrinsic operator %qs referenced at %L not found in module %qs"
-msgstr ""
+msgstr "Встроенный оператор '%s' встречающийся в %L не найден в модуле '%s'"
  
  #: fortran/module.c:5556
  #, gcc-internal-format
@@ -54545,35 +57075,40 @@ msgstr ""
  
  #: fortran/module.c:6076
  #, fuzzy, gcc-internal-format
+#| msgid "Can't open module file '%s' for writing at %C: %s"
  msgid "Can't open module file %qs for writing at %C: %s"
-msgstr "%s: ошибка открытия файла '%s' на чтение: %s\n"
+msgstr "Не удалось открыть файл модуля '%s' для записи в %C: %s"
  
  #: fortran/module.c:6095
  #, fuzzy, gcc-internal-format
+#| msgid "Error writing module file '%s' for writing: %s"
  msgid "Error writing module file %qs for writing: %s"
-msgstr "%s: ошибка записи файла '%s': %s\n"
+msgstr "Ошибка записи файла модуля '%s' для записи: %s"
  
  #: fortran/module.c:6106
  #, fuzzy, gcc-internal-format
+#| msgid "Can't delete module file '%s': %s"
  msgid "Can't delete module file %qs: %s"
-msgstr "%s: ошибка удаления файла '%s': %s\n"
+msgstr "Не удалось удалить файл модуля '%s': %s"
  
  #: fortran/module.c:6109
  #, fuzzy, gcc-internal-format
+#| msgid "Can't rename module file '%s' to '%s': %s"
  msgid "Can't rename module file %qs to %qs: %s"
-msgstr "%s: ошибка переименования файла '%s' в '%s': %s\n"
+msgstr "Не удалось переименовать файл модуля '%s' в '%s': %s"
  
  #: fortran/module.c:6115
  #, fuzzy, gcc-internal-format
+#| msgid "Can't delete temporary module file '%s': %s"
  msgid "Can't delete temporary module file %qs: %s"
-msgstr "%s: ошибка удаления вспомогательного файла '%s': %s\n"
+msgstr "Не удалось удалить временный файл модуля '%s': %s"
  
  #: fortran/module.c:6157 fortran/module.c:6484 fortran/module.c:6517
  #: fortran/module.c:6559
  #, fuzzy, gcc-internal-format
-#| msgid "%qD is already declared in this scope"
+#| msgid "Symbol '%s' already declared"
  msgid "Symbol %qs already declared"
-msgstr "Ð² Ñ\8dÑ\82Ð¾Ð¹ Ð¾Ð±Ð»Ð°Ñ\81Ñ\82Ð¸ Ð²Ð¸Ð´Ð¸Ð¼Ð¾Ñ\81Ñ\82Ð¸ Ñ\83Ð¶Ðµ ÐµÑ\81Ñ\82Ñ\8c Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qD"
+msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» '%s' Ñ\83Ð¶Ðµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
  
  #: fortran/module.c:6227
  #, gcc-internal-format, gfc-internal-format
@@ -54581,59 +57116,68 @@ msgid "import_iso_c_binding_module(): Unable to create symbol for %s"
  msgstr ""
  
  #: fortran/module.c:6335 fortran/module.c:6679
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The symbol '%s', referenced at %L, is not in the selected standard"
  msgid "The symbol %qs, referenced at %L, is not in the selected standard"
-msgstr ""
+msgstr "Символ '%s', встречающийся в %L, не содержится в выбранном стандарте"
  
  #: fortran/module.c:6463
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' referenced at %L not found in intrinsic module ISO_C_BINDING"
  msgid "Symbol %qs referenced at %L not found in intrinsic module ISO_C_BINDING"
-msgstr ""
+msgstr "Символ '%s' встречающийся в %L не найден во встроенном модуле ISO_C_BINDING"
  
  #: fortran/module.c:6664
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Use of intrinsic module '%s' at %C conflicts with non-intrinsic module name used previously"
  msgid "Use of intrinsic module %qs at %C conflicts with non-intrinsic module name used previously"
-msgstr ""
+msgstr "Использование встроенного модуля '%s' в %C конфликтует с именем невстроенного модуля использованным ранее"
  
  #: fortran/module.c:6686
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Use of the NUMERIC_STORAGE_SIZE named constant from intrinsic module ISO_FORTRAN_ENV at %L is incompatible with option %s"
  msgid "Use of the NUMERIC_STORAGE_SIZE named constant from intrinsic module ISO_FORTRAN_ENV at %L is incompatible with option %qs"
-msgstr ""
+msgstr "Использование NUMERIC_STORAGE_SIZE именованной константы из встроенного модуля ISO_FORTRAN_ENV в %L несовместимо с опцией %s"
  
  #: fortran/module.c:6754
  #, gcc-internal-format, gfc-internal-format
  msgid "Use of the NUMERIC_STORAGE_SIZE named constant from intrinsic module ISO_FORTRAN_ENV at %C is incompatible with option %s"
-msgstr ""
+msgstr "Использование NUMERIC_STORAGE_SIZE именованной константы из встроенного модуля ISO_FORTRAN_ENV в %C несовместимо с опцией %s"
  
  #: fortran/module.c:6808
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' referenced at %L not found in intrinsic module ISO_FORTRAN_ENV"
  msgid "Symbol %qs referenced at %L not found in intrinsic module ISO_FORTRAN_ENV"
-msgstr ""
+msgstr "Символ '%s' встречающийся в %L не найден во встроенном модуле ISO_FORTRAN_ENV"
  
  #: fortran/module.c:6834
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "CLOSE statement at %L requires a UNIT number"
  msgid "USE statement at %C has no ONLY qualifier"
-msgstr "ожидалось имя типа"
+msgstr "CLOSE оператор в %L требует UNIT номер"
  
  #: fortran/module.c:6863
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ISO_FORTRAN_ENV intrinsic module at %C"
  msgid "ISO_FORTRAN_ENV intrinsic module at %C"
-msgstr ""
+msgstr "Fortran 2003: ISO_FORTRAN_ENV встроенный модуль в %C"
  
  #: fortran/module.c:6875
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ISO_C_BINDING module at %C"
  msgid "ISO_C_BINDING module at %C"
-msgstr ""
+msgstr "Fortran 2003: ISO_C_BINDING модуль в %C"
  
  #: fortran/module.c:6888
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Can't find an intrinsic module named '%s' at %C"
  msgid "Can't find an intrinsic module named %qs at %C"
-msgstr ""
+msgstr "Не удалось найти встроенный модуль с названный '%s' в %C"
  
  #: fortran/module.c:6894
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "IEEE_FEATURES module at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr ""
  
  #: fortran/module.c:6900
  #, gcc-internal-format, gfc-internal-format
@@ -54647,18 +57191,21 @@ msgstr ""
  
  #: fortran/module.c:6913
  #, fuzzy, gcc-internal-format
+#| msgid "Can't open module file '%s' for reading at %C: %s"
  msgid "Can't open module file %qs for reading at %C: %s"
-msgstr "%s: ошибка открытия файла '%s' на чтение: %s\n"
+msgstr "Ошибка открытия файла модуля '%s' на чтение в %C: %s"
  
  #: fortran/module.c:6921
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Use of non-intrinsic module '%s' at %C conflicts with intrinsic module name used previously"
  msgid "Use of non-intrinsic module %qs at %C conflicts with intrinsic module name used previously"
-msgstr ""
+msgstr "Использование невстроенного модуля '%s' в %C конфликтует с именем встроенного модуля использованным ранее"
  
  #: fortran/module.c:6944
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "File '%s' opened at %C is not a GFORTRAN module file"
  msgid "File %qs opened at %C is not a GNU Fortran module file"
-msgstr ""
+msgstr "Файл '%s' открытый в %C не есть GFORTRAN файл модуля"
  
  #: fortran/module.c:6952
  #, gcc-internal-format
@@ -54666,40 +57213,45 @@ msgid "Cannot read module file %qs opened at %C, because it was created by a dif
  msgstr ""
  
  #: fortran/module.c:6967
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Can't USE the same module we're building!"
  msgid "Can't USE the same %smodule we're building!"
-msgstr ""
+msgstr "Невозможно USE тот же модуль что мы строим!"
  
  #: fortran/openmp.c:289 fortran/openmp.c:497 fortran/openmp.c:2399
  #: fortran/openmp.c:2473
  #, gcc-internal-format, gfc-internal-format
  msgid "COMMON block /%s/ not found at %C"
-msgstr ""
+msgstr "COMMON блок /%s/ не найден в %C"
  
  #: fortran/openmp.c:328
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in OpenMP variable list at %C"
-msgstr "синтаксическая ошибка в списке параметров макроса"
+msgstr "Синтаксическая ошибка в OpenMP списке переменных в %C"
  
  #: fortran/openmp.c:390
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Syntax error in expression at %C"
  msgid "Syntax error in OpenACC expression list at %C"
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ð² %C"
  
  #: fortran/openmp.c:465
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Threadprivate variable at %C is an element of a COMMON block"
  msgid "Variable at %C is an element of a COMMON block"
-msgstr ""
+msgstr "Threadprivate переменная в %C является элементом COMMON блока"
  
  #: fortran/openmp.c:525
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unexpected junk after $OMP ORDERED statement at %C"
  msgid "Unexpected junk after !$ACC DECLARE at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP ORDERED Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:535
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Syntax error in !$OMP THREADPRIVATE list at %C"
  msgid "Syntax error in !$ACC DECLARE list at %C"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ðµ Ð¿Ñ\83Ð»Ð° ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82 #%d\n"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² !$OMP THREADPRIVATE Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð² %C"
  
  #: fortran/openmp.c:991
  #, gcc-internal-format, gfc-internal-format
@@ -54709,7 +57261,7 @@ msgstr ""
  #: fortran/openmp.c:1091
  #, gcc-internal-format, gfc-internal-format
  msgid "COLLAPSE clause argument not constant positive integer at %C"
-msgstr ""
+msgstr "Аргумент COLLAPSE клаузулы не есть положительная целая константа в %C"
  
  #: fortran/openmp.c:1476
  #, gcc-internal-format, gfc-internal-format
@@ -54733,18 +57285,22 @@ msgstr ""
  
  #: fortran/openmp.c:1591
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unexpected junk after TASKWAIT clause at %C"
  msgid "Unexpected junk in !$ACC WAIT at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ TASKWAIT ÐºÐ»Ð°Ñ\83Ð·Ñ\83Ð»Ñ\8b Ð² %C"
  
+#
  #: fortran/openmp.c:1600
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Invalid third argument of IBITS at %L"
  msgid "Invalid argument to $!ACC WAIT at %L"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qs"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ñ\80ÐµÑ\82Ð¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 IBITS Ð² %L"
  
  #: fortran/openmp.c:1609
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
  msgid "WAIT clause at %L requires a scalar INTEGER expression"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "NUM_THREADS клаузула в %L требует скалярное INTEGER выражение"
  
  #: fortran/openmp.c:1638
  #, gcc-internal-format, gfc-internal-format
@@ -54769,8 +57325,9 @@ msgstr ""
  
  #: fortran/openmp.c:1731
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C"
  msgid "Syntax error in !$ACC ROUTINE ( NAME ) at %C"
-msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² !GCC$ ATTRIBUTES Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/openmp.c:1738
  #, gcc-internal-format, gfc-internal-format
@@ -54778,14 +57335,14 @@ msgid "Syntax error in !$ACC ROUTINE ( NAME ) at %C, expecting ')' after NAME"
  msgstr ""
  
  #: fortran/openmp.c:1844
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after $OMP CRITICAL statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP CRITICAL Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:1909
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after $OMP FLUSH statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP FLUSH Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:2292 fortran/openmp.c:5151
  #, gcc-internal-format, gfc-internal-format
@@ -54809,8 +57366,9 @@ msgstr ""
  
  #: fortran/openmp.c:2323
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unexpected junk after $OMP ORDERED statement at %C"
  msgid "Unexpected junk after !$OMP DECLARE REDUCTION at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP ORDERED Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:2352
  #, gcc-internal-format, gfc-internal-format
@@ -54818,174 +57376,198 @@ msgid "Only the !$OMP DECLARE TARGET form without list is allowed in interface b
  msgstr ""
  
  #: fortran/openmp.c:2378
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Threadprivate variable at %C is an element of a COMMON block"
  msgid "OMP DECLARE TARGET on a variable at %C is an element of a COMMON block"
-msgstr ""
+msgstr "Threadprivate переменная в %C является элементом COMMON блока"
  
  #: fortran/openmp.c:2417
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unexpected junk after $OMP ORDERED statement at %C"
  msgid "Unexpected junk after !$OMP DECLARE TARGET at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP ORDERED Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:2423
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Syntax error in !$OMP THREADPRIVATE list at %C"
  msgid "Syntax error in !$OMP DECLARE TARGET list at %C"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ðµ Ð¿Ñ\83Ð»Ð° ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82 #%d\n"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² !$OMP THREADPRIVATE Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð² %C"
  
  #: fortran/openmp.c:2453
  #, gcc-internal-format, gfc-internal-format
  msgid "Threadprivate variable at %C is an element of a COMMON block"
-msgstr ""
+msgstr "Threadprivate переменная в %C является элементом COMMON блока"
  
  #: fortran/openmp.c:2490
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unexpected junk after $OMP ORDERED statement at %C"
  msgid "Unexpected junk after OMP THREADPRIVATE at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP ORDERED Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:2497
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in !$OMP THREADPRIVATE list at %C"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ðµ Ð¿Ñ\83Ð»Ð° ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82 #%d\n"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² !$OMP THREADPRIVATE Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð² %C"
  
  #: fortran/openmp.c:2578
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after TASKWAIT clause at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ TASKWAIT ÐºÐ»Ð°Ñ\83Ð·Ñ\83Ð»Ñ\8b Ð² %C"
  
  #: fortran/openmp.c:2592
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after TASKYIELD clause at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ TASKYIELD ÐºÐ»Ð°Ñ\83Ð·Ñ\83Ð»Ñ\8b Ð² %C"
  
  #: fortran/openmp.c:2717
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after $OMP WORKSHARE statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP WORKSHARE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:2731
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after $OMP MASTER statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP MASTER Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:2745
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after $OMP ORDERED statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP ORDERED Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:2790
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after $OMP ATOMIC statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP ATOMIC Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:2817
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after $OMP BARRIER statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP BARRIER Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:2831
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unexpected junk after $OMP MASTER statement at %C"
  msgid "Unexpected junk after $OMP TASKGROUP statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP MASTER Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:2881
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unexpected junk after $OMP ATOMIC statement at %C"
  msgid "Unexpected junk after $OMP CANCELLATION POINT statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ $OMP ATOMIC Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %C"
  
  #: fortran/openmp.c:2901
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after NOWAIT clause at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ð¼Ñ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ NOWAIT ÐºÐ»Ð°Ñ\83Ð·Ñ\83Ð»Ñ\8b Ð² %C"
  
  #: fortran/openmp.c:2941
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
  msgid "%s clause at %L requires a scalar INTEGER expression"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "NUM_THREADS клаузула в %L требует скалярное INTEGER выражение"
  
  #: fortran/openmp.c:2952
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "SIZE at %L must be positive"
  msgid "INTEGER expression of %s clause at %L must be positive"
-msgstr "%qD не является элементом типа %qT"
+msgstr "SIZE в %L должен быть положительным"
  
  #: fortran/openmp.c:2963
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "POINTER object '%s' in %s clause at %L"
  msgid "POINTER object %qs of derived type in %s clause at %L"
-msgstr ""
+msgstr "POINTER объект '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:2966
  #, fuzzy, gcc-internal-format
+#| msgid "Cray pointer '%s' in %s clause at %L"
  msgid "Cray pointer object of derived type %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "Cray указатель '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:2969
  #, fuzzy, gcc-internal-format
+#| msgid "Cray pointee '%s' in %s clause at %L"
  msgid "Cray pointee object of derived type %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "Cray указуемое '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:2975
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "POINTER object '%s' in %s clause at %L"
  msgid "POINTER object %qs of polymorphic type in %s clause at %L"
-msgstr ""
+msgstr "POINTER объект '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:2980
  #, fuzzy, gcc-internal-format
+#| msgid "Cray pointer '%s' in %s clause at %L"
  msgid "Cray pointer object of polymorphic type %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "Cray указатель '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:2985
  #, fuzzy, gcc-internal-format
+#| msgid "Cray pointee '%s' in %s clause at %L"
  msgid "Cray pointee object of polymorphic type %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "Cray указуемое '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:2995 fortran/openmp.c:3521
  #, fuzzy, gcc-internal-format
+#| msgid "Assumed size array '%s' in %s clause at %L"
  msgid "Assumed size array %qs in %s clause at %L"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð² %s"
+msgstr "Ð\9cÐ°Ñ\81Ñ\81Ð¸Ð² Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° '%s' Ð² %s ÐºÐ»Ð°Ñ\83Ð·Ñ\83Ð»Ðµ Ð² %L"
  
  #: fortran/openmp.c:2998
  #, fuzzy, gcc-internal-format
+#| msgid "Assumed size array '%s' in %s clause at %L"
  msgid "Assumed rank array %qs in %s clause at %L"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ñ\8f %qT Ð² %qT Ð² %s"
+msgstr "Ð\9cÐ°Ñ\81Ñ\81Ð¸Ð² Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° '%s' Ð² %s ÐºÐ»Ð°Ñ\83Ð·Ñ\83Ð»Ðµ Ð² %L"
  
  #: fortran/openmp.c:3002
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Assumed size array '%s' in %s clause at %L"
  msgid "Noncontiguous deferred shape array %qs in %s clause at %L"
-msgstr ""
+msgstr "Массив предполагаемого размера '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3010
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "POINTER object '%s' in %s clause at %L"
  msgid "ALLOCATABLE object %qs of derived type in %s clause at %L"
-msgstr ""
+msgstr "POINTER объект '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3015
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "POINTER object '%s' in %s clause at %L"
  msgid "ALLOCATABLE object %qs of polymorphic type in %s clause at %L"
-msgstr ""
+msgstr "POINTER объект '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3027 fortran/openmp.c:3511 fortran/openmp.c:3684
  #, fuzzy, gcc-internal-format
+#| msgid "POINTER object '%s' in %s clause at %L"
  msgid "POINTER object %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "POINTER объект '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3032 fortran/openmp.c:3687
  #, fuzzy, gcc-internal-format
+#| msgid "Cray pointer '%s' in %s clause at %L"
  msgid "Cray pointer object %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "Cray указатель '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3037 fortran/openmp.c:3690
  #, fuzzy, gcc-internal-format
+#| msgid "Cray pointee '%s' in %s clause at %L"
  msgid "Cray pointee object %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "Cray указуемое '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3042 fortran/openmp.c:3679
  #, fuzzy, gcc-internal-format
+#| msgid "POINTER object '%s' in %s clause at %L"
  msgid "ALLOCATABLE object %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "POINTER объект '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3045
  #, fuzzy, gcc-internal-format
+#| msgid "POINTER object '%s' in %s clause at %L"
  msgid "VALUE object %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "POINTER объект '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3088
  #, gcc-internal-format, gfc-internal-format
@@ -55000,79 +57582,90 @@ msgstr ""
  #: fortran/openmp.c:3171 fortran/resolve.c:9395 fortran/resolve.c:10617
  #, gcc-internal-format, gfc-internal-format
  msgid "IF clause at %L requires a scalar LOGICAL expression"
-msgstr ""
+msgstr "IF клаузула в %L требует скалярное LOGICAL выражение"
  
  #: fortran/openmp.c:3179
  #, gcc-internal-format, gfc-internal-format
  msgid "FINAL clause at %L requires a scalar LOGICAL expression"
-msgstr ""
+msgstr "FINAL клаузула в %L требует скалярное LOGICAL выражение"
  
  #: fortran/openmp.c:3187
  #, gcc-internal-format, gfc-internal-format
  msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
-msgstr ""
+msgstr "NUM_THREADS клаузула в %L требует скалярное INTEGER выражение"
  
  #: fortran/openmp.c:3195
  #, gcc-internal-format, gfc-internal-format
  msgid "SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
-msgstr ""
+msgstr "chunk_size SCHEDULE клаузулы в %L требует скалярное INTEGER выражение"
  
  #: fortran/openmp.c:3210
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' has not been assigned a target label at %L"
  msgid "Variable %qs is not a dummy argument at %L"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ %qs"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ '%s' Ð½Ðµ Ð¿Ñ\80Ð¸Ñ\81Ð²Ð¾Ð¸Ð»Ð¸ Ñ\86ÐµÐ»ÐµÐ²Ñ\83Ñ\8e Ð¼ÐµÑ\82ÐºÑ\83 Ð² %L"
  
  #: fortran/openmp.c:3242
  #, fuzzy, gcc-internal-format
+#| msgid "Object '%s' is not a variable at %L"
  msgid "Object %qs is not a variable at %L"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\9eÐ±Ñ\8aÐµÐºÑ\82 '%s' Ð½Ðµ ÐµÑ\81Ñ\82Ñ\8c Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ð² %L"
  
  #: fortran/openmp.c:3258 fortran/openmp.c:3269 fortran/openmp.c:3277
  #: fortran/openmp.c:3288 fortran/openmp.c:3300 fortran/openmp.c:3315
  #: fortran/openmp.c:4958
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' present on multiple clauses at %L"
  msgid "Symbol %qs present on multiple clauses at %L"
-msgstr ""
+msgstr "Символ '%s' присутствует в нескольких клаузулах в %L"
  
  #: fortran/openmp.c:3322
  #, fuzzy, gcc-internal-format
+#| msgid "Array section not permitted in '%s' call at %L"
  msgid "Array %qs is not permitted in reduction at %L"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð¡ÐµÐºÑ\86Ð¸Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\80Ð°Ð·Ñ\80ÐµÑ\88ÐµÐ½Ð° Ð² '%s' Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ð² %L"
  
  #: fortran/openmp.c:3335
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' present on multiple clauses at %L"
  msgid "Symbol %qs present on both FROM and TO clauses at %L"
-msgstr ""
+msgstr "Символ '%s' присутствует в нескольких клаузулах в %L"
  
  #: fortran/openmp.c:3357
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Non-THREADPRIVATE object '%s' in COPYIN clause at %L"
  msgid "Non-THREADPRIVATE object %qs in COPYIN clause at %L"
-msgstr ""
+msgstr "Non-THREADPRIVATE объект '%s' в COPYIN клаузуле в %L"
  
  #: fortran/openmp.c:3365
  #, fuzzy, gcc-internal-format
+#| msgid "Assumed size array '%s' in COPYPRIVATE clause at %L"
  msgid "Assumed size array %qs in COPYPRIVATE clause at %L"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9cÐ°Ñ\81Ñ\81Ð¸Ð² Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° '%s' Ð² COPYPRIVATE ÐºÐ»Ð°Ñ\83Ð·Ñ\83Ð»Ðµ Ð² %L"
  
  #: fortran/openmp.c:3368
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Assumed size array '%s' in COPYPRIVATE clause at %L"
  msgid "INTENT(IN) POINTER %qs in COPYPRIVATE clause at %L"
-msgstr ""
+msgstr "Массив предполагаемого размера '%s' в COPYPRIVATE клаузуле в %L"
  
  #: fortran/openmp.c:3376
  #, fuzzy, gcc-internal-format
+#| msgid "THREADPRIVATE object '%s' in SHARED clause at %L"
  msgid "THREADPRIVATE object %qs in SHARED clause at %L"
-msgstr "Некорректная операция с указателем в PURE процедуре в %L"
+msgstr "THREADPRIVATE объект '%s' в SHARED клаузуле в %L"
  
  #: fortran/openmp.c:3379
  #, fuzzy, gcc-internal-format
+#| msgid "Cray pointee '%s' in SHARED clause at %L"
  msgid "Cray pointee %qs in SHARED clause at %L"
-msgstr "Некорректная операция с указателем в PURE процедуре в %L"
+msgstr "Cray указуемое '%s' в SHARED клаузуле в %L"
  
  #: fortran/openmp.c:3382
  #, fuzzy, gcc-internal-format
+#| msgid "THREADPRIVATE object '%s' in SHARED clause at %L"
  msgid "ASSOCIATE name %qs in SHARED clause at %L"
-msgstr "Некорректная операция с указателем в PURE процедуре в %L"
+msgstr "THREADPRIVATE объект '%s' в SHARED клаузуле в %L"
  
  #: fortran/openmp.c:3397
  #, gcc-internal-format
@@ -55081,8 +57674,9 @@ msgstr ""
  
  #: fortran/openmp.c:3409
  #, fuzzy, gcc-internal-format
+#| msgid "collapse argument needs positive constant integer expression"
  msgid "%qs in ALIGNED clause at %L requires a scalar positive constant integer alignment expression"
-msgstr "сравнение знакового и беззнакового целых выражений"
+msgstr "collapse аргумент требует положительного константного целого выражения"
  
  #: fortran/openmp.c:3429 fortran/openmp.c:3450
  #, gcc-internal-format
@@ -55091,13 +57685,15 @@ msgstr ""
  
  #: fortran/openmp.c:3433
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Cray pointee '%s' in %s clause at %L"
  msgid "Coarrays not supported in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "Cray указуемое '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3442
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Assumed size array '%s' in %s clause at %L"
  msgid "Stride should not be specified for array section in %s clause at %L"
-msgstr ""
+msgstr "Массив предполагаемого размера '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3463
  #, gcc-internal-format
@@ -55106,39 +57702,46 @@ msgstr ""
  
  #: fortran/openmp.c:3485 fortran/openmp.c:3497
  #, fuzzy, gcc-internal-format
+#| msgid "THREADPRIVATE object '%s' in %s clause at %L"
  msgid "THREADPRIVATE object %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "THREADPRIVATE объект '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3488 fortran/openmp.c:3500
  #, fuzzy, gcc-internal-format
+#| msgid "Cray pointee '%s' in %s clause at %L"
  msgid "Cray pointee %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "Cray указуемое '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3503
  #, fuzzy, gcc-internal-format
+#| msgid "POINTER object '%s' in %s clause at %L"
  msgid "ASSOCIATE name %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "POINTER объект '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3508
  #, fuzzy, gcc-internal-format
+#| msgid "Cray pointer '%s' in %s clause at %L"
  msgid "Procedure pointer %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "Cray указатель '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3514
  #, fuzzy, gcc-internal-format
+#| msgid "Cray pointer '%s' in %s clause at %L"
  msgid "Cray pointer %qs in %s clause at %L"
-msgstr "ошибка преобразования %qT в %qT в %s"
+msgstr "Cray указатель '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3524
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' in %s clause is used in NAMELIST statement at %L"
  msgid "Variable %qs in %s clause is used in NAMELIST statement at %L"
-msgstr "Ð\92Ñ\8bÑ\85Ð¾Ð´ Ð·Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ñ\8b Ð² Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÐµ Ð¸Ð»Ð¸ Ð¾Ð±Ñ\80Ð°Ñ\89ÐµÐ½Ð¸Ð¸ Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ñ\83 Ð´Ð»Ñ\8f `%A' Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %0"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f '%s' Ð² %s ÐºÐ»Ð°Ñ\83Ð·Ñ\83Ð»Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð² NAMELIST Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %L"
  
  #. case OMP_LIST_REDUCTION:
  #: fortran/openmp.c:3534
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "POINTER object '%s' in %s clause at %L"
  msgid "INTENT(IN) POINTER %qs in %s clause at %L"
-msgstr ""
+msgstr "POINTER объект '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:3627
  #, gcc-internal-format, gfc-internal-format
@@ -55146,84 +57749,94 @@ msgid "!$OMP DECLARE REDUCTION %s not found for type %s at %L"
  msgstr ""
  
  #: fortran/openmp.c:3650
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "%s REDUCTION variable '%s' must be INTEGER at %L"
  msgid "LINEAR variable %qs must be INTEGER at %L"
-msgstr ""
+msgstr "%s REDUCTION переменная '%s' должна быть INTEGER в %L"
  
  #: fortran/openmp.c:3653
  #, fuzzy, gcc-internal-format
+#| msgid "Actual argument for '%s' must be a pointer at %L"
  msgid "LINEAR dummy argument %qs must have VALUE attribute at %L"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼ Ð² %L"
  
  #: fortran/openmp.c:3661
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "FINAL clause at %L requires a scalar LOGICAL expression"
  msgid "%qs in LINEAR clause at %L requires a scalar integer linear-step expression"
-msgstr ""
+msgstr "FINAL клаузула в %L требует скалярное LOGICAL выражение"
  
  #: fortran/openmp.c:3665
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "FINAL clause at %L requires a scalar LOGICAL expression"
  msgid "%qs in LINEAR clause at %L requires a constant integer linear-step expression"
-msgstr ""
+msgstr "FINAL клаузула в %L требует скалярное LOGICAL выражение"
  
  #: fortran/openmp.c:3709
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
  msgid "SAFELEN clause at %L requires a scalar INTEGER expression"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "NUM_THREADS клаузула в %L требует скалярное INTEGER выражение"
  
  #: fortran/openmp.c:3717
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
  msgid "SIMDLEN clause at %L requires a scalar INTEGER expression"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "NUM_THREADS клаузула в %L требует скалярное INTEGER выражение"
  
  #: fortran/openmp.c:3725
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
  msgid "NUM_TEAMS clause at %L requires a scalar INTEGER expression"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "NUM_THREADS клаузула в %L требует скалярное INTEGER выражение"
  
  #: fortran/openmp.c:3733
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
  msgid "DEVICE clause at %L requires a scalar INTEGER expression"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "NUM_THREADS клаузула в %L требует скалярное INTEGER выражение"
  
  #: fortran/openmp.c:3741
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
  msgid "DIST_SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression"
-msgstr ""
+msgstr "chunk_size SCHEDULE клаузулы в %L требует скалярное INTEGER выражение"
  
  #: fortran/openmp.c:3749
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "NUM_THREADS clause at %L requires a scalar INTEGER expression"
  msgid "THREAD_LIMIT clause at %L requires a scalar INTEGER expression"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "NUM_THREADS клаузула в %L требует скалярное INTEGER выражение"
  
  #: fortran/openmp.c:3877
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP ATOMIC statement must set a scalar variable of intrinsic type at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC оператор должен устанавливать скалярную переменную встроенного типа в %L"
  
  #: fortran/openmp.c:3902
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP ATOMIC READ statement must read from a scalar variable of intrinsic type at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC READ оператор должен читать из скалярной переменной встроенного типа в %L"
  
  #: fortran/openmp.c:3907
  #, gcc-internal-format, gfc-internal-format
  msgid "expr in !$OMP ATOMIC WRITE assignment var = expr must be scalar and cannot reference var at %L"
-msgstr ""
+msgstr "expr в !$OMP ATOMIC WRITE присваивании var = expr должно быть скалярным и не может ссылаться на var в %L"
  
  #: fortran/openmp.c:3929 fortran/openmp.c:4220
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP ATOMIC CAPTURE capture statement must read from a scalar variable of intrinsic type at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC CAPTURE capture оператор должен читать из скалярной переменной встроенного типа в %L"
  
  #: fortran/openmp.c:3944
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP ATOMIC CAPTURE update statement must set a scalar variable of intrinsic type at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC CAPTURE update оператор должен устанавливать скалярную переменную встроенного типа в %L"
  
  #: fortran/openmp.c:3951 fortran/openmp.c:4227
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP ATOMIC CAPTURE capture statement reads from different variable than update statement writes into at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC CAPTURE capture оператор читает не из той переменной в которую update оператор пишет в %L"
  
  #: fortran/openmp.c:3967
  #, gcc-internal-format, gfc-internal-format
@@ -55231,64 +57844,68 @@ msgid "!$OMP ATOMIC with ALLOCATABLE variable at %L"
  msgstr ""
  
  #: fortran/openmp.c:4009
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "!$OMP ATOMIC assignment operator must be +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
  msgid "!$OMP ATOMIC assignment operator must be binary +, *, -, /, .AND., .OR., .EQV. or .NEQV. at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC оператор присваивания должен быть +, *, -, /, .AND., .OR., .EQV. или .NEQV. в %L"
  
  #: fortran/openmp.c:4057
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP ATOMIC assignment must be var = var op expr or var = expr op var at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC присваивание должно быть var = var op expr или var = expr op var в %L"
  
  #: fortran/openmp.c:4071
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP ATOMIC var = var op expr not mathematically equivalent to var = var op (expr) at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC var = var op expr не эквивалентно математически var = var op (expr) в %L"
  
  #: fortran/openmp.c:4103
  #, gcc-internal-format, gfc-internal-format
  msgid "expr in !$OMP ATOMIC assignment var = var op expr must be scalar and cannot reference var at %L"
-msgstr ""
+msgstr "expr в !$OMP ATOMIC присваивании var = var op expr должно быть скалярным и не может ссылаться на var в %L"
  
  #: fortran/openmp.c:4127
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC присваивание встроенные IAND, IOR или IEOR должны иметь два аргумента в %L"
  
  #: fortran/openmp.c:4134
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC присваивание встроенные должны быть MIN, MAX, IAND, IOR или IEOR в %L"
  
  #: fortran/openmp.c:4151
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "!$OMP ATOMIC intrinsic arguments except one must not reference '%s' at %L"
  msgid "!$OMP ATOMIC intrinsic arguments except one must not reference %qs at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC аргументы встроенных кроме одного не должны ссылаться на '%s' в %L"
  
  #: fortran/openmp.c:4158
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC аргументы встроенных должны быть скалярами в %L"
  
  #: fortran/openmp.c:4166
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "First or last !$OMP ATOMIC intrinsic argument must be '%s' at %L"
  msgid "First or last !$OMP ATOMIC intrinsic argument must be %qs at %L"
-msgstr ""
+msgstr "Первый или последний !$OMP ATOMIC аргумент встроенных должен быть '%s' в %L"
  
  #: fortran/openmp.c:4184
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP ATOMIC assignment must have an operator or intrinsic on right hand side at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC присваивание должно иметь оператор или встроенную в правой части в %L"
  
  #: fortran/openmp.c:4198
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP ATOMIC CAPTURE capture statement must set a scalar variable of intrinsic type at %L"
-msgstr ""
+msgstr "!$OMP ATOMIC CAPTURE capture оператор должен устанавливать скалярную переменную встроенного типа в %L"
  
  #: fortran/openmp.c:4475
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "!$OMP DO cannot be a DO WHILE or DO without loop control at %L"
  msgid "%s cannot be a DO WHILE or DO without loop control at %L"
-msgstr ""
+msgstr "!$OMP DO не может быть DO WHILE или DO без управления циклом в %L"
  
  #: fortran/openmp.c:4481
  #, gcc-internal-format, gfc-internal-format
@@ -55297,43 +57914,51 @@ msgstr ""
  
  #: fortran/openmp.c:4487
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "!$OMP DO iteration variable must be of type integer at %L"
  msgid "%s iteration variable must be of type integer at %L"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "!$OMP DO итерационная переменная должна быть типа integer в %L"
  
  #: fortran/openmp.c:4491
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "!$OMP DO iteration variable must not be THREADPRIVATE at %L"
  msgid "%s iteration variable must not be THREADPRIVATE at %L"
-msgstr ""
+msgstr "!$OMP DO итерационная переменная не должна быть THREADPRIVATE в %L"
  
  #: fortran/openmp.c:4504
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "!$OMP DO iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
  msgid "%s iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
-msgstr ""
+msgstr "!$OMP DO итерационная переменная присутствует в клаузуле отличной от PRIVATE и LASTPRIVATE в %L"
  
  #: fortran/openmp.c:4508
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "!$OMP DO iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
  msgid "%s iteration variable present on clause other than LASTPRIVATE at %L"
-msgstr ""
+msgstr "!$OMP DO итерационная переменная присутствует в клаузуле отличной от PRIVATE и LASTPRIVATE в %L"
  
  #: fortran/openmp.c:4512
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "!$OMP DO iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L"
  msgid "%s iteration variable present on clause other than LINEAR at %L"
-msgstr ""
+msgstr "!$OMP DO итерационная переменная присутствует в клаузуле отличной от PRIVATE и LASTPRIVATE в %L"
  
  #: fortran/openmp.c:4530
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "!$OMP DO collapsed loops don't form rectangular iteration space at %L"
  msgid "%s collapsed loops don't form rectangular iteration space at %L"
-msgstr ""
+msgstr "!$OMP DO сжатые циклы не образуют прямоугольное итерационное пространство в %L"
  
  #: fortran/openmp.c:4544
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "collapsed !$OMP DO loops not perfectly nested at %L"
  msgid "collapsed %s loops not perfectly nested at %L"
-msgstr ""
+msgstr "сжатые !$OMP DO циклы не вполне вложены в %L"
  
  #: fortran/openmp.c:4553 fortran/openmp.c:4561
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "not enough DO loops for collapsed !$OMP DO at %L"
  msgid "not enough DO loops for collapsed %s at %L"
-msgstr "Ð½ÐµÐ´Ð¾Ñ\81Ñ\82Ð°Ñ\82Ð¾Ñ\87Ð½Ð°Ñ\8f Ð¸Ð½Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\86Ð¸Ñ\8f Ð¾ Ñ\82Ð¸Ð¿Ðµ"
+msgstr "Ð½ÐµÐ´Ð¾Ñ\81Ñ\82Ð°Ñ\82Ð¾Ñ\87Ð½Ð¾ DO Ñ\86Ð¸ÐºÐ»Ð¾Ð² Ð´Ð»Ñ\8f Ñ\81Ð¶Ð°Ñ\82Ð¾Ð³Ð¾ !$OMP DO Ð² %L"
  
  #: fortran/openmp.c:4645 fortran/openmp.c:4658
  #, gcc-internal-format, gfc-internal-format
@@ -55341,29 +57966,34 @@ msgid "The %s directive cannot be specified within a %s region at %L"
  msgstr ""
  
  #: fortran/openmp.c:4677
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "!$OMP DO cannot be a DO WHILE or DO without loop control at %L"
  msgid "!$ACC LOOP cannot be a DO WHILE or DO without loop control at %L"
-msgstr ""
+msgstr "!$OMP DO не может быть DO WHILE или DO без управления циклом в %L"
  
  #: fortran/openmp.c:4683
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "!$OMP DO iteration variable must be of type integer at %L"
  msgid "!$ACC LOOP iteration variable must be of type integer at %L"
-msgstr ""
+msgstr "!$OMP DO итерационная переменная должна быть типа integer в %L"
  
  #: fortran/openmp.c:4699
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "!$OMP DO collapsed loops don't form rectangular iteration space at %L"
  msgid "!$ACC LOOP %s loops don't form rectangular iteration space at %L"
-msgstr ""
+msgstr "!$OMP DO сжатые циклы не образуют прямоугольное итерационное пространство в %L"
  
  #: fortran/openmp.c:4713
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "collapsed !$OMP DO loops not perfectly nested at %L"
  msgid "%s !$ACC LOOP loops not perfectly nested at %L"
-msgstr ""
+msgstr "сжатые !$OMP DO циклы не вполне вложены в %L"
  
  #: fortran/openmp.c:4723 fortran/openmp.c:4732
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "not enough DO loops for collapsed !$OMP DO at %L"
  msgid "not enough DO loops for %s !$ACC LOOP at %L"
-msgstr ""
+msgstr "недостаточно DO циклов для сжатого !$OMP DO в %L"
  
  #: fortran/openmp.c:4747 fortran/openmp.c:4754
  #, gcc-internal-format, gfc-internal-format
@@ -55396,44 +58026,52 @@ msgid "Loop parallelized across vectors is not allowed inside another loop paral
  msgstr ""
  
  #: fortran/openmp.c:4813
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "INTENT (%s) conflicts with INTENT(%s) at %L"
  msgid "Clause SEQ conflicts with INDEPENDENT at %L"
-msgstr ""
+msgstr "INTENT (%s)  конфликтует с INTENT(%s) в %L"
  
  #: fortran/openmp.c:4815
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%s attribute conflicts with %s attribute at %L"
  msgid "Clause SEQ conflicts with GANG at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%s атрибут конфликтует с %s атрибутом в %L"
  
  #: fortran/openmp.c:4817
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "MOLD tag at %L conflicts with SOURCE tag at %L"
  msgid "Clause SEQ conflicts with WORKER at %L"
-msgstr ""
+msgstr "MOLD тег в %L конфликтует с SOURCE тегом в %L"
  
  #: fortran/openmp.c:4819
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "MOLD tag at %L conflicts with SOURCE tag at %L"
  msgid "Clause SEQ conflicts with VECTOR at %L"
-msgstr ""
+msgstr "MOLD тег в %L конфликтует с SOURCE тегом в %L"
  
  #: fortran/openmp.c:4821
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "MOLD tag at %L conflicts with SOURCE tag at %L"
  msgid "Clause SEQ conflicts with AUTO at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "MOLD тег в %L конфликтует с SOURCE тегом в %L"
  
  #: fortran/openmp.c:4826
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%s attribute conflicts with %s attribute at %L"
  msgid "Clause AUTO conflicts with GANG at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%s атрибут конфликтует с %s атрибутом в %L"
  
  #: fortran/openmp.c:4828
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "MOLD tag at %L conflicts with SOURCE tag at %L"
  msgid "Clause AUTO conflicts with WORKER at %L"
-msgstr ""
+msgstr "MOLD тег в %L конфликтует с SOURCE тегом в %L"
  
  #: fortran/openmp.c:4830
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "MOLD tag at %L conflicts with SOURCE tag at %L"
  msgid "Clause AUTO conflicts with VECTOR at %L"
-msgstr ""
+msgstr "MOLD тег в %L конфликтует с SOURCE тегом в %L"
  
  #: fortran/openmp.c:4834
  #, gcc-internal-format, gfc-internal-format
@@ -55442,18 +58080,21 @@ msgstr ""
  
  #: fortran/openmp.c:4869
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%qE is not a constant expression"
  msgid "TILE requires constant expression at %L"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "%qE не есть константное выражение"
  
  #: fortran/openmp.c:4934
  #, fuzzy, gcc-internal-format
+#| msgid "POINTER object '%s' in %s clause at %L"
  msgid "PARAMETER object %qs is not allowed at %L"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "POINTER объект '%s' в %s клаузуле в %L"
  
  #: fortran/openmp.c:4941
  #, fuzzy, gcc-internal-format
+#| msgid "Array section not permitted in '%s' call at %L"
  msgid "Array sections: %qs not allowed in $!ACC DECLARE at %L"
-msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+msgstr "Ð¡ÐµÐºÑ\86Ð¸Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\80Ð°Ð·Ñ\80ÐµÑ\88ÐµÐ½Ð° Ð² '%s' Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ð² %L"
  
  #: fortran/openmp.c:5060
  #, gcc-internal-format, gfc-internal-format
@@ -55508,447 +58149,488 @@ msgstr ""
  #: fortran/options.c:202
  #, gcc-internal-format
  msgid "-fexcess-precision=standard for Fortran"
-msgstr ""
+msgstr "-fexcess-precision=standard для Fortran"
  
  #: fortran/options.c:289
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Reading file '%s' as free form"
  msgid "Reading file %qs as free form"
-msgstr ""
+msgstr "Чтение файла '%s' как свободной формы"
  
  #: fortran/options.c:299
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'-fd-lines-as-comments' has no effect in free form"
  msgid "%<-fd-lines-as-comments%> has no effect in free form"
-msgstr ""
+msgstr "'-fd-lines-as-comments' не действует в свободной форме"
  
  #: fortran/options.c:302
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'-fd-lines-as-code' has no effect in free form"
  msgid "%<-fd-lines-as-code%> has no effect in free form"
-msgstr ""
+msgstr "'-fd-lines-as-code' не действует в свободной форме"
  
  #: fortran/options.c:333
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Flag -fno-automatic overwrites -fmax-stack-var-size=%d"
  msgid "Flag %<-fno-automatic%> overwrites %<-fmax-stack-var-size=%d%>"
-msgstr ""
+msgstr "Флаг -fno-automatic перебивает -fmax-stack-var-size=%d"
  
  #: fortran/options.c:336
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Flag -fno-automatic overwrites -frecursive"
  msgid "Flag %<-fno-automatic%> overwrites %<-frecursive%>"
-msgstr ""
+msgstr "Флаг -fno-automatic перебивает -frecursive"
  
  #: fortran/options.c:338
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Flag -fno-automatic overwrites -frecursive implied by -fopenmp"
  msgid "Flag %<-fno-automatic%> overwrites %<-frecursive%> implied by %<-fopenmp%>"
-msgstr ""
+msgstr "Флаг -fno-automatic перебивает -frecursive следующий из -fopenmp"
  
  #: fortran/options.c:341
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Flag -frecursive overwrites -fmax-stack-var-size=%d"
  msgid "Flag %<-frecursive%> overwrites %<-fmax-stack-var-size=%d%>"
-msgstr ""
+msgstr "Флаг -frecursive перебивает -fmax-stack-var-size=%d"
  
  #: fortran/options.c:344
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Flag -fmax-stack-var-size=%d overwrites -frecursive implied by -fopenmp"
  msgid "Flag %<-fmax-stack-var-size=%d%> overwrites %<-frecursive%> implied by %<-fopenmp%>"
-msgstr ""
+msgstr "Флаг -fmax-stack-var-size=%d перебивает -frecursive следующий из -fopenmp"
  
  #: fortran/options.c:381
  #, fuzzy, gcc-internal-format
+#| msgid "Fixed line length must be at least seven."
  msgid "Fixed line length must be at least seven"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¤Ð¸ÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð°Ñ\8f Ð´Ð»Ð¸Ð½Ð° Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð½Ðµ Ð¼ÐµÐ½ÐµÐµ Ñ\81ÐµÐ¼Ð¸."
  
  #: fortran/options.c:384
  #, fuzzy, gcc-internal-format
+#| msgid "Free line length must be at least three."
  msgid "Free line length must be at least three"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¡Ð²Ð¾Ð±Ð¾Ð´Ð½Ð°Ñ\8f Ð´Ð»Ð¸Ð½Ð° Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð½Ðµ Ð¼ÐµÐ½ÐµÐµ Ñ\82Ñ\80ÐµÑ\85."
  
  #: fortran/options.c:387
  #, gcc-internal-format, gfc-internal-format
  msgid "Maximum subrecord length cannot exceed %d"
-msgstr ""
+msgstr "Максимальная длина подзаписи не может превышать %d"
  
  #: fortran/options.c:406
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfortran: Only one -J option allowed"
  msgid "gfortran: Only one %<-J%> option allowed"
-msgstr ""
+msgstr "gfortran: Только одна -J опция допустима"
  
  #: fortran/options.c:478
  #, fuzzy, gcc-internal-format
+#| msgid "Argument to -ffpe-trap is not valid: %s"
  msgid "Argument to %<-ffpe-trap%> is not valid: %s"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f -ffpe-trap Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½: %s"
  
  #: fortran/options.c:480
  #, fuzzy, gcc-internal-format
+#| msgid "Argument to -ffpe-trap is not valid: %s"
  msgid "Argument to %<-ffpe-summary%> is not valid: %s"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f -ffpe-trap Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½: %s"
  
  #: fortran/options.c:529
  #, fuzzy, gcc-internal-format
+#| msgid "Argument to -fcheck is not valid: %s"
  msgid "Argument to %<-fcheck%> is not valid: %s"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f -fcheck Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½: %s"
  
  #: fortran/options.c:578
  #, fuzzy, gcc-internal-format
+#| msgid "-static-libgfortran is not supported in this configuration"
  msgid "%<-static-libgfortran%> is not supported in this configuration"
-msgstr "-m%s в данной конфигурации не поддерживается"
+msgstr "-static-libgfortran не поддерживается в этой конфигурации"
  
  #: fortran/options.c:601
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Maximum supported identifier length is %d"
-msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80"
+msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð°Ñ\8f Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ð°Ñ\8f Ð´Ð»Ð¸Ð½Ð° Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð° ÐµÑ\81Ñ\82Ñ\8c %d"
  
  #: fortran/options.c:621
  #, fuzzy, gcc-internal-format
+#| msgid "Unrecognized option to -finit-logical: %s"
  msgid "Unrecognized option to %<-finit-logical%>: %s"
-msgstr "Ð½ÐµÐ¾Ð¿Ð¾Ð·Ð½Ð°Ð½Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 '-%s'"
+msgstr "Ð\9dÐµÐ¾Ð¿Ð¾Ð·Ð½Ð°Ð½Ð½Ð°Ñ\8f Ð¾Ð¿Ñ\86Ð¸Ñ\8f Ð´Ð»Ñ\8f -finit-logical: %s"
  
  #: fortran/options.c:637
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The value of n in -finit-character=n must be between 0 and 127"
  msgid "The value of n in %<-finit-character=n%> must be between 0 and 127"
-msgstr ""
+msgstr "Значение n в -finit-character=n должно быть между 0 и 127"
  
  #: fortran/parse.c:579
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unclassifiable statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐºÐ»Ð°Ñ\81Ñ\81Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ñ\83ÐµÐ¼Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/parse.c:623
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "OpenMP directives at %C may not appear in PURE or ELEMENTAL procedures"
  msgid "OpenACC directives at %C may not appear in PURE procedures"
-msgstr "оператор SAVE или атрибут в %1 несовместим с оператором SAVE или атрибутом в %0"
+msgstr "OpenMP директивы в %C не могут появляться в PURE или ELEMENTAL процедурах"
  
  #: fortran/parse.c:692
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unclassifiable OpenMP directive at %C"
  msgid "Unclassifiable OpenACC directive at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐºÐ»Ð°Ñ\81Ñ\81Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ñ\83ÐµÐ¼Ð°Ñ\8f OpenMP Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð² %C"
  
  #: fortran/parse.c:715
  #, gcc-internal-format, gfc-internal-format
  msgid "OpenMP directives at %C may not appear in PURE or ELEMENTAL procedures"
-msgstr ""
+msgstr "OpenMP директивы в %C не могут появляться в PURE или ELEMENTAL процедурах"
  
  #: fortran/parse.c:890
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unclassifiable OpenMP directive at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐºÐ»Ð°Ñ\81Ñ\81Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ñ\83ÐµÐ¼Ð°Ñ\8f OpenMP Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð² %C"
  
  #: fortran/parse.c:917
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unclassifiable GCC directive at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9dÐµÐºÐ»Ð°Ñ\81Ñ\81Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ñ\83ÐµÐ¼Ð°Ñ\8f GCC Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð² %C"
  
  #: fortran/parse.c:976 fortran/parse.c:1208
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Zero is not a valid statement label at %C"
-msgstr "%qE не является корректным аргументом шаблона"
+msgstr "Ноль не является корректной меткой оператора в %C"
  
  #: fortran/parse.c:983 fortran/parse.c:1200
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Non-numeric character in statement label at %C"
-msgstr "Не цифра в %0 в поле метки [info -f g77 M LEX]"
+msgstr "Нечисловой символ в метке оператора в %C"
  
  #: fortran/parse.c:995 fortran/parse.c:1249
  #, gcc-internal-format, gfc-internal-format
  msgid "Semicolon at %C needs to be preceded by statement"
-msgstr ""
+msgstr "Точке с запятой в %C должен предшествовать оператор"
  
  #: fortran/parse.c:1003 fortran/parse.c:1264
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Ignoring statement label in empty statement at %L"
-msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½ Ð² ÐºÐ¾Ð½Ñ\82ÐµÐºÑ\81Ñ\82Ðµ, Ñ\83Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð½Ð¾Ð¼ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð¼ Ð² %1"
+msgstr "Ð\98Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¼ÐµÑ\82ÐºÐ¸ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² Ð¿Ñ\83Ñ\81Ñ\82Ð¾Ð¼ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %L"
  
  #: fortran/parse.c:1070 fortran/parse.c:1251
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Fortran 2008: Semicolon at %C without preceding statement"
-msgstr "Недопустимое число в операторе FORMAT в %0"
+msgstr "Fortran 2008: Точка с запятой в %C без предшествующего оператора"
  
  #: fortran/parse.c:1093 fortran/parse.c:1227
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Bad continuation line at %C"
-msgstr "Ð\98Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¿Ñ\83Ñ\81Ñ\82Ð¾Ð³Ð¾ Ð¾Ð±Ñ\89ÐµÐ³Ð¾ Ð±Ð»Ð¾ÐºÐ° Ð² %0"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ° Ð¿Ñ\80Ð¾Ð´Ð¾Ð»Ð¶ÐµÐ½Ð¸Ñ\8f Ð² %C"
  
  #: fortran/parse.c:1514
  #, gcc-internal-format, gfc-internal-format
  msgid "FORMAT statement at %L does not have a statement label"
-msgstr ""
+msgstr "FORMAT оператор в %L не имеет метки оператора"
  
  #: fortran/parse.c:2194
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "gfc_ascii_statement(): Bad statement code"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: fortran/parse.c:2339
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected %s statement at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ %s Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/parse.c:2485
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s statement at %C cannot follow %s statement at %L"
-msgstr "Оператор в %0 некорректен в контексте, установленном оператором в %1"
+msgstr "%s оператор в %C не может следовать за %s оператором в %L"
  
  #: fortran/parse.c:2502
  #, fuzzy, gcc-internal-format
+#| msgid "Unexpected end of file in '%s'"
  msgid "Unexpected end of file in %qs"
-msgstr "Неожиданное окончание строки формата"
+msgstr "Неожиданный конец файла в '%s'"
  
  #: fortran/parse.c:2534
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Derived-type '%s' with SEQUENCE must not have a CONTAINS section at %C"
  msgid "Derived-type %qs with SEQUENCE must not have a CONTAINS section at %C"
-msgstr ""
+msgstr "Производный тип '%s' с SEQUENCE не должен иметь CONTAINS секцию в %C"
  
  #: fortran/parse.c:2537
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Derived-type '%s' with BIND(C) must not have a CONTAINS section at %C"
  msgid "Derived-type %qs with BIND(C) must not have a CONTAINS section at %C"
-msgstr ""
+msgstr "Производный тип '%s' с BIND(C)  не должен иметь CONTAINS секцию в %C"
  
  #: fortran/parse.c:2557
  #, gcc-internal-format, gfc-internal-format
  msgid "Components in TYPE at %C must precede CONTAINS"
-msgstr ""
+msgstr "Компоненты в TYPE в %C должны предшествовать CONTAINS"
  
  #: fortran/parse.c:2561
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003:  Type-bound procedure at %C"
  msgid "Type-bound procedure at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003:  Type-bound процедура в %C"
  
  #: fortran/parse.c:2569
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Junk after GENERIC binding at %C"
  msgid "GENERIC binding at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9cÑ\83Ñ\81Ð¾Ñ\80 Ð¿Ð¾Ñ\81Ð»Ðµ GENERIC Ñ\81Ð²Ñ\8fÐ·Ñ\8bÐ²Ð°Ð½Ð¸Ñ\8f Ð² %C"
  
  #: fortran/parse.c:2577
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003:  FINAL procedure declaration at %C"
  msgid "FINAL procedure declaration at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003:  FINAL декларация процедуры в %C"
  
  #: fortran/parse.c:2589
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: Derived type definition at %C with empty CONTAINS section"
  msgid "Derived type definition at %C with empty CONTAINS section"
-msgstr ""
+msgstr "Fortran 2008: Определение производного типа в %C с пустой CONTAINS секцией"
  
  #: fortran/parse.c:2599 fortran/parse.c:2702
  #, gcc-internal-format, gfc-internal-format
  msgid "PRIVATE statement in TYPE at %C must be inside a MODULE"
-msgstr ""
+msgstr "PRIVATE оператор в TYPE в %C должен быть внутри MODULE"
  
  #: fortran/parse.c:2606
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "PRIVATE statement at %C must precede procedure bindings"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "PRIVATE оператор в %C должен предшествовать связываниям процедур"
  
  #: fortran/parse.c:2613 fortran/parse.c:2715
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate PRIVATE statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ PRIVATE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/parse.c:2623
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "SEQUENCE statement at %C must precede CONTAINS"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "SEQUENCE оператор в %C должен предшествовать CONTAINS"
  
  #: fortran/parse.c:2627
  #, gcc-internal-format, gfc-internal-format
  msgid "Already inside a CONTAINS block at %C"
-msgstr ""
+msgstr "Уже внутри CONTAINS блока в %C"
  
  #: fortran/parse.c:2685
  #, gcc-internal-format, gfc-internal-format
  msgid "FINAL declaration at %C must be inside CONTAINS"
-msgstr ""
+msgstr "FINAL декларация в %C должна быть внутри CONTAINS"
  
  #: fortran/parse.c:2693
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: Derived type definition at %C without components"
  msgid "Derived type definition at %C without components"
-msgstr ""
+msgstr "Fortran 2003: Определение производного типа в %C без компонентов"
  
  #: fortran/parse.c:2709
  #, gcc-internal-format, gfc-internal-format
  msgid "PRIVATE statement at %C must precede structure components"
-msgstr ""
+msgstr "PRIVATE оператор в %C должен предшествовать компонентам структуры"
  
  #: fortran/parse.c:2726
  #, gcc-internal-format, gfc-internal-format
  msgid "SEQUENCE statement at %C must precede structure components"
-msgstr ""
+msgstr "SEQUENCE оператор в %C должен предшествовать компонентам структуры"
  
  #: fortran/parse.c:2732
  #, gcc-internal-format, gfc-internal-format
  msgid "SEQUENCE attribute at %C already specified in TYPE statement"
-msgstr ""
+msgstr "SEQUENCE атрибут в %C уже специфицирован в TYPE операторе"
  
  #: fortran/parse.c:2737
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate SEQUENCE statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\9fÐ¾Ð²Ñ\82Ð¾Ñ\80Ð½Ñ\8bÐ¹ SEQUENCE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/parse.c:2747
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003:  CONTAINS block in derived type definition at %C"
  msgid "CONTAINS block in derived type definition at %C"
-msgstr ""
+msgstr "Fortran 2003:  CONTAINS блок определении производного типа в %C"
  
  #: fortran/parse.c:2852
  #, gcc-internal-format, gfc-internal-format
  msgid "Component %s at %L of type LOCK_TYPE must have a codimension or be a subcomponent of a coarray, which is not possible as the component has the pointer attribute"
-msgstr ""
+msgstr "Компонент %s в %L типа LOCK_TYPE должен иметь коизмерение или быть подкомпонентом комассива, что невозможно поскольку компонент имеет pointer атрибут"
  
  #: fortran/parse.c:2858
  #, gcc-internal-format, gfc-internal-format
  msgid "Pointer component %s at %L has a noncoarray subcomponent of type LOCK_TYPE, which must have a codimension or be a subcomponent of a coarray"
-msgstr ""
+msgstr "Pointer компонент %s в %L имеет некомассивный подкомпонент типа LOCK_TYPE, который должен иметь коизмерение или быть подкомпонентом комассива"
  
  #: fortran/parse.c:2863
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Allocatable component %s at %L of type LOCK_TYPE must have a codimension"
-msgstr "Ð¿Ñ\80ÐµÐ´Ð¸ÐºÐ°Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð¾Ð¼"
+msgstr "Ð Ð°Ð·Ð¼ÐµÑ\89Ð°ÐµÐ¼Ñ\8bÐ¹ ÐºÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 %s Ð² %L Ñ\82Ð¸Ð¿Ð° LOCK_TYPE Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c ÐºÐ¾Ð¸Ð·Ð¼ÐµÑ\80ÐµÐ½Ð¸Ðµ"
  
  #: fortran/parse.c:2867
  #, gcc-internal-format, gfc-internal-format
  msgid "Allocatable component %s at %L must have a codimension as it has a noncoarray subcomponent of type LOCK_TYPE"
-msgstr ""
+msgstr "Размещаемый компонент %s в %L должен иметь коизмерение поскольку он имеет некомассивный подкомпонент типа LOCK_TYPE"
  
  #: fortran/parse.c:2872
  #, gcc-internal-format, gfc-internal-format
  msgid "Noncoarray component %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as already a coarray subcomponent exists)"
-msgstr ""
+msgstr "Некомассивный компонент %s в %L типа LOCK_TYPE или с подкомпонентом типа LOCK_TYPE должен иметь коизмерение или быть подкомпонентом комассива. (Переменные типа %s не могут иметь коизмерение поскольку уже существует комассивный подкомпонент)"
  
  #: fortran/parse.c:2879
  #, gcc-internal-format, gfc-internal-format
  msgid "Noncoarray component %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as %s at %L has a codimension or a coarray subcomponent)"
-msgstr ""
+msgstr "Некомассивный компонент %s в %L типа LOCK_TYPE или с подкомпонентом типа LOCK_TYPE должен иметь коизмерение или быть подкомпонентом комассива. (Переменные типа %s не могут иметь коизмерение поскольку %s в %L имеет коизмерение или комассивный подкомпонент)"
  
  #: fortran/parse.c:2889
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Component %s at %L of type LOCK_TYPE must have a codimension or be a subcomponent of a coarray, which is not possible as the component has the pointer attribute"
  msgid "Component %s at %L of type EVENT_TYPE must have a codimension or be a subcomponent of a coarray, which is not possible as the component has the pointer attribute"
-msgstr ""
+msgstr "Компонент %s в %L типа LOCK_TYPE должен иметь коизмерение или быть подкомпонентом комассива, что невозможно поскольку компонент имеет pointer атрибут"
  
  #: fortran/parse.c:2895
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Pointer component %s at %L has a noncoarray subcomponent of type LOCK_TYPE, which must have a codimension or be a subcomponent of a coarray"
  msgid "Pointer component %s at %L has a noncoarray subcomponent of type EVENT_TYPE, which must have a codimension or be a subcomponent of a coarray"
-msgstr ""
+msgstr "Pointer компонент %s в %L имеет некомассивный подкомпонент типа LOCK_TYPE, который должен иметь коизмерение или быть подкомпонентом комассива"
  
  #: fortran/parse.c:2900
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Allocatable component %s at %L of type LOCK_TYPE must have a codimension"
  msgid "Allocatable component %s at %L of type EVENT_TYPE must have a codimension"
-msgstr "Ð¿Ñ\80ÐµÐ´Ð¸ÐºÐ°Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð¾Ð¼"
+msgstr "Ð Ð°Ð·Ð¼ÐµÑ\89Ð°ÐµÐ¼Ñ\8bÐ¹ ÐºÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 %s Ð² %L Ñ\82Ð¸Ð¿Ð° LOCK_TYPE Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c ÐºÐ¾Ð¸Ð·Ð¼ÐµÑ\80ÐµÐ½Ð¸Ðµ"
  
  #: fortran/parse.c:2904
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Allocatable component %s at %L must have a codimension as it has a noncoarray subcomponent of type LOCK_TYPE"
  msgid "Allocatable component %s at %L must have a codimension as it has a noncoarray subcomponent of type EVENT_TYPE"
-msgstr ""
+msgstr "Размещаемый компонент %s в %L должен иметь коизмерение поскольку он имеет некомассивный подкомпонент типа LOCK_TYPE"
  
  #: fortran/parse.c:2909
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Noncoarray component %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as already a coarray subcomponent exists)"
  msgid "Noncoarray component %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as already a coarray subcomponent exists)"
-msgstr ""
+msgstr "Некомассивный компонент %s в %L типа LOCK_TYPE или с подкомпонентом типа LOCK_TYPE должен иметь коизмерение или быть подкомпонентом комассива. (Переменные типа %s не могут иметь коизмерение поскольку уже существует комассивный подкомпонент)"
  
  #: fortran/parse.c:2916
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Noncoarray component %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as %s at %L has a codimension or a coarray subcomponent)"
  msgid "Noncoarray component %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as %s at %L has a codimension or a coarray subcomponent)"
-msgstr ""
+msgstr "Некомассивный компонент %s в %L типа LOCK_TYPE или с подкомпонентом типа LOCK_TYPE должен иметь коизмерение или быть подкомпонентом комассива. (Переменные типа %s не могут иметь коизмерение поскольку %s в %L имеет коизмерение или комассивный подкомпонент)"
  
  #: fortran/parse.c:2968
  #, gcc-internal-format, gfc-internal-format
  msgid "ENUM declaration at %C has no ENUMERATORS"
-msgstr ""
+msgstr "ENUM декларация в %C не имеет ENUMERATORS"
  
  #: fortran/parse.c:3055
  #, gcc-internal-format, gfc-internal-format
  msgid "Unexpected %s statement in INTERFACE block at %C"
-msgstr ""
+msgstr "Неожиданный %s оператор в INTERFACE блоке в %C"
  
  #: fortran/parse.c:3079
  #, fuzzy, gcc-internal-format
+#| msgid "Name '%s' of ABSTRACT INTERFACE at %C cannot be the same as an intrinsic type"
  msgid "Name %qs of ABSTRACT INTERFACE at %C cannot be the same as an intrinsic type"
-msgstr "Имя типа в %0 не совпадает с именем, заданным в %1"
+msgstr "Имя '%s' от ABSTRACT INTERFACE в %C не может совпадать со встроенным типом"
  
  #: fortran/parse.c:3113
  #, gcc-internal-format, gfc-internal-format
  msgid "Unexpected %s statement at %C in INTERFACE body"
-msgstr ""
+msgstr "Неожиданный %s оператор в %C в INTERFACE теле"
  
  #: fortran/parse.c:3131
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "INTERFACE procedure '%s' at %L has the same name as the enclosing procedure"
  msgid "INTERFACE procedure %qs at %L has the same name as the enclosing procedure"
-msgstr ""
+msgstr "INTERFACE процедура '%s' в %L имеет то же имя что и объемлющая процедура"
  
  #: fortran/parse.c:3261
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s statement is not allowed inside of BLOCK at %C"
-msgstr "Оператор в %0 некорректен в программной единице BLOCK DATA в %1"
+msgstr "%s оператор не допускается внутри BLOCK в %C"
  
  #: fortran/parse.c:3291
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%s statement is not allowed inside of BLOCK at %C"
  msgid "%s statement is not allowed inside of BLOCK DATA at %C"
-msgstr "Оператор в %0 некорректен в программной единице BLOCK DATA в %1"
+msgstr "%s оператор не допускается внутри BLOCK в %C"
  
  #: fortran/parse.c:3375
  #, gcc-internal-format, gfc-internal-format
  msgid "%s statement must appear in a MODULE"
-msgstr ""
+msgstr "%s оператор должен появляться в MODULE"
  
  #: fortran/parse.c:3383
  #, gcc-internal-format, gfc-internal-format
  msgid "%s statement at %C follows another accessibility specification"
-msgstr ""
+msgstr "%s оператор в %C следует за другой спецификацией доступности"
  
  #: fortran/parse.c:3435
  #, fuzzy, gcc-internal-format
+#| msgid "Bad kind expression for function '%s' at %L"
  msgid "Bad kind expression for function %qs at %L"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°Ñ\85 spec-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s'"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð²Ð¸Ð´Ð° Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s' Ð² %L"
  
  #: fortran/parse.c:3439
  #, fuzzy, gcc-internal-format
+#| msgid "The type for function '%s' at %L is not accessible"
  msgid "The type for function %qs at %L is not accessible"
-msgstr "Ð\90Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð¢Ð¸Ð¿ Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s' Ð² %L Ð½ÐµÐ´Ð¾Ñ\81Ñ\82Ñ\83Ð¿ÐµÐ½"
  
  #: fortran/parse.c:3499
  #, gcc-internal-format, gfc-internal-format
  msgid "ELSEWHERE statement at %C follows previous unmasked ELSEWHERE"
-msgstr ""
+msgstr "ELSEWHERE оператор в %C следует за предыдущим немаскированным ELSEWHERE"
  
  #: fortran/parse.c:3521
  #, gcc-internal-format, gfc-internal-format
  msgid "Unexpected %s statement in WHERE block at %C"
-msgstr ""
+msgstr "Неожиданный %s оператор в WHERE блоке в %C"
  
  #: fortran/parse.c:3580
  #, gcc-internal-format, gfc-internal-format
  msgid "Unexpected %s statement in FORALL block at %C"
-msgstr ""
+msgstr "Неожиданный %s оператор в FORALL блоке в %C"
  
  #: fortran/parse.c:3631
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "ELSE IF statement at %C cannot follow ELSE statement at %L"
-msgstr "оператор PUBLIC или PRIVATE в %1 несовместим с оператором PUBLIC или PRIVATE в %0"
+msgstr "ELSE IF оператор в %C не может следовать за ELSE оператором в %L"
  
  #: fortran/parse.c:3649
  #, gcc-internal-format, gfc-internal-format
  msgid "Duplicate ELSE statements at %L and %C"
-msgstr ""
+msgstr "Повторные ELSE операторы в %L и %C"
  
  #: fortran/parse.c:3710
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected a CASE or END SELECT statement following SELECT CASE at %C"
-msgstr ""
+msgstr "Ожидался CASE или END SELECT оператор следующий за SELECT CASE в %C"
  
  #: fortran/parse.c:3793
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected TYPE IS, CLASS IS or END SELECT statement following SELECT TYPE at %C"
-msgstr ""
+msgstr "Ожидался TYPE IS, CLASS IS  или END SELECT оператор следующий за SELECT TYPE в %C"
  
  #: fortran/parse.c:3855
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
  msgid "Variable %qs at %C cannot be redefined inside loop beginning at %L"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 SAVE Ð¸Ð»Ð¸ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ð² %1 Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð¼ SAVE Ð¸Ð»Ð¸ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð¼ Ð² %0"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f '%s' Ð² %C Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¿ÐµÑ\80ÐµÐ¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð° Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\86Ð¸ÐºÐ»Ð° Ð½Ð°Ñ\87Ð¸Ð½Ð°Ñ\8eÑ\89ÐµÐ³Ð¾Ñ\81Ñ\8f Ð² %L"
  
  #: fortran/parse.c:3888
  #, gcc-internal-format, gfc-internal-format
  msgid "End of nonblock DO statement at %C is within another block"
-msgstr ""
+msgstr "Конец неблочного DO оператора в %C находится внутри другого блока"
  
  #: fortran/parse.c:3898
  #, gcc-internal-format, gfc-internal-format
  msgid "End of nonblock DO statement at %C is interwoven with another DO loop"
-msgstr ""
+msgstr "Конец неблочного DO оператора в %C перекрывается с другим DO циклом"
  
  #: fortran/parse.c:3924
  #, gcc-internal-format, gfc-internal-format
@@ -55956,89 +58638,99 @@ msgid "CRITICAL block inside of OpenACC region at %C"
  msgstr ""
  
  #: fortran/parse.c:3951
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Statement label in END CRITICAL at %C does not match CRITIAL label"
  msgid "Statement label in END CRITICAL at %C does not match CRITICAL label"
-msgstr ""
+msgstr "Метка оператора в END CRITICAL в %C не соответствует CRITIAL метке"
  
  #: fortran/parse.c:4020
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: BLOCK construct at %C"
  msgid "BLOCK construct at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: BLOCK конструкция в %C"
  
  #: fortran/parse.c:4054
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: ASSOCIATE construct at %C"
  msgid "ASSOCIATE construct at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: ASSOCIATE конструкция в %C"
  
  #: fortran/parse.c:4235
  #, gcc-internal-format, gfc-internal-format
  msgid "Statement label in ENDDO at %C doesn't match DO label"
-msgstr ""
+msgstr "Метка оператора в ENDDO в %C не соответствует DO метке"
  
  #: fortran/parse.c:4251
  #, gcc-internal-format, gfc-internal-format
  msgid "Named block DO at %L requires matching ENDDO name"
-msgstr ""
+msgstr "Именованный блок DO в %L требует соответствующего ENDDO имени"
  
  #: fortran/parse.c:4432
  #, gcc-internal-format, gfc-internal-format
  msgid "Missing !$OMP END ATOMIC after !$OMP ATOMIC CAPTURE at %C"
-msgstr ""
+msgstr "Отсутствует !$OMP END ATOMIC после !$OMP ATOMIC CAPTURE в %C"
  
  #: fortran/parse.c:4448 fortran/parse.c:4507
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Nested CRITICAL block at %C"
  msgid "OpenACC directive inside of CRITICAL block at %C"
-msgstr ""
+msgstr "Вложенный CRITICAL блок в %C"
  
  #: fortran/parse.c:4482
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Expecting %s statement at %C"
  msgid "Expecting %s at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°ÐµÑ\82Ñ\81Ñ\8f %s Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
  #: fortran/parse.c:4526
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Expected '(' at %C"
  msgid "Expected DO loop at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c '(' Ð² %C"
  
  #: fortran/parse.c:4546
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Redundant ACQUIRED_LOCK tag found at %L "
  msgid "Redundant !$ACC END LOOP at %C"
-msgstr ""
+msgstr "Избыточный ACQUIRED_LOCK тег найден в %L "
  
  #: fortran/parse.c:4759
  #, gcc-internal-format, gfc-internal-format
  msgid "Name after !$omp critical and !$omp end critical does not match at %C"
-msgstr ""
+msgstr "Имя после !$omp critical и !$omp end critical не соответствует в %C"
  
  #: fortran/parse.c:4816
  #, gcc-internal-format, gfc-internal-format
  msgid "%s statement at %C cannot terminate a non-block DO loop"
-msgstr ""
+msgstr "%s оператор в %C не может завершать неблочный DO цикл"
  
  #: fortran/parse.c:4830
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "FORMAT statement at %L does not have a statement label"
  msgid "DATA statement at %C after the first executable statement"
-msgstr ""
+msgstr "FORMAT оператор в %L не имеет метки оператора"
  
  #: fortran/parse.c:5061
  #, fuzzy, gcc-internal-format
+#| msgid "Contained procedure '%s' at %C is already ambiguous"
  msgid "Contained procedure %qs at %C is already ambiguous"
-msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ `%D' Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð¾"
+msgstr "Ð\92Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' Ð² %C Ñ\83Ð¶Ðµ Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð°"
  
  #: fortran/parse.c:5118
  #, gcc-internal-format, gfc-internal-format
  msgid "Unexpected %s statement in CONTAINS section at %C"
-msgstr ""
+msgstr "Неожиданный %s оператор в CONTAINS секции в %C"
  
  #: fortran/parse.c:5143
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2008: CONTAINS statement without FUNCTION or SUBROUTINE statement at %C"
  msgid "CONTAINS statement without FUNCTION or SUBROUTINE statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2008: CONTAINS оператор без FUNCTION или SUBROUTINE оператора в %C"
  
  #: fortran/parse.c:5255
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "CONTAINS statement at %C is already in a contained program unit"
-msgstr "оператор RETURN в %0 недопустим внутри главной программы"
+msgstr "CONTAINS оператор в %C уже во внутренней программной единице"
  
  #: fortran/parse.c:5301
  #, gcc-internal-format
@@ -56047,28 +58739,30 @@ msgstr ""
  
  #: fortran/parse.c:5306
  #, fuzzy, gcc-internal-format
+#| msgid "Global name '%s' at %L is already being used as a %s at %L"
  msgid "Global binding name %qs at %L is already being used as a %s at %L"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Глобальное имя '%s' в %L уже используется как %s в %L"
  
  #: fortran/parse.c:5309
  #, fuzzy, gcc-internal-format
+#| msgid "Global name '%s' at %L is already being used as a %s at %L"
  msgid "Global name %qs at %L is already being used as a %s at %L"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Глобальное имя '%s' в %L уже используется как %s в %L"
  
  #: fortran/parse.c:5330
  #, gcc-internal-format, gfc-internal-format
  msgid "Blank BLOCK DATA at %C conflicts with prior BLOCK DATA at %L"
-msgstr ""
+msgstr "Blank BLOCK DATA в %C конфликтует с предыдущей BLOCK DATA в %L"
  
  #: fortran/parse.c:5356
  #, gcc-internal-format, gfc-internal-format
  msgid "Unexpected %s statement in BLOCK DATA at %C"
-msgstr ""
+msgstr "Неожиданный %s оператор в BLOCK DATA в %C"
  
  #: fortran/parse.c:5441
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected %s statement in MODULE at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ %s Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² MODULE Ð² %C"
  
  #. If we see a duplicate main program, shut down.  If the second
  #. instance is an implied main program, i.e. data decls or executable
@@ -56076,12 +58770,12 @@ msgstr "ожидалось имя типа"
  #: fortran/parse.c:5828
  #, gcc-internal-format, gfc-internal-format
  msgid "Two main PROGRAMs at %L and %C"
-msgstr ""
+msgstr "Две главные программы в %L и %C"
  
  #: fortran/primary.c:105
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Missing kind-parameter at %C"
-msgstr "Отсутствует формальный параметр"
+msgstr "Отсутствует параметр вида в %C"
  
  #: fortran/primary.c:138
  #, gcc-internal-format
@@ -56089,109 +58783,118 @@ msgid "gfc_check_digit(): bad radix"
  msgstr ""
  
  #: fortran/primary.c:232
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Integer kind %d at %C not available"
-msgstr "тело функции недоступно"
+msgstr "Integer вид %d в %C недоступен"
  
  #: fortran/primary.c:241
  #, gcc-internal-format, gfc-internal-format
  msgid "Integer too big for its kind at %C. This check can be disabled with the option -fno-range-check"
-msgstr ""
+msgstr "Integer слишком велико для своего вида в %C. Эту проверку можно выключить опцией -fno-range-check"
  
  #: fortran/primary.c:270
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: Hollerith constant at %C"
  msgid "Hollerith constant at %C"
-msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð»Ñ\8cÐ½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð¹ Ð´Ð»Ð¸Ð½Ñ\8b Ð² %0"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: Ð¥Ð¾Ð»Ð»ÐµÑ\80Ð¸Ñ\82Ð¾Ð²Ð° ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð² %C"
  
  #: fortran/primary.c:281
  #, gcc-internal-format, gfc-internal-format
  msgid "Invalid Hollerith constant: %L must contain at least one character"
-msgstr ""
+msgstr "Некорректная Холлеритова константа: %L должна содержать по крайней мере один символ"
  
  #: fortran/primary.c:287
  #, gcc-internal-format, gfc-internal-format
  msgid "Invalid Hollerith constant: Integer kind at %L should be default"
-msgstr ""
+msgstr "Некорректная Холлеритова константа: Integer вид в %L должен быть подразумеваемым"
  
  #: fortran/primary.c:307
  #, gcc-internal-format, gfc-internal-format
  msgid "Invalid Hollerith constant at %L contains a wide character"
-msgstr ""
+msgstr "Некорректная Холлеритова константа в %L содержит широкий символ"
  
  #: fortran/primary.c:393
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: Hexadecimal constant at %C uses non-standard syntax"
  msgid "Hexadecimal constant at %C uses non-standard syntax"
-msgstr ""
+msgstr "Расширение: Шестнадцатеричная константа в %C использует нестандартный синтаксис"
  
  #: fortran/primary.c:402
  #, gcc-internal-format, gfc-internal-format
  msgid "Empty set of digits in BOZ constant at %C"
-msgstr ""
+msgstr "Пустое множество цифр в BOZ константе в %C"
  
  #: fortran/primary.c:408
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Illegal character in BOZ constant at %C"
-msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð»Ñ\8cÐ½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð¹ Ð´Ð»Ð¸Ð½Ñ\8b Ð² %0"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð¼Ð²Ð¾Ð» Ð² BOZ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ðµ Ð² %C"
  
  #: fortran/primary.c:431
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: BOZ constant at %C uses non-standard postfix syntax"
  msgid "BOZ constant at %C uses non-standard postfix syntax"
-msgstr ""
+msgstr "Расширение: BOZ константа в %C использует нестандартный постфиксный синтаксис"
  
  #: fortran/primary.c:461
  #, gcc-internal-format, gfc-internal-format
  msgid "Integer too big for integer kind %i at %C"
-msgstr ""
+msgstr "Integer слишком велико для integer вида %i в %C"
  
  #: fortran/primary.c:467
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: BOZ used outside a DATA statement at %C"
  msgid "BOZ used outside a DATA statement at %C"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: BOZ используется вне DATA оператора в %C"
  
  #: fortran/primary.c:557
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Invalid exponent-letter 'q' in real-literal-constant at %C"
  msgid "exponent-letter 'q' in real-literal-constant at %C"
-msgstr "Ð\9fÑ\80Ð¾Ð¿Ñ\83Ñ\89ÐµÐ½Ð° Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f exponent-letter 'q' Ð² real-literal-constant Ð² %C"
  
  #: fortran/primary.c:562
  #, fuzzy, gcc-internal-format
+#| msgid "Extension: exponent-letter 'q' in real-literal-constant at %C"
  msgid "Extension: exponent-letter %<q%> in real-literal-constant at %C"
-msgstr "Ð\9fÑ\80Ð¾Ð¿Ñ\83Ñ\89ÐµÐ½Ð° Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: exponent-letter 'q' Ð² real-literal-constant Ð² %C"
  
  #: fortran/primary.c:578
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Missing exponent in real number at %C"
-msgstr "Ð\92 %1 Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð¿Ð¾Ñ\80Ñ\8fÐ´ÐºÐ° Ð´Ð»Ñ\8f Ð²ÐµÑ\89ÐµÑ\81Ñ\82Ð²ÐµÐ½Ð½Ð¾Ð³Ð¾ Ñ\87Ð¸Ñ\81Ð»Ð° Ð² %0"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\8dÐºÑ\81Ð¿Ð¾Ð½ÐµÐ½Ñ\82Ð° Ð² Ð²ÐµÑ\89ÐµÑ\81Ñ\82Ð²ÐµÐ½Ð½Ð¾Ð¼ Ñ\87Ð¸Ñ\81Ð»Ðµ Ð² %C"
  
  #: fortran/primary.c:634
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Real number at %C has a 'd' exponent and an explicit kind"
  msgid "Real number at %C has a %<d%> exponent and an explicit kind"
-msgstr ""
+msgstr "Вещественное число в %C имеет 'd' экспоненту и явный вид"
  
  #: fortran/primary.c:664
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Real number at %C has a 'q' exponent and an explicit kind"
  msgid "Real number at %C has a %<q%> exponent and an explicit kind"
-msgstr ""
+msgstr "Вещественное число в %C имеет 'q' экспоненту и явный вид"
  
  #: fortran/primary.c:678
  #, fuzzy, gcc-internal-format
+#| msgid "Invalid exponent-letter 'q' in real-literal-constant at %C"
  msgid "Invalid exponent-letter %<q%> in real-literal-constant at %C"
-msgstr "Ð\9fÑ\80Ð¾Ð¿Ñ\83Ñ\89ÐµÐ½Ð° Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f exponent-letter 'q' Ð² real-literal-constant Ð² %C"
  
  #: fortran/primary.c:711
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid real kind %d at %C"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f %%R"
+msgstr "Ð\9dÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ð²ÐµÑ\89ÐµÑ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐ¹ Ð²Ð¸Ð´ %d Ð² %C"
  
  #: fortran/primary.c:726
  #, gcc-internal-format, gfc-internal-format
  msgid "Real constant overflows its kind at %C"
-msgstr ""
+msgstr "Вещественная константа переполняет свой вид в %C"
  
  #: fortran/primary.c:731
  #, gcc-internal-format, gfc-internal-format
  msgid "Real constant underflows its kind at %C"
-msgstr ""
+msgstr "Вещественная константа теряет значимость своего вида в %C"
  
  #: fortran/primary.c:736
  #, gcc-internal-format
@@ -56206,22 +58909,23 @@ msgstr ""
  #: fortran/primary.c:875
  #, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in SUBSTRING specification at %C"
-msgstr ""
+msgstr "Синтаксическая ошибка в SUBSTRING спецификации в %C"
  
  #: fortran/primary.c:1087
  #, gcc-internal-format, gfc-internal-format
  msgid "Invalid kind %d for CHARACTER constant at %C"
-msgstr ""
+msgstr "Некорректный вид %d для CHARACTER константы в %C"
  
  #: fortran/primary.c:1108
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unterminated character constant beginning at %C"
-msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð»Ñ\8cÐ½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð¹ Ð´Ð»Ð¸Ð½Ñ\8b Ð² %0"
+msgstr "Ð\9dÐµÑ\82ÐµÑ\80Ð¼Ð¸Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð°Ñ\8f Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ñ\8cÐ½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð½Ð°Ñ\87Ð¸Ð½Ð°Ñ\8eÑ\89Ð°Ñ\8fÑ\81Ñ\8f Ð² %C"
  
  #: fortran/primary.c:1138
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Character '%s' in string at %C is not representable in character kind %d"
  msgid "Character %qs in string at %C is not representable in character kind %d"
-msgstr ""
+msgstr "Символ '%s' в строке в %C непредставим в character виде %d"
  
  #: fortran/primary.c:1151
  #, gcc-internal-format
@@ -56231,27 +58935,28 @@ msgstr ""
  #: fortran/primary.c:1221
  #, gcc-internal-format, gfc-internal-format
  msgid "Bad kind for logical constant at %C"
-msgstr ""
+msgstr "Некорректный вид для logical константы в %C"
  
  #: fortran/primary.c:1253
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected PARAMETER symbol in complex constant at %C"
-msgstr ""
+msgstr "Ожидался PARAMETER символ в complex константе в %C"
  
  #: fortran/primary.c:1262
  #, gcc-internal-format, gfc-internal-format
  msgid "Numeric PARAMETER required in complex constant at %C"
-msgstr ""
+msgstr "Числовой PARAMETER требуется в complex константе в %C"
  
  #: fortran/primary.c:1268
  #, gcc-internal-format, gfc-internal-format
  msgid "Scalar PARAMETER required in complex constant at %C"
-msgstr ""
+msgstr "Скалярный PARAMETER требуется в complex константе в %C"
  
  #: fortran/primary.c:1272
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Expected PARAMETER symbol in complex constant at %C"
  msgid "PARAMETER symbol in complex constant at %C"
-msgstr ""
+msgstr "Ожидался PARAMETER символ в complex константе в %C"
  
  #: fortran/primary.c:1295
  #, gcc-internal-format
@@ -56261,43 +58966,45 @@ msgstr ""
  #: fortran/primary.c:1302
  #, gcc-internal-format, gfc-internal-format
  msgid "Error converting PARAMETER constant in complex constant at %C"
-msgstr ""
+msgstr "Ошибка преобразования PARAMETER константы в complex константу в %C"
  
  #: fortran/primary.c:1430
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in COMPLEX constant at %C"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ðµ Ð¿Ñ\83Ð»Ð° ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82 #%d\n"
+msgstr "Ð¡Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\87ÐµÑ\81ÐºÐ°Ñ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² COMPLEX ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ðµ Ð² %C"
  
  #: fortran/primary.c:1557
  #, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "non-parameter %qs cannot be a parameter pack"
+#| msgid "Namelist %s cannot be renamed by USE association to %s"
  msgid "Namelist '%s' can not be an argument at %L"
-msgstr "Ð½Ðµ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ %qs Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ñ\81Ð¾Ð´ÐµÑ\80Ð¶Ð°Ñ\82Ñ\8c Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ñ\8b"
+msgstr "Ð¡Ð¿Ð¸Ñ\81Ð¾Ðº Ð¸Ð¼ÐµÐ½ %s Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¿ÐµÑ\80ÐµÐ¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½ Ð¿Ñ\83Ñ\82ÐµÐ¼ USE Ð°Ñ\81Ñ\81Ð¾Ñ\86Ð¸Ð°Ñ\86Ð¸Ð¸ Ð² %s"
  
  #: fortran/primary.c:1643
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Keyword '%s' at %C has already appeared in the current argument list"
  msgid "Keyword %qs at %C has already appeared in the current argument list"
-msgstr ""
+msgstr "Ключевое слово '%s' в %C уже появлялось в текущем списке аргументов"
  
  #: fortran/primary.c:1707
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unknown argument list function at %L"
  msgid "argument list function at %C"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
+msgstr "Ð\9dÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ñ\81Ð¿Ð¸Ñ\81ÐºÐ° Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² %L"
  
  #: fortran/primary.c:1775
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected alternate return label at %C"
-msgstr ""
+msgstr "Ожидалась метка альтернативного возврата в %C"
  
  #: fortran/primary.c:1797
  #, gcc-internal-format, gfc-internal-format
  msgid "Missing keyword name in actual argument list at %C"
-msgstr ""
+msgstr "Отсутствует имя ключевого слова в списке фактических аргументов в %C"
  
  #: fortran/primary.c:1843
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in argument list at %C"
-msgstr "синтаксическая ошибка в списке параметров макроса"
+msgstr "Синтаксическая ошибка в списке аргументов в %C"
  
  #: fortran/primary.c:1864
  #, gcc-internal-format
@@ -56307,337 +59014,388 @@ msgstr ""
  #: fortran/primary.c:1902
  #, gcc-internal-format, gfc-internal-format
  msgid "Array section designator, e.g. '(:)', is required besides the coarray designator '[...]' at %C"
-msgstr ""
+msgstr "Обозначение секции массива, например, '(:)', требуется помимо обозначения комассива '[...]' в %C"
  
  #: fortran/primary.c:1910
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Coarray designator at %C but '%s' is not a coarray"
  msgid "Coarray designator at %C but %qs is not a coarray"
-msgstr ""
+msgstr "Обозначение комассива в %C но '%s' не есть комассив"
  
  #: fortran/primary.c:1981
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %L has no IMPLICIT type"
  msgid "Symbol %qs at %C has no IMPLICIT type"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Символ '%s' в %L не имеет IMPLICIT типа"
  
  #: fortran/primary.c:1987
  #, fuzzy, gcc-internal-format
+#| msgid "Unexpected character in variable list at %C"
  msgid "Unexpected %<%%%> for nonderived-type variable %qs at %C"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85, Ð²Ñ\81Ñ\82Ñ\80ÐµÑ\82Ð¸Ð²Ñ\88Ð¸Ñ\85Ñ\81Ñ\8f Ð¿Ð¾Ñ\81Ð»Ðµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð²"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð¼Ð²Ð¾Ð» Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85 Ð² %C"
  
  #: fortran/primary.c:2005
  #, gcc-internal-format, gfc-internal-format
  msgid "Expected structure component name at %C"
-msgstr ""
+msgstr "Ожидалось имя компонента структуры в %C"
  
  #: fortran/primary.c:2056
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected argument list at %C"
-msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð¾Ðµ Ð¾ÐºÐ¾Ð½Ñ\87Ð°Ð½Ð¸Ðµ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ð°"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ñ\81Ð¿Ð¸Ñ\81Ð¾Ðº Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² %C"
  
  #: fortran/primary.c:2087
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure pointer component '%s' requires an argument list at %C"
  msgid "Procedure pointer component %qs requires an argument list at %C"
-msgstr "функция возвращает агрегатное значение"
+msgstr "Компонент указатель на процедуру '%s' требует список аргументов в %C"
  
  #: fortran/primary.c:2175
  #, gcc-internal-format, gfc-internal-format
  msgid "Coindexed procedure-pointer component at %C"
-msgstr ""
+msgstr "Внутренний компонент указатель на процедуру в %C"
  
  #: fortran/primary.c:2210
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "gfc_variable_attr(): Expression isn't a variable"
-msgstr "невозможна прямая адресация к входной позиции памяти %d"
+msgstr ""
  
  #: fortran/primary.c:2265
  #, fuzzy, gcc-internal-format
+#| msgid "creating array of references"
  msgid "gfc_variable_attr(): Bad array reference"
-msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð² Ñ\82Ð¸Ð¿Ð° %qT"
+msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ðº"
  
  #: fortran/primary.c:2435
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: Structure constructor with missing optional arguments at %C"
  msgid "Structure constructor with missing optional arguments at %C"
-msgstr "Недопустимое число в операторе FORMAT в %0"
+msgstr "Fortran 2003: Конструктор структуры с отсутствующими необязательными аргументами в %C"
  
  #: fortran/primary.c:2444
  #, fuzzy, gcc-internal-format
+#| msgid "No initializer for component '%s' given in the structure constructor at %C!"
  msgid "No initializer for allocatable component '%qs' given in the structure constructor at %C"
-msgstr "функция возвращает агрегатное значение"
+msgstr "Не задан инициализатор для компонента '%s' в конструкторе структуры в %C!"
  
  #: fortran/primary.c:2451
  #, fuzzy, gcc-internal-format
+#| msgid "No initializer for component '%s' given in the structure constructor at %C!"
  msgid "No initializer for component %qs given in the structure constructor at %C!"
-msgstr "слишком много аргументов для %s `%+#D'"
+msgstr "Не задан инициализатор для компонента '%s' в конструкторе структуры в %C!"
  
  #: fortran/primary.c:2499
  #, fuzzy, gcc-internal-format
+#| msgid "Can't construct ABSTRACT type '%s' at %L"
  msgid "Can't construct ABSTRACT type %qs at %L"
-msgstr "Ð´Ñ\83Ð±Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¼ÐµÑ\82ÐºÐ¸ `%D'"
+msgstr "Ð\9dÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ñ\81ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ABSTRACT Ñ\82Ð¸Ð¿ '%s' Ð² %L"
  
  #: fortran/primary.c:2519
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: Structure constructor with named arguments at %C"
  msgid "Structure constructor with named arguments at %C"
-msgstr "Недопустимое число в операторе FORMAT в %0"
+msgstr "Fortran 2003: Конструктор структуры с именованными аргументами в %C"
  
  #: fortran/primary.c:2534
  #, gcc-internal-format, gfc-internal-format
  msgid "Component initializer without name after component named %s at %L!"
-msgstr ""
+msgstr "Инициализатор компонента без имени после компонента именуемого %s в %L!"
  
  #: fortran/primary.c:2539
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Too many components in structure constructor at %L!"
-msgstr "слишком много аргументов для %s `%+#D'"
+msgstr "Слишком много компонентов в конструкторе структуры в %L!"
  
  #: fortran/primary.c:2576
  #, fuzzy, gcc-internal-format
+#| msgid "Component '%s' is initialized twice in the structure constructor at %L!"
  msgid "Component %qs is initialized twice in the structure constructor at %L!"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %s"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 '%s' Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ð´Ð²Ð°Ð¶Ð´Ñ\8b Ð² ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ðµ Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ñ\83Ñ\80Ñ\8b Ð² %L!"
  
  #: fortran/primary.c:2588
  #, fuzzy, gcc-internal-format
+#| msgid "Coindexed expression to pointer component '%s' in structure constructor at %L!"
  msgid "Coindexed expression to pointer component %qs in structure constructor at %L!"
-msgstr "функция возвращает агрегатное значение"
+msgstr "Коиндексное выражение для компонента указателя '%s' в конструкторе структуры в %L!"
  
  #: fortran/primary.c:2642
  #, fuzzy, gcc-internal-format
+#| msgid "component '%s' at %L has already been set by a parent derived type constructor"
  msgid "component %qs at %L has already been set by a parent derived type constructor"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %s"
+msgstr "ÐºÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 '%s' Ð² %L Ñ\83Ð¶Ðµ Ñ\83Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð»ÐµÐ½ ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ð¾Ð¼ Ñ\80Ð¾Ð´Ð¸Ñ\82ÐµÐ»Ñ\8cÑ\81ÐºÐ¾Ð³Ð¾ Ð¿Ñ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð°"
  
  #: fortran/primary.c:2831
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %C is the name of a recursive function and so refers to the result variable. Use an explicit RESULT variable for direct recursion (12.5.2.1)"
  msgid "%qs at %C is the name of a recursive function and so refers to the result variable. Use an explicit RESULT variable for direct recursion (12.5.2.1)"
-msgstr ""
+msgstr "'%s' в %C есть имя рекурсивной функции и как таковое ссылается на результирующую переменную. Используйте явную RESULT переменную для прямой рекурсии (12.5.2.1)"
  
  #: fortran/primary.c:2954
  #, fuzzy, gcc-internal-format
+#| msgid "Unexpected use of subroutine name '%s' at %C"
  msgid "Unexpected use of subroutine name %qs at %C"
-msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¸Ð¼Ñ\8f Ñ\82Ð¸Ð¿Ð°"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð¼ÐµÐ½Ð¸ Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b '%s' Ð² %C"
  
  #: fortran/primary.c:2986
  #, fuzzy, gcc-internal-format
+#| msgid "Statement function '%s' requires argument list at %C"
  msgid "Statement function %qs requires argument list at %C"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ñ\81Ð¿Ð¸Ñ\81Ð¾Ðº Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² %C"
  
  #: fortran/primary.c:2989
  #, fuzzy, gcc-internal-format
+#| msgid "Function '%s' requires an argument list at %C"
  msgid "Function %qs requires an argument list at %C"
-msgstr "функция возвращает агрегатное значение"
+msgstr "Функция '%s' требует список аргументов в %C"
  
  #: fortran/primary.c:3039
  #, fuzzy, gcc-internal-format
+#| msgid "Missing argument to '%s' at %C"
  msgid "Missing argument to %qs at %C"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° '%s'"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %C"
  
  #: fortran/primary.c:3195
  #, fuzzy, gcc-internal-format
+#| msgid "Missing argument list in function '%s' at %C"
  msgid "Missing argument list in function %qs at %C"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\81Ð¿Ð¸Ñ\81Ð¾Ðº Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s' Ð² %C"
  
  #: fortran/primary.c:3233
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Symbol at %C is not appropriate for an expression"
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ñ\81 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ Ñ\82Ð¾Ñ\87ÐºÐ¾Ð¹"
+msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» Ð² %C Ð½Ðµ Ð³Ð¾Ð´Ð¸Ñ\82Ñ\81Ñ\8f Ð´Ð»Ñ\8f Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
  
  #: fortran/primary.c:3333
  #, gcc-internal-format, gfc-internal-format
  msgid "Named constant at %C in an EQUIVALENCE"
-msgstr ""
+msgstr "Именованная константа в %C в EQUIVALENCE"
  
  #: fortran/primary.c:3367
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %C is not a variable"
  msgid "%qs at %C is not a variable"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'%s' в %C не есть переменная"
  
  #: fortran/resolve.c:123
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L is of the ABSTRACT type '%s'"
  msgid "%qs at %L is of the ABSTRACT type %qs"
-msgstr "%qD не является элементом типа %qT"
+msgstr "'%s' в %L имеет ABSTRACT тип '%s'"
  
  #: fortran/resolve.c:126
  #, fuzzy, gcc-internal-format
+#| msgid "ABSTRACT type '%s' used at %L"
  msgid "ABSTRACT type %qs used at %L"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "ABSTRACT тип '%s' использован в %L"
  
  #: fortran/resolve.c:143
  #, fuzzy, gcc-internal-format
+#| msgid "Interface '%s', used by procedure '%s' at %L, is declared in a later PROCEDURE statement"
  msgid "Interface %qs at %L is declared in a later PROCEDURE statement"
-msgstr "Ð\92Ð½ÐµÑ\88Ð½Ñ\8fÑ\8f Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° `%A' Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð° ÐºÐ°Ðº Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0, Ð½Ð¾ Ð½Ðµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° Ñ\8fÐ²Ð½Ð¾ ÐºÐ°Ðº EXTERNAL"
+msgstr "Ð\98Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81 '%s', Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð¾Ð¹ '%s' at %L, Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ð² Ð±Ð¾Ð»ÐµÐµ Ð¿Ð¾Ð·Ð´Ð½ÐµÐ¼ PROCEDURE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ"
  
  #: fortran/resolve.c:156
  #, fuzzy, gcc-internal-format
+#| msgid "Interface '%s' at %C may not be generic"
  msgid "Interface %qs at %L may not be generic"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Интерфейс '%s' в %C не может быть generic"
  
  #: fortran/resolve.c:163
  #, fuzzy, gcc-internal-format
+#| msgid "Interface '%s' at %C may not be a statement function"
  msgid "Interface %qs at %L may not be a statement function"
-msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80 Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82ом-функцией"
+msgstr "Ð\98Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81 '%s' Ð² %C Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80ом-функцией"
  
  #: fortran/resolve.c:172
  #, fuzzy, gcc-internal-format
+#| msgid "Intrinsic procedure '%s' not allowed in PROCEDURE statement at %C"
  msgid "Intrinsic procedure %qs not allowed in PROCEDURE statement at %L"
-msgstr "Внешняя процедура `%A' передана как фактический аргумент в %0, но не декларирована явно как EXTERNAL"
+msgstr "Встроенная процедура '%s' не допускается в операторе PROCEDURE в %C"
  
  #: fortran/resolve.c:178
  #, fuzzy, gcc-internal-format
+#| msgid "Interface '%s' of procedure '%s' at %L must be explicit"
  msgid "Interface %qs at %L must be explicit"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Интерфейс '%s' процедуры '%s' в %L должен быть явным"
  
  #: fortran/resolve.c:200
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "PROCEDURE '%s' at %L may not be used as its own interface"
  msgid "PROCEDURE %qs at %L may not be used as its own interface"
-msgstr ""
+msgstr "PROCEDURE '%s' в %L не может быть использована в качестве своего собственного интерфейса"
  
  #: fortran/resolve.c:294
  #, fuzzy, gcc-internal-format
+#| msgid "Alternate return specifier in elemental subroutine '%s' at %L is not allowed"
  msgid "Alternate return specifier in elemental subroutine %qs at %L is not allowed"
-msgstr "Ð\90Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð°Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ð¾Ð³Ð¾ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð½Ð¾Ð¹ Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ðµ '%s' Ð² %L Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f"
  
  #: fortran/resolve.c:298
  #, fuzzy, gcc-internal-format
+#| msgid "Alternate return specifier in function '%s' at %L is not allowed"
  msgid "Alternate return specifier in function %qs at %L is not allowed"
-msgstr "Ð\90Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð°Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ð¾Ð³Ð¾ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s' Ð² %L Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f"
  
  #: fortran/resolve.c:309
  #, fuzzy, gcc-internal-format
+#| msgid "By-value argument at %L is not allowed in this context"
  msgid "Self-referential argument %qs at %L is not allowed"
-msgstr "стандартные преобразования в данном контексте недопустимы"
+msgstr "Аргумент по значению в %L не допускается в этом контексте"
  
  #: fortran/resolve.c:381
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy procedure '%s' of PURE procedure at %L must also be PURE"
  msgid "Dummy procedure %qs of PURE procedure at %L must also be PURE"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð¤Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ð°Ñ\8f Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' PURE Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ñ\82Ð°ÐºÐ¶Ðµ Ð±Ñ\8bÑ\82Ñ\8c PURE"
  
  #: fortran/resolve.c:391
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2008: Argument '%s' of pure function '%s' at %L with VALUE attribute but without INTENT(IN)"
  msgid "Argument %qs of pure function %qs at %L with VALUE attribute but without INTENT(IN)"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "Fortran 2008: Аргумент '%s' pure функции '%s' в %L с VALUE атрибутом но без INTENT(IN)"
  
  #: fortran/resolve.c:396
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' of pure function '%s' at %L must be INTENT(IN) or VALUE"
  msgid "Argument %qs of pure function %qs at %L must be INTENT(IN) or VALUE"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' pure Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c INTENT(IN) Ð¸Ð»Ð¸ VALUE"
  
  #: fortran/resolve.c:404
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2008: Argument '%s' of pure subroutine '%s' at %L with VALUE attribute but without INTENT"
  msgid "Argument %qs of pure subroutine %qs at %L with VALUE attribute but without INTENT"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "Fortran 2008: Аргумент '%s' pure подпрограммы '%s' в %L с VALUE атрибутом но без INTENT"
  
  #: fortran/resolve.c:409
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' of pure subroutine '%s' at %L must have its INTENT specified or have the VALUE attribute"
  msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified or have the VALUE attribute"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' pure Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ñ\81Ð²Ð¾Ð¹ INTENT Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¼ Ð¸Ð»Ð¸ Ð¸Ð¼ÐµÑ\82Ñ\8c VALUE Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
  #: fortran/resolve.c:419
  #, fuzzy, gcc-internal-format
+#| msgid "Parameter '%s' to '%s' at %L must not be polymorphic"
  msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "Параметр '%s' в '%s' в %L не должен быть полиморфным"
  
  #: fortran/resolve.c:452
  #, fuzzy, gcc-internal-format
+#| msgid "Coarray dummy argument '%s' at %L to elemental procedure"
  msgid "Coarray dummy argument %qs at %L to elemental procedure"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Комассивный формальный аргумент '%s' в %L для элементной процедуры"
  
  #: fortran/resolve.c:460
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' of elemental procedure at %L must be scalar"
  msgid "Argument %qs of elemental procedure at %L must be scalar"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80Ð¾Ð¼"
  
  #: fortran/resolve.c:469
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' of elemental procedure at %L cannot have the ALLOCATABLE attribute"
  msgid "Argument %qs of elemental procedure at %L cannot have the ALLOCATABLE attribute"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð¸Ð¼ÐµÑ\82Ñ\8c ALLOCATABLE Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
  #: fortran/resolve.c:479
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' of elemental procedure at %L cannot have the POINTER attribute"
  msgid "Argument %qs of elemental procedure at %L cannot have the POINTER attribute"
-msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ð² %C Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 POINTER"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð¸Ð¼ÐµÑ\82Ñ\8c POINTER Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
  #: fortran/resolve.c:487
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy procedure '%s' not allowed in elemental procedure '%s' at %L"
  msgid "Dummy procedure %qs not allowed in elemental procedure %qs at %L"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Формальная процедура '%s' не допускается в элементной процедуре '%s' в %L"
  
  #: fortran/resolve.c:496
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' of pure subroutine '%s' at %L must have its INTENT specified or have the VALUE attribute"
  msgid "Argument %qs of elemental procedure %qs at %L must have its INTENT specified or have the VALUE attribute"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' pure Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ñ\81Ð²Ð¾Ð¹ INTENT Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¼ Ð¸Ð»Ð¸ Ð¸Ð¼ÐµÑ\82Ñ\8c VALUE Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
  #: fortran/resolve.c:509
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' of statement function at %L must be scalar"
  msgid "Argument %qs of statement function at %L must be scalar"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80Ð¾Ð¼"
  
  #: fortran/resolve.c:519
  #, fuzzy, gcc-internal-format
+#| msgid "Character-valued argument '%s' of statement function at %L must have constant length"
  msgid "Character-valued argument %qs of statement function at %L must have constant length"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ñ\81 character Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼ '%s' Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\83Ñ\8e Ð´Ð»Ð¸Ð½Ñ\83"
  
  #: fortran/resolve.c:577
  #, fuzzy, gcc-internal-format
+#| msgid "Contained function '%s' at %L has no IMPLICIT type"
  msgid "Contained function %qs at %L has no IMPLICIT type"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Внутренняя функция '%s' в %L не имеет IMPLICIT типа"
  
  #: fortran/resolve.c:580
  #, fuzzy, gcc-internal-format
+#| msgid "Result '%s' of contained function '%s' at %L has no IMPLICIT type"
  msgid "Result %qs of contained function %qs at %L has no IMPLICIT type"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Результат '%s' внутренней функции '%s' в %L не имеет IMPLICIT типа"
  
  #: fortran/resolve.c:604
  #, fuzzy, gcc-internal-format
+#| msgid "Character-valued %s '%s' at %L must not be assumed length"
  msgid "Character-valued %s %qs at %L must not be assumed length"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "%s с character значением '%s' в %L не должен быть предполагаемой длины"
  
  #: fortran/resolve.c:778
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Function %s at %L has entries with mismatched array specifications"
-msgstr "Ð¿Ñ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ð²Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f instance-Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹"
+msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f %s Ð² %L Ð¸Ð¼ÐµÐµÑ\82 Ð²Ñ\85Ð¾Ð´Ñ\8b Ñ\81 Ð½ÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\89Ð¸Ð¼Ð¸ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8fÐ¼Ð¸ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾Ð²"
  
  #: fortran/resolve.c:795
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: Function %s at %L with entries returning variables of different string lengths"
  msgid "Function %s at %L with entries returning variables of different string lengths"
-msgstr ""
+msgstr "Расширение: Функция %s at %L с входами возвращающими переменные с разными длинами строк"
  
  #: fortran/resolve.c:822
  #, gcc-internal-format, gfc-internal-format
  msgid "FUNCTION result %s can't be an array in FUNCTION %s at %L"
-msgstr ""
+msgstr "FUNCTION результат %s не может быть массивом в FUNCTION %s в %L"
  
  #: fortran/resolve.c:826
  #, gcc-internal-format, gfc-internal-format
  msgid "ENTRY result %s can't be an array in FUNCTION %s at %L"
-msgstr ""
+msgstr "ENTRY результат %s не может быть массивом в FUNCTION %s в %L"
  
  #: fortran/resolve.c:833
  #, gcc-internal-format, gfc-internal-format
  msgid "FUNCTION result %s can't be a POINTER in FUNCTION %s at %L"
-msgstr ""
+msgstr "FUNCTION результат %s не может быть POINTER в FUNCTION %s в %L"
  
  #: fortran/resolve.c:837
  #, gcc-internal-format, gfc-internal-format
  msgid "ENTRY result %s can't be a POINTER in FUNCTION %s at %L"
-msgstr ""
+msgstr "ENTRY результат %s не может быть POINTER в FUNCTION %s в %L"
  
  #: fortran/resolve.c:875
  #, gcc-internal-format, gfc-internal-format
  msgid "FUNCTION result %s can't be of type %s in FUNCTION %s at %L"
-msgstr ""
+msgstr "FUNCTION результат %s не может быть типа %s в FUNCTION %s в %L"
  
  #: fortran/resolve.c:880
  #, gcc-internal-format, gfc-internal-format
  msgid "ENTRY result %s can't be of type %s in FUNCTION %s at %L"
-msgstr ""
+msgstr "ENTRY результат %s не может быть типа %s в FUNCTION %s в %L"
  
  #: fortran/resolve.c:929
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L is in COMMON but only in BLOCK DATA initialization is allowed"
  msgid "Variable %qs at %L is in COMMON but only in BLOCK DATA initialization is allowed"
-msgstr ""
+msgstr "Переменная '%s' в %L находится в COMMON но допустима только инициализация в BLOCK DATA"
  
  #: fortran/resolve.c:933
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Initialized variable '%s' at %L is in a blank COMMON but initialization is only allowed in named common blocks"
  msgid "Initialized variable %qs at %L is in a blank COMMON but initialization is only allowed in named common blocks"
-msgstr ""
+msgstr "Инициализированная переменная '%s' в %L находится в blank COMMON но инициализация допустима только в именованных common блоках"
  
  #: fortran/resolve.c:940
  #, gcc-internal-format
@@ -56646,18 +59404,21 @@ msgstr ""
  
  #: fortran/resolve.c:948
  #, fuzzy, gcc-internal-format
+#| msgid "Derived type variable '%s' in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
  msgid "Derived type variable %qs in COMMON at %L has neither the SEQUENCE nor the BIND(C) attribute"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Переменная производного типа '%s' в COMMON в %L не имеет ни SEQUENCE ни BIND(C) атрибута"
  
  #: fortran/resolve.c:952
  #, fuzzy, gcc-internal-format
+#| msgid "Derived type variable '%s' in COMMON at %L has an ultimate component that is allocatable"
  msgid "Derived type variable %qs in COMMON at %L has an ultimate component that is allocatable"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Переменная производного типа '%s' в COMMON в %L имеет окончательный компонент который является размещаемым"
  
  #: fortran/resolve.c:956
  #, fuzzy, gcc-internal-format
+#| msgid "Derived type variable '%s' in COMMON at %L may not have default initializer"
  msgid "Derived type variable %qs in COMMON at %L may not have default initializer"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Переменная производного типа '%s' в COMMON в %L не может иметь подразумеваемый инициализатор"
  
  #: fortran/resolve.c:1000
  #, gcc-internal-format
@@ -56666,8 +59427,9 @@ msgstr ""
  
  #: fortran/resolve.c:1014
  #, fuzzy, gcc-internal-format
+#| msgid "COMMON block '%s' at %L is used as PARAMETER at %L"
  msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
-msgstr "`%D' не является элементом типа `%T'"
+msgstr "COMMON блок '%s' в %L использован как PARAMETER в %L"
  
  #: fortran/resolve.c:1022
  #, gcc-internal-format
@@ -56681,324 +59443,379 @@ msgstr ""
  
  #: fortran/resolve.c:1065
  #, fuzzy, gcc-internal-format
+#| msgid "COMMON block '%s' at %L is used as PARAMETER at %L"
  msgid "COMMON block %qs at %L is used as PARAMETER at %L"
-msgstr "Компонент в %C должен иметь атрибут POINTER"
+msgstr "COMMON блок '%s' в %L использован как PARAMETER в %L"
  
  #: fortran/resolve.c:1069
  #, fuzzy, gcc-internal-format
+#| msgid "COMMON block '%s' at %L can not have the EXTERNAL attribute"
  msgid "COMMON block %qs at %L can not have the EXTERNAL attribute"
-msgstr "Компонент в %C должен иметь атрибут POINTER"
+msgstr "COMMON блок '%s' в %L не может иметь EXTERNAL атрибут"
  
  #: fortran/resolve.c:1073
  #, fuzzy, gcc-internal-format
+#| msgid "COMMON block '%s' at %L is also an intrinsic procedure"
  msgid "COMMON block %qs at %L is also an intrinsic procedure"
-msgstr "`%D' не является элементом типа `%T'"
+msgstr "COMMON блок '%s' в %L является также встроенной процедурой"
  
  #: fortran/resolve.c:1077
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: COMMON block '%s' at %L that is also a function result"
  msgid "COMMON block %qs at %L that is also a function result"
-msgstr "%q+D не является функцией,"
+msgstr "Fortran 2003: COMMON блок '%s' в %L который является также результатом функции"
  
  #: fortran/resolve.c:1082
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: COMMON block '%s' at %L that is also a global procedure"
  msgid "COMMON block %qs at %L that is also a global procedure"
-msgstr "`%D' не является элементом типа `%T'"
+msgstr "Fortran 2003: COMMON блок '%s' в %L который является также глобальной процедурой"
  
  #: fortran/resolve.c:1168
  #, gcc-internal-format, gfc-internal-format
  msgid "The rank of the element in the structure constructor at %L does not match that of the component (%d/%d)"
-msgstr ""
+msgstr "Ранг элемента в конструкторе структуры в %L не соответствует рангу компонента (%d/%d)"
  
  #: fortran/resolve.c:1189
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The element in the structure constructor at %L, for pointer component '%s', is %s but should be %s"
  msgid "The element in the structure constructor at %L, for pointer component %qs, is %s but should be %s"
-msgstr ""
+msgstr "Элемент в конструкторе структуры в %L для компонента указателя '%s' есть %s но должен быть %s"
  
  #: fortran/resolve.c:1274
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The NULL in the structure constructor at %L is being applied to component '%s', which is neither a POINTER nor ALLOCATABLE"
  msgid "The NULL in the structure constructor at %L is being applied to component %qs, which is neither a POINTER nor ALLOCATABLE"
-msgstr ""
+msgstr "NULL в конструкторе структуры в %L применяется к компоненту '%s', который не является ни POINTER ни ALLOCATABLE"
  
  #: fortran/resolve.c:1308
  #, fuzzy, gcc-internal-format
+#| msgid "Interface mismatch for procedure-pointer component '%s' in structure constructor at %L: %s"
  msgid "Interface mismatch for procedure-pointer component %qs in structure constructor at %L: %s"
-msgstr "Ð\9dÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð¿Ñ\80Ð¸ Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¹ Ð² %L"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81Ð° Ð´Ð»Ñ\8f ÐºÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82Ð° Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 '%s' Ð² ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80Ðµ Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ñ\83Ñ\80Ñ\8b Ð² %L: %s"
  
  #: fortran/resolve.c:1324
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The element in the structure constructor at %L, for pointer component '%s' should be a POINTER or a TARGET"
  msgid "The element in the structure constructor at %L, for pointer component %qs should be a POINTER or a TARGET"
-msgstr ""
+msgstr "Элемент в конструкторе структуры в %L для компонента указателя '%s' должен быть POINTER или TARGET"
  
  #: fortran/resolve.c:1335
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Pointer initialization target at %L must not be ALLOCATABLE "
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¦ÐµÐ»Ñ\8c Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð² %L Ð½Ðµ Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c ALLOCATABLE "
  
  #: fortran/resolve.c:1353
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Invalid expression in the structure constructor for pointer component '%s' at %L in PURE procedure"
  msgid "Invalid expression in the structure constructor for pointer component %qs at %L in PURE procedure"
-msgstr ""
+msgstr "Некорректное выражение в конструкторе структуры для компонента указателя '%s' в %L в PURE процедуре"
  
  #: fortran/resolve.c:1477
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The upper bound in the last dimension must appear in the reference to the assumed size array '%s' at %L"
  msgid "The upper bound in the last dimension must appear in the reference to the assumed size array %qs at %L"
-msgstr ""
+msgstr "Верхняя граница в последнем измерении должна появляться в ссылке на массив предполагаемого размера '%s' в %L"
  
  #: fortran/resolve.c:1539
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L is ambiguous"
  msgid "%qs at %L is ambiguous"
-msgstr "использование `%D' неоднозначно"
+msgstr "'%s' в %L неоднозначно"
  
  #: fortran/resolve.c:1543
  #, fuzzy, gcc-internal-format
+#| msgid "GENERIC procedure '%s' is not allowed as an actual argument at %L"
  msgid "GENERIC procedure %qs is not allowed as an actual argument at %L"
-msgstr "Внешняя процедура `%A' передана как фактический аргумент в %0, но не декларирована явно как EXTERNAL"
+msgstr "GENERIC процедура '%s' не допускается как фактический аргумент в %L"
  
  #: fortran/resolve.c:1664
  #, fuzzy, gcc-internal-format
+#| msgid "Type specified for intrinsic function '%s' at %L is ignored"
  msgid "Type specified for intrinsic function %qs at %L is ignored"
-msgstr "Ð\90Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð¢Ð¸Ð¿ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ð´Ð»Ñ\8f Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s' Ð² %L Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
  
  #: fortran/resolve.c:1677
  #, fuzzy, gcc-internal-format
+#| msgid "Intrinsic subroutine '%s' at %L shall not have a type specifier"
  msgid "Intrinsic subroutine %qs at %L shall not have a type specifier"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Встроенная подпрограмма '%s' в %L не должна иметь спецификатор типа"
  
  #: fortran/resolve.c:1688
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' declared INTRINSIC at %L does not exist"
  msgid "%qs declared INTRINSIC at %L does not exist"
-msgstr "%s: определение функции %qs не преобразовано\n"
+msgstr "'%s' декларированная INTRINSIC в %L не существует"
  
  #: fortran/resolve.c:1701
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The intrinsic '%s' declared INTRINSIC at %L is not available in the current standard settings but %s.  Use an appropriate -std=* option or enable -fall-intrinsics in order to use it."
  msgid "The intrinsic %qs declared INTRINSIC at %L is not available in the current standard settings but %s. Use an appropriate %<-std=*%> option or enable %<-fall-intrinsics%> in order to use it."
-msgstr ""
+msgstr "Встроенная '%s' декларированная INTRINSIC в %L недоступна в установках текущего стандарта кроме %s.  Используйте подходящую -std=* опцию или включите -fall-intrinsics чтобы использовать ее."
  
  #: fortran/resolve.c:1737
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Non-RECURSIVE procedure '%s' at %L is possibly calling itself recursively.  Declare it RECURSIVE or use -frecursive"
  msgid "Non-RECURSIVE procedure %qs at %L is possibly calling itself recursively.  Declare it RECURSIVE or use %<-frecursive%>"
-msgstr ""
+msgstr "Non-RECURSIVE процедура '%s' в %L возможно вызывает себя рекурсивно.  Декларируйте ее RECURSIVE или используйте -frecursive"
  
  #: fortran/resolve.c:1776 fortran/resolve.c:8932 fortran/resolve.c:10557
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Label %d referenced at %L is never defined"
-msgstr "Метка %A уже определена в %1 а затем переопределена в %0"
+msgstr "Метка %d используемая в %L нигде не определяется"
  
  #: fortran/resolve.c:1819
  #, fuzzy, gcc-internal-format
+#| msgid "Statement function '%s' at %L is not allowed as an actual argument"
  msgid "Statement function %qs at %L is not allowed as an actual argument"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %L Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f Ð² ÐºÐ°Ñ\87ÐµÑ\81Ñ\82Ð²Ðµ Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°"
  
  #: fortran/resolve.c:1827
  #, fuzzy, gcc-internal-format
+#| msgid "Intrinsic '%s' at %L is not allowed as an actual argument"
  msgid "Intrinsic %qs at %L is not allowed as an actual argument"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f '%s' Ð² %L Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f Ð² ÐºÐ°Ñ\87ÐµÑ\81Ñ\82Ð²Ðµ Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°"
  
  #: fortran/resolve.c:1834
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2008: Internal procedure '%s' is used as actual argument at %L"
  msgid "Internal procedure %qs is used as actual argument at %L"
-msgstr "Внешняя процедура `%A' передана как фактический аргумент в %0, но не декларирована явно как EXTERNAL"
+msgstr "Fortran 2008: Внутренняя процедура '%s' использована как фактический аргумент в %L"
  
  #: fortran/resolve.c:1842
  #, fuzzy, gcc-internal-format
+#| msgid "ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
  msgid "ELEMENTAL non-INTRINSIC procedure %qs is not allowed as an actual argument at %L"
-msgstr "Внешняя процедура `%A' передана как фактический аргумент в %0, но не декларирована явно как EXTERNAL"
+msgstr "ELEMENTAL non-INTRINSIC процедура '%s' не допускается в качестве фактического аргумента в %L"
  
  #: fortran/resolve.c:1869
  #, fuzzy, gcc-internal-format
+#| msgid "Unable to find a specific INTRINSIC procedure for the reference '%s' at %L"
  msgid "Unable to find a specific INTRINSIC procedure for the reference %qs at %L"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°Ñ\85 spec-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s'"
+msgstr "Ð\9dÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð½Ð°Ð¹Ñ\82Ð¸ ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð½Ñ\83Ñ\8e INTRINSIC Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 Ð´Ð»Ñ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ¸ '%s' Ð² %L"
  
  #: fortran/resolve.c:1891
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %L is ambiguous"
  msgid "Symbol %qs at %L is ambiguous"
-msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ `%D' Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð¾"
+msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» '%s' Ð² %L Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87ÐµÐ½"
  
  #: fortran/resolve.c:1946
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "By-value argument at %L is not of numeric type"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾Ðºа"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ð¾ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8e Ð² %L Ð½ÐµÑ\87Ð¸Ñ\81Ð»Ð¾Ð²Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿а"
  
  #: fortran/resolve.c:1953
  #, gcc-internal-format, gfc-internal-format
  msgid "By-value argument at %L cannot be an array or an array section"
-msgstr ""
+msgstr "Аргумент по значению в %L не может быть массивом или секцией массива"
  
  #: fortran/resolve.c:1967
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "By-value argument at %L is not allowed in this context"
-msgstr "стандартные преобразования в данном контексте недопустимы"
+msgstr "Аргумент по значению в %L не допускается в этом контексте"
  
  #: fortran/resolve.c:1979
  #, gcc-internal-format, gfc-internal-format
  msgid "Passing internal procedure at %L by location not allowed"
-msgstr ""
+msgstr "Передача внутренней процедуры в %L по расположению не допускается"
  
  #: fortran/resolve.c:1990
  #, fuzzy, gcc-internal-format
+#| msgid "ELEMENTAL non-INTRINSIC procedure '%s' is not allowed as an actual argument at %L"
  msgid "ELEMENTAL procedure pointer component %qs is not allowed as an actual argument at %L"
-msgstr "Внешняя процедура `%A' передана как фактический аргумент в %0, но не декларирована явно как EXTERNAL"
+msgstr "ELEMENTAL non-INTRINSIC процедура '%s' не допускается в качестве фактического аргумента в %L"
  
  #: fortran/resolve.c:1999
  #, gcc-internal-format, gfc-internal-format
  msgid "Coindexed actual argument at %L with ultimate pointer component"
-msgstr ""
+msgstr "Коиндексированный фактический аргумент в %L с окончательным компонентом указателем"
  
  #: fortran/resolve.c:2130
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L is an array and OPTIONAL; IF IT IS MISSING, it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (12.4.1.5)"
  msgid "%qs at %L is an array and OPTIONAL; IF IT IS MISSING, it cannot be the actual argument of an ELEMENTAL procedure unless there is a non-optional argument with the same rank (12.4.1.5)"
-msgstr ""
+msgstr "'%s' в %L есть массив и OPTIONAL; ЕСЛИ ОН ОПУЩЕН, он не может быть фактическим аргументом ELEMENTAL процедуры кроме случая когда есть обязательный аргумент того же ранга (12.4.1.5)"
  
  #: fortran/resolve.c:2167
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Actual argument at %L for INTENT(%s) dummy '%s' of ELEMENTAL subroutine '%s' is a scalar, but another actual argument is an array"
  msgid "Actual argument at %L for INTENT(%s) dummy %qs of ELEMENTAL subroutine %qs is a scalar, but another actual argument is an array"
-msgstr ""
+msgstr "Фактический аргумент в %L для INTENT(%s) формального параметра '%s' ELEMENTAL подпрограммы '%s' есть скаляр, но другой фактический аргумент является массивом"
  
  #: fortran/resolve.c:2439
  #, fuzzy, gcc-internal-format
+#| msgid "Return type mismatch of function '%s' at %L (%s/%s)"
  msgid "Return type mismatch of function %qs at %L (%s/%s)"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ð² Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\89Ð°ÐµÐ¼Ð¾Ð¼ Ñ\82Ð¸Ð¿Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s' Ð² %L (%s/%s)"
  
  #: fortran/resolve.c:2460
  #, fuzzy, gcc-internal-format
+#| msgid "Interface mismatch in dummy procedure '%s' at %L: %s"
  msgid "Interface mismatch in global procedure %qs at %L: %s "
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81Ð° Ð² Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ðµ '%s' Ð² %L: %s"
  
  #: fortran/resolve.c:2573
  #, fuzzy, gcc-internal-format
+#| msgid "There is no specific function for the generic '%s' at %L"
  msgid "There is no specific function for the generic %qs at %L"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°Ñ\85 spec-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s'"
+msgstr "Ð\9dÐµÑ\82 ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð½Ð¾Ð¹ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð´Ð»Ñ\8f generic '%s' Ð² %L"
  
  #: fortran/resolve.c:2591
  #, fuzzy, gcc-internal-format
+#| msgid "Generic function '%s' at %L is not consistent with a specific intrinsic interface"
  msgid "Generic function %qs at %L is not consistent with a specific intrinsic interface"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Generic функция '%s' в %L несовместима с конкретным встроенным интерфейсом"
  
  #: fortran/resolve.c:2629
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Function '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
  msgid "Function %qs at %L is INTRINSIC but is not compatible with an intrinsic"
-msgstr ""
+msgstr "Функция '%s' в %L есть INTRINSIC но не является совместимой со встроенной"
  
  #: fortran/resolve.c:2684
  #, fuzzy, gcc-internal-format
+#| msgid "Unable to resolve the specific function '%s' at %L"
  msgid "Unable to resolve the specific function %qs at %L"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°Ñ\85 spec-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s'"
+msgstr "Ð\9dÐµ Ñ\83Ð´Ð°ÐµÑ\82Ñ\81Ñ\8f Ñ\80Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð½Ñ\83Ñ\8e Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8e '%s' Ð² %L"
  
  #: fortran/resolve.c:2740 fortran/resolve.c:15308
  #, fuzzy, gcc-internal-format
+#| msgid "Function '%s' at %L has no IMPLICIT type"
  msgid "Function %qs at %L has no IMPLICIT type"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Функция '%s' в %L не имеет IMPLICIT типа"
  
  #: fortran/resolve.c:2849
  #, fuzzy, gcc-internal-format
+#| msgid "Reference to non-PURE function '%s' at %L inside a FORALL %s"
  msgid "Reference to impure function %qs at %L inside a FORALL %s"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "Ссылка на non-PURE функцию '%s' в %L внутри FORALL %s"
  
  #: fortran/resolve.c:2856
  #, fuzzy, gcc-internal-format
+#| msgid "Reference to non-PURE function '%s' at %L inside a DO CONCURRENT %s"
  msgid "Reference to impure function %qs at %L inside a DO CONCURRENT %s"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "Ссылка на non-PURE функцию '%s' в %L внутри DO CONCURRENT %s"
  
  #: fortran/resolve.c:2863
  #, fuzzy, gcc-internal-format
+#| msgid "Reference to non-PURE function '%s' at %L inside a FORALL %s"
  msgid "Reference to impure function %qs at %L within a PURE procedure"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "Ссылка на non-PURE функцию '%s' в %L внутри FORALL %s"
  
  #: fortran/resolve.c:2926
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L is not a function"
  msgid "%qs at %L is not a function"
-msgstr "%q+D не является функцией,"
+msgstr "'%s' в %L не есть функция"
  
  #: fortran/resolve.c:2934 fortran/resolve.c:3404
  #, fuzzy, gcc-internal-format
+#| msgid "ABSTRACT INTERFACE '%s' must not be referenced at %L"
  msgid "ABSTRACT INTERFACE %qs must not be referenced at %L"
-msgstr "Недопустимое число в операторе FORMAT в %0"
+msgstr "ABSTRACT INTERFACE '%s' не должна фигурировать в %L"
  
  #. Internal procedures are taken care of in resolve_contained_fntype.
  #: fortran/resolve.c:2977
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Function '%s' is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
  msgid "Function %qs is declared CHARACTER(*) and cannot be used at %L since it is not a dummy argument"
-msgstr ""
+msgstr "Функция '%s' декларирована CHARACTER(*) и не может использоваться в %L поскольку это не формальный аргумент"
  
  #: fortran/resolve.c:3011
  #, fuzzy, gcc-internal-format
+#| msgid "<unresolved overloaded function type>"
  msgid "resolve_function(): bad function type"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "<неразрешенный тип перегруженной функции>"
  
  #: fortran/resolve.c:3031
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "User defined non-ELEMENTAL function '%s' at %L not allowed in WORKSHARE construct"
  msgid "User defined non-ELEMENTAL function %qs at %L not allowed in WORKSHARE construct"
-msgstr ""
+msgstr "Определенная пользователем non-ELEMENTAL функция '%s' в %L не допускается в WORKSHARE конструкции"
  
  #: fortran/resolve.c:3093
  #, fuzzy, gcc-internal-format
+#| msgid "ENTRY '%s' at %L cannot be called recursively, as function '%s' is not RECURSIVE"
  msgid "ENTRY %qs at %L cannot be called recursively, as function %qs is not RECURSIVE"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "ENTRY '%s' в %L не может вызываться рекурсивно, поскольку функция '%s' не есть RECURSIVE"
  
  #: fortran/resolve.c:3097
  #, fuzzy, gcc-internal-format
+#| msgid "Function '%s' at %L cannot be called recursively, as it is not RECURSIVE"
  msgid "Function %qs at %L cannot be called recursively, as it is not RECURSIVE"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Функция '%s' в %L не может вызываться рекурсивно, поскольку она не есть RECURSIVE"
  
  #: fortran/resolve.c:3148
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Subroutine call to '%s' in FORALL block at %L is not PURE"
  msgid "Subroutine call to %qs in FORALL block at %L is not PURE"
-msgstr ""
+msgstr "Вызов подпрограммы '%s' в FORALL блоке в %L не есть PURE"
  
  #: fortran/resolve.c:3154
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Subroutine call to '%s' in DO CONCURRENT block at %L is not PURE"
  msgid "Subroutine call to %qs in DO CONCURRENT block at %L is not PURE"
-msgstr ""
+msgstr "Вызов подпрограммы '%s' в DO CONCURRENT блоке в %L не есть PURE"
  
  #: fortran/resolve.c:3160
  #, fuzzy, gcc-internal-format
+#| msgid "Subroutine call to '%s' at %L is not PURE"
  msgid "Subroutine call to %qs at %L is not PURE"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %s"
+msgstr "Ð\92Ñ\8bÐ·Ð¾Ð² Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b '%s' Ð² %L Ð½Ðµ ÐµÑ\81Ñ\82Ñ\8c PURE"
  
  #: fortran/resolve.c:3228
  #, fuzzy, gcc-internal-format
+#| msgid "There is no specific subroutine for the generic '%s' at %L"
  msgid "There is no specific subroutine for the generic %qs at %L"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°Ñ\85 spec-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s'"
+msgstr "Ð\9dÐµÑ\82 ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð½Ð¾Ð¹ Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b Ð´Ð»Ñ\8f generic '%s' Ð² %L"
  
  #: fortran/resolve.c:3237
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Generic subroutine '%s' at %L is not consistent with an intrinsic subroutine interface"
  msgid "Generic subroutine %qs at %L is not consistent with an intrinsic subroutine interface"
-msgstr ""
+msgstr "Generic подпрограмма '%s' в %L несовместима с интерфейсом встроенной подпрограммы"
  
  #: fortran/resolve.c:3272
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Subroutine '%s' at %L is INTRINSIC but is not compatible with an intrinsic"
  msgid "Subroutine %qs at %L is INTRINSIC but is not compatible with an intrinsic"
-msgstr ""
+msgstr "Подпрограмма '%s' в %L есть INTRINSIC но несовместима со встроенной"
  
  #: fortran/resolve.c:3317
  #, fuzzy, gcc-internal-format
+#| msgid "Unable to resolve the specific subroutine '%s' at %L"
  msgid "Unable to resolve the specific subroutine %qs at %L"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°Ñ\85 spec-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ '%s'"
+msgstr "Ð\9dÐµ Ñ\83Ð´Ð°ÐµÑ\82Ñ\81Ñ\8f Ñ\80Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c ÐºÐ¾Ð½ÐºÑ\80ÐµÑ\82Ð½Ñ\83Ñ\8e Ð¿Ð¾Ð´Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\83 '%s' Ð² %L"
  
  #: fortran/resolve.c:3375
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L has a type, which is not consistent with the CALL at %L"
  msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
-msgstr ""
+msgstr "'%s' в %L имеет тип, который несовместим с CALL в %L"
  
  #: fortran/resolve.c:3414
  #, fuzzy, gcc-internal-format
+#| msgid "ENTRY '%s' at %L cannot be called recursively, as subroutine '%s' is not RECURSIVE"
  msgid "ENTRY %qs at %L cannot be called recursively, as subroutine %qs is not RECURSIVE"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "ENTRY '%s' в %L не может вызываться рекурсивно, поскольку подпрограмма '%s' не есть RECURSIVE"
  
  #: fortran/resolve.c:3418
  #, fuzzy, gcc-internal-format
+#| msgid "SUBROUTINE '%s' at %L cannot be called recursively, as it is not RECURSIVE"
  msgid "SUBROUTINE %qs at %L cannot be called recursively, as it is not RECURSIVE"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "SUBROUTINE '%s' в %L не может вызываться рекурсивно, поскольку она не есть RECURSIVE"
  
  #: fortran/resolve.c:3463
  #, fuzzy, gcc-internal-format
+#| msgid "<unresolved overloaded function type>"
  msgid "resolve_subroutine(): bad function type"
-msgstr "%s: ошибка при определении адреса перегруженной функции"
+msgstr "<неразрешенный тип перегруженной функции>"
  
  #: fortran/resolve.c:3501
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Shapes for operands at %L and %L are not conformable"
-msgstr "shared и mdll несовместимы"
+msgstr "Формы для операндов в %L и %L не являются подобными"
  
  #: fortran/resolve.c:3733
  #, gcc-internal-format
@@ -57011,49 +59828,49 @@ msgid "compare_bound_int(): Bad expression"
  msgstr ""
  
  #: fortran/resolve.c:4021
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d"
-msgstr "ÐÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð¡Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² %L Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° (%ld < %ld) Ð² Ð¸Ð·Ð¼ÐµÑ\80ÐµÐ½Ð¸Ð¸ %d"
  
  #: fortran/resolve.c:4026
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Array reference at %L is out of bounds (%ld < %ld) in codimension %d"
-msgstr "ÐÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð¡Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² %L Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° (%ld < %ld) Ð² ÐºÐ¾Ð¸Ð·Ð¼ÐµÑ\80ÐµÐ½Ð¸Ð¸ %d"
  
  #: fortran/resolve.c:4036
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Array reference at %L is out of bounds (%ld > %ld) in dimension %d"
-msgstr "ÐÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð¡Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² %L Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° (%ld > %ld) Ð² Ð¸Ð·Ð¼ÐµÑ\80ÐµÐ½Ð¸Ð¸ %d"
  
  #: fortran/resolve.c:4041
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Array reference at %L is out of bounds (%ld > %ld) in codimension %d"
-msgstr "ÐÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð¡Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² %L Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° (%ld > %ld) Ð² ÐºÐ¾Ð¸Ð·Ð¼ÐµÑ\80ÐµÐ½Ð¸Ð¸ %d"
  
  #: fortran/resolve.c:4061
  #, gcc-internal-format, gfc-internal-format
  msgid "Illegal stride of zero at %L"
-msgstr ""
+msgstr "Некорректный нулевой шаг в %L"
  
  #: fortran/resolve.c:4078
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Lower array reference at %L is out of bounds (%ld < %ld) in dimension %d"
-msgstr "ÐÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð\9dÐ¸Ð¶Ð½Ñ\8fÑ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² %L Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° (%ld < %ld) Ð² Ð¸Ð·Ð¼ÐµÑ\80ÐµÐ½Ð¸Ð¸ %d"
  
  #: fortran/resolve.c:4086
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Lower array reference at %L is out of bounds (%ld > %ld) in dimension %d"
-msgstr "ÐÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð\9dÐ¸Ð¶Ð½Ñ\8fÑ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² %L Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° (%ld > %ld) Ð² Ð¸Ð·Ð¼ÐµÑ\80ÐµÐ½Ð¸Ð¸ %d"
  
  #: fortran/resolve.c:4102
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Upper array reference at %L is out of bounds (%ld < %ld) in dimension %d"
-msgstr "ÐÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð\92ÐµÑ\80Ñ\85Ð½Ñ\8fÑ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² %L Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° (%ld < %ld) Ð² Ð¸Ð·Ð¼ÐµÑ\80ÐµÐ½Ð¸Ð¸ %d"
  
  #: fortran/resolve.c:4111
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Upper array reference at %L is out of bounds (%ld > %ld) in dimension %d"
-msgstr "ÐÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð\92ÐµÑ\80Ñ\85Ð½Ñ\8fÑ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² %L Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° (%ld > %ld) Ð² Ð¸Ð·Ð¼ÐµÑ\80ÐµÐ½Ð¸Ð¸ %d"
  
  #: fortran/resolve.c:4127
  #, fuzzy, gcc-internal-format
@@ -57064,47 +59881,48 @@ msgstr "отсутствует индекс массива"
  #: fortran/resolve.c:4150
  #, gcc-internal-format, gfc-internal-format
  msgid "Rightmost upper bound of assumed size array section not specified at %L"
-msgstr ""
+msgstr "Самая правая верхняя граница секции массива предполагаемой формы не задана в %L"
  
  #: fortran/resolve.c:4160
  #, gcc-internal-format, gfc-internal-format
  msgid "Rank mismatch in array reference at %L (%d/%d)"
-msgstr ""
+msgstr "Несоответствие рангов в ссылке на массив в %L (%d/%d)"
  
  #: fortran/resolve.c:4168
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Coindex rank mismatch in array reference at %L (%d/%d)"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð°"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ðµ ÐºÐ¾Ð¸Ð½Ð´ÐµÐºÑ\81Ð½Ñ\8bÑ\85 Ñ\80Ð°Ð½Ð³Ð¾Ð² Ð² Ñ\81Ñ\81Ñ\8bÐ»ÐºÐµ Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² %L (%d/%d)"
  
  #: fortran/resolve.c:4184
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Coindex of codimension %d must be a scalar at %L"
-msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð½Ð¾Ñ\81Ñ\82Ð¸ %d Ð²Ñ\8bÑ\85Ð¾Ð´Ð¸Ñ\82 Ð·Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ñ\8b в %L"
+msgstr "Ð\9aÐ¾Ð¸Ð½Ð´ÐµÐºÑ\81 ÐºÐ¾Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð½Ð¾Ñ\81Ñ\82Ð¸ %d Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80Ð¾Ð¼ в %L"
  
  #: fortran/resolve.c:4212
  #, gcc-internal-format, gfc-internal-format
  msgid "Array index at %L must be scalar"
-msgstr ""
+msgstr "Индекс массива в %L должен быть скаляром"
  
  #: fortran/resolve.c:4218
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Array index at %L must be of INTEGER type, found %s"
-msgstr "%qD не является элементом типа %qT"
+msgstr "Индекс массива в %L должен быть INTEGER типа, найдено %s"
  
  #: fortran/resolve.c:4224
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Extension: REAL array index at %L"
  msgid "REAL array index at %L"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð¾Ð±Ñ\80Ð°Ñ\89ÐµÐ½Ð¸Ð¸ Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ñ\83 Ð² %1"
+msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: REAL Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %L"
  
  #: fortran/resolve.c:4263
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument dim at %L must be scalar"
-msgstr ""
+msgstr "Аргумент dim в %L должен быть скаляром"
  
  #: fortran/resolve.c:4270
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument dim at %L must be of INTEGER type"
-msgstr ""
+msgstr "Аргумент dim в %L должен быть INTEGER типа"
  
  #: fortran/resolve.c:4315
  #, gcc-internal-format
@@ -57122,64 +59940,65 @@ msgid "find_array_spec(): unused as(2)"
  msgstr ""
  
  #: fortran/resolve.c:4380
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Array index at %L is an array of rank %d"
-msgstr "Ð\9cÐ°Ñ\81Ñ\81Ð¸Ð² `%A' Ð² %0 Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð²ÐµÐ»Ð¸Ðº"
+msgstr "Ð\98Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %L Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾Ð¼ Ñ\80Ð°Ð½Ð³Ð° %d"
  
  #: fortran/resolve.c:4478
  #, gcc-internal-format, gfc-internal-format
  msgid "Substring start index at %L must be of type INTEGER"
-msgstr ""
+msgstr "Начальный индекс подстроки в %L должен быть типа INTEGER"
  
  #: fortran/resolve.c:4485
  #, gcc-internal-format, gfc-internal-format
  msgid "Substring start index at %L must be scalar"
-msgstr ""
+msgstr "Начальный индекс подстроки в %L должен быть скаляром"
  
  #: fortran/resolve.c:4494
  #, gcc-internal-format, gfc-internal-format
  msgid "Substring start index at %L is less than one"
-msgstr ""
+msgstr "Начальный индекс подстроки в %L меньше единицы"
  
  #: fortran/resolve.c:4507
  #, gcc-internal-format, gfc-internal-format
  msgid "Substring end index at %L must be of type INTEGER"
-msgstr ""
+msgstr "Конечный индекс подстроки в %L должен быть типа INTEGER"
  
  #: fortran/resolve.c:4514
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Substring end index at %L must be scalar"
-msgstr "Ð\9dÐ°Ñ\87Ð°Ð»Ð¾ Ð¸Ð»Ð¸ ÐºÐ¾Ð½ÐµÑ\86 Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð\9aÐ¾Ð½ÐµÑ\87Ð½Ñ\8bÐ¹ Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80Ð¾Ð¼"
  
  #: fortran/resolve.c:4524
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Substring end index at %L exceeds the string length"
-msgstr "Ð\9dÐ°Ñ\87Ð°Ð»Ð¾ Ð¸Ð»Ð¸ ÐºÐ¾Ð½ÐµÑ\86 Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸и"
+msgstr "Ð\9aÐ¾Ð½ÐµÑ\87Ð½Ñ\8bÐ¹ Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð² %L Ð¿Ñ\80ÐµÐ²Ñ\8bÑ\88Ð°ÐµÑ\82 Ð´Ð»Ð¸Ð½Ñ\83 Ñ\81Ñ\82Ñ\80Ð¾Ðºи"
  
  #: fortran/resolve.c:4534
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Substring end index at %L is too large"
-msgstr "Ð\9dÐ°Ñ\87Ð°Ð»Ð¾ Ð¸Ð»Ð¸ ÐºÐ¾Ð½ÐµÑ\86 Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð\9aÐ¾Ð½ÐµÑ\87Ð½Ñ\8bÐ¹ Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð² %L Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð²ÐµÐ»Ð¸Ðº"
  
  #: fortran/resolve.c:4687
  #, fuzzy, gcc-internal-format
+#| msgid "Bad array reference at %L"
  msgid "resolve_ref(): Bad array reference"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð¾Ð±Ñ\80Ð°Ñ\89ÐµÐ½Ð¸Ð¸ Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ñ\83 Ð² %1"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² %L"
  
  #: fortran/resolve.c:4701
  #, gcc-internal-format, gfc-internal-format
  msgid "Component to the right of a part reference with nonzero rank must not have the POINTER attribute at %L"
-msgstr ""
+msgstr "Компонент справа от частичной ссылки с ненулевым рангом не должен иметь POINTER атрибут в %L"
  
  #: fortran/resolve.c:4711
  #, gcc-internal-format, gfc-internal-format
  msgid "Component to the right of a part reference with nonzero rank must not have the ALLOCATABLE attribute at %L"
-msgstr ""
+msgstr "Компонент справа от частичной ссылки с ненулевым рангом не должен иметь ALLOCATABLE атрибут в %L"
  
  #: fortran/resolve.c:4730
  #, gcc-internal-format, gfc-internal-format
  msgid "Two or more part references with nonzero rank must not be specified at %L"
-msgstr ""
+msgstr "Две или больше частичные ссылки с ненулевым рангом не должны быть заданы в %L"
  
  #: fortran/resolve.c:4828
  #, gcc-internal-format
@@ -57187,14 +60006,15 @@ msgid "expression_rank(): Two array specs"
  msgstr ""
  
  #: fortran/resolve.c:4910
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Variable %s at %L with NO_ARG_CHECK attribute may only be used as actual argument"
-msgstr "Функция-оператор `%A', определенная в %0, не используется"
+msgstr ""
  
  #: fortran/resolve.c:4920
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Assumed shape array at %L must be a dummy argument"
  msgid "Assumed-type variable %s at %L may only be used as actual argument"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9cÐ°Ñ\81Ñ\81Ð¸Ð² Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð¹ Ñ\84Ð¾Ñ\80Ð¼Ñ\8b Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼"
  
  #. FIXME: It doesn't work reliably as inquiry_argument is not set
  #. for all inquiry functions in resolve_function; the reason is
@@ -57207,8 +60027,9 @@ msgstr ""
  
  #: fortran/resolve.c:4945
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Assumed shape array at %L must be a dummy argument"
  msgid "Assumed-rank variable %s at %L may only be used as actual argument"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9cÐ°Ñ\81Ñ\81Ð¸Ð² Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð¹ Ñ\84Ð¾Ñ\80Ð¼Ñ\8b Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼"
  
  #. FIXME: It doesn't work reliably as inquiry_argument is not set
  #. for all inquiry functions in resolve_function; the reason is
@@ -57221,254 +60042,270 @@ msgstr ""
  
  #: fortran/resolve.c:4966
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Procedure '%s' at %L with BIND(C) attribute must have an explicit interface"
  msgid "Variable %s at %L with NO_ARG_CHECK attribute shall not have a subobject reference"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Процедура '%s' в %L с BIND(C) атрибутом должна иметь явный интерфейс"
  
  #: fortran/resolve.c:4975
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Coarray variable '%s' at %L shall not have codimensions with deferred shape"
  msgid "Assumed-type variable %s at %L shall not have a subobject reference"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Комассивная переменная '%s' в %L не должна иметь коизмерения с отложенной формой"
  
  #: fortran/resolve.c:4990
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Coarray variable '%s' at %L shall not have codimensions with deferred shape"
  msgid "Assumed-rank variable %s at %L shall not have a subobject reference"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Комассивная переменная '%s' в %L не должна иметь коизмерения с отложенной формой"
  
  #: fortran/resolve.c:5147
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s', used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
  msgid "Variable %qs, used in a specification expression, is referenced at %L before the ENTRY statement in which it is a parameter"
-msgstr ""
+msgstr "Переменная '%s', использованная в спецификационном выражении, фигурирует в %L до ENTRY оператора в котором она является параметром"
  
  #: fortran/resolve.c:5152
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' is used at %L before the ENTRY statement in which it is a parameter"
  msgid "Variable %qs is used at %L before the ENTRY statement in which it is a parameter"
-msgstr ""
+msgstr "Переменная '%s' используется в %L до оператора ENTRY, в котором она является параметром"
  
  #: fortran/resolve.c:5222
  #, gcc-internal-format, gfc-internal-format
  msgid "Polymorphic subobject of coindexed object at %L"
-msgstr ""
+msgstr "Полиморфный подобъект коиндексированного объекта в %L"
  
  #: fortran/resolve.c:5235
  #, gcc-internal-format, gfc-internal-format
  msgid "Coindexed object with polymorphic allocatable subcomponent at %L"
-msgstr ""
+msgstr "Коиндексированный объект с полиморфным размещаемым подкомпонентом в %L"
  
  #: fortran/resolve.c:5573
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Passed-object at %L must be scalar"
-msgstr "Ð\9dÐ°Ñ\87Ð°Ð»Ð¾ Ð¸Ð»Ð¸ ÐºÐ¾Ð½ÐµÑ\86 Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð\9fÐµÑ\80ÐµÐ´Ð°Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ Ð¾Ð±Ñ\8aÐµÐºÑ\82 Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80Ð¾Ð¼"
  
  #: fortran/resolve.c:5580
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type '%s'"
  msgid "Base object for procedure-pointer component call at %L is of ABSTRACT type %qs"
-msgstr ""
+msgstr "Базовый объект для вызова компонента указателя на процедуру в %L имеет ABSTRACT тип '%s'"
  
  #: fortran/resolve.c:5615
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Base object for type-bound procedure call at %L is of ABSTRACT type '%s'"
  msgid "Base object for type-bound procedure call at %L is of ABSTRACT type %qs"
-msgstr ""
+msgstr "Базовый объект для вызова type-bound процедуры в %L имеет ABSTRACT тип '%s'"
  
  #: fortran/resolve.c:5624
  #, gcc-internal-format, gfc-internal-format
  msgid "Base object for NOPASS type-bound procedure call at %L must be scalar"
-msgstr ""
+msgstr "Базовый объект для вызова NOPASS type-bound процедуры в %L должен быть скаляром"
  
  #. Nothing matching found!
  #: fortran/resolve.c:5812
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Found no matching specific binding for the call to the GENERIC '%s' at %L"
  msgid "Found no matching specific binding for the call to the GENERIC %qs at %L"
-msgstr ""
+msgstr "Не найдено подходящего конкретного связывания для вызова GENERIC '%s' в %L"
  
  #: fortran/resolve.c:5839
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L should be a SUBROUTINE"
  msgid "%qs at %L should be a SUBROUTINE"
-msgstr ""
+msgstr "'%s' в %L должна быть SUBROUTINE"
  
  #: fortran/resolve.c:5890
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L should be a FUNCTION"
  msgid "%qs at %L should be a FUNCTION"
-msgstr ""
+msgstr "'%s' в %L должна быть FUNCTION"
  
  #: fortran/resolve.c:6407
  #, fuzzy, gcc-internal-format
+#| msgid "Expected expression type"
  msgid "gfc_resolve_expr(): Bad expression type"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ñ\81Ñ\8f Ñ\82Ð¸Ð¿ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
  
  #: fortran/resolve.c:6433
  #, gcc-internal-format, gfc-internal-format
  msgid "%s at %L must be a scalar"
-msgstr ""
+msgstr "'%s' в %L должна быть скаляром"
  
  #: fortran/resolve.c:6443
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "'%s' at %L must be nonnegative"
  msgid "%s at %L must be integer"
-msgstr "%qD не является элементом типа %qT"
+msgstr "'%s' в %L должен быть неотрицательным"
  
  #: fortran/resolve.c:6447 fortran/resolve.c:6454
  #, gcc-internal-format, gfc-internal-format
  msgid "%s at %L must be INTEGER"
-msgstr ""
+msgstr "%s в %L должна быть INTEGER"
  
  #: fortran/resolve.c:6496
  #, gcc-internal-format, gfc-internal-format
  msgid "Step expression in DO loop at %L cannot be zero"
-msgstr ""
+msgstr "Шаговое выражение в DO цикле в %L не может быть нулевым"
  
  #: fortran/resolve.c:6532
  #, gcc-internal-format, gfc-internal-format
  msgid "DO loop at %L will be executed zero times"
-msgstr ""
+msgstr "DO цикл в %L будет выполнен ноль раз"
  
  #: fortran/resolve.c:6593
  #, gcc-internal-format, gfc-internal-format
  msgid "FORALL index-name at %L must be a scalar INTEGER"
-msgstr ""
+msgstr "FORALL индекс-имя в %L должно быть скалярным INTEGER"
  
  #: fortran/resolve.c:6598
  #, gcc-internal-format, gfc-internal-format
  msgid "FORALL start expression at %L must be a scalar INTEGER"
-msgstr ""
+msgstr "FORALL стартовое выражение в %L должно быть скалярным INTEGER"
  
  #: fortran/resolve.c:6605
  #, gcc-internal-format, gfc-internal-format
  msgid "FORALL end expression at %L must be a scalar INTEGER"
-msgstr ""
+msgstr "FORALL конечное выражение в %L должно быть скалярным INTEGER"
  
  #: fortran/resolve.c:6613
  #, gcc-internal-format, gfc-internal-format
  msgid "FORALL stride expression at %L must be a scalar %s"
-msgstr ""
+msgstr "FORALL шаговое выражение в %L должно быть скаляром %s"
  
  #: fortran/resolve.c:6618
  #, gcc-internal-format, gfc-internal-format
  msgid "FORALL stride expression at %L cannot be zero"
-msgstr ""
+msgstr "FORALL шаговое выражение в %L не может быть нулевым"
  
  #: fortran/resolve.c:6631
  #, fuzzy, gcc-internal-format
+#| msgid "FORALL index '%s' may not appear in triplet specification at %L"
  msgid "FORALL index %qs may not appear in triplet specification at %L"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "FORALL индекс '%s' не может появляться в спецификации триплета в %L"
  
  #: fortran/resolve.c:6729 fortran/resolve.c:7021
  #, gcc-internal-format, gfc-internal-format
  msgid "Allocate-object at %L must be ALLOCATABLE or a POINTER"
-msgstr ""
+msgstr "Allocate-object в %L должен быть ALLOCATABLE или POINTER"
  
  #: fortran/resolve.c:6737 fortran/resolve.c:6986
  #, gcc-internal-format, gfc-internal-format
  msgid "Coindexed allocatable object at %L"
-msgstr ""
+msgstr "Коиндексированный размещаемый объект в %L"
  
  #: fortran/resolve.c:6843
  #, gcc-internal-format, gfc-internal-format
  msgid "Source-expr at %L must be scalar or have the same rank as the allocate-object at %L"
-msgstr ""
+msgstr "Source-expr в %L должно быть скалярным или иметь тот же ранг что и allocate-object в %L"
  
  #: fortran/resolve.c:6874
  #, gcc-internal-format, gfc-internal-format
  msgid "Source-expr at %L and allocate-object at %L must have the same shape"
-msgstr ""
+msgstr "Source-expr в %L и allocate-object в %L должны иметь одинаковую форму"
  
  #: fortran/resolve.c:7032
  #, gcc-internal-format, gfc-internal-format
  msgid "Type of entity at %L is type incompatible with source-expr at %L"
-msgstr ""
+msgstr "Тип сущности в %L есть тип несовместимый с source-expr в %L"
  
  #: fortran/resolve.c:7044
  #, gcc-internal-format, gfc-internal-format
  msgid "The allocate-object at %L and the source-expr at %L shall have the same kind type parameter"
-msgstr ""
+msgstr "Allocate-object в %L и source-expr в %L должны иметь одинаковый вид параметра типа"
  
  #: fortran/resolve.c:7058
  #, gcc-internal-format, gfc-internal-format
  msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
-msgstr ""
+msgstr "Source-expr в %L не должно быть типа LOCK_TYPE и не должно иметь LOCK_TYPE компонент если allocate-object в %L является комассивом"
  
  #: fortran/resolve.c:7073
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
  msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
-msgstr ""
+msgstr "Source-expr в %L не должно быть типа LOCK_TYPE и не должно иметь LOCK_TYPE компонент если allocate-object в %L является комассивом"
  
  #: fortran/resolve.c:7086
  #, gcc-internal-format, gfc-internal-format
  msgid "Allocating %s of ABSTRACT base type at %L requires a type-spec or source-expr"
-msgstr ""
+msgstr "Размещение %s ABSTRACT базового типа в %L требует type-spec или source-expr"
  
  #: fortran/resolve.c:7099
  #, gcc-internal-format, gfc-internal-format
  msgid "Allocating %s at %L with type-spec requires the same character-length parameter as in the declaration"
-msgstr ""
+msgstr "Размещение %s в %L с type-spec требует того же character-length параметра что и в декларации"
  
  #: fortran/resolve.c:7217 fortran/resolve.c:7232
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Array specification required in ALLOCATE statement at %L"
-msgstr "Ð\92Ñ\8bÑ\85Ð¾Ð´ Ð·Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ñ\8b Ð² Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÐµ Ð¸Ð»Ð¸ Ð¾Ð±Ñ\80Ð°Ñ\89ÐµÐ½Ð¸Ð¸ Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ñ\83 Ð´Ð»Ñ\8f `%A' Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %0"
+msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð² ALLOCATE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %L"
  
  #: fortran/resolve.c:7224
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Array specification required in ALLOCATE statement at %L"
  msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
-msgstr "Ð\92Ñ\8bÑ\85Ð¾Ð´ Ð·Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ñ\8b Ð² Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÐµ Ð¸Ð»Ð¸ Ð¾Ð±Ñ\80Ð°Ñ\89ÐµÐ½Ð¸Ð¸ Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ñ\83 Ð´Ð»Ñ\8f `%A' Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %0"
+msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð² ALLOCATE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %L"
  
  #: fortran/resolve.c:7247
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Coarray specification required in ALLOCATE statement at %L"
-msgstr "Ð\92Ñ\8bÑ\85Ð¾Ð´ Ð·Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ñ\8b Ð² Ð¿Ð¾Ð´Ñ\81Ñ\82Ñ\80Ð¾ÐºÐµ Ð¸Ð»Ð¸ Ð¾Ð±Ñ\80Ð°Ñ\89ÐµÐ½Ð¸Ð¸ Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ñ\83 Ð´Ð»Ñ\8f `%A' Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %0"
+msgstr "Ð¡Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð² ALLOCATE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %L"
  
  #: fortran/resolve.c:7274
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Bad array specification in ALLOCATE statement at %L"
-msgstr "Нет определения метки для оператора FORMAT в %0"
+msgstr "Некорректная спецификация массива в ALLOCATE операторе в %L"
  
  #: fortran/resolve.c:7293
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
  msgid "%qs must not appear in the array specification at %L in the same ALLOCATE statement where it is itself allocated"
-msgstr ""
+msgstr "'%s' не должно появляться в спецификации массива в %L в том же ALLOCATE операторе где оно само размещается"
  
  #: fortran/resolve.c:7308
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expected '*' in coindex specification in ALLOCATE statement at %L"
-msgstr "Ð\9dÐµÑ\82 Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f Ð¼ÐµÑ\82ÐºÐ¸ Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° FORMAT Ð² %0"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c '*' Ð² Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ ÐºÐ¾Ð¸Ð½Ð´ÐµÐºÑ\81Ð° Ð² ALLOCATE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %L"
  
  #: fortran/resolve.c:7319
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Bad coarray specification in ALLOCATE statement at %L"
-msgstr "Нет определения метки для оператора FORMAT в %0"
+msgstr "Некорректная спецификация комассива в ALLOCATE операторе в %L"
  
  #: fortran/resolve.c:7351
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Stat-variable at %L must be a scalar INTEGER variable"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "Stat-variable в %L должна быть скалярной INTEGER переменной"
  
  #: fortran/resolve.c:7374
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Stat-variable at %L shall not be %sd within the same %s statement"
-msgstr "Оператор в %0 некорректен в контексте, установленном оператором в %1"
+msgstr "Stat-variable в %L не должна быть %sd в том же %s операторе"
  
  #: fortran/resolve.c:7385
  #, gcc-internal-format, gfc-internal-format
  msgid "ERRMSG at %L is useless without a STAT tag"
-msgstr ""
+msgstr "ERRMSG в %L бесполезно без STAT тега"
  
  #: fortran/resolve.c:7396
  #, gcc-internal-format, gfc-internal-format
  msgid "Errmsg-variable at %L must be a scalar CHARACTER variable"
-msgstr ""
+msgstr "Errmsg-variable в %L должна быть скалярной CHARACTER переменной"
  
  #: fortran/resolve.c:7419
  #, gcc-internal-format, gfc-internal-format
  msgid "Errmsg-variable at %L shall not be %sd within the same %s statement"
-msgstr ""
+msgstr "Errmsg-variable в %L не должна быть %sd в том же %s операторе"
  
  #: fortran/resolve.c:7449
  #, gcc-internal-format, gfc-internal-format
  msgid "Allocate-object at %L also appears at %L"
-msgstr ""
+msgstr "Allocate-object в %L также появляется в %L"
  
  #: fortran/resolve.c:7455 fortran/resolve.c:7461
  #, gcc-internal-format, gfc-internal-format
  msgid "Allocate-object at %L is subobject of object at %L"
-msgstr ""
+msgstr "Allocate-object в %L есть подобъект объекта в %L"
  
  #. The cases overlap, or they are the same
  #. element in the list.  Either way, we must
@@ -57477,72 +60314,74 @@ msgstr ""
  #: fortran/resolve.c:7673
  #, gcc-internal-format, gfc-internal-format
  msgid "CASE label at %L overlaps with CASE label at %L"
-msgstr ""
+msgstr "CASE метка в %L перекрывается с CASE меткой в %L"
  
  #: fortran/resolve.c:7724
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expression in CASE statement at %L must be of type %s"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
+msgstr "Ð\92Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² CASE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c Ñ\82Ð¸Ð¿Ð° %s"
  
  #: fortran/resolve.c:7735
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expression in CASE statement at %L must be of kind %d"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
+msgstr "Ð\92Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² CASE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c Ð²Ð¸Ð´Ð° %d"
  
  #: fortran/resolve.c:7748
  #, gcc-internal-format, gfc-internal-format
  msgid "Expression in CASE statement at %L must be scalar"
-msgstr ""
+msgstr "Выражение в CASE операторе в %L должно быть скаляром"
  
  #: fortran/resolve.c:7794
  #, gcc-internal-format, gfc-internal-format
  msgid "Selection expression in computed GOTO statement at %L must be a scalar integer expression"
-msgstr ""
+msgstr "Выражение выбора в вычисляемом GOTO операторе в %L должно быть скалярным integer выражением"
  
  #: fortran/resolve.c:7813
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of SELECT statement at %L cannot be %s"
-msgstr ""
+msgstr "Аргумент SELECT оператора в %L не может быть %s"
  
  #: fortran/resolve.c:7823
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Argument of SELECT statement at %L cannot be %s"
  msgid "Argument of SELECT statement at %L must be a scalar expression"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 SELECT Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c %s"
  
  #: fortran/resolve.c:7841 fortran/resolve.c:7849
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Expression in CASE statement at %L is not in the range of %s"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
+msgstr "Ð\92Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² CASE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %L Ð½Ðµ Ð½Ð°Ñ\85Ð¾Ð´Ð¸Ñ\82Ñ\81Ñ\8f Ð² Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ðµ %s"
  
  #: fortran/resolve.c:7911 fortran/resolve.c:8350
  #, gcc-internal-format, gfc-internal-format
  msgid "The DEFAULT CASE at %L cannot be followed by a second DEFAULT CASE at %L"
-msgstr ""
+msgstr "За DEFAULT CASE в %L не может следовать второй DEFAULT CASE в %L"
  
  #: fortran/resolve.c:7937
  #, gcc-internal-format, gfc-internal-format
  msgid "Logical range in CASE statement at %L is not allowed"
-msgstr ""
+msgstr "Логический диапазон в CASE операторе в %L не допускается"
  
  #: fortran/resolve.c:7949
  #, gcc-internal-format, gfc-internal-format
  msgid "Constant logical value in CASE statement is repeated at %L"
-msgstr ""
+msgstr "Константное логическое значение в CASE операторе повторяется в %L"
  
  #: fortran/resolve.c:7964
  #, gcc-internal-format, gfc-internal-format
  msgid "Range specification at %L can never be matched"
-msgstr ""
+msgstr "Спецификации диапазона в %L невозможно найти соответствие"
  
  #: fortran/resolve.c:8067
  #, gcc-internal-format, gfc-internal-format
  msgid "Logical SELECT CASE block at %L has more that two cases"
-msgstr ""
+msgstr "Логический SELECT CASE блок в %L имеет более двух случаев"
  
  #: fortran/resolve.c:8142
  #, fuzzy, gcc-internal-format
+#| msgid "Associate-name '%s' at %L is used as array"
  msgid "Associate-name %qs at %L is used as array"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "Associate-name '%s' в %L используется как массив"
  
  #: fortran/resolve.c:8153
  #, gcc-internal-format, gfc-internal-format
@@ -57552,193 +60391,204 @@ msgstr ""
  #: fortran/resolve.c:8269
  #, gcc-internal-format, gfc-internal-format
  msgid "Selector shall be polymorphic in SELECT TYPE statement at %L"
-msgstr ""
+msgstr "Селектор должен быть полиморфным в SELECT TYPE операторе в %L"
  
  #: fortran/resolve.c:8286 fortran/resolve.c:8298
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Association target at %C must not be coindexed"
  msgid "Selector at %L must not be coindexed"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Цель ассоциации в %C не должна быть коиндексирована"
  
  #: fortran/resolve.c:8314
  #, fuzzy, gcc-internal-format
+#| msgid "Derived type '%s' at %L must be extensible"
  msgid "Derived type %qs at %L must be extensible"
-msgstr "Ð¿Ñ\80ÐµÐ´Ð¸ÐºÐ°Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð¾м"
+msgstr "Ð\9fÑ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80Ñ\8fÐµÐ¼Ñ\8bм"
  
  #: fortran/resolve.c:8326
  #, fuzzy, gcc-internal-format
+#| msgid "Derived type '%s' at %L must be an extension of '%s'"
  msgid "Derived type %qs at %L must be an extension of %qs"
-msgstr "Ð¿Ñ\80ÐµÐ´Ð¸ÐºÐ°Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð¾Ð¼"
+msgstr "Ð\9fÑ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸ÐµÐ¼ '%s'"
  
  #: fortran/resolve.c:8329
  #, fuzzy, gcc-internal-format
+#| msgid "Unexpected NULL() intrinsic at %L to dummy '%s'"
  msgid "Unexpected intrinsic type %qs at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð°Ñ\8f NULL() Ð²Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ð°Ñ\8f Ð² %L Ð² Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 '%s'"
  
  #: fortran/resolve.c:8338
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Type-spec at %L cannot contain a deferred type parameter"
  msgid "The type-spec at %L shall specify that each length type parameter is assumed"
-msgstr ""
+msgstr "Type-spec в %L не может содержать параметр отложенного типа"
  
  #: fortran/resolve.c:8530
  #, gcc-internal-format, gfc-internal-format
  msgid "Double CLASS IS block in SELECT TYPE statement at %L"
-msgstr ""
+msgstr "Двойной CLASS IS блок в SELECT TYPE операторе в %L"
  
  #: fortran/resolve.c:8619
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Invalid context for NULL() pointer at %%L"
  msgid "Invalid context for NULL () intrinsic at %L"
-msgstr ""
+msgstr "Некорректный контекст для NULL() указателя в %%L"
  
  #. FIXME: Test for defined input/output.
  #: fortran/resolve.c:8647
  #, gcc-internal-format, gfc-internal-format
  msgid "Data transfer element at %L cannot be polymorphic unless it is processed by a defined input/output procedure"
-msgstr ""
+msgstr "Элемент передачи данных в %L не может быть полиморфным если только он не обрабатывается определенной процедурой ввода/вывода"
  
  #: fortran/resolve.c:8659
  #, gcc-internal-format, gfc-internal-format
  msgid "Data transfer element at %L cannot have POINTER components unless it is processed by a defined input/output procedure"
-msgstr ""
+msgstr "Элемент передачи данных в %L не может иметь POINTER компоненты если только он не обрабатывается определенной процедурой ввода/вывода"
  
  #: fortran/resolve.c:8668
  #, gcc-internal-format, gfc-internal-format
  msgid "Data transfer element at %L cannot have procedure pointer components"
-msgstr ""
+msgstr "Элемент передачи данных в %L не может иметь компоненты указатели на процедуру"
  
  #: fortran/resolve.c:8675
  #, gcc-internal-format, gfc-internal-format
  msgid "Data transfer element at %L cannot have ALLOCATABLE components unless it is processed by a defined input/output procedure"
-msgstr ""
+msgstr "Элемент передачи данных в %L не может иметь ALLOCATABLE компоненты если только он не обрабатывается определенной процедурой ввода/вывода"
  
  #: fortran/resolve.c:8686 fortran/resolve.c:8692
  #, gcc-internal-format, gfc-internal-format
  msgid "Data transfer element at %L cannot have PRIVATE components"
-msgstr ""
+msgstr "Элемент передачи данных в %L не может иметь PRIVATE компоненты"
  
  #: fortran/resolve.c:8706
  #, gcc-internal-format, gfc-internal-format
  msgid "Data transfer element at %L cannot be a full reference to an assumed-size array"
-msgstr ""
+msgstr "Элемент передачи данных в %L не может быть полной ссылкой на массив предполагаемого размера"
  
  #: fortran/resolve.c:8763
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "Lock переменная в %L должна быть скаляром типа LOCK_TYPE"
  
  #: fortran/resolve.c:8773
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
  msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "Lock переменная в %L должна быть скаляром типа LOCK_TYPE"
  
  #: fortran/resolve.c:8777
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Actual argument to '%s' at %L must be a coarray"
  msgid "Event variable argument at %L must be a coarray or coindexed"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾м"
  
  #: fortran/resolve.c:8780
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Actual argument to '%s' at %L must be a coarray"
  msgid "Event variable argument at %L must be a coarray but not coindexed"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµм"
+msgstr "Ð¤Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾м"
  
  #: fortran/resolve.c:8787 fortran/resolve.c:8905
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "STAT= argument at %L must be a scalar INTEGER variable"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "STAT= аргумент в %L должна быть скалярной INTEGER переменной"
  
  #: fortran/resolve.c:8799 fortran/resolve.c:8912
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "ERRMSG= argument at %L must be a scalar CHARACTER variable"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "ERRMSG= аргумент в %L должна быть скалярной CHARACTER переменной"
  
  #: fortran/resolve.c:8811
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "ACQUIRED_LOCK= аргумент в %L должна быть скалярной LOGICAL переменной"
  
  #: fortran/resolve.c:8822
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
  msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "Imageset аргумент в %L должен быть скалярным или ранга 1 INTEGER выражением"
  
  #: fortran/resolve.c:8882
  #, gcc-internal-format, gfc-internal-format
  msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
-msgstr ""
+msgstr "Imageset аргумент в %L должен быть скалярным или ранга 1 INTEGER выражением"
  
  #: fortran/resolve.c:8886 fortran/resolve.c:8896
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Imageset argument at %L must between 1 and num_images()"
-msgstr "маска должна быть непосредственным значением"
+msgstr "Imageset аргумент в %L должен быть между 1 и num_images()"
  
  #: fortran/resolve.c:8939
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Statement at %L is not a valid branch target statement for the branch statement at %L"
-msgstr "Оператор в %0 некорректен в контексте, установленном оператором в %1"
+msgstr "Оператор в %L не есть корректный оператор цели перехода для оператора перехода в %L"
  
  #: fortran/resolve.c:8949
  #, gcc-internal-format, gfc-internal-format
  msgid "Branch at %L may result in an infinite loop"
-msgstr ""
+msgstr "Переход в %L может вызвать зацикливание"
  
  #. Note: A label at END CRITICAL does not leave the CRITICAL
  #. construct as END CRITICAL is still part of it.
  #: fortran/resolve.c:8966 fortran/resolve.c:8989
  #, gcc-internal-format, gfc-internal-format
  msgid "GOTO statement at %L leaves CRITICAL construct for label at %L"
-msgstr ""
+msgstr "GOTO оператор в %L покидает CRITICAL конструкцию для метки в %L"
  
  #: fortran/resolve.c:8970 fortran/resolve.c:8995
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "GOTO statement at %L leaves DO CONCURRENT construct for label at %L"
-msgstr "оператор continue вне цикла"
+msgstr "GOTO оператор в %L покидает DO CONCURRENT конструкцию для метки в %L"
  
  #. The label is not in an enclosing block, so illegal.  This was
  #. allowed in Fortran 66, so we allow it as extension.  No
  #. further checks are necessary in this case.
  #: fortran/resolve.c:9010
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Label at %L is not in the same block as the GOTO statement at %L"
-msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½ Ð² ÐºÐ¾Ð½Ñ\82ÐµÐºÑ\81Ñ\82Ðµ, Ñ\83Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð½Ð¾Ð¼ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð¼ Ð² %1"
+msgstr "Ð\9cÐµÑ\82ÐºÐ° Ð² %L Ð½Ðµ Ð½Ð°Ñ\85Ð¾Ð´Ð¸Ñ\82Ñ\81Ñ\8f Ð² Ñ\82Ð¾Ð¼ Ð¶Ðµ Ð±Ð»Ð¾ÐºÐµ Ñ\87Ñ\82Ð¾ GOTO Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %L"
  
  #: fortran/resolve.c:9082
  #, gcc-internal-format, gfc-internal-format
  msgid "WHERE mask at %L has inconsistent shape"
-msgstr ""
+msgstr "WHERE маска в %L имеет противоречивую форму"
  
  #: fortran/resolve.c:9098
  #, gcc-internal-format, gfc-internal-format
  msgid "WHERE assignment target at %L has inconsistent shape"
-msgstr ""
+msgstr "WHERE цель присваивания в %L имеет противоречивую форму"
  
  #: fortran/resolve.c:9106 fortran/resolve.c:9193
  #, gcc-internal-format, gfc-internal-format
  msgid "Non-ELEMENTAL user-defined assignment in WHERE at %L"
-msgstr ""
+msgstr "Non-ELEMENTAL определенное пользователем присваивание в WHERE в %L"
  
  #: fortran/resolve.c:9116 fortran/resolve.c:9203
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unsupported statement inside WHERE at %L"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Неподдерживаемый оператор внутри WHERE в %L"
  
  #: fortran/resolve.c:9147
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Assignment to a FORALL index variable at %L"
-msgstr "%s по отношению к переменной %qs, доступной только на чтение"
+msgstr "Присваивание FORALL индексной переменной в %L"
  
  #: fortran/resolve.c:9156
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The FORALL with index '%s' is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
  msgid "The FORALL with index %qs is not used on the left side of the assignment at %L and so might cause multiple assignment to this object"
-msgstr ""
+msgstr "FORALL с индексом '%s' не используется в левой части присваивания в %L и поэтому может вызвать множественное присваивание этому объекту"
  
  #: fortran/resolve.c:9325
  #, gcc-internal-format, gfc-internal-format
  msgid "An outer FORALL construct already has an index with this name %L"
-msgstr ""
+msgstr "Внешняя FORALL конструкция уже имеет индекс с этим именем %L"
  
  #: fortran/resolve.c:9403
  #, gcc-internal-format, gfc-internal-format
  msgid "WHERE/ELSEWHERE clause at %L requires a LOGICAL array"
-msgstr ""
+msgstr "WHERE/ELSEWHERE клаузула в %L требует LOGICAL массив"
  
  #: fortran/resolve.c:9481
  #, gcc-internal-format
@@ -57748,22 +60598,22 @@ msgstr ""
  #: fortran/resolve.c:9595
  #, gcc-internal-format, gfc-internal-format
  msgid "CHARACTER expression will be truncated in assignment (%d/%d) at %L"
-msgstr ""
+msgstr "CHARACTER выражение будет усечено в присваивании (%d/%d) в %L"
  
  #: fortran/resolve.c:9627
  #, gcc-internal-format, gfc-internal-format
  msgid "Coindexed expression at %L is assigned to a derived type variable with a POINTER component in a PURE procedure"
-msgstr ""
+msgstr "Коиндексированное выражение в %L присваивается переменной производного типа с POINTER компонентом в PURE процедуре"
  
  #: fortran/resolve.c:9632
  #, gcc-internal-format, gfc-internal-format
  msgid "The impure variable at %L is assigned to a derived type variable with a POINTER component in a PURE procedure (12.6)"
-msgstr ""
+msgstr "Impure переменная в %L присваивается переменной производного типа с POINTER компонентом в PURE процедуре (12.6)"
  
  #: fortran/resolve.c:9642
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Assignment to coindexed variable at %L in a PURE procedure"
-msgstr "%s по отношению к переменной %qs, доступной только на чтение"
+msgstr "Присваивание коиндексированной переменной в %L в PURE процедуре"
  
  #: fortran/resolve.c:9674
  #, gcc-internal-format, gfc-internal-format
@@ -57772,8 +60622,9 @@ msgstr ""
  
  #: fortran/resolve.c:9678
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Assignment to a FORALL index variable at %L"
  msgid "Assignment to an allocatable polymorphic variable at %L"
-msgstr "%s по отношению к переменной %qs, доступной только на чтение"
+msgstr "Присваивание FORALL индексной переменной в %L"
  
  #: fortran/resolve.c:9683
  #, gcc-internal-format
@@ -57783,18 +60634,21 @@ msgstr ""
  #. See PR 43366.
  #: fortran/resolve.c:9688
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Unlimited polymorphism at %C not yet supported"
  msgid "Assignment to an allocatable polymorphic variable at %L is not yet supported"
-msgstr "%s по отношению к переменной %qs, доступной только на чтение"
+msgstr "Неограниченный полиморфизм в %C пока не поддерживается"
  
  #: fortran/resolve.c:9694
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for '=' operator"
  msgid "Nonallocatable variable must not be polymorphic in intrinsic assignment at %L - check that there is a matching specific subroutine for '=' operator"
-msgstr ""
+msgstr "Переменная не должна быть полиморфной во встроенном присваивании в %L - проверьте что имеется соответствующая конкретная подпрограмма для '=' оператора"
  
  #: fortran/resolve.c:9705
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Coindexed variable must not be have an allocatable ultimate component in assignment at %L"
  msgid "Coindexed variable must not have an allocatable ultimate component in assignment at %L"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ %qs"
+msgstr "Ð\9aÐ¾Ð¸Ð½Ð´ÐµÐºÑ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ð½Ðµ Ð´Ð¾Ð»Ð¶Ð½Ð° Ð¸Ð¼ÐµÑ\82Ñ\8c Ñ\80Ð°Ð·Ð¼ÐµÑ\89Ð°ÐµÐ¼Ñ\8bÑ\85 Ð¾ÐºÐ¾Ð½Ñ\87Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÑ\85 ÐºÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82Ð¾Ð² Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ð² %L"
  
  #: fortran/resolve.c:10008
  #, gcc-internal-format, gfc-internal-format
@@ -57805,43 +60659,48 @@ msgstr ""
  #. the two statements to avoid upsetting frontend_passes.c.
  #: fortran/resolve.c:10250
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Invalid procedure pointer assignment at %L"
  msgid "Pointer procedure assignment at %L"
-msgstr "Несовместимые типы при присваивании указателей в %L"
+msgstr "Некорректное присваивание указателя на процедуру в %L"
  
  #: fortran/resolve.c:10262
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Target expression in pointer assignment at %L must deliver a pointer result"
  msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
-msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ð² %C Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 POINTER"
+msgstr "Ð¦ÐµÐ»ÐµÐ²Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð²Ñ\8bÐ´Ð°Ð²Ð°Ñ\82Ñ\8c Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐ¹ Ñ\80ÐµÐ·Ñ\83Ð»Ñ\8cÑ\82Ð°Ñ\82"
  
  #: fortran/resolve.c:10489
  #, gcc-internal-format, gfc-internal-format
  msgid "ASSIGNED GOTO statement at %L requires an INTEGER variable"
-msgstr ""
+msgstr "ASSIGNED GOTO оператор в %L требует INTEGER переменной"
  
  #: fortran/resolve.c:10492
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' has not been assigned a target label at %L"
  msgid "Variable %qs has not been assigned a target label at %L"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 SAVE Ð¸Ð»Ð¸ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ð² %1 Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð¼ SAVE Ð¸Ð»Ð¸ Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð¾Ð¼ Ð² %0"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ '%s' Ð½Ðµ Ð¿Ñ\80Ð¸Ñ\81Ð²Ð¾Ð¸Ð»Ð¸ Ñ\86ÐµÐ»ÐµÐ²Ñ\83Ñ\8e Ð¼ÐµÑ\82ÐºÑ\83 Ð² %L"
  
  #: fortran/resolve.c:10503
  #, gcc-internal-format, gfc-internal-format
  msgid "Alternate RETURN statement at %L requires a SCALAR-INTEGER return specifier"
-msgstr ""
+msgstr "Alternate RETURN оператор в %L требует SCALAR-INTEGER спецификатор возврата"
  
  #: fortran/resolve.c:10565
  #, gcc-internal-format, gfc-internal-format
  msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
-msgstr ""
+msgstr "ASSIGN оператор в %L требует скалярную подразумеваемого INTEGER переменную"
  
  #: fortran/resolve.c:10600
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Invalid kind for %s at %L"
  msgid "Invalid NULL at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð°"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð²Ð¸Ð´ Ð´Ð»Ñ\8f %s Ð² %L"
  
  #: fortran/resolve.c:10604
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Arithmetic IF statement at %L requires a numeric expression"
  msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð³Ð¾ IF Ð² %L Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ñ\87Ð¸Ñ\81Ð»Ð¾Ð²Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
  
  #: fortran/resolve.c:10660
  #, gcc-internal-format
@@ -57851,22 +60710,24 @@ msgstr ""
  #: fortran/resolve.c:10665
  #, gcc-internal-format, gfc-internal-format
  msgid "Exit condition of DO WHILE loop at %L must be a scalar LOGICAL expression"
-msgstr ""
+msgstr "Условие выхода из DO WHILE цикла в %L должно быть скалярным LOGICAL выражением"
  
  #: fortran/resolve.c:10749
  #, gcc-internal-format, gfc-internal-format
  msgid "FORALL mask clause at %L requires a scalar LOGICAL expression"
-msgstr ""
+msgstr "FORALL клаузула маски в %L требует скалярное LOGICAL выражение"
  
  #: fortran/resolve.c:10820
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "gfc_resolve_code(): Bad statement code"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: fortran/resolve.c:10915
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Binding label '%s' at %L collides with the global entity '%s' at %L"
  msgid "Variable %s with binding label %s at %L uses the same global identifier as entity at %L"
-msgstr ""
+msgstr "Связывающая метка '%s' в %L конфликтует с глобальной сущностью '%s' в %L"
  
  #. This can only happen if the variable is defined in a module - if it
  #. isn't the same module, reject it.
@@ -57879,111 +60740,130 @@ msgstr ""
  #. exclude references to the same procedure via module association or
  #. multiple checks for the same procedure.
  #: fortran/resolve.c:10945
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Binding label '%s' at %L collides with the global entity '%s' at %L"
  msgid "Procedure %s with binding label %s at %L uses the same global identifier as entity at %L"
-msgstr ""
+msgstr "Связывающая метка '%s' в %L конфликтует с глобальной сущностью '%s' в %L"
  
  #: fortran/resolve.c:11022
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "String length at %L is too large"
-msgstr "размер массива %qs слишком велик"
+msgstr "Длина строки в %L слишком велика"
  
  #: fortran/resolve.c:11358
  #, fuzzy, gcc-internal-format
+#| msgid "Allocatable array '%s' at %L must have a deferred shape"
  msgid "Allocatable array %qs at %L must have a deferred shape or assumed rank"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Размещаемый массив '%s' в %L должен иметь отложенную форму"
  
  #: fortran/resolve.c:11362
  #, fuzzy, gcc-internal-format
+#| msgid "Scalar object '%s' at %L may not be ALLOCATABLE"
  msgid "Scalar object %qs at %L may not be ALLOCATABLE"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð¡ÐºÐ°Ð»Ñ\8fÑ\80Ð½Ñ\8bÐ¹ Ð¾Ð±Ñ\8aÐµÐºÑ\82 '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c ALLOCATABLE"
  
  #: fortran/resolve.c:11370
  #, fuzzy, gcc-internal-format
+#| msgid "Array pointer '%s' at %L must have a deferred shape"
  msgid "Array pointer %qs at %L must have a deferred shape or assumed rank"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Указатель на массив '%s' at %L должен иметь отложенную форму"
  
  #: fortran/resolve.c:11380
  #, fuzzy, gcc-internal-format
+#| msgid "Array '%s' at %L cannot have a deferred shape"
  msgid "Array %qs at %L cannot have a deferred shape"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Массив '%s' at %L не может иметь отложенную форму"
  
  #: fortran/resolve.c:11395
  #, fuzzy, gcc-internal-format
+#| msgid "Type '%s' of CLASS variable '%s' at %L is not extensible"
  msgid "Type %qs of CLASS variable %qs at %L is not extensible"
-msgstr "Ð\90Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð¢Ð¸Ð¿ '%s' CLASS Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ '%s' at %L Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80Ñ\8fÐµÐ¼Ñ\8bÐ¼"
  
  #: fortran/resolve.c:11407
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "CLASS variable '%s' at %L must be dummy, allocatable or pointer"
  msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
-msgstr ""
+msgstr "CLASS переменная '%s' в %L должна быть формальным параметром, размещаемой или указателем"
  
  #: fortran/resolve.c:11438
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The type '%s' cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
  msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
-msgstr ""
+msgstr "Тип '%s' не может быть host ассоциированным в %L поскольку он блокирован несовместимым объектом с тем же именем декларированным в %L"
  
  #: fortran/resolve.c:11460
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2008: Implied SAVE for module variable '%s' at %L, needed due to the default initialization"
  msgid "Implied SAVE for module variable %qs at %L, needed due to the default initialization"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Fortran 2008: Выведенный SAVE для переменной модуля '%s' в %L, необходим в силе подразумеваемой инициализации"
  
  #. The shape of a main program or module array needs to be
  #. constant.
  #: fortran/resolve.c:11508
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The module or main program array '%s' at %L must have constant shape"
  msgid "The module or main program array %qs at %L must have constant shape"
-msgstr ""
+msgstr "Массив из модуля или главной программы '%s' в %L должен иметь константную форму"
  
  #: fortran/resolve.c:11520
  #, fuzzy, gcc-internal-format
+#| msgid "Entity '%s' at %L has a deferred type parameter and requires either the pointer or allocatable attribute"
  msgid "Entity %qs at %L has a deferred type parameter and requires either the pointer or allocatable attribute"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð¡Ñ\83Ñ\89Ð½Ð¾Ñ\81Ñ\82Ñ\8c '%s' Ð² %L Ð¸Ð¼ÐµÐµÑ\82 Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 Ð¾Ñ\82Ð»Ð¾Ð¶ÐµÐ½Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° Ð¸ Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð»Ð¸Ð±Ð¾ pointer Ð»Ð¸Ð±Ð¾ allocatable Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
  #: fortran/resolve.c:11536
  #, gcc-internal-format, gfc-internal-format
  msgid "Entity with assumed character length at %L must be a dummy argument or a PARAMETER"
-msgstr ""
+msgstr "Сущность с предполагаемой character длиной в %L должна быть формальным аргументом или PARAMETER"
  
  #: fortran/resolve.c:11557
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L must have constant character length in this context"
  msgid "%qs at %L must have constant character length in this context"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "'%s' в %L должна иметь константную character длину в этом контексте"
  
  #: fortran/resolve.c:11564
  #, fuzzy, gcc-internal-format
+#| msgid "COMMON variable '%s' at %L must have constant character length"
  msgid "COMMON variable %qs at %L must have constant character length"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "COMMON переменная '%s' в %L должна иметь константную character длину"
  
  #: fortran/resolve.c:11611
  #, fuzzy, gcc-internal-format
+#| msgid "Allocatable '%s' at %L cannot have an initializer"
  msgid "Allocatable %qs at %L cannot have an initializer"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Размещаемая '%s' в %L не может иметь инициализатор"
  
  #: fortran/resolve.c:11614
  #, fuzzy, gcc-internal-format
+#| msgid "External '%s' at %L cannot have an initializer"
  msgid "External %qs at %L cannot have an initializer"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Внешняя '%s' в %L не может иметь инициализатор"
  
  #: fortran/resolve.c:11618
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy '%s' at %L cannot have an initializer"
  msgid "Dummy %qs at %L cannot have an initializer"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Формальный параметр '%s' в %L не может иметь инициализатор"
  
  #: fortran/resolve.c:11621
  #, fuzzy, gcc-internal-format
+#| msgid "Intrinsic '%s' at %L cannot have an initializer"
  msgid "Intrinsic %qs at %L cannot have an initializer"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Встроенная '%s' в %L не может иметь инициализатор"
  
  #: fortran/resolve.c:11624
  #, fuzzy, gcc-internal-format
+#| msgid "Function result '%s' at %L cannot have an initializer"
  msgid "Function result %qs at %L cannot have an initializer"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Результат функции '%s' в %L не может иметь инициализатор"
  
  #: fortran/resolve.c:11627
  #, fuzzy, gcc-internal-format
+#| msgid "Automatic array '%s' at %L cannot have an initializer"
  msgid "Automatic array %qs at %L cannot have an initializer"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Автоматический массив '%s' в %L не может иметь инициализатор"
  
  #: fortran/resolve.c:11669
  #, fuzzy, gcc-internal-format, gfc-internal-format
@@ -57993,98 +60873,117 @@ msgstr "в %s, в %s:%d"
  
  #: fortran/resolve.c:11696
  #, fuzzy, gcc-internal-format
+#| msgid "Character-valued statement function '%s' at %L must have constant length"
  msgid "Character-valued statement function %qs at %L must have constant length"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ñ\81 character Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼ '%s' Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð¸Ð¼ÐµÑ\82Ñ\8c ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\83Ñ\8e Ð´Ð»Ð¸Ð½Ñ\83"
  
  #: fortran/resolve.c:11718
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: '%s' is of a PRIVATE type and cannot be a dummy argument of '%s', which is PUBLIC at %L"
  msgid "%qs is of a PRIVATE type and cannot be a dummy argument of %qs, which is PUBLIC at %L"
-msgstr ""
+msgstr "Fortran 2003: '%s' имеет PRIVATE тип и не может быть формальным аргументом '%s', который PUBLIC в %L"
  
  #: fortran/resolve.c:11740
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: Procedure '%s' in PUBLIC interface '%s' at %L takes dummy arguments of '%s' which is PRIVATE"
  msgid "Procedure %qs in PUBLIC interface %qs at %L takes dummy arguments of %qs which is PRIVATE"
-msgstr ""
+msgstr "Fortran 2003: Процедура '%s' в PUBLIC интерфейсе '%s' в %L берет формальные аргументы '%s' который PRIVATE"
  
  #: fortran/resolve.c:11758
  #, fuzzy, gcc-internal-format
+#| msgid "Function '%s' at %L cannot have an initializer"
  msgid "Function %qs at %L cannot have an initializer"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Функция '%s' в %L не может иметь инициализатор"
  
  #: fortran/resolve.c:11767
  #, fuzzy, gcc-internal-format
+#| msgid "External object '%s' at %L may not have an initializer"
  msgid "External object %qs at %L may not have an initializer"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Внешний объект '%s' в %L не может иметь инициализатор"
  
  #: fortran/resolve.c:11775
  #, fuzzy, gcc-internal-format
+#| msgid "ELEMENTAL function '%s' at %L must have a scalar result"
  msgid "ELEMENTAL function %qs at %L must have a scalar result"
-msgstr "Предупреждать о неявных декларациях функций"
+msgstr "ELEMENTAL функция '%s' в %L должна иметь скалярный результат"
  
  #: fortran/resolve.c:11785
  #, fuzzy, gcc-internal-format
+#| msgid "Statement function '%s' at %L may not have pointer or allocatable attribute"
  msgid "Statement function %qs at %L may not have pointer or allocatable attribute"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð¸Ð¼ÐµÑ\82Ñ\8c pointer Ð¸Ð»Ð¸ allocatable Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
  #: fortran/resolve.c:11804
  #, fuzzy, gcc-internal-format
+#| msgid "CHARACTER(*) function '%s' at %L cannot be array-valued"
  msgid "CHARACTER(*) function %qs at %L cannot be array-valued"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "CHARACTER(*) функция '%s' в %L не может иметь значение массив"
  
  #: fortran/resolve.c:11808
  #, fuzzy, gcc-internal-format
+#| msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued"
  msgid "CHARACTER(*) function %qs at %L cannot be pointer-valued"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "CHARACTER(*) функция '%s' в %L не может иметь значение указатель"
  
  #: fortran/resolve.c:11812
  #, fuzzy, gcc-internal-format
+#| msgid "CHARACTER(*) function '%s' at %L cannot be pure"
  msgid "CHARACTER(*) function %qs at %L cannot be pure"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "CHARACTER(*) функция '%s' в %L не может быть pure"
  
  #: fortran/resolve.c:11816
  #, fuzzy, gcc-internal-format
+#| msgid "CHARACTER(*) function '%s' at %L cannot be recursive"
  msgid "CHARACTER(*) function %qs at %L cannot be recursive"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "CHARACTER(*) функция '%s' в %L не может быть рекурсивной"
  
  #: fortran/resolve.c:11829
  #, fuzzy, gcc-internal-format
+#| msgid "CHARACTER(*) function '%s' at %L cannot be pure"
  msgid "CHARACTER(*) function %qs at %L"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "CHARACTER(*) функция '%s' в %L не может быть pure"
  
  #: fortran/resolve.c:11838
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' in %s at %L has no explicit interface"
  msgid "Procedure pointer %qs at %L shall not be elemental"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' Ð² %s Ð² %L Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\8fÐ²Ð½Ð¾Ð³Ð¾ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81Ð°"
  
  #: fortran/resolve.c:11844
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy procedure '%s' at %C cannot have a generic interface"
  msgid "Dummy procedure %qs at %L shall not be elemental"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Формальная процедура '%s' в %C не может иметь generic интерфейс"
  
  #: fortran/resolve.c:11900
  #, fuzzy, gcc-internal-format
+#| msgid "PROCEDURE attribute conflicts with SAVE attribute in '%s' at %L"
  msgid "PROCEDURE attribute conflicts with SAVE attribute in %qs at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "PROCEDURE атрибут конфликтует с SAVE атрибутом в '%s' в %L"
  
  #: fortran/resolve.c:11906
  #, fuzzy, gcc-internal-format
+#| msgid "PROCEDURE attribute conflicts with INTENT attribute in '%s' at %L"
  msgid "PROCEDURE attribute conflicts with INTENT attribute in %qs at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "PROCEDURE атрибут конфликтует с INTENT атрибутом в '%s' в %L"
  
  #: fortran/resolve.c:11912
  #, fuzzy, gcc-internal-format
+#| msgid "PROCEDURE attribute conflicts with RESULT attribute in '%s' at %L"
  msgid "PROCEDURE attribute conflicts with RESULT attribute in %qs at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "PROCEDURE атрибут конфликтует с RESULT атрибутом в '%s' в %L"
  
  #: fortran/resolve.c:11920
  #, fuzzy, gcc-internal-format
+#| msgid "EXTERNAL attribute conflicts with FUNCTION attribute in '%s' at %L"
  msgid "EXTERNAL attribute conflicts with FUNCTION attribute in %qs at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "EXTERNAL атрибут конфликтует с FUNCTION атрибутом в '%s' в %L"
  
  #: fortran/resolve.c:11926
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure pointer result '%s' at %L is missing the pointer attribute"
  msgid "Procedure pointer result %qs at %L is missing the pointer attribute"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð ÐµÐ·Ñ\83Ð»Ñ\8cÑ\82Ð°Ñ\82 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 '%s' Ð² %L Ð¾ÐºÐ°Ð·Ð°Ð»Ñ\81Ñ\8f Ð±ÐµÐ· pointer Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð°"
  
  #: fortran/resolve.c:11964
  #, gcc-internal-format, gfc-internal-format
@@ -58108,345 +61007,399 @@ msgstr ""
  
  #: fortran/resolve.c:12074
  #, fuzzy, gcc-internal-format
+#| msgid "FINAL procedure '%s' at %L is not a SUBROUTINE"
  msgid "FINAL procedure %qs at %L is not a SUBROUTINE"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "FINAL процедура '%s' в %L не есть SUBROUTINE"
  
  #: fortran/resolve.c:12083
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "FINAL procedure at %L must have exactly one argument"
-msgstr "%qD должен иметь ровно один аргумент"
+msgstr "FINAL процедура в %L должна иметь ровно один аргумент"
  
  #: fortran/resolve.c:12092
  #, fuzzy, gcc-internal-format
+#| msgid "Argument of FINAL procedure at %L must be of type '%s'"
  msgid "Argument of FINAL procedure at %L must be of type %qs"
-msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 FINAL Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\82Ð¸Ð¿Ð° '%s'"
  
  #: fortran/resolve.c:12100
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Argument of FINAL procedure at %L must not be a POINTER"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 FINAL Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b Ð² %L Ð½Ðµ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c POINTER"
  
  #: fortran/resolve.c:12106
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Argument of FINAL procedure at %L must not be ALLOCATABLE"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 FINAL Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b Ð² %L Ð½Ðµ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c ALLOCATABLE"
  
  #: fortran/resolve.c:12112
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of FINAL procedure at %L must not be OPTIONAL"
-msgstr ""
+msgstr "Аргумент FINAL процедуры в %L не должен быть OPTIONAL"
  
  #: fortran/resolve.c:12120
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of FINAL procedure at %L must not be INTENT(OUT)"
-msgstr ""
+msgstr "Аргумент FINAL процедуры в %L не должен быть INTENT(OUT)"
  
  #: fortran/resolve.c:12129
  #, gcc-internal-format, gfc-internal-format
  msgid "Non-scalar FINAL procedure at %L should have assumed shape argument"
-msgstr ""
+msgstr "Нескалярная FINAL процедура в %L должна иметь аргумент предполагаемой формы"
  
  #: fortran/resolve.c:12151
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "FINAL procedure '%s' declared at %L has the same rank (%d) as '%s'"
  msgid "FINAL procedure %qs declared at %L has the same rank (%d) as %qs"
-msgstr ""
+msgstr "FINAL процедура '%s' декларированная в %L имеет тот же ранг (%d) что и '%s'"
  
  #: fortran/resolve.c:12188
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Only array FINAL procedures declared for derived type '%s' defined at %L, suggest also scalar one"
  msgid "Only array FINAL procedures declared for derived type %qs defined at %L, suggest also scalar one"
-msgstr ""
+msgstr "Только массивные FINAL процедуры декларированные для производного типа '%s' определенного в %L, предлагают также скалярный тип"
  
  #: fortran/resolve.c:12228
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' and '%s' can't be mixed FUNCTION/SUBROUTINE for GENERIC '%s' at %L"
  msgid "%qs and %qs can't be mixed FUNCTION/SUBROUTINE for GENERIC %qs at %L"
-msgstr ""
+msgstr "'%s' и '%s' не могут быть смешанными FUNCTION/SUBROUTINE для GENERIC '%s' в %L"
  
  #: fortran/resolve.c:12264
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' and '%s' for GENERIC '%s' at %L are ambiguous"
  msgid "%qs and %qs for GENERIC %qs at %L are ambiguous"
-msgstr ""
+msgstr "'%s' и '%s' для GENERIC '%s' в %L неоднозначны"
  
  #: fortran/resolve.c:12323
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Undefined specific binding '%s' as target of GENERIC '%s' at %L"
  msgid "Undefined specific binding %qs as target of GENERIC %qs at %L"
-msgstr ""
+msgstr "Неопределенное конкретное связывание '%s' как цели GENERIC '%s' в %L"
  
  #: fortran/resolve.c:12335
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "GENERIC '%s' at %L must target a specific binding, '%s' is GENERIC, too"
  msgid "GENERIC %qs at %L must target a specific binding, %qs is GENERIC, too"
-msgstr ""
+msgstr "GENERIC '%s' в %L должен нацеливаться на конкретное связывание, '%s' также GENERIC"
  
  #: fortran/resolve.c:12363
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "GENERIC '%s' at %L can't overwrite specific binding with the same name"
  msgid "GENERIC %qs at %L can't overwrite specific binding with the same name"
-msgstr ""
+msgstr "GENERIC '%s' в %L не может перебить конкретное связывание с тем же именем"
  
  #: fortran/resolve.c:12419
  #, gcc-internal-format, gfc-internal-format
  msgid "Type-bound operator at %L can't be NOPASS"
-msgstr ""
+msgstr "Type-bound оператор в %L не может быть NOPASS"
  
  #: fortran/resolve.c:12601
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' must be a module procedure or an external procedure with an explicit interface at %L"
  msgid "%qs must be a module procedure or an external procedure with an explicit interface at %L"
-msgstr "Предупреждать о неявных декларациях функций"
+msgstr "'%s' должна быть процедурой модуля или внешней процедурой с явным интерфейсом в %L"
  
  #: fortran/resolve.c:12643
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' with PASS(%s) at %L has no argument '%s'"
  msgid "Procedure %qs with PASS(%s) at %L has no argument %qs"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' Ñ\81 PASS(%s) Ð² %L Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° '%s'"
  
  #: fortran/resolve.c:12657
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' with PASS at %L must have at least one argument"
  msgid "Procedure %qs with PASS at %L must have at least one argument"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' Ñ\81 PASS Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð¸Ð¼ÐµÑ\82Ñ\8c Ð¿Ð¾ ÐºÑ\80Ð°Ð¹Ð½ÐµÐ¹ Ð¼ÐµÑ\80Ðµ Ð¾Ð´Ð¸Ð½ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82"
  
  #: fortran/resolve.c:12671 fortran/resolve.c:13166
  #, fuzzy, gcc-internal-format
+#| msgid "Non-polymorphic passed-object dummy argument of '%s' at %L"
  msgid "Non-polymorphic passed-object dummy argument of %qs at %L"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s в %L"
+msgstr "Ð\9dÐµÐ¿Ð¾Ð»Ð¸Ð¼Ð¾Ñ\80Ñ\84Ð½Ñ\8bÐ¹ passed-object Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' в %L"
  
  #: fortran/resolve.c:12679
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' of '%s' with PASS(%s) at %L must be of the derived-type '%s'"
  msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived-type %qs"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð¾Ñ\82 '%s' Ñ\81 PASS(%s) Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ñ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° '%s'"
  
  #: fortran/resolve.c:12688
  #, fuzzy, gcc-internal-format
+#| msgid "Passed-object dummy argument of '%s' at %L must be scalar"
  msgid "Passed-object dummy argument of %qs at %L must be scalar"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "Passed-object формальный аргумент '%s' в %L должен быть скаляром"
  
  #: fortran/resolve.c:12694
  #, fuzzy, gcc-internal-format
+#| msgid "Passed-object dummy argument of '%s' at %L must not be ALLOCATABLE"
  msgid "Passed-object dummy argument of %qs at %L must not be ALLOCATABLE"
-msgstr "аргумент `%s' должен быть 2-битным беззнаковым литеральным значением"
+msgstr "Passed-object формальный аргумент '%s' в %L не должен быть ALLOCATABLE"
  
  #: fortran/resolve.c:12700
  #, fuzzy, gcc-internal-format
+#| msgid "Passed-object dummy argument of '%s' at %L must not be POINTER"
  msgid "Passed-object dummy argument of %qs at %L must not be POINTER"
-msgstr "Слишком много аргументов %s в %L"
+msgstr "Passed-object формальный аргумент '%s' в %L не должен быть POINTER"
  
  #: fortran/resolve.c:12729
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' at %L has the same name as a component of '%s'"
  msgid "Procedure %qs at %L has the same name as a component of %qs"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Процедура '%s' в %L имеет то же имя что и компонент '%s'"
  
  #: fortran/resolve.c:12738
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' at %L has the same name as an inherited component of '%s'"
  msgid "Procedure %qs at %L has the same name as an inherited component of %qs"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Процедура '%s' в %L имеет то же имя что и унаследованный компонент '%s'"
  
  #: fortran/resolve.c:12830
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Derived-type '%s' declared at %L must be ABSTRACT because '%s' is DEFERRED and not overridden"
  msgid "Derived-type %qs declared at %L must be ABSTRACT because %qs is DEFERRED and not overridden"
-msgstr ""
+msgstr "Производный тип '%s' декларированный в %L должен быть ABSTRACT поскольку '%s' есть DEFERRED и не перебивается"
  
  #: fortran/resolve.c:12928
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "As extending type '%s' at %L has a coarray component, parent type '%s' shall also have one"
  msgid "As extending type %qs at %L has a coarray component, parent type %qs shall also have one"
-msgstr ""
+msgstr "Поскольку расширяющий тип '%s' в %L имеет комассивный компонент, родительский тип '%s' должен также иметь его"
  
  #: fortran/resolve.c:12941
  #, fuzzy, gcc-internal-format
+#| msgid "Non-extensible derived-type '%s' at %L must not be ABSTRACT"
  msgid "Non-extensible derived-type %qs at %L must not be ABSTRACT"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Нерасширяемый производный тип '%s' в %L не должен быть ABSTRACT"
  
  #: fortran/resolve.c:12961
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Coarray component '%s' at %L must be allocatable with deferred shape"
  msgid "Coarray component %qs at %L must be allocatable with deferred shape"
-msgstr ""
+msgstr "Комассивный компонент '%s' в %L должен быть размещаемым с отложенной формой"
  
  #: fortran/resolve.c:12971
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Component '%s' at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
  msgid "Component %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
-msgstr ""
+msgstr "Компонент '%s' в %L типа TYPE(C_PTR) или TYPE(C_FUNPTR) не должен быть комассивом"
  
  #: fortran/resolve.c:12982
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Component '%s' at %L with coarray component shall be a nonpointer, nonallocatable scalar"
  msgid "Component %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar"
-msgstr ""
+msgstr "Компонент '%s' в %L с комассивным компонентом должен быть неуказательным, неразмещаемым скаляром"
  
  #: fortran/resolve.c:12992
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Component '%s' at %L has the CONTIGUOUS attribute but is not an array pointer"
  msgid "Component %qs at %L has the CONTIGUOUS attribute but is not an array pointer"
-msgstr ""
+msgstr "Компонент '%s' в %L имеет CONTIGUOUS атрибут но не является указателем на массив"
  
  #: fortran/resolve.c:13093
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure pointer component '%s' with PASS(%s) at %L has no argument '%s'"
  msgid "Procedure pointer component %qs with PASS(%s) at %L has no argument %qs"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 '%s' Ñ\81 PASS(%s) Ð² %L Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° '%s'"
  
  #: fortran/resolve.c:13108
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure pointer component '%s' with PASS at %L must have at least one argument"
  msgid "Procedure pointer component %qs with PASS at %L must have at least one argument"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c Ð½Ð° Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\83 '%s' Ñ\81 PASS Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð¸Ð¼ÐµÑ\82Ñ\8c Ð¿Ð¾ ÐºÑ\80Ð°Ð¹Ð½ÐµÐ¹ Ð¼ÐµÑ\80Ðµ Ð¾Ð´Ð¸Ð½ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82"
  
  #: fortran/resolve.c:13125
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' of '%s' with PASS(%s) at %L must be of the derived type '%s'"
  msgid "Argument %qs of %qs with PASS(%s) at %L must be of the derived type %qs"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð¾Ñ\82 '%s' Ñ\81 PASS(%s) Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð¿Ñ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° '%s'"
  
  #: fortran/resolve.c:13136
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' of '%s' with PASS(%s) at %L must be scalar"
  msgid "Argument %qs of %qs with PASS(%s) at %L must be scalar"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð¾Ñ\82 '%s' Ñ\81 PASS(%s) Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80Ð¾Ð¼"
  
  #: fortran/resolve.c:13146
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' of '%s' with PASS(%s) at %L may not have the POINTER attribute"
  msgid "Argument %qs of %qs with PASS(%s) at %L may not have the POINTER attribute"
-msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ð² %C Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 POINTER"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð¾Ñ\82 '%s' Ñ\81 PASS(%s) Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð¸Ð¼ÐµÑ\82Ñ\8c POINTER Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
  #: fortran/resolve.c:13156
  #, fuzzy, gcc-internal-format
+#| msgid "Argument '%s' of '%s' with PASS(%s) at %L may not be ALLOCATABLE"
  msgid "Argument %qs of %qs with PASS(%s) at %L may not be ALLOCATABLE"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð¾Ñ\82 '%s' Ñ\81 PASS(%s) Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c ALLOCATABLE"
  
  #: fortran/resolve.c:13198
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Component '%s' of '%s' at %L has the same name as an inherited type-bound procedure"
  msgid "Component %qs of %qs at %L has the same name as an inherited type-bound procedure"
-msgstr ""
+msgstr "Компонент '%s' от '%s' в %L имеет то же имя что и унаследованная type-bound процедура"
  
  #: fortran/resolve.c:13211
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Character length of component '%s' needs to be a constant specification expression at %L"
  msgid "Character length of component %qs needs to be a constant specification expression at %L"
-msgstr ""
+msgstr "Character длина компонента '%s' должна быть константным спецификационным выражением в %L"
  
  #: fortran/resolve.c:13222
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Character component '%s' of '%s' at %L with deferred length must be a POINTER or ALLOCATABLE"
  msgid "Character component %qs of %qs at %L with deferred length must be a POINTER or ALLOCATABLE"
-msgstr ""
+msgstr "Character компонент '%s' от '%s' в %L с отложенной длиной должен быть POINTER или ALLOCATABLE"
  
  #: fortran/resolve.c:13253
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: the component '%s' is a PRIVATE type and cannot be a component of '%s', which is PUBLIC at %L"
  msgid "the component %qs is a PRIVATE type and cannot be a component of %qs, which is PUBLIC at %L"
-msgstr ""
+msgstr "Fortran 2003: компонент '%s' имеет PRIVATE тип и не может быть компонентом '%s', который PUBLIC в %L"
  
  #: fortran/resolve.c:13261
  #, gcc-internal-format, gfc-internal-format
  msgid "Polymorphic component %s at %L in SEQUENCE or BIND(C) type %s"
-msgstr ""
+msgstr "Полиморфный компонент %s в %L в SEQUENCE или BIND(C) типе %s"
  
  #: fortran/resolve.c:13270
  #, gcc-internal-format, gfc-internal-format
  msgid "Component %s of SEQUENCE type declared at %L does not have the SEQUENCE attribute"
-msgstr ""
+msgstr "Компонент %s SEQUENCE типа декларированный в %L не имеет SEQUENCE атрибут"
  
  #: fortran/resolve.c:13288 fortran/resolve.c:13300
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The pointer component '%s' of '%s' at %L is a type that has not been declared"
  msgid "The pointer component %qs of %qs at %L is a type that has not been declared"
-msgstr ""
+msgstr "Компонент указатель '%s' от '%s' в %L есть тип который не был декларирован"
  
  #: fortran/resolve.c:13312
  #, fuzzy, gcc-internal-format
+#| msgid "Component '%s' with CLASS at %L must be allocatable or pointer"
  msgid "Component %qs with CLASS at %L must be allocatable or pointer"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 '%s' Ñ\81 CLASS Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\80Ð°Ð·Ð¼ÐµÑ\89Ð°ÐµÐ¼Ñ\8bÐ¼ Ð¸Ð»Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»ÐµÐ¼"
  
  #: fortran/resolve.c:13380
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: Generic name '%s' of function '%s' at %L being the same name as derived type at %L"
  msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
-msgstr ""
+msgstr "Fortran 2003: Generic имя '%s' функции '%s' в %L то же что и имя производного типа в %L"
  
  #: fortran/resolve.c:13436
  #, fuzzy, gcc-internal-format
+#| msgid "Assumed size array '%s' in namelist '%s' at %L is not allowed"
  msgid "Assumed size array %qs in namelist %qs at %L is not allowed"
-msgstr "Ð\90Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+msgstr "Ð\9cÐ°Ñ\81Ñ\81Ð¸Ð² Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° '%s' Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¸Ð¼ÐµÐ½ '%s' Ð² %L Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f"
  
  #: fortran/resolve.c:13442
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: NAMELIST array object '%s' with assumed shape in namelist '%s' at %L"
  msgid "NAMELIST array object %qs with assumed shape in namelist %qs at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "Fortran 2003: NAMELIST массивный объект '%s' с предполагаемой формой в списке имен '%s' в %L"
  
  #: fortran/resolve.c:13448
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: NAMELIST array object '%s' with nonconstant shape in namelist '%s' at %L"
  msgid "NAMELIST array object %qs with nonconstant shape in namelist %qs at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "Fortran 2003: NAMELIST массивный объект  '%s' с неконстантной формой в списке имен '%s' в %L"
  
  #: fortran/resolve.c:13456
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: NAMELIST object '%s' with nonconstant character length in namelist '%s' at %L"
  msgid "NAMELIST object %qs with nonconstant character length in namelist %qs at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "Fortran 2003: NAMELIST объект '%s' с неконстантной character длиной в списке имен '%s' в %L"
  
  #: fortran/resolve.c:13466
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "NAMELIST object '%s' in namelist '%s' at %L is polymorphic and requires a defined input/output procedure"
  msgid "NAMELIST object %qs in namelist %qs at %L is polymorphic and requires a defined input/output procedure"
-msgstr ""
+msgstr "NAMELIST объект '%s' в списке имен '%s' в %L является полиморфным и требует определенную процедуру ввода/вывода"
  
  #: fortran/resolve.c:13476
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: NAMELIST object '%s' in namelist '%s' at %L with ALLOCATABLE or POINTER components"
  msgid "NAMELIST object %qs in namelist %qs at %L with ALLOCATABLE or POINTER components"
-msgstr ""
+msgstr "Fortran 2003: NAMELIST объект '%s' в списке имен '%s' в %L с ALLOCATABLE или POINTER компонентами"
  
  #. FIXME: Once UDDTIO is implemented, the following can be
  #. removed.
  #: fortran/resolve.c:13484
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "NAMELIST object '%s' in namelist '%s' at %L has ALLOCATABLE or POINTER components and thus requires a defined input/output procedure"
  msgid "NAMELIST object %qs in namelist %qs at %L has ALLOCATABLE or POINTER components and thus requires a defined input/output procedure"
-msgstr ""
+msgstr "NAMELIST объект '%s' в списке имен '%s' в %L имеет ALLOCATABLE или POINTER компоненты и поэтому требует определенную процедуру ввода/вывода"
  
  #: fortran/resolve.c:13501
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "NAMELIST object '%s' was declared PRIVATE and cannot be member of PUBLIC namelist '%s' at %L"
  msgid "NAMELIST object %qs was declared PRIVATE and cannot be member of PUBLIC namelist %qs at %L"
-msgstr ""
+msgstr "NAMELIST объект '%s' был декларирован PRIVATE и не может быть членом PUBLIC списка имен '%s' в %L"
  
  #: fortran/resolve.c:13511
  #, fuzzy, gcc-internal-format
+#| msgid "NAMELIST object '%s' has use-associated PRIVATE components and cannot be member of namelist '%s' at %L"
  msgid "NAMELIST object %qs has use-associated PRIVATE components and cannot be member of namelist %qs at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "NAMELIST объект '%s' имеет use-associated PRIVATE компоненты и не может быть членом списка имен '%s' в %L"
  
  #: fortran/resolve.c:13522
  #, fuzzy, gcc-internal-format
+#| msgid "NAMELIST object '%s' has PRIVATE components and cannot be a member of PUBLIC namelist '%s' at %L"
  msgid "NAMELIST object %qs has PRIVATE components and cannot be a member of PUBLIC namelist %qs at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "NAMELIST объект '%s' имеет PRIVATE компоненты и не может быть членом PUBLIC списка имен '%s' в %L"
  
  #: fortran/resolve.c:13549
  #, fuzzy, gcc-internal-format
+#| msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L"
  msgid "PROCEDURE attribute conflicts with NAMELIST attribute in %qs at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "PROCEDURE атрибут конфликтует с NAMELIST атрибутом в '%s' в %L"
  
  #: fortran/resolve.c:13568
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Parameter array '%s' at %L cannot be automatic or of deferred shape"
  msgid "Parameter array %qs at %L cannot be automatic or of deferred shape"
-msgstr ""
+msgstr "Parameter массив '%s' at %L не может быть автоматическим или отложенной формы"
  
  #: fortran/resolve.c:13580
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Implicitly typed PARAMETER '%s' at %L doesn't match a later IMPLICIT type"
  msgid "Implicitly typed PARAMETER %qs at %L doesn't match a later IMPLICIT type"
-msgstr ""
+msgstr "Неявно типизированный PARAMETER '%s' в %L не соотвествует более позднему IMPLICIT типу"
  
  #: fortran/resolve.c:13591
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Incompatible derived type in PARAMETER at %L"
-msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ `%s'"
+msgstr "Ð\9dÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ð¿Ñ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð² PARAMETER Ð² %L"
  
  #: fortran/resolve.c:13678
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "PROTECTED атрибут конфликтует с EXTERNAL атрибутом в %L"
  
  #: fortran/resolve.c:13681
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "PROCEDURE атрибут конфликтует с PROTECTED атрибутом в %L"
  
  #: fortran/resolve.c:13770
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape array"
  msgid "%qs at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array"
-msgstr ""
+msgstr "'%s' в %L имеет CONTIGUOUS атрибут но не является указателем на массив или массивом предполагаемой формы"
  
  #: fortran/resolve.c:13788
  #, gcc-internal-format, gfc-internal-format
  msgid "Assumed size array at %L must be a dummy argument"
-msgstr ""
+msgstr "Массив предполагаемого размера в %L должен быть формальным аргументом"
  
  #: fortran/resolve.c:13791
  #, gcc-internal-format, gfc-internal-format
  msgid "Assumed shape array at %L must be a dummy argument"
-msgstr ""
+msgstr "Массив предполагаемой формы в %L должен быть формальным аргументом"
  
  #: fortran/resolve.c:13799
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Assumed shape array at %L must be a dummy argument"
  msgid "Assumed-rank array at %L must be a dummy argument"
-msgstr "Ð\90Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² %0 Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ð³Ð»Ð°Ð²Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+msgstr "Ð\9cÐ°Ñ\81Ñ\81Ð¸Ð² Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð¹ Ñ\84Ð¾Ñ\80Ð¼Ñ\8b Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼"
  
  #: fortran/resolve.c:13806
  #, gcc-internal-format, gfc-internal-format
@@ -58456,27 +61409,31 @@ msgstr ""
  #: fortran/resolve.c:13819
  #, gcc-internal-format, gfc-internal-format
  msgid "Symbol at %L is not a DUMMY variable"
-msgstr ""
+msgstr "Символ в %L не является DUMMY переменной"
  
  #: fortran/resolve.c:13825
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L cannot have the VALUE attribute because it is not a dummy argument"
  msgid "%qs at %L cannot have the VALUE attribute because it is not a dummy argument"
-msgstr ""
+msgstr "'%s' в %L не может иметь VALUE атрибут поскольку он не является формальным аргументом"
  
  #: fortran/resolve.c:13835
  #, fuzzy, gcc-internal-format
+#| msgid "Character dummy variable '%s' at %L with VALUE attribute must have constant length"
  msgid "Character dummy variable %qs at %L with VALUE attribute must have constant length"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "Character формальная переменная '%s' в %L с VALUE атрибутом должна иметь константную длину"
  
  #: fortran/resolve.c:13844
  #, fuzzy, gcc-internal-format
+#| msgid "C interoperable character dummy variable '%s' at %L with VALUE attribute must have length one"
  msgid "C interoperable character dummy variable %qs at %L with VALUE attribute must have length one"
-msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+msgstr "C совместимая character формальная переменная '%s' в %L с VALUE атрибутом должна иметь длину один"
  
  #: fortran/resolve.c:13857 fortran/resolve.c:14024
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The derived type '%s' at %L is of type '%s', which has not been defined"
  msgid "The derived type %qs at %L is of type %qs, which has not been defined"
-msgstr ""
+msgstr "Производный тип '%s' в %L имеет тип '%s', который не был определен"
  
  #: fortran/resolve.c:13871
  #, gcc-internal-format, gfc-internal-format
@@ -58489,134 +61446,158 @@ msgid "Variable %s at %L with NO_ARG_CHECK attribute shall be of type TYPE(*) or
  msgstr ""
  
  #: fortran/resolve.c:13889
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
  msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
-msgstr ""
+msgstr "Переменная '%s' в %L не может иметь оба атрибута ALLOCATABLE и BIND(C)"
  
  #: fortran/resolve.c:13897
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes"
  msgid "Variable %s at %L with NO_ARG_CHECK attribute may not have the INTENT(OUT) attribute"
-msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ð² %C Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 POINTER"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð¸Ð¼ÐµÑ\82Ñ\8c Ð¾Ð±Ð° Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° POINTER Ð¸ BIND(C)"
  
  #: fortran/resolve.c:13904
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "'%s' at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape array"
  msgid "Variable %s at %L with NO_ARG_CHECK attribute shall either be a scalar or an assumed-size array"
-msgstr ""
+msgstr "'%s' в %L имеет CONTIGUOUS атрибут но не является указателем на массив или массивом предполагаемой формы"
  
  #: fortran/resolve.c:13924
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Assumed shape array '%s' at %L is not permitted in an initialization expression"
  msgid "Assumed type of variable %s at %L is only permitted for dummy variables"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Массив предполагаемой формы '%s' в %L не разрешен в инициализационном выражении"
  
  #: fortran/resolve.c:13931
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes"
  msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute"
-msgstr ""
+msgstr "Переменная '%s' в %L не может иметь оба атрибута ALLOCATABLE и BIND(C)"
  
  #: fortran/resolve.c:13938
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes"
  msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute"
-msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ð² %C Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 POINTER"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð¸Ð¼ÐµÑ\82Ñ\8c Ð¾Ð±Ð° Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð° POINTER Ð¸ BIND(C)"
  
  #: fortran/resolve.c:13945
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Loop variable at %C cannot be a coarray"
  msgid "Assumed-type variable %s at %L shall not be an explicit-shape array"
-msgstr "Ð½Ðµ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ %qs Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ñ\81Ð¾Ð´ÐµÑ\80Ð¶Ð°Ñ\82Ñ\8c Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ñ\8b"
+msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f Ñ\86Ð¸ÐºÐ»Ð° Ð² %C Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c ÐºÐ¾Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾Ð¼"
  
  #: fortran/resolve.c:13970
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
  msgid "Variable %qs at %L cannot be BIND(C) because it is neither a COMMON block nor declared at the module level scope"
-msgstr ""
+msgstr "Переменная '%s' at %L не может быть BIND(C) поскольку она не COMMON блок и не декларирована на уровне модуля"
  
  #: fortran/resolve.c:14050
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: PUBLIC %s '%s' at %L of PRIVATE derived type '%s'"
  msgid "PUBLIC %s %qs at %L of PRIVATE derived type %qs"
-msgstr "%qD не является элементом типа %qT"
+msgstr "Fortran 2003: PUBLIC %s '%s' в %L PRIVATE производного типа '%s'"
  
  #: fortran/resolve.c:14065
  #, gcc-internal-format, gfc-internal-format
  msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
-msgstr ""
+msgstr "Переменная %s в %L типа LOCK_TYPE или с подкомпонентом типа LOCK_TYPE должна быть комассивом"
  
  #: fortran/resolve.c:14078
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
  msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
-msgstr ""
+msgstr "Переменная %s в %L типа LOCK_TYPE или с подкомпонентом типа LOCK_TYPE должна быть комассивом"
  
  #: fortran/resolve.c:14096
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The INTENT(OUT) dummy argument '%s' at %L is ASSUMED SIZE and so cannot have a default initializer"
  msgid "The INTENT(OUT) dummy argument %qs at %L is ASSUMED SIZE and so cannot have a default initializer"
-msgstr ""
+msgstr "The INTENT(OUT) формальный аргумент '%s' в %L имеет ASSUMED SIZE и поэтому не может иметь подразумеваемый инициализатор"
  
  #: fortran/resolve.c:14108
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy argument '%s' at %L of LOCK_TYPE shall not be INTENT(OUT)"
  msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð¤Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð² %L Ñ\82Ð¸Ð¿Ð° LOCK_TYPE Ð½Ðµ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c INTENT(OUT)"
  
  #: fortran/resolve.c:14117
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy argument '%s' at %L of LOCK_TYPE shall not be INTENT(OUT)"
  msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð¤Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð² %L Ñ\82Ð¸Ð¿Ð° LOCK_TYPE Ð½Ðµ Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c INTENT(OUT)"
  
  #: fortran/resolve.c:14129
  #, fuzzy, gcc-internal-format
+#| msgid "Function result '%s' at %L shall not be a coarray or have a coarray component"
  msgid "Function result %qs at %L shall not be a coarray or have a coarray component"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Результат функции '%s' в %L не должен быть комассивом или иметь комассивный компонент"
  
  #: fortran/resolve.c:14138
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
  msgid "Variable %qs at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray"
-msgstr ""
+msgstr "Переменная '%s' в %L типа TYPE(C_PTR) или TYPE(C_FUNPTR) не должна быть комассивом"
  
  #: fortran/resolve.c:14150
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L with coarray component shall be a nonpointer, nonallocatable scalar"
  msgid "Variable %qs at %L with coarray component shall be a nonpointer, nonallocatable scalar, which is not a coarray"
-msgstr ""
+msgstr "Переменная '%s' в %L с комассивным компонентом должна быть неуказательным, неразмещаемым скаляром"
  
  #: fortran/resolve.c:14165
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
  msgid "Variable %qs at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument"
-msgstr ""
+msgstr "Переменная '%s' в %L является комассивом и не является ни ALLOCATABLE, ни SAVE, ни формальным аргументом"
  
  #: fortran/resolve.c:14173
  #, fuzzy, gcc-internal-format
+#| msgid "Coarray variable '%s' at %L shall not have codimensions with deferred shape"
  msgid "Coarray variable %qs at %L shall not have codimensions with deferred shape"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Комассивная переменная '%s' в %L не должна иметь коизмерения с отложенной формой"
  
  #: fortran/resolve.c:14180
  #, fuzzy, gcc-internal-format
+#| msgid "Allocatable coarray variable '%s' at %L must have deferred shape"
  msgid "Allocatable coarray variable %qs at %L must have deferred shape"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Размещаемая комассивная переменная '%s' в %L должна иметь отложенную форму"
  
  #: fortran/resolve.c:14192
  #, fuzzy, gcc-internal-format
+#| msgid "Variable '%s' at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
  msgid "Variable %qs at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Переменная '%s' в %L является INTENT(OUT) и может поэтому не быть размещаемым комассивом или иметь комассивные компоненты"
  
  #: fortran/resolve.c:14201
  #, fuzzy, gcc-internal-format
+#| msgid "Coarray dummy variable '%s' at %L not allowed in BIND(C) procedure '%s'"
  msgid "Coarray dummy variable %qs at %L not allowed in BIND(C) procedure %qs"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Комассивная формальная переменная '%s' в %L не допускается в BIND(C) процедуре '%s'"
  
  #: fortran/resolve.c:14217
  #, fuzzy, gcc-internal-format
+#| msgid "Coarray dummy variable '%s' at %L not allowed in BIND(C) procedure '%s'"
  msgid "LOGICAL dummy argument %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Комассивная формальная переменная '%s' в %L не допускается в BIND(C) процедуре '%s'"
  
  #: fortran/resolve.c:14223
  #, fuzzy, gcc-internal-format
+#| msgid "Coarray dummy variable '%s' at %L not allowed in BIND(C) procedure '%s'"
  msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedure %qs"
-msgstr "%s не может присутствовать в константном выражении"
+msgstr "Комассивная формальная переменная '%s' в %L не допускается в BIND(C) процедуре '%s'"
  
  #: fortran/resolve.c:14248
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Namelist %s cannot be renamed by USE association to %s"
  msgid "Namelist '%s' can not be an argument to subroutine or function at %L"
-msgstr ""
+msgstr "Список имен %s не может быть переименован путем USE ассоциации в %s"
  
  #: fortran/resolve.c:14317
  #, gcc-internal-format, gfc-internal-format
  msgid "Threadprivate at %L isn't SAVEd"
-msgstr ""
+msgstr "Threadprivate в %L не является SAVEd"
  
  #: fortran/resolve.c:14328
  #, gcc-internal-format
@@ -58630,198 +61611,221 @@ msgstr ""
  
  #: fortran/resolve.c:14426
  #, fuzzy, gcc-internal-format
+#| msgid "BLOCK DATA element '%s' at %L must be in COMMON"
  msgid "BLOCK DATA element %qs at %L must be in COMMON"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "BLOCK DATA элемент '%s' в %L должен быть в COMMON"
  
  #: fortran/resolve.c:14432
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "DATA array '%s' at %L must be specified in a previous declaration"
  msgid "DATA array %qs at %L must be specified in a previous declaration"
-msgstr ""
+msgstr "DATA массив '%s' в %L должен быть специфицирован в предшествующей декларации"
  
  #: fortran/resolve.c:14441
  #, fuzzy, gcc-internal-format
+#| msgid "DATA element '%s' at %L cannot have a coindex"
  msgid "DATA element %qs at %L cannot have a coindex"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "DATA элемент '%s' в %L не может иметь коиндекс"
  
  #: fortran/resolve.c:14455
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "DATA element '%s' at %L is a pointer and so must be a full array"
  msgid "DATA element %qs at %L is a pointer and so must be a full array"
-msgstr ""
+msgstr "DATA элемент '%s' в %L является указателем и поэтому должен быть полным массивом"
  
  #: fortran/resolve.c:14501
  #, gcc-internal-format, gfc-internal-format
  msgid "Nonconstant array section at %L in DATA statement"
-msgstr ""
+msgstr "Неконстантная секция массива в %L в DATA операторе"
  
  #: fortran/resolve.c:14514
  #, gcc-internal-format, gfc-internal-format
  msgid "DATA statement at %L has more variables than values"
-msgstr ""
+msgstr "DATA оператор в %L имеет больше переменных чем значений"
  
  #: fortran/resolve.c:14613
  #, gcc-internal-format, gfc-internal-format
  msgid "start of implied-do loop at %L could not be simplified to a constant value"
-msgstr ""
+msgstr "начало implied-do цикла в %L не может быть упрощено до константного значения"
  
  #: fortran/resolve.c:14621
  #, gcc-internal-format, gfc-internal-format
  msgid "end of implied-do loop at %L could not be simplified to a constant value"
-msgstr ""
+msgstr "окончание implied-do цикла в %L не может быть упрощено до константного значения"
  
  #: fortran/resolve.c:14629
  #, gcc-internal-format, gfc-internal-format
  msgid "step of implied-do loop at %L could not be simplified to a constant value"
-msgstr ""
+msgstr "шаг implied-do цикла в %L не может быть упрощен до константного значения"
  
  #: fortran/resolve.c:14754
  #, gcc-internal-format, gfc-internal-format
  msgid "DATA statement at %L has more values than variables"
-msgstr ""
+msgstr "DATA оператор в %L имеет больше значений чем переменных"
  
  #: fortran/resolve.c:14919
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Label %d at %L defined but not used"
-msgstr "Ð¼ÐµÑ\82ÐºÐ° %qD Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð°, но не используется"
+msgstr "Ð\9cÐµÑ\82ÐºÐ° %d Ð² %L Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð° но не используется"
  
  #: fortran/resolve.c:14924
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Label %d at %L defined but cannot be used"
-msgstr "Ð¼ÐµÑ\82ÐºÐ° %qD Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð°, Ð½Ð¾ Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\9cÐµÑ\82ÐºÐ° %d Ð² %L Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð° Ð½Ð¾ Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð°"
  
  #: fortran/resolve.c:15008
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
  msgid "Derived type variable %qs at %L must have SEQUENCE attribute to be an EQUIVALENCE object"
-msgstr ""
+msgstr "Переменная производного типа '%s' в %L должна иметь SEQUENCE атрибут чтобы быть EQUIVALENCE объектом"
  
  #: fortran/resolve.c:15017
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Derived type variable '%s' at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
  msgid "Derived type variable %qs at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object"
-msgstr ""
+msgstr "Переменная производного типа '%s' в %L не может иметь ALLOCATABLE компоненты чтобы быть EQUIVALENCE объектом"
  
  #: fortran/resolve.c:15025
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Derived type variable '%s' at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
  msgid "Derived type variable %qs at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON"
-msgstr ""
+msgstr "Переменная производного типа '%s' в %L с подразумеваемой инициализацией не может быть в EQUIVALENCE с переменной в COMMON"
  
  #: fortran/resolve.c:15041
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Derived type variable '%s' at %L with pointer component(s) cannot be an EQUIVALENCE object"
  msgid "Derived type variable %qs at %L with pointer component(s) cannot be an EQUIVALENCE object"
-msgstr ""
+msgstr "Переменная производного типа '%s' в %L с указательными компонентами не может быть EQUIVALENCE объектом"
  
  #: fortran/resolve.c:15144
  #, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in EQUIVALENCE statement at %L"
-msgstr ""
+msgstr "Синтаксическая ошибка в EQUIVALENCE операторе в %L"
  
  #: fortran/resolve.c:15159
  #, gcc-internal-format, gfc-internal-format
  msgid "Either all or none of the objects in the EQUIVALENCE set at %L shall have the PROTECTED attribute"
-msgstr ""
+msgstr "Все или никакие объекты в EQUIVALENCE множестве в %L должны иметь PROTECTED атрибут"
  
  #: fortran/resolve.c:15171
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Common block member '%s' at %L cannot be an EQUIVALENCE object in the pure procedure '%s'"
  msgid "Common block member %qs at %L cannot be an EQUIVALENCE object in the pure procedure %qs"
-msgstr ""
+msgstr "Член common блока '%s' в %L не может быть EQUIVALENCE объектом в pure процедуре '%s'"
  
  #: fortran/resolve.c:15180
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Named constant '%s' at %L cannot be an EQUIVALENCE object"
  msgid "Named constant %qs at %L cannot be an EQUIVALENCE object"
-msgstr ""
+msgstr "Именованная константа '%s' at %L не может быть EQUIVALENCE объектом"
  
  #: fortran/resolve.c:15253
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Array '%s' at %L with non-constant bounds cannot be an EQUIVALENCE object"
  msgid "Array %qs at %L with non-constant bounds cannot be an EQUIVALENCE object"
-msgstr ""
+msgstr "Массив '%s' at %L с неконстантными границами не может быть EQUIVALENCE объектом"
  
  #: fortran/resolve.c:15264
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Structure component '%s' at %L cannot be an EQUIVALENCE object"
  msgid "Structure component %qs at %L cannot be an EQUIVALENCE object"
-msgstr ""
+msgstr "Компонент структуры '%s' at %L не может быть EQUIVALENCE объектом"
  
  #: fortran/resolve.c:15275
  #, gcc-internal-format, gfc-internal-format
  msgid "Substring at %L has length zero"
-msgstr ""
+msgstr "Подстрока в %L имеет нулевую длину"
  
  #: fortran/resolve.c:15318
  #, fuzzy, gcc-internal-format
+#| msgid "Fortran 2003: PUBLIC function '%s' at %L of PRIVATE type '%s'"
  msgid "PUBLIC function %qs at %L of PRIVATE type %qs"
-msgstr "%qD не является элементом типа %qT"
+msgstr "Fortran 2003: PUBLIC функция '%s' в %L PRIVATE типа '%s'"
  
  #: fortran/resolve.c:15331
  #, fuzzy, gcc-internal-format
+#| msgid "ENTRY '%s' at %L has no IMPLICIT type"
  msgid "ENTRY %qs at %L has no IMPLICIT type"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "ENTRY '%s' в %L не имеет IMPLICIT типа"
  
  #: fortran/resolve.c:15348
  #, fuzzy, gcc-internal-format
+#| msgid "User operator procedure '%s' at %L must be a FUNCTION"
  msgid "User operator procedure %qs at %L must be a FUNCTION"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `asm' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð°Ñ\8f Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ°"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82ÐµÐ»Ñ\8cÑ\81ÐºÐ¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° '%s' Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c FUNCTION"
  
  #: fortran/resolve.c:15358
  #, fuzzy, gcc-internal-format
+#| msgid "User operator procedure '%s' at %L cannot be assumed character length"
  msgid "User operator procedure %qs at %L cannot be assumed character length"
-msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ð¾Ñ\80 Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð¼-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸ÐµÐ¹"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82ÐµÐ»Ñ\8cÑ\81ÐºÐ¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c character Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð¹ Ð´Ð»Ð¸Ð½Ñ\8b"
  
  #: fortran/resolve.c:15366
  #, fuzzy, gcc-internal-format
+#| msgid "User operator procedure '%s' at %L must have at least one argument"
  msgid "User operator procedure %qs at %L must have at least one argument"
-msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82ÐµÐ»Ñ\8cÑ\81ÐºÐ¾Ð³Ð¾ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° '%s' Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð¸Ð¼ÐµÑ\82Ñ\8c Ð¿Ð¾ ÐºÑ\80Ð°Ð¹Ð½ÐµÐ¹ Ð¼ÐµÑ\80Ðµ Ð¾Ð´Ð¸Ð½ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82"
  
  #: fortran/resolve.c:15380
  #, gcc-internal-format, gfc-internal-format
  msgid "First argument of operator interface at %L cannot be optional"
-msgstr ""
+msgstr "Первый аргумент интерфейса оператора в %L не может быть необязательным"
  
  #: fortran/resolve.c:15398
  #, gcc-internal-format, gfc-internal-format
  msgid "Second argument of operator interface at %L cannot be optional"
-msgstr ""
+msgstr "Второй аргумент интерфейса оператора в %L не может быть необязательным"
  
  #: fortran/resolve.c:15405
  #, gcc-internal-format, gfc-internal-format
  msgid "Operator interface at %L must have, at most, two arguments"
-msgstr ""
+msgstr "Интерфейс оператора в %L должен иметь не более двух аргументов"
  
  #: fortran/resolve.c:15483
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Contained procedure '%s' at %L of a PURE procedure must also be PURE"
  msgid "Contained procedure %qs at %L of a PURE procedure must also be PURE"
-msgstr ""
+msgstr "Внутренняя процедура '%s' в %L PURE процедуры должна также быть PURE"
  
+#
  #: fortran/scanner.c:330
  #, fuzzy, gcc-internal-format
+#| msgid "can't create directory %s: %m"
  msgid "Include directory %qs: %s"
-msgstr "ошибка записи в %s: %m"
+msgstr "ошибка создания каталога %s: %m"
  
  #: fortran/scanner.c:334
  #, fuzzy, gcc-internal-format
+#| msgid "ignoring nonexistent directory \"%s\"\n"
  msgid "Nonexistent include directory %qs"
  msgstr "несуществующий каталог \"%s\" проигнорирован\n"
  
  #: fortran/scanner.c:339
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is not a type"
  msgid "%qs is not a directory"
  msgstr "%qD не является типом"
  
  #: fortran/scanner.c:742
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
  msgid "!$ACC at %C starts a commented line as it neither is followed by a space nor is a continuation line"
-msgstr ""
+msgstr "!$OMP в %C начинает закомментированную строку поскольку за ним не следует пробел и это не строка продолжения"
  
  #: fortran/scanner.c:782
  #, gcc-internal-format, gfc-internal-format
  msgid "!$OMP at %C starts a commented line as it neither is followed by a space nor is a continuation line"
-msgstr ""
+msgstr "!$OMP в %C начинает закомментированную строку поскольку за ним не следует пробел и это не строка продолжения"
  
  #: fortran/scanner.c:1275 fortran/scanner.c:1464
  #, gcc-internal-format, gfc-internal-format
  msgid "Line truncated at %L"
-msgstr ""
+msgstr "Строка усечена в %L"
  
  #: fortran/scanner.c:1331 fortran/scanner.c:1541
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Limit of %d continuations exceeded in statement at %C"
-msgstr "Ð\98Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¿Ñ\83Ñ\81Ñ\82Ð¾Ð³Ð¾ Ð¾Ð±Ñ\89ÐµÐ³Ð¾ Ð±Ð»Ð¾ÐºÐ° Ð² %0"
+msgstr "Ð\9bÐ¸Ð¼Ð¸Ñ\82 Ð² %d Ñ\81Ñ\82Ñ\80Ð¾Ðº Ð¿Ñ\80Ð¾Ð´Ð¾Ð»Ð¶ÐµÐ½Ð¸Ñ\8f Ð¿Ñ\80ÐµÐ²Ñ\8bÑ\88ÐµÐ½ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/scanner.c:1409 fortran/scanner.c:1502
  #, gcc-internal-format, gfc-internal-format
@@ -58830,68 +61834,73 @@ msgstr ""
  
  #: fortran/scanner.c:1422
  #, fuzzy, gcc-internal-format
+#| msgid "Missing '&' in continued character constant at %C"
  msgid "Missing %<&%> in continued character constant at %C"
-msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð»Ñ\8cÐ½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð¹ Ð´Ð»Ð¸Ð½Ñ\8b Ð² %0"
+msgstr "Ð\9eÑ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 '&' Ð² Ð¿Ñ\80Ð¾Ð´Ð¾Ð»Ð¶ÐµÐ½Ð½Ð¾Ð¹ Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ñ\8cÐ½Ð¾Ð¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ðµ Ð² %C"
  
  #: fortran/scanner.c:1691
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Nonconforming tab character at %C"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ñ\85Ð¾Ð´Ñ\8fÑ\89Ð¸Ð¹ Ñ\81Ð¸Ð¼Ð²Ð¾Ð» Ñ\82Ð°Ð±Ñ\83Ð»Ñ\8fÑ\86Ð¸Ð¸ Ð² %C"
  
  #: fortran/scanner.c:1779 fortran/scanner.c:1782
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'&' not allowed by itself in line %d"
  msgid "%<&%> not allowed by itself in line %d"
-msgstr ""
+msgstr "'&' не допускается сам по себе в строке %d"
  
  #: fortran/scanner.c:1841
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Nonconforming tab character in column %d of line %d"
-msgstr "Ð\9bÐ¸Ñ\88Ð½Ñ\8fÑ\8f Ð·Ð°Ð¿Ñ\8fÑ\82Ð°Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ FORMAT Ð² %0"
+msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ñ\85Ð¾Ð´Ñ\8fÑ\89Ð¸Ð¹ Ñ\81Ð¸Ð¼Ð²Ð¾Ð» Ñ\82Ð°Ð±Ñ\83Ð»Ñ\8fÑ\86Ð¸Ð¸ Ð² ÐºÐ¾Ð»Ð¾Ð½ÐºÐµ %d Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸ %d"
  
  #: fortran/scanner.c:2070
  #, fuzzy, gcc-internal-format
+#| msgid "%s:%d: file %s left but not entered"
  msgid "file %qs left but not entered"
-msgstr "метка %q+D определена, но не используется"
+msgstr "%s:%d: файл %s покидается без входа"
  
  #: fortran/scanner.c:2108
  #, fuzzy, gcc-internal-format
+#| msgid "%s:%d: Illegal preprocessor directive"
  msgid "Illegal preprocessor directive"
-msgstr "неверная директива препроцессора #%s"
+msgstr "%s:%d: Некорректная директива препроцессора"
  
  #: fortran/scanner.c:2235
  #, fuzzy, gcc-internal-format
+#| msgid "Can't open file '%s'"
  msgid "Can't open file %qs"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82Ð¸Ñ\8f Ð²Ñ\85Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\84Ð°Ð¹Ð»Ð° %qs"
+msgstr "Ð\9eÑ\88Ð¸Ð±ÐºÐ° Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82Ð¸Ñ\8f Ð²Ñ\85Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\84Ð°Ð¹Ð»Ð° '%s'"
  
  #: fortran/simplify.c:88
  #, gcc-internal-format, gfc-internal-format
  msgid "Result of %s overflows its kind at %L"
-msgstr ""
+msgstr "Результат %s переполняет свой вид в %L"
  
  #: fortran/simplify.c:93
  #, gcc-internal-format, gfc-internal-format
  msgid "Result of %s underflows its kind at %L"
-msgstr ""
+msgstr "Результат %s теряет значимость своего вида в %L"
  
  #: fortran/simplify.c:98
  #, gcc-internal-format, gfc-internal-format
  msgid "Result of %s is NaN at %L"
-msgstr ""
+msgstr "Результат %s есть NaN в %L"
  
  #: fortran/simplify.c:102
  #, gcc-internal-format, gfc-internal-format
  msgid "Result of %s gives range error for its kind at %L"
-msgstr ""
+msgstr "Результат %s дает ошибку диапазона для своего вида в %L"
  
  #: fortran/simplify.c:125
  #, gcc-internal-format, gfc-internal-format
  msgid "KIND parameter of %s at %L must be an initialization expression"
-msgstr ""
+msgstr "KIND параметр %s в %L должен быть инициализационным выражением"
  
  #: fortran/simplify.c:133
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid KIND parameter of %s at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %qs"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ KIND Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %s Ð² %L"
  
  #: fortran/simplify.c:691
  #, gcc-internal-format
@@ -58899,24 +61908,24 @@ msgid "gfc_simplify_abs(): Bad type"
  msgstr ""
  
  #: fortran/simplify.c:712
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Argument of %s function at %L is negative"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 `%A', Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð½Ð°Ñ\8f Ð² %0, Ð½Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %s Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð² %L Ð¾Ñ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»ÐµÐ½"
  
  #: fortran/simplify.c:719
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Argument of %s function at %L outside of range [0,127]"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² %1"
+msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %s Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ Ð² %L Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð° [0,127]"
  
  #: fortran/simplify.c:737
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of %s function at %L is too large for the collating sequence of kind %d"
-msgstr ""
+msgstr "Аргумент %s функции в %L слишком велик для последовательности сравнения вида %d"
  
  #: fortran/simplify.c:774
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of ACOS at %L must be between -1 and 1"
-msgstr ""
+msgstr "Аргумент ACOS в %L должен быть между -1 и 1"
  
  #: fortran/simplify.c:788
  #, gcc-internal-format
@@ -58926,7 +61935,7 @@ msgstr ""
  #: fortran/simplify.c:807
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of ACOSH at %L must not be less than 1"
-msgstr ""
+msgstr "Аргумент ACOSH в %L не должен быть меньше 1"
  
  #: fortran/simplify.c:822
  #, gcc-internal-format
@@ -58936,7 +61945,7 @@ msgstr ""
  #: fortran/simplify.c:1051
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of ASIN at %L must be between -1 and 1"
-msgstr ""
+msgstr "Аргумент ASIN в %L должен быть между -1 и 1"
  
  #: fortran/simplify.c:1065
  #, gcc-internal-format
@@ -58956,7 +61965,7 @@ msgstr ""
  #: fortran/simplify.c:1142
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of ATANH at %L must be inside the range -1 to 1"
-msgstr ""
+msgstr "Аргумент ATANH в %L должен быть внутри диапазона от -1 до 1"
  
  #: fortran/simplify.c:1156
  #, gcc-internal-format
@@ -58966,12 +61975,12 @@ msgstr ""
  #: fortran/simplify.c:1173
  #, gcc-internal-format, gfc-internal-format
  msgid "If first argument of ATAN2 %L is zero, then the second argument must not be zero"
-msgstr ""
+msgstr "Если первый аргумент %L ATAN2 нулевой, то второй аргумент не должен быть нулевым"
  
  #: fortran/simplify.c:1265
  #, gcc-internal-format, gfc-internal-format
  msgid "Result of BESSEL_YN is -INF at %L"
-msgstr ""
+msgstr "Результат BESSEL_YN есть -INF в %L"
  
  #: fortran/simplify.c:1634
  #, gcc-internal-format
@@ -59006,17 +62015,17 @@ msgstr ""
  #: fortran/simplify.c:2587
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of IACHAR at %L must be of length one"
-msgstr ""
+msgstr "Аргумент IACHAR в %L должен быть длины один"
  
  #: fortran/simplify.c:2595
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of IACHAR function at %L outside of range 0..127"
-msgstr ""
+msgstr "Аргумент IACHAR функции в %L вне диапазона 0..127"
  
  #: fortran/simplify.c:2710
  #, gcc-internal-format, gfc-internal-format
  msgid "Sum of second and third arguments of IBITS exceeds bit size at %L"
-msgstr ""
+msgstr "Сумма второго и третьего аргументов IBITS превышает битовый размер в %L"
  
  #: fortran/simplify.c:2734
  #, gcc-internal-format
@@ -59026,38 +62035,38 @@ msgstr ""
  #: fortran/simplify.c:2785
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of ICHAR at %L must be of length one"
-msgstr ""
+msgstr "Аргумент ICHAR в %L должен быть длины один"
  
  #. Left shift, as in SHIFTL.
  #: fortran/simplify.c:3150 fortran/simplify.c:3158
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Second argument of %s is negative at %L"
-msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 `%s' Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c 2-Ð±Ð¸Ñ\82Ð½Ñ\8bÐ¼ Ð±ÐµÐ·Ð·Ð½Ð°ÐºÐ¾Ð²Ñ\8bÐ¼ Ð»Ð¸Ñ\82ÐµÑ\80Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+msgstr "Ð\92Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %s Ð¾Ñ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»ÐµÐ½ Ð² %L"
  
  #: fortran/simplify.c:3170
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Magnitude of second argument of %s exceeds bit size at %L"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qs"
+msgstr "Ð\90Ð±Ñ\81Ð¾Ð»Ñ\8eÑ\82Ð½Ð°Ñ\8f Ð²ÐµÐ»Ð¸Ñ\87Ð¸Ð½Ð° Ð²Ñ\82Ð¾Ñ\80Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %s Ð¿Ñ\80ÐµÐ²Ñ\8bÑ\88Ð°ÐµÑ\82 Ð±Ð¸Ñ\82Ð¾Ð²Ñ\8bÐ¹ Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð² %L"
  
  #: fortran/simplify.c:3296
  #, gcc-internal-format, gfc-internal-format
  msgid "Magnitude of second argument of ISHFTC exceeds BIT_SIZE of first argument at %L"
-msgstr ""
+msgstr "Абсолютная величина второго аргумента ISHFTC превышает BIT_SIZE первого аргумента в %L"
  
  #: fortran/simplify.c:3616 fortran/simplify.c:3748
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "DIM argument at %L is out of bounds"
-msgstr "номер сумматора вне диапазона"
+msgstr "DIM аргумент в %L вне границ"
  
  #: fortran/simplify.c:3927
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of LOG at %L cannot be less than or equal to zero"
-msgstr ""
+msgstr "Аргумент LOG в %L не может быть меньше или равен нулю"
  
  #: fortran/simplify.c:3940
  #, gcc-internal-format, gfc-internal-format
  msgid "Complex argument of LOG at %L cannot be zero"
-msgstr ""
+msgstr "Complex аргумент LOG в %L не может быть нулевым"
  
  #: fortran/simplify.c:3951
  #, gcc-internal-format
@@ -59067,7 +62076,7 @@ msgstr ""
  #: fortran/simplify.c:3968
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument of LOG10 at %L cannot be less than or equal to zero"
-msgstr ""
+msgstr "Аргумент LOG10 в %L не может быть меньше или равен нулю"
  
  #: fortran/simplify.c:4271
  #, gcc-internal-format
@@ -59078,18 +62087,19 @@ msgstr ""
  #: fortran/simplify.c:4447
  #, gcc-internal-format, gfc-internal-format
  msgid "Second argument MOD at %L is zero"
-msgstr ""
+msgstr "Второй аргумент MOD в %L нулевой"
  
  #. Result is processor-dependent.
  #: fortran/simplify.c:4458
  #, gcc-internal-format, gfc-internal-format
  msgid "Second argument of MOD at %L is zero"
-msgstr ""
+msgstr "Второй аргумент MOD в %L нулевой"
  
  #: fortran/simplify.c:4469
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "gfc_simplify_mod(): Bad arguments"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #. Result is processor-dependent. This processor just opts
  #. to not handle it at all.
@@ -59097,7 +62107,7 @@ msgstr ""
  #: fortran/simplify.c:4495 fortran/simplify.c:4507
  #, gcc-internal-format, gfc-internal-format
  msgid "Second argument of MODULO at %L is zero"
-msgstr ""
+msgstr "Второй аргумент MODULO в %L нулевой"
  
  #: fortran/simplify.c:4527
  #, gcc-internal-format
@@ -59107,32 +62117,34 @@ msgstr ""
  #: fortran/simplify.c:4575
  #, gcc-internal-format, gfc-internal-format
  msgid "Result of NEAREST is NaN at %L"
-msgstr ""
+msgstr "Результат NEAREST есть NaN в %L"
  
  #: fortran/simplify.c:5051
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument NCOPIES of REPEAT intrinsic is negative at %L"
-msgstr ""
+msgstr "Аргумент NCOPIES встроенной функции REPEAT отрицателен в %L"
  
  #: fortran/simplify.c:5106
  #, gcc-internal-format, gfc-internal-format
  msgid "Argument NCOPIES of REPEAT intrinsic is too large at %L"
-msgstr ""
+msgstr "Аргумент NCOPIES встроенной функции REPEAT слишком велик в %L"
  
  #: fortran/simplify.c:5259
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Integer too large at %C"
  msgid "Reshaped array too large at %C"
-msgstr "Целое в %0 слишком велико"
+msgstr "Целое слишком велико в %C"
  
  #: fortran/simplify.c:5373
  #, gcc-internal-format, gfc-internal-format
  msgid "Result of SCALE overflows its kind at %L"
-msgstr ""
+msgstr "Результат SCALE переполняет свой вид в %L"
  
  #: fortran/simplify.c:5952
  #, fuzzy, gcc-internal-format
+#| msgid "Bad type in constant expression"
  msgid "Bad type in gfc_simplify_sign"
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¸ Ð²Ñ\8bÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ð¸ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð³Ð¾ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð² ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ð¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸"
  
  #: fortran/simplify.c:5981
  #, gcc-internal-format
@@ -59145,69 +62157,79 @@ msgid "Failure getting length of a constant array."
  msgstr ""
  
  #: fortran/simplify.c:6118
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit.   See -fmax-array-constructor option"
  msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
-msgstr ""
+msgstr "Число элементов в конструкторе массива в %L требует увеличения допустимой %d верхней границы. См. опцию -fmax-array-constructor"
  
  #: fortran/simplify.c:6184
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Finalization at %L is not yet implemented"
  msgid "Simplification of SPREAD at %L not yet implemented"
-msgstr ""
+msgstr "Финализация в %L пока не реализована"
  
  #: fortran/simplify.c:6209
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Argument of SQRT at %L has a negative value"
-msgstr "функция возвращает агрегатное значение"
+msgstr "Аргумент SQRT в %L имеет отрицательное значение"
  
+#
  #: fortran/simplify.c:6225
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Invalid second argument of IBSET at %L"
  msgid "invalid argument of SQRT at %L"
-msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qs"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 IBSET Ð² %L"
  
  #: fortran/simplify.c:6520
  #, gcc-internal-format, gfc-internal-format
  msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY lower bound is %ld)"
-msgstr ""
+msgstr "Вне границ в IMAGE_INDEX в %L для измерения %d, SUB имеет %ld и COARRAY нижняя граница есть %ld)"
  
  #: fortran/simplify.c:6543
  #, gcc-internal-format, gfc-internal-format
  msgid "Out of bounds in IMAGE_INDEX at %L for dimension %d, SUB has %ld and COARRAY upper bound is %ld)"
-msgstr ""
+msgstr "Вне границ в IMAGE_INDEX в %L для измерения %d, SUB имеет %ld и COARRAY верхняя граница есть %ld)"
  
  #: fortran/simplify.c:6878
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_conv_constant_to_tree(): invalid type: %s"
  msgid "gfc_convert_constant(): Unexpected type"
-msgstr ""
+msgstr "gfc_conv_constant_to_tree(): некорректный тип: %s"
  
  #: fortran/simplify.c:6964
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Character '%s' in string at %L cannot be converted into character kind %d"
  msgid "Character %qs in string at %L cannot be converted into character kind %d"
-msgstr ""
+msgstr "Символ '%s' в строке в %L не может быть преобразован в символьный вид %d"
  
  #: fortran/st.c:263
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "gfc_free_statement(): Bad statement"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: fortran/symbol.c:131
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "SAVE statement at %C follows blanket SAVE statement"
  msgid "IMPLICIT NONE (type) statement at %L following an IMPLICIT statement"
-msgstr ""
+msgstr "SAVE оператор в %C следует за общим SAVE оператором"
  
  #: fortran/symbol.c:168
  #, fuzzy, gcc-internal-format
+#| msgid "Letter '%c' already set in IMPLICIT statement at %C"
  msgid "Letter %qc already set in IMPLICIT statement at %C"
-msgstr "Ð\9dÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ VXT-Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %0"
+msgstr "Ð\91Ñ\83ÐºÐ²Ð° '%c' Ñ\83Ð¶Ðµ Ñ\83Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð»ÐµÐ½Ð° Ð² IMPLICIT Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
  #: fortran/symbol.c:190
  #, gcc-internal-format, gfc-internal-format
  msgid "Cannot specify IMPLICIT at %C after IMPLICIT NONE"
-msgstr ""
+msgstr "Невозможно специфицировать IMPLICIT в %C после IMPLICIT NONE"
  
  #: fortran/symbol.c:200
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Letter %c already has an IMPLICIT type at %C"
  msgid "Letter %qc already has an IMPLICIT type at %C"
-msgstr ""
+msgstr "Буква '%c' уже имеет IMPLICIT тип в %C"
  
  #: fortran/symbol.c:224
  #, gcc-internal-format
@@ -59226,146 +62248,157 @@ msgstr ""
  
  #: fortran/symbol.c:256
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %L has no IMPLICIT type"
  msgid "Symbol %qs at %L has no IMPLICIT type"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Символ '%s' в %L не имеет IMPLICIT типа"
  
  #. BIND(C) variables should not be implicitly declared.
  #: fortran/symbol.c:276
  #, fuzzy, gcc-internal-format
+#| msgid "Implicitly declared BIND(C) variable '%s' at %L may not be C interoperable"
  msgid "Implicitly declared BIND(C) variable %qs at %L may not be C interoperable"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "Неявно декларированная BIND(C) переменная '%s' в %L может не быть C совместимой"
  
  #. Dummy args to a BIND(C) routine may not be interoperable if
  #. they are implicitly typed.
  #: fortran/symbol.c:292
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Implicitly declared variable '%s' at %L may not be C interoperable but it is a dummy argument to the BIND(C) procedure '%s' at %L"
  msgid "Implicitly declared variable %qs at %L may not be C interoperable but it is a dummy argument to the BIND(C) procedure %qs at %L"
-msgstr ""
+msgstr "Неявно декларированная переменная '%s' в %L может не быть C совместимой но это формальный аргумент для BIND(C) процедуры '%s' в %L"
  
  #: fortran/symbol.c:333
  #, fuzzy, gcc-internal-format
+#| msgid "Function result '%s' at %L has no IMPLICIT type"
  msgid "Function result %qs at %L has no IMPLICIT type"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "Результат функции '%s' в %L не имеет IMPLICIT типа"
  
  #: fortran/symbol.c:429
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s attribute not allowed in BLOCK DATA program unit at %L"
-msgstr "Оператор в %0 некорректен в программной единице BLOCK DATA в %1"
+msgstr "%s атрибут не допускается в BLOCK DATA программной единице в %L"
  
  #: fortran/symbol.c:453
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Namelist group name at %L cannot have the SAVE attribute"
-msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 Ð² %C Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 POINTER"
+msgstr "Ð\98Ð¼Ñ\8f NAMELIST Ð³Ñ\80Ñ\83Ð¿Ð¿Ñ\8b Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð¸Ð¼ÐµÑ\82Ñ\8c SAVE Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
  #: fortran/symbol.c:468
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "internal procedure %qs at %L conflicts with DUMMY argument"
-msgstr "Внешняя процедура `%A' передана как фактический аргумент в %0, но не декларирована явно как EXTERNAL"
+msgstr ""
  
  #: fortran/symbol.c:494
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: Procedure pointer at %C"
  msgid "Procedure pointer at %C"
-msgstr "Недопустимое число в операторе FORMAT в %0"
+msgstr "Fortran 2003: Указатель на процедуру в %C"
  
  #: fortran/symbol.c:679
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s attribute applied to %s %s at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%s атрибут применен к %s %s в %L"
  
  #: fortran/symbol.c:686
  #, gcc-internal-format, gfc-internal-format
  msgid "BIND(C) applied to %s %s at %L"
-msgstr ""
+msgstr "BIND(C) применен к %s %s в %L"
  
  #: fortran/symbol.c:802 fortran/symbol.c:1599
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s attribute conflicts with %s attribute at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%s атрибут конфликтует с %s атрибутом в %L"
  
  #: fortran/symbol.c:805
  #, fuzzy, gcc-internal-format
+#| msgid "%s attribute conflicts with %s attribute in '%s' at %L"
  msgid "%s attribute conflicts with %s attribute in %qs at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%s атрибут конфликтует с %s атрибутом в '%s' в %L"
  
  #: fortran/symbol.c:813
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "%s attribute conflicts with %s attribute at %L"
  msgid "%s attribute with %s attribute at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%s атрибут конфликтует с %s атрибутом в %L"
  
  #: fortran/symbol.c:819
  #, fuzzy, gcc-internal-format
+#| msgid "%s attribute conflicts with %s attribute in '%s' at %L"
  msgid "%s attribute with %s attribute in %qs at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%s атрибут конфликтует с %s атрибутом в '%s' в %L"
  
  #: fortran/symbol.c:863
  #, gcc-internal-format, gfc-internal-format
  msgid "Cannot change attributes of USE-associated symbol at %L"
-msgstr ""
+msgstr "Невозможно изменить атрибуты USE-associated символа в %L"
  
  #: fortran/symbol.c:866
  #, gcc-internal-format, gfc-internal-format
  msgid "Cannot change attributes of USE-associated symbol %s at %L"
-msgstr ""
+msgstr "Невозможно изменить атрибуты USE-associated символа %s в %L"
  
  #: fortran/symbol.c:882
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate %s attribute specified at %L"
-msgstr "%Jinline функция %qD с атрибутом noinline"
+msgstr "Повторный %s атрибут специфицирован в %L"
  
  #: fortran/symbol.c:924
  #, gcc-internal-format, gfc-internal-format
  msgid "ALLOCATABLE specified outside of INTERFACE body at %L"
-msgstr ""
+msgstr "ALLOCATABLE специфицирован вне INTERFACE тела в %L"
  
  #: fortran/symbol.c:950
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "CODIMENSION specified for '%s' outside its INTERFACE body at %L"
  msgid "CODIMENSION specified for %qs outside its INTERFACE body at %L"
-msgstr ""
+msgstr "CODIMENSION специфицирован для '%s' вне своего INTERFACE тела в %L"
  
  #: fortran/symbol.c:976
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "DIMENSION specified for '%s' outside its INTERFACE body at %L"
  msgid "DIMENSION specified for %qs outside its INTERFACE body at %L"
-msgstr ""
+msgstr "DIMENSION специфицирован для '%s' вне своего INTERFACE тела в %L"
  
  #: fortran/symbol.c:1106
  #, gcc-internal-format, gfc-internal-format
  msgid "Cray Pointee at %L appears in multiple pointer() statements"
-msgstr ""
+msgstr "Cray указуемое в %L появляется в нескольких pointer() операторах"
  
  #: fortran/symbol.c:1125
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate PROTECTED attribute specified at %L"
-msgstr "%Jinline функция %qD с атрибутом noinline"
+msgstr "Повторный PROTECTED атрибут специфицирован в %L"
  
  #: fortran/symbol.c:1158
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "SAVE attribute at %L cannot be specified in a PURE procedure"
-msgstr "оператор SAVE или атрибут в %1 несовместим с оператором SAVE или атрибутом в %0"
+msgstr "SAVE атрибут в %L не может быть специфицирован в PURE процедуре"
  
  #: fortran/symbol.c:1169
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate SAVE attribute specified at %L"
-msgstr "%Jinline функция %qD с атрибутом noinline"
+msgstr "Повторный SAVE атрибут специфицирован в %L"
  
  #: fortran/symbol.c:1189
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate VALUE attribute specified at %L"
-msgstr "%Jinline функция %qD с атрибутом noinline"
+msgstr "Повторный VALUE атрибут специфицирован в %L"
  
  #: fortran/symbol.c:1208
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate VOLATILE attribute specified at %L"
-msgstr "%Jinline функция %qD с атрибутом noinline"
+msgstr "Повторный VOLATILE атрибут специфицирован в %L"
  
  #: fortran/symbol.c:1227
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate ASYNCHRONOUS attribute specified at %L"
-msgstr "%Jinline функция %qD с атрибутом noinline"
+msgstr "Повторный ASYNCHRONOUS атрибут специфицирован в %L"
  
  #: fortran/symbol.c:1595
  #, fuzzy, gcc-internal-format
+#| msgid "%s attribute of '%s' conflicts with %s attribute at %L"
  msgid "%s attribute of %qs conflicts with %s attribute at %L"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%s атрибут '%s' конфликтует с %s атрибутом в %L"
  
  #: fortran/symbol.c:1631
  #, gcc-internal-format, gfc-internal-format
@@ -59377,112 +62410,126 @@ msgstr ""
  #: fortran/symbol.c:1639
  #, gcc-internal-format, gfc-internal-format
  msgid "%s procedure at %L is already declared as %s procedure"
-msgstr ""
+msgstr "%s процедура в %L уже декларирована как %s процедура"
  
  #: fortran/symbol.c:1674
  #, gcc-internal-format, gfc-internal-format
  msgid "INTENT (%s) conflicts with INTENT(%s) at %L"
-msgstr ""
+msgstr "INTENT (%s)  конфликтует с INTENT(%s) в %L"
  
  #: fortran/symbol.c:1698
  #, gcc-internal-format, gfc-internal-format
  msgid "ACCESS specification at %L was already specified"
-msgstr ""
+msgstr "ACCESS спецификация в %L уже была специфицирована"
  
  #: fortran/symbol.c:1715
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate BIND attribute specified at %L"
-msgstr "%Jinline функция %qD с атрибутом noinline"
+msgstr "Повторный BIND атрибут специфицирован в %L"
  
  #: fortran/symbol.c:1722
-#, gcc-internal-format, gfc-internal-format
+#, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: BIND(C) at %L"
  msgid "BIND(C) at %L"
-msgstr ""
+msgstr "Fortran 2003: BIND(C) в %L"
  
  #: fortran/symbol.c:1738
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Duplicate EXTENDS attribute specified at %L"
-msgstr "%Jinline функция %qD с атрибутом noinline"
+msgstr "Повторный EXTENDS атрибут специфицирован в %L"
  
  #: fortran/symbol.c:1742
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Fortran 2003: EXTENDS at %L"
  msgid "EXTENDS at %L"
-msgstr "Неподдерживаемый VXT-оператор в %0"
+msgstr "Fortran 2003: EXTENDS в %L"
  
  #: fortran/symbol.c:1768
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %L already has an explicit interface"
  msgid "Symbol %qs at %L already has an explicit interface"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %s"
+msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» '%s' Ð² %L Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\8fÐ²Ð½Ñ\8bÐ¹ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81"
  
  #: fortran/symbol.c:1775
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "'%s' at %L has attributes specified outside its INTERFACE body"
  msgid "%qs at %L has attributes specified outside its INTERFACE body"
-msgstr ""
+msgstr "'%s' в %L имеет атрибуты специфицированные вне своего INTERFACE тела"
  
  #: fortran/symbol.c:1813
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %L conflicts with symbol from module '%s', use-associated at %L"
  msgid "Symbol %qs at %L conflicts with symbol from module %qs, use-associated at %L"
-msgstr ""
+msgstr "Символ '%s' в %L конфликтует с символом из модуля '%s', use-associated в %L"
  
  #: fortran/symbol.c:1817
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %L already has basic type of %s"
  msgid "Symbol %qs at %L already has basic type of %s"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 тип %s"
+msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» '%s' Ð² %L Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð±Ð°Ð·Ð¾Ð²Ñ\8bÐ¹ тип %s"
  
  #: fortran/symbol.c:1824
  #, fuzzy, gcc-internal-format
+#| msgid "Procedure '%s' at %L may not have basic type of %s"
  msgid "Procedure %qs at %L may not have basic type of %s"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Процедура '%s' в %L не может иметь базовый тип %s"
  
  #: fortran/symbol.c:1836
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %L cannot have a type"
  msgid "Symbol %qs at %L cannot have a type"
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Символ '%s' в %L не может иметь тип"
  
  #: fortran/symbol.c:2057
  #, fuzzy, gcc-internal-format
+#| msgid "Component '%s' at %C already declared at %L"
  msgid "Component %qs at %C already declared at %L"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %s"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 '%s' Ð² %C Ñ\83Ð¶Ðµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ð² %L"
  
  #: fortran/symbol.c:2068
  #, fuzzy, gcc-internal-format
+#| msgid "Component '%s' at %C already in the parent type at %L"
  msgid "Component %qs at %C already in the parent type at %L"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %s"
+msgstr "Ð\9aÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82 '%s' Ð² %C Ñ\83Ð¶Ðµ Ð² Ñ\80Ð¾Ð´Ð¸Ñ\82ÐµÐ»Ñ\8cÑ\81ÐºÐ¾Ð¼ Ñ\82Ð¸Ð¿Ðµ Ð² %L"
  
  #: fortran/symbol.c:2153
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %C is ambiguous"
  msgid "Symbol %qs at %C is ambiguous"
-msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ `%D' Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð¾"
+msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» '%s' Ð² %C Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87ÐµÐ½"
  
  #: fortran/symbol.c:2185
  #, fuzzy, gcc-internal-format
+#| msgid "Derived type '%s' at %C is being used before it is defined"
  msgid "Derived type %qs at %C is being used before it is defined"
-msgstr "Ð¿Ñ\80ÐµÐ´Ð¸ÐºÐ°Ñ\82 Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð´ÐµÐ½Ñ\82Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ð¾Ð¼"
+msgstr "Ð\9fÑ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ '%s' Ð² %C Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð´Ð¾ Ñ\81Ð²Ð¾ÐµÐ³Ð¾ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ñ\8f"
  
  #: fortran/symbol.c:2223
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Component '%s' at %C is a PRIVATE component of '%s'"
  msgid "Component %qs at %C is a PRIVATE component of %qs"
-msgstr ""
+msgstr "Компонент '%s' в %C есть PRIVATE компонент '%s'"
  
  #: fortran/symbol.c:2241
  #, fuzzy, gcc-internal-format
+#| msgid "'%s' at %C is not a member of the '%s' structure"
  msgid "%qs at %C is not a member of the %qs structure"
-msgstr "`%D' не является элементом типа `%T'"
+msgstr "'%s' в %C не является членом '%s' структуры"
  
  #: fortran/symbol.c:2381
  #, gcc-internal-format, gfc-internal-format
  msgid "Duplicate statement label %d at %L and %L"
-msgstr ""
+msgstr "Повторная метка оператора %d в %L и %L"
  
  #: fortran/symbol.c:2392
  #, gcc-internal-format, gfc-internal-format
  msgid "Label %d at %C already referenced as branch target"
-msgstr ""
+msgstr "Метка %d в %C уже фигурирует как цель перехода"
  
  #: fortran/symbol.c:2402
  #, gcc-internal-format, gfc-internal-format
  msgid "Label %d at %C already referenced as a format label"
-msgstr ""
+msgstr "Метка %d в %C уже фигурирует как метка формата"
  
  #: fortran/symbol.c:2408
  #, gcc-internal-format, gfc-internal-format
@@ -59492,17 +62539,18 @@ msgstr ""
  #: fortran/symbol.c:2450
  #, gcc-internal-format, gfc-internal-format
  msgid "Label %d at %C previously used as a FORMAT label"
-msgstr ""
+msgstr "Метка %d в %C ранее использована как FORMAT метка"
  
  #: fortran/symbol.c:2459
  #, gcc-internal-format, gfc-internal-format
  msgid "Label %d at %C previously used as branch target"
-msgstr ""
+msgstr "Метка %d в %C ранее использована как цель перехода"
  
  #: fortran/symbol.c:2465
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Expected terminating name at %C"
  msgid "Shared DO termination label %d at %C"
-msgstr "Ð\98Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¿Ñ\83Ñ\81Ñ\82Ð¾Ð³Ð¾ Ð¾Ð±Ñ\89ÐµÐ³Ð¾ Ð±Ð»Ð¾ÐºÐ° Ð² %0"
+msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð·Ð°Ð²ÐµÑ\80Ñ\88Ð°Ñ\8eÑ\89ÐµÐµ Ð¸Ð¼Ñ\8f Ð² %C"
  
  #: fortran/symbol.c:2781
  #, gcc-internal-format
@@ -59510,20 +62558,23 @@ msgid "new_symbol(): Symbol name too long"
  msgstr ""
  
  #: fortran/symbol.c:2805
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Name '%s' at %C is an ambiguous reference to '%s' from module '%s'"
  msgid "Name %qs at %C is an ambiguous reference to %qs from module %qs"
-msgstr ""
+msgstr "Имя '%s' в %C является неоднозначной ссылкой на '%s' из модуля '%s'"
  
  #: fortran/symbol.c:2808
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Name '%s' at %C is an ambiguous reference to '%s' from current program unit"
  msgid "Name %qs at %C is an ambiguous reference to %qs from current program unit"
-msgstr ""
+msgstr "Имя '%s' в %C является неоднозначной ссылкой на '%s' из текущей программной единицы"
  
  #. Symbol is from another namespace.
  #: fortran/symbol.c:3029
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' at %C has already been host associated"
  msgid "Symbol %qs at %C has already been host associated"
-msgstr "Ð¤Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f '%s' Ð² %C Ñ\83Ð¶Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %s"
+msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» '%s' Ð² %C Ñ\83Ð¶Ðµ Ð±Ñ\8bÐ» host Ð°Ñ\81Ñ\81Ð¾Ñ\86Ð¸Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
  
  #: fortran/symbol.c:4022
  #, gcc-internal-format
@@ -59531,59 +62582,70 @@ msgid "verify_bind_c_derived_type(): Given symbol is unexpectedly NULL"
  msgstr ""
  
  #: fortran/symbol.c:4035
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Derived type '%s' declared at %L must have the BIND attribute to be C interoperable"
  msgid "Derived type %qs declared at %L must have the BIND attribute to be C interoperable"
-msgstr ""
+msgstr "Производный тип '%s' декларированный в %L должен иметь BIND атрибут чтобы быть C совместимым"
  
  #: fortran/symbol.c:4053
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Derived type '%s' with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
  msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor"
-msgstr ""
+msgstr "Производный тип '%s' с BIND(C) атрибутом в %L пуст и может быть недоступен для C парного процессора"
  
  #: fortran/symbol.c:4074
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Component '%s' at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type '%s' at %L"
  msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
-msgstr ""
+msgstr "Компонент '%s' в %L не может иметь POINTER атрибут поскольку он является членом BIND(C) производного типа '%s' в %L"
  
  #: fortran/symbol.c:4084
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Procedure pointer component '%s' at %L cannot be a member of the BIND(C) derived type '%s' at %L"
  msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
-msgstr ""
+msgstr "Компонент указатель на процедуру'%s' в %L не может быть членом BIND(C) производного типа '%s' в %L"
  
  #: fortran/symbol.c:4095
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Component '%s' at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type '%s' at %L"
  msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
-msgstr ""
+msgstr "Компонент '%s' в %L не может иметь ALLOCATABLE атрибут поскольку он является членом BIND(C) производного типа '%s' в %L"
  
  #: fortran/symbol.c:4134
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Component '%s' in derived type '%s' at %L may not be C interoperable, even though derived type '%s' is BIND(C)"
  msgid "Component %qs in derived type %qs at %L may not be C interoperable, even though derived type %qs is BIND(C)"
-msgstr ""
+msgstr "Компонент '%s' в производном типе '%s' в %L может не быть C совместимым хотя производный тип '%s' есть BIND(C)"
  
  #: fortran/symbol.c:4144
  #, fuzzy, gcc-internal-format
+#| msgid "Component '%s' in derived type '%s' at %L may not be C interoperable"
  msgid "Component %qs in derived type %qs at %L may not be C interoperable"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "Компонент '%s' в производном типе '%s' в %L может не быть C совместимым"
  
  #: fortran/symbol.c:4158
  #, fuzzy, gcc-internal-format
+#| msgid "Derived type '%s' at %L cannot be declared with both PRIVATE and BIND(C) attributes"
  msgid "Derived type %qs at %L cannot be declared with both PRIVATE and BIND(C) attributes"
-msgstr "Ð¾Ñ\82Ð¼ÐµÐ½Ð° Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %qD Ð² Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ðµ Ð¸Ð¼Ñ\91Ð½ %qD"
+msgstr "Ð\9fÑ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ñ\81 Ð¾Ð±Ð¾Ð¸Ð¼Ð¸ PRIVATE Ð¸ BIND(C) Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ð°Ð¼Ð¸"
  
  #: fortran/symbol.c:4166
  #, fuzzy, gcc-internal-format
+#| msgid "Derived type '%s' at %L cannot have the SEQUENCE attribute because it is BIND(C)"
  msgid "Derived type %qs at %L cannot have the SEQUENCE attribute because it is BIND(C)"
-msgstr "Ð¾Ñ\82Ð¼ÐµÐ½Ð° Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %qD Ð² Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ðµ Ð¸Ð¼Ñ\91Ð½ %qD"
+msgstr "Ð\9fÑ\80Ð¾Ð¸Ð·Ð²Ð¾Ð´Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð¸Ð¼ÐµÑ\82Ñ\8c SEQUENCE Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 Ð¿Ð¾Ñ\81ÐºÐ¾Ð»Ñ\8cÐºÑ\83 Ð¾Ð½ ÐµÑ\81Ñ\82Ñ\8c BIND(C)"
  
  #: fortran/symbol.c:4646 fortran/symbol.c:4651
  #, fuzzy, gcc-internal-format
+#| msgid "Symbol '%s' is used before it is typed at %L"
  msgid "Symbol %qs is used before it is typed at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT"
+msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» '%s' Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð´Ð¾ Ñ\81Ð²Ð¾ÐµÐ³Ð¾ Ñ\82Ð¸Ð¿Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð² %L"
  
  #: fortran/target-memory.c:126
  #, fuzzy, gcc-internal-format
+#| msgid "invalid expression for min lvalue"
  msgid "Invalid expression in gfc_element_size."
-msgstr "Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð·Ð°Ð´Ð°Ð½Ð¾ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
+msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² Ð»ÐµÐ²Ð¾Ð¹ Ñ\87Ð°Ñ\81Ñ\82Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ min"
  
  #: fortran/target-memory.c:346
  #, gcc-internal-format
@@ -59598,34 +62660,37 @@ msgstr ""
  #: fortran/target-memory.c:681
  #, gcc-internal-format, gfc-internal-format
  msgid "Overlapping unequal initializers in EQUIVALENCE at %L"
-msgstr ""
+msgstr "Перекрывающиеся неравные инициализаторы в EQUIVALENCE в %L"
  
  #: fortran/target-memory.c:769
  #, gcc-internal-format, gfc-internal-format
  msgid "BOZ constant at %L is too large (%ld vs %ld bits)"
-msgstr ""
+msgstr "BOZ константа в %L слишком велика (%ld против %ld бит)"
  
  #. Problems occur when we get something like
  #. integer :: a(lots) = (/(i, i=1, lots)/)
  #: fortran/trans-array.c:5659
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit.   See -fmax-array-constructor option"
  msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit. See %<-fmax-array-constructor%> option"
-msgstr ""
+msgstr "Число элементов в конструкторе массива в %L требует увеличения допустимой %d верхней границы. См. опцию -fmax-array-constructor"
  
  #: fortran/trans-array.c:7514
  #, fuzzy, gcc-internal-format
+#| msgid "Creating array temporary at %L for argument '%s'"
  msgid "Creating array temporary at %L for argument %qs"
-msgstr "создание массива элементов типа %qT"
+msgstr "Создание временного массива в %L для аргумента '%s'"
  
  #: fortran/trans-array.c:9593
  #, gcc-internal-format, gfc-internal-format
  msgid "bad expression type during walk (%d)"
-msgstr ""
+msgstr "Некорректный тип выражения при проходе (%d)"
  
  #: fortran/trans-common.c:403
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Named COMMON block '%s' at %L shall be of the same size as elsewhere (%lu vs %lu bytes)"
  msgid "Named COMMON block %qs at %L shall be of the same size as elsewhere (%lu vs %lu bytes)"
-msgstr ""
+msgstr "Именованный COMMON блок '%s' at %L везде должен быть одного размера (%lu против %lu байт)"
  
  #: fortran/trans-common.c:775
  #, fuzzy, gcc-internal-format
@@ -59639,140 +62704,160 @@ msgid "element_number(): Bad dimension type"
  msgstr ""
  
  #: fortran/trans-common.c:865
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Bad array reference at %L"
-msgstr "Ð\9fÑ\83Ñ\81Ñ\82Ð¾Ð¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð² %0 Ð² Ð¾Ð±Ñ\80Ð°Ñ\89ÐµÐ½Ð¸Ð¸ Ðº Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ñ\83 Ð² %1"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ° Ð½Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð² Ð² %L"
  
  #: fortran/trans-common.c:873
  #, gcc-internal-format, gfc-internal-format
  msgid "Illegal reference type at %L as EQUIVALENCE object"
-msgstr ""
+msgstr "Некорректный тип ссылки в %L как EQUIVALENCE объект"
  
  #: fortran/trans-common.c:913
  #, fuzzy, gcc-internal-format
+#| msgid "Inconsistent equivalence rules involving '%s' at %L and '%s' at %L"
  msgid "Inconsistent equivalence rules involving %qs at %L and %qs at %L"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐµ Ð¾Ð³Ñ\80Ð°Ð½Ð¸Ñ\87Ð¸Ñ\82ÐµÐ»Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ `asm'"
+msgstr "Ð\9fÑ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ð²Ñ\8bÐµ Ð¿Ñ\80Ð°Ð²Ð¸Ð»Ð° Ñ\8dÐºÐ²Ð¸Ð²Ð°Ð»ÐµÐ½Ñ\82Ð½Ð¾Ñ\81Ñ\82Ð¸ Ð²ÐºÐ»Ñ\8eÑ\87Ð°Ñ\8eÑ\89Ð¸Ðµ %s' Ð² %L Ð¸ '%s' Ð² %L"
  
  #. Aligning this field would misalign a previous field.
  #: fortran/trans-common.c:1046
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The equivalence set for variable '%s' declared at %L violates alignment requirements"
  msgid "The equivalence set for variable %qs declared at %L violates alignment requirements"
-msgstr ""
+msgstr "Множество эквивалентности для переменной '%s' декларированной в %L нарушает требования выравнивания"
  
  #: fortran/trans-common.c:1111
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Equivalence for '%s' does not match ordering of COMMON '%s' at %L"
  msgid "Equivalence for %qs does not match ordering of COMMON %qs at %L"
-msgstr ""
+msgstr "Эквивалентность для '%s' не соответствует упорядочению COMMON'%s' at %L"
  
  #: fortran/trans-common.c:1126
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "The equivalence set for '%s' cause an invalid extension to COMMON '%s' at %L"
  msgid "The equivalence set for %qs cause an invalid extension to COMMON %qs at %L"
-msgstr ""
+msgstr "Множество эквивалентности для '%s' вызывает некорректное расширение COMMON '%s' at %L"
  
  #: fortran/trans-common.c:1142
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Padding of %d bytes required before '%s' in COMMON '%s' at %L; reorder elements or use -fno-align-commons"
  msgid "Padding of %d bytes required before %qs in COMMON %qs at %L; reorder elements or use -fno-align-commons"
-msgstr ""
+msgstr "Заполнитель в %d байт требуется перед '%s' в COMMON '%s' в %L; измените порядок элементов или используйте -fno-align-commons"
  
  #: fortran/trans-common.c:1148
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Padding of %d bytes required before '%s' in COMMON at %L; reorder elements or use -fno-align-commons"
  msgid "Padding of %d bytes required before %qs in COMMON at %L; reorder elements or use -fno-align-commons"
-msgstr ""
+msgstr "Заполнитель в %d байт требуется перед '%s' в COMMON в %L; измените порядок элементов или используйте -fno-align-commons"
  
  #: fortran/trans-common.c:1169
  #, fuzzy, gcc-internal-format
+#| msgid "COMMON '%s' at %L does not exist"
  msgid "COMMON %qs at %L does not exist"
-msgstr "%s: определение функции %qs не преобразовано\n"
+msgstr "COMMON '%s' в %L не существует"
  
  #: fortran/trans-common.c:1178
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "COMMON '%s' at %L requires %d bytes of padding; reorder elements or use -fno-align-commons"
  msgid "COMMON %qs at %L requires %d bytes of padding; reorder elements or use %<-fno-align-commons%>"
-msgstr ""
+msgstr "COMMON '%s' в %L требует %d байт заполнителя; измените порядок элементов или используйте -fno-align-commons"
  
  #: fortran/trans-common.c:1183
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "COMMON at %L requires %d bytes of padding; reorder elements or use -fno-align-commons"
  msgid "COMMON at %L requires %d bytes of padding; reorder elements or use %<-fno-align-commons%>"
-msgstr ""
+msgstr "COMMON в %L требует %d байт заполнителя; измените порядок элементов или используйте -fno-align-commons"
  
  #: fortran/trans-const.c:323
  #, gcc-internal-format, gfc-internal-format
  msgid "Assigning value other than 0 or 1 to LOGICAL has undefined result at %L"
-msgstr ""
+msgstr "Присваивание значения отличного от 0 и 1 в LOGICAL имеет неопределенный результат в %L"
  
  #: fortran/trans-const.c:360
  #, gcc-internal-format, gfc-internal-format
  msgid "gfc_conv_constant_to_tree(): invalid type: %s"
-msgstr ""
+msgstr "gfc_conv_constant_to_tree(): некорректный тип: %s"
  
  #: fortran/trans-const.c:391
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "non-constant initialization expression at %L"
-msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+msgstr "неконстантное инициализационное выражение в %L"
  
  #: fortran/trans-decl.c:1557
  #, gcc-internal-format
  msgid "intrinsic variable which isn't a procedure"
-msgstr ""
+msgstr "встроенная переменная которая не есть процедура"
  
  #: fortran/trans-decl.c:4031 fortran/trans-decl.c:6231
  #, fuzzy, gcc-internal-format
+#| msgid "Return value of function '%s' at %L not set"
  msgid "Return value of function %qs at %L not set"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "Возвращаемое значение функции '%s' в %L не установлено"
  
  #: fortran/trans-decl.c:4419
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "Deferred type parameter not yet supported"
-msgstr "\"трамплины\" не поддерживаются"
+msgstr "Параметр отложенного типа пока не поддерживается"
  
  #: fortran/trans-decl.c:4648
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "backend decl for module variable %s already exists"
  msgid "backend decl for module variable %qs already exists"
-msgstr ""
+msgstr "backend декларация для переменной модуля %s уже существует"
  
  #: fortran/trans-decl.c:4661
  #, fuzzy, gcc-internal-format
+#| msgid "Unused variable '%s' declared at %L"
  msgid "Unused PRIVATE module variable %qs declared at %L"
-msgstr "instance-переменная %qs декларирована как %s"
+msgstr "Неиспользуемая переменная '%s' декларирована в %L"
  
  #: fortran/trans-decl.c:5230
  #, fuzzy, gcc-internal-format
+#| msgid "Dummy argument '%s' at %L was declared INTENT(OUT) but was not set"
  msgid "Dummy argument %qs at %L was declared INTENT(OUT) but was not set"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s Ð² %L"
+msgstr "Ð¤Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð² %L Ð±Ñ\8bÐ» Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½ INTENT(OUT) Ð½Ð¾ Ð½Ðµ Ð±Ñ\8bÐ» Ñ\83Ñ\81Ñ\82Ð°Ð½Ð¾Ð²Ð»ÐµÐ½"
  
  #: fortran/trans-decl.c:5236
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Derived-type dummy argument '%s' at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
  msgid "Derived-type dummy argument %qs at %L was declared INTENT(OUT) but was not set and does not have a default initializer"
-msgstr ""
+msgstr "Формальный аргумент производного типа '%s' в %L был декларирован INTENT(OUT) но не был установлен и не имеет подразумеваемого инициализатора"
  
  #: fortran/trans-decl.c:5246 fortran/trans-decl.c:5377
  #, fuzzy, gcc-internal-format
+#| msgid "Unused dummy argument '%s' at %L"
  msgid "Unused dummy argument %qs at %L"
-msgstr "Ð¡Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð¼Ð½Ð¾Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² %s в %L"
+msgstr "Ð\9dÐµÐ¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÐ¹ Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' в %L"
  
  #: fortran/trans-decl.c:5261
  #, fuzzy, gcc-internal-format
+#| msgid "Unused module variable '%s' which has been explicitly imported at %L"
  msgid "Unused module variable %qs which has been explicitly imported at %L"
-msgstr "instance-переменная %qs декларирована как %s"
+msgstr "Неиспользуемая переменная модуля '%s' которая была явно импортирована в %L"
  
  #: fortran/trans-decl.c:5270
  #, fuzzy, gcc-internal-format
+#| msgid "Unused variable '%s' declared at %L"
  msgid "Unused variable %qs declared at %L"
-msgstr "instance-переменная %qs декларирована как %s"
+msgstr "Неиспользуемая переменная '%s' декларирована в %L"
  
  #: fortran/trans-decl.c:5319
  #, fuzzy, gcc-internal-format
+#| msgid "Unused parameter '%s' declared at %L"
  msgid "Unused parameter %qs declared at %L"
-msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %qD Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»ÐµÐ½ void"
+msgstr "Ð\9dÐµÐ¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÐ¹ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 '%s' Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ð² %L"
  
  #: fortran/trans-decl.c:5323
  #, fuzzy, gcc-internal-format
+#| msgid "Unused parameter '%s' which has been explicitly imported at %L"
  msgid "Unused parameter %qs which has been explicitly imported at %L"
-msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %qD Ð¾Ð±Ñ\8aÑ\8fÐ²Ð»ÐµÐ½ void"
+msgstr "Ð\9dÐµÐ¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ñ\8bÐ¹ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 '%s' ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐ¹ Ð±Ñ\8bÐ» Ñ\8fÐ²Ð½Ð¾ Ð¸Ð¼Ð¿Ð¾Ñ\80Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ð² %L"
  
  #: fortran/trans-decl.c:5349
  #, fuzzy, gcc-internal-format
+#| msgid "Return value '%s' of function '%s' declared at %L not set"
  msgid "Return value %qs of function %qs declared at %L not set"
-msgstr "%Jвнутренняя функция `%D' декларирована как не функция"
+msgstr "Возвращаемое значение '%s' функции '%s' декларированное в %L не установлено"
  
  #: fortran/trans-decl.c:5958
  #, gcc-internal-format, gfc-internal-format
@@ -59807,33 +62892,37 @@ msgstr ""
  #: fortran/trans-expr.c:3303
  #, gcc-internal-format
  msgid "Unknown intrinsic op"
-msgstr "Неизвестный операнд intrinsic"
+msgstr "Неизвестная встроенная операция"
  
  #: fortran/trans-expr.c:4591
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Unknown argument list function at %L"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ÐºÐ»Ñ\8eÑ\87Ð° %qs"
+msgstr "Ð\9dÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ñ\81Ð¿Ð¸Ñ\81ÐºÐ° Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² %L"
  
  #: fortran/trans-intrinsic.c:858
  #, fuzzy, gcc-internal-format
+#| msgid "Intrinsic function %s(%d) not recognized"
  msgid "Intrinsic function %qs (%d) not recognized"
-msgstr "%s: определение функции %qs не преобразовано\n"
+msgstr "Встроенная операция %s(%d) не опознана"
  
  #: fortran/trans-intrinsic.c:1501 fortran/trans-intrinsic.c:1887
  #: fortran/trans-intrinsic.c:2083
  #, fuzzy, gcc-internal-format
+#| msgid "'dim' argument of %s intrinsic at %L is not a valid dimension index"
  msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
-msgstr "аргумент `asm' - не константная строка"
+msgstr "'dim' аргумент встроенной функции %s в %L не есть корректный индекс измерения"
  
  #: fortran/trans-intrinsic.c:9366 fortran/trans-stmt.c:919
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Deferred-length character component '%s' at %L is not yet supported"
  msgid "Sorry, the event component of derived type at %L is not yet supported"
-msgstr "\"трамплины\" не поддерживаются"
+msgstr "Character компонент с отложенной длиной '%s' в %L пока не поддерживается"
  
  #: fortran/trans-intrinsic.c:9373
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Pointer object at %C shall not be coindexed"
  msgid "The event variable at %L shall not be coindexed "
-msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+msgstr "Указательный объект в %C не должен быть коиндексирован"
  
  #: fortran/trans-io.c:1849
  #, gcc-internal-format
@@ -59848,77 +62937,89 @@ msgstr "Некорректный базовый тип ввода-вывода (
  #: fortran/trans-openmp.c:4344
  #, gcc-internal-format
  msgid "gfc_trans_omp_workshare(): Bad statement code"
-msgstr ""
+msgstr "gfc_trans_omp_workshare(): Некорректный код оператора"
  
  #: fortran/trans-stmt.c:542
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "An alternate return at %L without a * dummy argument"
-msgstr "Альтернативный спецификатор возврата в %0 внутри главной программы"
+msgstr "Альтернативный возврат в %L без * формального аргумента"
  
  #: fortran/trans-stmt.c:723
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "Deferred-length character component '%s' at %L is not yet supported"
  msgid "Sorry, the lock component of derived type at %L is not yet supported"
-msgstr "\"трамплины\" не поддерживаются"
+msgstr "Character компонент с отложенной длиной '%s' в %L пока не поддерживается"
  
  #: fortran/trans-stmt.c:1178
  #, gcc-internal-format, gfc-internal-format
  msgid "Sorry, only support for integer kind %d implemented for image-set at %L"
-msgstr ""
+msgstr "Извините, поддержка только для integer вида %d реализована для image-set в %L"
  
  #: fortran/trans-stmt.c:2951
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "gfc_trans_code(): Bad statement code"
  msgid "gfc_trans_select(): Bad type for case expr."
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: fortran/trans-types.c:488
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "INTEGER(KIND=8) is not available for -fdefault-integer-8 option"
  msgid "INTEGER(KIND=8) is not available for %<-fdefault-integer-8%> option"
-msgstr ""
+msgstr "INTEGER(KIND=8) недоступно для -fdefault-integer-8 опции"
  
  #: fortran/trans-types.c:497
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "INTEGER(KIND=8) is not available for -finteger-4-integer-8 option"
  msgid "INTEGER(KIND=8) is not available for %<-finteger-4-integer-8%> option"
-msgstr ""
+msgstr "INTEGER(KIND=8) недоступно для -finteger-4-integer-8 опции"
  
  #: fortran/trans-types.c:516
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "REAL(KIND=8) is not available for -fdefault-real-8 option"
  msgid "REAL(KIND=8) is not available for %<-fdefault-real-8%> option"
-msgstr ""
+msgstr "REAL(KIND=8) недоступно для -fdefault-real-8 опции"
  
  #: fortran/trans-types.c:524
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "REAL(KIND=8) is not available for -freal-4-real-8 option"
  msgid "REAL(KIND=8) is not available for %<-freal-4-real-8%> option"
-msgstr ""
+msgstr "REAL(KIND=8) недоступно для -freal-4-real-8 опции"
  
  #: fortran/trans-types.c:532
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "REAL(KIND=10) is not available for -freal-4-real-10 option"
  msgid "REAL(KIND=10) is not available for %<-freal-4-real-10%> option"
-msgstr ""
+msgstr "REAL(KIND=10) недоступно для -freal-4-real-10 опции"
  
  #: fortran/trans-types.c:540
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "REAL(KIND=16) is not available for -freal-4-real-16 option"
  msgid "REAL(KIND=16) is not available for %<-freal-4-real-16%> option"
-msgstr ""
+msgstr "REAL(KIND=16) недоступно для -freal-4-real-16 опции"
  
  #: fortran/trans-types.c:555
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "Use of -fdefault-double-8 requires -fdefault-real-8"
  msgid "Use of %<-fdefault-double-8%> requires %<-fdefault-real-8%>"
-msgstr ""
+msgstr "Использование -fdefault-double-8 требует -fdefault-real-8"
  
  #: fortran/trans-types.c:565
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "REAL(KIND=4) is not available for -freal-8-real-4 option"
  msgid "REAL(KIND=4) is not available for %<-freal-8-real-4%> option"
-msgstr ""
+msgstr "REAL(KIND=4) недоступно для -freal-8-real-4 опции"
  
  #: fortran/trans-types.c:573
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "REAL(KIND=10) is not available for -freal-8-real-10 option"
  msgid "REAL(KIND=10) is not available for %<-freal-8-real-10%> option"
-msgstr ""
+msgstr "REAL(KIND=10) недоступно для -freal-8-real-10 опции"
  
  #: fortran/trans-types.c:581
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "REAL(KIND=10) is not available for -freal-8-real-16 option"
  msgid "REAL(KIND=10) is not available for %<-freal-8-real-16%> option"
-msgstr ""
+msgstr "REAL(KIND=10) недоступно для -freal-8-real-16 опции"
  
  #: fortran/trans-types.c:721
  #, gcc-internal-format
@@ -59931,14 +63032,14 @@ msgid "gfc_validate_kind(): Got bad kind"
  msgstr ""
  
  #: fortran/trans-types.c:1463
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Array element size too big at %C"
-msgstr "ÐÐ»ÐµÐ¼ÐµÐ½Ñ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð² %0 Ð²Ð½Ðµ Ð´Ð¸Ð°Ð¿Ð°Ð·Ð¾Ð½Ð°, Ð·Ð°Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸"
+msgstr "Ð Ð°Ð·Ð¼ÐµÑ\80 Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð²ÐµÐ»Ð¸Ðº Ð² %C"
  
  #: fortran/trans.c:1956
  #, gcc-internal-format
  msgid "gfc_trans_code(): Bad statement code"
-msgstr ""
+msgstr "gfc_trans_code(): Некорректный код оператора"
  
  #: java/class.c:823
  #, gcc-internal-format
@@ -59948,7 +63049,7 @@ msgstr "некорректная сигнатура метода"
  #: java/class.c:880
  #, gcc-internal-format
  msgid "misplaced ConstantValue attribute (not in any field)"
-msgstr "некорректное положение атрибута ConstantValue"
+msgstr "некорректное положение атрибута ConstantValue (ни в каком поле)"
  
  #: java/class.c:883
  #, gcc-internal-format, gfc-internal-format
@@ -59961,24 +63062,24 @@ msgid "ConstantValue attribute of field '%s' has wrong type"
  msgstr "некорректный тип атрибута ConstantValue поля '%s'"
  
  #: java/class.c:1619
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "abstract method in non-abstract class"
-msgstr "%Jабстрактный метод в неабстрактном классе"
+msgstr "абстрактный метод в неабстрактном классе"
  
  #: java/class.c:2682
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-static method %q+D overrides static method"
-msgstr "%Jнестатический метод %qD перекрывает статический метод"
+msgstr "нестатический метод %q+D перекрывает статический метод"
  
  #: java/decl.c:1204
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%q+D used prior to declaration"
-msgstr "%J%qD использовано до декларации"
+msgstr "%q+D использовано до декларации"
  
  #: java/decl.c:1627
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "In %+D: overlapped variable and exception ranges at %d"
-msgstr "%JВ %D: перекрытие диапазонов переменных и исключений в %d"
+msgstr "В %+D: перекрытие диапазонов переменных и исключений в %d"
  
  #: java/decl.c:1678
  #, gcc-internal-format
@@ -59996,14 +63097,14 @@ msgid "need to insert runtime check for %s"
  msgstr "необходимо вставить проверку %s на стадии выполнения"
  
  #: java/expr.c:493 java/expr.c:540
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "assert: %s is assign compatible with %s"
-msgstr "ключ -march=%s несовместим с выбранным ABI"
+msgstr "assert: %s совместима по присваиванию с %s"
  
  #: java/expr.c:651
  #, gcc-internal-format
  msgid "stack underflow - dup* operation"
-msgstr "Ð¿ÐµÑ\80ÐµÐ¿Ð¾Ð»Ð½Ðµние стека - операция dup*"
+msgstr "Ð¸Ñ\81Ñ\87ÐµÑ\80Ð¿Ð°ние стека - операция dup*"
  
  #: java/expr.c:1650
  #, gcc-internal-format
@@ -60018,7 +63119,7 @@ msgstr "нет поля %qs"
  #: java/expr.c:2236
  #, gcc-internal-format, gfc-internal-format
  msgid "method '%s' not found in class"
-msgstr "метод '%s' отсутствует в классе "
+msgstr "метод '%s' отсутствует в классе"
  
  #: java/expr.c:2428
  #, gcc-internal-format, gfc-internal-format
@@ -60056,9 +63157,9 @@ msgid "mismatching signature for field '%s' in '%s'"
  msgstr "несоответствие сигнатуры для поля '%s' в '%s'"
  
  #: java/expr.c:2907
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "assignment to final field %q+D not in field%'s class"
-msgstr "присваивание финальному полю %q+D - не в классе этого поля"
+msgstr "присваивание финальному полю %q+D не в классе этого поля"
  
  #: java/expr.c:3135
  #, gcc-internal-format
@@ -60077,19 +63178,19 @@ msgstr "недостижимый байткод от %d до конца мето
  
  #. duplicate code from LOAD macro
  #: java/expr.c:3535
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unrecognized wide sub-instruction"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ñ\88Ð¸Ñ\80Ð¾ÐºÐ°Ñ\8f Ñ\81Ñ\83Ð±-инструкция"
+msgstr "Ð½ÐµÐ¾Ð¿Ð¾Ð·Ð½Ð°Ð½Ð½Ð°Ñ\8f Ñ\88Ð¸Ñ\80Ð¾ÐºÐ°Ñ\8f Ð¿Ð¾Ð´инструкция"
  
  #: java/jcf-parse.c:502
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "<constant pool index %d not in range>"
-msgstr "Константный операнд загрузки полуслова - вне диапазона"
+msgstr "<константный индекс пуля %d вне диапазона>"
  
  #: java/jcf-parse.c:512
  #, gcc-internal-format, gfc-internal-format
  msgid "<constant pool index %d unexpected type"
-msgstr ""
+msgstr "<константный индекс пуля %d неожиданного типа"
  
  #: java/jcf-parse.c:1094
  #, gcc-internal-format
@@ -60137,9 +63238,9 @@ msgid "error while parsing final attributes"
  msgstr "ошибка при разборе финальных атрибутов"
  
  #: java/jcf-parse.c:1505
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "duplicate class will only be compiled once"
-msgstr "%Hповторно встреченный класс будет скомпилирован только один раз"
+msgstr "повторный класс будет скомпилирован только один раз"
  
  #: java/jcf-parse.c:1602
  #, gcc-internal-format
@@ -60152,7 +63253,7 @@ msgid "no input file specified"
  msgstr "не задано ни одного входного файла"
  
  #: java/jcf-parse.c:1886
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t close input file %s: %m"
  msgstr "ошибка при закрытии входного файла %s: %m"
  
@@ -60167,14 +63268,14 @@ msgid "error while reading %s from zip file"
  msgstr "ошибка чтения  %s из zip-файла"
  
  #: java/jvspec.c:395
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t specify %<-D%> without %<--main%>"
-msgstr "не допускается использовать '-D' без '--main'\n"
+msgstr "невозможно специфицировать %<-D%> без %<--main%>"
  
  #: java/jvspec.c:399
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qs is not a valid class name"
-msgstr "'%s' не является корректным именем класса"
+msgstr "%qs не является корректным именем класса"
  
  #: java/jvspec.c:405
  #, gcc-internal-format
@@ -60182,9 +63283,9 @@ msgid "--resource requires -o"
  msgstr "ключ --resource требует задания -o"
  
  #: java/jvspec.c:412
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "already-compiled .class files ignored with -C"
-msgstr "предупреждение: скомпилированные .class файлы игнорируются, если задано -C"
+msgstr "уже скомпилированные .class файлы игнорируются с -C"
  
  #: java/jvspec.c:419
  #, gcc-internal-format
@@ -60202,32 +63303,32 @@ msgid "using both @FILE with multiple files not implemented"
  msgstr "использование @FILE и нескольких входных файлов не поддерживается"
  
  #: java/jvspec.c:539
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot specify %<main%> class when not linking"
-msgstr "Ð·Ð°Ð´Ð°Ð½Ð¸Ðµ ÐºÐ»Ð°Ñ\81Ñ\81Ð° 'main' Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ без компоновки"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c %<main%> ÐºÐ»Ð°Ñ\81Ñ\81 без компоновки"
  
  #: java/lang.c:574
  #, gcc-internal-format
  msgid "-fexcess-precision=standard for Java"
-msgstr ""
+msgstr "-fexcess-precision=standard для Java"
  
  #: java/lang.c:585
  #, gcc-internal-format
  msgid "-findirect-dispatch is incompatible with -freduced-reflection"
-msgstr ""
+msgstr "-findirect-dispatch несовместимо с -freduced-reflection"
  
  #: java/lang.c:588
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-fjni is incompatible with -freduced-reflection"
-msgstr "ключ -G несовместим с PIC-кодом, который генерируется по умолчанию"
+msgstr "-fjni несовместимо с -freduced-reflection"
  
  #: java/lang.c:599
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can%'t do dependency tracking with input from stdin"
  msgstr "отслеживание зависимостей невозможно при вводе со стандартного ввода"
  
  #: java/lang.c:615
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "couldn%'t determine target name for dependency tracking"
  msgstr "ошибка определения имени цели при отслеживании зависимостей"
  
@@ -60258,8 +63359,9 @@ msgstr "некорректный pc в таблице прерываний excep
  
  #: jit/docs/examples/tut05-bf.c:242
  #, fuzzy, gcc-internal-format
+#| msgid "too many arguments"
  msgid "too many open parens"
-msgstr "слишком много аргументов для форматирования"
+msgstr "слишком много аргументов"
  
  #: jit/docs/examples/tut05-bf.c:275
  #, fuzzy, gcc-internal-format
@@ -60274,14 +63376,14 @@ msgid "unable to open file"
  msgstr "не удалось открыть %s"
  
  #: lto/lto-lang.c:808
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "-fwpa and -fltrans are mutually exclusive"
-msgstr "-G и -static несовместимы"
+msgstr "-fwpa и -fltrans являются взаимоисключающими"
  
  #: lto/lto-object.c:107
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "open %s failed: %s"
-msgstr "ошибка открытия входного файла %qs"
+msgstr "ошибка открытия %s: %s"
  
  #: lto/lto-object.c:151 lto/lto-object.c:186 lto/lto-object.c:283
  #: lto/lto-object.c:340 lto/lto-object.c:364
@@ -60290,44 +63392,46 @@ msgid "%s: %s"
  msgstr "%s: %s"
  
  #: lto/lto-object.c:153
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "%s: %s: %s"
-msgstr "%s: %s"
+msgstr "%s: %s: %s"
  
  #: lto/lto-object.c:195
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "close: %s"
-msgstr "fclose %s"
+msgstr "close: %s"
  
  #: lto/lto-object.c:251
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "two or more sections for %s"
-msgstr "Ð´Ð²Ð° Ð¸Ð»Ð¸ Ð±Ð¾Ð»ÐµÐµ Ñ\82Ð¸Ð¿Ð° Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð¸Ð¼ÐµÐ½Ð¸ %qs"
+msgstr "Ð´Ð²Ðµ Ð¸Ð»Ð¸ Ð±Ð¾Ð»ÐµÐµ Ñ\81ÐµÐºÑ\86Ð¸Ð¸ Ð´Ð»Ñ\8f %s"
  
  #: lto/lto-symtab.c:172
  #, fuzzy, gcc-internal-format
+#| msgid "%qD is initialized with itself"
  msgid "%qD is defined with tls model %s"
-msgstr "%H%qD используется без инициализации в данной функции"
+msgstr "%qD инициализируется самим собой"
  
  #: lto/lto-symtab.c:174
  #, fuzzy, gcc-internal-format, gfc-internal-format
+#| msgid "previously defined here"
  msgid "previously defined here as %s"
-msgstr "это предыдущее определение `%#D'"
+msgstr "предыдущее определение здесь"
  
  #: lto/lto-symtab.c:444
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "multiple prevailing defs for %qE"
-msgstr "Ð±Ð¾Ð»ÐµÐµ Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° Ñ\81 Ð¸Ð¼ÐµÐ½ÐµÐ¼ %qE"
+msgstr "Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ Ð¿Ñ\80ÐµÐ²Ð°Ð»Ð¸Ñ\80Ñ\83Ñ\8eÑ\89Ð¸Ñ\85 Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¹ Ð´Ð»Ñ\8f %qE"
  
  #: lto/lto-symtab.c:462
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qD has already been defined"
-msgstr "определение %qD уже есть в %qT"
+msgstr "%qD уже была определена"
  
  #: lto/lto-symtab.c:464
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "previously defined here"
-msgstr "это предыдущее определение `%#D'"
+msgstr "предыдущее определение здесь"
  
  #: lto/lto-symtab.c:664
  #, gcc-internal-format
@@ -60335,24 +63439,26 @@ msgid "%qD violates the C++ One Definition Rule "
  msgstr ""
  
  #: lto/lto-symtab.c:669
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type of %qD does not match original declaration"
-msgstr "идентификатор шаблона %qD использован как декларатор"
+msgstr "тип %qD не соответствует исходной декларации"
  
  #: lto/lto-symtab.c:689
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "alignment of %qD is bigger than original declaration"
-msgstr "Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ (Ð° Ð½Ðµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f) Ð² декларации"
+msgstr "Ð²Ñ\8bÑ\80Ð°Ð²Ð½Ð¸Ð²Ð°Ð½Ð¸Ðµ %qD Ð±Ð¾Ð»Ñ\8cÑ\88Ðµ Ñ\87ÐµÐ¼ Ð² Ð¸Ñ\81Ñ\85Ð¾Ð´Ð½Ð¾Ð¹ декларации"
  
  #: lto/lto-symtab.c:695
  #, fuzzy, gcc-internal-format
+#| msgid "type of %qD does not match original declaration"
  msgid "size of %qD differ from the size of original declaration"
-msgstr "идентификатор шаблона %qD использован как декларатор"
+msgstr "тип %qD не соответствует исходной декларации"
  
  #: lto/lto-symtab.c:700
  #, fuzzy, gcc-internal-format
+#| msgid "%q#T was previously declared here"
  msgid "%qD was previously declared here"
-msgstr "это предыдущее определение `%#D'"
+msgstr "%q#T был ранее декларирован здесь"
  
  #: lto/lto-symtab.c:703
  #, gcc-internal-format
@@ -60360,94 +63466,97 @@ msgid "code may be misoptimized unless -fno-strict-aliasing is used"
  msgstr ""
  
  #: lto/lto-symtab.c:789
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "variable %qD redeclared as function"
-msgstr "Ð¿Ð¾Ð»Ðµ %qs Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¾ как функция"
+msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qD Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð¾ Ð´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð° как функция"
  
  #: lto/lto-symtab.c:796
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "function %qD redeclared as variable"
-msgstr "функция %q+D повторно декларирована как inline"
+msgstr "функция %qD повторно декларирована как переменная"
  
  #: lto/lto-symtab.c:808
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "previously declared here"
-msgstr "это предыдущее определение `%#D'"
+msgstr "предыдущая декларация здесь"
  
  #: lto/lto.c:1817
  #, gcc-internal-format
  msgid "bytecode stream: garbage at the end of symbols section"
-msgstr ""
+msgstr "поток байткода: мусор в конце секции символов"
  
  #: lto/lto.c:1844
  #, gcc-internal-format
  msgid "could not parse hex number"
-msgstr ""
+msgstr "невозможно разобрать шестнадцатеричное число"
  
  #: lto/lto.c:1876
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "unexpected file name %s in linker resolution file. Expected %s"
-msgstr "ÐºÐ²Ð°Ð»Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ñ\8b Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°Ñ\8eÑ\82Ñ\81Ñ\8f Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ `operator %T'"
+msgstr "Ð½ÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð¾Ðµ Ð¸Ð¼Ñ\8f Ñ\84Ð°Ð¹Ð»Ð° %s Ð² Ñ\84Ð°Ð¹Ð»Ðµ Ñ\80Ð°Ð·Ñ\80ÐµÑ\88ÐµÐ½Ð¸Ð¹ Ð»Ð¸Ð½ÐºÐµÑ\80Ð°. Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %s"
  
  #: lto/lto.c:1885
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "could not parse file offset"
-msgstr "не удалось найти файл отзыва %s"
+msgstr "невозможно разобрать файловое смещение"
  
  #: lto/lto.c:1888
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "unexpected offset"
-msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´"
+msgstr "Ð½ÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ð¾Ðµ Ñ\81Ð¼ÐµÑ\89ÐµÐ½Ð¸Ðµ"
  
  #: lto/lto.c:1910
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid line in the resolution file"
-msgstr "некорректный регистр в инструкции"
+msgstr "некорректная строка в файле разрешений"
  
  #: lto/lto.c:1921
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid resolution in the resolution file"
-msgstr "некорректный регистр в инструкции"
+msgstr "некорректное разрешение в файле разрешений"
  
  #: lto/lto.c:1927
-#, gcc-internal-format
+#, fuzzy, gcc-internal-format
+#| msgid "resolution sub id "
  msgid "resolution sub id %wx not in object file"
-msgstr ""
+msgstr "разрешения sub id "
  
  #: lto/lto.c:2039
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "cannot read LTO decls from %s"
-msgstr "Ð½ÐµÑ\82 ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qs"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f LTO Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¹ Ð¸Ð· %s"
  
  #: lto/lto.c:2145
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Cannot open %s"
-msgstr "Ð¾шибка открытия %s"
+msgstr "Ð\9eшибка открытия %s"
  
  #: lto/lto.c:2166
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Cannot map %s"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82ия %s"
+msgstr "Ð\9eÑ\88Ð¸Ð±ÐºÐ° Ð¾Ñ\82Ð¾Ð±Ñ\80Ð°Ð¶ÐµÐ½ия %s"
  
  #: lto/lto.c:2177
-#, fuzzy, gcc-internal-format, gfc-internal-format
+#, gcc-internal-format, gfc-internal-format
  msgid "Cannot read %s"
-msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82ия %s"
+msgstr "Ð\9eÑ\88Ð¸Ð±ÐºÐ° Ñ\87Ñ\82ÐµÐ½ия %s"
  
  #: lto/lto.c:2291
  #, gcc-internal-format
  msgid "lto_obj_file_open() failed"
-msgstr ""
+msgstr "ошибка lto_obj_file_open()"
  
  #: lto/lto.c:2314
  #, fuzzy, gcc-internal-format
+#| msgid "atexit failed"
  msgid "waitpid failed"
-msgstr "ошибка в pex_init"
+msgstr "ошибка в atexit"
  
  #: lto/lto.c:2317
  #, fuzzy, gcc-internal-format
+#| msgid "renaming .rpo file: %m"
  msgid "streaming subprocess failed"
-msgstr "переименование файла .rpo"
+msgstr "переименование файла .rpo: %m"
  
  #: lto/lto.c:2320
  #, gcc-internal-format
@@ -60457,32 +63566,32 @@ msgstr ""
  #: lto/lto.c:2396
  #, gcc-internal-format
  msgid "no LTRANS output list filename provided"
-msgstr ""
+msgstr "Не задано LTRANS имя файла выходного списка"
  
  #: lto/lto.c:2484
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "opening LTRANS output list %s: %m"
-msgstr "Ð¿Ñ\80Ð¸ Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82Ð¸Ð¸ Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\84Ð°Ð¹Ð»а %s: %m"
+msgstr "Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82Ð¸Ðµ LTRANS Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\81Ð¿Ð¸Ñ\81Ðºа %s: %m"
  
  #: lto/lto.c:2490
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "writing to LTRANS output list %s: %m"
-msgstr "Ð¿Ñ\80Ð¸ Ð·Ð°Ð¿Ð¸Ñ\81Ð¸ Ð²Ñ\8bÐ²Ð¾Ð´Ð° Ð² %s: %m"
+msgstr "Ð·Ð°Ð¿Ð¸Ñ\81Ñ\8c Ð² LTRANS Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ð¾Ð¹ Ñ\81Ð¿Ð¸Ñ\81Ð¾Ðº %s: %m"
  
  #: lto/lto.c:2501
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "closing LTRANS output list %s: %m"
-msgstr "Ð¿Ñ\80Ð¸ Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82Ð¸Ð¸ Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\84Ð°Ð¹Ð»а %s: %m"
+msgstr "Ð·Ð°ÐºÑ\80Ñ\8bÑ\82Ð¸Ðµ LTRANS Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ñ\81Ð¿Ð¸Ñ\81Ðºа %s: %m"
  
  #: lto/lto.c:2753
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "could not open symbol resolution file: %m"
-msgstr "Ð½Ðµ Ñ\83Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð½Ð°Ð¹Ñ\82Ð¸ Ñ\84Ð°Ð¹Ð» Ð¾Ñ\82Ð·Ñ\8bÐ²Ð° %s"
+msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82Ð¸Ñ\8f Ñ\84Ð°Ð¹Ð»Ð° Ñ\80Ð°Ð·Ñ\80ÐµÑ\88ÐµÐ½Ð¸Ñ\8f Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ð¾Ð²: %m"
  
  #: lto/lto.c:2894
  #, gcc-internal-format
  msgid "errors during merging of translation units"
-msgstr ""
+msgstr "ошибки при слиянии единиц трансляции"
  
  #: objc/objc-act.c:425 objc/objc-act.c:6779
  #, gcc-internal-format
@@ -60492,32 +63601,32 @@ msgstr "отсутствует %<@end%> в контексте реализаци
  #: objc/objc-act.c:578
  #, gcc-internal-format
  msgid "class attributes are not available in Objective-C 1.0"
-msgstr ""
+msgstr "атрибуты класс недоступны в Objective-C 1.0"
  
  #: objc/objc-act.c:593
  #, gcc-internal-format
  msgid "category attributes are not available in Objective-C 1.0"
-msgstr ""
+msgstr "атрибуты категорий недоступны в Objective-C 1.0"
  
  #: objc/objc-act.c:596
  #, gcc-internal-format
  msgid "category attributes are not available in this version of the compiler, (ignored)"
-msgstr ""
+msgstr "атрибуты категорий недоступны в этой версии компилятора, (игнорируется)"
  
  #: objc/objc-act.c:602
  #, gcc-internal-format
  msgid "class extensions are not available in Objective-C 1.0"
-msgstr ""
+msgstr "расширения класса недоступны в Objective-C 1.0"
  
  #: objc/objc-act.c:616
  #, gcc-internal-format
  msgid "class extension for class %qE declared after its %<@implementation%>"
-msgstr ""
+msgstr "расширение класса для класса %qE декларировано после его %<@implementation%>"
  
  #: objc/objc-act.c:631
  #, gcc-internal-format
  msgid "protocol attributes are not available in Objective-C 1.0"
-msgstr ""
+msgstr "атрибуты протокола недоступны в Objective-C 1.0"
  
  #: objc/objc-act.c:696
  #, gcc-internal-format
@@ -60527,77 +63636,77 @@ msgstr "%<@end%> должен находиться в контексте @implem
  #: objc/objc-act.c:705
  #, gcc-internal-format
  msgid "%<@package%> is not available in Objective-C 1.0"
-msgstr ""
+msgstr "%<@package%> недоступен в Objective-C 1.0"
  
  #: objc/objc-act.c:707
  #, gcc-internal-format
  msgid "%<@package%> presently has the same effect as %<@public%>"
-msgstr ""
+msgstr "%<@package%> в настоящее время имеет тот же эффект что и %<@public%>"
  
  #: objc/objc-act.c:718
  #, gcc-internal-format
  msgid "%<@optional%> is not available in Objective-C 1.0"
-msgstr ""
+msgstr "%<@optional%> недоступно в Objective-C 1.0"
  
  #: objc/objc-act.c:720
  #, gcc-internal-format
  msgid "%<@required%> is not available in Objective-C 1.0"
-msgstr ""
+msgstr "%<@required%> недоступно в Objective-C 1.0"
  
  #: objc/objc-act.c:728
  #, gcc-internal-format
  msgid "%<@optional%> is allowed in @protocol context only"
-msgstr ""
+msgstr "%<@optional%> допускается только в @protocol контексте"
  
  #: objc/objc-act.c:730
  #, gcc-internal-format
  msgid "%<@required%> is allowed in @protocol context only"
-msgstr ""
+msgstr "%<@required%> допускается только в @protocol контексте"
  
  #: objc/objc-act.c:837
  #, gcc-internal-format
  msgid "%<@property%> is not available in Objective-C 1.0"
-msgstr ""
+msgstr "%<@property%> недоступно в Objective-C 1.0"
  
  #: objc/objc-act.c:841
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<readonly%> attribute conflicts with %<readwrite%> attribute"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%<readonly%> атрибут конфликтует с %<readwrite%> атрибутом"
  
  #: objc/objc-act.c:858
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<readonly%> attribute conflicts with %<setter%> attribute"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%<readonly%> атрибут конфликтует с %<setter%> атрибутом"
  
  #: objc/objc-act.c:864
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<assign%> attribute conflicts with %<retain%> attribute"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%<assign%> атрибут конфликтует с %<retain%> атрибутом"
  
  #: objc/objc-act.c:869
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<assign%> attribute conflicts with %<copy%> attribute"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%<assign%> атрибут конфликтует с %<copy%> атрибутом"
  
  #: objc/objc-act.c:874
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<retain%> attribute conflicts with %<copy%> attribute"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%<retain%> атрибут конфликтует с %<copy%> атрибутом"
  
  #: objc/objc-act.c:891
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "property declaration not in @interface or @protocol context"
-msgstr "декларация метода вне контекста @interface"
+msgstr "декларация свойства не в @interface или @protocol контексте"
  
  #: objc/objc-act.c:902
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid property declaration"
-msgstr "некорректная декларация %q+D"
+msgstr "некорректная декларация свойства"
  
  #: objc/objc-act.c:910
  #, gcc-internal-format
  msgid "property can not be an array"
-msgstr ""
+msgstr "свойство не может быть массивом"
  
  #. A @property is not an actual variable, but it is a way to
  #. describe a pair of accessor methods, so its type (which is
@@ -60607,107 +63716,107 @@ msgstr ""
  #. underlying instance variable could be a bitfield, but that is
  #. a different matter.
  #: objc/objc-act.c:928
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "property can not be a bit-field"
-msgstr "статический элемент %qD не может быть битовым полем"
+msgstr "свойство не может быть битовым полем"
  
  #: objc/objc-act.c:960
  #, gcc-internal-format
  msgid "object property %qD has no %<assign%>, %<retain%> or %<copy%> attribute; assuming %<assign%>"
-msgstr ""
+msgstr "свойство объекта %qD не имеет %<assign%>, %<retain%> или %<copy%> атрибута; предполагается %<assign%>"
  
  #: objc/objc-act.c:963
  #, gcc-internal-format
  msgid "%<assign%> can be unsafe for Objective-C objects; please state explicitly if you need it"
-msgstr ""
+msgstr "%<assign%> может быть небезопасным для Objective-C объектов; пожалуйста укажите явно если вам это нужно"
  
  #: objc/objc-act.c:970
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<retain%> attribute is only valid for Objective-C objects"
-msgstr "атрибут %qs допустим только для переменных"
+msgstr "%<retain%> атрибут допустим только для Objective-C объектов"
  
  #: objc/objc-act.c:974
  #, gcc-internal-format
  msgid "%<copy%> attribute is only valid for Objective-C objects"
-msgstr ""
+msgstr "%<copy%> атрибут допустим только для Objective-C объектов"
  
  #: objc/objc-act.c:1028
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "redeclaration of property %qD"
-msgstr "повторная декларация перечислимого типа %q+D"
+msgstr "редекларация свойства %qD"
  
  #: objc/objc-act.c:1031 objc/objc-act.c:1096 objc/objc-act.c:1106
  #: objc/objc-act.c:1119 objc/objc-act.c:1130 objc/objc-act.c:1141
  #: objc/objc-act.c:1178 objc/objc-act.c:7552 objc/objc-act.c:7615
  #: objc/objc-act.c:7637 objc/objc-act.c:7650 objc/objc-act.c:7668
  #: objc/objc-act.c:7767
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "originally specified here"
-msgstr "%J  исходное определение находится здесь"
+msgstr "первоначально специфицировано здесь"
  
  #: objc/objc-act.c:1093
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "'nonatomic' attribute of property %qD conflicts with previous declaration"
-msgstr "%Jобласть данных %qD противоречит предыдущей декларации"
+msgstr "'nonatomic' атрибут свойства %qD конфликтует с предшествующей декларацией"
  
  #: objc/objc-act.c:1103
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "'getter' attribute of property %qD conflicts with previous declaration"
-msgstr "%Jобласть данных %qD противоречит предыдущей декларации"
+msgstr "'getter' атрибут свойства %qD конфликтует с предшествующей декларацией"
  
  #: objc/objc-act.c:1116
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "'setter' attribute of property %qD conflicts with previous declaration"
-msgstr "%Jобласть данных %qD противоречит предыдущей декларации"
+msgstr "'setter' атрибут свойства %qD конфликтует с предшествующей декларацией"
  
  #: objc/objc-act.c:1127
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "assign semantics attributes of property %qD conflict with previous declaration"
-msgstr "%Jобласть данных %qD противоречит предыдущей декларации"
+msgstr "атрибуты семантики присваивания свойства %qD конфликтуют с предшествующей декларацией"
  
  #: objc/objc-act.c:1138
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "'readonly' attribute of property %qD conflicts with previous declaration"
-msgstr "%Jобласть данных %qD противоречит предыдущей декларации"
+msgstr "'readonly' атрибут свойства %qD конфликтует с предшествующей декларацией"
  
  #: objc/objc-act.c:1176
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type of property %qD conflicts with previous declaration"
-msgstr "%Jобласть данных %qD противоречит предыдущей декларации"
+msgstr "тип свойства %qD конфликтует с предшествующей декларацией"
  
  #: objc/objc-act.c:1649
  #, gcc-internal-format
  msgid "the dot syntax is not available in Objective-C 1.0"
-msgstr ""
+msgstr "точечный синтаксис недоступен в Objective-C 1.0"
  
  #. We know that 'class_name' is an Objective-C class name as the
  #. parser won't call this function if it is not.  This is only a
  #. double-check for safety.
  #: objc/objc-act.c:1665
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "could not find class %qE"
-msgstr "нет класса %qs"
+msgstr "невозможно найти класс %qE"
  
  #. Again, this should never happen, but we do check.
  #: objc/objc-act.c:1673
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "could not find interface for class %qE"
-msgstr "нет файла для класса %s"
+msgstr "невозможно найти интерфейс для класса %qE"
  
  #: objc/objc-act.c:1679 objc/objc-act.c:6816 objc/objc-act.c:6947
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "class %qE is deprecated"
-msgstr "Ð¸Ð¼Ñ\8f %qs Ð±Ñ\83Ð´ÐµÑ\82 Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¾ Ð² Ð±Ñ\83Ð´Ñ\83Ñ\89Ð¸Ñ\85 Ð²ÐµÑ\80Ñ\81Ð¸Ñ\8fÑ\85"
+msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 %qE Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ»"
  
  #: objc/objc-act.c:1708
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "could not find setter/getter for %qE in class %qE"
-msgstr "нет тега для класса %qs"
+msgstr "невозможно найти setter/getter для %qE в классе %qE"
  
  #: objc/objc-act.c:1744
  #, gcc-internal-format
  msgid "readonly property can not be set"
-msgstr ""
+msgstr "readonly свойство на может быть установлено"
  
  #: objc/objc-act.c:2015
  #, gcc-internal-format
@@ -60717,7 +63826,7 @@ msgstr "декларация метода вне контекста @interface"
  #: objc/objc-act.c:2019
  #, gcc-internal-format
  msgid "method attributes are not available in Objective-C 1.0"
-msgstr ""
+msgstr "атрибуты методов недоступны в Objective-C 1.0"
  
  #: objc/objc-act.c:2039
  #, gcc-internal-format
@@ -60725,19 +63834,19 @@ msgid "method definition not in @implementation context"
  msgstr "определение метода вне контекста @implementation"
  
  #: objc/objc-act.c:2054
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "method attributes can not be specified in @implementation context"
-msgstr "Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ Ð¼ÐµÑ\82Ð¾Ð´Ð° Ð²Ð½Ðµ ÐºÐ¾Ð½Ñ\82ÐµÐºÑ\81Ñ\82Ð° @implementation"
+msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82Ñ\8b Ð¼ÐµÑ\82Ð¾Ð´Ð¾Ð² Ð½Ðµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð±Ñ\8bÑ\82Ñ\8c Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ñ\8b Ð² @implementation ÐºÐ¾Ð½Ñ\82ÐµÐºÑ\81Ñ\82Ðµ"
  
  #: objc/objc-act.c:2283
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "class %qs does not implement the %qE protocol"
-msgstr "%s %qs не является полной реализацией протокола %qs"
+msgstr "класс %qs не реализует %qE протокол"
  
  #: objc/objc-act.c:2286
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type %qs does not conform to the %qE protocol"
-msgstr "%s %qs не является полной реализацией протокола %qs"
+msgstr "тип %qs не подходит %qE протоколу"
  
  #: objc/objc-act.c:2567
  #, gcc-internal-format
@@ -60765,14 +63874,14 @@ msgid "passing argument %d of %qE from distinct Objective-C type"
  msgstr "Передача аргумента %d функции %qE с отличающимся Objective-C типом"
  
  #: objc/objc-act.c:2725
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "statically allocated instance of Objective-C class %qE"
-msgstr "статически размещенный экземпляр класса Objective-C %qs"
+msgstr "статически размещенный экземпляр Objective-C класса %qE"
  
  #: objc/objc-act.c:2734
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "redeclaration of Objective-C class %qs"
-msgstr "Ñ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸ Ñ\80Ð°Ð·Ð¼ÐµÑ\89ÐµÐ½Ð½Ñ\8bÐ¹ Ñ\8dÐºÐ·ÐµÐ¼Ð¿Ð»Ñ\8fÑ\80 ÐºÐ»Ð°Ñ\81Ñ\81Ð° Objective-C %qs"
+msgstr "Ñ\80ÐµÐ´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Objective-C ÐºÐ»Ð°Ñ\81Ñ\81Ð° %qs"
  
  #. This case happens when we are given an 'interface' which
  #. is not a valid class name.  For example if a typedef was
@@ -60784,38 +63893,38 @@ msgstr "статически размещенный экземпляр клас
  #: objc/objc-act.c:2776
  #, gcc-internal-format
  msgid "only Objective-C object types can be qualified with a protocol"
-msgstr ""
+msgstr "только типы Objective-C объектов могут быть квалифицированы протоколом"
  
  #: objc/objc-act.c:2840
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "protocol %qE has circular dependency"
-msgstr "циклическая зависимость в протоколе %qs"
+msgstr "протокол %qE имеет циклические зависимости"
  
  #: objc/objc-act.c:2873 objc/objc-act.c:5680
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot find protocol declaration for %qE"
-msgstr "нет декларации протокола для %qs"
+msgstr "невозможно найти декларацию протокола для %qE"
  
  #: objc/objc-act.c:3174 objc/objc-act.c:3829 objc/objc-act.c:6392
  #: objc/objc-act.c:6867 objc/objc-act.c:6940 objc/objc-act.c:6993
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot find interface declaration for %qE"
-msgstr "нет декларации интерфейса для %qs"
+msgstr "невозможно найти декларацию интерфейса для %qE"
  
  #: objc/objc-act.c:3178
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "interface %qE does not have valid constant string layout"
-msgstr "интерфейс %qs не имеет корректной структуры константной строки"
+msgstr "интерфейс %qE не имеет корректной структуры константной строки"
  
  #: objc/objc-act.c:3183
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot find reference tag for class %qE"
-msgstr "нет тега для класса %qs"
+msgstr "невозможно найти тег ссылки для класса %qE"
  
  #: objc/objc-act.c:3328
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE is not an Objective-C class name or alias"
-msgstr "%qs не является именем класса Objective-C или синонимом"
+msgstr "%qE не является именем Objective-C класса или синонимом"
  
  #: objc/objc-act.c:3343 objc/objc-act.c:3374 objc/objc-act.c:6773
  #: objc/objc-act.c:8098 objc/objc-act.c:8149
@@ -60824,19 +63933,19 @@ msgid "Objective-C declarations may only appear in global scope"
  msgstr "декларации Objective-C могут находиться только в глобальной области"
  
  #: objc/objc-act.c:3348
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot find class %qE"
-msgstr "нет класса %qs"
+msgstr "невозможно найти класс %qE"
  
  #: objc/objc-act.c:3350
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "class %qE already exists"
-msgstr "класс %qs уже существует"
+msgstr "класс %qE уже существует"
  
  #: objc/objc-act.c:3392 objc/objc-act.c:6832
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE redeclared as different kind of symbol"
-msgstr "имя %qs повторно декларировано как имя другого вида"
+msgstr "%qE редекларирован как другой вид символа"
  
  #: objc/objc-act.c:3394 objc/objc-act.c:3980 objc/objc-act.c:4008
  #: objc/objc-act.c:4063 objc/objc-act.c:6834
@@ -60870,14 +63979,14 @@ msgid "global/static variable assignment has been intercepted"
  msgstr "Перехвачено присваивание к глобальной или статической переменной"
  
  #: objc/objc-act.c:3977 objc/objc-act.c:4005 objc/objc-act.c:4060
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "duplicate instance variable %q+D"
-msgstr "Ð½ÐµÐ¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ñ\83ÐµÐ¼Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %q+D"
+msgstr "Ð´Ñ\83Ð±Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ instance Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹ %q+D"
  
  #: objc/objc-act.c:4120
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<-fobjc-exceptions%> is required to enable Objective-C exception syntax"
-msgstr "задайте %<-fobjc-exceptions%> для использования синтаксиса исключений Objective-C"
+msgstr "%<-fobjc-exceptions%> требуется для включения Objective-C синтаксиса исключений"
  
  #: objc/objc-act.c:4204
  #, gcc-internal-format
@@ -60885,9 +63994,9 @@ msgid "@catch parameter is not a known Objective-C class type"
  msgstr "параметр @catch не является известным типом класса в Objective-C"
  
  #: objc/objc-act.c:4210
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "@catch parameter can not be protocol-qualified"
-msgstr "параметры шаблона не могут быть friend"
+msgstr "параметр @catch не может быть protocol-qualified"
  
  #: objc/objc-act.c:4255
  #, gcc-internal-format
@@ -60895,9 +64004,9 @@ msgid "exception of type %<%T%> will be caught"
  msgstr "будет обработана исключительная ситуация типа %<%T%>"
  
  #: objc/objc-act.c:4257
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "   by earlier handler for %<%T%>"
-msgstr "%H   при помощи ранее заданного обработчика для %<%T%>"
+msgstr "   при помощи ранее заданного обработчика для %<%T%>"
  
  #: objc/objc-act.c:4304
  #, gcc-internal-format
@@ -60910,19 +64019,19 @@ msgid "%<@throw%> (rethrow) used outside of a @catch block"
  msgstr "%<@throw%> (rethrow) использовано вне блока @catch"
  
  #: objc/objc-act.c:4345
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<@throw%> argument is not an object"
-msgstr "аргумент %qD не является константой"
+msgstr "%<@throw%> аргумент не является объектом"
  
  #: objc/objc-act.c:4366
  #, gcc-internal-format
  msgid "%<@synchronized%> argument is not an object"
-msgstr ""
+msgstr "%<@synchronized%> аргумент не является объектом"
  
  #: objc/objc-act.c:4574
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s %qs"
-msgstr "%J%s %qs"
+msgstr "%s %qs"
  
  #: objc/objc-act.c:4597 objc/objc-act.c:4616
  #, gcc-internal-format
@@ -60937,32 +64046,32 @@ msgstr "недопустимое использование объекта ка
  #: objc/objc-act.c:4715
  #, gcc-internal-format
  msgid "method argument attributes are not available in Objective-C 1.0"
-msgstr ""
+msgstr "атрибуты аргументов методов недоступны в Objective-C 1.0"
  
  #: objc/objc-act.c:5089
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "multiple methods named %<%c%E%> found"
-msgstr "Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶ÐµÐ½Ð¾ Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ %s Ñ\81 Ð¸Ð¼ÐµÐ½ÐµÐ¼ %<%c%s%>"
+msgstr "Ð½Ð°Ð¹Ð´ÐµÐ½Ð¾ Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ Ð¼ÐµÑ\82Ð¾Ð´Ð¾Ð² Ñ\81 Ð¸Ð¼ÐµÐ½ÐµÐ¼ %<%c%E%>"
  
  #: objc/objc-act.c:5092
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "using %<%c%s%>"
-msgstr "%J%s %<%c%s%>"
+msgstr "использование %<%c%s%>"
  
  #: objc/objc-act.c:5101
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "multiple selectors named %<%c%E%> found"
-msgstr "Ð¾Ð±Ð½Ð°Ñ\80Ñ\83Ð¶ÐµÐ½Ð¾ Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ %s Ñ\81 Ð¸Ð¼ÐµÐ½ÐµÐ¼ %<%c%s%>"
+msgstr "Ð½Ð°Ð¹Ð´ÐµÐ½Ð¾ Ð½ÐµÑ\81ÐºÐ¾Ð»Ñ\8cÐºÐ¾ Ñ\81ÐµÐ»ÐµÐºÑ\82Ð¾Ñ\80Ð¾Ð² Ñ\81 Ð¸Ð¼ÐµÐ½ÐµÐ¼ %<%c%E%>"
  
  #: objc/objc-act.c:5104
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "found %<%c%s%>"
-msgstr "%J%s %<%c%s%>"
+msgstr "найдено %<%c%s%>"
  
  #: objc/objc-act.c:5113
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "also found %<%c%s%>"
-msgstr "%J%s %<%c%s%>"
+msgstr "также найдено %<%c%s%>"
  
  #. If 'rtype' is NULL_TREE at this point it means that
  #. we have seen no @interface corresponding to that
@@ -60988,19 +64097,19 @@ msgstr "%J%s %<%c%s%>"
  #. class, or cast the receiver to 'id'.  Note that
  #. rtype is an IDENTIFIER_NODE at this point.
  #: objc/objc-act.c:5399 objc/objc-act.c:5533
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "@interface of class %qE not found"
-msgstr "не найдено определение метода для %<%c%s%>"
+msgstr "@interface класса %qE не найден"
  
  #: objc/objc-act.c:5407
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no super class declared in @interface for %qE"
-msgstr "в @interface для %qs нет декларации суперкласса"
+msgstr "в @interface для %qE нет декларации суперкласса"
  
  #: objc/objc-act.c:5458
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "found %<-%E%> instead of %<+%E%> in protocol(s)"
-msgstr "В протоколе найдено %<-%s%> вместо %<+%s%>"
+msgstr "В протоколе найдено %<-%E%> вместо %<+%E%>"
  
  #. We have a type, but it's not an Objective-C type (!).
  #: objc/objc-act.c:5570
@@ -61009,19 +64118,19 @@ msgid "invalid receiver type %qs"
  msgstr "некорректный тип приемника %qs"
  
  #: objc/objc-act.c:5587
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<%c%E%> not found in protocol(s)"
-msgstr "%<%c%s%> не реализовано протоколом(ами)"
+msgstr "%<%c%E%> не найдено в протокол(ах)"
  
  #: objc/objc-act.c:5601
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%qE may not respond to %<%c%E%>"
-msgstr "%qs не может соответствовать %<%c%s%>"
+msgstr "%qE может не соответствовать %<%c%E%>"
  
  #: objc/objc-act.c:5609
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no %<%c%E%> method found"
-msgstr "не найден метод %<%c%s%>"
+msgstr "не найден метод %<%c%E%>"
  
  #: objc/objc-act.c:5616
  #, gcc-internal-format
@@ -61036,12 +64145,12 @@ msgstr "рассматриваются как возвращающие %<id%> и
  #: objc/objc-act.c:5620
  #, gcc-internal-format
  msgid "%<...%> as arguments.)"
-msgstr "аргументы %<...%>.)"
+msgstr "%<...%> как аргументы.)"
  
  #: objc/objc-act.c:5729
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "undeclared selector %qE"
-msgstr "Ð¾Ñ\82Ñ\81Ñ\83Ñ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ñ\81ÐµÐ»ÐµÐºÑ\82Ð¾Ñ\80Ð° %qs"
+msgstr "Ð½ÐµÐ´ÐµÐºÐ»Ð°Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\81ÐµÐ»ÐµÐºÑ\82Ð¾Ñ\80 %qE"
  
  #. Historically, a class method that produced objects (factory
  #. method) would assign `self' to the instance that it
@@ -61053,39 +64162,39 @@ msgstr "отсутствует декларация селектора %qs"
  #. where this is done unknowingly than to support the above
  #. paradigm.
  #: objc/objc-act.c:5753
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "instance variable %qE accessed in class method"
-msgstr "доступ к instance-переменной %qs в методе класса"
+msgstr "доступ к instance-переменной %qE в методе класса"
  
  #: objc/objc-act.c:5983 objc/objc-act.c:6003
  #, gcc-internal-format
  msgid "method %<%c%E%> declared %<@optional%> and %<@required%> at the same time"
-msgstr ""
+msgstr "метод %<%c%E%> декларирован %<@optional%> и %<@required%> одновременно"
  
  #: objc/objc-act.c:5987
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "previous declaration of %<%c%E%> as %<@required%>"
-msgstr "Ð·Ð´ÐµÑ\81Ñ\8c Ð±Ñ\8bÐ»Ð° Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q+D"
+msgstr "Ð¿Ñ\80ÐµÐ´Ñ\88ÐµÑ\81Ñ\82Ð²Ñ\83Ñ\8eÑ\89Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %<%c%E%> ÐºÐ°Ðº %<@required%>"
  
  #: objc/objc-act.c:6007
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "previous declaration of %<%c%E%> as %<@optional%>"
-msgstr "функция %q+D была ранее декларирована как inline"
+msgstr "предшествующая декларация %<%c%E%> как %<@optional%>"
  
  #: objc/objc-act.c:6067
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "duplicate declaration of method %<%c%E%> with conflicting types"
-msgstr "повторная декларация метода %<%c%s%>"
+msgstr "повторная декларация метода %<%c%E%> с конфликтующими типами"
  
  #: objc/objc-act.c:6071
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "previous declaration of %<%c%E%>"
-msgstr "это предыдущая декларация %qs"
+msgstr "предшествующая декларация %<%c%E%>"
  
  #: objc/objc-act.c:6108
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "duplicate interface declaration for category %<%E(%E)%>"
-msgstr "повторная декларация интерфейса для категории %<%s(%s)%>"
+msgstr "повторная декларация интерфейса для категории %<%E(%E)%>"
  
  #: objc/objc-act.c:6196
  #, gcc-internal-format
@@ -61098,41 +64207,41 @@ msgid "instance variable %qs has unknown size"
  msgstr "instance-переменная %qs имеет неизвестный размер"
  
  #: objc/objc-act.c:6228
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "instance variable %qs uses flexible array member"
-msgstr "неправильное использование регулируемого элемента-массива в структуре"
+msgstr "instance-переменная %qs использует член гибкого массива"
  
  #: objc/objc-act.c:6255
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type %qE has no default constructor to call"
-msgstr "тип %qs не имеет подходящего конструктора"
+msgstr "тип %qE не имеет подразумеваемого конструктора для вызова"
  
  #: objc/objc-act.c:6261
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "destructor for %qE shall not be run either"
-msgstr "деструктор для %qs тоже не будет выполнен"
+msgstr "деструктор для %qE тоже не будет выполнен"
  
  #. Vtable pointers are Real Bad(tm), since Obj-C cannot
  #. initialize them.
  #: objc/objc-act.c:6273
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type %qE has virtual member functions"
-msgstr "тип %qs имеет виртуальную функцию-элемент"
+msgstr "тип %qE имеет виртуальную функцию-элемент"
  
  #: objc/objc-act.c:6274
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "illegal aggregate type %qE specified for instance variable %qs"
-msgstr "Ð\97Ð°Ð´Ð°Ð½ Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð»Ð¾Ð¶Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qs Ð´Ð»Ñ\8f переменной %qs"
+msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ð³Ñ\80ÐµÐ³Ð°Ñ\82Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qE Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ð´Ð»Ñ\8f instance переменной %qs"
  
  #: objc/objc-act.c:6284
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type %qE has a user-defined constructor"
-msgstr "тип %qs имеет конструктор, определённый пользователем"
+msgstr "тип %qE имеет конструктор, определённый пользователем"
  
  #: objc/objc-act.c:6286
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type %qE has a user-defined destructor"
-msgstr "тип %qs имеет деструктор, определённый пользователем"
+msgstr "тип %qE имеет деструктор, определённый пользователем"
  
  #: objc/objc-act.c:6290
  #, gcc-internal-format
@@ -61140,196 +64249,196 @@ msgid "C++ constructors and destructors will not be invoked for Objective-C fiel
  msgstr "Для полей Objective-C не будут выполняться конструкторы и деструкторы C++"
  
  #: objc/objc-act.c:6421
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "instance variable %qE is declared private"
-msgstr "instance-переменная %qs объявлена как private"
+msgstr "instance-переменная %qE декларирована как private"
  
  #: objc/objc-act.c:6432
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "instance variable %qE is %s; this will be a hard error in the future"
-msgstr "instance-переменная %qs является %s; в будущем это будет считаться серьёзной ошибкой"
+msgstr "instance-переменная %qE есть %s; в будущем это будет считаться серьёзной ошибкой"
  
  #: objc/objc-act.c:6439
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "instance variable %qE is declared %s"
-msgstr "instance-переменная %qs декларирована как %s"
+msgstr "instance-переменная %qE декларирована как %s"
  
  #: objc/objc-act.c:6550 objc/objc-act.c:6665
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "incomplete implementation of class %qE"
-msgstr "неполная реализаций класса %qs"
+msgstr "неполная реализация класса %qE"
  
  #: objc/objc-act.c:6554 objc/objc-act.c:6669
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "incomplete implementation of category %qE"
-msgstr "неполная реализаций категории %qs"
+msgstr "неполная реализация категории %qE"
  
  #: objc/objc-act.c:6563 objc/objc-act.c:6677
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "method definition for %<%c%E%> not found"
-msgstr "не найдено определение метода для %<%c%s%>"
+msgstr "не найдено определение метода для %<%c%E%>"
  
  #: objc/objc-act.c:6718
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%s %qE does not fully implement the %qE protocol"
-msgstr "%s %qs не является полной реализацией протокола %qs"
+msgstr "%s %qE не является полной реализацией протокола %qE"
  
  #: objc/objc-act.c:6808
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "cannot find interface declaration for %qE, superclass of %qE"
-msgstr "нет декларации интерфейса для %qs, суперкласса  %qs"
+msgstr "нет декларации интерфейса для %qE, суперкласс %qE"
  
  #: objc/objc-act.c:6847
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "reimplementation of class %qE"
-msgstr "повторная реализация класса %qs"
+msgstr "повторная реализация класса %qE"
  
  #: objc/objc-act.c:6880
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conflicting super class name %qE"
-msgstr "конфликтующее имя суперкласса %qs"
+msgstr "конфликтующее имя суперкласса %qE"
  
  #: objc/objc-act.c:6883
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "previous declaration of %qE"
-msgstr "это предыдущая декларация %qs"
+msgstr "предыдущая декларация %qE"
  
  #: objc/objc-act.c:6885
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "previous declaration"
-msgstr "предыдущая декларация %q+D"
+msgstr "предыдущая декларация"
  
  #: objc/objc-act.c:6898 objc/objc-act.c:6900
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "duplicate interface declaration for class %qE"
-msgstr "повторная декларация интерфейса для класса %qs"
+msgstr "повторная декларация интерфейса для класса %qE"
  
  #: objc/objc-act.c:7219 objc/objc-act.c:7415
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "can not find instance variable associated with property"
-msgstr "Ð¿Ñ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ð²Ð°Ñ\8f Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8f instance-Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð¹"
+msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð½Ð°Ð¹Ñ\82Ð¸ instance Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\83Ñ\8e Ð°Ñ\81Ñ\81Ð¾Ñ\86Ð¸Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\83Ñ\8e Ñ\81Ð¾ Ñ\81Ð²Ð¾Ð¹Ñ\81Ñ\82Ð²Ð¾Ð¼"
  
  #. TODO: This should be caught much earlier than this.
  #: objc/objc-act.c:7381
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "invalid setter, it must have one argument"
-msgstr "некорректный аргумент ключа %qs"
+msgstr "некорректный setter, он должен иметь один аргумент"
  
  #: objc/objc-act.c:7545 objc/objc-act.c:7760
  #, gcc-internal-format
  msgid "property %qs already specified in %<@dynamic%>"
-msgstr ""
+msgstr "свойство %qs уже специфицировано в %<@dynamic%>"
  
  #: objc/objc-act.c:7548 objc/objc-act.c:7763
  #, gcc-internal-format
  msgid "property %qs already specified in %<@synthesize%>"
-msgstr ""
+msgstr "свойство %qs уже специфицировано в %<@synthesize%>"
  
  #: objc/objc-act.c:7562 objc/objc-act.c:7777
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no declaration of property %qs found in the interface"
-msgstr "Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ð¾Ðµ Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¸Ðµ %qs Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÐ²Ð°ÐµÑ\82 Ð¾Ð´Ð½Ð¾Ð¸Ð¼ÐµÐ½Ð½Ñ\83Ñ\8e Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\83Ñ\8e"
+msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ñ\81Ð²Ð¾Ð¹Ñ\81Ñ\82Ð²Ð° %qs Ð½Ðµ Ð½Ð°Ð¹Ð´ÐµÐ½Ð° Ð² Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81Ðµ"
  
  #: objc/objc-act.c:7589
  #, gcc-internal-format
  msgid "ivar %qs used by %<@synthesize%> declaration must be an existing ivar"
-msgstr ""
+msgstr "ivar %qs использованная %<@synthesize%> декларацией должна быть существующей ivar"
  
  #: objc/objc-act.c:7610
  #, gcc-internal-format
  msgid "property %qs is using instance variable %qs of incompatible type"
-msgstr ""
+msgstr "свойство %qs использует instance переменную %qs несовместимого типа"
  
  #: objc/objc-act.c:7632
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "'assign' property %qs is using bit-field instance variable %qs"
-msgstr "Задан некорректный сложный тип %qs для переменной %qs"
+msgstr "'assign' свойство %qs использует bit-field instance переменную %qs"
  
  #: objc/objc-act.c:7645
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "'atomic' property %qs is using bit-field instance variable %qs"
-msgstr "Задан некорректный сложный тип %qs для переменной %qs"
+msgstr "'atomic' свойство %qs использует bit-field instance переменную %qs"
  
  #: objc/objc-act.c:7663
  #, gcc-internal-format
  msgid "property %qs is using the same instance variable as property %qs"
-msgstr ""
+msgstr "свойство %qs использует ту же instance переменную что и свойство %qs"
  
  #: objc/objc-act.c:7704
  #, gcc-internal-format
  msgid "%<@synthesize%> is not available in Objective-C 1.0"
-msgstr ""
+msgstr "%<@synthesize%> недоступно в Objective-C 1.0"
  
  #. We can get here only in Objective-C; the Objective-C++ parser
  #. detects the problem while parsing, outputs the error
  #. "misplaced '@synthesize' Objective-C++ construct" and skips
  #. the declaration.
  #: objc/objc-act.c:7715
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<@synthesize%> not in @implementation context"
-msgstr "отсутствует %<@end%> в контексте реализации"
+msgstr "%<@synthesize%> не в @implementation контексте"
  
  #: objc/objc-act.c:7721
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<@synthesize%> can not be used in categories"
-msgstr "%s нельзя использовать в asm в таком контексте"
+msgstr "%<@synthesize%> нельзя использовать в категориях"
  
  #: objc/objc-act.c:7730
  #, gcc-internal-format
  msgid "%<@synthesize%> requires the @interface of the class to be available"
-msgstr ""
+msgstr "%<@synthesize%> требует чтобы @interface класса был доступен"
  
  #: objc/objc-act.c:7813
  #, gcc-internal-format
  msgid "%<@dynamic%> is not available in Objective-C 1.0"
-msgstr ""
+msgstr "%<@dynamic%> недоступно в Objective-C 1.0"
  
  #. We can get here only in Objective-C; the Objective-C++ parser
  #. detects the problem while parsing, outputs the error
  #. "misplaced '@dynamic' Objective-C++ construct" and skips the
  #. declaration.
  #: objc/objc-act.c:7824
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "%<@dynamic%> not in @implementation context"
-msgstr "отсутствует %<@end%> в контексте реализации"
+msgstr "%<@dynamic%> не в @implementation контексте"
  
  #: objc/objc-act.c:7846
  #, gcc-internal-format
  msgid "%<@dynamic%> requires the @interface of the class to be available"
-msgstr ""
+msgstr "%<@dynamic%> требует чтобы @interface класса был доступен"
  
  #: objc/objc-act.c:8044
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "definition of protocol %qE not found"
-msgstr "Ð½Ðµ Ð½Ð°Ð¹Ð´ÐµÐ½Ð¾ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ Ð¼ÐµÑ\82Ð¾Ð´Ð° Ð´Ð»Ñ\8f %<%c%s%>"
+msgstr "Ð½Ðµ Ð½Ð°Ð¹Ð´ÐµÐ½Ð¾ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ Ð¿Ñ\80Ð¾Ñ\82Ð¾ÐºÐ¾Ð»Ð° %qE"
  
  #. It would be nice to use warn_deprecated_use() here, but
  #. we are using TREE_CHAIN (which is supposed to be the
  #. TYPE_STUB_DECL for a TYPE) for something different.
  #: objc/objc-act.c:8075
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "protocol %qE is deprecated"
-msgstr "Ð¸Ð¼Ñ\8f %qs Ð±Ñ\83Ð´ÐµÑ\82 Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¾ Ð² Ð±Ñ\83Ð´Ñ\83Ñ\89Ð¸Ñ\85 Ð²ÐµÑ\80Ñ\81Ð¸Ñ\8fÑ\85"
+msgstr "Ð¿Ñ\80Ð¾Ñ\82Ð¾ÐºÐ¾Ð» %qE Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ»"
  
  #: objc/objc-act.c:8194
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "duplicate declaration for protocol %qE"
-msgstr "повторная декларация протокола %qs"
+msgstr "повторная декларация протокола %qE"
  
  #: objc/objc-act.c:8705
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "conflicting types for %<%c%s%>"
-msgstr "несовместимые типы для %q+D"
+msgstr "несовместимые типы для %<%c%s%>"
  
  #: objc/objc-act.c:8709
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "previous declaration of %<%c%s%>"
-msgstr "это предыдущая декларация %qs"
+msgstr "предыдущая декларация %<%c%s%>"
  
  #: objc/objc-act.c:8809
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no super class declared in interface for %qE"
-msgstr "ни один из родительских классов не декларировал интерфейс для %qs"
+msgstr "суперклассы не декларированы в интерфейсе для %qE"
  
  #: objc/objc-act.c:8836
  #, gcc-internal-format
@@ -61347,407 +64456,2463 @@ msgid "instance variable %qs is declared private"
  msgstr "instance-переменная %qs объявлена как private"
  
  #: objc/objc-act.c:9393
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "local declaration of %qE hides instance variable"
-msgstr "Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ð¾Ðµ Ð¾Ð¿Ð¸Ñ\81Ð°Ð½Ð¸Ðµ %qs Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÐ²Ð°ÐµÑ\82 Ð¾Ð´Ð½Ð¾Ð¸Ð¼ÐµÐ½Ð½Ñ\83Ñ\8e переменную"
+msgstr "Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qE Ñ\81ÐºÑ\80Ñ\8bÐ²Ð°ÐµÑ\82 instance переменную"
  
  #. This can happen if DECL_ARTIFICIAL (*expr_p), but
  #. should be impossible for real properties, which always
  #. have a getter.
  #: objc/objc-act.c:9439
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "no %qs getter found"
-msgstr "не найден метод %<%c%s%>"
+msgstr "не найден %qs getter"
  
  #: objc/objc-act.c:9679
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "fast enumeration is not available in Objective-C 1.0"
-msgstr "эта media-функция имеется только в fr500"
+msgstr "быстрое перечисление недоступно в Objective-C 1.0"
  
  #: objc/objc-act.c:9689
  #, gcc-internal-format
  msgid "iterating variable in fast enumeration is not an object"
-msgstr ""
+msgstr "итерационная переменная в быстром перечислении не есть объект"
  
  #: objc/objc-act.c:9695
  #, gcc-internal-format
  msgid "collection in fast enumeration is not an object"
-msgstr ""
+msgstr "collection в быстром перечислении не есть объект"
  
  #: objc/objc-encoding.c:130
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "type %qT does not have a known size"
-msgstr "тип %q+D имеет неизвестный размер"
+msgstr "тип %qT не имеет известный размер"
  
  #: objc/objc-encoding.c:720
  #, gcc-internal-format
  msgid "unknown type %<%T%> found during Objective-C encoding"
-msgstr ""
+msgstr "неизвестный тип %<%T%> найден при Objective-C кодировании"
  
  #. Do not do any encoding, produce an error and keep going.
  #: objc/objc-encoding.c:803
  #, gcc-internal-format
  msgid "trying to encode non-integer type as a bitfield"
-msgstr ""
+msgstr "попытка кодировать non-integer тип как bitfield"
  
  #: objc/objc-gnu-runtime-abi-01.c:131
  #, gcc-internal-format
  msgid "%<-fobjc-gc%> is ignored for %<-fgnu-runtime%>"
-msgstr ""
+msgstr "%<-fobjc-gc%> игнорируется для %<-fgnu-runtime%>"
  
  #: objc/objc-gnu-runtime-abi-01.c:139
  #, gcc-internal-format
  msgid "%<-fobjc-sjlj-exceptions%> is ignored for %<-fgnu-runtime%>"
-msgstr ""
+msgstr "%<-fobjc-sjlj-exceptions%> игнорируется для %<-fgnu-runtime%>"
  
  #: objc/objc-gnu-runtime-abi-01.c:2168 objc/objc-next-runtime-abi-01.c:2815
  #: objc/objc-next-runtime-abi-02.c:3587
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "non-objective-c type '%T' cannot be caught"
-msgstr "недопустимая декларация не объектного элемента %qs как %<mutable%>"
+msgstr "non-objective-c тип '%T' не может быть перехвачен"
  
  #: objc/objc-next-runtime-abi-01.c:150
  #, gcc-internal-format
  msgid "%<-fobjc-sjlj-exceptions%> is the only supported exceptions system for %<-fnext-runtime%> with %<-fobjc-abi-version%> < 2"
-msgstr ""
+msgstr "%<-fobjc-sjlj-exceptions%> единственная поддерживаемая система исключений для %<-fnext-runtime%> с %<-fobjc-abi-version%> < 2"
  
  #: objc/objc-next-runtime-abi-02.c:242
  #, gcc-internal-format
  msgid "%<-fobjc-sjlj-exceptions%> is ignored for %<-fnext-runtime%> when %<-fobjc-abi-version%> >= 2"
-msgstr ""
+msgstr "%<-fobjc-sjlj-exceptions%> игнорируется для %<-fnext-runtime%> если %<-fobjc-abi-version%> >= 2"
  
  #: objc/objc-runtime-shared-support.c:425
-#, fuzzy, gcc-internal-format
+#, gcc-internal-format
  msgid "creating selector for nonexistent method %qE"
-msgstr "%Hсоздаётся селектор для несуществующего метода %qE"
+msgstr "создается селектор для несуществующего метода %qE"
  
-#, fuzzy
-#~ msgid "%s:%d:%d: Invalid state file; %s"
-#~ msgstr "%s: некорректное имя файла: %s\n"
+#~ msgid "expected %<;%> at end of input"
+#~ msgstr "ожидалось %<;%> в конце входного потока"
  
-#, fuzzy
-#~ msgid "%s:%d: Invalid state file; %s"
-#~ msgstr "%s: некорректное имя файла: %s\n"
+#~ msgid "expected %<;%> before %s'%c'"
+#~ msgstr "ожидалось %<;%> перед %s'%c'"
  
-#~ msgid "%s:%d:%d: Invalid state file; "
-#~ msgstr "%s:%d:%d: недопустимый файл состояния; "
+#~ msgid "expected %<;%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<;%> перед %s'\\x%x'"
  
-#, fuzzy
-#~ msgid "%s:%d: Invalid state file; "
-#~ msgstr "%s: некорректное имя файла: %s\n"
+#~ msgid "expected %<;%> before string constant"
+#~ msgstr "ожидалось %<;%> перед строковой константой"
  
-#, fuzzy
-#~ msgid "Unexpected type in write_state_scalar_type"
-#~ msgstr "некорректный тип базы в cris_print_base"
+#~ msgid "expected %<;%> before numeric constant"
+#~ msgstr "ожидалось %<;%> перед числовой константой"
  
-#, fuzzy
-#~ msgid "Unexpected type in write_state_string_type"
-#~ msgstr "некорректный тип базы в cris_print_base"
+#~ msgid "expected %<;%> before %<#pragma%>"
+#~ msgstr "ожидалось %<;%> перед %<#pragma%>"
  
-#, fuzzy
-#~ msgid "failed to write state trailer [%s]"
-#~ msgstr "не удалось получить код возврата"
+#~ msgid "expected %<;%> before end of line"
+#~ msgstr "ожидалось %<;%> перед концом строки"
  
-#, fuzzy
-#~ msgid "Failed to open file %s for writing state: %s"
-#~ msgstr "%s: ошибка открытия файла '%s' на чтение: %s\n"
+#~ msgid "expected %<;%> before %<decltype%>"
+#~ msgstr "ожидалось %<;%> перед %<decltype%>"
  
-#, fuzzy
-#~ msgid "output error when writing state file %s [%s]"
-#~ msgstr "%s: ошибка записи файла '%s': %s\n"
+#~ msgid "expected %<;%> before %qs token"
+#~ msgstr "ожидалось %<;%> перед лексемой %qs"
  
-#, fuzzy
-#~ msgid "failed to close state file %s [%s]"
-#~ msgstr "%s: ошибка закрытия выходного файла %s\n"
+#~ msgid "expected %<(%> at end of input"
+#~ msgstr "ожидалась %<(%> в конце входного потока"
  
-#~ msgid "failed to rename %s to state file %s [%s]"
-#~ msgstr "Ð½Ðµ Ñ\83Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¿ÐµÑ\80ÐµÐ¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ñ\82Ñ\8c %s Ð² Ñ\84Ð°Ð¹Ð» Ñ\81Ð¾Ñ\81Ñ\82Ð¾Ñ\8fÐ½Ð¸Ñ\8f %s [%s]"
+#~ msgid "expected %<(%> before %s'%c'"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<(%> Ð¿ÐµÑ\80ÐµÐ´ %s'%c'"
  
-#, fuzzy
-#~ msgid "Failed to open state file %s for reading [%s]"
-#~ msgstr "%s: ошибка открытия файла '%s' на чтение: %s\n"
+#~ msgid "expected %<(%> before %s'\\x%x'"
+#~ msgstr "ожидалась %<(%> перед %s'\\x%x'"
  
-#, fuzzy
-#~ msgid "failed to close read state file %s [%s]"
-#~ msgstr "%s: ошибка закрытия выходного файла %s\n"
+#~ msgid "expected %<(%> before string constant"
+#~ msgstr "ожидалась %<(%> перед строковой константой"
  
-#~ msgid "pex_init failed"
-#~ msgstr "ошибка в pex_init"
+#~ msgid "expected %<(%> before numeric constant"
+#~ msgstr "ожидалась %<(%> перед числовой константой"
  
-#~ msgid "can't get program status"
-#~ msgstr "Ð½Ðµ Ñ\83Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c Ð¿Ð¾Ð»Ñ\83Ñ\87Ð¸Ñ\82Ñ\8c Ñ\81Ð¾Ñ\81Ñ\82Ð¾Ñ\8fÐ½Ð¸Ðµ Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\8b"
+#~ msgid "expected %<(%> before %qE"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<(%> Ð¿ÐµÑ\80ÐµÐ´ %qE"
  
-#, fuzzy
-#~ msgid "%s terminated with signal %d [%s], core dumped"
-#~ msgstr "%s завершилась по сигналу %d [%s]%s"
+#~ msgid "expected %<(%> before %<#pragma%>"
+#~ msgstr "ожидалась %<(%> перед %<#pragma%>"
  
-#, fuzzy
-#~ msgid "%s terminated with signal %d [%s]"
-#~ msgstr "%s завершилась по сигналу %d [%s]%s"
+#~ msgid "expected %<(%> before end of line"
+#~ msgstr "ожидалась %<(%> перед концом строки"
  
-#, fuzzy
-#~ msgid "could not write to temporary file %s"
-#~ msgstr "не удалось записать во временный файл ответа %s"
+#~ msgid "expected %<(%> before %<decltype%>"
+#~ msgstr "ожидалась %<(%> перед %<decltype%>"
  
-#~ msgid "fopen: %s"
-#~ msgstr "fopen: %s"
+#~ msgid "expected %<(%> before %qs token"
+#~ msgstr "ожидалась %<(%> перед лексемой %qs"
  
-#~ msgid "enabled by default"
-#~ msgstr "Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð²ÐºÐ»Ñ\8eÑ\87ÐµÐ½а"
+#~ msgid "expected %<,%> at end of input"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<,%> Ð² ÐºÐ¾Ð½Ñ\86Ðµ Ð²Ñ\85Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ð¿Ð¾Ñ\82Ð¾Ðºа"
  
-#~ msgid "out of memory"
-#~ msgstr "Ð½ÐµÐ´Ð¾Ñ\81Ñ\82Ð°Ñ\82Ð¾Ñ\87Ð½Ð¾ Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸"
+#~ msgid "expected %<,%> before %s'%c'"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<,%> Ð¿ÐµÑ\80ÐµÐ´ %s'%c'"
  
-#~ msgid "optimizing for size and code size would grow"
-#~ msgstr "размер кода увеличится при включённой оптимизации по размеру"
+#~ msgid "expected %<,%> before %s'\\x%x'"
+#~ msgstr "ожидалась %<,%> перед %s'\\x%x'"
  
-#, fuzzy
-#~ msgid "Allow new data races on packed data loads to be introduced"
-#~ msgstr "Комбинировать условные переходы с другими инструкциями"
+#~ msgid "expected %<,%> before string constant"
+#~ msgstr "ожидалась %<,%> перед строковой константой"
  
-#, fuzzy
-#~ msgid "Bad address, not (reg+disp):"
-#~ msgstr "некорректный адрес, не (reg+disp)"
+#~ msgid "expected %<,%> before numeric constant"
+#~ msgstr "ожидалась %<,%> перед числовой константой"
  
-#, fuzzy
-#~ msgid "-mvsx used with little endian code"
-#~ msgstr "Генерировать код для обратного порядка байт (little endian)"
+#~ msgid "expected %<,%> before %qE"
+#~ msgstr "ожидалась %<,%> перед %qE"
  
-#~ msgid "invalid %%S value"
-#~ msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° %%S"
+#~ msgid "expected %<,%> before %<#pragma%>"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<,%> Ð¿ÐµÑ\80ÐµÐ´ %<#pragma%>"
  
-#~ msgid "invalid operand for code: '%c'"
-#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð´Ð»Ñ\8f ÐºÐ¾Ð´Ð° '%c'"
+#~ msgid "expected %<,%> before end of line"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<,%> Ð¿ÐµÑ\80ÐµÐ´ ÐºÐ¾Ð½Ñ\86Ð¾Ð¼ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸"
  
-#~ msgid "long long constant not a valid immediate operand"
-#~ msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° long long Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¼ Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐ¼ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð¼"
+#~ msgid "expected %<,%> before %<decltype%>"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<,%> Ð¿ÐµÑ\80ÐµÐ´ %<decltype%>"
  
-#, fuzzy
-#~ msgid "Use little-endian format for unformatted files"
-#~ msgstr "Использовать обратный порядок байт для данных"
+#~ msgid "expected %<,%> before %qs token"
+#~ msgstr "ожидалась %<,%> перед лексемой %qs"
  
-#, fuzzy
-#~ msgid "Deprecated in favor of -Wc++11-compat"
-#~ msgstr "Не рекомендуется; используйте -std=c99"
+#~ msgid "expected %<)%> at end of input"
+#~ msgstr "ожидалась %<)%> в конце входного потока"
  
-#~ msgid "Add mudflap bounds-checking instrumentation for single-threaded program"
-#~ msgstr "Ð\98Ð½Ñ\81Ñ\82Ñ\80Ñ\83Ð¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¾Ð´Ð½Ð¾Ð¿Ð¾Ñ\82Ð¾Ñ\87Ð½Ñ\83Ñ\8e Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\83 Ð´Ð»Ñ\8f Ð¿Ñ\80Ð¾Ð²ÐµÑ\80ÐºÐ¸ Ð²Ñ\8bÑ\85Ð¾Ð´Ð° Ð·Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ñ\8b Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾Ð² Ð¿Ñ\80Ð¸ Ð¿Ð¾Ð¼Ð¾Ñ\89Ð¸ mudflap"
+#~ msgid "expected %<)%> before %s'%c'"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<)%> Ð¿ÐµÑ\80ÐµÐ´ %s'%c'"
  
-#~ msgid "Add mudflap bounds-checking instrumentation for multi-threaded program"
-#~ msgstr "Ð\98Ð½Ñ\81Ñ\82Ñ\80Ñ\83Ð¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¼Ð½Ð¾Ð³Ð¾Ð¿Ð¾Ñ\82Ð¾Ñ\87Ð½Ñ\83Ñ\8e Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ñ\83 Ð´Ð»Ñ\8f Ð¿Ñ\80Ð¾Ð²ÐµÑ\80ÐºÐ¸ Ð²Ñ\8bÑ\85Ð¾Ð´Ð° Ð·Ð° Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ñ\8b Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾Ð² Ð¿Ñ\80Ð¸ Ð¿Ð¾Ð¼Ð¾Ñ\89Ð¸ mudflap"
+#~ msgid "expected %<)%> before %s'\\x%x'"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<)%> Ð¿ÐµÑ\80ÐµÐ´ %s'\\x%x'"
  
-#~ msgid "Ignore read operations when inserting mudflap instrumentation"
-#~ msgstr "Ð\98Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f Ð¿Ñ\80Ð¸ Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83Ð¼ÐµÐ½Ñ\82Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ð´Ð»Ñ\8f mudflap"
+#~ msgid "expected %<)%> before string constant"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<)%> Ð¿ÐµÑ\80ÐµÐ´ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾Ð²Ð¾Ð¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
  
-#~ msgid "Use the same size for double as for float"
-#~ msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð´Ð»Ñ\8f double Ñ\80Ð°Ð·Ð¼ÐµÑ\80 float"
+#~ msgid "expected %<)%> before numeric constant"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<)%> Ð¿ÐµÑ\80ÐµÐ´ Ñ\87Ð¸Ñ\81Ð»Ð¾Ð²Ð¾Ð¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
  
-#, fuzzy
-#~ msgid "Conform to the ISO 2011 C++ standard (experimental and incomplete support)"
-#~ msgstr "Компилировать в соответствии с ISO 1990 C с дополнениями от 1994"
+#~ msgid "expected %<)%> before %qE"
+#~ msgstr "ожидалась %<)%> перед %qE"
  
-#, fuzzy
-#~ msgid "Conform to the ISO 2011 C standard (experimental and incomplete support)"
-#~ msgstr "Компилировать в соответствии с ISO 1990 C с дополнениями от 1994"
+#~ msgid "expected %<)%> before %<#pragma%>"
+#~ msgstr "ожидалась %<)%> перед %<#pragma%>"
  
-#, fuzzy
-#~ msgid "Conform to the ISO 2011 C++ standard with GNU extensions (experimental and incomplete support)"
-#~ msgstr "Компилировать в соответствии с ISO 1998 C++ с расширениями GNU"
+#~ msgid "expected %<)%> before end of line"
+#~ msgstr "ожидалась %<)%> перед концом строки"
  
-#, fuzzy
-#~ msgid "Conform to the ISO 2011 C standard with GNU extensions (experimental and incomplete support)"
-#~ msgstr "Компилировать в соответствии с ISO 1998 C++ с расширениями GNU"
+#~ msgid "expected %<)%> before %<decltype%>"
+#~ msgstr "ожидалась %<)%> перед %<decltype%>"
  
-#, fuzzy
-#~ msgid "Enable debug output to be generated."
-#~ msgstr "Включить отладочную выдачу"
+#~ msgid "expected %<)%> before %qs token"
+#~ msgstr "ожидалась %<)%> перед лексемой %qs"
  
-#, fuzzy
-#~ msgid "Disable bcnz instruction"
-#~ msgstr "Использовать команды AltiVec"
+#~ msgid "expected %<]%> at end of input"
+#~ msgstr "ожидалась %<]%> в конце входного потока"
  
-#~ msgid "Ignored (obsolete)"
-#~ msgstr "Ð\98Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ñ\83ÐµÑ\82Ñ\81Ñ\8f (Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð°Ñ\8f)"
+#~ msgid "expected %<]%> before %s'%c'"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<]%> Ð¿ÐµÑ\80ÐµÐ´ %s'%c'"
  
-#~ msgid "Generate code for huge switch statements"
-#~ msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c ÐºÐ¾Ð´ Ð´Ð»Ñ\8f Ð±Ð¾Ð»Ñ\8cÑ\88Ð¸Ñ\85 Ð¿ÐµÑ\80ÐµÐºÐ»Ñ\8eÑ\87Ð°Ñ\82ÐµÐ»ÐµÐ¹"
+#~ msgid "expected %<]%> before %s'\\x%x'"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<]%> Ð¿ÐµÑ\80ÐµÐ´ %s'\\x%x'"
  
-#~ msgid "Put jumps in call delay slots"
-#~ msgstr "Ð\9fÐ¾Ð¼ÐµÑ\89Ð°Ñ\82Ñ\8c Ð¿ÐµÑ\80ÐµÑ\85Ð¾Ð´Ñ\8b Ð² Ð³Ð½ÐµÐ·Ð´Ð° Ð·Ð°Ð´ÐµÑ\80Ð¶ÐºÐ¸ Ð²Ñ\8bÐ·Ð¾Ð²Ð¾Ð²"
+#~ msgid "expected %<]%> before string constant"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<]%> Ð¿ÐµÑ\80ÐµÐ´ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¾Ð²Ð¾Ð¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
  
-#~ msgid "mvcle use"
-#~ msgstr "mvcle use"
+#~ msgid "expected %<]%> before numeric constant"
+#~ msgstr "ожидалась %<]%> перед числовой константой"
  
-#, fuzzy
-#~ msgid "Assume big endian bytes, little endian words.  This option is deprecated."
-#~ msgstr "Считать, что байты имеют прямой порядок бит, а слова - обратный порядок байт"
+#~ msgid "expected %<]%> before %qE"
+#~ msgstr "ожидалась %<]%> перед %qE"
  
-#~ msgid "Generate floating-point multiply-add instructions"
-#~ msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ðµ ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ñ\83Ð¼Ð½Ð¾Ð¶ÐµÐ½Ð¸Ñ\8f Ñ\81 Ð½Ð°ÐºÐ¾Ð¿Ð»ÐµÐ½Ð¸ÐµÐ¼"
+#~ msgid "expected %<]%> before %<#pragma%>"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<]%> Ð¿ÐµÑ\80ÐµÐ´ %<#pragma%>"
  
-#, fuzzy
-#~ msgid "Enable Loop Blocking transformation"
-#~ msgstr "Включить линейные трансформации циклов на древовидном представлении"
+#~ msgid "expected %<]%> before end of line"
+#~ msgstr "ожидалась %<]%> перед концом строки"
  
-#, fuzzy
-#~ msgid "Disable partioning and streaming"
-#~ msgstr "Не использовать индексную адресацию"
+#~ msgid "expected %<]%> before %<decltype%>"
+#~ msgstr "ожидалась %<]%> перед %<decltype%>"
  
-#~ msgid "Do the full register move optimization pass"
-#~ msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð»Ð½Ñ\83Ñ\8e Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿ÐµÑ\80ÐµÐ¼ÐµÑ\89ÐµÐ½Ð¸Ñ\8f Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²"
+#~ msgid "expected %<]%> before %qs token"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<]%> Ð¿ÐµÑ\80ÐµÐ´ Ð»ÐµÐºÑ\81ÐµÐ¼Ð¾Ð¹ %qs"
  
-#~ msgid "Enables a register move optimization"
-#~ msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8e Ð¿ÐµÑ\80ÐµÐ¼ÐµÑ\89ÐµÐ½Ð¸Ñ\8f Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ð¾Ð²"
+#~ msgid "expected %<;%>, %<,%> or %<)%> at end of input"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<;%>, %<,%> Ð¸Ð»Ð¸ %<)%> Ð² ÐºÐ¾Ð½Ñ\86Ðµ Ð²Ñ\85Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ð¿Ð¾Ñ\82Ð¾ÐºÐ°"
  
-#~ msgid "Replace SSA temporaries with better names in copies"
-#~ msgstr "Ð\9fÐµÑ\80ÐµÐ¸Ð¼ÐµÐ½Ð¾Ð²Ñ\8bÐ²Ð°Ñ\82Ñ\8c Ð²Ñ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÐµ SSA-Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÐµ Ð¿Ñ\80Ð¸ ÐºÐ¾Ð¿Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ð¸ Ð´Ð»Ñ\8f Ð±Ð¾Ð»ÐµÐµ Ð±Ð»Ð¸Ð·ÐºÐ¾Ð³Ð¾ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¸Ñ\8f Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ð½Ñ\8bÐ¼ Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÐ¼"
+#~ msgid "expected %<;%>, %<,%> or %<)%> before %s'%c'"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<;%>, %<,%> Ð¸Ð»Ð¸ %<)%> Ð¿ÐµÑ\80ÐµÐ´ %s'%c'"
  
-#, fuzzy
-#~ msgid "-ftree-vectorizer-verbose=<number>\tThis switch is deprecated. Use -fopt-info instead."
-#~ msgstr "Установить степень подробности сообщений при векторизации циклов"
+#~ msgid "expected %<;%>, %<,%> or %<)%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<;%>, %<,%> или %<)%> перед %s'\\x%x'"
  
-#, fuzzy
-#~ msgid "Enable use of cost model in vectorization"
-#~ msgstr "Использовать команду DB"
+#~ msgid "expected %<;%>, %<,%> or %<)%> before string constant"
+#~ msgstr "ожидалось %<;%>, %<,%> или %<)%> перед строковой константой"
  
-#~ msgid "Enable loop versioning when doing loop vectorization on trees"
-#~ msgstr "Ð¡Ð¾Ð·Ð´Ð°Ð²Ð°Ñ\82Ñ\8c Ð²ÐµÑ\80Ñ\81Ð¸Ð¸ Ñ\86Ð¸ÐºÐ»Ð¾Ð² Ð¿Ñ\80Ð¸ Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð¸Ð·Ð°Ñ\86Ð¸Ð¸"
+#~ msgid "expected %<;%>, %<,%> or %<)%> before numeric constant"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<;%>, %<,%> Ð¸Ð»Ð¸ %<)%> Ð¿ÐµÑ\80ÐµÐ´ Ñ\87Ð¸Ñ\81Ð»Ð¾Ð²Ð¾Ð¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹"
  
-#, fuzzy
-#~ msgid "expected integer or boolean type"
-#~ msgstr "ожидалось выражение"
+#~ msgid "expected %<;%>, %<,%> or %<)%> before %qE"
+#~ msgstr "ожидалось %<;%>, %<,%> или %<)%> перед %qE"
  
-#, fuzzy
-#~ msgid "invalid operand for unary %<&%>"
-#~ msgstr "неверные операнды бинарной операции %s"
+#~ msgid "expected %<;%>, %<,%> or %<)%> before %<#pragma%>"
+#~ msgstr "ожидалось %<;%>, %<,%> или %<)%> перед %<#pragma%>"
  
-#~ msgid "invalid argument to %<__builtin_return_address%>"
-#~ msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %<__builtin_return_address%>"
+#~ msgid "expected %<;%>, %<,%> or %<)%> before end of line"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<;%>, %<,%> Ð¸Ð»Ð¸ %<)%> Ð¿ÐµÑ\80ÐµÐ´ ÐºÐ¾Ð½Ñ\86Ð¾Ð¼ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸"
  
-#~ msgid "unsupported argument to %<__builtin_frame_address%>"
-#~ msgstr "Ð½ÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %<__builtin_frame_address%>"
+#~ msgid "expected %<;%>, %<,%> or %<)%> before %<decltype%>"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<;%>, %<,%> Ð¸Ð»Ð¸ %<)%> Ð¿ÐµÑ\80ÐµÐ´ %<decltype%>"
  
-#~ msgid "unsupported argument to %<__builtin_return_address%>"
-#~ msgstr "Ð½ÐµÐ¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÐ¼Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %<__builtin_return_address%>"
+#~ msgid "expected %<;%>, %<,%> or %<)%> before %qs token"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<;%>, %<,%> Ð¸Ð»Ð¸ %<)%> Ð¿ÐµÑ\80ÐµÐ´ Ð»ÐµÐºÑ\81ÐµÐ¼Ð¾Ð¹ %qs"
  
-#~ msgid "insn %d inside basic block %d but block_for_insn is NULL"
-#~ msgstr "RTL-инструкция %d - внутри блока %d, а block_for_insn=NULL"
+#~ msgid "expected %<}%> at end of input"
+#~ msgstr "ожидалась %<}%> в конце входного потока"
  
-#~ msgid "insn %d inside basic block %d but block_for_insn is %i"
-#~ msgstr "RTL-инструкция %d - внутри блока %d, а block_for_insn=%i"
+#~ msgid "expected %<}%> before %s'%c'"
+#~ msgstr "ожидалась %<}%> перед %s'%c'"
  
-#, fuzzy
-#~ msgid "mis-aligned access used for structure member"
-#~ msgstr "класс хранения в декларации поля структуры %qs"
+#~ msgid "expected %<}%> before %s'\\x%x'"
+#~ msgstr "ожидалась %<}%> перед %s'\\x%x'"
  
-#, fuzzy
-#~ msgid "mis-aligned access used for structure bitfield"
-#~ msgstr "класс хранения в декларации поля структуры %qs"
+#~ msgid "expected %<}%> before string constant"
+#~ msgstr "ожидалась %<}%> перед строковой константой"
  
-#, fuzzy
-#~ msgid "local frame unavailable (naked function?)"
-#~ msgstr "глобальная регистровая переменная %qD использована во вложенной функции"
+#~ msgid "expected %<}%> before numeric constant"
+#~ msgstr "ожидалась %<}%> перед числовой константой"
  
-#, fuzzy
-#~ msgid "type of field declared here"
-#~ msgstr "  имя `%#D' объявлено здесь"
+#~ msgid "expected %<}%> before %qE"
+#~ msgstr "ожидалась %<}%> перед %qE"
  
-#, fuzzy
-#~ msgid "type of mismatching field declared here"
-#~ msgstr "несоответствие типов в условном выражении"
+#~ msgid "expected %<}%> before %<#pragma%>"
+#~ msgstr "ожидалась %<}%> перед %<#pragma%>"
  
-#~ msgid "unrecognized command line option \"%s\""
-#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ ÐºÐ»Ñ\8eÑ\87 \"%s\""
+#~ msgid "expected %<}%> before end of line"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<}%> Ð¿ÐµÑ\80ÐµÐ´ ÐºÐ¾Ð½Ñ\86Ð¾Ð¼ Ñ\81Ñ\82Ñ\80Ð¾ÐºÐ¸"
  
-#, fuzzy
-#~ msgid "corrupted profile info: edge count exceeds maximal count"
-#~ msgstr "испорчены данные профилирования: дуга из %i в %i превышает максимальный счётчик"
+#~ msgid "expected %<}%> before %<decltype%>"
+#~ msgstr "ожидалась %<}%> перед %<decltype%>"
  
-#~ msgid "corrupted profile info: run_max * runs < sum_max"
-#~ msgstr "Ð¸Ñ\81Ð¿Ð¾Ñ\80Ñ\87ÐµÐ½Ñ\8b Ð´Ð°Ð½Ð½Ñ\8bÐµ Ð¿Ñ\80Ð¾Ñ\84Ð¸Ð»Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f: run_max * runs < sum_max"
+#~ msgid "expected %<}%> before %qs token"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<}%> Ð¿ÐµÑ\80ÐµÐ´ Ð»ÐµÐºÑ\81ÐµÐ¼Ð¾Ð¹ %qs"
  
-#~ msgid "try reducing the number of local variables"
-#~ msgstr "Ð¿Ð¾Ð¿Ñ\80Ð¾Ð±Ñ\83Ð¹Ñ\82Ðµ Ñ\83Ð¼ÐµÐ½Ñ\8cÑ\88Ð¸Ñ\82Ñ\8c Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+#~ msgid "expected %<{%> at end of input"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c %<{%> Ð² ÐºÐ¾Ð½Ñ\86Ðµ Ð²Ñ\85Ð¾Ð´Ð½Ð¾Ð³Ð¾ Ð¿Ð¾Ñ\82Ð¾ÐºÐ°"
  
-#, fuzzy
-#~ msgid "node not found in symtab decl hashtable"
-#~ msgstr "не найден узел в хеш-таблице DECL_ASSEMBLER_NAME"
+#~ msgid "expected %<{%> before %s'%c'"
+#~ msgstr "ожидалась %<{%> перед %s'%c'"
  
-#, fuzzy
-#~ msgid "unwind tables currently require a frame pointer for correctness"
-#~ msgstr "для корректного формирования таблица раскрутки стека требуется указатель кадра"
+#~ msgid "expected %<{%> before %s'\\x%x'"
+#~ msgstr "ожидалась %<{%> перед %s'\\x%x'"
  
-#~ msgid "mudflap checking not yet implemented for ARRAY_RANGE_REF"
-#~ msgstr "mudflap-проверки еще для ARRAY_RANGE_REF еще не реализованы"
+#~ msgid "expected %<{%> before string constant"
+#~ msgstr "ожидалась %<{%> перед строковой константой"
  
-#, fuzzy
-#~ msgid "mudflap cannot track %qE in stub function"
-#~ msgstr "mudflap не может отслеживать %qs в stub-функциях"
+#~ msgid "expected %<{%> before numeric constant"
+#~ msgstr "ожидалась %<{%> перед числовой константой"
  
-#, fuzzy
-#~ msgid "mudflap cannot track unknown size extern %qE"
-#~ msgstr "mudflap не может отслеживать внешние %qs неизвестного размера"
+#~ msgid "expected %<{%> before %qE"
+#~ msgstr "ожидалась %<{%> перед %qE"
  
-#~ msgid "mudflap: this language is not supported"
-#~ msgstr "mudflap: этот язык не поддерживается"
+#~ msgid "expected %<{%> before %<#pragma%>"
+#~ msgstr "ожидалась %<{%> перед %<#pragma%>"
  
-#, fuzzy
-#~ msgid "%qD is deprecated (declared at %s:%d): %s"
-#~ msgstr "устаревшая функция, переменная или тип %qs (декларация в %s:%d)"
+#~ msgid "expected %<{%> before end of line"
+#~ msgstr "ожидалась %<{%> перед концом строки"
  
-#, fuzzy
-#~ msgid "%qD is deprecated (declared at %s:%d)"
-#~ msgstr "устаревшая функция, переменная или тип %qs (декларация в %s:%d)"
+#~ msgid "expected %<{%> before %<decltype%>"
+#~ msgstr "ожидалась %<{%> перед %<decltype%>"
  
-#, fuzzy
-#~ msgid "%qE is deprecated (declared at %s:%d): %s"
-#~ msgstr "устаревшая функция, переменная или тип %qs (декларация в %s:%d)"
+#~ msgid "expected %<{%> before %qs token"
+#~ msgstr "ожидалась %<{%> перед лексемой %qs"
  
-#, fuzzy
-#~ msgid "%qE is deprecated (declared at %s:%d)"
-#~ msgstr "устаревшая функция, переменная или тип %qs (декларация в %s:%d)"
+#~ msgid "expected %<:%> at end of input"
+#~ msgstr "ожидалось %<:%> в конце входного потока"
  
-#, fuzzy
-#~ msgid "type is deprecated (declared at %s:%d): %s"
-#~ msgstr "поддержка данного типа будет исключена в будущих версиях (декларация в %s:%d)"
+#~ msgid "expected %<:%> before %s'%c'"
+#~ msgstr "ожидалось %<:%> перед %s'%c'"
  
-#~ msgid "type is deprecated (declared at %s:%d)"
-#~ msgstr "Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶ÐºÐ° Ð´Ð°Ð½Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° Ð±Ñ\83Ð´ÐµÑ\82 Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð° Ð² Ð±Ñ\83Ð´Ñ\83Ñ\89Ð¸Ñ\85 Ð²ÐµÑ\80Ñ\81Ð¸Ñ\8fÑ\85 (Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð² %s:%d)"
+#~ msgid "expected %<:%> before %s'\\x%x'"
+#~ msgstr "Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<:%> Ð¿ÐµÑ\80ÐµÐ´ %s'\\x%x'"
  
-#, fuzzy
-#~ msgid "correcting inconsistent value profile: %s profiler overall count (%d) does not match BB count (%d)"
-#~ msgstr "%HИспорчен профиль значений: общий счётчик профиля %s (%d) не соответствует BB count (%d)"
+#~ msgid "expected %<:%> before string constant"
+#~ msgstr "ожидалось %<:%> перед строковой константой"
  
-#, fuzzy
-#~ msgid "transaction_wrap argument is not a function"
-#~ msgstr "аргумент атрибута cleanup - не функция"
+#~ msgid "expected %<:%> before %qE"
+#~ msgstr "ожидалось %<:%> перед %qE"
  
-#, fuzzy
-#~ msgid "incompatible type for argument %d, expected %<const int%>"
-#~ msgstr "несовместимый тип аргумента %d функции %qE"
+#~ msgid "expected %<:%> before %<#pragma%>"
+#~ msgstr "ожидалось %<:%> перед %<#pragma%>"
  
-#, fuzzy
-#~ msgid "function profiling"
-#~ msgstr "Включить профилирование функций"
+#~ msgid "expected %<:%> before end of line"
+#~ msgstr "ожидалось %<:%> перед концом строки"
  
-#, fuzzy
-#~ msgid "%qs and floating point or vector arguments"
-#~ msgstr "Использовать команды плавающей арифметики формата paired-single (над парами значений одинарной точности)"
+#~ msgid "expected %<:%> before %<decltype%>"
+#~ msgstr "ожидалось %<:%> перед %<decltype%>"
  
-#, fuzzy
-#~ msgid "unwind tables currently require either a frame pointer or %saccumulate-outgoing-args%s for correctness"
-#~ msgstr "для корректной поддержки таблиц раскрутки стека требуется либо указатель кадра, либо -maccumulate-outgoing-args"
+#~ msgid "expected %<:%> before %qs token"
+#~ msgstr "ожидалось %<:%> перед лексемой %qs"
+
+#~ msgid "expected %<:%> or %<)%>"
+#~ msgstr "ожидалось %<:%>"
+
+#~ msgid "expected %<:%> or %<)%> at end of input"
+#~ msgstr "ожидалось %<:%> или %<)%> в конце входного потока"
+
+#~ msgid "expected %<:%> or %<)%> before %s'%c'"
+#~ msgstr "ожидалось %<:%> или %<)%> перед %s'%c'"
+
+#~ msgid "expected %<:%> or %<)%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<:%> или %<)%> перед %s'\\x%x'"
+
+#~ msgid "expected %<:%> or %<)%> before string constant"
+#~ msgstr "ожидалось %<:%> или %<)%> перед строковой константой"
+
+#~ msgid "expected %<:%> or %<)%> before numeric constant"
+#~ msgstr "ожидалось %<:%> или %<)%> перед числовой константой"
+
+#~ msgid "expected %<:%> or %<)%> before %qE"
+#~ msgstr "ожидалось %<:%> или %<)%> перед %qE"
+
+#~ msgid "expected %<:%> or %<)%> before %<#pragma%>"
+#~ msgstr "ожидалось %<:%> или %<)%> перед %<#pragma%>"
+
+#~ msgid "expected %<:%> or %<)%> before end of line"
+#~ msgstr "ожидалось %<:%> или %<)%> перед концом строки"
+
+#~ msgid "expected %<:%> or %<)%> before %<decltype%>"
+#~ msgstr "ожидалось %<:%> или %<)%> перед %<decltype%>"
+
+#~ msgid "expected %<:%> or %<)%> before %qs token"
+#~ msgstr "ожидалось %<:%> или %<)%> перед лексемой %qs"
+
+#~ msgid "expected %<while%> at end of input"
+#~ msgstr "ожидалось %<while%> в конце входного потока"
+
+#~ msgid "expected %<while%> before %s'%c'"
+#~ msgstr "ожидалось %<while%> перед %s'%c'"
+
+#~ msgid "expected %<while%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<while%> перед %s'\\x%x'"
+
+#~ msgid "expected %<while%> before string constant"
+#~ msgstr "ожидалось %<while%> перед строковой константой"
+
+#~ msgid "expected %<while%> before numeric constant"
+#~ msgstr "ожидалось %<while%> перед числовой константой"
+
+#~ msgid "expected %<while%> before %qE"
+#~ msgstr "ожидалось %<while%> перед %qE"
+
+#~ msgid "expected %<while%> before %<#pragma%>"
+#~ msgstr "ожидалось %<while%> перед %<#pragma%>"
+
+#~ msgid "expected %<while%> before end of line"
+#~ msgstr "ожидалось %<while%> перед концом строки"
+
+#~ msgid "expected %<while%> before %<decltype%>"
+#~ msgstr "ожидалось %<while%> перед %<decltype%>"
+
+#~ msgid "expected %<while%> before %qs token"
+#~ msgstr "ожидалось %<while%> перед лексемой %qs"
+
+#~ msgid "expected %<.%> at end of input"
+#~ msgstr "ожидалась %<.%> в конце входного потока"
+
+#~ msgid "expected %<.%> before %s'%c'"
+#~ msgstr "ожидалась %<.%> перед %s'%c'"
+
+#~ msgid "expected %<.%> before %s'\\x%x'"
+#~ msgstr "ожидалась %<.%> перед %s'\\x%x'"
+
+#~ msgid "expected %<.%> before string constant"
+#~ msgstr "ожидалась %<.%> перед строковой константой"
+
+#~ msgid "expected %<.%> before numeric constant"
+#~ msgstr "ожидалась %<.%> перед числовой константой"
+
+#~ msgid "expected %<.%> before %qE"
+#~ msgstr "ожидалась %<.%> перед %qE"
+
+#~ msgid "expected %<.%> before %<#pragma%>"
+#~ msgstr "ожидалась %<.%> перед %<#pragma%>"
+
+#~ msgid "expected %<.%> before end of line"
+#~ msgstr "ожидалась %<.%> перед концом строки"
+
+#~ msgid "expected %<.%> before %<decltype%>"
+#~ msgstr "ожидалась %<.%> перед %<decltype%>"
+
+#~ msgid "expected %<.%> before %qs token"
+#~ msgstr "ожидалась %<.%> перед лексемой %qs"
+
+#~ msgid "expected %<@end%> at end of input"
+#~ msgstr "ожидалось %<@end%> в конце входного потока"
+
+#~ msgid "expected %<@end%> before %s'%c'"
+#~ msgstr "ожидалось %<@end%> перед %s'%c'"
+
+#~ msgid "expected %<@end%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<@end%> перед %s'\\x%x'"
+
+#~ msgid "expected %<@end%> before string constant"
+#~ msgstr "ожидалось %<@end%> перед строковой константой"
+
+#~ msgid "expected %<@end%> before numeric constant"
+#~ msgstr "ожидалось %<@end%> перед числовой константой"
+
+#~ msgid "expected %<@end%> before %qE"
+#~ msgstr "ожидалось %<@end%> перед %qE"
+
+#~ msgid "expected %<@end%> before end of line"
+#~ msgstr "ожидалось %<@end%> перед концом строки"
+
+#~ msgid "expected %<@end%> before %<decltype%>"
+#~ msgstr "ожидалось %<@end%> перед %<decltype%>"
+
+#~ msgid "expected %<@end%> before %qs token"
+#~ msgstr "ожидалось %<@end%> перед лексемой %qs"
+
+#~ msgid "expected %<>%> at end of input"
+#~ msgstr "ожидалось %<>%> в конце входного потока"
+
+#~ msgid "expected %<>%> before %s'%c'"
+#~ msgstr "ожидалось %<>%> перед %s'%c'"
+
+#~ msgid "expected %<>%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<>%> перед %s'\\x%x'"
+
+#~ msgid "expected %<>%> before string constant"
+#~ msgstr "ожидалось %<>%> перед строковой константой"
+
+#~ msgid "expected %<>%> before numeric constant"
+#~ msgstr "ожидалось %<>%> перед числовой константой"
+
+#~ msgid "expected %<>%> before %qE"
+#~ msgstr "ожидалось %<>%> перед %qE"
+
+#~ msgid "expected %<>%> before %<#pragma%>"
+#~ msgstr "ожидалось %<>%> перед %<#pragma%>"
+
+#~ msgid "expected %<>%> before end of line"
+#~ msgstr "ожидалось %<>%> перед концом строки"
+
+#~ msgid "expected %<>%> before %<decltype%>"
+#~ msgstr "ожидалось %<>%> перед %<decltype%>"
+
+#~ msgid "expected %<>%> before %qs token"
+#~ msgstr "ожидалось %<>%> перед лексемой %qs"
+
+#~ msgid "expected %<,%> or %<)%> at end of input"
+#~ msgstr "ожидалась %<,%> или %<)%> в конце входного потока"
+
+#~ msgid "expected %<,%> or %<)%> before %s'%c'"
+#~ msgstr "ожидалась %<,%> или %<)%> перед %s'%c'"
+
+#~ msgid "expected %<,%> or %<)%> before %s'\\x%x'"
+#~ msgstr "ожидалась %<,%> или %<)%> перед %s'\\x%x'"
+
+#~ msgid "expected %<,%> or %<)%> before string constant"
+#~ msgstr "ожидалась %<,%> или %<)%> перед строковой константой"
+
+#~ msgid "expected %<,%> or %<)%> before numeric constant"
+#~ msgstr "ожидалась %<,%> или %<)%> перед числовой константой"
+
+#~ msgid "expected %<,%> or %<)%> before %<#pragma%>"
+#~ msgstr "ожидалась %<,%> или %<)%> перед %<#pragma%>"
+
+#~ msgid "expected %<,%> or %<)%> before end of line"
+#~ msgstr "ожидалась %<,%> или %<)%> перед концом строки"
+
+#~ msgid "expected %<,%> or %<)%> before %<decltype%>"
+#~ msgstr "ожидалась %<,%> или %<)%> перед %<decltype%>"
+
+#~ msgid "expected %<,%> or %<)%> before %qs token"
+#~ msgstr "ожидалась %<,%> или %<)%> перед лексемой %qs"
+
+#~ msgid "expected %<=%> at end of input"
+#~ msgstr "ожидалось %<=%> в конце входного потока"
+
+#~ msgid "expected %<=%> before %s'%c'"
+#~ msgstr "ожидалось %<=%> перед %s'%c'"
+
+#~ msgid "expected %<=%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<=%> перед %s'\\x%x'"
+
+#~ msgid "expected %<=%> before string constant"
+#~ msgstr "ожидалось %<=%> перед строковой константой"
+
+#~ msgid "expected %<=%> before numeric constant"
+#~ msgstr "ожидалось %<=%> перед числовой константой"
+
+#~ msgid "expected %<=%> before %qE"
+#~ msgstr "ожидалось %<=%> перед %qE"
+
+#~ msgid "expected %<=%> before %<#pragma%>"
+#~ msgstr "ожидалось %<=%> перед %<#pragma%>"
+
+#~ msgid "expected %<=%> before end of line"
+#~ msgstr "ожидалось %<=%> перед концом строки"
+
+#~ msgid "expected %<=%> before %<decltype%>"
+#~ msgstr "ожидалось %<=%> перед %<decltype%>"
+
+#~ msgid "expected %<=%> before %qs token"
+#~ msgstr "ожидалось %<=%> перед лексемой %qs"
+
+#~ msgid "expected %<#pragma omp section%> or %<}%> at end of input"
+#~ msgstr "ожидалось %<#pragma omp section%> или %<}%> в конце входного потока"
+
+#~ msgid "expected %<#pragma omp section%> or %<}%> before %s'%c'"
+#~ msgstr "ожидалось %<#pragma omp section%> или %<}%> перед %s'%c'"
+
+#~ msgid "expected %<#pragma omp section%> or %<}%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<#pragma omp section%> или %<}%> перед %s'\\x%x'"
+
+#~ msgid "expected %<#pragma omp section%> or %<}%> before string constant"
+#~ msgstr "ожидалось %<#pragma omp section%> или %<}%> перед строковой константой"
+
+#~ msgid "expected %<#pragma omp section%> or %<}%> before numeric constant"
+#~ msgstr "ожидалось %<#pragma omp section%> или %<}%> перед числовой константой"
+
+#~ msgid "expected %<#pragma omp section%> or %<}%> before %qE"
+#~ msgstr "ожидалось %<#pragma omp section%> или %<}%> перед %qE"
+
+#~ msgid "expected %<#pragma omp section%> or %<}%> before %<#pragma%>"
+#~ msgstr "ожидалось %<#pragma omp section%> или %<}%> перед %<#pragma%>"
+
+#~ msgid "expected %<#pragma omp section%> or %<}%> before end of line"
+#~ msgstr "ожидалось %<#pragma omp section%> или %<}%> перед концом строки"
+
+#~ msgid "expected %<#pragma omp section%> or %<}%> before %<decltype%>"
+#~ msgstr "ожидалось %<#pragma omp section%> или %<}%> перед %<decltype%>"
+
+#~ msgid "expected %<#pragma omp section%> or %<}%> before %qs token"
+#~ msgstr "ожидалось %<#pragma omp section%> или %<}%> перед лексемой %qs"
+
+#~ msgid "expected %<[%> at end of input"
+#~ msgstr "ожидалось %<[%> в конце входного потока"
+
+#~ msgid "expected %<[%> before %s'%c'"
+#~ msgstr "ожидалось %<[%> перед %s'%c'"
+
+#~ msgid "expected %<[%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<[%> перед %s'\\x%x'"
+
+#~ msgid "expected %<[%> before string constant"
+#~ msgstr "ожидалось %<[%> перед строковой константой"
+
+#~ msgid "expected %<[%> before numeric constant"
+#~ msgstr "ожидалось %<[%> перед числовой константой"
+
+#~ msgid "expected %<[%> before %qE"
+#~ msgstr "ожидалось %<[%> перед %qE"
+
+#~ msgid "expected %<[%> before %<#pragma%>"
+#~ msgstr "ожидалось %<[%> перед %<#pragma%>"
+
+#~ msgid "expected %<[%> before end of line"
+#~ msgstr "ожидалось %<[%> перед концом строки"
+
+#~ msgid "expected %<[%> before %<decltype%>"
+#~ msgstr "ожидалось %<[%> перед %<decltype%>"
+
+#~ msgid "expected %<[%> before %qs token"
+#~ msgstr "ожидалось %<[%> перед лексемой %qs"
+
+#~ msgid "%s 2015 Scientific Research Institute of System Analysis, RAS.\n"
+#~ msgstr "%s 2015 НИИ Системных Исследований, РАН.\n"
+
+#~ msgid ""
+#~ "This is free software; see the source for copying conditions.\n"
+#~ "\n"
+#~ msgstr ""
+#~ "Это свободно распространяемое программное обеспечение. Условия копирования\n"
+#~ "приведены в исходных текстах.\n"
+
+#~ msgid "%s:not a gcov graph file\n"
+#~ msgstr "%s:не графический файл gcov\n"
+
+#~ msgid "%s:%d:%d: Invalid state file; %s"
+#~ msgstr "%s:%d:%d: Некорректный файл состояния; %s"
+
+#~ msgid "%s:%d: Invalid state file; %s"
+#~ msgstr "%s:%d: Некорректный файл состояния; %s"
+
+#~ msgid "%s:%d:%d: Invalid state file; "
+#~ msgstr "%s:%d:%d: Некорректный файл состояния; "
+
+#~ msgid "%s:%d: Invalid state file; "
+#~ msgstr "%s:%d: Некорректный файл состояния; "
+
+#~ msgid "Option tag unknown"
+#~ msgstr "Неизвестный тег опции"
+
+#~ msgid "Unexpected type in write_state_scalar_type"
+#~ msgstr "Некорректный тип в write_state_scalar_type"
+
+#~ msgid "Unexpected type in write_state_string_type"
+#~ msgstr "Некорректный тип в write_state_string_type"
+
+#~ msgid "Unexpected type..."
+#~ msgstr "Неожиданный тип..."
+
+#~ msgid "failed to write state trailer [%s]"
+#~ msgstr "не удалось записать трейлер состояния [%s]"
+
+#~ msgid "Failed to open file %s for writing state: %s"
+#~ msgstr "ошибка открытия файла %s для записи состояния: %s"
+
+#~ msgid "output error when writing state file %s [%s]"
+#~ msgstr "ошибка записи в файл состояния %s [%s]"
+
+#~ msgid "failed to close state file %s [%s]"
+#~ msgstr "ошибка закрытия файла состояния %s [%s]"
+
+#~ msgid "failed to rename %s to state file %s [%s]"
+#~ msgstr "не удалось переименовать %s в файл состояния %s [%s]"
+
+#~ msgid "Failed to open state file %s for reading [%s]"
+#~ msgstr "Ошибка открытия файла состояния %s на чтение [%s]"
+
+#~ msgid "failed to close read state file %s [%s]"
+#~ msgstr "ошибка закрытия файла состояния файла %s [%s]"
+
+#~ msgid "pex_init failed"
+#~ msgstr "ошибка в pex_init"
+
+#~ msgid "can't get program status"
+#~ msgstr "не удалось получить состояние программы"
+
+#~ msgid "%s terminated with signal %d [%s], core dumped"
+#~ msgstr "%s завершилась по сигналу %d [%s], выдан файл core"
+
+#~ msgid "%s terminated with signal %d [%s]"
+#~ msgstr "%s завершилась по сигналу %d [%s]"
+
+#~ msgid "could not write to temporary file %s"
+#~ msgstr "не удалось выполнить запись во временный файл %s"
+
+#~ msgid "fopen: %s"
+#~ msgstr "fopen: %s"
+
+#~ msgid "enabled by default"
+#~ msgstr "включено по умолчанию"
+
+#~ msgid "out of memory"
+#~ msgstr "недостаточно памяти"
+
+#~ msgid "optimizing for size and code size would grow"
+#~ msgstr "размер кода увеличится при включённой оптимизации по размеру"
+
+#~ msgid "Select fraction of the maximal count of repetitions of basic block in program given basic block needs to have to be considered hot"
+#~ msgstr "Относительное максимальное число повторений блока в программе, при превышении которого блок должен считаться критическим"
+
+#~ msgid "Bound on the number of variables in Omega constraint systems"
+#~ msgstr "Верхняя граница числа переменных в системе ограничений Omega"
+
+#~ msgid "Bound on the number of inequalities in Omega constraint systems"
+#~ msgstr "Верхняя граница числа неравенств в системе ограничений Omega"
+
+#~ msgid "Bound on the number of equalities in Omega constraint systems"
+#~ msgstr "Верхняя граница числа равенств в системе ограничений Omega"
+
+#~ msgid "Bound on the number of wild cards in Omega constraint systems"
+#~ msgstr "Верхняя граница числа сопоставлений в системе ограничений Omega"
+
+#~ msgid "Bound on the size of the hash table in Omega constraint systems"
+#~ msgstr "Верхняя граница размера хэш-таблицы в системе ограничений Omega"
+
+#~ msgid "Bound on the number of keys in Omega constraint systems"
+#~ msgstr "Верхняя граница числа ключей в системе ограничений Omega"
+
+#~ msgid "When set to 1, use expensive methods to eliminate all redundant constraints"
+#~ msgstr "При значении 1 будут использоваться дорогостоящие методы для удаления избыточных ограничений"
+
+#~ msgid "Minimum number of virtual mappings to consider switching to full virtual renames"
+#~ msgstr "Минимальное число виртуальных отображений, при котором может быть выполнено полное переименование виртуальных символов"
+
+#~ msgid "Ratio between virtual mappings and virtual symbols to do full virtual renames"
+#~ msgstr "Отношение числа виртуальных отображений к числу виртуальных символов, при котором выполняется полное переименование символов"
+
+#~ msgid "Allow new data races on loads to be introduced"
+#~ msgstr "Разрешить оптимизатору добавление новых гонок данных по загрузкам данных"
+
+#~ msgid "Allow new data races on packed data loads to be introduced"
+#~ msgstr "Разрешить оптимизатору добавление новых гонок данных по загрузке упакованных данных"
+
+#~ msgid "Allow new data races on packed data stores to be introduced"
+#~ msgstr "Разрешить оптимизатору добавление новых гонок данных по записи упакованных данных"
+
+#~ msgid "If frame size of a leaf function is less than this do not check stack limit for it"
+#~ msgstr "Не проверять выход за границу стека в листовой функции, если ее кадр стека меньше этого значения"
+
+#~ msgid "<unnamed-signed:"
+#~ msgstr "<unnamed-signed:"
+
+#~ msgid "operand is neither a constant nor a condition code, invalid operand code 'C'"
+#~ msgstr "операнд не является константой или кодом условия, неверный код операнда 'C'"
+
+#~ msgid "operand is neither a constant nor a condition code, invalid operand code 'F'"
+#~ msgstr "операнд не является константой или кодом условия, неверный код операнда 'F'"
+
+#~ msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
+#~ msgstr "операнд не является константой или кодом условия, неверный код операнда 'c'"
+
+#~ msgid "operand is neither a constant nor a condition code, invalid operand code 'f'"
+#~ msgstr "операнд не является константой или кодом условия, неверный код операнда 'f'"
+
+#~ msgid "mips_debugger_offset called with non stack/frame/arg pointer"
+#~ msgstr "mips_debugger_offset вызвана не с указателем стека/кадра/аргумента"
+
+#~ msgid "picochip_print_memory_address - Operand isn't memory based"
+#~ msgstr "picochip_print_memory_address - Операнд не базирован в памяти"
+
+#~ msgid "Unknown mode in print_operand (CONST_DOUBLE) :"
+#~ msgstr "Неизвестный режим в print_operand (CONST_DOUBLE) :"
+
+#~ msgid "Bad address, not (reg+disp):"
+#~ msgstr "некорректный адрес, не (reg+disp):"
+
+#~ msgid "-mvsx used with little endian code"
+#~ msgstr "-mvsx использован для кода little endian"
+
+#~ msgid "invalid %%c value"
+#~ msgstr "некорректное %%c значение"
+
+#~ msgid "invalid %%S value"
+#~ msgstr "недопустимое значение для кода %%S"
+
+#~ msgid "memory reference expected for 'O' output modifier"
+#~ msgstr "ожидалась ссылка на память для 'O' модификатора вывода"
+
+#~ msgid "memory reference expected for 'R' output modifier"
+#~ msgstr "ожидалась ссылка на память для 'R' модификатора вывода"
+
+#~ msgid "invalid operand for code: '%c'"
+#~ msgstr "некорректный операнд для кода '%c'"
+
+#~ msgid "long long constant not a valid immediate operand"
+#~ msgstr "константа long long не является корректным непосредственным операндом"
+
+#~ msgid "%s:%d:   [ skipping %d instantiation contexts ]\n"
+#~ msgstr "%s:%d:   [ пропуск %d контекстов конкретизации ]\n"
+
+#~ msgid ""
+#~ "GNU Fortran comes with NO WARRANTY, to the extent permitted by law.\n"
+#~ "You may redistribute copies of GNU Fortran\n"
+#~ "under the terms of the GNU General Public License.\n"
+#~ "For more information about these matters, see the file named COPYING\n"
+#~ "\n"
+#~ msgstr ""
+#~ "GNU Fortran поступает без гарантий в степени, позволенной законом.\n"
+#~ "Вы можете передавать копии GNU Fortran\n"
+#~ "на условиях GNU General Public License.\n"
+#~ "Более подробная информация имеется в файле COPYING\n"
+#~ "\n"
+
+#~ msgid "-I <dir>.\tAdd <dir> to the end of the main source path"
+#~ msgstr "-I <каталог>.\tДобавить <каталог> в конец основного пути поиска заголовков"
+
+#~ msgid "Do not look for source files in standard path"
+#~ msgstr "Не искать исходные файлы по стандартным маршрутам"
+
+#~ msgid "Use big-endian format for unformatted files"
+#~ msgstr "Использовать прямой (big-endian) порядок байт для неформатированных файлов"
+
+#~ msgid "Use little-endian format for unformatted files"
+#~ msgstr "Использовать обратный порядок байт для неформатированных файлов"
+
+#~ msgid "Use native format for unformatted files"
+#~ msgstr "Использовать естественный формат для неформатированных файлов"
+
+#~ msgid "Swap endianness for unformatted files"
+#~ msgstr "Изменить порядок байт для неформатированных файлов"
+
+#~ msgid "Compile all program units at once and check all interfaces"
+#~ msgstr "Компилировать все программные единицы совместно, с проверкой всех интерфейсов"
+
+#~ msgid "Assume GAS"
+#~ msgstr "Предполагать использование GAS"
+
+#~ msgid "Do not assume GAS"
+#~ msgstr "Не предполагать использование GAS"
+
+#~ msgid "mvcle use"
+#~ msgstr "mvcle use"
+
+#~ msgid "If set, data speculative instructions will be chosen for schedule only if there are no other choices at the moment "
+#~ msgstr "Если установлены, инструкции предвыборки данных будут выбраны для планирования только если нет других вариантов в момент "
+
+#~ msgid "If set, control speculative instructions will be chosen for schedule only if there are no other choices at the moment "
+#~ msgstr "Если установлены, инструкции предвыборки управления будут выбраны для планирования только если нет других вариантов в момент "
+
+#~ msgid "Ignored (obsolete)"
+#~ msgstr "Игнорируется (устаревшая)"
+
+#~ msgid "Use POWER instruction set"
+#~ msgstr "Использовать систему команд POWER"
+
+#~ msgid "Do not use POWER instruction set"
+#~ msgstr "Не использовать систему команд POWER"
+
+#~ msgid "Use POWER2 instruction set"
+#~ msgstr "Использовать систему команд POWER2"
+
+#~ msgid "Use PowerPC instruction set"
+#~ msgstr "Использовать систему команд PowerPC"
+
+#~ msgid "Use new mnemonics for PowerPC architecture"
+#~ msgstr "Использовать новые мнемоники команд для архитектуры PowerPC"
+
+#~ msgid "Use old mnemonics for PowerPC architecture"
+#~ msgstr "Использовать старые мнемоники команд для архитектуры PowerPC"
+
+#~ msgid "Throttle unrolling to avoid thrashing target registers unless the unroll benefit outweighs this"
+#~ msgstr "Прервать раскатку чтобы избежать перегрузку целевых регистров если только выгода от раскатки не перевесит это"
+
+#~ msgid "Enable the use of the fused floating point multiply-accumulate operation"
+#~ msgstr "Включить использование слитых плавающих операций умножения с накоплением"
+
+#~ msgid "Use software atomic sequences supported by kernel"
+#~ msgstr "Использовать программные атомарные последовательности поддерживаемые ядром"
+
+#~ msgid "Cirrus: Place NOPs to avoid invalid instruction combinations"
+#~ msgstr "Cirrus: генерировать команды NOP во избежание некорректного комбинирования команд"
+
+#~ msgid "Assume big endian bytes, little endian words.  This option is deprecated."
+#~ msgstr "Считать, что байты имеют прямой порядок бит, а слова - обратный порядок байт.  Эта опция устарела."
+
+#~ msgid "Ignore dllimport attribute for functions"
+#~ msgstr "Игнорировать атрибут dllimport для функций"
+
+#~ msgid "Use rjmp/rcall (limited range) on >8K devices"
+#~ msgstr "Использовать rjmp/rcall (с ограниченным диапазоном) для устройств >8K"
+
+#~ msgid "Known MCU names:"
+#~ msgstr "Известные MCU имена:"
+
+#~ msgid "Generate code for huge switch statements"
+#~ msgstr "Генерировать код для больших переключателей"
+
+#~ msgid "Put jumps in call delay slots"
+#~ msgstr "Помещать переходы в гнезда задержки вызовов"
+
+#~ msgid "Enable use of CPV in code generation for k64m and k128m"
+#~ msgstr "Разрешить использование команд сопроцессора CPV при генерации кода для k64m и k128m"
+
+#~ msgid "Allow use of 256-bit CPV loads and stores and use 32-byte alignment of stack frames"
+#~ msgstr "Разрешить использование команд чтения-записи 256-битных данных сопроцессора CPV и выравнивать кадр стека на 32 байта"
+
+#~ msgid "Use CPV in 64 bit mode"
+#~ msgstr "Использовать сопроцессор CPV в 64-битном режиме"
+
+#~ msgid "Disable indexed memory addressing"
+#~ msgstr "Запретить использование индексной адресации"
+
+#~ msgid "Do not put instructions using HI/LO registers to delay slots"
+#~ msgstr "Не помещать в гнезда задержки команды, использующие HI/LO регистры"
+
+#~ msgid "Fix division error of k128rio"
+#~ msgstr "Обходить ошибку деления процессора k128rio"
+
+#~ msgid "Generate 2 NOPs before integer multiplication"
+#~ msgstr "Генерировать 2 команды NOP перед целочисленным умножением"
+
+#~ msgid "Fix errata in K128RIO unaligned load instructions"
+#~ msgstr "Обходить ошибки невыровненного чтения K128RIO"
+
+#~ msgid "Generate floating-point multiply-add instructions"
+#~ msgstr "Генерировать плавающие команды умножения с накоплением"
+
+#~ msgid "-mstack-limit-register=REG\tCheck stack overflow using REG as stack limit value"
+#~ msgstr "-mstack-limit-register=REG\tПроверять переполнение стека, считая что граница стека находится в регистре REG"
+
+#~ msgid "Generate code for k128m"
+#~ msgstr "Генерировать код для процессора k128m"
+
+#~ msgid "Generate code for k128rio, version 3"
+#~ msgstr "Генерировать код для процессора k128rio, версия 3"
+
+#~ msgid "Generate code for k128rio, version 2"
+#~ msgstr "Генерировать код для процессора k128rio, версия 3"
+
+#~ msgid "Generate code for k64m"
+#~ msgstr "Генерировать код для процессора k64m"
+
+#~ msgid "Generate code for k64mp"
+#~ msgstr "Генерировать код для процессора k64mp"
+
+#~ msgid "Generate code for k64rio"
+#~ msgstr "Генерировать код для процессора k64rio"
+
+#~ msgid "Generate code for k64smp"
+#~ msgstr "Генерировать код для процессора k64smp"
+
+#~ msgid "Generate code for xlp"
+#~ msgstr "Генерировать код для процессора xlp"
+
+#~ msgid "Generate code for rm7000"
+#~ msgstr "Генерировать код для процессора rm7000"
+
+#~ msgid "Generate code for r3000"
+#~ msgstr "Генерировать код для процессора r3000"
+
+#~ msgid "Support Green Hills ABI"
+#~ msgstr "Включить поддержку Green Hills ABI"
+
+#~ msgid "Specify which type of AE to target. This option sets the mul-type and byte-access."
+#~ msgstr "Задать какой тип AE целевой. Эта опция устанавливает mul-type и byte-access."
+
+#~ msgid "Specify which type of multiplication to use. Can be mem, mac or none."
+#~ msgstr "Задать какой тип умножения использовать. Может быть mem, mac или none."
+
+#~ msgid "Specify whether the byte access instructions should be used. Enabled by default."
+#~ msgstr "Задать следует ли использовать инструкции байтного доступа. Включено по умолчанию."
+
+#~ msgid "Enable debug output to be generated."
+#~ msgstr "Включить генерацию отладочной выдачи."
+
+#~ msgid "Allow a symbol value to be used as an immediate value in an instruction."
+#~ msgstr "Разрешить использовать значение символа как непосредственное значение в инструкции."
+
+#~ msgid "Generate warnings when inefficient code is known to be generated."
+#~ msgstr "Генерировать предупреждения если известно что будет сгенерирован неэффективный код."
+
+#~ msgid "Disable bcnz instruction"
+#~ msgstr "Выключить bcnz инструкцию"
+
+#~ msgid "Support SCORE 7 ISA"
+#~ msgstr "Поддерживать SCORE 7 ISA"
+
+#~ msgid "Support SCORE 7D ISA"
+#~ msgstr "Поддерживать SCORE 7D ISA"
+
+#~ msgid "Known SCORE architectures (for use with the -march= option):"
+#~ msgstr "Известные SCORE архитектуры (для использования с -march= опцией):"
+
+#~ msgid "Deprecated in favor of -Wc++11-compat"
+#~ msgstr "Устарел; используйте -Wc++11-compat"
+
+#~ msgid "Warn about constructs not instrumented by -fmudflap"
+#~ msgstr "Предупреждать о конструкциях, не инструментированных в соответствии с -fmudflap"
+
+#~ msgid "Reduce the size of object files"
+#~ msgstr "Сократить объем объектных файлов"
+
+#~ msgid "Add mudflap bounds-checking instrumentation for single-threaded program"
+#~ msgstr "Инструментировать однопоточную программу для проверки выхода за границы массивов при помощи mudflap"
+
+#~ msgid "Add mudflap bounds-checking instrumentation for multi-threaded program"
+#~ msgstr "Инструментировать многопоточную программу для проверки выхода за границы массивов при помощи mudflap"
+
+#~ msgid "Ignore read operations when inserting mudflap instrumentation"
+#~ msgstr "Игнорировать операции чтения при инструментировании для mudflap"
+
+#~ msgid "Use the same size for double as for float"
+#~ msgstr "Использовать для double размер float"
+
+#~ msgid "Conform to the ISO 2011 C standard (experimental and incomplete support)"
+#~ msgstr "Компилировать в соответствии со стандартом ISO 2011 C (неполная экспериментальная поддержка)"
+
+#~ msgid "Conform to the ISO 1998 C++ standard revised by the 2003 technical corrigendum with GNU extensions"
+#~ msgstr "Компилировать в соответствии с ISO 1998 C++ с учетом технических поправок 2003 года, с расширениями GNU"
+
+#~ msgid "Conform to the ISO 2011 C standard with GNU extensions (experimental and incomplete support)"
+#~ msgstr "Компилировать в соответствии с ISO 2011 C с расширениями GNU (неполная экспериментальная поддержка)"
+
+#~ msgid "Compare the results of several data dependence analyzers."
+#~ msgstr "Сравнивать результаты нескольких анализаторов зависимостей по данным."
+
+#~ msgid "Enable Loop Strip Mining transformation"
+#~ msgstr "Включить трансформации \"выделения полос\" в циклах"
+
+#~ msgid "Enable Loop Interchange transformation"
+#~ msgstr "Включить трансформации обмена циклов в гнездах"
+
+#~ msgid "Enable Loop Blocking transformation"
+#~ msgstr "Включить трансформации выделения блоков в гнездах циклах"
+
+#~ msgid "Enable Loop Flattening transformation"
+#~ msgstr "Включить трансформации распрямления циклов"
+
+#~ msgid "Perform matrix layout flattening and transposing based on profiling information."
+#~ msgstr "Выполнить распрямление и транспонирование матриц на основе данных профилирования."
+
+#~ msgid "Partition functions and vars at linktime based on object files they originate from"
+#~ msgstr "Разбивать функции и переменные во время компоновки в соответствии с их принадлежностью объектным файлам"
+
+#~ msgid "Partition functions and vars at linktime into approximately same sized buckets"
+#~ msgstr "Разбивать функции и переменные во время компоновки на приблизительно одинаковые по размеру порции"
+
+#~ msgid "Disable partioning and streaming"
+#~ msgstr "Отключить разбиение полностью"
+
+#~ msgid "Do the full register move optimization pass"
+#~ msgstr "Выполнить полную оптимизацию перемещения регистров"
+
+#~ msgid "Enables a register move optimization"
+#~ msgstr "Выполнить оптимизацию перемещения регистров"
+
+#~ msgid "Replace SSA temporaries with better names in copies"
+#~ msgstr "Переименовывать временные SSA-переменные при копировании для более близкого соответствия программным переменным"
+
+#~ msgid "Enable loop versioning when doing loop vectorization on trees"
+#~ msgstr "Создавать версии циклов при векторизации"
+
+#~ msgid "-ftree-vectorizer-verbose=<number>\tSet the verbosity level of the vectorizer"
+#~ msgstr "-ftree-vectorizer-verbose=<уровень>\tУстановить <уровень> подробности сообщений при векторизации циклов"
+
+#~ msgid "expected integer or boolean type"
+#~ msgstr "ожидалось выражение или булевый тип"
+
+#~ msgid "invalid operand for unary %<&%>"
+#~ msgstr "неверный операнд унарной операции %<&%>"
+
+#~ msgid "bad size for make"
+#~ msgstr "некорректный размер для make"
+
+#~ msgid "bad capacity when making slice"
+#~ msgstr "некорректная емкость при изготовлении вырезки"
+
+#~ msgid "implicit assignment of %s%s%s hidden field %s%s%s"
+#~ msgstr "неявное присваивание %s%s%s скрытого поля %s%s%s"
+
+#~ msgid "invalid argument to %<__builtin_return_address%>"
+#~ msgstr "неверный аргумент для %<__builtin_return_address%>"
+
+#~ msgid "unsupported argument to %<__builtin_frame_address%>"
+#~ msgstr "неподдерживаемый аргумент для %<__builtin_frame_address%>"
+
+#~ msgid "unsupported argument to %<__builtin_return_address%>"
+#~ msgstr "неподдерживаемый аргумент для %<__builtin_return_address%>"
+
+#~ msgid "invalid memory model for %<__atomic_exchange%>"
+#~ msgstr "некорректный аргумент модели памяти в вызове %<__atomic_exchange%>"
+
+#~ msgid "declaration of %q+D shadows a global declaration"
+#~ msgstr "декларация %q+D перекрывает глобальную декларацию"
+
+#~ msgid "useless %<__thread%> in empty declaration"
+#~ msgstr "бесполезное %<__thread%> в пустой декларации"
+
+#~ msgid "the size of array %qE can%'t be evaluated"
+#~ msgstr "невозможно вычислить размер массива %qE"
+
+#~ msgid "the size of array can %'t be evaluated"
+#~ msgstr "невозможно вычислить размер массива"
+
+#~ msgid "variable length array %qE is used"
+#~ msgstr "используется массив переменного размера %qE"
+
+#~ msgid "function definition declared %<__thread%>"
+#~ msgstr "определение функции со спецификатором %<__thread%>"
+
+#~ msgid "%<%s %E%> declared inside parameter list"
+#~ msgstr "декларация %<%s %E%> внутри списка параметров"
+
+#~ msgid "anonymous %s declared inside parameter list"
+#~ msgstr "декларация %s без имени внутри списка параметров"
+
+#~ msgid "its scope is only this definition or declaration, which is probably not what you want"
+#~ msgstr "область действия типа - только данная декларация или определение, что может не соответствовать вашим намерениям"
+
+#~ msgid "%<__thread%> used with %qE"
+#~ msgstr "спецификатор %<__thread%> использован с %qE"
+
+#~ msgid "expected declaration specifiers at end of input"
+#~ msgstr "ожидались спецификаторы декларации в конце входного потока"
+
+#~ msgid "expected declaration specifiers before %s'%c'"
+#~ msgstr "ожидались спецификаторы декларации перед %s'%c'"
+
+#~ msgid "expected declaration specifiers before %s'\\x%x'"
+#~ msgstr "ожидались спецификаторы декларации перед %s'\\x%x'"
+
+#~ msgid "expected declaration specifiers before string constant"
+#~ msgstr "ожидались спецификаторы декларации перед строковой константой"
+
+#~ msgid "expected declaration specifiers before numeric constant"
+#~ msgstr "ожидались спецификаторы декларации перед числовой константой"
+
+#~ msgid "expected declaration specifiers before %qE"
+#~ msgstr "ожидались спецификаторы декларации перед %qE"
+
+#~ msgid "expected declaration specifiers before %<#pragma%>"
+#~ msgstr "ожидались спецификаторы декларации перед %<#pragma%>"
+
+#~ msgid "expected declaration specifiers before end of line"
+#~ msgstr "ожидались спецификаторы декларации перед концом строки"
+
+#~ msgid "expected declaration specifiers before %<decltype%>"
+#~ msgstr "ожидались спецификаторы декларации перед %<decltype%>"
+
+#~ msgid "expected declaration specifiers before %qs token"
+#~ msgstr "ожидались спецификаторы декларации перед лексемой %qs"
+
+#~ msgid "expected %<;%>, identifier or %<(%> at end of input"
+#~ msgstr "ожидалось %<;%>, идентификатор или %<(%> в конце входного потока"
+
+#~ msgid "expected %<;%>, identifier or %<(%> before %s'%c'"
+#~ msgstr "ожидалось %<;%>, идентификатор или %<(%> перед %s'%c'"
+
+#~ msgid "expected %<;%>, identifier or %<(%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<;%>, идентификатор или %<(%> перед %s'\\x%x'"
+
+#~ msgid "expected %<;%>, identifier or %<(%> before string constant"
+#~ msgstr "ожидалось %<;%>, идентификатор или %<(%> перед строковой константой"
+
+#~ msgid "expected %<;%>, identifier or %<(%> before numeric constant"
+#~ msgstr "ожидалось %<;%>, идентификатор или %<(%> перед числовой константой"
+
+#~ msgid "expected %<;%>, identifier or %<(%> before %qE"
+#~ msgstr "ожидалось %<;%>, идентификатор или %<(%> перед %qE"
+
+#~ msgid "expected %<;%>, identifier or %<(%> before %<#pragma%>"
+#~ msgstr "ожидалось %<;%>, идентификатор или %<(%> перед %<#pragma%>"
+
+#~ msgid "expected %<;%>, identifier or %<(%> before end of line"
+#~ msgstr "ожидалось %<;%>, идентификатор или %<(%> перед концом строки"
+
+#~ msgid "expected %<;%>, identifier or %<(%> before %<decltype%>"
+#~ msgstr "ожидалось %<;%>, идентификатор или %<(%> перед %<decltype%>"
+
+#~ msgid "expected %<;%>, identifier or %<(%> before %qs token"
+#~ msgstr "ожидалось %<;%>, идентификатор или %<(%> перед лексемой %qs"
+
+#~ msgid "unexpected attribute at end of input"
+#~ msgstr "неожиданный атрибут в конце входного потока"
+
+#~ msgid "unexpected attribute before %s'%c'"
+#~ msgstr "неожиданный атрибут перед %s'%c'"
+
+#~ msgid "unexpected attribute before %s'\\x%x'"
+#~ msgstr "неожиданный атрибут перед %s'\\x%x'"
+
+#~ msgid "unexpected attribute before string constant"
+#~ msgstr "неожиданный атрибут перед строковой константой"
+
+#~ msgid "unexpected attribute before numeric constant"
+#~ msgstr "неожиданный атрибут перед числовой константой"
+
+#~ msgid "unexpected attribute before %qE"
+#~ msgstr "неожиданный атрибут перед %qE"
+
+#~ msgid "unexpected attribute before %<#pragma%>"
+#~ msgstr "неожиданный атрибут перед %<#pragma%>"
+
+#~ msgid "unexpected attribute before end of line"
+#~ msgstr "неожиданный атрибут перед концом строки"
+
+#~ msgid "unexpected attribute before %<decltype%>"
+#~ msgstr "неожиданный атрибут перед %<decltype%>"
+
+#~ msgid "unexpected attribute before %qs token"
+#~ msgstr "неожиданный атрибут перед лексемой %qs"
+
+#~ msgid "expected %<,%> or %<;%> at end of input"
+#~ msgstr "ожидалось %<,%> или %<;%> в конце входного потока"
+
+#~ msgid "expected %<,%> or %<;%> before %s'%c'"
+#~ msgstr "ожидалось %<,%> или %<;%> перед %s'%c'"
+
+#~ msgid "expected %<,%> or %<;%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<,%> или %<;%> перед %s'\\x%x'"
+
+#~ msgid "expected %<,%> or %<;%> before string constant"
+#~ msgstr "ожидалось %<,%> или %<;%> перед строковой константой"
+
+#~ msgid "expected %<,%> or %<;%> before numeric constant"
+#~ msgstr "ожидалось %<,%> или %<;%> перед числовой константой"
+
+#~ msgid "expected %<,%> or %<;%> before %qE"
+#~ msgstr "ожидалось %<,%> или %<;%> перед %qE"
+
+#~ msgid "expected %<,%> or %<;%> before %<#pragma%>"
+#~ msgstr "ожидалось %<,%> или %<;%> перед %<#pragma%>"
+
+#~ msgid "expected %<,%> or %<;%> before end of line"
+#~ msgstr "ожидалось %<,%> или %<;%> перед концом строки"
+
+#~ msgid "expected %<,%> or %<;%> before %<decltype%>"
+#~ msgstr "ожидалось %<,%> или %<;%> перед %<decltype%>"
+
+#~ msgid "expected %<,%> or %<;%> before %qs token"
+#~ msgstr "ожидалось %<,%> или %<;%> перед лексемой %qs"
+
+#~ msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%> at end of input"
+#~ msgstr "ожидалось %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%> в конце входного потока"
+
+#~ msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%> before %s'%c'"
+#~ msgstr "ожидалось %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%> перед %s'%c'"
+
+#~ msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%> перед %s'\\x%x'"
+
+#~ msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%> before string constant"
+#~ msgstr "ожидалось %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%> перед строковой константой"
+
+#~ msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%> before numeric constant"
+#~ msgstr "ожидалось %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%> перед числовой константой"
+
+#~ msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%> before %qE"
+#~ msgstr "ожидалось %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%> перед %qE"
+
+#~ msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%> before %<#pragma%>"
+#~ msgstr "ожидалось %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%> перед %<#pragma%>"
+
+#~ msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%> before end of line"
+#~ msgstr "ожидалось %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%> перед концом строки"
+
+#~ msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%> before %<decltype%>"
+#~ msgstr "ожидалось %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%> перед %<decltype%>"
+
+#~ msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%> before %qs token"
+#~ msgstr "ожидалось %<=%>, %<,%>, %<;%>, %<asm%> или %<__attribute__%> перед лексемой %qs"
+
+#~ msgid "expected string literal at end of input"
+#~ msgstr "ожидался строковый литерал в конце входного потока"
+
+#~ msgid "expected string literal before %s'%c'"
+#~ msgstr "ожидался строковый литерал перед %s'%c'"
+
+#~ msgid "expected string literal before %s'\\x%x'"
+#~ msgstr "ожидался строковый литерал перед %s'\\x%x'"
+
+#~ msgid "expected string literal before string constant"
+#~ msgstr "ожидался строковый литерал перед строковой константой"
+
+#~ msgid "expected string literal before numeric constant"
+#~ msgstr "ожидался строковый литерал перед числовой константой"
+
+#~ msgid "expected string literal before %qE"
+#~ msgstr "ожидался строковый литерал перед %qE"
+
+#~ msgid "expected string literal before %<#pragma%>"
+#~ msgstr "ожидался строковый литерал перед %<#pragma%>"
+
+#~ msgid "expected string literal before end of line"
+#~ msgstr "ожидался строковый литерал перед концом строки"
+
+#~ msgid "expected string literal before %<decltype%>"
+#~ msgstr "ожидался строковый литерал перед %<decltype%>"
+
+#~ msgid "expected string literal before %qs token"
+#~ msgstr "ожидался строковый литерал перед лексемой %qs"
+
+#~ msgid "expected identifier at end of input"
+#~ msgstr "ожидался идентификатор в конце входного потока"
+
+#~ msgid "expected identifier before %s'%c'"
+#~ msgstr "ожидался идентификатор перед %s'%c'"
+
+#~ msgid "expected identifier before %s'\\x%x'"
+#~ msgstr "ожидался идентификатор перед %s'\\x%x'"
+
+#~ msgid "expected identifier before numeric constant"
+#~ msgstr "ожидался идентификатор перед числовой константой"
+
+#~ msgid "expected identifier before %<#pragma%>"
+#~ msgstr "ожидался идентификатор перед %<#pragma%>"
+
+#~ msgid "expected identifier before end of line"
+#~ msgstr "ожидался идентификатор перед концом строки"
+
+#~ msgid "expected identifier before %<decltype%>"
+#~ msgstr "ожидался идентификатор перед %<decltype%>"
+
+#~ msgid "expected identifier before %qs token"
+#~ msgstr "ожидался идентификатор перед лексемой %qs"
+
+#~ msgid "expected %<,%> or %<}%> at end of input"
+#~ msgstr "ожидалось %<,%> или %<}%> в конце входного потока"
+
+#~ msgid "expected %<,%> or %<}%> before %s'%c'"
+#~ msgstr "ожидалось %<,%> или %<}%> перед %s'%c'"
+
+#~ msgid "expected %<,%> or %<}%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<,%> или %<}%> перед %s'\\x%x'"
+
+#~ msgid "expected %<,%> or %<}%> before string constant"
+#~ msgstr "ожидалось %<,%> или %<}%> перед строковой константой"
+
+#~ msgid "expected %<,%> or %<}%> before numeric constant"
+#~ msgstr "ожидалось %<,%> или %<}%> перед числовой константой"
+
+#~ msgid "expected %<,%> or %<}%> before %qE"
+#~ msgstr "ожидалось %<,%> или %<}%> перед %qE"
+
+#~ msgid "expected %<,%> or %<}%> before %<#pragma%>"
+#~ msgstr "ожидалось %<,%> или %<}%> перед %<#pragma%>"
+
+#~ msgid "expected %<,%> or %<}%> before end of line"
+#~ msgstr "ожидалось %<,%> или %<}%> перед концом строки"
+
+#~ msgid "expected %<,%> or %<}%> before %<decltype%>"
+#~ msgstr "ожидалось %<,%> или %<}%> перед %<decltype%>"
+
+#~ msgid "expected %<,%> or %<}%> before %qs token"
+#~ msgstr "ожидалось %<,%> или %<}%> перед лексемой %qs"
+
+#~ msgid "expected class name at end of input"
+#~ msgstr "ожидалось имя класса в конце входного потока"
+
+#~ msgid "expected class name before %s'%c'"
+#~ msgstr "ожидалось имя класса перед %s'%c'"
+
+#~ msgid "expected class name before %s'\\x%x'"
+#~ msgstr "ожидалось имя класса перед %s'\\x%x'"
+
+#~ msgid "expected class name before string constant"
+#~ msgstr "ожидалось имя класса перед строковой константой"
+
+#~ msgid "expected class name before numeric constant"
+#~ msgstr "ожидалось имя класса перед числовой константой"
+
+#~ msgid "expected class name before %qE"
+#~ msgstr "ожидалось имя класса перед %qE"
+
+#~ msgid "expected class name before %<#pragma%>"
+#~ msgstr "ожидалось имя класса перед %<#pragma%>"
+
+#~ msgid "expected class name before end of line"
+#~ msgstr "ожидалось имя класса перед концом строки"
+
+#~ msgid "expected class name before %<decltype%>"
+#~ msgstr "ожидалось имя класса перед %<decltype%>"
+
+#~ msgid "expected class name before %qs token"
+#~ msgstr "ожидалось имя класса перед лексемой %qs"
+
+#~ msgid "expected specifier-qualifier-list at end of input"
+#~ msgstr "ожидался список спецификаторов и квалификаторов в конце входного потока"
+
+#~ msgid "expected specifier-qualifier-list before %s'%c'"
+#~ msgstr "ожидался список спецификаторов и квалификаторов перед %s'%c'"
+
+#~ msgid "expected specifier-qualifier-list before %s'\\x%x'"
+#~ msgstr "ожидался список спецификаторов и квалификаторов перед %s'\\x%x'"
+
+#~ msgid "expected specifier-qualifier-list before string constant"
+#~ msgstr "ожидался список спецификаторов и квалификаторов перед строковой константой"
+
+#~ msgid "expected specifier-qualifier-list before numeric constant"
+#~ msgstr "ожидался список спецификаторов и квалификаторов перед числовой константой"
+
+#~ msgid "expected specifier-qualifier-list before %qE"
+#~ msgstr "ожидался список спецификаторов и квалификаторов перед %qE"
+
+#~ msgid "expected specifier-qualifier-list before %<#pragma%>"
+#~ msgstr "ожидался список спецификаторов и квалификаторов перед %<#pragma%>"
+
+#~ msgid "expected specifier-qualifier-list before end of line"
+#~ msgstr "ожидался список спецификаторов и квалификаторов перед концом строки"
+
+#~ msgid "expected specifier-qualifier-list before %<decltype%>"
+#~ msgstr "ожидался список спецификаторов и квалификаторов перед %<decltype%>"
+
+#~ msgid "expected specifier-qualifier-list before %qs token"
+#~ msgstr "ожидался список спецификаторов и квалификаторов перед лексемой %qs"
+
+#~ msgid "expected %<,%>, %<;%> or %<}%> at end of input"
+#~ msgstr "ожидалось %<,%>, %<;%> или %<}%> в конце входного потока"
+
+#~ msgid "expected %<,%>, %<;%> or %<}%> before %s'%c'"
+#~ msgstr "ожидалось %<,%>, %<;%> или %<}%> перед %s'%c'"
+
+#~ msgid "expected %<,%>, %<;%> or %<}%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<,%>, %<;%> или %<}%> перед %s'\\x%x'"
+
+#~ msgid "expected %<,%>, %<;%> or %<}%> before string constant"
+#~ msgstr "ожидалось %<,%>, %<;%> или %<}%> перед строковой константой"
+
+#~ msgid "expected %<,%>, %<;%> or %<}%> before numeric constant"
+#~ msgstr "ожидалось %<,%>, %<;%> или %<}%> перед числовой константой"
+
+#~ msgid "expected %<,%>, %<;%> or %<}%> before %qE"
+#~ msgstr "ожидалось %<,%>, %<;%> или %<}%> перед %qE"
+
+#~ msgid "expected %<,%>, %<;%> or %<}%> before %<#pragma%>"
+#~ msgstr "ожидалось %<,%>, %<;%> или %<}%> перед %<#pragma%>"
+
+#~ msgid "expected %<,%>, %<;%> or %<}%> before end of line"
+#~ msgstr "ожидалось %<,%>, %<;%> или %<}%> перед концом строки"
+
+#~ msgid "expected %<,%>, %<;%> or %<}%> before %<decltype%>"
+#~ msgstr "ожидалось %<,%>, %<;%> или %<}%> перед %<decltype%>"
+
+#~ msgid "expected %<,%>, %<;%> or %<}%> before %qs token"
+#~ msgstr "ожидалось %<,%>, %<;%> или %<}%> перед лексемой %qs"
+
+#~ msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%> at end of input"
+#~ msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%> в конце входного потока"
+
+#~ msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%> before %s'%c'"
+#~ msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%> перед %s'%c'"
+
+#~ msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%> перед %s'\\x%x'"
+
+#~ msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%> before string constant"
+#~ msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%> перед строковой константой"
+
+#~ msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%> before numeric constant"
+#~ msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%> перед числовой константой"
+
+#~ msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%> before %qE"
+#~ msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%> перед %qE"
+
+#~ msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%> before %<#pragma%>"
+#~ msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%> перед %<#pragma%>"
+
+#~ msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%> before end of line"
+#~ msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%> перед концом строки"
+
+#~ msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%> before %<decltype%>"
+#~ msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%> перед %<decltype%>"
+
+#~ msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%> before %qs token"
+#~ msgstr "ожидалось %<:%>, %<,%>, %<;%>, %<}%> или %<__attribute__%> перед лексемой %qs"
+
+#~ msgid "expected identifier or %<(%> at end of input"
+#~ msgstr "ожидался идентификатор или %<(%> в конце входного потока"
+
+#~ msgid "expected identifier or %<(%> before %s'%c'"
+#~ msgstr "ожидался идентификатор или %<(%> перед %s'%c'"
+
+#~ msgid "expected identifier or %<(%> before %s'\\x%x'"
+#~ msgstr "ожидался идентификатор или %<(%> перед %s'\\x%x'"
+
+#~ msgid "expected identifier or %<(%> before string constant"
+#~ msgstr "ожидался идентификатор или %<(%> перед строковой константой"
+
+#~ msgid "expected identifier or %<(%> before numeric constant"
+#~ msgstr "ожидался идентификатор или %<(%> перед числовой константой"
+
+#~ msgid "expected identifier or %<(%> before %qE"
+#~ msgstr "ожидался идентификатор или %<(%> перед %qE"
+
+#~ msgid "expected identifier or %<(%> before %<#pragma%>"
+#~ msgstr "ожидался идентификатор или %<(%> перед %<#pragma%>"
+
+#~ msgid "expected identifier or %<(%> before end of line"
+#~ msgstr "ожидался идентификатор или %<(%> перед концом строки"
+
+#~ msgid "expected identifier or %<(%> before %<decltype%>"
+#~ msgstr "ожидался идентификатор или %<(%> перед %<decltype%>"
+
+#~ msgid "expected identifier or %<(%> before %qs token"
+#~ msgstr "ожидался идентификатор или %<(%> перед лексемой %qs"
+
+#~ msgid "expected declaration specifiers or %<...%> at end of input"
+#~ msgstr "ожидались спецификаторы декларации или %<...%> в конце входного потока"
+
+#~ msgid "expected declaration specifiers or %<...%> before %s'%c'"
+#~ msgstr "ожидались спецификаторы декларации или %<...%> перед %s'%c'"
+
+#~ msgid "expected declaration specifiers or %<...%> before %s'\\x%x'"
+#~ msgstr "ожидались спецификаторы декларации или %<...%> перед %s'\\x%x'"
+
+#~ msgid "expected declaration specifiers or %<...%> before string constant"
+#~ msgstr "ожидались спецификаторы декларации или %<...%> перед строковой константой"
+
+#~ msgid "expected declaration specifiers or %<...%> before numeric constant"
+#~ msgstr "ожидались спецификаторы декларации или %<...%> перед числовой константой"
+
+#~ msgid "expected declaration specifiers or %<...%> before %qE"
+#~ msgstr "ожидались спецификаторы декларации или %<...%> перед %qE"
+
+#~ msgid "expected declaration specifiers or %<...%> before %<#pragma%>"
+#~ msgstr "ожидались спецификаторы декларации или %<...%> перед %<#pragma%>"
+
+#~ msgid "expected declaration specifiers or %<...%> before end of line"
+#~ msgstr "ожидались спецификаторы декларации или %<...%> перед концом строки"
+
+#~ msgid "expected declaration specifiers or %<...%> before %<decltype%>"
+#~ msgstr "ожидались спецификаторы декларации или %<...%> перед %<decltype%>"
+
+#~ msgid "expected declaration specifiers or %<...%> before %qs token"
+#~ msgstr "ожидались спецификаторы декларации или %<...%> перед лексемой %qs"
+
+#~ msgid "expected declaration or statement at end of input"
+#~ msgstr "ожидалась декларация или оператор в конце входного потока"
+
+#~ msgid "expected declaration or statement before %s'%c'"
+#~ msgstr "ожидалась декларация или оператор перед %s'%c'"
+
+#~ msgid "expected declaration or statement before %s'\\x%x'"
+#~ msgstr "ожидалась декларация или оператор перед %s'\\x%x'"
+
+#~ msgid "expected declaration or statement before string constant"
+#~ msgstr "ожидалась декларация или оператор перед строковой константой"
+
+#~ msgid "expected declaration or statement before numeric constant"
+#~ msgstr "ожидалась декларация или оператор перед числовой константой"
+
+#~ msgid "expected declaration or statement before %qE"
+#~ msgstr "ожидалась декларация или оператор перед %qE"
+
+#~ msgid "expected declaration or statement before %<#pragma%>"
+#~ msgstr "ожидалась декларация или оператор перед %<#pragma%>"
+
+#~ msgid "expected declaration or statement before end of line"
+#~ msgstr "ожидалась декларация или оператор перед концом строки"
+
+#~ msgid "expected declaration or statement before %<decltype%>"
+#~ msgstr "ожидалась декларация или оператор перед %<decltype%>"
+
+#~ msgid "expected declaration or statement before %qs token"
+#~ msgstr "ожидалась декларация или оператор перед лексемой %qs"
+
+#~ msgid "expected %<:%> or %<...%> at end of input"
+#~ msgstr "ожидалось %<:%> или %<...%> в конце входного потока"
+
+#~ msgid "expected %<:%> or %<...%> before %s'%c'"
+#~ msgstr "ожидалось %<:%> или %<...%> перед %s'%c'"
+
+#~ msgid "expected %<:%> or %<...%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<:%> или %<...%> перед %s'\\x%x'"
+
+#~ msgid "expected %<:%> or %<...%> before string constant"
+#~ msgstr "ожидалось %<:%> или %<...%> перед строковой константой"
+
+#~ msgid "expected %<:%> or %<...%> before numeric constant"
+#~ msgstr "ожидалось %<:%> или %<...%> перед числовой константой"
+
+#~ msgid "expected %<:%> or %<...%> before %qE"
+#~ msgstr "ожидалось %<:%> или %<...%> перед %qE"
+
+#~ msgid "expected %<:%> or %<...%> before %<#pragma%>"
+#~ msgstr "ожидалось %<:%> или %<...%> перед %<#pragma%>"
+
+#~ msgid "expected %<:%> or %<...%> before end of line"
+#~ msgstr "ожидалось %<:%> или %<...%> перед концом строки"
+
+#~ msgid "expected %<:%> or %<...%> before %<decltype%>"
+#~ msgstr "ожидалось %<:%> или %<...%> перед %<decltype%>"
+
+#~ msgid "expected %<:%> or %<...%> before %qs token"
+#~ msgstr "ожидалось %<:%> или %<...%> перед лексемой %qs"
+
+#~ msgid "expected identifier or %<*%> at end of input"
+#~ msgstr "ожидался идентификатор или %<*%> в конце входного потока"
+
+#~ msgid "expected identifier or %<*%> before %s'%c'"
+#~ msgstr "ожидался идентификатор или %<*%> перед %s'%c'"
+
+#~ msgid "expected identifier or %<*%> before %s'\\x%x'"
+#~ msgstr "ожидался идентификатор или %<*%> перед %s'\\x%x'"
+
+#~ msgid "expected identifier or %<*%> before string constant"
+#~ msgstr "ожидался идентификатор или %<*%> перед строковой константой"
+
+#~ msgid "expected identifier or %<*%> before numeric constant"
+#~ msgstr "ожидался идентификатор или %<*%> перед числовой константой"
+
+#~ msgid "expected identifier or %<*%> before %qE"
+#~ msgstr "ожидался идентификатор или %<*%> перед %qE"
+
+#~ msgid "expected identifier or %<*%> before %<#pragma%>"
+#~ msgstr "ожидался идентификатор или %<*%> перед %<#pragma%>"
+
+#~ msgid "expected identifier or %<*%> before end of line"
+#~ msgstr "ожидался идентификатор или %<*%> перед концом строки"
+
+#~ msgid "expected identifier or %<*%> before %<decltype%>"
+#~ msgstr "ожидался идентификатор или %<*%> перед %<decltype%>"
+
+#~ msgid "expected identifier or %<*%> before %qs token"
+#~ msgstr "ожидался идентификатор или %<*%> перед лексемой %qs"
+
+#~ msgid "expected statement before %s'%c'"
+#~ msgstr "ожидался оператор перед %s'%c'"
+
+#~ msgid "expected statement before %s'\\x%x'"
+#~ msgstr "ожидался оператор перед %s'\\x%x'"
+
+#~ msgid "expected statement before string constant"
+#~ msgstr "ожидался оператор перед строковой константой"
+
+#~ msgid "expected statement before numeric constant"
+#~ msgstr "ожидался оператор перед числовой константой"
+
+#~ msgid "expected statement before %qE"
+#~ msgstr "ожидался оператор перед %qE"
+
+#~ msgid "expected statement before %<#pragma%>"
+#~ msgstr "ожидался оператор перед %<#pragma%>"
+
+#~ msgid "expected statement before end of line"
+#~ msgstr "ожидался оператор перед концом строки"
+
+#~ msgid "expected statement before %<decltype%>"
+#~ msgstr "ожидался оператор перед %<decltype%>"
+
+#~ msgid "expected statement before %qs token"
+#~ msgstr "ожидался оператор перед лексемой %qs"
+
+#~ msgid "multiple iterating variables in fast enumeration at end of input"
+#~ msgstr "несколько переменных-итераторов в быстром перечислении в конце входного потока"
+
+#~ msgid "multiple iterating variables in fast enumeration before %s'%c'"
+#~ msgstr "несколько переменных-итераторов в быстром перечислении перед %s'%c'"
+
+#~ msgid "multiple iterating variables in fast enumeration before %s'\\x%x'"
+#~ msgstr "несколько переменных-итераторов в быстром перечислении перед %s'\\x%x'"
+
+#~ msgid "multiple iterating variables in fast enumeration before string constant"
+#~ msgstr "несколько переменных-итераторов в быстром перечислении перед строковой константой"
+
+#~ msgid "multiple iterating variables in fast enumeration before numeric constant"
+#~ msgstr "несколько переменных-итераторов в быстром перечислении перед числовой константой"
+
+#~ msgid "multiple iterating variables in fast enumeration before %qE"
+#~ msgstr "несколько переменных-итераторов в быстром перечислении перед %qE"
+
+#~ msgid "multiple iterating variables in fast enumeration before %<#pragma%>"
+#~ msgstr "несколько переменных-итераторов в быстром перечислении перед %<#pragma%>"
+
+#~ msgid "multiple iterating variables in fast enumeration before end of line"
+#~ msgstr "несколько переменных-итераторов в быстром перечислении перед концом строки"
+
+#~ msgid "multiple iterating variables in fast enumeration before %<decltype%>"
+#~ msgstr "несколько переменных-итераторов в быстром перечислении перед %<decltype%>"
+
+#~ msgid "multiple iterating variables in fast enumeration before %qs token"
+#~ msgstr "несколько переменных-итераторов в быстром перечислении перед лексемой %qs"
+
+#~ msgid "invalid iterating variable in fast enumeration at end of input"
+#~ msgstr "некорректная переменная-итератор в быстром перечислении в конце входного потока"
+
+#~ msgid "invalid iterating variable in fast enumeration before %s'%c'"
+#~ msgstr "некорректная переменная-итератор в быстром перечислении перед %s'%c'"
+
+#~ msgid "invalid iterating variable in fast enumeration before %s'\\x%x'"
+#~ msgstr "некорректная переменная-итератор в быстром перечислении перед %s'\\x%x'"
+
+#~ msgid "invalid iterating variable in fast enumeration before string constant"
+#~ msgstr "некорректная переменная-итератор в быстром перечислении перед строковой константой"
+
+#~ msgid "invalid iterating variable in fast enumeration before numeric constant"
+#~ msgstr "некорректная переменная-итератор в быстром перечислении перед числовой константой"
+
+#~ msgid "invalid iterating variable in fast enumeration before %qE"
+#~ msgstr "некорректная переменная-итератор в быстром перечислении перед %qE"
+
+#~ msgid "invalid iterating variable in fast enumeration before %<#pragma%>"
+#~ msgstr "некорректная переменная-итератор в быстром перечислении перед %<#pragma%>"
+
+#~ msgid "invalid iterating variable in fast enumeration before end of line"
+#~ msgstr "некорректная переменная-итератор в быстром перечислении перед концом строки"
+
+#~ msgid "invalid iterating variable in fast enumeration before %<decltype%>"
+#~ msgstr "некорректная переменная-итератор в быстром перечислении перед %<decltype%>"
+
+#~ msgid "invalid iterating variable in fast enumeration before %qs token"
+#~ msgstr "некорректная переменная-итератор в быстром перечислении перед лексемой %qs"
+
+#~ msgid "missing collection in fast enumeration at end of input"
+#~ msgstr "отсутствует составной объект в быстром перечислении в конце входного потока"
+
+#~ msgid "missing collection in fast enumeration before %s'%c'"
+#~ msgstr "отсутствует составной объект в быстром перечислении перед %s'%c'"
+
+#~ msgid "missing collection in fast enumeration before %s'\\x%x'"
+#~ msgstr "отсутствует составной объект в быстром перечислении перед %s'\\x%x'"
+
+#~ msgid "missing collection in fast enumeration before string constant"
+#~ msgstr "отсутствует составной объект в быстром перечислении перед строковой константой"
+
+#~ msgid "missing collection in fast enumeration before numeric constant"
+#~ msgstr "отсутствует составной объект в быстром перечислении перед числовой константой"
+
+#~ msgid "missing collection in fast enumeration before %qE"
+#~ msgstr "отсутствует составной объект в быстром перечислении перед %qE"
+
+#~ msgid "missing collection in fast enumeration before %<#pragma%>"
+#~ msgstr "отсутствует составной объект в быстром перечислении перед %<#pragma%>"
+
+#~ msgid "missing collection in fast enumeration before end of line"
+#~ msgstr "отсутствует составной объект в быстром перечислении перед концом строки"
+
+#~ msgid "missing collection in fast enumeration before %<decltype%>"
+#~ msgstr "отсутствует составной объект в быстром перечислении перед %<decltype%>"
+
+#~ msgid "missing collection in fast enumeration before %qs token"
+#~ msgstr "отсутствует составной объект в быстром перечислении перед лексемой %qs"
+
+#~ msgid "expected expression at end of input"
+#~ msgstr "ожидалось выражение в конце входного потока"
+
+#~ msgid "expected expression before %s'%c'"
+#~ msgstr "ожидалось выражение перед %s'%c'"
+
+#~ msgid "expected expression before %s'\\x%x'"
+#~ msgstr "ожидалось выражение перед %s'\\x%x'"
+
+#~ msgid "expected expression before string constant"
+#~ msgstr "ожидалось выражение перед строковой константой"
+
+#~ msgid "expected expression before numeric constant"
+#~ msgstr "ожидалось выражение перед числовой константой"
+
+#~ msgid "expected expression before %qE"
+#~ msgstr "ожидалось выражение перед %qE"
+
+#~ msgid "expected expression before %<#pragma%>"
+#~ msgstr "ожидалось выражение перед %<#pragma%>"
+
+#~ msgid "expected expression before end of line"
+#~ msgstr "ожидалось выражение перед концом строки"
+
+#~ msgid "expected expression before %<decltype%>"
+#~ msgstr "ожидалось выражение перед %<decltype%>"
+
+#~ msgid "expected expression before %qs token"
+#~ msgstr "ожидалось выражение перед лексемой %qs"
+
+#~ msgid "expected identifier or %<)%> at end of input"
+#~ msgstr "ожидался идентификатор или %<)%> в конце входного потока"
+
+#~ msgid "expected identifier or %<)%> before %s'%c'"
+#~ msgstr "ожидался идентификатор или %<)%> перед %s'%c'"
+
+#~ msgid "expected identifier or %<)%> before %s'\\x%x'"
+#~ msgstr "ожидался идентификатор или %<)%> перед %s'\\x%x'"
+
+#~ msgid "expected identifier or %<)%> before string constant"
+#~ msgstr "ожидался идентификатор или %<)%> перед строковой константой"
+
+#~ msgid "expected identifier or %<)%> before numeric constant"
+#~ msgstr "ожидался идентификатор или %<)%> перед числовой константой"
+
+#~ msgid "expected identifier or %<)%> before %qE"
+#~ msgstr "ожидался идентификатор или %<)%> перед %qE"
+
+#~ msgid "expected identifier or %<)%> before %<#pragma%>"
+#~ msgstr "ожидался идентификатор или %<)%> перед %<#pragma%>"
+
+#~ msgid "expected identifier or %<)%> before end of line"
+#~ msgstr "ожидался идентификатор или %<)%> перед концом строки"
+
+#~ msgid "expected identifier or %<)%> before %<decltype%>"
+#~ msgstr "ожидался идентификатор или %<)%> перед %<decltype%>"
+
+#~ msgid "expected identifier or %<)%> before %qs token"
+#~ msgstr "ожидался идентификатор или %<)%> перед лексемой %qs"
+
+#~ msgid "objective-c method declaration is expected at end of input"
+#~ msgstr "ожидалась декларация метода objective-c в конце входного потока"
+
+#~ msgid "objective-c method declaration is expected before %s'%c'"
+#~ msgstr "ожидалась декларация метода objective-c перед %s'%c'"
+
+#~ msgid "objective-c method declaration is expected before %s'\\x%x'"
+#~ msgstr "ожидалась декларация метода objective-c перед %s'\\x%x'"
+
+#~ msgid "objective-c method declaration is expected before string constant"
+#~ msgstr "ожидалась декларация метода objective-c перед строковой константой"
+
+#~ msgid "objective-c method declaration is expected before numeric constant"
+#~ msgstr "ожидалась декларация метода objective-c перед числовой константой"
+
+#~ msgid "objective-c method declaration is expected before %qE"
+#~ msgstr "ожидалась декларация метода objective-c перед %qE"
+
+#~ msgid "objective-c method declaration is expected before %<#pragma%>"
+#~ msgstr "ожидалась декларация метода objective-c перед %<#pragma%>"
+
+#~ msgid "objective-c method declaration is expected before end of line"
+#~ msgstr "ожидалась декларация метода objective-c перед концом строки"
+
+#~ msgid "objective-c method declaration is expected before %<decltype%>"
+#~ msgstr "ожидалась декларация метода objective-c перед %<decltype%>"
+
+#~ msgid "objective-c method declaration is expected before %qs token"
+#~ msgstr "ожидалась декларация метода objective-c перед лексемой %qs"
+
+#~ msgid "no type or storage class may be specified here, at end of input"
+#~ msgstr "в этом месте не может указываться ни тип, ни класс хранения, в конце входного потока"
+
+#~ msgid "no type or storage class may be specified here, before %s'%c'"
+#~ msgstr "в этом месте не может указываться ни тип, ни класс хранения, перед %s'%c'"
+
+#~ msgid "no type or storage class may be specified here, before %s'\\x%x'"
+#~ msgstr "в этом месте не может указываться ни тип, ни класс хранения, перед %s'\\x%x'"
+
+#~ msgid "no type or storage class may be specified here, before string constant"
+#~ msgstr "в этом месте не может указываться ни тип, ни класс хранения, перед строковой константой"
+
+#~ msgid "no type or storage class may be specified here, before numeric constant"
+#~ msgstr "в этом месте не может указываться ни тип, ни класс хранения, перед числовой константой"
+
+#~ msgid "no type or storage class may be specified here, before %qE"
+#~ msgstr "в этом месте не может указываться ни тип, ни класс хранения, перед %qE"
+
+#~ msgid "no type or storage class may be specified here, before %<#pragma%>"
+#~ msgstr "в этом месте не может указываться ни тип, ни класс хранения, перед %<#pragma%>"
+
+#~ msgid "no type or storage class may be specified here, before end of line"
+#~ msgstr "в этом месте не может указываться ни тип, ни класс хранения, перед концом строки"
+
+#~ msgid "no type or storage class may be specified here, before %<decltype%>"
+#~ msgstr "в этом месте не может указываться ни тип, ни класс хранения, перед %<decltype%>"
+
+#~ msgid "no type or storage class may be specified here, before %qs token"
+#~ msgstr "в этом месте не может указываться ни тип, ни класс хранения, перед лексемой %qs"
+
+#~ msgid "unknown property attribute at end of input"
+#~ msgstr "неизвестный атрибут свойства в конце входного потока"
+
+#~ msgid "unknown property attribute before %s'%c'"
+#~ msgstr "неизвестный атрибут свойства перед %s'%c'"
+
+#~ msgid "unknown property attribute before %s'\\x%x'"
+#~ msgstr "неизвестный атрибут свойства перед %s'\\x%x'"
+
+#~ msgid "unknown property attribute before string constant"
+#~ msgstr "неизвестный атрибут свойства перед строковой константой"
+
+#~ msgid "unknown property attribute before numeric constant"
+#~ msgstr "неизвестный атрибут свойства перед числовой константой"
+
+#~ msgid "unknown property attribute before %qE"
+#~ msgstr "неизвестный атрибут свойства перед %qE"
+
+#~ msgid "unknown property attribute before %<#pragma%>"
+#~ msgstr "неизвестный атрибут свойства перед %<#pragma%>"
+
+#~ msgid "unknown property attribute before end of line"
+#~ msgstr "неизвестный атрибут свойства перед концом строки"
+
+#~ msgid "unknown property attribute before %<decltype%>"
+#~ msgstr "неизвестный атрибут свойства перед %<decltype%>"
+
+#~ msgid "unknown property attribute before %qs token"
+#~ msgstr "неизвестный атрибут свойства перед лексемой %qs"
+
+#~ msgid "missing %<=%> (after %<getter%> attribute) at end of input"
+#~ msgstr "отсутствует %<=%> (после атрибута %<getter%>) в конце входного потока"
+
+#~ msgid "missing %<=%> (after %<getter%> attribute) before %s'%c'"
+#~ msgstr "отсутствует %<=%> (после атрибута %<getter%>) перед %s'%c'"
+
+#~ msgid "missing %<=%> (after %<getter%> attribute) before %s'\\x%x'"
+#~ msgstr "отсутствует %<=%> (после атрибута %<getter%>) перед %s'\\x%x'"
+
+#~ msgid "missing %<=%> (after %<getter%> attribute) before string constant"
+#~ msgstr "отсутствует %<=%> (после атрибута %<getter%>) перед строковой константой"
+
+#~ msgid "missing %<=%> (after %<getter%> attribute) before numeric constant"
+#~ msgstr "отсутствует %<=%> (после атрибута %<getter%>) перед числовой константой"
+
+#~ msgid "missing %<=%> (after %<getter%> attribute) before %<#pragma%>"
+#~ msgstr "отсутствует %<=%> (после атрибута %<getter%>) перед %<#pragma%>"
+
+#~ msgid "missing %<=%> (after %<getter%> attribute) before end of line"
+#~ msgstr "отсутствует %<=%> (после атрибута %<getter%>) перед концом строки"
+
+#~ msgid "missing %<=%> (after %<getter%> attribute) before %<decltype%>"
+#~ msgstr "отсутствует %<=%> (после атрибута %<getter%>) перед %<decltype%>"
+
+#~ msgid "missing %<=%> (after %<getter%> attribute) before %qs token"
+#~ msgstr "отсутствует %<=%> (после атрибута %<getter%>) перед лексемой %qs"
+
+#~ msgid "missing %<=%> (after %<setter%> attribute) at end of input"
+#~ msgstr "отсутствует %<=%> (после атрибута %<setter%>) в конце входного потока"
+
+#~ msgid "missing %<=%> (after %<setter%> attribute) before %s'%c'"
+#~ msgstr "отсутствует %<=%> (после атрибута %<setter%>) перед %s'%c'"
+
+#~ msgid "missing %<=%> (after %<setter%> attribute) before %s'\\x%x'"
+#~ msgstr "отсутствует %<=%> (после атрибута %<setter%>) перед %s'\\x%x'"
+
+#~ msgid "missing %<=%> (after %<setter%> attribute) before string constant"
+#~ msgstr "отсутствует %<=%> (после атрибута %<setter%>) перед строковой константой"
+
+#~ msgid "missing %<=%> (after %<setter%> attribute) before numeric constant"
+#~ msgstr "отсутствует %<=%> (после атрибута %<setter%>) перед числовой константой"
+
+#~ msgid "missing %<=%> (after %<setter%> attribute) before %qE"
+#~ msgstr "отсутствует %<=%> (после атрибута %<setter%>) перед %qE"
+
+#~ msgid "missing %<=%> (after %<setter%> attribute) before %<#pragma%>"
+#~ msgstr "отсутствует %<=%> (после атрибута %<setter%>) перед %<#pragma%>"
+
+#~ msgid "missing %<=%> (after %<setter%> attribute) before end of line"
+#~ msgstr "отсутствует %<=%> (после атрибута %<setter%>) перед концом строки"
+
+#~ msgid "missing %<=%> (after %<setter%> attribute) before %<decltype%>"
+#~ msgstr "отсутствует %<=%> (после атрибута %<setter%>) перед %<decltype%>"
+
+#~ msgid "missing %<=%> (after %<setter%> attribute) before %qs token"
+#~ msgstr "отсутствует %<=%> (после атрибута %<setter%>) перед лексемой %qs"
+
+#~ msgid "expected %<none%> or %<shared%> at end of input"
+#~ msgstr "ожидалось %<none%> или %<shared%> в конце входного потока"
+
+#~ msgid "expected %<none%> or %<shared%> before %s'%c'"
+#~ msgstr "ожидалось %<none%> или %<shared%> перед %s'%c'"
+
+#~ msgid "expected %<none%> or %<shared%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<none%> или %<shared%> перед %s'\\x%x'"
+
+#~ msgid "expected %<none%> or %<shared%> before string constant"
+#~ msgstr "ожидалось %<none%> или %<shared%> перед строковой константой"
+
+#~ msgid "expected %<none%> or %<shared%> before numeric constant"
+#~ msgstr "ожидалось %<none%> или %<shared%> перед числовой константой"
+
+#~ msgid "expected %<none%> or %<shared%> before %qE"
+#~ msgstr "ожидалось %<none%> или %<shared%> перед %qE"
+
+#~ msgid "expected %<none%> or %<shared%> before %<#pragma%>"
+#~ msgstr "ожидалось %<none%> или %<shared%> перед %<#pragma%>"
+
+#~ msgid "expected %<none%> or %<shared%> before %<decltype%>"
+#~ msgstr "ожидалось %<none%> или %<shared%> перед %<decltype%>"
+
+#~ msgid "expected %<none%> or %<shared%> before %qs token"
+#~ msgstr "ожидалось %<none%> или %<shared%> перед лексемой %qs"
+
+#~ msgid "expected integer expression at end of input"
+#~ msgstr "ожидалось целочисленное выражение в конце входного потока"
+
+#~ msgid "expected integer expression before %s'\\x%x'"
+#~ msgstr "ожидалось целочисленное выражение перед %s'\\x%x'"
+
+#~ msgid "expected integer expression before string constant"
+#~ msgstr "ожидалось целочисленное выражение перед строковой константой"
+
+#~ msgid "expected integer expression before numeric constant"
+#~ msgstr "ожидалось целочисленное выражение перед числовой константой"
+
+#~ msgid "expected integer expression before %qE"
+#~ msgstr "ожидалось целочисленное выражение перед %qE"
+
+#~ msgid "expected integer expression before %<#pragma%>"
+#~ msgstr "ожидалось целочисленное выражение перед %<#pragma%>"
+
+#~ msgid "expected integer expression before end of line"
+#~ msgstr "ожидалось целочисленное выражение перед концом строки"
+
+#~ msgid "expected integer expression before %<decltype%>"
+#~ msgstr "ожидалось целочисленное выражение перед %<decltype%>"
+
+#~ msgid "expected integer expression before %qs token"
+#~ msgstr "ожидалось целочисленное выражение перед лексемой %qs"
+
+#~ msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%> at end of input"
+#~ msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%> в конце входного потока"
+
+#~ msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%> before %s'%c'"
+#~ msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%> перед %s'%c'"
+
+#~ msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%> before %s'\\x%x'"
+#~ msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%> перед %s'\\x%x'"
+
+#~ msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%> before string constant"
+#~ msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%> перед строковой константой"
+
+#~ msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%> before numeric constant"
+#~ msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%> перед числовой константой"
+
+#~ msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%> before %qE"
+#~ msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%> перед %qE"
+
+#~ msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%> before %<#pragma%>"
+#~ msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%> перед %<#pragma%>"
+
+#~ msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%> before end of line"
+#~ msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%> перед концом строки"
+
+#~ msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%> before %<decltype%>"
+#~ msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%> перед %<decltype%>"
+
+#~ msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%> before %qs token"
+#~ msgstr "ожидалось %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> или %<max%> перед лексемой %qs"
+
+#~ msgid "invalid schedule kind at end of input"
+#~ msgstr "некорректный тип планирования в конце входного потока"
+
+#~ msgid "invalid schedule kind before %s'%c'"
+#~ msgstr "некорректный тип планирования перед %s'%c'"
+
+#~ msgid "invalid schedule kind before %s'\\x%x'"
+#~ msgstr "некорректный тип планирования перед %s'\\x%x'"
+
+#~ msgid "invalid schedule kind before string constant"
+#~ msgstr "некорректный тип планирования перед строковой константой"
+
+#~ msgid "invalid schedule kind before numeric constant"
+#~ msgstr "некорректный тип планирования перед числовой константой"
+
+#~ msgid "invalid schedule kind before %qE"
+#~ msgstr "некорректный тип планирования перед %qE"
+
+#~ msgid "invalid schedule kind before %<#pragma%>"
+#~ msgstr "некорректный тип планирования перед %<#pragma%>"
+
+#~ msgid "invalid schedule kind before end of line"
+#~ msgstr "некорректный тип планирования перед концом строки"
+
+#~ msgid "invalid schedule kind before %qs token"
+#~ msgstr "некорректный тип планирования перед лексемой %qs"
+
+#~ msgid "expected %<#pragma omp%> clause at end of input"
+#~ msgstr "ожидалась конструкция %<#pragma omp%> в конце входного потока"
+
+#~ msgid "expected %<#pragma omp%> clause before %s'%c'"
+#~ msgstr "ожидалась конструкция %<#pragma omp%> перед %s'%c'"
+
+#~ msgid "expected %<#pragma omp%> clause before %s'\\x%x'"
+#~ msgstr "ожидалась конструкция %<#pragma omp%> перед %s'\\x%x'"
+
+#~ msgid "expected %<#pragma omp%> clause before string constant"
+#~ msgstr "ожидалась конструкция %<#pragma omp%> перед строковой константой"
+
+#~ msgid "expected %<#pragma omp%> clause before numeric constant"
+#~ msgstr "ожидалась конструкция %<#pragma omp%> перед числовой константой"
+
+#~ msgid "expected %<#pragma omp%> clause before %qE"
+#~ msgstr "ожидалась конструкция %<#pragma omp%> перед %qE"
+
+#~ msgid "expected %<#pragma omp%> clause before %<#pragma%>"
+#~ msgstr "ожидалась конструкция %<#pragma omp%> перед %<#pragma%>"
+
+#~ msgid "expected %<#pragma omp%> clause before end of line"
+#~ msgstr "ожидалась конструкция %<#pragma omp%> перед концом строки"
+
+#~ msgid "expected %<#pragma omp%> clause before %qs token"
+#~ msgstr "ожидалась конструкция %<#pragma omp%> перед лексемой %qs"
+
+#~ msgid "invalid form of %<#pragma omp atomic%> at end of input"
+#~ msgstr "некорректный формат %<#pragma omp atomic%> в конце входного потока"
+
+#~ msgid "invalid form of %<#pragma omp atomic%> before %s'%c'"
+#~ msgstr "некорректный формат %<#pragma omp atomic%> перед %s'%c'"
+
+#~ msgid "invalid form of %<#pragma omp atomic%> before %s'\\x%x'"
+#~ msgstr "некорректный формат %<#pragma omp atomic%> перед %s'\\x%x'"
+
+#~ msgid "invalid form of %<#pragma omp atomic%> before string constant"
+#~ msgstr "некорректный формат %<#pragma omp atomic%> перед строковой константой"
+
+#~ msgid "invalid form of %<#pragma omp atomic%> before numeric constant"
+#~ msgstr "некорректный формат %<#pragma omp atomic%> перед числовой константой"
+
+#~ msgid "invalid form of %<#pragma omp atomic%> before %qE"
+#~ msgstr "некорректный формат %<#pragma omp atomic%> перед %qE"
+
+#~ msgid "invalid form of %<#pragma omp atomic%> before %<#pragma%>"
+#~ msgstr "некорректный формат %<#pragma omp atomic%> перед %<#pragma%>"
+
+#~ msgid "invalid form of %<#pragma omp atomic%> before end of line"
+#~ msgstr "некорректный формат %<#pragma omp atomic%> перед концом строки"
+
+#~ msgid "invalid form of %<#pragma omp atomic%> before %<decltype%>"
+#~ msgstr "некорректный формат %<#pragma omp atomic%> перед %<decltype%>"
+
+#~ msgid "invalid form of %<#pragma omp atomic%> before %qs token"
+#~ msgstr "некорректный формат %<#pragma omp atomic%> перед лексемой %qs"
+
+#~ msgid "invalid operator for %<#pragma omp atomic%> at end of input"
+#~ msgstr "некорректный оператор для %<#pragma omp atomic%> в конце входного потока"
+
+#~ msgid "invalid operator for %<#pragma omp atomic%> before %s'%c'"
+#~ msgstr "некорректный оператор для %<#pragma omp atomic%> перед %s'%c'"
+
+#~ msgid "invalid operator for %<#pragma omp atomic%> before %s'\\x%x'"
+#~ msgstr "некорректный оператор для %<#pragma omp atomic%> перед %s'\\x%x'"
+
+#~ msgid "invalid operator for %<#pragma omp atomic%> before string constant"
+#~ msgstr "некорректный оператор для %<#pragma omp atomic%> перед строковой константой"
+
+#~ msgid "invalid operator for %<#pragma omp atomic%> before numeric constant"
+#~ msgstr "некорректный оператор для %<#pragma omp atomic%> перед числовой константой"
+
+#~ msgid "invalid operator for %<#pragma omp atomic%> before %qE"
+#~ msgstr "некорректный оператор для %<#pragma omp atomic%> перед %qE"
+
+#~ msgid "invalid operator for %<#pragma omp atomic%> before %<#pragma%>"
+#~ msgstr "некорректный оператор для %<#pragma omp atomic%> перед %<#pragma%>"
+
+#~ msgid "invalid operator for %<#pragma omp atomic%> before end of line"
+#~ msgstr "некорректный оператор для %<#pragma omp atomic%> перед концом строки"
+
+#~ msgid "invalid operator for %<#pragma omp atomic%> before %<decltype%>"
+#~ msgstr "некорректный оператор для %<#pragma omp atomic%> перед %<decltype%>"
+
+#~ msgid "invalid operator for %<#pragma omp atomic%> before %qs token"
+#~ msgstr "некорректный оператор для %<#pragma omp atomic%> перед лексемой %qs"
+
+#~ msgid "expected %<(%> or end of line at end of input"
+#~ msgstr "ожидалось %<(%> или конец строки в конце входного потока"
+
+#~ msgid "expected %<(%> or end of line before %s'%c'"
+#~ msgstr "ожидалось %<(%> или конец строки перед %s'%c'"
+
+#~ msgid "expected %<(%> or end of line before %s'\\x%x'"
+#~ msgstr "ожидалось %<(%> или конец строки перед %s'\\x%x'"
+
+#~ msgid "expected %<(%> or end of line before string constant"
+#~ msgstr "ожидалось %<(%> или конец строки перед строковой константой"
+
+#~ msgid "expected %<(%> or end of line before numeric constant"
+#~ msgstr "ожидалось %<(%> или конец строки перед числовой константой"
+
+#~ msgid "expected %<(%> or end of line before %qE"
+#~ msgstr "ожидалось %<(%> или конец строки перед %qE"
+
+#~ msgid "expected %<(%> or end of line before %<#pragma%>"
+#~ msgstr "ожидалось %<(%> или конец строки перед %<#pragma%>"
+
+#~ msgid "expected %<(%> or end of line before end of line"
+#~ msgstr "ожидалось %<(%> или конец строки перед концом строки"
+
+#~ msgid "expected %<(%> or end of line before %<decltype%>"
+#~ msgstr "ожидалось %<(%> или конец строки перед %<decltype%>"
+
+#~ msgid "expected %<(%> or end of line before %qs token"
+#~ msgstr "ожидалось %<(%> или конец строки перед лексемой %qs"
+
+#~ msgid "for statement expected at end of input"
+#~ msgstr "ожидался оператор for в конце входного потока"
+
+#~ msgid "for statement expected before %s'%c'"
+#~ msgstr "ожидался оператор for перед %s'%c'"
+
+#~ msgid "for statement expected before %s'\\x%x'"
+#~ msgstr "ожидался оператор for перед %s'\\x%x'"
+
+#~ msgid "for statement expected before string constant"
+#~ msgstr "ожидался оператор for перед строковой константой"
+
+#~ msgid "for statement expected before numeric constant"
+#~ msgstr "ожидался оператор for перед числовой константой"
+
+#~ msgid "for statement expected before %qE"
+#~ msgstr "ожидался оператор for перед %qE"
+
+#~ msgid "for statement expected before %<#pragma%>"
+#~ msgstr "ожидался оператор for перед %<#pragma%>"
+
+#~ msgid "for statement expected before end of line"
+#~ msgstr "ожидался оператор for перед концом строки"
+
+#~ msgid "for statement expected before %<decltype%>"
+#~ msgstr "ожидался оператор for перед %<decltype%>"
+
+#~ msgid "for statement expected before %qs token"
+#~ msgstr "ожидался оператор for перед лексемой %qs"
+
+#~ msgid "expected iteration declaration or initialization at end of input"
+#~ msgstr "ожидалась декларация итерации или инициализация в конце входного потока"
+
+#~ msgid "expected iteration declaration or initialization before %s'%c'"
+#~ msgstr "ожидалась декларация итерации или инициализация перед %s'%c'"
+
+#~ msgid "expected iteration declaration or initialization before %s'\\x%x'"
+#~ msgstr "ожидалась декларация итерации или инициализация перед %s'\\x%x'"
+
+#~ msgid "expected iteration declaration or initialization before string constant"
+#~ msgstr "ожидалась декларация итерации или инициализация перед строковой константой"
+
+#~ msgid "expected iteration declaration or initialization before numeric constant"
+#~ msgstr "ожидалась декларация итерации или инициализация перед числовой константой"
+
+#~ msgid "expected iteration declaration or initialization before %qE"
+#~ msgstr "ожидалась декларация итерации или инициализация перед %qE"
+
+#~ msgid "expected iteration declaration or initialization before %<#pragma%>"
+#~ msgstr "ожидалась декларация итерации или инициализация перед %<#pragma%>"
+
+#~ msgid "expected iteration declaration or initialization before end of line"
+#~ msgstr "ожидалась декларация итерации или инициализация перед концом строки"
+
+#~ msgid "expected iteration declaration or initialization before %<decltype%>"
+#~ msgstr "ожидалась декларация итерации или инициализация перед %<decltype%>"
+
+#~ msgid "expected iteration declaration or initialization before %qs token"
+#~ msgstr "ожидалась декларация итерации или инициализация перед лексемой %qs"
+
+#~ msgid "increment of pointer to unknown structure"
+#~ msgstr "инкрементация указателя на неизвестную структуру"
+
+#~ msgid "decrement of pointer to unknown structure"
+#~ msgstr "декрементация указателя на неизвестную структуру"
+
+#~ msgid "missing initializer"
+#~ msgstr "пропущен инициализатор"
+
+#~ msgid "too many eh edges %i"
+#~ msgstr "слишком много eh дуг %i"
+
+#~ msgid "insn %d inside basic block %d but block_for_insn is NULL"
+#~ msgstr "RTL-инструкция %d - внутри блока %d, а block_for_insn=NULL"
+
+#~ msgid "insn %d inside basic block %d but block_for_insn is %i"
+#~ msgstr "RTL-инструкция %d - внутри блока %d, а block_for_insn=%i"
+
+#~ msgid "non-DECL_ONE_ONLY node in a same_comdat_group list"
+#~ msgstr "не-DECL_ONE_ONLY узел в списке same_comdat_group"
+
+#~ msgid "use -Wno-error=coverage-mismatch to tolerate the mismatch but performance may drop if the function is hot"
+#~ msgstr "use -Wno-error=coverage-mismatch чтобы игнорировать несоответствие, но производительность может упасть, если функция часто используется"
+
+#~ msgid "coverage mismatch ignored"
+#~ msgstr "несоответствие данных профилирования проигнорировано"
+
+#~ msgid "this can result in poorly optimized code"
+#~ msgstr "это может ухудшить оптимизацию кода"
+
+#~ msgid "multiple accesses to volatile structure member because of packed attribute"
+#~ msgstr "множественные доступы к элементу volatile структуры из-за атрибута packed"
+
+#~ msgid "multiple accesses to volatile structure bitfield because of packed attribute"
+#~ msgstr "множественные доступы к битовому полю volatile структуры из-за атрибута packed"
+
+#~ msgid "mis-aligned access used for structure member"
+#~ msgstr "неверное выравнивание при доступе к элементу структуры"
+
+#~ msgid "mis-aligned access used for structure bitfield"
+#~ msgstr "неверное выравнивание при доступе к битовому полю структуры"
+
+#~ msgid "when a volatile object spans multiple type-sized locations, the compiler must choose between using a single mis-aligned access to preserve the volatility, or using multiple aligned accesses to avoid runtime faults; this code may fail at runtime if the hardware does not allow this access"
+#~ msgstr "если volatile объект покрывает несколько позиций (размера, соответствующего типу) в памяти, компилятор должен выбирать между использованием одного неверно выровненного доступа (чтобы учесть спецификатор volatile) и множественными корректно выровненными доступами (чтобы избежать ошибок времени выполнения); этот код может дать ошибку времени выполнения, если аппаратура не поддерживает подобный доступ к памяти"
+
+#~ msgid "local frame unavailable (naked function?)"
+#~ msgstr "локальный кадр недоступен (naked функция?)"
+
+#~ msgid "assuming signed overflow does not occur when negating a division"
+#~ msgstr "предполагается что при смене знака результата деления не произошло переполнение"
+
+#~ msgid "can%'t seek PCH file: %m"
+#~ msgstr "ошибка позиционирования PCH файла: %m"
+
+#~ msgid "use of type %<%E%> with two mismatching declarations at field %<%E%>"
+#~ msgstr "использование типа %<%E%>, имеющего две несовместные декларации в поле %<%E%>"
+
+#~ msgid "field in mismatching type declared here"
+#~ msgstr "поле несовместного типа объявлено здесь"
+
+#~ msgid "type of field declared here"
+#~ msgstr "тип поля объявлен здесь"
+
+#~ msgid "type of mismatching field declared here"
+#~ msgstr "тип несовместного поля объявлен здесь"
+
+#~ msgid "enclosing parallel"
+#~ msgstr "объемлющая конструкция parallel"
+
+#~ msgid "the file is not in OpenScop format"
+#~ msgstr "файл - не в формате OpenScop"
+
+#~ msgid "the language is not recognized"
+#~ msgstr "язык не распознан"
+
+#~ msgid "parameters number in the scop file is different from the internal scop parameter number"
+#~ msgstr "число параметров в scop файле отличается от внутреннего числа параметров scop"
+
+#~ msgid "number of statements in the OpenScop file does not match the graphite internal statements number"
+#~ msgstr "число операторов в OpenScop файле не соответствует числу graphite внутренних операторов"
+
+#~ msgid "can%'t open %s for reading: %m"
+#~ msgstr "ошибка открытия %s на чтение: %m"
+
+#~ msgid "the graphite file read for scop %d does not contain a legal transform"
+#~ msgstr "graphite файл прочитанный для scop %d не содержит корректного преобразования"
+
+#~ msgid "cannot find LTO varpool in %s"
+#~ msgstr "не найден пул переменных LTO в %s"
+
+#~ msgid "unrecognized command line option \"%s\""
+#~ msgstr "некорректный ключ \"%s\""
+
+#~ msgid "malformed option -fplugin-arg-%s (multiple '=' signs)"
+#~ msgstr "некорректная опция -fplugin-arg-%s (более одного знака '=')"
+
+#~ msgid "corrupted profile info: edge count exceeds maximal count"
+#~ msgstr "испорчены данные профилирования: счетчик дуги превышает максимальное значение"
+
+#~ msgid "corrupted profile info: run_max * runs < sum_max"
+#~ msgstr "испорчены данные профилирования: run_max * runs < sum_max"
+
+#~ msgid "correcting inconsistent profile data"
+#~ msgstr "исправлены несогласованные данные профилирования"
+
+#~ msgid "try reducing the number of local variables"
+#~ msgstr "попробуйте уменьшить число локальных переменных"
+
+#~ msgid "use of memory input without lvalue in asm operand %d is deprecated"
+#~ msgstr "более не рекомендуется использовать входной операнд \"память\" без lvalue-выражения в операнде asm %d"
+
+#~ msgid "mudflap cannot be used together with link-time optimization"
+#~ msgstr "mudflap нельзя использовать вместе с оптимизацией времени компоновки"
+
+#~ msgid "-fstrict-volatile-bitfields disabled; it is incompatible with ABI versions < 2"
+#~ msgstr "ключ -fstrict-volatile-bitfields отменен; он несовместим с ABI версий < 2"
+
+#~ msgid "-ffunction-sections disabled; it makes profiling impossible"
+#~ msgstr "-ffunction-sections отменен, поскольку профилирование с ним невозможно"
+
+#~ msgid "unwind tables currently require a frame pointer for correctness"
+#~ msgstr "для корректного формирования таблица раскрутки стека требуется указатель кадра"
+
+#~ msgid "static chain in indirect gimple call"
+#~ msgstr "статическая цепочка в косвенном gimple вызове"
+
+#~ msgid "non-element sized vector shift of floating point vector"
+#~ msgstr "размер сдвига вещественного вектора не равен размеру элемента"
+
+#~ msgid "mudflap checking not yet implemented for ARRAY_RANGE_REF"
+#~ msgstr "mudflap-проверки еще для ARRAY_RANGE_REF еще не реализованы"
+
+#~ msgid "mudflap cannot track %qE in stub function"
+#~ msgstr "mudflap не может отслеживать %qE в stub-функциях"
+
+#~ msgid "mudflap cannot track unknown size extern %qE"
+#~ msgstr "mudflap не может отслеживать внешние %qE неизвестного размера"
+
+#~ msgid "mudflap: this language is not supported"
+#~ msgstr "mudflap: этот язык не поддерживается"
+
+#~ msgid "excess def operand for stmt"
+#~ msgstr "избыточный def операнд для оператора"
+
+#~ msgid "def operand missing for stmt"
+#~ msgstr "отсутствует def операнд для оператора"
+
+#~ msgid "cl_target_option size mismatch in LTO reader and writer"
+#~ msgstr "несоответствие размера cl_target_option в функциях чтения и записи LTO"
+
+#~ msgid "cl_optimization size mismatch in LTO reader and writer"
+#~ msgstr "несоответствие размера cl_optimization в функциях чтения и записи LTO"
+
+#~ msgid "%qD is deprecated (declared at %s:%d): %s"
+#~ msgstr "%qD устаревшее, (декларация в %s:%d): %s"
+
+#~ msgid "%qD is deprecated (declared at %s:%d)"
+#~ msgstr "%qD устаревшее, (декларация в %s:%d)"
+
+#~ msgid "%qE is deprecated (declared at %s:%d): %s"
+#~ msgstr "%qE устаревшее, (декларация в %s:%d): %s"
+
+#~ msgid "%qE is deprecated (declared at %s:%d)"
+#~ msgstr "%qE устаревшее, (декларация в %s:%d)"
+
+#~ msgid "type is deprecated (declared at %s:%d): %s"
+#~ msgstr "устаревший тип (декларация в %s:%d): %s"
+
+#~ msgid "type is deprecated (declared at %s:%d)"
+#~ msgstr "поддержка данного типа будет исключена в будущих версиях (декларация в %s:%d)"
+
+#~ msgid "correcting inconsistent value profile: %s profiler overall count (%d) does not match BB count (%d)"
+#~ msgstr "исправлен некорректный профиль значений: общий счётчик профиля %s (%d) не соответствует BB count (%d)"
+
+#~ msgid "Inconsistent profile: indirect call target (%d) does not exist"
+#~ msgstr "Некорректный профиль: цель косвенного вызова (%d) не существует"
+
+#~ msgid "Skipping target %s with mismatching types for icall "
+#~ msgstr "Пропускается цель %s с несовместимыми типами для icall "
+
+#~ msgid "vector %s %s domain error, in %s at %s:%u"
+#~ msgstr "вектор %s %s ошибка области определения, в in %s на %s:%u"
+
+#~ msgid "transaction_wrap argument is not a function"
+#~ msgstr "аргумент transaction_wrap - не функция"
+
+#~ msgid "-Werror=normalized=: set -Wnormalized=nfc"
+#~ msgstr "-Werror=normalized=: установите -Wnormalized=nfc"
+
+#~ msgid "can%'t seek in %s: %m"
+#~ msgstr "ошибка позиционирования в %s: %m"
+
+#~ msgid "malformed #pragma extern_prefix, ignored"
+#~ msgstr "неверный синтаксис #pragma extern_prefix, директива проигнорирована"
+
+#~ msgid "junk at end of %<#pragma extern_prefix%>"
+#~ msgstr "мусор в конце директивы %<#pragma extern_prefix%>"
+
+#~ msgid "#pragma extern_prefix not supported on this target"
+#~ msgstr "#pragma extern_prefix для этой платформы не поддерживается"
+
+#~ msgid "internal and protected visibility attributes not supported in this configuration; ignored"
+#~ msgstr "атрибуты видимости internal и protected не поддерживаются для этой конфигурации; игнорируются"
+
+#~ msgid "FPA is unsupported in the AAPCS"
+#~ msgstr "FPA не поддерживается в AAPCS"
+
+#~ msgid "iWMMXt and hardware floating point"
+#~ msgstr "iWMMXt и аппаратная плавающая точка"
+
+#~ msgid "Thumb-2 iWMMXt"
+#~ msgstr "Thumb-2 iWMMXt"
+
+#~ msgid "the mangling of %<va_list%> has changed in GCC 4.4"
+#~ msgstr "разборка %<va_list%> изменилась в GCC 4.4"
+
+#~ msgid "static variable %q+D is marked dllimport"
+#~ msgstr "статическая переменная %q+D помечена как dllimport"
+
+#~ msgid "that particular -g option is invalid with -maout and -melinux"
+#~ msgstr "заданный ключ -g несовместим с -maout и -melinux"
+
+#~ msgid "unwind tables currently require either a frame pointer or %saccumulate-outgoing-args%s for correctness"
+#~ msgstr "таблицы раскрутки стека в настоящее время требуют либо указатель кадра, либо %saccumulate-outgoing-args%s для корректной работы"
+
+#~ msgid "ms_abi attribute requires -maccumulate-outgoing-args or subtarget optimization implying it"
+#~ msgstr "атрибут ms_abi требует -maccumulate-outgoing-args или оптимизацию целевой платформы, которая подразумевает его"
  
-#, fuzzy
  #~ msgid "%q+D:'selectany' attribute applies only to initialized objects"
-#~ msgstr "атрибут %qs допустим только для переменных"
+#~ msgstr "атрибут %q+D:'selectany' применяется только к инициализированным объектам"
  
  #~ msgid "%q+D causes a section type conflict"
  #~ msgstr "%q+D дает конфликт типов секций"
  
-#, fuzzy
  #~ msgid "-fPIC ignored for target (all code is position independent)"
-#~ msgstr "ключ -f%s проигнорирован для целевой машины (весь код позиционно-независимый)"
+#~ msgstr "ключ -fPIC проигнорирован для целевой машины (весь код позиционно-независим)"
  
  #~ msgid "-f%s ignored for target (all code is position independent)"
  #~ msgstr "ключ -f%s проигнорирован для целевой машины (весь код позиционно-независимый)"
@@ -61755,21 +66920,74 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "-mbnu210 is ignored (option is obsolete)"
  #~ msgstr "устаревший ключ -mbnu210 проигнорирован"
  
-#, fuzzy
+#~ msgid "the %<interrupt%> attribute requires %<-msoft-float%>"
+#~ msgstr "атрибут %<interrupt%> требует использования ключа %<-msoft-float%>"
+
+#~ msgid "-munix=98 option required for C89 Amendment 1 features.\n"
+#~ msgstr "опция -munix=98 требуется для C89 Amendment 1 возможностей.\n"
+
  #~ msgid "invalid AE type specified (%s)"
-#~ msgstr "неверный аргумент для %qs"
+#~ msgstr "задан некорректный AE тип (%s)"
+
+#~ msgid "invalid mul type specified (%s) - expected mac, mul or none"
+#~ msgstr "задан некорректный mul тип (%s) - ожидалось mac, mul или ничего"
+
+#~ msgid "unexpected mode %s encountered in picochip_emit_save_register"
+#~ msgstr "неожиданный режим %s встретился в picochip_emit_save_register"
+
+#~ msgid "defaulting to stack for %s register creation"
+#~ msgstr "используется умолчание - стек для создания регистра %s"
+
+#~ msgid "LCFI labels have already been deferred"
+#~ msgstr "LCFI метки уже были отложены"
+
+#~ msgid "LM label has already been deferred"
+#~ msgstr "LM метка уже была отложена"
+
+#~ msgid "LCFI labels have already been deferred."
+#~ msgstr "LCFI метки уже были отложены."
+
+#~ msgid "picochip_asm_output_opcode - Found multiple lines in VLIW packet %s"
+#~ msgstr "picochip_asm_output_opcode - Найдены несколько строк в VLIW пакете %s"
+
+#~ msgid "picochip_asm_output_opcode - can%'t output unknown operator %c"
+#~ msgstr "picochip_asm_output_opcode - невозможно вывести неизвестный оператор %c"
+
+#~ msgid "%s: at least one operand can%'t be handled"
+#~ msgstr "%s: по крайней мере один операнд не может быть обработан"
+
+#~ msgid "unknown short branch in %s (type %d)"
+#~ msgstr "неизвестный короткий переход в %s (тип %d)"
+
+#~ msgid "unknown long branch in %s (type %d)"
+#~ msgstr "неизвестный длинный переход в %s (тип %d)"
+
+#~ msgid "PUT uses port array index %d, which is out of range [%d..%d)"
+#~ msgstr "PUT использует индекс %d массива портов, оказавшийся вне диапазона [%d..%d)"
+
+#~ msgid "GET uses port array index %d, which is out of range [%d..%d)"
+#~ msgstr "GET использует индекс %d массива портов, оказавшийся вне диапазона [%d..%d)"
+
+#~ msgid "too many ALU instructions emitted (%d)"
+#~ msgstr "выдано слишком много инструкций ALU (%d)"
  
-#, fuzzy
  #~ msgid "%s: Second source operand is not a constant"
-#~ msgstr "операнд с кодом 'o' - не константа"
+#~ msgstr "%s: Второй исходный операнд не константа"
  
-#, fuzzy
  #~ msgid "%s: Third source operand is not a constant"
-#~ msgstr "операнд с кодом 'o' - не константа"
+#~ msgstr "%s: Третий исходный операнд не константа"
  
-#, fuzzy
  #~ msgid "%s: Fourth source operand is not a constant"
-#~ msgstr "операнд с кодом 'o' - не константа"
+#~ msgstr "%s: Четвертый исходный операнд не константа"
+
+#~ msgid "%s (disable warning using -mno-inefficient-warnings)"
+#~ msgstr "%s (отключите предупреждение посредством -mno-inefficient-warnings)"
+
+#~ msgid "-maix64 and POWER architecture are incompatible"
+#~ msgstr "ключ -maix64 несовместим с архитектурой POWER"
+
+#~ msgid "-m64 not supported in this configuration"
+#~ msgstr "ключ -m64 в этой конфигурации не поддерживается"
  
  #~ msgid "RETURN_ADDRESS_OFFSET not supported"
  #~ msgstr "RETURN_ADDRESS_OFFSET не поддерживается"
@@ -61777,57 +66995,38 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "-mcall-aixdesc must be big endian"
  #~ msgstr "ключ -mcall-aixdesc требует прямого порядка байт"
  
-#~ msgid "useless %<__thread%> in empty declaration"
-#~ msgstr "бесполезное %<__thread%> в пустой декларации"
-
-#, fuzzy
-#~ msgid "the size of array %qE can%'t be evaluated"
-#~ msgstr "ISO C90 не поддерживает массив %qs, размер которого нельзя определить"
-
-#, fuzzy
-#~ msgid "the size of array can %'t be evaluated"
-#~ msgstr "размер типа невозможно вычислить явно"
-
-#~ msgid "function definition declared %<__thread%>"
-#~ msgstr "определение функции со спецификатором %<__thread%>"
-
-#~ msgid "%<%s %E%> declared inside parameter list"
-#~ msgstr "декларация %<%s %E%> внутри списка параметров"
+#~ msgid "ambiguous overload for ternary %<operator?:%> in %<%E ? %E : %E%>"
+#~ msgstr "неоднозначная перегрузка для трехместного %<operator?:%> в %<%E ? %E : %E%>"
  
-#~ msgid "anonymous %s declared inside parameter list"
-#~ msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %s Ð±ÐµÐ· Ð¸Ð¼ÐµÐ½Ð¸ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\81Ð¿Ð¸Ñ\81ÐºÐ° Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð¾Ð²"
+#~ msgid "ambiguous overload for %<operator%s%> in %<%E%s%>"
+#~ msgstr "Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ³Ñ\80Ñ\83Ð·ÐºÐ° Ð´Ð»Ñ\8f %<operator%s%> Ð² %<%E%s%>"
  
-#~ msgid "its scope is only this definition or declaration, which is probably not what you want"
-#~ msgstr "Ð¾Ð±Ð»Ð°Ñ\81Ñ\82Ñ\8c Ð´ÐµÐ¹Ñ\81Ñ\82Ð²Ð¸Ñ\8f Ñ\82Ð¸Ð¿Ð° - Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð°Ð½Ð½Ð°Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f Ð¸Ð»Ð¸ Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ðµ, Ñ\87Ñ\82Ð¾ Ð¼Ð¾Ð¶ÐµÑ\82 Ð½Ðµ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ð¾Ð²Ð°Ñ\82Ñ\8c Ð²Ð°Ñ\88Ð¸Ð¼ Ð½Ð°Ð¼ÐµÑ\80ÐµÐ½Ð¸Ñ\8fÐ¼"
+#~ msgid "ambiguous overload for %<operator[]%> in %<%E[%E]%>"
+#~ msgstr "Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ³Ñ\80Ñ\83Ð·ÐºÐ° Ð´Ð»Ñ\8f %<operator[]%> Ð² %<%E[%E]%>"
  
-#~ msgid "%<__thread%> used with %qE"
-#~ msgstr "спецификатор %<__thread%> использован с %qE"
+#~ msgid "ambiguous overload for %<operator%s%> in %<%E %s %E%>"
+#~ msgstr "неоднозначная перегрузка для %<operator%s%> в %<%E %s %E%>"
  
-#~ msgid "increment of pointer to unknown structure"
-#~ msgstr "Ð¸Ð½ÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð°Ñ\86Ð¸Ñ\8f Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\83Ñ\8e Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ñ\83Ñ\80Ñ\83"
+#~ msgid "ambiguous overload for %<operator%s%> in %<%s%E%>"
+#~ msgstr "Ð½ÐµÐ¾Ð´Ð½Ð¾Ð·Ð½Ð°Ñ\87Ð½Ð°Ñ\8f Ð¿ÐµÑ\80ÐµÐ³Ñ\80Ñ\83Ð·ÐºÐ° Ð´Ð»Ñ\8f %<operator%s%> Ð² %<%s%E%>"
  
-#~ msgid "decrement of pointer to unknown structure"
-#~ msgstr "Ð´ÐµÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð°Ñ\86Ð¸Ñ\8f Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð½Ð° Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\83Ñ\8e Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ñ\83Ñ\80Ñ\83"
+#~ msgid "selected for placement delete"
+#~ msgstr "Ð²Ñ\8bÐ±Ñ\80Ð°Ð½Ð¾ Ð´Ð»Ñ\8f Ñ\83Ð´Ð°Ð»ÐµÐ½Ð¸Ñ\8f Ñ\80Ð°Ð·Ð¼ÐµÑ\89ÐµÐ½Ð¸Ñ\8f"
  
-#, fuzzy
  #~ msgid "%q+#D is private"
-#~ msgstr "`%+#D' - частный (private) элемент"
+#~ msgstr "%q+#D - private"
  
-#, fuzzy
  #~ msgid "%q+#D is protected"
-#~ msgstr "`%+#D' - защищенный (protected) элемент"
+#~ msgstr "%q+#D - protected"
  
-#, fuzzy
  #~ msgid "  initializing argument %P of %q+D"
-#~ msgstr "  Ð¿Ñ\80Ð¸ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ %P -Ð³Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %qD"
+#~ msgstr "  Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %P Ð¸Ð· %q+D"
  
-#, fuzzy
  #~ msgid "scoped enum %qT will not promote to an integral type in a future version of GCC"
-#~ msgstr "ÐºÐ»Ð°Ñ\81Ñ\81 %qT Ð±Ñ\83Ð´ÐµÑ\82 Ñ\80Ð°Ñ\81Ñ\81Ð¼Ð°Ñ\82Ñ\80Ð¸Ð²Ð°Ñ\82Ñ\8cÑ\81Ñ\8f ÐºÐ°Ðº Ð¿Ð¾Ñ\87Ñ\82Ð¸ Ð¿Ñ\83Ñ\81Ñ\82Ð¾Ð¹ Ð² Ð±Ñ\83Ð´Ñ\83Ñ\89Ð¸Ñ\85 Ð²ÐµÑ\80Ñ\81Ð¸Ñ\8fÑ\85 GCC"
+#~ msgstr "ÐºÐ¾Ð½Ñ\82ÐµÐºÑ\81Ñ\82Ð½Ñ\8bÐ¹ enum %qT Ð½Ðµ Ð±Ñ\83Ð´ÐµÑ\82 Ð¿Ð¾Ð²Ñ\8bÑ\88Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ð´Ð¾ Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° Ð² Ð±Ñ\83Ð´Ñ\83Ñ\89ÐµÐ¹ Ð²ÐµÑ\80Ñ\81Ð¸Ð¸ GCC"
  
-#, fuzzy
  #~ msgid "  in call to %q+D"
-#~ msgstr "  в вызове %qD"
+#~ msgstr "  в вызове %q+D"
  
  #~ msgid "offset of empty base %qT may not be ABI-compliant and maychange in a future version of GCC"
  #~ msgstr "смещение пустой базы %qT может быть несовместимо с ABI и может быть изменено в будущих версиях GCC"
@@ -61835,6 +67034,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "class %qT will be considered nearly empty in a future version of GCC"
  #~ msgstr "класс %qT будет рассматриваться как почти пустой в будущих версиях GCC"
  
+#~ msgid "%q+D declared to take non-const reference cannot be defaulted in the class body"
+#~ msgstr "%q+D декларировано принимать неконстантные ссылки, не может быть подразумеваемым в теле класса"
+
  #~ msgid "offset of virtual base %qT is not ABI-compliant and may change in a future version of GCC"
  #~ msgstr "смещение виртуальной базы %qT несовместимо с ABI и может быть изменено в будущих версиях GCC"
  
@@ -61850,57 +67052,41 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "layout of classes derived from empty class %qT may change in a future version of GCC"
  #~ msgstr "представление классов, производных от пустого класса %qT, может измениться в будущих версиях GCC"
  
-#, fuzzy
+#~ msgid "%qE implicitly determined as %<firstprivate%> has reference type"
+#~ msgstr "%qE неявно определяется как %<firstprivate%> имеет ссылочный тип"
+
  #~ msgid "  candidate conversions include %qD"
-#~ msgstr "  возможные преобразования - %qD и %qD"
+#~ msgstr "  возможные преобразования - %qD"
  
-#, fuzzy
  #~ msgid "variable %q+D set but not used"
-#~ msgstr "Ð¼ÐµÑ\82ÐºÐ° %q+D определена, но не используется"
+#~ msgstr "Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %q+D определена, но не используется"
  
-#, fuzzy
  #~ msgid "declaration of %qF has a different exception specifier"
-#~ msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qF Ð·Ð°Ð´Ð°ÐµÑ\82 Ð´Ñ\80Ñ\83Ð³Ð¸Ðµ Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÐµ Ñ\81Ð¸Ñ\82Ñ\83Ð°Ñ\86Ð¸Ð¸"
+#~ msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %qF Ð¸Ð¼ÐµÐµÑ\82 Ð´Ñ\80Ñ\83Ð³Ð¾Ð¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð¸Ñ\81ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ð¹"
  
-#, fuzzy
  #~ msgid "new declaration %q#D"
-#~ msgstr "новая декларация `%#D'"
+#~ msgstr "новая декларация %#D"
  
-#, fuzzy
  #~ msgid "previous declaration of %q+#D"
-#~ msgstr "предыдущая декларация %qD"
+#~ msgstr "предыдущая декларация %q+#D"
  
-#, fuzzy
  #~ msgid "declaration of C function %q#D conflicts with"
-#~ msgstr "декларация C-функции `%#D' противоречит"
-
-#, fuzzy
-#~ msgid "previous declaration %q+#D here"
-#~ msgstr "предыдущей декларации `%#D', которая находится здесь"
+#~ msgstr "декларация C-функции %q#D противоречит"
  
-#, fuzzy
  #~ msgid "%q+D has a previous declaration as %q#D"
-#~ msgstr "%qD был(а) ранее декларирован(а) как `%#D'"
+#~ msgstr "%q+D ранее декларирован как %q#D"
  
-#, fuzzy
  #~ msgid "declaration of namespace %qD conflicts with"
-#~ msgstr "декларация `namespace %D' противоречит"
+#~ msgstr "декларация namespace %qD противоречит"
  
-#, fuzzy
  #~ msgid "conflicts with new declaration with %qL linkage"
-#~ msgstr "ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83ÐµÑ\82 Ñ\81 Ð½Ð¾Ð²Ð¾Ð¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸ÐµÐ¹ Ñ\81 Ð¿Ñ\80Ð¸Ð²Ñ\8fÐ·ÐºÐ¾Ð¹ %L"
+#~ msgstr "Ð¿Ñ\80Ð¾Ñ\82Ð¸Ð²Ð¾Ñ\80ÐµÑ\87Ð¸Ñ\82 Ð½Ð¾Ð²Ð¾Ð¹ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\81 %qL Ð¿Ñ\80Ð¸Ð²Ñ\8fÐ·ÐºÐ¾Ð¹"
  
-#, fuzzy
  #~ msgid "after previous declaration %q+D"
-#~ msgstr "предыдущая декларация %q+D"
+#~ msgstr "после предыдущей декларации %q+D"
  
-#, fuzzy
  #~ msgid "%q+D: visibility attribute ignored because it"
-#~ msgstr "%J%qD: атрибут видимости игнорируется, поскольку он"
-
-#, fuzzy
-#~ msgid "conflicts with previous declaration here"
-#~ msgstr "%Jпротиворечит предыдущей декларации здесь"
+#~ msgstr "%q+D: атрибут видимости игнорируется, поскольку он"
  
  #~ msgid "jump to label %q+D"
  #~ msgstr "переход по метке %q+D"
@@ -61911,27 +67097,29 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "%q#D is not a static member of %q#T"
  #~ msgstr "%q#D не является статическим элементом %q#T"
  
+#~ msgid "template header not allowed in member definition of explicitly specialized class"
+#~ msgstr "заголовок шаблона недопустим в определении члена явно специализированного класса"
+
  #~ msgid "variable-sized object %qD may not be initialized"
  #~ msgstr "инициализация объекта %qD переменного размера недопустима"
  
+#~ msgid "%qD cannot be thread-local because it has non-trivial type %qT"
+#~ msgstr "%qD не может быть локально-поточным, поскольку имеет нетривиальный тип %qT"
+
+#~ msgid "%qD is thread-local and so cannot be dynamically initialized"
+#~ msgstr "%qD является локально-поточным, поэтому не может быть динамически инициализирован"
+
  #~ msgid "%qD cannot be initialized by a non-constant expression when being declared"
  #~ msgstr "во время декларации не допускается инициализировать %qD неконстантным выражением"
  
-#, fuzzy
  #~ msgid "declaration of %qD as array of %<auto%>"
-#~ msgstr "имя %qs описано как массив элементов типа void"
-
-#, fuzzy
-#~ msgid "%qs declared as function returning an abstract class type"
-#~ msgstr "%qs объявлена как функция, возвращающая массив"
+#~ msgstr "декларация %qD как массива %<auto%>"
  
-#, fuzzy
  #~ msgid "can%'t initialize friend function %qs"
-#~ msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f friend-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs"
+#~ msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c friend-Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8e %qs"
  
-#, fuzzy
  #~ msgid "both %<volatile%> and %<constexpr%> cannot be used here"
-#~ msgstr "Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ñ\8b Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ñ\8b %<short%> Ð¸ %<double%>"
+#~ msgstr "Ð¸ %<volatile%> Ð¸ %<constexpr%> Ð½Ðµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8cÑ\81Ñ\8f Ð·Ð´ÐµÑ\81Ñ\8c"
  
  #~ msgid "size of array %qs is too large"
  #~ msgstr "размер массива %qs слишком велик"
@@ -61948,39 +67136,35 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "  in instantiation of template %qT"
  #~ msgstr "  в конкретизации шаблона %qT"
  
+#~ msgid "default argument for %q#D has type %qT"
+#~ msgstr "аргумент по умолчанию для %q#D имеет тип %qT"
+
+#~ msgid "default argument for parameter of type %qT has type %qT"
+#~ msgstr "аргумент по умолчанию для параметра типа %qT имеет тип %qT"
+
  #~ msgid "no previous declaration for %q+D"
  #~ msgstr "отсутствует предварительная декларация %q+D"
  
-#, fuzzy
  #~ msgid "parameter %q+D set but not used"
-#~ msgstr "Ð¼ÐµÑ\82ÐºÐ° %q+D Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð°, но не используется"
+#~ msgstr "Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80 %q+D Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½, но не используется"
  
  #~ msgid "field initializer is not constant"
  #~ msgstr "инициализатор поля не является константой"
  
-#, fuzzy
  #~ msgid "uninitialized member %qD with %<const%> type %qT"
-#~ msgstr "неинициализированный элемент %qD константного типа %qT"
+#~ msgstr "неинициализирован элемент %qD с %<const%> типом %qT"
  
-#, fuzzy
  #~ msgid "uninitialized reference member %qD"
  #~ msgstr "инициализирован элемент-ссылка %qD"
  
-#, fuzzy
-#~ msgid "ISO C++ does not support variable-length array types"
-#~ msgstr "ISO C не поддерживает целочисленные комплексные типы"
-
-#, fuzzy
  #~ msgid "non-constant array size in new, unable to verify length of initializer-list"
-#~ msgstr "неконстантный индекс массива в инициализаторе"
+#~ msgstr "неконстантный размер массива в new, невозможно проверить длину списка инициализации"
  
-#, fuzzy
  #~ msgid "uninitialized non-static const member %q#D"
-#~ msgstr "не инициализирован константный элемент %qD"
+#~ msgstr "неинициализированный нестатический константный элемент %q#D"
  
-#, fuzzy
  #~ msgid "uninitialized non-static reference member %q#D"
-#~ msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82-Ñ\81Ñ\81Ñ\8bÐ»ÐºÐ° %qD"
+#~ msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹ Ð½ÐµÑ\81Ñ\82Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ñ\81Ñ\81Ñ\8bÐ»Ð¾Ñ\87Ð½Ñ\8bÐ¹ Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82 %q#D"
  
  #~ msgid "vtable layout for class %qT may not be ABI-compliantand may change in a future version of GCC due to implicit virtual destructor"
  #~ msgstr "структура vtable для класса %qT может быть несовместима с ABI и может быть изменена в будущих версиях GCC из-за неявного виртуального деструктора"
@@ -61991,82 +67175,77 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "%q#D conflicts with previous using declaration %q#D"
  #~ msgstr "%q#D конфликтует с предыдущим использованием декларации %q#D"
  
-#, fuzzy
+#~ msgid "%<%T::%D%> names constructor"
+#~ msgstr "%%<%T::%D%> обозначает конструктор"
+
  #~ msgid "unable to find string literal operator %qD"
-#~ msgstr "не найден регистр класса %qs для выталкивания в память"
+#~ msgstr "невозможно найти оператор строкового литерала %qD"
  
-#, fuzzy
  #~ msgid "ISO C++ does not allow initializers in lambda expression capture lists"
-#~ msgstr "ISO C++ Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°ÐµÑ\82 Ð½Ð°Ð·Ð½Ð°Ñ\87ÐµÐ½Ð½Ñ\8bÐµ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ñ\8b"
+#~ msgstr "ISO C++ Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82 Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80Ñ\8b Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐ°Ñ\85 lambda expression capture"
  
-#, fuzzy
  #~ msgid "range-based %<for%> loops are not allowed in C++98 mode"
-#~ msgstr "стандартные преобразования в данном контексте недопустимы"
+#~ msgstr "range-based %<for%> циклы не допускаются в C++98 режиме"
  
-#, fuzzy
  #~ msgid "%qD is not an enumerator-name"
-#~ msgstr "%qT не является пространством имён"
+#~ msgstr "%qD не является enumerator-name"
  
  #~ msgid "deprecated use of default argument for parameter of non-function"
  #~ msgstr "устаревшее использование аргумента по умолчанию в качестве параметра не-функции"
  
-#, fuzzy
  #~ msgid "declaration of %q+#D"
-#~ msgstr "декларация `%#D'"
+#~ msgstr "декларация %q+#D"
  
-#, fuzzy
  #~ msgid " shadows template parm %q+#D"
-#~ msgstr "параметр шаблона `%#D'"
+#~ msgstr "затеняет параметр шаблона %q+#D"
+
+#~ msgid "parameter pack %qT must be at the end of the template parameter list"
+#~ msgstr "parameter pack %qT должен быть в конце списка параметров шаблона"
  
-#, fuzzy
  #~ msgid "wrong number of template arguments (%d, should be %d or more)"
-#~ msgstr "Ð½ÐµÐ¿Ñ\80Ð°Ð²Ð¸Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° (%d, Ð° Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c %d)"
+#~ msgstr "Ð½ÐµÐ¿Ñ\80Ð°Ð²Ð¸Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° (%d, Ð´Ð¾Ð»Ð¶Ð½Ð¾ Ð±Ñ\8bÑ\82Ñ\8c %d Ð¸Ð»Ð¸ Ð±Ð¾Ð»Ñ\8cÑ\88Ðµ)"
  
-#, fuzzy
  #~ msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth= to increase the maximum) instantiating %qD"
-#~ msgstr "глубина конкретизации шаблона превышает максимум %d (задайте -ftemplate-depth-NN, чтобы увеличить максимум) при конкретизации %qD"
+#~ msgstr "глубина конкретизации шаблона превышает максимум %d (задайте -ftemplate-depth= чтобы увеличить максимум) при конкретизации %qD"
  
-#, fuzzy
  #~ msgid "instantiation of %q+D as type %qT"
-#~ msgstr "конкретизация %qD для типа %qT"
+#~ msgstr "конкретизация %q+D как типа %qT"
  
  #~ msgid "%s %+#T"
  #~ msgstr "%s %+#T"
  
-#, fuzzy
+#~ msgid "variable %q#D with %<auto%> type used in its own initializer"
+#~ msgstr "переменная %q#D с %<auto%> типом использована в своем собственном инициализаторе"
+
  #~ msgid "deprecated covariant return type for %q+#D"
-#~ msgstr "некорректный ковариантный тип результата для `%#D',"
+#~ msgstr "устаревший ковариантный возвращаемый тип для %q+#D"
  
  #~ msgid "invalid use of non-static data member %q+D"
  #~ msgstr "некорректное использование нестатического элемента %q+D"
  
-#, fuzzy
  #~ msgid "use of parameter %qD outside function body"
-#~ msgstr "использование %s в объемлющей функции"
+#~ msgstr "использование параметра %qD вне тела функции"
  
-#, fuzzy
  #~ msgid "%qE has reference type for %qs"
-#~ msgstr "создание %s на ссылочный тип %qT"
+#~ msgstr "%qE имеет ссылочный тип для %qs"
+
+#~ msgid "__is_convertible_to"
+#~ msgstr "__is_convertible_to"
  
-#, fuzzy
  #~ msgid "array subscript out of bound"
-#~ msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
+#~ msgstr "Ð¸Ð½Ð´ÐµÐºÑ\81 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð²Ð½Ðµ Ð³Ñ\80Ð°Ð½Ð¸Ñ\86"
  
-#, fuzzy
  #~ msgid "use of the value of the object being constructed in a constant expression"
-#~ msgstr "размер массива %qD не является целочисленным константным выражением"
+#~ msgstr "использование значения конструируемого объекта в константном выражении"
  
-#, fuzzy
  #~ msgid "calling a member function of the object being constructed in a constant expression"
-#~ msgstr "%s не может присутствовать в константном выражении"
+#~ msgstr "вызов элемента-функции конструируемого объекта в константном выражении"
  
-#, fuzzy
  #~ msgid "difference of two pointer expressions is not a constant expression"
-#~ msgstr "Ñ\80Ð°Ð·Ð¼ÐµÑ\80 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ñ\86ÐµÐ»Ð¾Ñ\87Ð¸Ñ\81Ð»ÐµÐ½Ð½Ñ\8bÐ¼ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÐ¼ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸ÐµÐ¼"
+#~ msgstr "Ñ\80Ð°Ð·Ð½Ð¾Ñ\81Ñ\82Ñ\8c Ð´Ð²Ñ\83Ñ\85 Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8cÐ½Ñ\8bÑ\85 Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¹ Ð½Ðµ ÐµÑ\81Ñ\82Ñ\8c ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ð¾Ðµ Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ"
  
-#, fuzzy
  #~ msgid "pointer comparison expression is not a constant expression"
-#~ msgstr "целочисленное выражение %qE не является константой"
+#~ msgstr "выражение сравнения указателей не есть константное выражение"
  
  #~ msgid "invalid use of non-static member function"
  #~ msgstr "некорректное использование нестатической функции-элемента"
@@ -62077,24 +67256,23 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "(perhaps the %<offsetof%> macro was used incorrectly)"
  #~ msgstr "(возможно, некорректное использование макроса %<offsetof%>)"
  
-#, fuzzy
  #~ msgid "%qD has no member named %qE"
-#~ msgstr "%qD не имеет элемента с именем '%E'"
+#~ msgstr "%qD не имеет элемента с именем %qE"
  
  #~ msgid "ISO C++ forbids subscripting non-lvalue array"
  #~ msgstr "ISO C++ не поддерживает индексирование массива, не являющегося левой частью присваивания"
  
-#, fuzzy
  #~ msgid "comparison with string literal results in unspecified behaviour"
-#~ msgstr "для weak декларации %q+D после первого использования поведение системы не специфицировано"
+#~ msgstr "сравнение со строковым литералом ведет к неспецифицированному поведению"
+
+#~ msgid "\t%+#D"
+#~ msgstr "\t%+#D"
  
-#, fuzzy
  #~ msgid "  since type %qT has pure virtual functions"
-#~ msgstr "  поскольку тип %qT имеет абстрактные виртуальные функции"
+#~ msgstr "  поскольку тип %qT имеет чистые виртуальные функции"
  
-#, fuzzy
  #~ msgid "%q+D has incomplete type"
-#~ msgstr "%qD имеет неполный тип"
+#~ msgstr "%q+D имеет неполный тип"
  
  #~ msgid "cannot initialize arrays using this syntax"
  #~ msgstr "недопустимый синтаксис для инициализации массива"
@@ -62105,358 +67283,286 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "member %qD with uninitialized const fields"
  #~ msgstr "элемент %qD с неинициализированными константными полями"
  
-#, fuzzy
-#~ msgid "ATOM and VALUE argument of the %s intrinsic function shall have the same type at %L"
-#~ msgstr "аргумент `asm' - не константная строка"
-
-#, fuzzy
-#~ msgid "Missing closing quote '\"' for binding label at %C"
-#~ msgstr "Отсутствует формальный параметр"
-
-#, fuzzy
-#~ msgid "Missing closing quote ''' for binding label at %C"
-#~ msgstr "Отсутствует формальный параметр"
-
-#~ msgid "Internal Error at (1):"
-#~ msgstr "Внутренняя ошибка в (1): "
-
-#, fuzzy
-#~ msgid "Alternate RETURN at %C"
-#~ msgstr "Неподдерживаемый VXT-оператор в %0"
-
-#, fuzzy
-#~ msgid "Character length mismatch in return type of function '%s' at %L (%ld/%ld)"
-#~ msgstr "Слишком много аргументов %s в %L"
+#~ msgid "Fortran 2008: Array specification at %C with more than 7 dimensions"
+#~ msgstr "Fortran 2008: Спецификация массива в %C с более чем 7 измерениями"
  
-#, fuzzy
-#~ msgid "Procedure '%s' at %L with assumed-shape dummy argument '%s' must have an explicit interface"
-#~ msgstr "Предупреждать о неявных декларациях функций"
+#~ msgid "'dim' argument of '%s' intrinsic at %L is not a valid dimension index"
+#~ msgstr "'dim' аргумент '%s' встроенной функции в %L не есть корректный индекс измерения"
  
-#, fuzzy
-#~ msgid "Procedure '%s' at %L with assumed-rank dummy argument '%s' must have an explicit interface"
-#~ msgstr "Предупреждать о неявных декларациях функций"
+#~ msgid "ATOM and VALUE argument of the %s intrinsic function shall have the same type at %L"
+#~ msgstr "ATOM и VALUE аргумент для %s встроенной функции должен иметь одинаковый тип в %L"
  
-#, fuzzy
-#~ msgid "Procedure '%s' at %L with coarray dummy argument '%s' must have an explicit interface"
-#~ msgstr "Предупреждать о неявных декларациях функций"
+#~ msgid "'%s' argument of '%s' intrinsic at %L must be a non-derived type"
+#~ msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть невыведенным типом"
  
-#, fuzzy
-#~ msgid "Procedure '%s' at %L with parametrized derived type argument '%s' must have an explicit interface"
-#~ msgstr "Предупреждать о неявных декларациях функций"
+#~ msgid "the '%s' and '%s' arguments of '%s' intrinsic at %L must be of the same kind %d/%d"
+#~ msgstr "'%s' и '%s' аргументы '%s' встроенной функции в %L должны иметь одинаковый вид %d/%d"
  
-#, fuzzy
-#~ msgid "Procedure '%s' at %L with polymorphic dummy argument '%s' must have an explicit interface"
-#~ msgstr "Предупреждать о неявных декларациях функций"
+#~ msgid "'%s' argument of '%s' intrinsic at %L must be of a derived type"
+#~ msgstr "'%s' аргумент '%s' встроенной функции в %L должен быть производного типа"
  
-#, fuzzy
-#~ msgid "Procedure '%s' at %L with assumed-type dummy argument '%s' must have an explicit interface"
-#~ msgstr "Предупреждать о неявных декларациях функций"
+#~ msgid "Conflict in attributes of function argument at %C"
+#~ msgstr "Конфликт в атрибутах аргумента функции в %C"
  
-#, fuzzy
-#~ msgid "Function '%s' at %L with a POINTER or ALLOCATABLE result must have an explicit interface"
-#~ msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+#~ msgid "Variable '%s' at %L cannot have the ALLOCATABLE attribute because procedure '%s' is BIND(C)"
+#~ msgstr "Переменная '%s' в %L не может иметь ALLOCATABLE атрибут поскольку процедура '%s' является BIND(C)"
  
-#, fuzzy
-#~ msgid "Nonconstant character-length function '%s' at %L must have an explicit interface"
-#~ msgstr "%Jфинальное поле %qD, возможно, не было инициализировано"
+#~ msgid "Variable '%s' at %L cannot have the POINTER attribute because procedure '%s' is BIND(C)"
+#~ msgstr "Переменная '%s' в %L не может иметь POINTER атрибут поскольку процедура '%s' является BIND(C)"
  
-#, fuzzy
-#~ msgid "Argument to '%s' at %L is not a variable"
-#~ msgstr "аргумент `asm' - не константная строка"
+#~ msgid "Deferred-shape array '%s' at %L cannot be an argument to the procedure '%s' at %L because the procedure is BIND(C)"
+#~ msgstr "Массив отложенного размера '%s' в %L не может быть аргументом процедуры '%s' в %L поскольку процедура является BIND(C)"
  
-#, fuzzy
-#~ msgid "More actual than formal arguments in '%s' call at %L"
-#~ msgstr "передано %qT для %s %P в %qD"
+#~ msgid "The type of '%s' at %C has not been declared within the interface"
+#~ msgstr "Тип '%s' в %C не был декларирован в интерфейсе"
  
-#, fuzzy
-#~ msgid "Coindexed argument not permitted in '%s' call at %L"
-#~ msgstr "в конструкции case нельзя употреблять указатели"
+#~ msgid "Fortran 2003: IMPORT statement at %C"
+#~ msgstr "Fortran 2003: IMPORT оператор в %C"
  
-#, fuzzy
-#~ msgid "CHARACTER argument '%s' to '%s' at %L must have a length of 1"
-#~ msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+#~ msgid "Missing closing quote '\"' for binding label at %C"
+#~ msgstr "Отсутствует закрывающая кавычка '\"' для связывающей метки в %C"
  
-#, fuzzy
-#~ msgid "Argument '%s' to '%s' at %L must be an associated scalar POINTER"
-#~ msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+#~ msgid "Missing closing quote ''' for binding label at %C"
+#~ msgstr "Отсутствует закрывающая кавычка ''' для связывающей метки в %C"
  
-#, fuzzy
-#~ msgid "Parameter '%s' to '%s' at %L must be a scalar"
-#~ msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+#~ msgid "No such symbol in TYPE definition at %C"
+#~ msgstr "Нет такого символа в TYPE определении в %C"
  
-#, fuzzy
-#~ msgid "Argument '%s' to '%s' at %L must be a procedure"
-#~ msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+#~ msgid "Fortran 2003: ABSTRACT type at %C"
+#~ msgstr "Fortran 2003: ABSTRACT тип в %C"
  
-#, fuzzy
-#~ msgid "SHAPE argument for call to %s at %L must be a rank 1 INTEGER array"
-#~ msgstr "Пустой аргумент в %0 в вызове функции-оператора в %1"
+#~ msgid "Expected ',' at %C"
+#~ msgstr "Ожидалась ',' в %C"
  
-#~ msgid "%s:not a gcov graph file\n"
-#~ msgstr "%s:не графический файл gcov\n"
+#~ msgid "Error count reached limit of %d."
+#~ msgstr "Счетчик ошибок достиг предела %d."
  
-#~ msgid "Unexpected type..."
-#~ msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿..."
+#~ msgid "Internal Error at (1):"
+#~ msgstr "Ð\92Ð½Ñ\83Ñ\82Ñ\80ÐµÐ½Ð½Ñ\8fÑ\8f Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð² (1):"
  
-#~ msgid "Select fraction of the maximal count of repetitions of basic block in program given basic block needs to have to be considered hot"
-#~ msgstr "Ð\9eÑ\82Ð½Ð¾Ñ\81Ð¸Ñ\82ÐµÐ»Ñ\8cÐ½Ð¾Ðµ Ð¼Ð°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80ÐµÐ½Ð¸Ð¹ Ð±Ð»Ð¾ÐºÐ° Ð² Ð¿Ñ\80Ð¾Ð³Ñ\80Ð°Ð¼Ð¼Ðµ, Ð¿Ñ\80Ð¸ Ð¿Ñ\80ÐµÐ²Ñ\8bÑ\88ÐµÐ½Ð¸Ð¸ ÐºÐ¾Ñ\82Ð¾Ñ\80Ð¾Ð³Ð¾ Ð±Ð»Ð¾Ðº Ð´Ð¾Ð»Ð¶ÐµÐ½ Ñ\81Ñ\87Ð¸Ñ\82Ð°Ñ\82Ñ\8cÑ\81Ñ\8f ÐºÑ\80Ð¸Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¼"
+#~ msgid "Pointer initialization target at %C must not be ALLOCATABLE "
+#~ msgstr "Ð¦ÐµÐ»Ñ\8c Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð² %C Ð½Ðµ Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c ALLOCATABLE "
  
-#~ msgid "Minimum number of virtual mappings to consider switching to full virtual renames"
-#~ msgstr "Ð\9cÐ¸Ð½Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð²Ð¸Ñ\80Ñ\82Ñ\83Ð°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ð¾Ñ\82Ð¾Ð±Ñ\80Ð°Ð¶ÐµÐ½Ð¸Ð¹, Ð¿Ñ\80Ð¸ ÐºÐ¾Ñ\82Ð¾Ñ\80Ð¾Ð¼ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¾ Ð¿Ð¾Ð»Ð½Ð¾Ðµ Ð¿ÐµÑ\80ÐµÐ¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð²Ð¸Ñ\80Ñ\82Ñ\83Ð°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ð¾Ð²"
+#~ msgid "Pointer initialization target at %C must have the SAVE attribute"
+#~ msgstr "Ð¦ÐµÐ»Ñ\8c Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f Ð² %C Ð´Ð¾Ð»Ð¶Ð½Ð° Ð¸Ð¼ÐµÑ\82Ñ\8c SAVE Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82"
  
-#~ msgid "Ratio between virtual mappings and virtual symbols to do full virtual renames"
-#~ msgstr "Ð\9eÑ\82Ð½Ð¾Ñ\88ÐµÐ½Ð¸Ðµ Ñ\87Ð¸Ñ\81Ð»Ð° Ð²Ð¸Ñ\80Ñ\82Ñ\83Ð°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ð¾Ñ\82Ð¾Ð±Ñ\80Ð°Ð¶ÐµÐ½Ð¸Ð¹ Ðº Ñ\87Ð¸Ñ\81Ð»Ñ\83 Ð²Ð¸Ñ\80Ñ\82Ñ\83Ð°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ð¾Ð², Ð¿Ñ\80Ð¸ ÐºÐ¾Ñ\82Ð¾Ñ\80Ð¾Ð¼ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ð¿Ð¾Ð»Ð½Ð¾Ðµ Ð¿ÐµÑ\80ÐµÐ¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ð¾Ð²"
+#~ msgid "Unexpected type in truthvalue_conversion"
+#~ msgstr "Ð\9dÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð² truthvalue_conversion"
  
-#, fuzzy
-#~ msgid "operand is neither a constant nor a condition code, invalid operand code 'C'"
-#~ msgstr "операнд не является константой или кодом условия, неверный код операнда 'c'"
+#~ msgid "Procedure argument at %L is INTENT(IN) while interface specifies INTENT(%s)"
+#~ msgstr "Аргумент процедуры в %L является INTENT(IN) хотя интерфейс задает INTENT(%s)"
  
-#, fuzzy
-#~ msgid "operand is neither a constant nor a condition code, invalid operand code 'F'"
-#~ msgstr "операнд не является константой или кодом условия, неверный код операнда 'c'"
+#~ msgid "Procedure argument at %L is local to a PURE procedure and is passed to an INTENT(%s) argument"
+#~ msgstr "Аргумент процедуры в %L локален в PURE процедуре и передан в INTENT(%s) аргумент"
  
-#~ msgid "operand is neither a constant nor a condition code, invalid operand code 'c'"
-#~ msgstr "операнд не является константой или кодом условия, неверный код операнда 'c'"
+#~ msgid "'%s' at %L and the overridden FUNCTION should have matching result types and ranks"
+#~ msgstr "'%s' в %L и перебиваемая FUNCTION должна иметь соответствующие типы результатов и ранги"
  
-#, fuzzy
-#~ msgid "operand is neither a constant nor a condition code, invalid operand code 'f'"
-#~ msgstr "операнд не является константой или кодом условия, неверный код операнда 'c'"
+#~ msgid "Character length mismatch between '%s' at '%L' and overridden FUNCTION"
+#~ msgstr "Несоответствие character длин между '%s' в '%L' и перебиваемой FUNCTION"
  
-#~ msgid "mips_debugger_offset called with non stack/frame/arg pointer"
-#~ msgstr "mips_debugger_offset вызвана не с указателем стека/кадра/аргумента"
+#~ msgid "Possible character length mismatch between '%s' at '%L' and overridden FUNCTION"
+#~ msgstr "Возможное несоответствие character длин между '%s' в '%L' и перебиваемой FUNCTION"
  
-#, fuzzy
-#~ msgid "invalid %%c value"
-#~ msgstr "некорректное %%H значение"
+#~ msgid "Fortran 2008: 'G0' in format at %L"
+#~ msgstr "Fortran 2008: 'G0' в формате в %L"
  
-#, fuzzy
-#~ msgid "-I <dir>.\tAdd <dir> to the end of the main source path"
-#~ msgstr "Добавить <каталог> в конец основного пути поиска заголовков"
+#~ msgid "Fortran 2008: NEWUNIT specifier at %L"
+#~ msgstr "Fortran 2008: NEWUNIT спецификатор в %L"
  
-#~ msgid "Assume GAS"
-#~ msgstr "Ð\9fÑ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ GAS"
+#~ msgid "Embedded space in NAME= specifier at %C"
+#~ msgstr "Ð\92Ñ\81Ñ\82Ñ\80Ð¾ÐµÐ½Ð½Ñ\8bÐ¹ Ð¿Ñ\80Ð¾Ð±ÐµÐ» Ð² NAME= Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ðµ Ð² %C"
  
-#~ msgid "Do not assume GAS"
-#~ msgstr "Ð\9dÐµ Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°Ñ\82Ñ\8c Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ GAS"
+#~ msgid "Deleted feature: PAUSE statement at %C"
+#~ msgstr "Ð£Ð´Ð°Ð»ÐµÐ½Ð½Ð°Ñ\8f Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ñ\8c: PAUSE Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ð² %C"
  
-#~ msgid "Use POWER instruction set"
-#~ msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81Ð¸Ñ\81Ñ\82ÐµÐ¼Ñ\83 ÐºÐ¾Ð¼Ð°Ð½Ð´ POWER"
+#~ msgid "Obsolescent feature: Alternate RETURN at %C"
+#~ msgstr "Ð£Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð°Ñ\8f Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ñ\8c: Alternate RETURN Ð² %C"
  
-#~ msgid "Do not use POWER instruction set"
-#~ msgstr "Ð\9dÐµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81Ð¸Ñ\81Ñ\82ÐµÐ¼Ñ\83 ÐºÐ¾Ð¼Ð°Ð½Ð´ POWER"
+#~ msgid "Symbol '%s' at %C is already an external symbol that is not COMMON"
+#~ msgstr "Ð¡Ð¸Ð¼Ð²Ð¾Ð» '%s' Ð² %C Ñ\83Ð¶Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ð²Ð½ÐµÑ\88Ð½Ð¸Ð¼ Ñ\81Ð¸Ð¼Ð²Ð¾Ð»Ð¾Ð¼ ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐ¹ Ð½Ðµ ÐµÑ\81Ñ\82Ñ\8c COMMON"
  
-#~ msgid "Use POWER2 instruction set"
-#~ msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81Ð¸Ñ\81Ñ\82ÐµÐ¼Ñ\83 ÐºÐ¾Ð¼Ð°Ð½Ð´ POWER2"
+#~ msgid "Obsolescent feature: Statement function at %C"
+#~ msgstr "Ð£Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88Ð°Ñ\8f Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ñ\8c: Ð\9eÐ¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80 Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ð² %C"
  
-#~ msgid "Use PowerPC instruction set"
-#~ msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ñ\81Ð¸Ñ\81Ñ\82ÐµÐ¼Ñ\83 ÐºÐ¾Ð¼Ð°Ð½Ð´ PowerPC"
+#~ msgid "Parse error when checking module version for file '%s' opened at %C"
+#~ msgstr "Ð\9eÑ\88Ð¸Ð±ÐºÐ° Ñ\80Ð°Ð·Ð±Ð¾Ñ\80Ð° Ð¿Ñ\80Ð¸ Ð¿Ñ\80Ð¾Ð²ÐµÑ\80ÐºÐµ Ð²ÐµÑ\80Ñ\81Ð¸Ð¸ Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8f Ð´Ð»Ñ\8f Ñ\84Ð°Ð¹Ð»Ð° '%s' Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82Ð¾Ð³Ð¾ Ð² %C"
  
-#~ msgid "Use new mnemonics for PowerPC architecture"
-#~ msgstr "Ð\98Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð½Ð¾Ð²Ñ\8bÐµ Ð¼Ð½ÐµÐ¼Ð¾Ð½Ð¸ÐºÐ¸ ÐºÐ¾Ð¼Ð°Ð½Ð´ Ð´Ð»Ñ\8f Ð°Ñ\80Ñ\85Ð¸Ñ\82ÐµÐºÑ\82Ñ\83Ñ\80Ñ\8b PowerPC"
+#~ msgid "Wrong module version '%s' (expected '%s') for file '%s' opened at %C"
+#~ msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð°Ñ\8f Ð²ÐµÑ\80Ñ\81Ð¸Ñ\8f Ð¼Ð¾Ð´Ñ\83Ð»Ñ\8f '%s' (Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c '%s') Ð´Ð»Ñ\8f Ñ\84Ð°Ð¹Ð»Ð° '%s' Ð¾Ñ\82ÐºÑ\80Ñ\8bÑ\82Ð¾Ð³Ð¾ Ð² %C"
  
-#~ msgid "Use old mnemonics for PowerPC architecture"
-#~ msgstr "Использовать старые мнемоники команд для архитектуры PowerPC"
+#~ msgid "%s is not INTRINSIC procedure name at %C"
+#~ msgstr "%s не есть имя INTRINSIC процедуры в %C"
  
-#, fuzzy
-#~ msgid "Enable the use of the fused floating point multiply-accumulate operation"
-#~ msgstr "Включить использование коротких команд загрузки"
+#~ msgid "COPYIN clause object '%s' at %L has ALLOCATABLE components"
+#~ msgstr "Объект COPYIN клаузулы '%s' в %L имеет ALLOCATABLE компоненты"
  
-#~ msgid "Cirrus: Place NOPs to avoid invalid instruction combinations"
-#~ msgstr "Cirrus: генерировать команды NOP во избежание некорректного комбинирования команд"
+#~ msgid "COPYPRIVATE clause object '%s' at %L has ALLOCATABLE components"
+#~ msgstr "Объект COPYPRIVATE клаузулы '%s' в %L имеет ALLOCATABLE компоненты"
  
-#~ msgid "Ignore dllimport attribute for functions"
-#~ msgstr "Ð\98Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 dllimport Ð´Ð»Ñ\8f Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¹"
+#~ msgid "%s clause object '%s' has ALLOCATABLE components at %L"
+#~ msgstr "Ð\9eÐ±Ñ\8aÐµÐºÑ\82 %s ÐºÐ»Ð°Ñ\83Ð·Ñ\83Ð»Ñ\8b '%s' Ð¸Ð¼ÐµÐµÑ\82 ALLOCATABLE ÐºÐ¾Ð¼Ð¿Ð¾Ð½ÐµÐ½Ñ\82Ñ\8b Ð² %L"
  
-#~ msgid "Use rjmp/rcall (limited range) on >8K devices"
-#~ msgstr "Использовать rjmp/rcall (с ограниченным диапазоном) для устройств >8K"
+#~ msgid "%c REDUCTION variable '%s' at %L must be of numeric type, got %s"
+#~ msgstr "%c REDUCTION переменная '%s' в %L должна быть числового типа, получено %s"
  
-#~ msgid "Support Green Hills ABI"
-#~ msgstr "Включить поддержку Green Hills ABI"
+#~ msgid "%s REDUCTION variable '%s' must be LOGICAL at %L"
+#~ msgstr "%s REDUCTION переменная '%s' должна быть LOGICAL в %L"
  
-#~ msgid "Reduce the size of object files"
-#~ msgstr "Сократить объем объектных файлов"
+#~ msgid "%s REDUCTION variable '%s' must be INTEGER or REAL at %L"
+#~ msgstr "%s REDUCTION переменная '%s' должна быть INTEGER или REAL в %L"
  
-#, fuzzy
-#~ msgid "Enable Loop Flattening transformation"
-#~ msgstr "Включить автоматическую конкретизацию шаблонов"
+#~ msgid "Argument to -fcoarray is not valid: %s"
+#~ msgstr "Аргумент для -fcoarray некорректен: %s"
  
-#, fuzzy
-#~ msgid "bad size for make"
-#~ msgstr "некорректная инструкция для 'A'"
+#~ msgid "Fortran 2003:  GENERIC binding at %C"
+#~ msgstr "Fortran 2003:  GENERIC связывание в %C"
  
-#, fuzzy
-#~ msgid "invalid unsafe.Pointer conversion"
-#~ msgstr "некорректный операнд в инструкции"
+#~ msgid "Fortran 2003: PARAMETER symbol in complex constant at %C"
+#~ msgstr "Fortran 2003: PARAMETER символ в complex константе в %C"
  
-#~ msgid "declaration of %q+D shadows a global declaration"
-#~ msgstr "Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8f %q+D Ð¿ÐµÑ\80ÐµÐºÑ\80Ñ\8bÐ²Ð°ÐµÑ\82 Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ñ\83Ñ\8e Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8e"
+#~ msgid "Extension: argument list function at %C"
+#~ msgstr "Ð Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð¸Ðµ: Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ñ\8f Ñ\81Ð¿Ð¸Ñ\81ÐºÐ° Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² %C"
  
-#~ msgid "missing initializer"
-#~ msgstr "Ð¿Ñ\80Ð¾Ð¿Ñ\83Ñ\89ÐµÐ½ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\82Ð¾Ñ\80"
+#~ msgid "Argument '%s' of elemental procedure '%s' at %L must have its INTENT specified"
+#~ msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð½Ð¾Ð¹ Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ñ\81Ð²Ð¾Ð¹ INTENT Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸Ñ\86Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¼"
  
-#, fuzzy
-#~ msgid "too many eh edges %i"
-#~ msgstr "слишком много переходов, исходящих из блока %i"
+#~ msgid "Components of structure constructor '%s' at %L are PRIVATE"
+#~ msgstr "Компоненты конструктора структуры '%s' в %L являются PRIVATE"
  
-#, fuzzy
-#~ msgid "can%'t seek PCH file: %m"
-#~ msgstr "ошибка позиционирования PCH файла: %m"
+#~ msgid "Character length mismatch in return type of function '%s' at %L (%ld/%ld)"
+#~ msgstr "Несоответствие character длины в возвращаемом типе функции '%s' в %L (%ld/%ld)"
  
-#, fuzzy
-#~ msgid "the file is not in OpenScop format"
-#~ msgstr "ширина поля в формате printf"
+#~ msgid "Dummy argument '%s' of procedure '%s' at %L has an attribute that requires an explicit interface for this procedure"
+#~ msgstr "Формальный аргумент '%s' процедуры '%s' в %L имеет атрибут который требует явный интерфейс для этой процедуры"
  
-#, fuzzy
-#~ msgid "the language is not recognized"
-#~ msgstr "некорректное задание языка %s"
+#~ msgid "Procedure '%s' at %L with assumed-shape dummy argument '%s' must have an explicit interface"
+#~ msgstr "Процедура '%s' в %L с формальным аргументом массивом предполагаемой формы '%s' должна иметь явный интерфейс"
  
-#, fuzzy
-#~ msgid "can%'t open %s for reading: %m"
-#~ msgstr "ошибка открытия %s на запись: %m"
+#~ msgid "Procedure '%s' at %L with coarray dummy argument '%s' must have an explicit interface"
+#~ msgstr "Процедура '%s' в %L с формальным аргументом комассивом '%s' должна иметь явный интерфейс"
  
-#, fuzzy
-#~ msgid "cannot find LTO varpool in %s"
-#~ msgstr "нет класса %qs"
+#~ msgid "Procedure '%s' at %L with parametrized derived type argument '%s' must have an explicit interface"
+#~ msgstr "Процедура '%s' в %L с аргументом параметризованного производного типа '%s' должна иметь явный интерфейс"
  
-#~ msgid "use of memory input without lvalue in asm operand %d is deprecated"
-#~ msgstr "Ð±Ð¾Ð»ÐµÐµ Ð½Ðµ Ñ\80ÐµÐºÐ¾Ð¼ÐµÐ½Ð´Ñ\83ÐµÑ\82Ñ\81Ñ\8f Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ñ\82Ñ\8c Ð²Ñ\85Ð¾Ð´Ð½Ð¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ \"Ð¿Ð°Ð¼Ñ\8fÑ\82Ñ\8c\" Ð±ÐµÐ· lvalue-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ñ\8f Ð² Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ðµ asm %d"
+#~ msgid "Procedure '%s' at %L with polymorphic dummy argument '%s' must have an explicit interface"
+#~ msgstr "Ð\9fÑ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° '%s' Ð² %L Ñ\81 Ð¿Ð¾Ð»Ð¸Ð¼Ð¾Ñ\80Ñ\84Ð½Ñ\8bÐ¼ Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÐ¼ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼ '%s' Ð´Ð¾Ð»Ð¶Ð½Ð° Ð¸Ð¼ÐµÑ\82Ñ\8c Ñ\8fÐ²Ð½Ñ\8bÐ¹ Ð¸Ð½Ñ\82ÐµÑ\80Ñ\84ÐµÐ¹Ñ\81"
  
-#~ msgid "-ffunction-sections disabled; it makes profiling impossible"
-#~ msgstr "-ffunction-sections отменен, поскольку профилирование с ним невозможно"
+#~ msgid "The reference to function '%s' at %L either needs an explicit INTERFACE or the rank is incorrect"
+#~ msgstr "Ссылка на функцию '%s' в %L либо требует явный INTERFACE либо ранг некорректен"
  
-#, fuzzy
-#~ msgid "excess def operand for stmt"
-#~ msgstr "ожидалась декларация или оператор"
+#~ msgid "Function '%s' at %L with a POINTER or ALLOCATABLE result must have an explicit interface"
+#~ msgstr "Функция '%s' в %L с POINTER или ALLOCATABLE результатом должна иметь явный интерфейс"
  
-#, fuzzy
-#~ msgid "def operand missing for stmt"
-#~ msgstr "не задан номер операнда после %%-буква"
+#~ msgid "Nonconstant character-length function '%s' at %L must have an explicit interface"
+#~ msgstr "Функция д неконстантной character длиной '%s' в %L должна иметь явный интерфейс"
  
-#~ msgid "vector %s %s domain error, in %s at %s:%u"
-#~ msgstr "вектор %s %s ошибка области определения, в in %s на %s:%u"
+#~ msgid "ELEMENTAL procedure '%s' at %L must have an explicit interface"
+#~ msgstr "ELEMENTAL процедура '%s' в %L должна иметь явный интерфейс"
  
-#~ msgid "can%'t seek in %s: %m"
-#~ msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ð¿Ð¾Ð·Ð¸Ñ\86Ð¸Ð¾Ð½Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ñ\8f Ð² %s: %m"
+#~ msgid "Argument to '%s' at %L is not a variable"
+#~ msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð² '%s' Ð² %L Ð½Ðµ ÐµÑ\81Ñ\82Ñ\8c Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f"
  
-#~ msgid "malformed #pragma extern_prefix, ignored"
-#~ msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð½Ñ\82Ð°ÐºÑ\81Ð¸Ñ\81 #pragma extern_prefix, Ð´Ð¸Ñ\80ÐµÐºÑ\82Ð¸Ð²Ð° Ð¿Ñ\80Ð¾Ð¸Ð³Ð½Ð¾Ñ\80Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð°"
+#~ msgid "More actual than formal arguments in '%s' call at %L"
+#~ msgstr "Ð\91Ð¾Ð»Ñ\8cÑ\88Ðµ Ñ\84Ð°ÐºÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ñ\85 Ñ\87ÐµÐ¼ Ñ\84Ð¾Ñ\80Ð¼Ð°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð² Ð² '%s' Ð²Ñ\8bÐ·Ð¾Ð²Ðµ Ð² %L"
  
-#, fuzzy
-#~ msgid "junk at end of %<#pragma extern_prefix%>"
-#~ msgstr "мусор в конце #pragma extern_prefix"
+#~ msgid "Parameter '%s' to '%s' at %L must be either a TARGET or an associated pointer"
+#~ msgstr "Параметр '%s' в '%s' в %L должен быть либо TARGET либо ассоциированный указатель"
  
-#~ msgid "#pragma extern_prefix not supported on this target"
-#~ msgstr "#pragma extern_prefix для этой платформы не поддерживается"
+#~ msgid "Coindexed argument not permitted in '%s' call at %L"
+#~ msgstr "Коиндексированный аргумент не разрешен в '%s' вызове в %L"
  
-#, fuzzy
-#~ msgid "internal and protected visibility attributes not supported in this configuration; ignored"
-#~ msgstr "атрибуты видимости internal и protected не поддерживаются для этой платформы"
+#~ msgid "Allocatable variable '%s' used as a parameter to '%s' at %L must not be an array of zero size"
+#~ msgstr "Размещаемая переменная '%s' использованная как параметр в '%s' в %L не должна быть массивом нулевого размера"
  
-#~ msgid "iWMMXt and hardware floating point"
-#~ msgstr "Ð°Ð¿Ð¿Ð°Ñ\80Ð°Ñ\82Ð½Ð°Ñ\8f Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð°Ñ\8f Ñ\82Ð¾Ñ\87ÐºÐ° Ð¸Ð»Ð¸ iWMMXt"
+#~ msgid "Assumed-shape array '%s' at %L cannot be an argument to the procedure '%s' because it is not C interoperable"
+#~ msgstr "Ð\9cÐ°Ñ\81Ñ\81Ð¸Ð² Ð¿Ñ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð¾Ð¹ Ñ\84Ð¾Ñ\80Ð¼Ñ\8b '%s' Ð² %L Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð¼ Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ñ\8b '%s' Ð¿Ð¾Ñ\81ÐºÐ¾Ð»Ñ\8cÐºÑ\83 Ð¾Ð½ Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f C Ñ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¼"
  
-#~ msgid "static variable %q+D is marked dllimport"
-#~ msgstr "статическая переменная %q+D помечена как dllimport"
+#~ msgid "Deferred-shape array '%s' at %L cannot be an argument to the procedure '%s' because it is not C interoperable"
+#~ msgstr "Массив отложенной формы '%s' в %L не может быть аргументом процедуры '%s' поскольку он не является C совместимым"
  
-#~ msgid "that particular -g option is invalid with -maout and -melinux"
-#~ msgstr "заданный ключ -g несовместим с -maout и -melinux"
+#~ msgid "CHARACTER argument '%s' to '%s' at %L must have a length of 1"
+#~ msgstr "CHARACTER аргумент '%s' в '%s' в %L должен иметь длину 1"
  
-#~ msgid "-maix64 and POWER architecture are incompatible"
-#~ msgstr "Ð\9aÐ»Ñ\8eÑ\87 -maix64 Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼ Ñ\81 Ð°Ñ\80Ñ\85Ð¸Ñ\82ÐµÐºÑ\82Ñ\83Ñ\80Ð¾Ð¹ POWER"
+#~ msgid "Argument '%s' to '%s' at %L must be an associated scalar POINTER"
+#~ msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð² '%s' Ð² %L Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð±Ñ\8bÑ\82Ñ\8c Ð°Ñ\81Ñ\81Ð¾Ñ\86Ð¸Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¼ Ñ\81ÐºÐ°Ð»Ñ\8fÑ\80Ð½Ñ\8bÐ¼ POINTER"
  
-#, fuzzy
-#~ msgid "-m64 not supported in this configuration"
-#~ msgstr "-m%s в данной конфигурации не поддерживается"
+#~ msgid "Parameter '%s' to '%s' at %L must be a scalar"
+#~ msgstr "Параметр '%s' в '%s' в %L должен быть скаляром"
  
-#, fuzzy
-#~ msgid "ambiguous overload for ternary %<operator?:%> in %<%E ? %E : %E%>"
-#~ msgstr "%s для трехиестного 'operator?:' в '%E ? %E : %E'"
+#~ msgid "Parameter '%s' to '%s' at %L must be a procedure"
+#~ msgstr "Параметр '%s' в '%s' в %L должен быть процедурой"
  
-#, fuzzy
-#~ msgid "ambiguous overload for %<operator%s%> in %<%E%s%>"
-#~ msgstr "%s для 'operator%s' в '%E%s'"
+#~ msgid "Parameter '%s' to '%s' at %L must be BIND(C)"
+#~ msgstr "Параметр '%s' в '%s' в %L должен быть BIND(C)"
  
-#, fuzzy
-#~ msgid "ambiguous overload for %<operator[]%> in %<%E[%E]%>"
-#~ msgstr "%s для 'operator[]' в '%E[%E]'"
+#~ msgid "Function reference to '%s' at %L is to a non-PURE procedure within a PURE procedure"
+#~ msgstr "Функциональная ссылка на '%s' at %L является ссылкой на non-PURE процедуру внутри PURE процедуры"
  
-#, fuzzy
-#~ msgid "ambiguous overload for %<operator%s%> in %<%E %s %E%>"
-#~ msgstr "%s для 'operator%s' в '%E %s %E'"
+#~ msgid "Missing SHAPE parameter for call to %s at %L"
+#~ msgstr "Отсутствует SHAPE параметр для вызова %s в %L"
  
-#, fuzzy
-#~ msgid "ambiguous overload for %<operator%s%> in %<%s%E%>"
-#~ msgstr "%s для 'operator%s' в '%s%E'"
+#~ msgid "SHAPE parameter for call to %s at %L must be a rank 1 INTEGER array"
+#~ msgstr "SHAPE параметр для вызова %s в %L должен быть INTEGER массивом ранга 1"
  
-#~ msgid "template header not allowed in member definition of explicitly specialized class"
-#~ msgstr "Ð·Ð°Ð³Ð¾Ð»Ð¾Ð²Ð¾Ðº Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ð² Ð¾Ð¿Ñ\80ÐµÐ´ÐµÐ»ÐµÐ½Ð¸Ð¸ Ñ\87Ð»ÐµÐ½Ð° Ñ\8fÐ²Ð½Ð¾ Ñ\81Ð¿ÐµÑ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð¾Ð³Ð¾ ÐºÐ»Ð°Ñ\81Ñ\81Ð°"
+#~ msgid "Deleted feature: %s at %L must be integer"
+#~ msgstr "Ð£Ð´Ð°Ð»ÐµÐ½Ð½Ð°Ñ\8f Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾Ñ\81Ñ\82Ñ\8c: %s Ð² %L Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c integer"
  
-#~ msgid "%qD is thread-local and so cannot be dynamically initialized"
-#~ msgstr "%qD является локально-поточным, поэтому не может быть динамически инициализирован"
+#~ msgid "NULL intrinsic at %L in data transfer statement requires MOLD="
+#~ msgstr "NULL встроенная в %L в операторе передачи данных требует MOLD="
  
-#~ msgid "default argument for %q#D has type %qT"
-#~ msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f %q#D Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %qT"
+#~ msgid "Binding label '%s' for common block '%s' at %L collides with the global entity '%s' at %L"
+#~ msgstr "Ð¡Ð²Ñ\8fÐ·Ñ\8bÐ²Ð°Ñ\8eÑ\89Ð°Ñ\8f Ð¼ÐµÑ\82ÐºÐ° '%s' Ð´Ð»Ñ\8f common Ð±Ð»Ð¾ÐºÐ° '%s' Ð² %L ÐºÐ¾Ð½Ñ\84Ð»Ð¸ÐºÑ\82Ñ\83ÐµÑ\82 Ñ\81 Ð³Ð»Ð¾Ð±Ð°Ð»Ñ\8cÐ½Ð¾Ð¹ Ñ\81Ñ\83Ñ\89Ð½Ð¾Ñ\81Ñ\82Ñ\8cÑ\8e '%s' Ð² %L"
  
-#~ msgid "default argument for parameter of type %qT has type %qT"
-#~ msgstr "Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f Ð¿Ð°Ñ\80Ð°Ð¼ÐµÑ\82Ñ\80Ð° Ñ\82Ð¸Ð¿Ð° %qT Ð¸Ð¼ÐµÐµÑ\82 Ñ\82Ð¸Ð¿ %qT"
+#~ msgid "Binding label '%s' for common block '%s' at %L does not match the binding label '%s' for common block '%s' at %L"
+#~ msgstr "Ð¡Ð²Ñ\8fÐ·Ñ\8bÐ²Ð°Ñ\8eÑ\89Ð°Ñ\8f Ð¼ÐµÑ\82ÐºÐ° '%s' Ð´Ð»Ñ\8f common Ð±Ð»Ð¾ÐºÐ° '%s' Ð² %L Ð½Ðµ Ñ\81Ð¾Ð¾Ñ\82Ð²ÐµÑ\82Ñ\81Ñ\82Ð²Ñ\83ÐµÑ\82 Ñ\81Ð²Ñ\8fÐ·Ñ\8bÐ²Ð°Ñ\8eÑ\89ÐµÐ¹ Ð¼ÐµÑ\82ÐºÐµ '%s' Ð´Ð»Ñ\8f common Ð±Ð»Ð¾ÐºÐ° '%s' Ð² %L"
  
-#~ msgid "%<%T::%D%> names constructor"
-#~ msgstr "%%<%T::%D%> обозначает конструктор"
+#~ msgid "Binding label '%s' for common block '%s' at %L collides with global entity '%s' at %L"
+#~ msgstr "Связывающая метка '%s' для common блока '%s' в %L конфликтует с глобальной сущностью '%s' в %L"
  
-#, fuzzy
-#~ msgid "variable %q#D with %<auto%> type used in its own initializer"
-#~ msgstr "инициализация объекта %qD переменного размера недопустима"
+#~ msgid "Binding label '%s' in interface body at %L collides with the global entity '%s' at %L"
+#~ msgstr "Связывающая метка '%s' в теле интерфейса в %L конфликтует с глобальной сущностью '%s' в %L"
  
-#, fuzzy
-#~ msgid "The type of '%s' at %C has not been declared within the interface"
-#~ msgstr "отмена декларации %qD в пространстве имён %qD"
+#~ msgid "Binding label '%s' at %L collides with global entity '%s' at %L"
+#~ msgstr "Связывающая метка '%s' в %L конфликтует с глобальной сущностью '%s' в %L"
  
-#, fuzzy
-#~ msgid "Fortran 2003: IMPORT statement at %C"
-#~ msgstr "Неподдерживаемый VXT-оператор в %0"
+#~ msgid "CHARACTER variable at %L has negative length %d, the length has been set to zero"
+#~ msgstr "CHARACTER переменная в %L имеет отрицательную длину %d, длина установлена в ноль"
  
-#, fuzzy
-#~ msgid "Pointer initialization target at %C must have the SAVE attribute"
-#~ msgstr "Компонент в %C должен иметь атрибут POINTER"
+#~ msgid "Obsolescent feature: CHARACTER(*) function '%s' at %L"
+#~ msgstr "Устаревшая возможность: CHARACTER(*) функция '%s' в %L"
  
-#, fuzzy
-#~ msgid "Character length mismatch between '%s' at '%L' and overridden FUNCTION"
-#~ msgstr "Слишком много аргументов %s в %L"
+#~ msgid "Interface '%s', used by procedure pointer component '%s' at %L, is declared in a later PROCEDURE statement"
+#~ msgstr "Интерфейс '%s', используемый компонентом указателем на процедуру '%s' в %L, декларирован в более позднем PROCEDURE операторе"
  
-#, fuzzy
-#~ msgid "Fortran 2008: NEWUNIT specifier at %L"
-#~ msgstr "Неподдерживаемый VXT-оператор в %0"
+#~ msgid "Interface '%s' of procedure pointer component '%s' at %L must be explicit"
+#~ msgstr "Интерфейс '%s' компонента указателя на процедуру '%s' в %L должен быть явным"
  
-#, fuzzy
-#~ msgid "Deleted feature: PAUSE statement at %C"
-#~ msgstr "Неподдерживаемый VXT-оператор в %0"
+#~ msgid "Fortran 2003: %s attribute with %s attribute at %L"
+#~ msgstr "Fortran 2003: %s атрибут с %s атрибутом в %L"
  
-#, fuzzy
-#~ msgid "Obsolescent feature: Statement function at %C"
-#~ msgstr "Неподдерживаемый VXT-оператор в %0"
+#~ msgid "Fortran 2003: %s attribute with %s attribute in '%s' at %L"
+#~ msgstr "Fortran 2003: %s атрибут с %s атрибутом в '%s' в %L"
  
-#, fuzzy
-#~ msgid "Extension: argument list function at %C"
-#~ msgstr "отсутствует аргумент ключа %qs"
+#~ msgid "Extension: Symbol '%s' is used before it is typed at %L"
+#~ msgstr "Расширение: Символ '%s' используется до своего типизирования в %L"
  
-#, fuzzy
-#~ msgid "Deleted feature: %s at %L must be integer"
-#~ msgstr "предикат должен быть идентификатором"
+#~ msgid "Possible front-end bug: Deferred array size without pointer, allocatable attribute or derived type without allocatable components."
+#~ msgstr "Возможная front-end ошибка: Отложенный размер массива без pointer, allocatable атрибута или производный тип без allocatable компонентов."
  
-#, fuzzy
-#~ msgid "Interface '%s', used by procedure pointer component '%s' at %L, is declared in a later PROCEDURE statement"
-#~ msgstr "Внешняя процедура `%A' передана как фактический аргумент в %0, но не декларирована явно как EXTERNAL"
+#~ msgid "Derived type '%s' at %L has PRIVATE components"
+#~ msgstr "Производный тип '%s' в %L имеет PRIVATE компоненты"
  
-#, fuzzy
-#~ msgid "Fortran 2003: %s attribute with %s attribute at %L"
-#~ msgstr "Ð°Ñ\82Ñ\80Ð¸Ð±Ñ\83Ñ\82 %qs Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼ Ñ\82Ð¾Ð»Ñ\8cÐºÐ¾ Ð´Ð»Ñ\8f Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ñ\8bÑ\85"
+#
+#~ msgid "invalid unsafe.Pointer conversion"
+#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ unsafe.Pointer Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ"
  
  #~ msgid "internal gcc abort in %s, at %s:%d"
  #~ msgstr "аварийный выход gcc в %s, в %s:%d"
  
-#, fuzzy
+#
  #~ msgid "The threshold ratio between current and hottest structure counts"
-#~ msgstr "Пороговое соотношение между конкретизированными полями и общим размером структуры"
+#~ msgstr "Пороговое соотношение между текущими и максимальными структурными счетчиками"
  
  #~ msgid " (frv)"
  #~ msgstr " (frv)"
@@ -62479,30 +67585,34 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "invalid Z register replacement for insn"
  #~ msgstr "некорректная замена Z-регистра в инструкции"
  
+#
+#~ msgid "%s:%d:%d:   instantiated from %qs\n"
+#~ msgstr "%s:%d:%d:   экземпляр из %qs\n"
+
  #~ msgid "Generate code for little-endian"
  #~ msgstr "Генерировать код для обратного (little endian) порядка байт"
  
  #~ msgid "Generate code for big-endian"
  #~ msgstr "Генерировать код для прямого (big endian) порядка байт"
  
-#, fuzzy
+#
  #~ msgid "-mabi=\tSpecify ABI to use"
-#~ msgstr "Использовать указанный ABI"
+#~ msgstr "-mabi=\tСпецифицировать ABI для использования"
  
  #~ msgid "Prepend the name of the cpu to all public symbol names"
  #~ msgstr "Добавлять название процессора ко всем символам"
  
-#, fuzzy
+#
  #~ msgid "-mtext=SECTION\tPut functions in SECTION"
-#~ msgstr "Помещать функции в СЕКЦИЮ"
+#~ msgstr "-mtext=SECTION\tПомещать функции в SECTION"
  
-#, fuzzy
+#
  #~ msgid "-mdata=SECTION\tPut data in SECTION"
-#~ msgstr "Помещать данные в СЕКЦИЮ"
+#~ msgstr "-mdata=SECTION\tПомещать данные в SECTION"
  
-#, fuzzy
+#
  #~ msgid "-mrodata=SECTION\tPut read-only data in SECTION"
-#~ msgstr "Помещать данные только для чтения в СЕКЦИЮ"
+#~ msgstr "-mrodata=SECTION\tПомещать данные только для чтения в SECTION"
  
  #~ msgid "Alias for -mfloat-abi=hard"
  #~ msgstr "Замена для -mflat-abi=hard"
@@ -62567,17 +67677,17 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "Indicate the number of soft registers available"
  #~ msgstr "Число доступных программных псевдорегистров"
  
-#, fuzzy
+#
  #~ msgid "Conform to the ISO 1998 C++ standard, with extensions that are likely to"
-#~ msgstr "Компилировать в соответствии с ISO 1998 C++ с расширениями GNU"
+#~ msgstr "Компилировать в соответствии с ISO 1998 C++ с расширениями вероятными для"
  
-#, fuzzy
+#
  #~ msgid "Conform to the ISO 1998 C++ standard, with GNU extensions and"
-#~ msgstr "Компилировать в соответствии с ISO 1998 C++ с расширениями GNU"
+#~ msgstr "Компилировать в соответствии с ISO 1998 C++ с расширениями GNU и"
  
-#, fuzzy
+#
  #~ msgid "Generate debug information to support Identical Code Folding (ICF)"
-#~ msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¾Ñ\82Ð»Ð°Ð´Ð¾Ñ\87Ð½Ñ\83Ñ\8e Ð¸Ð½Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\86Ð¸Ñ\8e Ð² Ñ\80Ð°Ñ\81Ñ\88Ð¸Ñ\80ÐµÐ½Ð½Ð¾Ð¼ Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\82Ðµ XCOFF"
+#~ msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¾Ñ\82Ð»Ð°Ð´Ð¾Ñ\87Ð½Ñ\83Ñ\8e Ð¸Ð½Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\86Ð¸Ñ\8e Ð´Ð»Ñ\8f Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶ÐºÐ¸ Identical Code Folding (ICF)"
  
  #~ msgid "Pay attention to the \"inline\" keyword"
  #~ msgstr "Принимать во внимание спецификаторы \"inline\""
@@ -62585,55 +67695,55 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "Integrate simple functions into their callers"
  #~ msgstr "Подставлять тела простых функций в места вызовов"
  
-#, fuzzy
+#
  #~ msgid "Perform structure layout optimizations based"
-#~ msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¿Ð¾Ð½Ð¸Ð¶ÐµÐ½Ð¸Ðµ Ð¼Ð¾Ñ\89Ð½Ð¾Ñ\81Ñ\82Ð¸ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¹"
+#~ msgstr "Ð\92Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ñ\8c Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ñ\80Ð°Ñ\81Ð¿Ð¾Ð»Ð¾Ð¶ÐµÐ½Ð¸Ñ\8f Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\82Ñ\83Ñ\80 Ð½Ð° Ð¾Ñ\81Ð½Ð¾Ð²Ðµ"
  
-#, fuzzy
+#
  #~ msgid "floating point constant truncated to integer"
-#~ msgstr "Ð´ÐµÐ»ÐµÐ½Ð¸Ðµ Ð½Ð° Ð½Ð¾Ð»Ñ\8c Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89ÐµÐ¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ñ\8b"
+#~ msgstr "Ð\9fÐ»Ð°Ð²Ð°Ñ\8eÑ\89Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° Ñ\83Ñ\81ÐµÑ\87ÐµÐ½Ð° Ð´Ð¾ Ñ\86ÐµÐ»Ð¾Ð³Ð¾"
  
-#, fuzzy
+#
  #~ msgid "arguments 1 and 2 have different types"
-#~ msgstr "Ð Ð°Ð·Ñ\80ÐµÑ\88Ð¸Ñ\82Ñ\8c Ñ\80Ð°Ð·Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b Ð´Ð»Ñ\8f Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ '?'"
+#~ msgstr "Ð\90Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ñ\8b 1 Ð¸ 2 Ð¸Ð¼ÐµÑ\8eÑ\82 Ñ\80Ð°Ð·Ð½Ñ\8bÐµ Ñ\82Ð¸Ð¿Ñ\8b"
  
-#, fuzzy
+#
  #~ msgid "invalid new of function type"
-#~ msgstr "некорректное приведение к типу функции %qT"
+#~ msgstr "некорректное new типа функции"
  
-#, fuzzy
+#
  #~ msgid "not enough values in return statement"
-#~ msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾Ðµ lvalue-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ asm"
+#~ msgstr "Ð½ÐµÐ´Ð¾Ñ\81Ñ\82Ð°Ñ\82Ð¾Ñ\87Ð½Ð¾ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ð¹ Ð² Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð°"
  
-#, fuzzy
+#
  #~ msgid "edge points to same body alias:"
-#~ msgstr "дуга указывает на неверную декларацию:"
+#~ msgstr "дуга указывает на тот же синоним тела:"
  
  #~ msgid "coverage mismatch for function %u while reading execution counters"
  #~ msgstr "несоответствие покрытия для функции %u при чтении счётчиков выполнения"
  
-#, fuzzy
+#
  #~ msgid "no coverage for function %qE found"
-#~ msgstr "не найдено покрытие для функции %qs"
+#~ msgstr "не найдено покрытие для функции %qE"
  
-#, fuzzy
+#
  #~ msgid "coverage mismatch for function %qE while reading counter %qs"
-#~ msgstr "несоответствие покрытия для функции %qs при чтении счётчика %qs"
+#~ msgstr "несоответствие покрытия для функции %qE при чтении счётчика %qs"
  
  #~ msgid "DW_LOC_OP %s not implemented"
  #~ msgstr "DW_LOC_OP %s не реализован"
  
-#, fuzzy
+#
  #~ msgid "use of obsolete %%[ operator in specs"
-#~ msgstr "Ð¿Ñ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´ÐµÐ½Ð¸Ðµ: Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88ÐµÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ %%[ Ð² specs"
+#~ msgstr "Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ñ\83Ñ\81Ñ\82Ð°Ñ\80ÐµÐ²Ñ\88ÐµÐ³Ð¾ %%[ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° Ð² Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ñ\8fÑ\85"
  
-#, fuzzy
+#
  #~ msgid "optimization options not supported yet"
-#~ msgstr "Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð´Ð»Ñ\8f Ð³Ñ\80Ð°Ð½Ð¸Ñ\86Ñ\8b Ñ\81Ñ\82ÐµÐºÐ° Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°Ðµтся"
+#~ msgstr "Ð¾Ð¿Ñ\86Ð¸Ð¸ Ð¾Ð¿Ñ\82Ð¸Ð¼Ð¸Ð·Ð°Ñ\86Ð¸Ð¸ Ð¿Ð¾ÐºÐ° Ð½Ðµ Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶Ð¸Ð²Ð°Ñ\8eтся"
  
-#, fuzzy
+#
  #~ msgid "-fira-algorithm=CB does not work on this architecture"
-#~ msgstr "-freorder-blocks-and-partition не работает для заданной архитектуры"
+#~ msgstr "-fira-algorithm=CB не работает для заданной архитектуры"
  
  #~ msgid "type size can%'t be explicitly evaluated"
  #~ msgstr "размер типа невозможно вычислить явно"
@@ -62641,24 +67751,24 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "variable-size type declared outside of any function"
  #~ msgstr "тип переменного размера декларирован вне функции"
  
-#, fuzzy
+#
  #~ msgid "type mismatch in binary truth expression"
-#~ msgstr "несоответствие типов в условном выражении"
+#~ msgstr "несоответствие типов в бинарном истинностном выражении"
  
-#, fuzzy
+#
  #~ msgid "invalid COND_EXPR in gimple assignment"
-#~ msgstr "некорректная левая часть в присваивании"
+#~ msgstr "некорректная COND_EXPR в gimple присваивании"
  
-#, fuzzy
+#
  #~ msgid "invalid GIMPLE statement"
-#~ msgstr "не является корректным оператором GIMPLE"
+#~ msgstr "некорректный оператор GIMPLE"
  
  #~ msgid "verify_stmts failed"
  #~ msgstr "процедура verify_stmts выявила ошибки"
  
-#, fuzzy
+#
  #~ msgid "statement makes a memory store, but has no VDEFS"
-#~ msgstr "оператор производит записи в перекрывающуюся область, но не имеет флага V_MAY_DEFS"
+#~ msgstr "оператор производит запись в память но не имеет VDEFS"
  
  #~ msgid "-mieee not supported on Unicos/Mk"
  #~ msgstr "-mieee не поддерживается для Unicos/Mk"
@@ -62684,48 +67794,48 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "%qs appears to be a misspelled interrupt handler"
  #~ msgstr "%qs возможно некорректно названный обработчик прерывания"
  
-#, fuzzy
+#
  #~ msgid "unknown ABI (%s) for %sabi=%s %s"
-#~ msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ ABI: '%s'"
+#~ msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ ABI (%s) Ð´Ð»Ñ\8f %sabi=%s %s"
  
-#, fuzzy
+#
  #~ msgid "bad value (%s) for %scmodel=%s %s"
-#~ msgstr "некорректное значение (%s) для ключа -mcmodel"
+#~ msgstr "некорректное значение (%s) для ключа %scmodel=%s %s"
  
-#, fuzzy
+#
  #~ msgid "bad value (%s) for %sasm=%s %s"
-#~ msgstr "некорректное значение (%s) для ключа -masm"
+#~ msgstr "некорректное значение (%s) для ключа %sasm=%s %s"
  
-#, fuzzy
+#
  #~ msgid "%slarge-data-threshold=%d%s is negative"
-#~ msgstr "-mlarge-data-threshold=%d - отрицательное значение"
+#~ msgstr "%slarge-data-threshold=%d%s отрицателен"
  
-#, fuzzy
+#
  #~ msgid "bad value (%s) for %stls-dialect=%s %s"
-#~ msgstr "некорректное значение (%s) для ключа -mtls-dialect"
+#~ msgstr "некорректное значение (%s) для ключа %stls-dialect=%s %s"
  
-#, fuzzy
+#
  #~ msgid "bad value (%s) for %sfpmath=%s %s"
-#~ msgstr "некорректное значение (%s) для ключа -mfpmath"
+#~ msgstr "некорректное значение (%s) для ключа %sfpmath=%s %s"
  
-#, fuzzy
+#
  #~ msgid "%qE attribute only available for 64-bit"
-#~ msgstr "атрибут %qs допустим только для переменных"
+#~ msgstr "атрибут %qE допустим только для 64-бит"
  
-#, fuzzy
+#
  #~ msgid "vector permutation requires vector constant"
-#~ msgstr "Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ñ\81 ÐºÐ¾Ð´Ð¾Ð¼ 'o' - Ð½Ðµ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð°"
+#~ msgstr "Ð¿ÐµÑ\80ÐµÑ\81Ñ\82Ð°Ð½Ð¾Ð²ÐºÐ° Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð° Ñ\82Ñ\80ÐµÐ±Ñ\83ÐµÑ\82 Ð²ÐµÐºÑ\82Ð¾Ñ\80Ð½Ð¾Ð¹ ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ñ\8b"
  
-#, fuzzy
+#
  #~ msgid "invalid vector permutation constant"
-#~ msgstr "некорректный знак %qc в ограничителе"
+#~ msgstr "некорректная константа перестановки вектора"
  
  #~ msgid "ms-bitfields not supported for objc"
  #~ msgstr "ms-bitfields не поддерживается для objc"
  
-#, fuzzy
+#
  #~ msgid "bad value %<%s%> for -mtune= switch"
-#~ msgstr "некорректное значение (%s) для ключа -mtune="
+#~ msgstr "некорректное значение %<%s%> для ключа -mtune="
  
  #~ msgid "-f%s ignored for 68HC11/68HC12 (not supported)"
  #~ msgstr "ключ -f%s игнорируется для 68HC11/68HC12 (не поддерживается)"
@@ -62736,74 +67846,74 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "%<trap%> attribute is already used"
  #~ msgstr "атрибут %<trap%> уже использован"
  
-#, fuzzy
+#
  #~ msgid "CPU names must be lower case"
-#~ msgstr "имя процессора задается строчными буквами"
+#~ msgstr "CPU имена задаются строчными буквами"
  
  #~ msgid "unknown -m%s= option specified: '%s'"
  #~ msgstr "некорректный ключ -m%s=: '%s'"
  
-#, fuzzy
+#
  #~ msgid "invalid option for -mcmodel: '%s'"
-#~ msgstr "некорректный аргумент ключа %qs"
+#~ msgstr "некорректный аргумент ключа -mcmodel: '%s'"
  
  #~ msgid "unknown ABI specified: '%s'"
  #~ msgstr "Некорректное значение ABI: '%s'"
  
-#, fuzzy
+#
  #~ msgid "bad value (%s) for -mcpu"
-#~ msgstr "некорректный аргумент %qs для ключа -mcpu"
+#~ msgstr "некорректное значение (%s) для ключа -mcpu"
  
-#, fuzzy
+#
  #~ msgid "bad value (%s) for -mtune"
-#~ msgstr "некорректное значение (%s) для ключа -mtune="
+#~ msgstr "некорректное значение (%s) для ключа -mtune"
  
-#, fuzzy
+#
  #~ msgid "unknown -mtraceback arg %qs; expecting %<full%>, %<partial%> or %<none%>"
-#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %qs ÐºÐ»Ñ\8eÑ\87Ð° -mtraceback; Ð´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ñ\8bÐµ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f `full', `partial', `none'"
+#~ msgstr "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %qs ÐºÐ»Ñ\8eÑ\87Ð° -mtraceback; Ð¾Ð¶Ð¸Ð´Ð°Ð»Ð¾Ñ\81Ñ\8c %<full%>, %<partial%> Ð¸Ð»Ð¸ %<none%>"
  
-#, fuzzy
+#
  #~ msgid "invalid option for -mfloat-gprs: '%s'"
-#~ msgstr "некорректный аргумент ключа %qs"
+#~ msgstr "некорректный аргумент ключа -mfloat-gprs: '%s'"
  
  #~ msgid "unknown -malign-XXXXX option specified: '%s'"
  #~ msgstr "некорректный ключ -malign-XXXXX: '%s'"
  
-#, fuzzy
+#
  #~ msgid "unrecognized argument '%s' to -mcpu= option"
-#~ msgstr "ÐºÐ»Ñ\8eÑ\87 '%s' Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð¾Ð²"
+#~ msgstr "Ð½ÐµÐ¾Ð¿Ð¾Ð·Ð½Ð°Ð½Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 '%s' Ð´Ð»Ñ\8f -mcpu= Ð¾Ð¿Ñ\86Ð¸Ð¸"
  
-#, fuzzy
+#
  #~ msgid "frame size of function %qs is "
-#~ msgstr "размер %qD в памяти неизвестен"
+#~ msgstr "размер кадра функции %qs есть "
  
-#, fuzzy
+#
  #~ msgid "%qE declared as both exported to and imported from a DLL"
-#~ msgstr "имя %qs декларировано как DLL экспортируемое и импортируемое"
+#~ msgstr "%qE декларировано как DLL экспортируемое и импортируемое"
  
-#, fuzzy
+#
  #~ msgid "failure in redeclaration of %q+D: dllimport%'d symbol lacks external linkage"
-#~ msgstr "%Jнекорректная повторная декларация %qD: dllimport-символ - не внешний."
+#~ msgstr "некорректная редекларация %q+D: dllimport символ не имеет внешней связи"
  
-#, fuzzy
+#
  #~ msgid "%s %q+D %s after being referenced with dllimport linkage"
-#~ msgstr "%J%qD определен локально после ссылки на него как на dllimport"
+#~ msgstr "%s %q+D %s после ссылки на него с dllimport связью"
  
-#, fuzzy
+#
  #~ msgid "function %q+D is defined after prior declaration as dllimport: attribute ignored"
-#~ msgstr "%Jфункция %qD определена до декларации с атрибутом dllimport: атрибут игнорируется"
+#~ msgstr "функция %q+D определена после предшествующей декларации как dllimport: атрибут игнорируется"
  
-#, fuzzy
+#
  #~ msgid "inline function %q+D is declared as dllimport: attribute ignored"
-#~ msgstr "%Jinline функция %qD декларирована как dllimport: атрибут игнорируется."
+#~ msgstr "inline функция %q+D декларирована как dllimport: атрибут игнорируется."
  
-#, fuzzy
+#
  #~ msgid "repeated using declaration %q+D"
-#~ msgstr "Ð´Ð»Ñ\8f Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ñ\88Ð°Ð±Ð»Ð¾Ð½Ð° %qD"
+#~ msgstr "Ð¿Ð¾Ð²Ñ\82Ð¾Ñ\80Ð½Ð¾Ðµ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ %q+D"
  
-#, fuzzy
+#
  #~ msgid "using declaration %q+D conflicts with a previous using declaration"
-#~ msgstr "%Jсекция, заданная для %qD, противоречит предшествующей декларации"
+#~ msgstr "использование декларации %q+D конфликтует с предшествующим использованием декларации"
  
  #~ msgid "argument of type %qT does not match %qT"
  #~ msgstr "аргумент типа %qT не соответствует типу %qT"
@@ -62814,9 +67924,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "cannot initialize %qT from %qT"
  #~ msgstr "недопустимая инициализация %qT из %qT"
  
-#, fuzzy
+#
  #~ msgid "%<__int128%> invalid for %qs"
-#~ msgstr "недопустимо использовать %<long%> для %qs"
+#~ msgstr "%<__int128%> некорректно для %qs"
  
  #~ msgid "ISO C++ forbids initialization of member %qD"
  #~ msgstr "ISO C++ запрещает инициализацию элемента %qD"
@@ -62824,83 +67934,91 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "making %qD static"
  #~ msgstr "в результате которой %qD становится статическим"
  
-#, fuzzy
+#
+#~ msgid "parameter packs must be at the end of the parameter list"
+#~ msgstr "parameter packs должны быть в конце списка параметров"
+
+#
  #~ msgid "value-initialization of %q#D, which has reference type"
-#~ msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¿Ð¾ Ñ\83Ð¼Ð¾Ð»Ñ\87Ð°Ð½Ð¸Ñ\8e Ð´Ð»Ñ\8f `%#D', имеющего тип ссылки"
+#~ msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ñ\8f Ð´Ð»Ñ\8f %q#D, имеющего тип ссылки"
  
-#, fuzzy
+#
  #~ msgid "uninitialized base %qT in %<constexpr%> constructor"
-#~ msgstr "неинициализированный элемент %qD константного типа %qT"
+#~ msgstr "неинициализированная база %qT в %<constexpr%> конструкторе"
  
  #~ msgid "ISO C++ forbids initialization in array new"
  #~ msgstr "ISO C++ запрещает использовать инициализацию при создании массивов с помощью new"
  
-#, fuzzy
+#
  #~ msgid "mangling new-expression"
-#~ msgstr "подавление присваивания"
+#~ msgstr "разборка new-expression"
  
-#, fuzzy
+#
  #~ msgid "%qE is not a valid template argument for type %qT because function %qD has not external linkage"
-#~ msgstr "строковый литерал %E  не является корректным аргументом шаблона, потому что это адрес статического объекта"
+#~ msgstr "%qE не является корректным аргументом шаблона для типа %qT поскольку функция %qD не имеет внешней связи"
  
  #~ msgid "base class %qT has cv qualifiers"
  #~ msgstr "базовый класс %qT имеет квалификаторы cv"
  
-#, fuzzy
+#
  #~ msgid "%qE refers to a set of overloaded functions"
-#~ msgstr "%s: ошибка при определении адреса перегруженной функции"
+#~ msgstr "%qE ссылается на множество перегруженных функций"
  
-#, fuzzy
+#
  #~ msgid "incomplete type %qT not allowed"
-#~ msgstr "Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT Ð½Ðµ Ð¸Ð¼ÐµÐµÑ\82 Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð° %qD"
+#~ msgstr "Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ %qT Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f"
  
-#, fuzzy
+#
  #~ msgid "enclosing class of %q#D is not a literal type"
-#~ msgstr "%qs не является именем типа"
+#~ msgstr "объемлющий класс от %q#D не есть литеральный тип"
  
-#, fuzzy
+#
  #~ msgid "%qE is not a potential constant expression"
-#~ msgstr "%s не может присутствовать в константном выражении"
+#~ msgstr "%qE не есть потенциальное константное выражение"
  
-#, fuzzy
+#
  #~ msgid "object argument is not a potential constant expression"
-#~ msgstr "размер массива не является целочисленным константным выражением"
+#~ msgstr "объектный аргумент не есть потенциальное константное выражение"
  
-#, fuzzy
+#
  #~ msgid "argument in position %qP is not a potential constant expression"
-#~ msgstr "размер массива %qD не является целочисленным константным выражением"
+#~ msgstr "аргумент в позиции %qP не есть потенциальное константное выражение"
  
-#, fuzzy
+#
  #~ msgid "Expected a PURE procedure for argument '%s' at %L"
-#~ msgstr "Ð¿ÐµÑ\80ÐµÐ´Ð°Ð½Ð¾ %qT Ð´Ð»Ñ\8f %s %P Ð² %qD"
+#~ msgstr "Ð\9eÐ¶Ð¸Ð´Ð°Ð»Ð°Ñ\81Ñ\8c PURE Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° Ð´Ð»Ñ\8f Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° '%s' Ð² %L"
  
-#, fuzzy
+#
  #~ msgid "Allocation would exceed memory limit -- malloc() failed"
  #~ msgstr "Свободная память закончилась - malloc() завершился ошибкой"
  
-#, fuzzy
+#
+#~ msgid "Variable must not be polymorphic in assignment at %L"
+#~ msgstr "переменная не должна быть полиморфной в присваивании в %L"
+
+#
  #~ msgid "Invalid SHIFT argument of DSHIFTL at %L"
-#~ msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qs"
+#~ msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ SHIFT Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 DSHIFTL Ð² %L"
  
-#, fuzzy
+#
  #~ msgid "Invalid second argument of IBCLR at %L"
-#~ msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qs"
+#~ msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 IBCLR Ð² %L"
  
-#, fuzzy
+#
  #~ msgid "Invalid second argument of IBITS at %L"
-#~ msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qs"
+#~ msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 IBITS Ð² %L"
  
-#, fuzzy
+#
  #~ msgid "Invalid second argument of %s at %L"
-#~ msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qs"
+#~ msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 %s Ð² %L"
  
-#, fuzzy
+#
  #~ msgid "Invalid second argument of ISHFTC at %L"
-#~ msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qs"
+#~ msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ISHFTC Ð² %L"
  
-#, fuzzy
+#
  #~ msgid "Invalid third argument of ISHFTC at %L"
-#~ msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qs"
+#~ msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\82Ñ\80ÐµÑ\82Ð¸Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 ISHFTC Ð² %L"
  
  #~ msgid ""
  #~ "Internal error: %s (program %s)\n"
@@ -63134,9 +68252,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "The maximum number of fields in a structure variable without direct structure accesses that GCC will attempt to track separately"
  #~ msgstr "Максимальное число полей в структурной переменной без прямого доступа к структуре, которые gcc будет пытаться обрабатывать индивидуально"
  
-#, fuzzy
+#
  #~ msgid "The maximum number of elements in an array for wich we track its elements separately"
-#~ msgstr "Максимальный коэффициент для полной раскатки цикла"
+#~ msgstr "Максимальное число элементов в массиве для которых мы отслеживаем их элементы отдельно"
  
  #~ msgid "The maximum structure size (in bytes) for which GCC will use by-element copies"
  #~ msgstr "Максимальный размер структуры (в байтах), при котором будет применяться поэлементное копирование"
@@ -63156,13 +68274,13 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "The maximum memory locations recorded by flow"
  #~ msgstr "Максимальное число позиций в памяти, записываемых flow"
  
-#, fuzzy
+#
  #~ msgid "The maximum number of virtual operators that a function is allowed to have before triggering memory partitioning heuristics"
-#~ msgstr "Максимальное число виртуальных операндов, которые могут представлять алиасы, по достижении которого предпринимается группирование алиасов"
+#~ msgstr "Максимальное число виртуальных операторов которые функции разрешено иметь до включения эвристик разбиения памяти"
  
-#, fuzzy
+#
  #~ msgid "The average number of virtual operators that memory statements are allowed to have before triggering memory partitioning heuristics"
-#~ msgstr "Ð\9cÐ°ÐºÑ\81Ð¸Ð¼Ð°Ð»Ñ\8cÐ½Ð¾Ðµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð²Ð¸Ñ\80Ñ\82Ñ\83Ð°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ð¾Ð², ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐµ Ð¼Ð¾Ð³Ñ\83Ñ\82 Ð¿Ñ\80ÐµÐ´Ñ\81Ñ\82Ð°Ð²Ð»Ñ\8fÑ\82Ñ\8c Ð°Ð»Ð¸Ð°Ñ\81Ñ\8b, Ð¿Ð¾ Ð´Ð¾Ñ\81Ñ\82Ð¸Ð¶ÐµÐ½Ð¸Ð¸ ÐºÐ¾Ñ\82Ð¾Ñ\80Ð¾Ð³Ð¾ Ð¿Ñ\80ÐµÐ´Ð¿Ñ\80Ð¸Ð½Ð¸Ð¼Ð°ÐµÑ\82Ñ\81Ñ\8f Ð³Ñ\80Ñ\83Ð¿Ð¿Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð°Ð»Ð¸Ð°Ñ\81Ð¾Ð²"
+#~ msgstr "Ð¡Ñ\80ÐµÐ´Ð½ÐµÐµ Ñ\87Ð¸Ñ\81Ð»Ð¾ Ð²Ð¸Ñ\80Ñ\82Ñ\83Ð°Ð»Ñ\8cÐ½Ñ\8bÑ\85 Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð¾Ð² ÐºÐ¾Ñ\82Ð¾Ñ\80Ñ\8bÐµ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð°Ð¼ Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸ Ñ\80Ð°Ð·Ñ\80ÐµÑ\88ÐµÐ½Ð¾ Ð¸Ð¼ÐµÑ\82Ñ\8c Ð´Ð¾ Ð²ÐºÐ»Ñ\8eÑ\87ÐµÐ½Ð¸Ñ\8f Ñ\8dÐ²Ñ\80Ð¸Ñ\81Ñ\82Ð¸Ðº Ñ\80Ð°Ð·Ð±Ð¸ÐµÐ½Ð¸Ñ\8f Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸"
  
  #~ msgid "mt_final_prescan_insn, invalid insn #1"
  #~ msgstr "mt_final_prescan_insn, некорректная инструкция #1"
@@ -63182,9 +68300,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "duplicated initializer"
  #~ msgstr "повторный инициализатор"
  
-#, fuzzy
+#
  #~ msgid "DOUBLE COMPLEX at %C does not conform to the Fortran 95 standard"
-#~ msgstr "Компилировать в соответствии с ISO 1990 C"
+#~ msgstr "DOUBLE COMPLEX в %C не согласуется с Fortran 95 стандартом"
  
  #~ msgid "%-5d "
  #~ msgstr "%-5d "
@@ -63237,9 +68355,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "''"
  #~ msgstr "''"
  
-#, fuzzy
+#
  #~ msgid ") // '"
-#~ msgstr "// "
+#~ msgstr ") // '"
  
  #~ msgid "%s("
  #~ msgstr "%s("
@@ -63271,9 +68389,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "???"
  #~ msgstr "???"
  
-#, fuzzy
+#
  #~ msgid " {"
-#~ msgstr " "
+#~ msgstr " {"
  
  #~ msgid "%s:"
  #~ msgstr "%s:"
@@ -63317,9 +68435,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "= "
  #~ msgstr "= "
  
-#, fuzzy
+#
  #~ msgid "/= "
-#~ msgstr "/ "
+#~ msgstr "/= "
  
  #~ msgid "> "
  #~ msgstr "> "
@@ -63363,13 +68481,13 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid " POINTER"
  #~ msgstr " POINTER"
  
-#, fuzzy
+#
  #~ msgid " PROTECTED"
-#~ msgstr " FORMATTED"
+#~ msgstr " PROTECTED"
  
-#, fuzzy
+#
  #~ msgid " THREADPRIVATE"
-#~ msgstr " READWRITE="
+#~ msgstr " THREADPRIVATE"
  
  #~ msgid " TARGET"
  #~ msgstr " TARGET"
@@ -63458,33 +68576,33 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid " from namespace %s"
  #~ msgstr " из пространства имён %s"
  
-#, fuzzy
+#
  #~ msgid "%s,"
-#~ msgstr "%s"
+#~ msgstr "%s,"
  
-#, fuzzy
+#
  #~ msgid " (%s)"
-#~ msgstr " %s"
+#~ msgstr " (%s)"
  
-#, fuzzy
+#
  #~ msgid " ("
-#~ msgstr ", ("
+#~ msgstr " ("
  
-#, fuzzy
+#
  #~ msgid " ORDERED"
-#~ msgstr " OPENED="
+#~ msgstr " ORDERED"
  
-#, fuzzy
+#
  #~ msgid " REDUCTION(%s:"
-#~ msgstr " FUNCTION"
+#~ msgstr " REDUCTION(%s:"
  
-#, fuzzy
+#
  #~ msgid " %s("
-#~ msgstr "%s("
+#~ msgstr " %s("
  
-#, fuzzy
+#
  #~ msgid " NOWAIT"
-#~ msgstr " UNIT="
+#~ msgstr " NOWAIT"
  
  #~ msgid "NOP"
  #~ msgstr "NOP"
@@ -63756,47 +68874,47 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "Pointer assignment to non-POINTER at %L"
  #~ msgstr "Присваивание указателя не к указателю в %L"
  
-#, fuzzy
+#
  #~ msgid "argument to '%s' missing"
-#~ msgstr "отсутствует аргумент для '%s'\n"
+#~ msgstr "отсутствует аргумент для '%s'"
  
  #~ msgid "Unexpected element"
  #~ msgstr "Неожиданный элемент"
  
-#, fuzzy
+#
  #~ msgid "Assumed character length '%s' in namelist '%s' at %C is not allowed"
-#~ msgstr "Ð\90Ð»Ñ\8cÑ\82ÐµÑ\80Ð½Ð°Ñ\82Ð¸Ð²Ð½Ñ\8bÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80 Ð²Ð¾Ð·Ð²Ñ\80Ð°Ñ\82Ð° Ð² %0 Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82ÐµÐ½ Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸"
+#~ msgstr "Ð\9fÑ\80ÐµÐ´Ð¿Ð¾Ð»Ð°Ð³Ð°ÐµÐ¼Ð°Ñ\8f character Ð´Ð»Ð¸Ð½Ð° '%s' Ð² Ñ\81Ð¿Ð¸Ñ\81ÐºÐµ Ð¸Ð¼ÐµÐ½ '%s' Ð² %C Ð½Ðµ Ð´Ð¾Ð¿Ñ\83Ñ\81ÐºÐ°ÐµÑ\82Ñ\81Ñ\8f"
  
-#, fuzzy
+#
  #~ msgid "Assigning to PROTECTED variable at %C"
-#~ msgstr "%s по отношению к переменной %qs, доступной только на чтение"
+#~ msgstr "Присваивание PROTECTED переменной в %C"
  
-#, fuzzy
+#
  #~ msgid "STAT tag in %s statement at %L must be of type INTEGER"
-#~ msgstr "оператор-выражение имеет неполный тип"
+#~ msgstr "STAT тег в %s операторе в %L должен быть типа INTEGER"
  
-#, fuzzy
+#
  #~ msgid "Intrinsic '%s' at %L does not exist"
-#~ msgstr "%s: определение функции %qs не преобразовано\n"
+#~ msgstr "Встроенная '%s' в %L не существует"
  
-#, fuzzy
+#
  #~ msgid "iterator end at %L does not simplify"
-#~ msgstr "%s: определение функции %qs не преобразовано\n"
+#~ msgstr "конец итератора в %L не упрощается"
  
-#, fuzzy
+#
  #~ msgid "Can't open included file '%s'"
-#~ msgstr "ошибка открытия входного файла %qs"
+#~ msgstr "ошибка открытия включаемого файла '%s'"
  
-#, fuzzy
+#
  #~ msgid "Integer too large in shape specification at %L"
-#~ msgstr "Ð¿Ð¾Ñ\81Ð»Ðµ Ð¿Ñ\80ÐµÐ´Ñ\8bÐ´Ñ\83Ñ\89ÐµÐ¹ Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ð² `%#D'"
+#~ msgstr "Ð¦ÐµÐ»Ð¾Ðµ Ñ\81Ð»Ð¸Ñ\88ÐºÐ¾Ð¼ Ð²ÐµÐ»Ð¸ÐºÐ¾ Ð² Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\86Ð¸Ð¸ Ñ\84Ð¾Ñ\80Ð¼Ñ\8b Ð² %L"
  
  #~ msgid "Array bound mismatch"
  #~ msgstr "Границы массива не совпадают"
  
-#, fuzzy
+#
  #~ msgid "Out of memory"
-#~ msgstr "Ð½ÐµÐ´Ð¾Ñ\81Ñ\82Ð°Ñ\82Ð¾Ñ\87Ð½Ð¾ Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸"
+#~ msgstr "Ð\98Ñ\81Ñ\87ÐµÑ\80Ð¿Ð°Ð½Ð° Ð¿Ð°Ð¼Ñ\8fÑ\82Ñ\8c"
  
  #~ msgid "mno-cygwin and mno-win32 are not compatible"
  #~ msgstr "mno-cygwin и mno-win32 несовместимы"
@@ -63810,9 +68928,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "Add a directory for INCLUDE and MODULE searching"
  #~ msgstr "Добавить каталог для поиска INCLUDE и MODULE"
  
-#, fuzzy
+#
  #~ msgid "Treat the input file as preprocessed"
-#~ msgstr "Ð¡Ñ\87Ð¸Ñ\82Ð°Ñ\82Ñ\8c, Ñ\87Ñ\82Ð¾ Ð²Ñ\85Ð¾Ð´Ð½Ð¾Ð¹ Ñ\84Ð°Ð¹Ð» Ñ\83Ð¶Ðµ Ð¿Ñ\80ÐµÐ¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
+#~ msgstr "Ð¢Ñ\80Ð°ÐºÑ\82Ð¾Ð²Ð°Ñ\82Ñ\8c Ð²Ñ\85Ð¾Ð´Ð½Ð¾Ð¹ Ñ\84Ð°Ð¹Ð» ÐºÐ°Ðº Ð¿Ñ\80ÐµÐ¿Ñ\80Ð¾Ñ\86ÐµÑ\81Ñ\81Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐ¹"
  
  #~ msgid "Set maximum alignment to 4"
  #~ msgstr "Максимальное выравнивание равно 4"
@@ -63826,9 +68944,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "Use the Cygwin interface"
  #~ msgstr "Использовать интерфейс Cygwin"
  
-#, fuzzy
+#
  #~ msgid "Enable automatic generation of fused floating point multiply-add instructions"
-#~ msgstr "Ð\93ÐµÐ½ÐµÑ\80Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ðµ ÐºÐ¾Ð¼Ð°Ð½Ð´Ñ\8b Ñ\83Ð¼Ð½Ð¾Ð¶ÐµÐ½Ð¸Ñ\8f Ñ\81 Ð½Ð°ÐºÐ¾Ð¿Ð»ÐµÐ½Ð¸ÐµÐ¼"
+#~ msgstr "Ð\92ÐºÐ»Ñ\8eÑ\87Ð¸Ñ\82Ñ\8c Ð°Ð²Ñ\82Ð¾Ð¼Ð°Ñ\82Ð¸Ñ\87ÐµÑ\81ÐºÑ\83Ñ\8e Ð³ÐµÐ½ÐµÑ\80Ð°Ñ\86Ð¸Ñ\8e Ñ\81Ð»Ð¸Ñ\82Ñ\8bÑ\85 Ð¿Ð»Ð°Ð²Ð°Ñ\8eÑ\89Ð¸Ñ\85 multiply-add Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¹"
  
  #~ msgid "Generate ELF output"
  #~ msgstr "Генерировать выходной файл в формате ELF"
@@ -63845,9 +68963,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "Output instruction sizes to the asm file"
  #~ msgstr "Выводить размеры команд в ассемблерный файл"
  
-#, fuzzy
+#
  #~ msgid "Use GNU libc instead of uClibc"
-#~ msgstr "Использовать ROM вместо RAM"
+#~ msgstr "Использовать GNU libc вместо uClibc"
  
  #~ msgid "Use the WindISS simulator"
  #~ msgstr "Использовать симулятор WindISS"
@@ -63894,9 +69012,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "If scheduling post reload, do trace scheduling"
  #~ msgstr "При планировании после распределения регистров, использовать метод трасс"
  
-#, fuzzy
+#
  #~ msgid "Perform sequence abstraction optimization on RTL"
-#~ msgstr "Выполнить понижение мощности операций"
+#~ msgstr "Выполнить последовательную оптимизацию абстракций на RTL"
  
  #~ msgid "Enable SSA-CCP optimization for stores and loads"
  #~ msgstr "Включить SSA-оптимизацию распространения констант для инструкций записи и загрузки"
@@ -63982,17 +69100,17 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "both %<long%> and %<float%> in declaration specifiers"
  #~ msgstr "для имени заданы несовместимые спецификаторы %<long%> и %<float%>"
  
-#, fuzzy
+#
  #~ msgid "both %<long%> and %<_Decimal32%> in declaration specifiers"
-#~ msgstr "в декларации заданы спецификаторы %<long%> и %<char%>"
+#~ msgstr "в спецификаторах декларации заданы и %<long%> и %<_Decimal32%>"
  
-#, fuzzy
+#
  #~ msgid "both %<long%> and %<_Decimal64%> in declaration specifiers"
-#~ msgstr "в декларации заданы спецификаторы %<long%> и %<char%>"
+#~ msgstr "в спецификаторах декларации заданы и %<long%> и %<_Decimal64%>"
  
-#, fuzzy
+#
  #~ msgid "both %<long%> and %<_Decimal128%> in declaration specifiers"
-#~ msgstr "в декларации заданы спецификаторы %<long%> и %<char%>"
+#~ msgstr "в спецификаторах декларации заданы и %<long%> и %<_Decimal128%>"
  
  #~ msgid "both %<short%> and %<void%> in declaration specifiers"
  #~ msgstr "в декларации использованы спецификаторы %<short%> и %<void%>"
@@ -64009,17 +69127,17 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "both %<short%> and %<double%> in declaration specifiers"
  #~ msgstr "в декларации использованы спецификаторы %<short%> и %<double%>"
  
-#, fuzzy
+#
  #~ msgid "both %<short%> and %<_Decimal32%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<short%> и %<char%>"
+#~ msgstr "в спецификаторах декларации заданы и %<short%> и %<_Decimal32%>"
  
-#, fuzzy
+#
  #~ msgid "both %<short%> and %<_Decimal64%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<short%> и %<char%>"
+#~ msgstr "в спецификаторах декларации заданы и %<short%> и %<_Decimal64%>"
  
-#, fuzzy
+#
  #~ msgid "both %<short%> and %<_Decimal128%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<short%> и %<char%>"
+#~ msgstr "в спецификаторах декларации заданы и %<short%> и %<_Decimal128%>"
  
  #~ msgid "both %<signed%> and %<unsigned%> in declaration specifiers"
  #~ msgstr "в декларации использованы спецификаторы %<signed%> и %<unsigned%>"
@@ -64036,17 +69154,17 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "both %<signed%> and %<double%> in declaration specifiers"
  #~ msgstr "в декларации использованы спецификаторы %<signed%> и %<double%>"
  
-#, fuzzy
+#
  #~ msgid "both %<signed%> and %<_Decimal32%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<signed%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<signed%> и %<_Decimal32%>"
  
-#, fuzzy
+#
  #~ msgid "both %<signed%> and %<_Decimal64%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<signed%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<signed%> и %<_Decimal64%>"
  
-#, fuzzy
+#
  #~ msgid "both %<signed%> and %<_Decimal128%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<signed%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<signed%> и %<_Decimal128%>"
  
  #~ msgid "both %<unsigned%> and %<void%> in declaration specifiers"
  #~ msgstr "в декларации использованы спецификаторы %<unsigned%> и %<void%>"
@@ -64060,17 +69178,17 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "both %<unsigned%> and %<double%> in declaration specifiers"
  #~ msgstr "в декларации использованы спецификаторы %<unsigned%> и %<double%>"
  
-#, fuzzy
+#
  #~ msgid "both %<unsigned%> and %<_Decimal32%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<unsigned%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<unsigned%> и %<_Decimal32%>"
  
-#, fuzzy
+#
  #~ msgid "both %<unsigned%> and %<_Decimal64%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<unsigned%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<unsigned%> и %<_Decimal64%>"
  
-#, fuzzy
+#
  #~ msgid "both %<unsigned%> and %<_Decimal128%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<unsigned%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<unsigned%> и %<_Decimal128%>"
  
  #~ msgid "both %<complex%> and %<void%> in declaration specifiers"
  #~ msgstr "в декларации использованы спецификаторы %<complex%> и %<void%>"
@@ -64078,89 +69196,89 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "both %<complex%> and %<_Bool%> in declaration specifiers"
  #~ msgstr "в декларации использованы спецификаторы %<complex%> и %<_Bool%>"
  
-#, fuzzy
+#
  #~ msgid "both %<complex%> and %<_Decimal32%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<complex%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<complex%> и %<_Decimal32%>"
  
-#, fuzzy
+#
  #~ msgid "both %<complex%> and %<_Decimal64%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<complex%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<complex%> и %<_Decimal64%>"
  
-#, fuzzy
+#
  #~ msgid "both %<complex%> and %<_Decimal128%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<complex%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<complex%> и %<_Decimal128%>"
  
-#, fuzzy
+#
  #~ msgid "both %<complex%> and %<_Fract%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<complex%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<complex%> и %<_Fract%>"
  
-#, fuzzy
+#
  #~ msgid "both %<complex%> and %<_Accum%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<complex%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<complex%> и %<_Accum%>"
  
-#, fuzzy
+#
  #~ msgid "both %<complex%> and %<_Sat%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<complex%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<complex%> и %<_Sat%>"
  
-#, fuzzy
+#
  #~ msgid "both %<_Sat%> and %<void%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<short%> и %<void%>"
+#~ msgstr "в спецификаторах декларации заданы и %<_Sat%> и %<void%>"
  
-#, fuzzy
+#
  #~ msgid "both %<_Sat%> and %<_Bool%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<short%> и %<_Bool%>"
+#~ msgstr "в спецификаторах декларации заданы и %<_Sat%> и %<_Bool%>"
  
-#, fuzzy
+#
  #~ msgid "both %<_Sat%> and %<int%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<short%> и %<void%>"
+#~ msgstr "в спецификаторах декларации заданы и %<_Sat%> и %<int%>"
  
-#, fuzzy
+#
  #~ msgid "both %<_Sat%> and %<float%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<short%> и %<float%>"
+#~ msgstr "в спецификаторах декларации заданы и %<_Sat%> и %<float%>"
  
-#, fuzzy
+#
  #~ msgid "both %<_Sat%> and %<double%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<short%> и %<double%>"
+#~ msgstr "в спецификаторах декларации заданы и %<_Sat%> и %<double%>"
  
-#, fuzzy
+#
  #~ msgid "both %<_Sat%> and %<_Decimal32%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<short%> и %<char%>"
+#~ msgstr "в спецификаторах декларации заданы и %<_Sat%> и %<_Decimal32%>"
  
-#, fuzzy
+#
  #~ msgid "both %<_Sat%> and %<_Decimal64%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<short%> и %<char%>"
+#~ msgstr "в спецификаторах декларации заданы и %<_Sat%> и %<_Decimal64%>"
  
-#, fuzzy
+#
  #~ msgid "both %<_Sat%> and %<_Decimal128%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<short%> и %<char%>"
+#~ msgstr "в спецификаторах декларации заданы и %<_Sat%> и %<_Decimal128%>"
  
-#, fuzzy
+#
  #~ msgid "both %<long long%> and %<%s%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<long long%> и %<double%>"
+#~ msgstr "в декларации использованы спецификаторы и %<long long%> и %<%s%>"
  
-#, fuzzy
+#
  #~ msgid "both %<long%> and %<%s%> in declaration specifiers"
-#~ msgstr "Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð·Ð°Ð´Ð°Ð½Ñ\8b Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ñ\8b %<long%> Ð¸ %<short%>"
+#~ msgstr "Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ñ\8b Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ñ\8b Ð¸ %<long%> Ð¸ %<%s%>"
  
-#, fuzzy
+#
  #~ msgid "both %<short%> and %<%s%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<short%> и %<void%>"
+#~ msgstr "в декларации использованы спецификаторы и %<short%> и %<%s%>"
  
-#, fuzzy
+#
  #~ msgid "both %<signed%> and %<%s%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<signed%> и %<void%>"
+#~ msgstr "в декларации использованы спецификаторы и %<signed%> и %<%s%>"
  
-#, fuzzy
+#
  #~ msgid "both %<unsigned%> and %<%s%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<unsigned%> и %<void%>"
+#~ msgstr "в декларации использованы спецификаторы и %<unsigned%> и %<%s%>"
  
-#, fuzzy
+#
  #~ msgid "both %<complex%> and %<%s%> in declaration specifiers"
-#~ msgstr "в декларации использованы спецификаторы %<complex%> и %<void%>"
+#~ msgstr "в декларации использованы спецификаторы и %<complex%> и %<%s%>"
  
-#, fuzzy
+#
  #~ msgid "both %<_Sat%> and %<%s%> in declaration specifiers"
-#~ msgstr "Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð·Ð°Ð´Ð°Ð½Ñ\8b Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ñ\8b %<long%> Ð¸ %<short%>"
+#~ msgstr "Ð² Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ñ\8b Ñ\81Ð¿ÐµÑ\86Ð¸Ñ\84Ð¸ÐºÐ°Ñ\82Ð¾Ñ\80Ñ\8b Ð¸ %<_Sat%> Ð¸ %<%s%>"
  
  #~ msgid "%s should have type %<%s%s%>, but argument %d has type %qT"
  #~ msgstr "%s должен иметь тип %<%s%s%>, но аргумент %d имеет тип %qT"
@@ -64168,21 +69286,21 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "%s should have type %<%T%s%>, but argument %d has type %qT"
  #~ msgstr "%s должен иметь тип %<%T%s%>, но аргумент %d имеет тип %qT"
  
-#, fuzzy
+#
  #~ msgid "The C++ parser does not support -dy, option ignored"
-#~ msgstr "реентерабельный код APCS не поддерживается. Ключ игнорируется."
+#~ msgstr "C++ парсер не поддерживает -dy, опция игнорируется"
  
-#, fuzzy
+#
  #~ msgid "%Hempty declaration"
-#~ msgstr "пустая декларация"
+#~ msgstr "%Hпустая декларация"
  
-#, fuzzy
+#
  #~ msgid "%Hcomma at end of enumerator list"
-#~ msgstr "запятая в конце списка значений перечислимого типа"
+#~ msgstr "%Hзапятая в конце списка значений перечислимого типа"
  
-#, fuzzy
+#
  #~ msgid "%H%qs is not valid for %qs"
-#~ msgstr "%qs не является корректным выходным файлом"
+#~ msgstr "%H%qs не является корректной для %qs"
  
  #~ msgid "#pragma pack(push[, id], <n>) is not supported on this target"
  #~ msgstr "#pragma pack(push[, id], <n>) для данной платформы не поддерживается"
@@ -64190,29 +69308,29 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "#pragma pack(pop[, id], <n>) is not supported on this target"
  #~ msgstr "#pragma pack(pop[, id], <n>) для данной платформы не поддерживается"
  
-#, fuzzy
+#
  #~ msgid "missing %<(%> after %<#pragma push_macro%> - ignored"
-#~ msgstr "отсутствует %<(%> после %<#pragma pack%> - директива проигнорирована"
+#~ msgstr "отсутствует %<(%> после %<#pragma push_macro%> - директива проигнорирована"
  
-#, fuzzy
+#
  #~ msgid "invalid constant in %<#pragma push_macro%> - ignored"
-#~ msgstr "некорректная константа в %<#pragma pack%> - директива проигнорирована"
+#~ msgstr "некорректная константа в %<#pragma push_macro%> - директива проигнорирована"
  
-#, fuzzy
+#
  #~ msgid "missing %<)%> after %<#pragma push_macro%> - ignored"
-#~ msgstr "отсутствует %<(%> после %<#pragma pack%> - директива проигнорирована"
+#~ msgstr "отсутствует %<)%> после %<#pragma push_macro%> - директива проигнорирована"
  
-#, fuzzy
+#
  #~ msgid "missing %<(%> after %<#pragma pop_macro%> - ignored"
-#~ msgstr "отсутствует %<(%> после %<#pragma pack%> - директива проигнорирована"
+#~ msgstr "отсутствует %<(%> после %<#pragma pop_macro%> - директива проигнорирована"
  
-#, fuzzy
+#
  #~ msgid "invalid constant in %<#pragma pop_macro%> - ignored"
-#~ msgstr "некорректная константа в %<#pragma pack%> - директива проигнорирована"
+#~ msgstr "некорректная константа в %<#pragma pop_macro%> - директива проигнорирована"
  
-#, fuzzy
+#
  #~ msgid "missing %<)%> after %<#pragma pop_macro%> - ignored"
-#~ msgstr "отсутствует %<(%> после %<#pragma pack%> - директива проигнорирована"
+#~ msgstr "отсутствует %<)%> после %<#pragma pop_macro%> - директива проигнорирована"
  
  #~ msgid "#pragma redefine_extname not supported on this target"
  #~ msgstr "#pragma redefine_extname не поддерживается для этой платформы"
@@ -64274,9 +69392,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "%qs is deprecated (declared at %s:%d)"
  #~ msgstr "устаревшая функция, переменная или тип %qs (декларация в %s:%d)"
  
-#, fuzzy
+#
  #~ msgid "GCC supports only %d input file changes"
-#~ msgstr "GCC поддерживает только %u вложенных областей видимости"
+#~ msgstr "GCC поддерживает только %d изменений файлов ввода"
  
  #~ msgid "-ffunction-sections may affect debugging on some targets"
  #~ msgstr "-ffunction-sections может затруднить отладку на некоторых платформах"
@@ -64290,37 +69408,37 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "invariant not recomputed when ADDR_EXPR changed"
  #~ msgstr "инвариант не перевычислен после изменения ADDR_EXPR"
  
-#, fuzzy
+#
  #~ msgid "type mismatch in unary expression"
-#~ msgstr "несоответствие типов в условном выражении"
+#~ msgstr "несоответствие типов в унарном выражении"
  
-#, fuzzy
+#
  #~ msgid "invalid operand in int to float conversion"
-#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
+#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸ int Ð² float"
  
-#, fuzzy
+#
  #~ msgid "invalid operand in float to int conversion"
-#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
+#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ð¸ float Ð² int"
  
-#, fuzzy
+#
  #~ msgid "invalid operands in shift expression"
-#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
+#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ñ\81Ð´Ð²Ð¸Ð³Ð°"
  
-#, fuzzy
+#
  #~ msgid "invalid operands in pointer plus expression"
-#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ð¸"
+#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð² Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ð¸ Ð¸Ð½ÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ð°Ñ\86Ð¸Ð¸ Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8f"
  
-#, fuzzy
+#
  #~ msgid "invalid operands in conditional expression"
-#~ msgstr "не lvalue-массив в условном выражении"
+#~ msgstr "некорректный операнд в условном выражении"
  
-#, fuzzy
+#
  #~ msgid "unexpected non-tuple"
-#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\83Ð·ÐµÐ»"
+#~ msgstr "Ð½ÐµÐ¾Ð¶Ð¸Ð´Ð°Ð½Ð½Ñ\8bÐ¹ non-tuple"
  
-#, fuzzy
+#
  #~ msgid "COND_EXPR with code in branches at the end of bb %d"
-#~ msgstr "структурный COND_EXPR в конце блока %d"
+#~ msgstr "COND_EXPR с кодом в ветвях в конце bb %d"
  
  #~ msgid "no default case found at end of case vector"
  #~ msgstr "случай default не найден в конце case-вектора"
@@ -64358,9 +69476,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "verify_flow_insensitive_alias_info failed"
  #~ msgstr "процедура verify_flow_insensitive_alias_info выявила ошибки"
  
-#, fuzzy
+#
  #~ msgid "dereferenced pointers should have a name or a symbol tag"
-#~ msgstr "Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c, Ð¿Ð¾ ÐºÐ¾Ñ\82Ð¾Ñ\80Ð¾Ð¼Ñ\83 Ð¾Ñ\81Ñ\83Ñ\89ÐµÑ\81Ñ\82Ð²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿, Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ð¸Ð¼Ñ\8f Ð¸Ð»Ð¸ Ñ\82ÐµÐ³ Ñ\82Ð¸Ð¿а"
+#~ msgstr "Ñ\83ÐºÐ°Ð·Ð°Ñ\82ÐµÐ»Ñ\8c, Ð¿Ð¾ ÐºÐ¾Ñ\82Ð¾Ñ\80Ð¾Ð¼Ñ\83 Ð¾Ñ\81Ñ\83Ñ\89ÐµÑ\81Ñ\82Ð²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f Ð´Ð¾Ñ\81Ñ\82Ñ\83Ð¿, Ð´Ð¾Ð»Ð¶ÐµÐ½ Ð¸Ð¼ÐµÑ\82Ñ\8c Ð¸Ð¼Ñ\8f Ð¸Ð»Ð¸ Ñ\82ÐµÐ³ Ñ\81Ð¸Ð¼Ð²Ð¾Ð»а"
  
  #~ msgid "pointers with a memory tag, should have points-to sets"
  #~ msgstr "указатели с тегом памяти должны иметь множества указуемых объектов"
@@ -64371,13 +69489,13 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "verify_flow_sensitive_alias_info failed"
  #~ msgstr "процедура verify_flow_sensitive_alias_info выявила ошибки"
  
-#, fuzzy
+#
  #~ msgid "verify_call_clobbering failed"
-#~ msgstr "Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° verify_cgraph_node Ð²Ñ\8bÑ\8fÐ²Ð¸Ð»Ð° Ð¾Ñ\88Ð¸Ð±ÐºÐ¸"
+#~ msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° verify_call_clobbering"
  
-#, fuzzy
+#
  #~ msgid "verify_memory_partitions failed"
-#~ msgstr "Ð¿Ñ\80Ð¾Ñ\86ÐµÐ´Ñ\83Ñ\80Ð° verify_name_tags Ð²Ñ\8bÑ\8fÐ²Ð¸Ð»Ð° Ð¾Ñ\88Ð¸Ð±ÐºÐ¸"
+#~ msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° verify_memory_partitions"
  
  #~ msgid "tree check: accessed elt %d of phi_node with %d elts in %s, at %s:%d"
  #~ msgstr "дерево: доступ к элементу %d узла phi_node с %d элементами в %s, на %s:%d"
@@ -64386,7 +69504,7 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgstr "weak декларация %q+D должна предшествовать определению"
  
  #~ msgid "weak declaration of %q+D after first use results in unspecified behavior"
-#~ msgstr "для weak декларации %q+D после первого использования поведение системыне специфицировано"
+#~ msgstr "для weak декларации %q+D после первого использования поведение системные специфицировано"
  
  #~ msgid "%Jonly weak aliases are supported in this configuration"
  #~ msgstr "%Jв данной конфигурации поддерживаются только слабые алиасы"
@@ -64406,16 +69524,16 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "large frame pointer change (%d) with -mtiny-stack"
  #~ msgstr "большое изменение указателя кадра (%d) при -mtiny-stack"
  
-#, fuzzy
+#
  #~ msgid "bf561 support is incomplete yet."
-#~ msgstr "Ð¿Ð¾Ð»Ðµ %qs Ð¸Ð¼ÐµÐµÑ\82 Ð½ÐµÐ¿Ð¾Ð»Ð½Ñ\8bÐ¹ Ñ\82Ð¸Ð¿"
+#~ msgstr "Ð¿Ð¾Ð´Ð´ÐµÑ\80Ð¶ÐºÐ° bf561 Ð¿Ð¾ÐºÐ° Ð½ÐµÐ¿Ð¾Ð»Ð½Ð°."
  
  #~ msgid "`%s' attribute only applies to functions"
  #~ msgstr "атрибут `%s' допустим только для функций"
  
-#, fuzzy
+#
  #~ msgid "`%s' attribute only applies to variables"
-#~ msgstr "атрибут %qs допустим только для переменных"
+#~ msgstr "атрибут `%s' допустим только для переменных"
  
  #~ msgid "Trampoline support for CRX"
  #~ msgstr "Поддержка трамплинов для CRX"
@@ -64423,24 +69541,24 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "shift must be an immediate"
  #~ msgstr "сдвиг должен быть непосредственным значением"
  
-#, fuzzy
+#
  #~ msgid "length mask must be an immediate"
-#~ msgstr "маска должна быть непосредственным значением"
+#~ msgstr "Ð¼Ð°Ñ\81ÐºÐ° Ð´Ð»Ð¸Ð½Ñ\8b Ð´Ð¾Ð»Ð¶Ð½Ð° Ð±Ñ\8bÑ\82Ñ\8c Ð½ÐµÐ¿Ð¾Ñ\81Ñ\80ÐµÐ´Ñ\81Ñ\82Ð²ÐµÐ½Ð½Ñ\8bÐ¼ Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸ÐµÐ¼"
  
  #~ msgid "not yet implemented: latency-optimized inline square root"
  #~ msgstr "не реализовано: inline-подстановка sqrt, оптимизированная по латентности"
  
-#, fuzzy
+#
  #~ msgid "`%s' attribute applies only to functions"
-#~ msgstr "%J%qE: атрибут допустим только для функций"
+#~ msgstr "`%s' атрибут допустим только для функций"
  
-#, fuzzy
+#
  #~ msgid "`%s' attribute argument not an integer constant"
-#~ msgstr "аргумент атрибута %qs не является целой константой"
+#~ msgstr "`%s' аргумент атрибута не является целой константой"
  
-#, fuzzy
+#
  #~ msgid "`%s' attribute ignored"
-#~ msgstr "атрибут %qs проигнорирован"
+#~ msgstr "`%s' атрибут проигнорирован"
  
  #~ msgid "missing argument to \"-%s\""
  #~ msgstr "отсутствует аргумент для \"-%s\""
@@ -64454,9 +69572,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "%s has no effect"
  #~ msgstr "%s не имеет побочных эффектов"
  
-#, fuzzy
+#
  #~ msgid "%q#D was used before it was declared inline"
-#~ msgstr "`%#D' использована до ее декларации как inline"
+#~ msgstr "%q#D использована до ее декларации как inline"
  
  #~ msgid "%Jprevious non-inline declaration here"
  #~ msgstr "%Jэто предыдущая не-inline декларация"
@@ -64464,9 +69582,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "%H  from here"
  #~ msgstr "%H  отсюда"
  
-#, fuzzy
+#
  #~ msgid "  enters scope of non-POD %q+#D"
-#~ msgstr "  входит в область видимости не-POD `%#D'"
+#~ msgstr "  входит в область видимости не-POD %q+#D"
  
  #~ msgid "%J  enters catch block"
  #~ msgstr "%J  входит в catch-блок"
@@ -64519,9 +69637,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "call_expr cannot be mangled due to a defect in the C++ ABI"
  #~ msgstr "call_expr не может быть закодировано из-за дефектов ABI C++"
  
-#, fuzzy
+#
  #~ msgid "zero-operand casts cannot be mangled due to a defect in the C++ ABI"
-#~ msgstr "call_expr не может быть закодировано из-за дефектов ABI C++"
+#~ msgstr "приведение типов с нулем операндов не может быть разобрано из-за дефекта в C++ ABI"
  
  #~ msgid "XXX is_class_level != (current_scope == class_scope)\n"
  #~ msgstr "XXX is_class_level != (current_scope == class_scope)\n"
@@ -64544,17 +69662,17 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "%Hextra %<;%>"
  #~ msgstr "%Hизбыточная %<;%>"
  
-#, fuzzy
+#
  #~ msgid "%qE is not a valid template argument for type %qT because it is a non-constant expression"
-#~ msgstr "строковый литерал %E  не является корректным аргументом шаблона, потому что это адрес статического объекта"
+#~ msgstr "%qE не является корректным аргументом шаблона для типа %qT поскольку это неконстантное выражение"
  
-#, fuzzy
+#
  #~ msgid "wrong number of template arguments (%d, should be %d%s)"
-#~ msgstr "неправильное число аргументов шаблона (%d, а должно быть %d)"
+#~ msgstr "неправильное число аргументов шаблона (%d, а должно быть %d%s)"
  
-#, fuzzy
+#
  #~ msgid "creating array with negative size (%qE)"
-#~ msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð½Ñ\83Ð»ÐµÐ²ого размера (%qE)"
+#~ msgstr "Ñ\81Ð¾Ð·Ð´Ð°Ð½Ð¸Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð° Ð¾Ñ\82Ñ\80Ð¸Ñ\86Ð°Ñ\82ÐµÐ»Ñ\8cÐ½ого размера (%qE)"
  
  #~ msgid "object missing in reference to %q+D"
  #~ msgstr "отсутствует объект в ссылке на %q+D"
@@ -64562,21 +69680,21 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "at this point in file"
  #~ msgstr "в этом месте файла"
  
-#, fuzzy
+#
  #~ msgid "%s might be a candidate for a format attribute"
-#~ msgstr "этой функции, вероятно, можно задать атрибут форматирования %s"
+#~ msgstr "%s может быть кандидатом для формального атрибута"
  
-#, fuzzy
+#
  #~ msgid "%s of read-only parameter %qD"
-#~ msgstr "присваивание элементу %qD, доступному только на чтение"
+#~ msgstr "%s доступного только на чтение параметра %qD"
  
-#, fuzzy
+#
  #~ msgid "%s of read-only reference %qD"
-#~ msgstr "присваивание элементу %qD, доступному только на чтение"
+#~ msgstr "%s доступной только на чтение ссылки %qD"
  
-#, fuzzy
+#
  #~ msgid "%s of read-only location %qE"
-#~ msgstr "присваивание позиции в памяти, доступной только на чтение"
+#~ msgstr "%s доступной только на чтение позиции %qE"
  
  #~ msgid "global register variable %qs used in nested function"
  #~ msgstr "глобальная регистровая переменная %qs использована во вложенной функции"
@@ -64659,9 +69777,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "c4x_rptb_rpts_p: Repeat block top label moved"
  #~ msgstr "c4x_rptb_rpts_p: Метка заголовка повторяющегося блока перемещена"
  
-#, fuzzy
+#
  #~ msgid "Inquiry function '%s' at %L is not permitted in an initialization expression"
-#~ msgstr "%Jфинальное поле '%D', возможно, не было инициализировано"
+#~ msgstr "Функция запроса '%s' в %L не разрешена в инициализационном выражении"
  
  #~ msgid "Generate code for C30 CPU"
  #~ msgstr "Генерировать код для процессора C30"
@@ -64726,9 +69844,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "Copy memory address constants into registers before use"
  #~ msgstr "Перед использованием адресных констант, копировать их в регистры"
  
-#, fuzzy
+#
  #~ msgid "This switch is obsolete"
-#~ msgstr "Этот ключ не документирован"
+#~ msgstr "Этот ключ устарел"
  
  #~ msgid "static or type qualifiers in abstract declarator"
  #~ msgstr "слово static или квалификаторы типов в абстрактном деклараторе"
@@ -64754,17 +69872,17 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "ISR %s requires %d words of local vars, max is 32767"
  #~ msgstr "ISR %s требует %d слов локальных переменных, а максимум = 32767"
  
-#, fuzzy
+#
  #~ msgid "constant halfword load operand out of range"
-#~ msgstr "Ð\9aÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð·Ð°Ð³Ñ\80Ñ\83Ð·ÐºÐ¸ Ð¿Ð¾Ð»Ñ\83Ñ\81Ð»Ð¾Ð²Ð° - вне диапазона"
+#~ msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð·Ð°Ð³Ñ\80Ñ\83Ð·ÐºÐ¸ Ð¿Ð¾Ð»Ñ\83Ñ\81Ð»Ð¾Ð²Ð° вне диапазона"
  
-#, fuzzy
+#
  #~ msgid "constant arithmetic operand out of range"
-#~ msgstr "Ð\9aÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÐ¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¾Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ñ\86Ð¸Ð¸ - вне диапазона"
+#~ msgstr "ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð¸Ñ\84Ð¼ÐµÑ\82Ð¸Ñ\87ÐµÑ\81ÐºÐ¸Ð¹ Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´ вне диапазона"
  
-#, fuzzy
+#
  #~ msgid "used %d template parameter(s) instead of %d"
-#~ msgstr "использовано %d параметров%s шаблона вместо %d"
+#~ msgstr "использовано %d параметр(ов) шаблона вместо %d"
  
  #~ msgid "Attempt to delete prologue/epilogue insn:"
  #~ msgstr "попытка удаления RTL-инструкции из пролога/эпилога:"
@@ -64772,9 +69890,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "call is unlikely"
  #~ msgstr "вызов имеет небольшую вероятность"
  
-#, fuzzy
+#
  #~ msgid "In file %s:%d\n"
-#~ msgstr "В функции %qs"
+#~ msgstr "В файле %s:%d\n"
  
  #~ msgid "Found in %s\n"
  #~ msgstr "Найдено в %s\n"
@@ -64794,9 +69912,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "-malign-double makes no sense in the 64bit mode"
  #~ msgstr "-malign-double не имеет смысла в 64-битном режиме"
  
-#, fuzzy
+#
  #~ msgid "inconsistent dll linkage for %q+D, dllexport assumed"
-#~ msgstr "%Jнекорректный dll признак для %qD, предполагается dllexport"
+#~ msgstr "противоречивая dll связь для %q+D, предполагается dllexport"
  
  #~ msgid "internal error: %%) found without a %%( in assembler pattern"
  #~ msgstr "внутренняя ошибка: %%) без %%( в ассемблерном шаблоне"
@@ -64810,9 +69928,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "internal error: %%} found without a %%{ in assembler pattern"
  #~ msgstr "внутренняя ошибка: %%} без %%{ в ассемблерном шаблоне"
  
-#, fuzzy
+#
  #~ msgid "%qE has type %<void%> and is not a throw-expression"
-#~ msgstr "%qE имеет тип `void' и не является throw-выражением"
+#~ msgstr "%qE имеет тип %<void%> и не является throw-выражением"
  
  #~ msgid "field %q+D in local class cannot be static"
  #~ msgstr "поле %q+D в локальном классе не может быть статическим"
@@ -64835,9 +69953,9 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "source file for class %qs is newer than its matching class file.  Source file %qs used instead"
  #~ msgstr "исходный файл для класса %qs новее, чем соответствующий файл класса. Используется исходный файл %qs"
  
-#, fuzzy
+#
  #~ msgid "the %<java.lang.Object%> that was found in %qs didn't have the special zero-length %<gnu.gcj.gcj-compiled%> attribute.  This generally means that your classpath is incorrectly set.  Use %<info gcj \"Input Options\"%> to see the info page describing how to set the classpath"
-#~ msgstr "`java.lang.Object', найденный в %qs не имеет специального атрибута нулевойдлины `gnu.gcj.gcj-compiled'.  Это обычно означает, что значение classpath задано неправильно.  Выполните `info gcj \"Input Options\"', и прочтите info-страницу, описывающую установку classpath"
+#~ msgstr "%<java.lang.Object%> найденный в %qs не имеет специального атрибута нулевой длины `gnu.gcj.gcj-compiled'.  Это обычно означает, что значение classpath задано неправильно.  Выполните `info gcj \"Input Options\"', и прочтите info-страницу, описывающую установку classpath"
  
  #~ msgid "internal error in generate_bytecode_insn - tree code not implemented: %s"
  #~ msgstr "внутренняя ошибка в generate_bytecode_insn - узел дерева не реализован: %s"
@@ -64845,7 +69963,7 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ msgid "only one of '--print-main', '--list-class', and '--complexity' allowed"
  #~ msgstr "возможен только один из ключей '--print-main', '--list-class', '--complexity'"
  
-#, fuzzy
+#
  #~ msgid ""
  #~ "unknown encoding: %qs\n"
  #~ "This might mean that your locale's encoding is not supported\n"
@@ -64853,370 +69971,372 @@ msgstr "%Hсоздаётся селектор для несуществующе
  #~ "to use a particular encoding for your input file, try the\n"
  #~ "%<--encoding=UTF-8%> option"
  #~ msgstr ""
-#~ "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºтная кодировка: %qs\n"
+#~ "Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81тная кодировка: %qs\n"
  #~ "Возможно, кодировка, установленная вашим locale, не поддерживается\n"
  #~ "реализацией iconv(3) в вашей системе.  Если вам не нужна специальная\n"
  #~ "кодировка входного файла, попробуйте задать ключ\n"
-#~ "`--encoding=UTF-8'"
+#~ "%<--encoding=UTF-8%>"
  
-#, fuzzy
+#
  #~ msgid "Incompatible type for %qs. Can't convert %qs to numeric type"
-#~ msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %d Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qs"
+#~ msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f %qs. Ð\9dÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ñ\82Ñ\8c %qs Ð² Ñ\87Ð¸Ñ\81Ð»Ð¾Ð²Ð¾Ð¹ Ñ\82Ð¸Ð¿"
  
-#, fuzzy
+#
  #~ msgid "%s (GCC) %s\n"
-#~ msgstr "%s %s%s\n"
+#~ msgstr "%s (GCC) %s\n"
  
-#, fuzzy
+#
  #~ msgid ""
  #~ "The %s front end recognizes the following options:\n"
  #~ "\n"
-#~ msgstr "Ключ --param позволяет задать следующие параметры"
+#~ msgstr ""
+#~ "The %s front end распознает следующие опции:\n"
+#~ "\n"
  
-#, fuzzy
+#
  #~ msgid "PRINT_OPERAND, invalid insn for %%F"
-#~ msgstr "PRINT_OPERAND_ADDRESS: некорректная инструкция #1"
+#~ msgstr "PRINT_OPERAND, некорректная инструкция для %%F"
  
-#, fuzzy
+#
  #~ msgid "PRINT_OPERAND, invalid insn for %%W"
-#~ msgstr "PRINT_OPERAND_ADDRESS: некорректная инструкция #1"
+#~ msgstr "PRINT_OPERAND, некорректная инструкция для %%W"
  
-#, fuzzy
+#
  #~ msgid "invalid %%Y value"
-#~ msgstr "некорректное %%H значение"
+#~ msgstr "некорректное %%Y значение"
  
-#, fuzzy
+#
  #~ msgid "PRINT_OPERAND, invalid insn for %%q"
-#~ msgstr "PRINT_OPERAND_ADDRESS: некорректная инструкция #1"
+#~ msgstr "PRINT_OPERAND, некорректная инструкция для %%q"
  
-#, fuzzy
+#
  #~ msgid "PRINT_OPERAND, invalid operand for relocation"
-#~ msgstr "PRINT_OPERAND_ADDRESS: некорректная инструкция #1"
+#~ msgstr "PRINT_OPERAND, некорректный операнд для настройки"
  
-#, fuzzy
+#
  #~ msgid "Period required"
-#~ msgstr "Требуется неотрицательная ширина"
+#~ msgstr "Требуется точка"
  
-#, fuzzy
+#
  #~ msgid "Invalid second argument of REPEAT at %L"
-#~ msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ñ\8bÐ¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 Ð´Ð»Ñ\8f %qs"
+#~ msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ð²Ñ\82Ð¾Ñ\80Ð¾Ð¹ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82 REPEAT Ð² %L"
  
-#, fuzzy
+#
  #~ msgid "storage size not known"
-#~ msgstr "размер %qD в памяти неизвестен"
+#~ msgstr "размер в памяти неизвестен"
  
-#, fuzzy
+#
  #~ msgid " --help' for more information.\n"
-#~ msgstr "Для получения более подробной информации выполните 'jcf-dump --help'\n"
+#~ msgstr " --help' для получения более подробной информации.\n"
  
-#, fuzzy
+#
  #~ msgid "  -stubs                  Generate an implementation stub file\n"
-#~ msgstr "  -pipe                    Передавать промежуточные данные по конвейеру\n"
+#~ msgstr "  -stubs                  Генерировать файл суррогата реализации\n"
  
-#, fuzzy
+#
  #~ msgid "  -force                  Always overwrite output files\n"
-#~ msgstr "  -o ФАЙЛ                 Задать имя выходного файла\n"
+#~ msgstr "  -force                  Всегда перезаписывать выходные файлы\n"
  
-#, fuzzy
+#
  #~ msgid "  -old                    Unused compatibility option\n"
-#~ msgstr "  --help                   Вывести этот текст\n"
+#~ msgstr "  -old                    Неиспользуемая опция совместимости\n"
  
-#, fuzzy
+#
  #~ msgid "  -trace                  Unused compatibility option\n"
-#~ msgstr "  --help                   Вывести этот текст\n"
+#~ msgstr "  -trace                  Неиспользуемая опция совместимости\n"
  
-#, fuzzy
+#
  #~ msgid "  -MD                     Print all dependencies to stdout\n"
-#~ msgstr "  -h, --help                      Напечатать этот текст и выйти\n"
+#~ msgstr "  -MD                     Напечатать все зависимости в stdout\n"
  
-#, fuzzy
+#
  #~ msgid "  -MMD                    Print non-system dependencies to stdout\n"
-#~ msgstr "  --help                  Напечатать эту справку и выйти\n"
+#~ msgstr "  -MMD                    Напечатать несистемные зависимости в stdout\n"
  
-#, fuzzy
+#
  #~ msgid "Processing %s\n"
-#~ msgstr "создание %s"
+#~ msgstr "Обработка %s\n"
  
-#, fuzzy
+#
  #~ msgid "Try 'jv-scan --help' for more information.\n"
-#~ msgstr "Ð\94Ð»Ñ\8f Ð¿Ð¾Ð»Ñ\83Ñ\87ÐµÐ½Ð¸Ñ\8f Ð±Ð¾Ð»ÐµÐµ Ð¿Ð¾Ð´Ñ\80Ð¾Ð±Ð½Ð¾Ð¹ Ð¸Ð½Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\86Ð¸Ð¸ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½Ð¸Ñ\82Ðµ 'jcf-dump --help'\n"
+#~ msgstr "Ð\9fÐ¾Ð¿Ñ\80Ð¾Ð±Ñ\83Ð¹Ñ\82Ðµ 'jv-scan --help' Ð´Ð»Ñ\8f Ð¿Ð¾Ð»Ñ\83Ñ\87ÐµÐ½Ð¸Ñ\8f Ð±Ð¾Ð»ÐµÐµ Ð¿Ð¾Ð´Ñ\80Ð¾Ð±Ð½Ð¾Ð¹ Ð¸Ð½Ñ\84Ð¾Ñ\80Ð¼Ð°Ñ\86Ð¸Ð¸.\n"
  
-#, fuzzy
+#
  #~ msgid ""
  #~ "Usage: jv-scan [OPTION]... FILE...\n"
  #~ "\n"
  #~ msgstr ""
-#~ "Использование: gcov [КЛЮЧ]... ВХОДНОЙ_ФАЙЛ...\n"
+#~ "Использование: jv-scan [OPTION]... FILE...\n"
  #~ "\n"
  
-#, fuzzy
+#
  #~ msgid "%s: error: "
-#~ msgstr "ошибка: "
+#~ msgstr "%s: ошибка: "
  
-#, fuzzy
+#
  #~ msgid "%s: warning: "
-#~ msgstr "предупреждение: "
+#~ msgstr "%s: предупреждение: "
  
-#, fuzzy
+#
  #~ msgid "Don't use hardware fp"
  #~ msgstr "Не использовать аппаратную плавающую арифметику"
  
-#, fuzzy
+#
  #~ msgid "Uninitialized locals in .bss"
-#~ msgstr "Ð½ÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ð°Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð° %qD"
+#~ msgstr "Ð\9dÐµÐ¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð½Ñ\8bÐµ Ð»Ð¾ÐºÐ°Ð»Ñ\8cÐ½Ñ\8bÐµ Ð² .bss"
  
-#, fuzzy
+#
  #~ msgid "Use STACK as the initial value of the stack pointer"
-#~ msgstr "Изменять только младшие 8 бит указателя стека"
+#~ msgstr "Использовать STACK как начальное значение указателя стека"
  
-#, fuzzy
+#
  #~ msgid "Generate mips16 code"
-#~ msgstr "Генерировать код SH1"
+#~ msgstr "Генерировать mips16 код"
  
-#, fuzzy
+#
  #~ msgid "Warn about possibly confusing type conversions"
-#~ msgstr "Предупреждать о возможно отсутствующих скобках"
+#~ msgstr "Предупреждать о возможно спутанных преобразованиях типов"
  
-#, fuzzy
+#
  #~ msgid "Make implicit function declarations an error"
-#~ msgstr "Ð\9fÑ\80ÐµÐ´Ñ\83Ð¿Ñ\80ÐµÐ¶Ð´Ð°Ñ\82Ñ\8c Ð¾ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÑ\85 Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ñ\8fÑ\85 функций"
+#~ msgstr "Ð¡Ñ\87Ð¸Ñ\82Ð°Ñ\82Ñ\8c Ð¾Ñ\88Ð¸Ð±ÐºÐ¾Ð¹ Ð½ÐµÑ\8fÐ²Ð½Ñ\8bÐµ Ð´ÐµÐºÐ»Ð°Ñ\80Ð°Ñ\86Ð¸Ð¸ функций"
  
-#, fuzzy
+#
  #~ msgid "Copy memory operands into registers before use"
-#~ msgstr "Ð\9fÐµÑ\80ÐµÐ´ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸ÐµÐ¼ Ð°Ð´Ñ\80ÐµÑ\81Ð½Ñ\8bÑ\85 ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82, ÐºÐ¾Ð¿Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¸Ñ\85 Ð² Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ñ\8b"
+#~ msgstr "Ð\9aÐ¾Ð¿Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c Ð¾Ð¿ÐµÑ\80Ð°Ð½Ð´Ñ\8b Ð¸Ð· Ð¿Ð°Ð¼Ñ\8fÑ\82Ð¸ Ð² Ñ\80ÐµÐ³Ð¸Ñ\81Ñ\82Ñ\80Ñ\8b Ð\9fÐµÑ\80ÐµÐ´ Ð¸Ñ\81Ð¿Ð¾Ð»Ñ\8cÐ·Ð¾Ð²Ð°Ð½Ð¸ÐµÐ¼"
  
-#, fuzzy
+#
  #~ msgid "Perform loop optimizations using the new loop optimizer"
-#~ msgstr "Включить оптимизации циклов на древовидном представлении"
+#~ msgstr "Выполнять оптимизации циклов используя новый оптимизатор циклов"
  
-#, fuzzy
+#
  #~ msgid "second argument to %<__builtin_expect%> must be a constant"
-#~ msgstr "второй аргумент %<__builtin_prefetch%> должен быть константой"
+#~ msgstr "второй аргумент %<__builtin_expect%> должен быть константой"
  
-#, fuzzy
+#
  #~ msgid "invalid lvalue in decrement"
-#~ msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾Ðµ lvalue-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ð¾Ð¼ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ %d Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° asm"
+#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ lvalue Ð² Ð´ÐµÐºÑ\80ÐµÐ¼ÐµÐ½Ñ\82Ðµ"
  
-#, fuzzy
+#
  #~ msgid "invalid lvalue in unary %<&%>"
-#~ msgstr "Ð½ÐµÐ²ÐµÑ\80Ð½Ð¾Ðµ lvalue-Ð²Ñ\8bÑ\80Ð°Ð¶ÐµÐ½Ð¸Ðµ Ð² Ð²Ñ\8bÑ\85Ð¾Ð´Ð½Ð¾Ð¼ Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ðµ %d Ð¾Ð¿ÐµÑ\80Ð°Ñ\82Ð¾Ñ\80Ð° asm"
+#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ lvalue Ð² Ñ\83Ð½Ð°Ñ\80Ð½Ð¾Ð¼ %<&%>"
  
-#, fuzzy
+#
  #~ msgid "GCC does not yet properly implement %<[*]%> array declarators"
-#~ msgstr "ISO C90 не поддерживает конструкцию [*] в декларациях массивов"
+#~ msgstr "GCC пока не реализует должным образом %<[*]%> деклараторы массивов"
  
-#, fuzzy
+#
  #~ msgid "thread-local storage not supported for this target"
-#~ msgstr "-fstack-protector не поддерживается для этой целевой платформы"
+#~ msgstr "thread-local память не поддерживается для этой целевой платформы"
  
-#, fuzzy
+#
  #~ msgid "function %q+F can never be inlined because it might not be bound within this unit of translation"
-#~ msgstr "подстановка функции %q+F невозможна, т.к. она имеет атрибуты, препятствующие inline-подстановке"
+#~ msgstr "подстановка функции %q+F невозможна поскольку она может не быть связана внутри этой единицы трансляции"
  
-#, fuzzy
+#
  #~ msgid "junk at end of #pragma weak"
-#~ msgstr "мусор в конце директивы %<#pragma pack%>"
+#~ msgstr "мусор в конце директивы #pragma weak"
  
-#, fuzzy
+#
  #~ msgid "%qs is corrupted"
-#~ msgstr "%s:испорчен\n"
+#~ msgstr "%qs испорчен"
  
-#, fuzzy
+#
  #~ msgid "label %s in the middle of basic block %d"
-#~ msgstr "Ð¸Ð½Ñ\81Ñ\82Ñ\80Ñ\83ÐºÑ\86Ð¸Ñ\8f Ñ\83Ð¿Ñ\80Ð°Ð²Ð»ÐµÐ½Ð¸Ñ\8f Ð¿Ð¾Ñ\82Ð¾ÐºÐ¾Ð¼ Ð²Ñ\8bÐ¿Ð¾Ð»Ð½ÐµÐ½Ð¸Ñ\8f Ð²Ð½Ñ\83Ñ\82Ñ\80Ð¸ блока %d"
+#~ msgstr "Ð¼ÐµÑ\82ÐºÐ° %s Ð² Ñ\81ÐµÑ\80ÐµÐ´Ð¸Ð½Ðµ Ð±Ð°Ð·Ð¾Ð²Ð¾Ð³Ð¾ блока %d"
  
-#, fuzzy
+#
  #~ msgid "-mips3d/-mpaired-single must be used with -mips64"
-#~ msgstr "-frepo следует использовать вместе с -c"
+#~ msgstr "-mips3d/-mpaired-single нужно использовать с -mips64"
  
-#, fuzzy
+#
  #~ msgid "PRINT_OPERAND: unknown punctuation '%c'"
-#~ msgstr "PRINT_OPERAND: Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Ñ\81Ð¸Ð¼Ð²Ð¾Ð» Ð¿Ñ\83Ð½ÐºÑ\82Ñ\83Ð°Ñ\86Ð¸Ð¸ '%c'"
+#~ msgstr "PRINT_OPERAND: Ð½ÐµÐ¸Ð·Ð²ÐµÑ\81Ñ\82Ð½Ð°Ñ\8f Ð¿Ñ\83Ð½ÐºÑ\82Ñ\83Ð°Ñ\86Ð¸Ñ\8f '%c'"
  
-#, fuzzy
+#
  #~ msgid "-fpic is not supported; -fPIC assumed"
-#~ msgstr "ключ -f%s не поддерживается; игнорируется"
+#~ msgstr "ключ -fpic не поддерживается; -fPIC предполагается"
  
-#, fuzzy
+#
  #~ msgid "unable to call pointer to member function here"
-#~ msgstr "   в преобразовании указателя на элемент-функцию"
+#~ msgstr "невозможно вызвать указатель на функцию-элемент здесь"
  
-#, fuzzy
+#
  #~ msgid "converting to %qT from %qT"
-#~ msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð¸Ð· %qT Ð² %qT"
+#~ msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ð² %qT Ð¸Ð· %qT"
  
-#, fuzzy
+#
  #~ msgid "pointer to member cast from %qT to %qT is via virtual base"
-#~ msgstr "преобразование указателя к элементу через виртуальную базу %qT"
+#~ msgstr "указатель на преобразование элемента из %qT в %qT через виртуальную базу"
  
-#, fuzzy
+#
  #~ msgid "cannot initialize %qD to namespace %qD"
-#~ msgstr "Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼Ð°Ñ\8f Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f %qT Ð¸Ð· %qT"
+#~ msgstr "Ð½ÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ñ\82Ñ\8c %qD Ð² Ð¿Ñ\80Ð¾Ñ\81Ñ\82Ñ\80Ð°Ð½Ñ\81Ñ\82Ð²Ð¾ Ð¸Ð¼ÐµÐ½ %qD"
  
-#, fuzzy
+#
  #~ msgid "operator %qT declared to return %qT"
-#~ msgstr "%<operator delete%> должен иметь результат типа %qT"
+#~ msgstr "оператор %qT декларирован для возврата %qT"
  
-#, fuzzy
+#
  #~ msgid "long or short specified with floating type for %qs"
-#~ msgstr "%<long%> или %<short%> заданы в описании %qs с типом char"
+#~ msgstr "long или short заданы с плавающим типом для %qs"
  
-#, fuzzy
+#
  #~ msgid "enumerator value for %qD not integer constant"
-#~ msgstr "Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»Ð¸Ð¼Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° Ð´Ð»Ñ\8f %qD Ð½Ðµ Ñ\8fÐ²Ð»Ñ\8fÐµÑ\82Ñ\81Ñ\8f ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82Ð¾Ð¹ Ñ\86ÐµÐ»Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿а"
+#~ msgstr "Ð·Ð½Ð°Ñ\87ÐµÐ½Ð¸Ðµ Ð¿ÐµÑ\80ÐµÑ\87Ð¸Ñ\81Ð»ÐµÐ½Ð¸Ñ\8f Ð´Ð»Ñ\8f %qD Ð½Ðµ integer ÐºÐ¾Ð½Ñ\81Ñ\82Ð°Ð½Ñ\82а"
  
-#, fuzzy
+#
  #~ msgid "qualified type %qT does not match destructor name %<~%T%>"
-#~ msgstr "квалифицированный тип %qT не соответствует имени деструктора `~%T'"
+#~ msgstr "квалифицированный тип %qT не соответствует имени деструктора %<~%T%>"
  
-#, fuzzy
+#
  #~ msgid "%qD is not a member of type %qT"
-#~ msgstr "%qD не является элементом %qT"
+#~ msgstr "%qD не является элементом типа %qT"
  
-#, fuzzy
+#
  #~ msgid "%qD denotes an ambiguous type"
-#~ msgstr "%qE не является именем типа"
+#~ msgstr "%qD обозначает неоднозначный тип"
  
-#, fuzzy
+#
  #~ msgid "%<%D::%D%> is not a template"
-#~ msgstr "%qs не является шаблоном"
+#~ msgstr "%<%D::%D%> не является шаблоном"
  
-#, fuzzy
+#
  #~ msgid "%qD undeclared in namespace %qD"
-#~ msgstr "декларация %qD может не действовать в пространстве имён"
+#~ msgstr "%qD не декларирован в пространстве имён %qD"
  
-#, fuzzy
+#
  #~ msgid "%qD does not declare a template type"
-#~ msgstr "%qT не является шаблонным типом"
+#~ msgstr "%qD не декларирует шаблонный тип"
  
-#, fuzzy
+#
  #~ msgid "division by zero in %<%E / 0%>"
-#~ msgstr "деление на ноль"
+#~ msgstr "деление на ноль в %<%E / 0%>"
  
-#, fuzzy
+#
  #~ msgid "division by zero in %<%E / 0.%>"
-#~ msgstr "деление на ноль"
+#~ msgstr "деление на ноль в %<%E / 0.%>"
  
-#, fuzzy
+#
  #~ msgid "division by zero in %<%E %% 0%>"
-#~ msgstr "деление на ноль"
+#~ msgstr "деление на ноль в %<%E %% 0%>"
  
-#, fuzzy
+#
  #~ msgid "division by zero in %<%E %% 0.%>"
-#~ msgstr "деление на ноль в %L"
+#~ msgstr "деление на ноль в %<%E %% 0.%>"
  
-#, fuzzy
+#
  #~ msgid "ISO C++ forbids assignment of arrays"
-#~ msgstr "ISO C++ Ð·Ð°Ð¿Ñ\80ÐµÑ\89Ð°ÐµÑ\82 Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ñ\8b Ð½Ñ\83Ð»ÐµÐ²Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð°"
+#~ msgstr "ISO C++ Ð·Ð°Ð¿Ñ\80ÐµÑ\89Ð°ÐµÑ\82 Ð¿Ñ\80Ð¸Ñ\81Ð²Ð°Ð¸Ð²Ð°Ð½Ð¸Ðµ Ð¼Ð°Ñ\81Ñ\81Ð¸Ð²Ð¾Ð²"
  
-#, fuzzy
+#
  #~ msgid "pointer to member cast via virtual base %qT"
-#~ msgstr "Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ указателя к элементу через виртуальную базу %qT"
+#~ msgstr "Ð¿Ñ\80Ð¸Ð²ÐµÐ´ÐµÐ½Ð¸Ðµ Ñ\82Ð¸Ð¿Ð° указателя к элементу через виртуальную базу %qT"
  
-#, fuzzy
+#
  #~ msgid "union %qT with no named members cannot be initialized"
-#~ msgstr "Ð²ÐµÐºÑ\82Ð¾Ñ\80 Ñ\81ÐºÑ\80Ñ\8bÑ\82Ð¾Ð³Ð¾ Ñ\82Ð¸Ð¿Ð° Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½"
+#~ msgstr "Ð¾Ð±Ñ\8aÐµÐ´Ð¸Ð½ÐµÐ½Ð¸Ðµ %qT Ð±ÐµÐ· Ð¸Ð¼ÐµÐ½Ð¾Ð²Ð°Ð½Ð½Ñ\8bÑ\85 Ñ\8dÐ»ÐµÐ¼ÐµÐ½Ñ\82Ð¾Ð² Ð½Ðµ Ð¼Ð¾Ð¶ÐµÑ\82 Ð±Ñ\8bÑ\82Ñ\8c Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½Ð¾"
  
-#, fuzzy
+#
  #~ msgid "unused variable %qs"
-#~ msgstr "неиспользуемая переменная %q+D"
+#~ msgstr "неиспользуемая переменная %qs"
  
-#, fuzzy
+#
  #~ msgid "%Jfinal field %qD may not have been initialized"
-#~ msgstr "инициализация объекта %qD переменного размера недопустима"
+#~ msgstr "%JФинальное поле %qD возможно не было инициализировано"
  
-#, fuzzy
+#
  #~ msgid "declaration of %qs shadows a parameter"
-#~ msgstr "декларация %q+D перекрывает параметр"
+#~ msgstr "декларация %qs затеняет параметр"
  
-#, fuzzy
+#
  #~ msgid "declaration of %qs shadows a symbol from the parameter list"
-#~ msgstr "декларация %q+D перекрывает параметр"
+#~ msgstr "декларация %qs затеняет символ из списка параметров"
  
-#, fuzzy
+#
  #~ msgid "assignment to final static field %q+D not in class initializer"
-#~ msgstr "присваивание финальному полю %q+D - не в классе этого поля"
+#~ msgstr "присваивание финальному статическому полю %q+D не в инициализаторе класса"
  
-#, fuzzy
+#
  #~ msgid "assignment to final field %q+D not in constructor"
-#~ msgstr "присваивание финальному полю %q+D - не в классе этого поля"
+#~ msgstr "присваивание финальному полю %q+D не в конструкторе"
  
-#, fuzzy
+#
  #~ msgid "parse error while reading %s"
-#~ msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ñ\87Ñ\82ÐµÐ½Ð¸Ñ\8f  %s Ð¸Ð· zip-Ñ\84Ð°Ð¹Ð»Ð°"
+#~ msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ñ\80Ð°Ð·Ð±Ð¾Ñ\80Ð° Ð¿Ñ\80Ð¸ Ñ\87Ñ\82ÐµÐ½Ð¸Ð¸ %s"
  
-#, fuzzy
+#
  #~ msgid "Not a valid Java .class file."
-#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Java .class Ñ\84Ð°Ð¹Ð».\n"
+#~ msgstr "Ð\9dÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ñ\8bÐ¹ Java .class Ñ\84Ð°Ð¹Ð»."
  
-#, fuzzy
+#
  #~ msgid "error in constant pool entry #%d"
-#~ msgstr "ошибка в элементе пула констант #%d\n"
+#~ msgstr "ошибка в элементе пула констант #%d"
  
-#, fuzzy
+#
  #~ msgid "class is of array type\n"
-#~ msgstr "тип массива в операции приведения типов"
+#~ msgstr "класс имеет тип массива\n"
  
-#, fuzzy
+#
  #~ msgid "base class is of array type"
-#~ msgstr "тип массива в операции приведения типов"
+#~ msgstr "базовый класс имеет тип массива\n"
  
-#, fuzzy
+#
  #~ msgid "no classes specified"
-#~ msgstr "jcf-dump: не задано имя класса\n"
+#~ msgstr "нет специфицированных классов"
  
-#, fuzzy
+#
  #~ msgid "'-MG' option is unimplemented"
-#~ msgstr "ключ '-%c' требует аргумента"
+#~ msgstr "'-MG' опция не реализована"
  
-#, fuzzy
+#
  #~ msgid "can't specify both -o and -MD"
-#~ msgstr "не допускается задание одновременно -C и -o"
+#~ msgstr "невозможно специфицировать и -o и -MD"
  
-#, fuzzy
+#
  #~ msgid "%s: no such class"
-#~ msgstr "%q#T не является классом"
+#~ msgstr "%s: нет такого класса"
  
-#, fuzzy
+#
  #~ msgid "can't reopen %s: %m"
-#~ msgstr "ошибка открытия %s: %m"
+#~ msgstr "ошибка reopen %s: %m"
  
-#, fuzzy
+#
  #~ msgid "can't close %s: %m"
-#~ msgstr "ошибка открытия %s: %m"
+#~ msgstr "ошибка close %s: %m"
  
-#, fuzzy
+#
  #~ msgid "can't open %s for writing: %m"
  #~ msgstr "ошибка открытия %s на запись: %m"
  
-#, fuzzy
+#
  #~ msgid "can't create %s: %m"
-#~ msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ñ\87Ñ\82Ðµния %s: %m"
+#~ msgstr "Ð¾Ñ\88Ð¸Ð±ÐºÐ° Ñ\81Ð¾Ð·Ð´Ð°ния %s: %m"
  
-#, fuzzy
+#
  #~ msgid "can't open output file '%s'"
-#~ msgstr "ошибка открытия входного файла %qs"
+#~ msgstr "ошибка открытия входного файла '%s'"
  
-#, fuzzy
+#
  #~ msgid "file not found '%s'"
-#~ msgstr "не удалось найти '%s'"
+#~ msgstr "файл не найден '%s'"
  
-#, fuzzy
+#
  #~ msgid "internal error - bad unget"
-#~ msgstr "внутренняя ошибка - некорректное Utf8-имя"
+#~ msgstr "внутренняя ошибка - некорректный unget"
  
-#, fuzzy
+#
  #~ msgid "%s method can't be abstract"
-#~ msgstr "%Jабстрактный метод в неабстрактном классе"
+#~ msgstr "%s метод не может быть абстрактным"
  
-#, fuzzy
+#
  #~ msgid "Incompatible type for %qs. Can't convert %qs to boolean"
-#~ msgstr "Ð½ÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð°Ñ\80Ð³Ñ\83Ð¼ÐµÐ½Ñ\82Ð° %d Ñ\84Ñ\83Ð½ÐºÑ\86Ð¸Ð¸ %qE"
+#~ msgstr "Ð\9dÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f %qs. Ð\9dÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ñ\82Ñ\8c %qs Ð² boolean"
  
-#, fuzzy
+#
  #~ msgid "Incompatible type for %qs. Can't convert %qs to integral"
-#~ msgstr "Ð½ÐµÐºÐ¾Ñ\80Ñ\80ÐµÐºÑ\82Ð½Ð¾Ðµ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ð½Ð¸Ðµ Ðº %<__fpreg%>"
+#~ msgstr "Ð\9dÐµÑ\81Ð¾Ð²Ð¼ÐµÑ\81Ñ\82Ð¸Ð¼Ñ\8bÐ¹ Ñ\82Ð¸Ð¿ Ð´Ð»Ñ\8f %qs. Ð\9dÐµÐ²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð¿Ñ\80ÐµÐ¾Ð±Ñ\80Ð°Ð·Ð¾Ð²Ð°Ñ\82Ñ\8c %qs Ð² integral"
  
-#, fuzzy
+#
  #~ msgid "Variable %qs may not have been initialized"
-#~ msgstr "Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð°Ñ\86Ð¸Ñ\8f Ð¾Ð±Ñ\8aÐµÐºÑ\82Ð° %qD Ð¿ÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð¾Ð³Ð¾ Ñ\80Ð°Ð·Ð¼ÐµÑ\80Ð° Ð½ÐµÐ´Ð¾Ð¿Ñ\83Ñ\81Ñ\82Ð¸Ð¼а"
+#~ msgstr "Ð\9fÐµÑ\80ÐµÐ¼ÐµÐ½Ð½Ð°Ñ\8f %qs Ð²Ð¾Ð·Ð¼Ð¾Ð¶Ð½Ð¾ Ð½Ðµ Ð±Ñ\8bÐ»Ð° Ð¸Ð½Ð¸Ñ\86Ð¸Ð°Ð»Ð¸Ð·Ð¸Ñ\80Ð¾Ð²Ð°Ð½а"
diff --git a/gcc/po/sv.po b/gcc/po/sv.po

index 2590a2e..9148562 100644 (file)
--- a/gcc/po/sv.po
+++ b/gcc/po/sv.po
@@ -20,7 +20,7 @@ msgstr ""
  "Project-Id-Version: gcc 6.1.0\n"
  "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n"
  "POT-Creation-Date: 2016-04-21 15:24+0000\n"
-"PO-Revision-Date: 2016-05-01 21:54+0200\n"
+"PO-Revision-Date: 2016-05-14 00:01+0200\n"
  "Last-Translator: Göran Uddeborg <goeran@uddeborg.se>\n"
  "Language-Team: Swedish <tp-sv@listor.tp-sv.se>\n"
  "Language: sv\n"
@@ -39385,10 +39385,9 @@ msgid "value-initialization of reference type %qT"
  msgstr "värdeinitiering av referenstypen %qT"
  
  #: cp/init.c:556
-#, fuzzy, gcc-internal-format
-#| msgid "pure virtual %q#D called from non-static data member initializer"
+#, gcc-internal-format
  msgid "recursive instantiation of non-static data member initializer for %qD"
-msgstr "pure virtual %q#D anropad från initierare av ickestatisk datamedlem"
+msgstr "rekursiv instantiering av ickestatisk datamedleminitierare för %qD"
  
  #: cp/init.c:580
  #, gcc-internal-format
@@ -39427,10 +39426,9 @@ msgid "uninitialized reference member in %q#T"
  msgstr "oinitierad referensmedlem i %q#T"
  
  #: cp/init.c:950
-#, fuzzy, gcc-internal-format
-#| msgid "%q+D will be initialized after"
+#, gcc-internal-format
  msgid "%qD will be initialized after"
-msgstr "%q+D kommer initieras efter"
+msgstr "%qD kommer initieras efter"
  
  #: cp/init.c:953
  #, gcc-internal-format
@@ -39438,10 +39436,9 @@ msgid "base %qT will be initialized after"
  msgstr "basen %qT kommer initieras efter"
  
  #: cp/init.c:957
-#, fuzzy, gcc-internal-format
-#| msgid "  %q+#D"
+#, gcc-internal-format
  msgid "  %q#D"
-msgstr "  %q+#D"
+msgstr "  %q#D"
  
  #: cp/init.c:959
  #, gcc-internal-format
@@ -39624,10 +39621,9 @@ msgid "call to Java constructor with %qs undefined"
  msgstr "anrop av Javakonstruerare med %qs odefinierad"
  
  #: cp/init.c:2873
-#, fuzzy, gcc-internal-format
-#| msgid "%qD is not a function template"
+#, gcc-internal-format
  msgid "%qD is not a function returning a pointer"
-msgstr "%qD är inte en funktionsmall"
+msgstr "%qD är inte en funktion som returnerar en pekare"
  
  #: cp/init.c:2882
  #, gcc-internal-format
@@ -39710,14 +39706,12 @@ msgid "neither the destructor nor the class-specific operator delete will be cal
  msgstr "varken destrueraren eller den klasspecifika operatorn delete kommer anropas, även om de är deklarerade när klassen definieras"
  
  #: cp/init.c:4395
-#, fuzzy, gcc-internal-format
-#| msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behaviour"
+#, gcc-internal-format
  msgid "deleting object of abstract class type %qT which has non-virtual destructor will cause undefined behavior"
  msgstr "radering av objekt av den abstrakta klasstypen %qT som har en ej virtuell destruerare kommer medföra odefinierat beteende"
  
  #: cp/init.c:4400
-#, fuzzy, gcc-internal-format
-#| msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behaviour"
+#, gcc-internal-format
  msgid "deleting object of polymorphic class type %qT which has non-virtual destructor might cause undefined behavior"
  msgstr "radering av objekt av den polymorfa klasstypen %qT som har en ej virtuell destruerare kommer medföra odefinierat beteende"
  
@@ -39857,28 +39851,24 @@ msgid "a later -fabi-version= (or =0) avoids this error with a change in manglin
  msgstr "en senare -fabi-version= (eller =0) undviker detta fel med en ändring av manglingen"
  
  #: cp/mangle.c:3667
-#, fuzzy, gcc-internal-format
-#| msgid "the mangled name of %q+D changed between -fabi-version=%d (%D) and -fabi-version=%d (%D)"
+#, gcc-internal-format
  msgid "the mangled name of %qD changed between -fabi-version=%d (%D) and -fabi-version=%d (%D)"
-msgstr "det manglade namnet för %q+D ändrades mellan -fabi-version=%d (%D) och -fabi-version=%d (%D)"
+msgstr "det manglade namnet på %qD ändrades mellan -fabi-version=%d (%D) och -fabi-version=%d (%D)"
  
  #: cp/mangle.c:3673
-#, fuzzy, gcc-internal-format
-#| msgid "the mangled name of %q+D changes between -fabi-version=%d (%D) and -fabi-version=%d (%D)"
+#, gcc-internal-format
  msgid "the mangled name of %qD changes between -fabi-version=%d (%D) and -fabi-version=%d (%D)"
-msgstr "det manglade namnet för %q+D ändras mellan -fabi-version=%d (%D) och -fabi-version=%d (%D)"
+msgstr "det manglade namnet på %qD ändras mellan -fabi-version=%d (%D) och -fabi-version=%d (%D)"
  
  #: cp/mangle.c:3969
-#, fuzzy, gcc-internal-format
-#| msgid "the mangled name of %q+D changes between -fabi-version=%d (%D) and -fabi-version=%d (%D)"
+#, gcc-internal-format
  msgid "the mangled name of %qD changes between -fabi-version=%d and -fabi-version=%d"
-msgstr "det manglade namnet för %q+D ändras mellan -fabi-version=%d (%D) och -fabi-version=%d (%D)"
+msgstr "det manglade namnet på %qD ändras mellan -fabi-version=%d och -fabi-version=%d"
  
  #: cp/mangle.c:3974
-#, fuzzy, gcc-internal-format
-#| msgid "the mangled name of %q+D changes between -fabi-version=%d (%D) and -fabi-version=%d (%D)"
+#, gcc-internal-format
  msgid "the mangled name of the initialization guard variable for%qD changes between -fabi-version=%d and -fabi-version=%d"
-msgstr "det manglade namnet för %q+D ändras mellan -fabi-version=%d (%D) och -fabi-version=%d (%D)"
+msgstr "det manglade namnet på initieringsvaktsvariabeln för %qD ändras mellan -fabi-version=%d och -fabi-version=%d"
  
  #: cp/method.c:705 cp/method.c:1186
  #, gcc-internal-format
@@ -39901,22 +39891,19 @@ msgid "union member %q+D with non-trivial %qD"
  msgstr "union-medlem %q+D med icketrivial %qD"
  
  #: cp/method.c:1145
-#, fuzzy, gcc-internal-format
-#| msgid "defaulted constructor calls non-constexpr %q+D"
+#, gcc-internal-format
  msgid "defaulted constructor calls non-constexpr %qD"
-msgstr "standarddefinierad konstruerare anropar %q+D som inte är constexpr"
+msgstr "standarddefinierad konstruerare anropar %qD som inte är constexpr"
  
  #: cp/method.c:1209
-#, fuzzy, gcc-internal-format
-#| msgid "initializer for %q+#D is invalid"
+#, gcc-internal-format
  msgid "initializer for %q#D is invalid"
-msgstr "initieraren för %q+#D är ogiltig"
+msgstr "initieraren för %q#D är ogiltig"
  
  #: cp/method.c:1261
-#, fuzzy, gcc-internal-format
-#| msgid "defaulted default constructor does not initialize %q+#D"
+#, gcc-internal-format
  msgid "defaulted default constructor does not initialize %q#D"
-msgstr "den standarddefinierade standardkonstrueraren initierar inte %q+#D"
+msgstr "den standarddefinierade standardkonstrueraren initierar inte %q#D"
  
  #: cp/method.c:1272
  #, gcc-internal-format
@@ -39945,16 +39932,14 @@ msgid "a lambda closure type has a deleted copy assignment operator"
  msgstr "en lambdahöljetyp har en raderad koperingstilldelningsoperator"
  
  #: cp/method.c:1636
-#, fuzzy, gcc-internal-format
-#| msgid "%q+#D is implicitly declared as deleted because %qT declares a move constructor or move assignment operator"
+#, gcc-internal-format
  msgid "%q#D is implicitly declared as deleted because %qT declares a move constructor or move assignment operator"
-msgstr "%q+#D är implicit deklarerad som raderad för att %qT deklarerar en flyttkonstruerare eller flyttilldelningsoperator"
+msgstr "%q#D är implicit deklarerad som raderad för att %qT deklarerar en flyttkonstruerare eller flyttilldelningsoperator"
  
  #: cp/method.c:1656
-#, fuzzy, gcc-internal-format
-#| msgid "%q+#D is implicitly deleted because the default definition would be ill-formed:"
+#, gcc-internal-format
  msgid "%q#D is implicitly deleted because the default definition would be ill-formed:"
-msgstr "%q+#D är underförstått raderad eftersom standarddefinitionen skulle vara felformulerad:"
+msgstr "%q#D är underförstått raderad eftersom standarddefinitionen skulle vara felformulerad:"
  
  #: cp/method.c:1665
  msgid "%q#F is implicitly deleted because its exception-specification does not match the implicit exception-specification %qX"
@@ -40026,10 +40011,9 @@ msgid "declaration of %q#D with C language linkage"
  msgstr "deklaration av %q#D med C-länkklass"
  
  #: cp/name-lookup.c:872 cp/name-lookup.c:887
-#, fuzzy, gcc-internal-format
-#| msgid "conflicts with previous declaration %q+#D"
+#, gcc-internal-format
  msgid "conflicts with previous declaration %q#D"
-msgstr "står i konflikt med tidigare deklaration %q+#D"
+msgstr "står i konflikt med tidigare deklaration %q#D"
  
  #: cp/name-lookup.c:875
  #, gcc-internal-format
@@ -40042,10 +40026,9 @@ msgid "type mismatch with previous external decl of %q#D"
  msgstr "typ stämmer inte med tidigare externdeklaration av %q#D"
  
  #: cp/name-lookup.c:989
-#, fuzzy, gcc-internal-format
-#| msgid "previous external decl of %q+#D"
+#, gcc-internal-format
  msgid "previous external decl of %q#D"
-msgstr "tidigare externdeklaration av %q+#D"
+msgstr "tidigare externdeklaration av %q#D"
  
  #: cp/name-lookup.c:1077
  #, gcc-internal-format
@@ -40053,10 +40036,9 @@ msgid "extern declaration of %q#D doesn%'t match"
  msgstr "externdeklaration av %q#D stämmer inte"
  
  #: cp/name-lookup.c:1079
-#, fuzzy, gcc-internal-format
-#| msgid "global declaration %q+#D"
+#, gcc-internal-format
  msgid "global declaration %q#D"
-msgstr "global deklaration av %q+#D"
+msgstr "global deklaration av %q#D"
  
  #: cp/name-lookup.c:1131 cp/name-lookup.c:1201
  #, gcc-internal-format
@@ -40085,16 +40067,14 @@ msgid "name lookup of %qD changed"
  msgstr "namnuppslagning av %qD ändrades"
  
  #: cp/name-lookup.c:1408
-#, fuzzy, gcc-internal-format
-#| msgid "  matches this %q+D under ISO standard rules"
+#, gcc-internal-format
  msgid "  matches this %qD under ISO standard rules"
  msgstr "  stämmer med denna %qD under ISO:s standardregler"
  
  #: cp/name-lookup.c:1411
-#, fuzzy, gcc-internal-format
-#| msgid "  matches this %q+D under old rules"
+#, gcc-internal-format
  msgid "  matches this %qD under old rules"
-msgstr "  stämmer med denna %q+D under gamla regler"
+msgstr "  stämmer med denna %qD under gamla regler"
  
  #: cp/name-lookup.c:1429 cp/name-lookup.c:1437
  #, gcc-internal-format
@@ -40107,10 +40087,9 @@ msgid "  cannot use obsolete binding at %q+D because it has a destructor"
  msgstr "  det går inte att använda föråldrad bindning vid %q+D för att den har en destruerare"
  
  #: cp/name-lookup.c:1441
-#, fuzzy, gcc-internal-format
-#| msgid "  using obsolete binding at %q+D"
+#, gcc-internal-format
  msgid "  using obsolete binding at %qD"
-msgstr "  använder föråldrad bindning vid %q+D"
+msgstr "  använder föråldrad bindning vid %qD"
  
  #: cp/name-lookup.c:1447
  #, gcc-internal-format
@@ -40209,16 +40188,14 @@ msgid "explicit qualification in declaration of %qD"
  msgstr "explicit-kvalifikation i deklaration av %qD"
  
  #: cp/name-lookup.c:3583
-#, fuzzy, gcc-internal-format
-#| msgid "%qE has not been declared"
+#, gcc-internal-format
  msgid "%qD has not been declared within %D"
-msgstr "%qE har inte deklarerats"
+msgstr "%qD har inte deklarerats inom %D"
  
  #: cp/name-lookup.c:3584
-#, fuzzy, gcc-internal-format
-#| msgid "%q+D declared as a friend"
+#, gcc-internal-format
  msgid "only here as a friend"
-msgstr "%q+D deklarerad som en vän"
+msgstr "endast här som en vän"
  
  #: cp/name-lookup.c:3600
  #, gcc-internal-format
@@ -40319,10 +40296,9 @@ msgstr "%<#pragma omp declare simd%> som inte omedelbart följs av en funktionsd
  
  #: cp/parser.c:1387 cp/parser.c:36470 cp/parser.c:36575 cp/parser.c:36600
  #: cp/parser.c:36657
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp declare simd%> must be followed by function declaration or definition"
+#, gcc-internal-format
  msgid "%<#pragma acc routine%> not followed by a function declaration or definition"
-msgstr "%<#pragma omp declare simd%> måste följas av en funktionsdeklaration eller -definition"
+msgstr "%<#pragma acc routine%> följs inte av en funktionsdeklaration eller -definition"
  
  #: cp/parser.c:2773
  #, gcc-internal-format
@@ -40532,10 +40508,9 @@ msgid "C++11 %<thread_local%> only available with -std=c++11 or -std=gnu++11"
  msgstr "C++11 %<thread_local%> är endast tillgängligt med -std=c++11 eller -std=gnu++11"
  
  #: cp/parser.c:3176
-#, fuzzy, gcc-internal-format
-#| msgid "C++11 %<noexcept%> only available with -std=c++11 or -std=gnu++11"
+#, gcc-internal-format
  msgid "%<concept%> only available with -fconcepts"
-msgstr "C++11 %<noexcept%> är endast tillgängligt med -std=c++11 eller -std=gnu++11"
+msgstr "%<concept%> är endast tillgängligt -fconcepts"
  
  #: cp/parser.c:3202
  #, gcc-internal-format
@@ -40634,34 +40609,29 @@ msgid "expected declaration"
  msgstr "en deklaration förväntades"
  
  #: cp/parser.c:4609 cp/parser.c:4624
-#, fuzzy, gcc-internal-format
-#| msgid "expected operator"
+#, gcc-internal-format
  msgid "expected binary operator"
-msgstr "operator förväntades"
+msgstr "binär operator förväntades"
  
  #: cp/parser.c:4630
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<...%>"
+#, gcc-internal-format
  msgid "expected ..."
-msgstr "%<...%> förväntades"
+msgstr "... förväntades"
  
  #: cp/parser.c:4640
-#, fuzzy, gcc-internal-format
-#| msgid "lambda-expression in a constant expression"
+#, gcc-internal-format
  msgid "binary expression in operand of fold-expression"
-msgstr "lambdauttryck i ett konstantuttryck"
+msgstr "binärt uttryck i operanden till ett vikningsuttryck"
  
  #: cp/parser.c:4643
-#, fuzzy, gcc-internal-format
-#| msgid "a transaction expression cannot appear in a constant-expression"
+#, gcc-internal-format
  msgid "conditional expression in operand of fold-expression"
-msgstr "ett transaktionsuttryck får inte finnas i ett konstantuttryck"
+msgstr "villkorligt uttryck i operanden till ett vikningsuttryck"
  
  #: cp/parser.c:4651
-#, fuzzy, gcc-internal-format
-#| msgid "type mismatch in sad expression"
+#, gcc-internal-format
  msgid "mismatched operator in fold-expression"
-msgstr "typfel i sad-uttryck"
+msgstr "operator som inte stämmer i vikningsuttryck"
  
  #: cp/parser.c:4755
  #, gcc-internal-format
@@ -40679,10 +40649,9 @@ msgid "statement-expressions are not allowed outside functions nor in template-a
  msgstr "satsuttryck är inte tillåtna utanför funktioner eller i mallargumentlistor"
  
  #: cp/parser.c:4887
-#, fuzzy, gcc-internal-format
-#| msgid "lambda expressions only available with -std=c++11 or -std=gnu++11"
+#, gcc-internal-format
  msgid "fold-expressions only available with -std=c++1z or -std=gnu++1z"
-msgstr "lambdauttryck är endast tillgängliga med -std=c++11 eller -std=gnu++11"
+msgstr "vikningsuttryck är endast tillgängliga med -std=c++1z eller -std=gnu++1z"
  
  #: cp/parser.c:4945 cp/parser.c:5116 cp/parser.c:5294
  #, gcc-internal-format
@@ -40845,16 +40814,14 @@ msgid "try removing the parentheses around the type-id"
  msgstr "försök ta bort parenteserna runt typ-id:t"
  
  #: cp/parser.c:8123
-#, fuzzy, gcc-internal-format
-#| msgid "direct-list-initialization of %<auto%> requires exactly one element"
+#, gcc-internal-format
  msgid "initialization of new-expression for type %<auto%> requires exactly one element"
-msgstr "direkt listinitiering av %<auto%> tar precis ett element"
+msgstr "initiering av new-uttryck för typen %<auto%> tar precis ett element"
  
  #: cp/parser.c:8171
-#, fuzzy, gcc-internal-format
-#| msgid "Expected expression type"
+#, gcc-internal-format
  msgid "expected expression-list or type-id"
-msgstr "Uttryckstyp förväntades"
+msgstr "uttryckslista eller typ-id förväntades"
  
  #: cp/parser.c:8200
  #, gcc-internal-format
@@ -40922,10 +40889,9 @@ msgid "capture of non-variable %qD "
  msgstr "fångst av en icke-variabel %qD"
  
  #: cp/parser.c:9941 cp/parser.c:9951 cp/semantics.c:3371 cp/semantics.c:3381
-#, fuzzy, gcc-internal-format
-#| msgid "%q+#D declared here"
+#, gcc-internal-format
  msgid "%q#D declared here"
-msgstr "%q+#D är deklarerad här"
+msgstr "%q#D är deklarerad här"
  
  #: cp/parser.c:9947
  #, gcc-internal-format
@@ -41106,10 +41072,9 @@ msgid "invalid linkage-specification"
  msgstr "ogiltig länkklasspecifikation"
  
  #: cp/parser.c:13021
-#, fuzzy, gcc-internal-format
-#| msgid "range-based for loop without a type-specifier only available with -std=c++1z or -std=gnu++1z"
+#, gcc-internal-format
  msgid "static_assert without a message only available with -std=c++1z or -std=gnu++1z"
-msgstr "intervallbaserad for-slinga utan en typspecificerare är endast tillgänglig med -std=c++1z eller -std=gnu++1z"
+msgstr "static_assert utan ett meddelande är endast tillgänglig med -std=c++1z eller -std=gnu++1z"
  
  #: cp/parser.c:13215
  #, gcc-internal-format
@@ -41193,16 +41158,14 @@ msgid "keyword %<export%> not implemented, and will be ignored"
  msgstr "nyckelordet %<export%> är inte implementerat och kommer ignoreras"
  
  #: cp/parser.c:14264
-#, fuzzy, gcc-internal-format
-#| msgid "invalid template non-type parameter"
+#, gcc-internal-format
  msgid "invalid constrained type parameter"
-msgstr "ogiltig mallparameter som inte är en typ"
+msgstr "ogiltig begränsad typparameter"
  
  #: cp/parser.c:14272
-#, fuzzy, gcc-internal-format
-#| msgid "invalid template non-type parameter"
+#, gcc-internal-format
  msgid "cv-qualified type parameter"
-msgstr "ogiltig mallparameter som inte är en typ"
+msgstr "cv-kvalificerad typparameter"
  
  #: cp/parser.c:14357
  #, gcc-internal-format
@@ -41210,10 +41173,9 @@ msgid "variadic constraint introduced without %<...%>"
  msgstr "variadisk begränsning introducerad utan %<...%>"
  
  #: cp/parser.c:14421
-#, fuzzy, gcc-internal-format
-#| msgid "invalid use of %<auto%> in template argument"
+#, gcc-internal-format
  msgid "invalid use of %<auto%> in default template argument"
-msgstr "felaktig användning av %<auto%> i mallargument"
+msgstr "felaktig användning av %<auto%> i standardmallargument"
  
  #: cp/parser.c:14656 cp/parser.c:14739 cp/parser.c:20599
  #, gcc-internal-format
@@ -41363,10 +41325,9 @@ msgid "%qD is an enumeration template"
  msgstr "%qD är en uppräkningsmall"
  
  #: cp/parser.c:17081
-#, fuzzy, gcc-internal-format
-#| msgid "%qD does not have integral or enumeration type"
+#, gcc-internal-format
  msgid "%qD does not name an enumeration in %qT"
-msgstr "%qD har inte heltals- eller uppräkningstyp"
+msgstr "%qD är inte namnet på en uppräkningstyp i %qT"
  
  #: cp/parser.c:17096
  #, gcc-internal-format
@@ -41384,10 +41345,9 @@ msgid "cannot add an enumerator list to a template instantiation"
  msgstr "det går inte att lägga till en uppräkningslista till en mallinstansiering"
  
  #: cp/parser.c:17214
-#, fuzzy, gcc-internal-format
-#| msgid "friend declaration does not name a class or function"
+#, gcc-internal-format
  msgid "nested name specifier %qT for enum declaration does not name a class or namespace"
-msgstr "vändeklaration som inte namnger en klass eller funktion"
+msgstr "nästad namnspecificerare %qT för enum-deklaration som inte namnger en klass eller namnrymd"
  
  #: cp/parser.c:17226 cp/parser.c:21835
  #, gcc-internal-format
@@ -41430,34 +41390,29 @@ msgid "expected namespace-name"
  msgstr "namnrymdsnamn förväntades"
  
  #: cp/parser.c:17549
-#, fuzzy, gcc-internal-format
-#| msgid "%<namespace%> definition is not allowed here"
+#, gcc-internal-format
  msgid "a nested namespace definition cannot have attributes"
-msgstr "%<namespace%>-definition är inte tillåten här"
+msgstr "en nästad namnrymdsdefinition kan inte ha attribut"
  
  #: cp/parser.c:17552
-#, fuzzy, gcc-internal-format
-#| msgid "inline namespaces only available with -std=c++11 or -std=gnu++11"
+#, gcc-internal-format
  msgid "nested namespace definitions only available with -std=c++1z or -std=gnu++1z"
-msgstr "inline-namnrymder är endast tillgängliga med -std=c++11 eller -std=gnu++11"
+msgstr "nästade namnrymdsdefinitioner är endast tillgängliga med -std=c++1z eller -std=gnu++1z"
  
  #: cp/parser.c:17555
-#, fuzzy, gcc-internal-format
-#| msgid "Warn when an inlined function cannot be inlined"
+#, gcc-internal-format
  msgid "a nested namespace definition cannot be inline"
-msgstr "Varna när en inline:ad funktion inte kan inline:as"
+msgstr "en nästad namnrymdsdefinition kan inte inline:as"
  
  #: cp/parser.c:17563
-#, fuzzy, gcc-internal-format
-#| msgid "expected identifier"
+#, gcc-internal-format
  msgid "nested identifier required"
-msgstr "identifierare förväntades"
+msgstr "nästad identifierare behövs"
  
  #: cp/parser.c:17591
-#, fuzzy, gcc-internal-format
-#| msgid "use of namespace %qD as expression"
+#, gcc-internal-format
  msgid "namespace %qD entered"
-msgstr "användning av namnrymden %q+D som uttryck"
+msgstr "gick in i namnrymden %qD"
  
  #: cp/parser.c:17643
  #, gcc-internal-format
@@ -41597,10 +41552,9 @@ msgid "multiple ref-qualifiers"
  msgstr "upprepade ref-kvalificerare"
  
  #: cp/parser.c:19650
-#, fuzzy, gcc-internal-format
-#| msgid "%<-mfpxx%> requires %<-mlra%>"
+#, gcc-internal-format
  msgid "%E requires %<-fgnu-tm%>"
-msgstr "%<-mfpxx%> kräver %<-mlra%>"
+msgstr "%E kräver %<-fgnu-tm%>"
  
  #: cp/parser.c:19706
  #, gcc-internal-format
@@ -41823,10 +41777,9 @@ msgid "dynamic exception specifications are deprecated in C++0x; use %<noexcept%
  msgstr "dynamiska undantagsspecifikationer undanbedes i C++0x, använd %<noexcept%> istället"
  
  #: cp/parser.c:23153
-#, fuzzy, gcc-internal-format
-#| msgid "invalid use of %<auto%> in conversion operator"
+#, gcc-internal-format
  msgid "invalid use of %<auto%> in exception-specification"
-msgstr "ogiltig användning av %<auto%> i konverteringsoperator"
+msgstr "ogiltig användning av %<auto%> i undantagsspecifikation"
  
  #: cp/parser.c:23192
  #, gcc-internal-format
@@ -41849,10 +41802,9 @@ msgid "%<deprecated%> is a C++14 feature; use %<gnu::deprecated%>"
  msgstr "%<deprecated%> är en funktion i C++14; använd %<gnu::deprecated%>"
  
  #: cp/parser.c:23998
-#, fuzzy, gcc-internal-format
-#| msgid "%qE attribute ignored due to conflict with attribute %qs"
+#, gcc-internal-format
  msgid "attribute noreturn can appear at most once in an attribute-list"
-msgstr "attributet %qE ignoreras eftersom det står i konflikt med attributet %qs"
+msgstr "attributet noreturn får förekomma högst en gång i en attributlista"
  
  #: cp/parser.c:24002
  #, gcc-internal-format
@@ -41860,16 +41812,14 @@ msgid "attribute deprecated can appear at most once in an attribute-list"
  msgstr "attributet deprecated kan förekomma högst en gång i en attributlista"
  
  #: cp/parser.c:24273
-#, fuzzy, gcc-internal-format
-#| msgid "ref-qualifiers only available with -std=c++11 or -std=gnu++11"
+#, gcc-internal-format
  msgid "%<requires%> only available with -fconcepts"
-msgstr "ref-kvalificerare är endast tillgängliga med -std=c++11 eller -std=gnu++11"
+msgstr "%<requires%> är endast tillgängligt med -fconcepts"
  
  #: cp/parser.c:24305
-#, fuzzy, gcc-internal-format
-#| msgid "a transaction expression cannot appear in a constant-expression"
+#, gcc-internal-format
  msgid "a requires expression cannot appear outside a template"
-msgstr "ett transaktionsuttryck får inte finnas i ett konstantuttryck"
+msgstr "ett transaktionsuttryck får inte finnas utanför en mall"
  
  #: cp/parser.c:25001
  #, gcc-internal-format
@@ -41911,16 +41861,14 @@ msgid "literal operator template %qD has invalid parameter list.  Expected non-t
  msgstr "den literala operatormallen %qD har ogiltig parameterlista.  Ett mallargument som inte är en typ pack <char...> förväntades"
  
  #: cp/parser.c:25582
-#, fuzzy, gcc-internal-format
-#| msgid "Enable multiply instructions"
+#, gcc-internal-format
  msgid "empty introduction-list"
-msgstr "Använd multiplikationsinstruktioner"
+msgstr "tom introduktionslista"
  
  #: cp/parser.c:25606
-#, fuzzy, gcc-internal-format
-#| msgid "no matching template for %qD found"
+#, gcc-internal-format
  msgid "no matching concept for template-introduction"
-msgstr "det finns ingen matchande mall för %qD"
+msgstr "det finns inget matchande koncept för mallintroduktionen"
  
  #: cp/parser.c:25628
  #, gcc-internal-format
@@ -41943,10 +41891,9 @@ msgid "template declaration of %<typedef%>"
  msgstr "malldeklaration av %<typedef%>"
  
  #: cp/parser.c:25808
-#, fuzzy, gcc-internal-format
-#| msgid "declaration does not declare anything"
+#, gcc-internal-format
  msgid "a class template declaration must not declare anything else"
-msgstr "deklaration som inte deklarerar något"
+msgstr "en klassmallsdeklaration får inte deklarera något annat"
  
  #: cp/parser.c:25854
  #, gcc-internal-format
@@ -42260,22 +42207,19 @@ msgid "not enough collapsed for loops"
  msgstr "inte tillräcklig kollapsat för slingor"
  
  #: cp/parser.c:34003
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp barrier%> may only be used in compound statements"
+#, gcc-internal-format
  msgid "%<#pragma omp ordered%> with %<depend%> clause may only be used in compound statements"
-msgstr "%<#pragma omp barrier%> får bara användas i sammansatta satser"
+msgstr "%<#pragma omp ordered%> med %<depend%>-klausul får bara användas i sammansatta satser"
  
  #: cp/parser.c:34795
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp target update%> must contain at least one %<from%> or %<to%> clauses"
+#, gcc-internal-format
  msgid "%<#pragma omp target exit data%> with map-type other than %<from%>, %<release%> or %<delete%> on %<map%> clause"
-msgstr "%<#pragma omp target update%> måste innehålla åtminstone en %<from%>- eller %<to%>-klausul"
+msgstr "%<#pragma omp target exit data%> med en annan map-typ än %<from%>-, %<release%>- eller %<delete%> på %<map%>-klausul"
  
  #: cp/parser.c:35658
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma omp declare simd%> cannot be used in the same function marked as a Cilk Plus SIMD-enabled function"
+#, gcc-internal-format
  msgid "%<#pragma omp declare simd%> of %<simd%> attribute cannot be used in the same function marked as a Cilk Plus SIMD-enabled  function"
-msgstr "%<#pragma omp declare simd%> kan inte användas i samma funktion som är markerad som en Cilk Plus SIMD-aktiverad funktion"
+msgstr "%<#pragma omp declare simd%> av %<simd%>-attributkan inte användas i samma funktion som är markerad som en Cilk Plus SIMD-aktiverad funktion"
  
  #: cp/parser.c:35668
  #, gcc-internal-format
@@ -42328,22 +42272,19 @@ msgid "const, volatile or __restrict qualified type %qT in %<#pragma omp declare
  msgstr "const-, volatile- eller __restrict-kvalificerad typ %qT i %<#pragma omp declare reduction%>"
  
  #: cp/parser.c:36517
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma acc enter data%> has no data movement clause"
+#, gcc-internal-format
  msgid "%<#pragma acc routine%> names a set of overloads"
-msgstr "%<#pragma acc enter data%> har ingen dataflyttningsklausul"
+msgstr "%<#pragma acc routine%> namnger en mängd överlagrade"
  
  #: cp/parser.c:36526
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma cilk grainsize%> must be inside a function"
+#, gcc-internal-format
  msgid "%<#pragma acc routine%> does not refer to a namespace scope function"
-msgstr "%<#pragma cilk grainsize%> måste vara inuti en funktion"
+msgstr "%<#pragma acc routine%> refererar inte till en funktion med namnrymdsräckvidd"
  
  #: cp/parser.c:36535
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma cilk grainsize%> must be inside a function"
+#, gcc-internal-format
  msgid "%<#pragma acc routine%> does not refer to a function"
-msgstr "%<#pragma cilk grainsize%> måste vara inuti en funktion"
+msgstr "%<#pragma acc routine%> refererar inte till en funktion"
  
  #. cancel-and-throw is unimplemented.
  #: cp/parser.c:36873
@@ -42442,10 +42383,9 @@ msgid "specialization of %qD in different namespace"
  msgstr "specialisering av %qD i en annan namnrymd"
  
  #: cp/pt.c:797 cp/pt.c:1024
-#, fuzzy, gcc-internal-format
-#| msgid "  from definition of %q+#D"
+#, gcc-internal-format
  msgid "  from definition of %q#D"
-msgstr "  än definitionen av %q+#D"
+msgstr "  från definitionen av %q#D"
  
  #: cp/pt.c:814
  #, gcc-internal-format
@@ -42577,10 +42517,9 @@ msgid "explicit specialization of %qD must be introduced by %<template <>%>"
  msgstr "explicit specialisering av %qD måste inledas av %<template <>%>"
  
  #: cp/pt.c:2715
-#, fuzzy, gcc-internal-format
-#| msgid "explicit specialization of non-template %qT"
+#, gcc-internal-format
  msgid "explicit specialization declared %<concept%>"
-msgstr "explicit specialisering av icke-mall %qT"
+msgstr "explicit specialisering  deklarerad %<concept%>"
  
  #: cp/pt.c:2746
  #, gcc-internal-format
@@ -42626,10 +42565,9 @@ msgid "%qD is not declared in %qD"
  msgstr "%qD inte deklarerad i %qD"
  
  #: cp/pt.c:3059
-#, fuzzy, gcc-internal-format
-#| msgid "explicit specialization of non-template %qT"
+#, gcc-internal-format
  msgid "explicit specialization of function concept %qD"
-msgstr "explicit specialisering av icke-mall %qT"
+msgstr "explicit specialisering av funktionskonceptet %qD"
  
  #: cp/pt.c:3654
  #, gcc-internal-format
@@ -42662,28 +42600,24 @@ msgid "        <anonymous>"
  msgstr "        <anonym>"
  
  #: cp/pt.c:3905
-#, fuzzy, gcc-internal-format
-#| msgid "declaration of %q+D shadows a parameter"
+#, gcc-internal-format
  msgid "declaration of template parameter %q+D shadows template parameter"
-msgstr "deklaration av %q+D skuggar en parameter"
+msgstr "deklaration av mallparametern %q+D skuggar en mallparameter"
  
  #: cp/pt.c:3908
-#, fuzzy, gcc-internal-format
-#| msgid "declaration of %q+D shadows a parameter"
+#, gcc-internal-format
  msgid "declaration of %q+#D shadows template parameter"
-msgstr "deklaration av %q+D skuggar en parameter"
+msgstr "deklaration av %q+#D skuggar en mallparameter"
  
  #: cp/pt.c:3910
-#, fuzzy, gcc-internal-format
-#| msgid "template parameter type %qT declared %<friend%>"
+#, gcc-internal-format
  msgid "template parameter %qD declared here"
-msgstr "mallparametertyp %qT deklarerad %<friend%>"
+msgstr "mallparametern %qD deklarerad här"
  
  #: cp/pt.c:4449
-#, fuzzy, gcc-internal-format
-#| msgid "specialization of alias template %qD"
+#, gcc-internal-format
  msgid "specialization of variable concept %q#D"
-msgstr "specialisering av aliasmall %qD"
+msgstr "specialisering av variabelkonceptet %q#D"
  
  #: cp/pt.c:4508
  #, gcc-internal-format
@@ -42691,16 +42625,14 @@ msgid "template parameters not deducible in partial specialization:"
  msgstr "mallparameter är inte härledbara i partiell specialisering:"
  
  #: cp/pt.c:4532
-#, fuzzy, gcc-internal-format
-#| msgid "partial specialization %qD does not specialize any template arguments"
+#, gcc-internal-format
  msgid "partial specialization %q+D does not specialize any template arguments"
-msgstr "partiell specialisering %qD specialiserar inte något mallargument"
+msgstr "partiell specialisering %q+D specialiserar inte något mallargument"
  
  #: cp/pt.c:4535
-#, fuzzy, gcc-internal-format
-#| msgid "partial specialization %qD does not specialize any template arguments"
+#, gcc-internal-format
  msgid "partial specialization %q+D does not specialize any template arguments and is not more constrained than"
-msgstr "partiell specialisering %qD specialiserar inte något mallargument"
+msgstr "partiell specialisering %q+D specialiserar inte något mallargument och är inte mer begränsad än"
  
  #: cp/pt.c:4537 cp/pt.c:4548
  #, gcc-internal-format
@@ -42735,10 +42667,9 @@ msgstr[0] "typ %qT för mallargument %qE beror på en mallparameter"
  msgstr[1] "typ %qT för mallargument %qE beror på mallparametrar"
  
  #: cp/pt.c:4718
-#, fuzzy, gcc-internal-format
-#| msgid "ambiguous template instantiation for %q#D"
+#, gcc-internal-format
  msgid "declaration of %qD ambiguates earlier template instantiation for %qD"
-msgstr "tvetydig mallinstansiering av %q#D"
+msgstr "deklaration av %qD gör tidigare mallinstansiering av %qD tvetydig"
  
  #: cp/pt.c:4722
  #, gcc-internal-format
@@ -42784,10 +42715,9 @@ msgid "default argument for template parameter for class enclosing %qD"
  msgstr "standardargumentet för mallparameter för klass om omsluter %qD"
  
  #: cp/pt.c:5122
-#, fuzzy, gcc-internal-format
-#| msgid "parameter %qD declared void"
+#, gcc-internal-format
  msgid "template %qD declared"
-msgstr "parameter %qD deklarerad void"
+msgstr "mallen %qD deklarerad"
  
  #: cp/pt.c:5129
  #, gcc-internal-format
@@ -42862,13 +42792,11 @@ msgstr[0] "omdeklarerad med %d mallparameter"
  msgstr[1] "omdeklarerad med %d mallparametrar"
  
  #: cp/pt.c:5541
-#, fuzzy, gcc-internal-format
-#| msgid "previous declaration %q+D used %d template parameter"
-#| msgid_plural "previous declaration %q+D used %d template parameters"
+#, gcc-internal-format
  msgid "previous declaration %qD used %d template parameter"
  msgid_plural "previous declaration %qD used %d template parameters"
-msgstr[0] "tidigare deklaration av %q+D använde %d mallparameter"
-msgstr[1] "tidigare deklaration av %q+D använde %d mallparametrar"
+msgstr[0] "tidigare deklaration av %qD använde %d mallparameter"
+msgstr[1] "tidigare deklaration av %qD använde %d mallparametrar"
  
  #: cp/pt.c:5578
  #, gcc-internal-format
@@ -42895,16 +42823,14 @@ msgid "original definition appeared here"
  msgstr "ursprunglig definition fanns här"
  
  #: cp/pt.c:5616
-#, fuzzy, gcc-internal-format
-#| msgid "redeclaration %qD differs in %<constexpr%>"
+#, gcc-internal-format
  msgid "redeclaration %q#D with different constraints"
-msgstr "omdeklaration av %qD skiljer i %<constexpr%>"
+msgstr "omdeklaration av %q#D med andra begränsningar"
  
  #: cp/pt.c:5619
-#, fuzzy, gcc-internal-format
-#| msgid "original definition appeared here"
+#, gcc-internal-format
  msgid "original declaration appeared here"
-msgstr "ursprunglig definition fanns här"
+msgstr "ursprunglig deklaration fanns här"
  
  #: cp/pt.c:5872 cp/pt.c:5923
  #, gcc-internal-format
@@ -43084,16 +43010,14 @@ msgid "%q#D is not a valid template argument for type %qT because a reference va
  msgstr "%q#D är inte ett giltigt mallargument till typen %qT eftersom en referensvariabel inte har en konstant adress"
  
  #: cp/pt.c:6533
-#, fuzzy, gcc-internal-format
-#| msgid "%qE is not a valid template argument for type %qT because it is not an object with external linkage"
+#, gcc-internal-format
  msgid "%qE is not a valid template argument for type %qT because it is not an object with linkage"
-msgstr "%qE är inte ett giltigt mallargument för typen %qT eftersom det inte är ett objekt med extern länkklass"
+msgstr "%qE är inte ett giltigt mallargument för typen %qT eftersom det inte är ett objekt med länkklass"
  
  #: cp/pt.c:6544
-#, fuzzy, gcc-internal-format
-#| msgid "%qE is not a valid template argument for type %qT because object %qD has not external linkage"
+#, gcc-internal-format
  msgid "%qE is not a valid template argument for type %qT because object %qD does not have linkage"
-msgstr "%qE är inte ett giltigt mallargument för typ %qT eftersom objekt %qD inte har extern länkklass"
+msgstr "%qE är inte ett giltigt mallargument för typ %qT eftersom objekt %qD inte har någon länkklass"
  
  #: cp/pt.c:6590
  #, gcc-internal-format
@@ -43171,16 +43095,14 @@ msgid "  expected a template of type %qD, got %qT"
  msgstr "  förväntade en mall av typen %qD, fick %qT"
  
  #: cp/pt.c:7202
-#, fuzzy, gcc-internal-format
-#| msgid "type/value mismatch at argument %d in template parameter list for %qD"
+#, gcc-internal-format
  msgid "constraint mismatch at argument %d in template parameter list for %qD"
-msgstr "typ/värde stämmer inte vid argument %d i mallparameterlistan till %qD"
+msgstr "begränsningar stämmer inte vid argument %d i mallparameterlistan till %qD"
  
  #: cp/pt.c:7205
-#, fuzzy, gcc-internal-format
-#| msgid "  expected a type, got %qE"
+#, gcc-internal-format
  msgid "  expected %qD but got %qD"
-msgstr "  förväntade en typ, fick %qE"
+msgstr "  %qD förväntades men fick %qD"
  
  #. Not sure if this is reachable, but it doesn't hurt
  #. to be robust.
@@ -43210,10 +43132,9 @@ msgid "wrong number of template arguments (%d, should be at least %d)"
  msgstr "fel antal mallargument (%d, skulle vara åtminstone %d)"
  
  #: cp/pt.c:7547
-#, fuzzy, gcc-internal-format
-#| msgid "provided for %q+D"
+#, gcc-internal-format
  msgid "provided for %qD"
-msgstr "angivna till %q+D"
+msgstr "angivna till %qD"
  
  #: cp/pt.c:7572
  #, gcc-internal-format
@@ -43221,10 +43142,9 @@ msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
  msgstr "pack-expansionsargument för icke-pack-parametern %qD till aliasmall %qD"
  
  #: cp/pt.c:7576
-#, fuzzy, gcc-internal-format
-#| msgid "pack expansion argument for non-pack parameter %qD of alias template %qD"
+#, gcc-internal-format
  msgid "pack expansion argument for non-pack parameter %qD of concept %qD"
-msgstr "pack-expansionsargument för icke-pack-parametern %qD till aliasmall %qD"
+msgstr "pack-expansionsargument för icke-pack-parametern %qD till konceptet %qD"
  
  #: cp/pt.c:7668
  #, gcc-internal-format
@@ -43252,16 +43172,14 @@ msgid "for template declaration %q+D"
  msgstr "för malldeklaration %q+D"
  
  #: cp/pt.c:8339
-#, fuzzy, gcc-internal-format
-#| msgid "internal consistency failure"
+#, gcc-internal-format
  msgid "template constraint failure"
-msgstr "internt konsistensfel"
+msgstr "mallbegränsningsfel"
  
  #: cp/pt.c:8683
-#, fuzzy, gcc-internal-format
-#| msgid "constructors may not be cv-qualified"
+#, gcc-internal-format
  msgid "constraints for %qD not satisfied"
-msgstr "konstruerare får inte vara cv-kvalificerade"
+msgstr "begränsningarna för %qD är inte uppfyllda"
  
  #: cp/pt.c:9075
  #, gcc-internal-format, gfc-internal-format
@@ -43447,10 +43365,9 @@ msgid "use %<%T::%D%> instead"
  msgstr "använd %<%T::%D%> istället"
  
  #: cp/pt.c:16574
-#, fuzzy, gcc-internal-format
-#| msgid "%q+D declared here, later in the translation unit"
+#, gcc-internal-format
  msgid "%qD declared here, later in the translation unit"
-msgstr "%q+D är deklarerad här, senare i översättningsenheten"
+msgstr "%qD är deklarerad här, senare i översättningsenheten"
  
  #: cp/pt.c:16847
  #, gcc-internal-format
@@ -43629,22 +43546,19 @@ msgid "placeholder constraints not satisfied"
  msgstr "platshållabegränsningar är inte uppfyllt"
  
  #: cp/pt.c:24036
-#, fuzzy, gcc-internal-format
-#| msgid "insn does not satisfy its constraints:"
+#, gcc-internal-format
  msgid "deduced initializer does not satisfy placeholder constraints"
-msgstr "instruktionen håller inte sina begränsningar:"
+msgstr "härledd initierare uppfyller inte sina platshållarbegränsningar"
  
  #: cp/pt.c:24040
-#, fuzzy, gcc-internal-format
-#| msgid "insn does not satisfy its constraints:"
+#, gcc-internal-format
  msgid "deduced return type does not satisfy placeholder constraints"
-msgstr "instruktionen håller inte sina begränsningar:"
+msgstr "härledd returtyp uppfyller inte sina platshållarbegränsningar"
  
  #: cp/pt.c:24044
-#, fuzzy, gcc-internal-format
-#| msgid "insn does not satisfy its constraints:"
+#, gcc-internal-format
  msgid "deduced expression type does not saatisy placeholder constraints"
-msgstr "instruktionen håller inte sina begränsningar:"
+msgstr "härledd uttryckstyp uppfyller inte sina platshållarbegränsningar"
  
  #: cp/repo.c:113
  #, gcc-internal-format
@@ -43712,10 +43626,9 @@ msgid "invalid covariant return type for %q#D"
  msgstr "ogiltig kovariant returtyp för %q#D"
  
  #: cp/search.c:2054
-#, fuzzy, gcc-internal-format
-#| msgid "  overriding %q+#D"
+#, gcc-internal-format
  msgid "  overriding %q#D"
-msgstr "  åsidosätter %q+#D"
+msgstr "  åsidosätter %q#D"
  
  #: cp/search.c:2067
  #, gcc-internal-format
@@ -43748,16 +43661,14 @@ msgid "conflicting type attributes specified for %q+#D"
  msgstr "motstridiga typattribut angivna för %q+#D"
  
  #: cp/search.c:2115
-#, fuzzy, gcc-internal-format
-#| msgid "expected %<__transaction_atomic%>"
+#, gcc-internal-format
  msgid "%qD declared %<transaction_safe_dynamic%>"
-msgstr "%<__transaction_atomic%> förväntades"
+msgstr "%qD deklarerad %<transaction_safe_dynamic%>"
  
  #: cp/search.c:2117
-#, fuzzy, gcc-internal-format
-#| msgid "variable %q+D declared %<inline%>"
+#, gcc-internal-format
  msgid "overriding %qD declared %<transaction_safe%>"
-msgstr "variabeln %q+D deklarerad %<inline%>"
+msgstr "åsidosätter %qD deklarerad %<transaction_safe%>"
  
  #: cp/search.c:2124
  #, gcc-internal-format
@@ -43996,16 +43907,14 @@ msgid "user defined reduction lookup is ambiguous"
  msgstr "användardefinierad reduktionsuppslagning är tvetydig"
  
  #: cp/semantics.c:5496
-#, fuzzy, gcc-internal-format
-#| msgid "%qE in %<aligned%> clause is neither a pointer nor an array"
+#, gcc-internal-format
  msgid "%qE in %<reduction%> clause is a zero size array"
-msgstr "%qE i %<aligned%>-klausul är varken en pekare eller en vektor"
+msgstr "%qE i %<reduction%>-klausul är en vektor med storlek noll"
  
  #: cp/semantics.c:5544
-#, fuzzy, gcc-internal-format
-#| msgid "%qE has invalid type for %<reduction%>"
+#, gcc-internal-format
  msgid "%qE has const type for %<reduction%>"
-msgstr "%qE har ogiltig typ för %<reduction%>"
+msgstr "%qE har const-typ för %<reduction%>"
  
  #: cp/semantics.c:5656
  #, gcc-internal-format
@@ -44013,10 +43922,9 @@ msgid "user defined reduction with constructor initializer for base class %qT"
  msgstr "användardefinierad reduktion med konstruerarinitierare för basklassen %qT"
  
  #: cp/semantics.c:5878
-#, fuzzy, gcc-internal-format
-#| msgid "linear clause applied to non-integral non-pointer variable with %qT type"
+#, gcc-internal-format
  msgid "linear clause with %qs modifier applied to non-reference variable with %qT type"
-msgstr "linjär klausul tillämpad på en variabel som inte är heltal och inte pekare med typen %qT"
+msgstr "linjär klausul med modifieraren %qs tillämpad på en variabel som inte är en referens med typen %qT"
  
  #: cp/semantics.c:5890
  #, gcc-internal-format
@@ -44044,64 +43952,54 @@ msgid "%qD is not a variable in clause %<lastprivate%>"
  msgstr "%qD är inte en variabel i klausul %<lastprivate%>"
  
  #: cp/semantics.c:6154
-#, fuzzy, gcc-internal-format
-#| msgid "%<async%> expression must be integral"
+#, gcc-internal-format
  msgid "%<gang%> static expression must be integral"
-msgstr "%<async%>-uttryck måste vara heltal"
+msgstr "%<gang%>-statisk uttryck måste vara heltal"
  
  #: cp/semantics.c:6168
-#, fuzzy, gcc-internal-format
-#| msgid "%<num_gangs%> value must be positive"
+#, gcc-internal-format
  msgid "%<gang%> static value must bepositive"
-msgstr "%<num_gangs%>-värdet måste vara positivt"
+msgstr "%<gang%>-statiskt värde måste vara positivt"
  
  #: cp/semantics.c:6200
-#, fuzzy, gcc-internal-format
-#| msgid "%<async%> expression must be integral"
+#, gcc-internal-format
  msgid "%<gang%> num expression must be integral"
-msgstr "%<async%>-uttryck måste vara heltal"
+msgstr "%<gang%>-numeriskt uttryck måste vara ett heltal"
  
  #: cp/semantics.c:6203
-#, fuzzy, gcc-internal-format
-#| msgid "%qs length expression must be integral"
+#, gcc-internal-format
  msgid "%<vector%> length expression must be integral"
-msgstr "%qs-längduttryck måste vara ett heltal"
+msgstr "%<vector%>-längduttryck måste vara ett heltal"
  
  #: cp/semantics.c:6207
-#, fuzzy, gcc-internal-format
-#| msgid "%<wait%> expression must be integral"
+#, gcc-internal-format
  msgid "%<worker%> num expression must be integral"
-msgstr "%<wait%>-uttryck måste vara heltal"
+msgstr "%<worker%>-numeriskt uttryck måste vara ett heltal"
  
  #: cp/semantics.c:6211
-#, fuzzy, gcc-internal-format
-#| msgid "expression must be integral"
+#, gcc-internal-format
  msgid "%qs expression must be integral"
-msgstr "uttrycket måste vara ett heltal"
+msgstr "%qs-uttrycket måste vara ett heltal"
  
  #: cp/semantics.c:6229
-#, fuzzy, gcc-internal-format
-#| msgid "%<num_gangs%> value must be positive"
+#, gcc-internal-format
  msgid "%<gang%> num value must be positive"
-msgstr "%<num_gangs%>-värdet måste vara positivt"
+msgstr "%<gang%>-numeriskt värde måste vara positivt"
  
  #: cp/semantics.c:6233
-#, fuzzy, gcc-internal-format
-#| msgid "%<vector_length%> value must be positive"
+#, gcc-internal-format
  msgid "%<vector%> length value must bepositive"
-msgstr "%<vector_length%>-värdet måste vara positivt"
+msgstr "%<vector%>-längdvärdet måste vara positivt"
  
  #: cp/semantics.c:6238
-#, fuzzy, gcc-internal-format
-#| msgid "%<num_workers%> value must be positive"
+#, gcc-internal-format
  msgid "%<worker%> num value must bepositive"
-msgstr "%<num_workers%>-värdet måste vara positivt"
+msgstr "%<worker%>-numerikst värde måste vara positivt"
  
  #: cp/semantics.c:6243
-#, fuzzy, gcc-internal-format
-#| msgid "%<num_gangs%> value must be positive"
+#, gcc-internal-format
  msgid "%qs value must be positive"
-msgstr "%<num_gangs%>-värdet måste vara positivt"
+msgstr "%qs-värdet måste vara positivt"
  
  #: cp/semantics.c:6290
  #, gcc-internal-format
@@ -44169,34 +44067,29 @@ msgid "overloaded function name %qE in clause %qs"
  msgstr "överlagrad funktion med namnet %qE i klausulen %qs"
  
  #: cp/semantics.c:6813
-#, fuzzy, gcc-internal-format
-#| msgid "too many %qs clauses"
+#, gcc-internal-format
  msgid "template %qE in clause %qs"
-msgstr "för många %qs-klausuler"
+msgstr "mallen %qE i-klausulen %qs"
  
  #: cp/semantics.c:6878
-#, fuzzy, gcc-internal-format
-#| msgid "%<wait%> expression must be integral"
+#, gcc-internal-format
  msgid "%<grainsize%> expression must be integral"
-msgstr "%<wait%>-uttryck måste vara heltal"
+msgstr "%<grainsize%>-uttryck måste vara ett heltal"
  
  #: cp/semantics.c:6907
-#, fuzzy, gcc-internal-format
-#| msgid "%<wait%> expression must be integral"
+#, gcc-internal-format
  msgid "%<priority%> expression must be integral"
-msgstr "%<wait%>-uttryck måste vara heltal"
+msgstr "%<priority%>-uttryck måste vara ett heltal"
  
  #: cp/semantics.c:6936
-#, fuzzy, gcc-internal-format
-#| msgid "%<num_teams%> expression must be integral"
+#, gcc-internal-format
  msgid "%<num_tasks%> expression must be integral"
-msgstr "%<num_teams%>-uttryck måste vara heltal"
+msgstr "%<num_tasks%>-uttryck måste vara ett heltal"
  
  #: cp/semantics.c:6965
-#, fuzzy, gcc-internal-format
-#| msgid "%qE in %<aligned%> clause is neither a pointer nor an array nor a reference to pointer or array"
+#, gcc-internal-format
  msgid "%qs variable is neither a pointer, nor an arraynor reference to pointer or array"
-msgstr "%qE i %<aligned%>-klausul är varken en pekare eller en vektor eller en referens till pekare eller vektor"
+msgstr "%qs-variabeln är varken en pekare, eller en vektor eller en referens till pekare eller vektor"
  
  #: cp/semantics.c:7421
  #, gcc-internal-format
@@ -44224,10 +44117,9 @@ msgid "%<#pragma omp atomic update%> uses two different expressions for memory"
  msgstr "%<#pragma omp atomic update%> använder två olika uttryck för minne"
  
  #: cp/semantics.c:8705
-#, fuzzy, gcc-internal-format
-#| msgid "static assertion failed: %E"
+#, gcc-internal-format
  msgid "static assertion failed"
-msgstr "statisk försäkran misslyckades: %E"
+msgstr "statisk försäkran misslyckades"
  
  #: cp/semantics.c:8707
  #, gcc-internal-format, gfc-internal-format
@@ -44250,16 +44142,14 @@ msgid "decltype cannot resolve address of overloaded function"
  msgstr "decltype kan inte lösa upp adressen till en överlagrad funktion"
  
  #: cp/semantics.c:9299
-#, fuzzy, gcc-internal-format
-#| msgid "third operand of conditional expression has no effect"
+#, gcc-internal-format
  msgid "operand of fold expression has no unexpanded parameter packs"
-msgstr "tredje operanden av villkorsuttryck har ingen effekt"
+msgstr "operanden till vikningsuttrycket har inget oexpanderat parameterpaket"
  
  #: cp/semantics.c:9352
-#, fuzzy, gcc-internal-format
-#| msgid "template argument %qE involves template parameter(s)"
+#, gcc-internal-format
  msgid "both arguments in binary fold have unexpanded parameter packs"
-msgstr "mallargument %qE berör mallparametrar"
+msgstr "båda argumentet i en binär vikning har oexpanderade parameterpaket"
  
  #: cp/semantics.c:9354
  #, gcc-internal-format
@@ -44467,10 +44357,9 @@ msgid "ISO C++ forbids applying %<__alignof%> to an expression of function type"
  msgstr "ISO C++ förbjuder användning av %<__alignof%> på ett uttryck med funktionstyp"
  
  #: cp/typeck.c:1836
-#, fuzzy, gcc-internal-format
-#| msgid "invalid use of non-static member function %qD"
+#, gcc-internal-format
  msgid "invalid use of non-static member function of type %qT"
-msgstr "ogiltig användning av icke-statisk medlemsfunktion %qD"
+msgstr "ogiltig användning av icke-statisk medlemsfunktion av typen %qT"
  
  #: cp/typeck.c:2001
  #, gcc-internal-format
@@ -44528,10 +44417,9 @@ msgid "%qT is not a base of %qT"
  msgstr "%qT är inte en basklass till %qT"
  
  #: cp/typeck.c:2820
-#, fuzzy, gcc-internal-format
-#| msgid "%q#T has no member named %qE"
+#, gcc-internal-format
  msgid "%q#T has no member named %qE; did you mean %qE?"
-msgstr "%q#T har ingen medlem med namnet %qE"
+msgstr "%q#T har ingen medlem med namnet %qE, menade du %qE?"
  
  #: cp/typeck.c:2824
  #, gcc-internal-format
@@ -44594,10 +44482,9 @@ msgid "object missing in use of %qE"
  msgstr "objekt saknas i användning av %qE"
  
  #: cp/typeck.c:3535
-#, fuzzy, gcc-internal-format
-#| msgid "cannot disable built-in function %qs"
+#, gcc-internal-format
  msgid "cannot call function %qD"
-msgstr "det går inte att avaktivera den inbyggda funktionen %qs"
+msgstr "det går inte att anropa funktionen %qD"
  
  #: cp/typeck.c:3550
  #, gcc-internal-format
@@ -44690,10 +44577,9 @@ msgid "the address of %qD will never be NULL"
  msgstr "adressen till %qD kommer aldrig vara NULL"
  
  #: cp/typeck.c:4004
-#, fuzzy, gcc-internal-format
-#| msgid "the comparison will always evaluate as %<true%> for the address of %qD will never be NULL"
+#, gcc-internal-format
  msgid "the compiler can assume that the address of %qD will never be NULL"
-msgstr "jämförelsen kommer alltid beräknas till %<true%> för adressen till %qD kommer aldrig att vara NULL"
+msgstr "kompilatorn kan anta att adressen till %qD aldrig kommer att vara NULL"
  
  #: cp/typeck.c:4123 cp/typeck.c:4134
  #, gcc-internal-format
@@ -45108,10 +44994,9 @@ msgid "left-hand side of assignment might be a candidate for a format attribute"
  msgstr "vänsterhandssida av tilldelning kan vara en kandidat för ett formatattribut"
  
  #: cp/typeck.c:8523
-#, fuzzy, gcc-internal-format
-#| msgid "in passing argument %P of %q+D"
+#, gcc-internal-format
  msgid "in passing argument %P of %qD"
-msgstr "när argument %P till %q+D skickades"
+msgstr "när argument %P till %qD skickades"
  
  #: cp/typeck.c:8582
  #, gcc-internal-format
@@ -45124,22 +45009,19 @@ msgid "reference to non-lvalue returned"
  msgstr "referens till annat än lvärde returnerad"
  
  #: cp/typeck.c:8604
-#, fuzzy, gcc-internal-format
-#| msgid "reference to local variable %q+D returned"
+#, gcc-internal-format
  msgid "reference to local variable %qD returned"
-msgstr "referens till lokal variabel %q+D returnerad"
+msgstr "referens till lokal variabel %qD returnerad"
  
  #: cp/typeck.c:8608
-#, fuzzy, gcc-internal-format
-#| msgid "address of label %q+D returned"
+#, gcc-internal-format
  msgid "address of label %qD returned"
-msgstr "adressen till etiketten %q+D returnerad"
+msgstr "adressen till etiketten %qD returnerad"
  
  #: cp/typeck.c:8612
-#, fuzzy, gcc-internal-format
-#| msgid "address of local variable %q+D returned"
+#, gcc-internal-format
  msgid "address of local variable %qD returned"
-msgstr "adress till lokal variabel %q+D returnerad"
+msgstr "adress till lokal variabel %qD returnerad"
  
  #: cp/typeck.c:8658
  #, gcc-internal-format
@@ -45176,10 +45058,9 @@ msgid "inconsistent types %qT and %qT deduced for lambda return type"
  msgstr "inkonsistenta typer %qT och %qT härledda för lambda-returtypen"
  
  #: cp/typeck.c:8729
-#, fuzzy, gcc-internal-format
-#| msgid "inconsistent deduction for %qT: %qT and then %qT"
+#, gcc-internal-format
  msgid "inconsistent deduction for auto return type: %qT and then %qT"
-msgstr "inkonsistent härledning för %qT: %qT och sedan %qT"
+msgstr "inkonsistent härledning för auto-returtyp: %qT och sedan %qT"
  
  #: cp/typeck.c:8764
  #, gcc-internal-format
@@ -45354,10 +45235,9 @@ msgid "declaration of %q#T"
  msgstr "deklaration av %q#T"
  
  #: cp/typeck2.c:472
-#, fuzzy, gcc-internal-format
-#| msgid "%q#D has incomplete type"
+#, gcc-internal-format
  msgid "%qD has incomplete type"
-msgstr "%q#D har ofullständig typ"
+msgstr "%qD har ofullständig typ"
  
  #: cp/typeck2.c:487
  #, gcc-internal-format
@@ -45370,16 +45250,14 @@ msgid "invalid use of %qT"
  msgstr "ogiltigt användning av %qT"
  
  #: cp/typeck2.c:517
-#, fuzzy, gcc-internal-format
-#| msgid "invalid use of member function (did you forget the %<()%> ?)"
+#, gcc-internal-format
  msgid "invalid use of member function %qD (did you forget the %<()%> ?)"
-msgstr "ogiltig användning av medlemsfunktion (glömde du %<()%> ?)"
+msgstr "ogiltig användning av medlemsfunktionen %qD (glömde du %<()%> ?)"
  
  #: cp/typeck2.c:521
-#, fuzzy, gcc-internal-format
-#| msgid "invalid use of member (did you forget the %<&%> ?)"
+#, gcc-internal-format
  msgid "invalid use of member %qD (did you forget the %<&%> ?)"
-msgstr "ogiltig användning av medlem (glömde du %<&%>?)"
+msgstr "ogiltig användning av medlem %qD (glömde du %<&%>?)"
  
  #: cp/typeck2.c:532
  #, gcc-internal-format
@@ -45432,10 +45310,9 @@ msgid "narrowing conversion of %qE from %qT to %qT inside { }"
  msgstr "avsmalnande konvertering av %qE från %qT till %qT inuti { }"
  
  #: cp/typeck2.c:958
-#, fuzzy, gcc-internal-format
-#| msgid "expression in static assertion is not an integer constant expression"
+#, gcc-internal-format
  msgid " the expression has a constant value but is not a C++ constant-expression"
-msgstr "uttryck i statisk försäkran är inte ett konstant heltalsuttryck"
+msgstr " uttrycket har ett konstant värde men är inte ett C++ konstant uttryck"
  
  #: cp/typeck2.c:1044
  #, gcc-internal-format
@@ -45702,16 +45579,14 @@ msgstr "Konvertering från %qs till %qs vid %L"
  #: fortran/arith.c:2075 fortran/arith.c:2108 fortran/arith.c:2147
  #: fortran/arith.c:2205 fortran/arith.c:2257 fortran/arith.c:2317
  #: fortran/arith.c:2386
-#, fuzzy, gcc-internal-format
-#| msgid "Change of value in conversion from  %qs to %qs at %L"
+#, gcc-internal-format
  msgid "Change of value in conversion from %qs to %qs at %L"
  msgstr "Ändring av värde vid konvertering från %qs till %qs vid %L"
  
  #: fortran/arith.c:2303 fortran/arith.c:2372
-#, fuzzy, gcc-internal-format
-#| msgid "Possible change of value in conversion from %qs to %qs at %L"
+#, gcc-internal-format
  msgid "Non-zero imaginary part discarded in conversion from %qs to %qs at %L"
-msgstr "Möjlig ändring av värde vid konvertering från %qs till %qs vid %L"
+msgstr "Icke tom imaginär del kastades vid konvertering från %qs till %qs vid %L"
  
  #: fortran/arith.c:2455
  #, gcc-internal-format
@@ -45807,10 +45682,9 @@ msgid "Expected expression in array specification at %C"
  msgstr "Förväntade uttryck i vektorspecifikation vid %C"
  
  #: fortran/array.c:431 fortran/array.c:463
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expected scalar initialization expression at %C"
+#, gcc-internal-format, gfc-internal-format
  msgid "Expecting a scalar INTEGER expression at %C, found %s"
-msgstr "Ett skalärt initieringsuttryck förväntades vid %C"
+msgstr "Ett skalärt INTEGER-uttryck förväntades vid %C, hittade %s"
  
  #: fortran/array.c:500
  #, gcc-internal-format, gfc-internal-format
@@ -45908,10 +45782,9 @@ msgid "Empty array constructor at %C is not allowed"
  msgstr "Tom vektorkonstruerare vid %C är inte tillåtet"
  
  #: fortran/array.c:1188 fortran/array.c:1198
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "incompatible type for argument %d of %qE"
+#, gcc-internal-format, gfc-internal-format
  msgid "Incompatible typespec for array element at %L"
-msgstr "inkompatibel typ för argument %d av %qE"
+msgstr "Inkompatibel typspecifikation för vektorelement vid %L"
  
  #: fortran/array.c:1264
  #, gcc-internal-format, gfc-internal-format
@@ -46181,10 +46054,9 @@ msgid "ATOM argument at %L of the %s intrinsic function shall be a coarray or co
  msgstr "ATOM-argumentet till vid %L till den inbyggda funktionen %s måste vara en co-vektor eller co-indexat"
  
  #: fortran/check.c:1042
-#, fuzzy, gcc-internal-format
-#| msgid "'%s' argument of '%s' intrinsic at %L shall have the same type as '%s' at %L"
+#, gcc-internal-format
  msgid "%qs argument of %qs intrinsic at %L shall have the same type as %qs at %L"
-msgstr "”%s”-argumentet till inbyggd ”%s” vid %L måste ha samma typ och sort som ”%s” vid %L"
+msgstr "%qs-argumentet till inbyggd %qs vid %L måste ha samma typ som %qs vid %L"
  
  #: fortran/check.c:1060 fortran/check.c:1205
  #, gcc-internal-format, gfc-internal-format
@@ -46212,22 +46084,19 @@ msgid "OLD argument of the %s intrinsic function at %L shall be definable"
  msgstr "OLD-argumentet till den inbyggda funktionen %s vid %L måste vara definierbart"
  
  #: fortran/check.c:1167
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The A argument at %L to the intrinsic %s shall not be coindexed"
+#, gcc-internal-format, gfc-internal-format
  msgid "EVENT argument at %L to the intrinsic EVENT_QUERY shall be of type EVENT_TYPE"
-msgstr "Argumentet A vid %L till den inbyggda %s skall inte vara co-indexerat"
+msgstr "EVENT-argumentetet vid %L till den inbyggda EVENT_QUERY skall ha typen EVENT_TYPE"
  
  #: fortran/check.c:1177
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "OLD argument of the %s intrinsic function at %L shall be definable"
+#, gcc-internal-format, gfc-internal-format
  msgid "COUNT argument of the EVENT_QUERY intrinsic function at %L shall be definable"
-msgstr "OLD-argumentet till den inbyggda funktionen %s vid %L måste vara definierbart"
+msgstr "COUNT-argumentet till den inbyggda funktionen EVENT_QUERY vid %L måste vara definierbart"
  
  #: fortran/check.c:1190
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "OLD argument of the %s intrinsic function at %L shall be definable"
+#, gcc-internal-format, gfc-internal-format
  msgid "COUNT argument of the EVENT_QUERY intrinsic function at %L shall have at least the range of the default integer"
-msgstr "OLD-argumentet till den inbyggda funktionen %s vid %L måste vara definierbart"
+msgstr "COUNT-argumentet till den inbyggda funktionen EVENT_QUERY vid %L måste ha åtminstone intervallet för standardheltal"
  
  #: fortran/check.c:1269
  #, gcc-internal-format, gfc-internal-format
@@ -46353,10 +46222,9 @@ msgid "The character length of the A argument at %L and of the function result o
  msgstr "Teckenlängden för argumentet A vid %L och funktionsresultatet av OPERATOR vid %L skall vara samma"
  
  #: fortran/check.c:1744
-#, fuzzy, gcc-internal-format
-#| msgid "'%s' argument of '%s' intrinsic at %L shall be of type integer, real or character"
+#, gcc-internal-format
  msgid "%qs argument of %qs intrinsic at %L shall be of type integer, real or character"
-msgstr "Argument ”%s” till inbyggd ”%s” vid %L skall ha typen heltal, reell eller tecken"
+msgstr "Argument %qs till inbyggd %qs vid %L skall ha typen heltal, reell eller tecken"
  
  #: fortran/check.c:1792 fortran/check.c:2324 fortran/check.c:2427
  #: fortran/check.c:2628 fortran/check.c:2673 fortran/check.c:3984
@@ -46392,10 +46260,9 @@ msgid "%qs argument of %qs intrinsic at %L must be default real"
  msgstr "%qs-argumentet till inbyggd %qs vid %L måste vara standard reell"
  
  #: fortran/check.c:2020
-#, fuzzy, gcc-internal-format
-#| msgid "'I' at %L and 'J' at %L cannot both be BOZ literal constants"
+#, gcc-internal-format
  msgid "%<I%> at %L and %<J%>' at %L cannot both be BOZ literal constants"
-msgstr "”I” vid %L och ”J” vid %L kan inte båda vara literala BOZ-konstanter"
+msgstr "%<I%> vid %L och %<J%> vid %L kan inte båda vara literala BOZ-konstanter"
  
  #: fortran/check.c:2151
  #, gcc-internal-format, gfc-internal-format
@@ -46583,10 +46450,9 @@ msgid "%qs argument of %qs intrinsic at %L has negative element (%d)"
  msgstr "%qs-argumentet till inbyggd %qs vid %L har negativa element (%d)"
  
  #: fortran/check.c:3799
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Complex argument of LOG at %L cannot be zero"
+#, gcc-internal-format, gfc-internal-format
  msgid "Element %d of actual argument of RESHAPE at %L cannot be negative"
-msgstr "Komplext argument till LOG vid %L får inte vara noll"
+msgstr "Elementet %d av aktuellt argument till RESHAPE vid %L får inte vara negativt"
  
  #: fortran/check.c:3837
  #, gcc-internal-format
@@ -46599,10 +46465,9 @@ msgid "%qs argument of %qs intrinsic at %L has out-of-range dimension (%d)"
  msgstr "%qs-argumentet till inbyggd %qs vid %L har dimension utanför giltigt intervall (%d)"
  
  #: fortran/check.c:3864
-#, fuzzy, gcc-internal-format
-#| msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %<%d%> duplicated)"
+#, gcc-internal-format
  msgid "%qs argument of %qs intrinsic at %L has invalid permutation of dimensions (dimension %qd duplicated)"
-msgstr "%qs-argumentet till inbyggd %qs vid %L har en ogiltig permutation av dimensioner (dimension %<%d%> dubblerad)"
+msgstr "%qs-argumentet till inbyggd %qs vid %L har en ogiltig permutation av dimensioner (dimension %qd dubblerad)"
  
  #: fortran/check.c:3900
  #, gcc-internal-format, gfc-internal-format
@@ -46885,10 +46750,9 @@ msgid "fe_runtime_error string must be null terminated"
  msgstr "fe_runtime_error-sträng måste vara null-terminerad"
  
  #: fortran/check.c:5646
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "wrong number of template arguments (%d, should be %d)"
+#, gcc-internal-format, gfc-internal-format
  msgid "fe_runtime_error: Wrong number of arguments (%d instead of %d)"
-msgstr "fel antal mallargument (%d, skulle vara %d)"
+msgstr "fe_runtime_error: Fel antal argument (%d istället för %d)"
  
  #: fortran/check.c:5686
  #, gcc-internal-format, gfc-internal-format
@@ -46968,16 +46832,14 @@ msgid "Unused initialization string at %L because variable has zero length"
  msgstr "Oanvänd initieringssträng vid %L för att variabeln har nollängd"
  
  #: fortran/data.c:176
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Initialization string starting at %L was truncated to fit the variable (%d/%d)"
+#, gcc-internal-format, gfc-internal-format
  msgid "Initialization string at %L was truncated to fit the variable (%d/%d)"
-msgstr "Initieringssträng som startar vid %L höggs av för att stämma med variabeln (%d/%d)"
+msgstr "Initieringssträng vid %L höggs av för att stämma med variabeln (%d/%d)"
  
  #: fortran/data.c:266
-#, fuzzy, gcc-internal-format
-#| msgid "'%s' at %L already is initialized at %L"
+#, gcc-internal-format
  msgid "%qs at %L already is initialized at %L"
-msgstr "”%s” vid %L är redan initierad vid %L"
+msgstr "%qs vid %L är redan initierad vid %L"
  
  #: fortran/data.c:290
  #, gcc-internal-format, gfc-internal-format
@@ -47025,10 +46887,9 @@ msgid "Initialization at %C is not allowed in a PURE procedure"
  msgstr "Initieringen vid %C får inte förekomma i en PURE-procedur"
  
  #: fortran/decl.c:560
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
+#, gcc-internal-format, gfc-internal-format
  msgid "DATA statement at %C cannot appear within an INTERFACE"
-msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett INTERFACE"
+msgstr "DATA-sats vid %C kan inte förekomma inuti ett INTERFACE"
  
  #: fortran/decl.c:592
  #, gcc-internal-format, gfc-internal-format
@@ -47066,22 +46927,19 @@ msgid "Syntax error in character length specification at %C"
  msgstr "Syntaxfel i specifikation av teckenlängd vid %C"
  
  #: fortran/decl.c:990
-#, fuzzy, gcc-internal-format
-#| msgid "Procedure '%s' at %C is already defined at %L"
+#, gcc-internal-format
  msgid "Procedure %qs at %C is already defined at %L"
-msgstr "Proceduren ”%s” vid %C är redan definierad vid %L"
+msgstr "Proceduren %qs vid %C är redan definierad vid %L"
  
  #: fortran/decl.c:998
-#, fuzzy, gcc-internal-format
-#| msgid "Name '%s' at %C is already defined as a generic interface at %L"
+#, gcc-internal-format
  msgid "Name %qs at %C is already defined as a generic interface at %L"
-msgstr "Namnet ”%s” vid %C är redan definierat som ett generiskt gränssnitt vid %L"
+msgstr "Namnet %qs vid %C är redan definierat som ett generiskt gränssnitt vid %L"
  
  #: fortran/decl.c:1011
-#, fuzzy, gcc-internal-format
-#| msgid "Procedure '%s' at %C has an explicit interface and must not have attributes declared at %L"
+#, gcc-internal-format
  msgid "Procedure %qs at %C has an explicit interface and must not have attributes declared at %L"
-msgstr "Proceduren ”%s” vid %C har ett explicit gränssnitt och får inte ha attribut deklarerade vid %L"
+msgstr "Proceduren %qs vid %C har ett explicit gränssnitt och får inte ha attribut deklarerade vid %L"
  
  #: fortran/decl.c:1082
  #, gcc-internal-format
@@ -47134,16 +46992,14 @@ msgid "Variable %qs at %L with OPTIONAL attribute in procedure %qs which is BIND
  msgstr "Variabeln %qs vid %L med attributet OPTIONAL i proceduren %qs som är BIND(C)"
  
  #: fortran/decl.c:1195
-#, fuzzy, gcc-internal-format
-#| msgid "Assumed-shape array '%s' at %L as dummy argument to the BIND(C) procedure '%s' at %L"
+#, gcc-internal-format
  msgid "Assumed-shape array %qs at %L as dummy argument to the BIND(C) procedure %qs at %L"
-msgstr "Vektorn ”%s” med antagen form vid %L som attrappargument till BIND(C)-proceduren ”%s” vid %L"
+msgstr "Vektorn %qs med antagen form vid %L som attrappargument till BIND(C)-proceduren %qs vid %L"
  
  #: fortran/decl.c:1244
-#, fuzzy, gcc-internal-format
-#| msgid "Symbol %qs at %L already has basic type of %s"
+#, gcc-internal-format
  msgid "Symbol %qs at %C also declared as a type at %L"
-msgstr "Symbolen %qs vid %L har redan grundtypen %s"
+msgstr "Symbolen %qs vid %C är också deklarerad som en typ vid %L"
  
  #: fortran/decl.c:1303
  #, gcc-internal-format
@@ -47393,10 +47249,9 @@ msgid "Type name %qs at %C is ambiguous"
  msgstr "Typnamnet %qs vid %C är tvetydigt"
  
  #: fortran/decl.c:3005
-#, fuzzy, gcc-internal-format
-#| msgid "Type name '%s' at %C conflicts with previously declared entity at %L, which has the same name"
+#, gcc-internal-format
  msgid "Type name %qs at %C conflicts with previously declared entity at %L, which has the same name"
-msgstr "Typnamnet ”%s” vid %C står i konflikt med tidigare deklarerad enhet vid %L, som har samma namn"
+msgstr "Typnamnet %qs vid %C står i konflikt med tidigare deklarerad enhet vid %L, som har samma namn"
  
  #: fortran/decl.c:3122
  #, gcc-internal-format, gfc-internal-format
@@ -47434,10 +47289,9 @@ msgid "IMPORT statement at %C only permitted in an INTERFACE body"
  msgstr "IMPORT-sats vid %C endast tillåten inuti en INTERFACE-kropp"
  
  #: fortran/decl.c:3412
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "IMPORT statement at %C only permitted in an INTERFACE body"
+#, gcc-internal-format, gfc-internal-format
  msgid "F2008: C1210 IMPORT statement at %C is not permitted in a module procedure interface body"
-msgstr "IMPORT-sats vid %C endast tillåten inuti en INTERFACE-kropp"
+msgstr "F2008: C1210 IMPORT-sats vid %C är inte tillåten i en moduls procedurgränssnittskropp"
  
  #: fortran/decl.c:3417
  #, gcc-internal-format, gfc-internal-format
@@ -47622,10 +47476,9 @@ msgid "Syntax error in data declaration at %C"
  msgstr "Syntaxfel i datadeklaration vid %C"
  
  #: fortran/decl.c:4615
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "IMPURE procedure at %C"
+#, gcc-internal-format, gfc-internal-format
  msgid "MODULE prefix at %C"
-msgstr "IMPURE-procedur vid %C"
+msgstr "MODULE-prefix vid %C"
  
  #: fortran/decl.c:4660
  #, gcc-internal-format, gfc-internal-format
@@ -47663,10 +47516,9 @@ msgid "Mismatch in MODULE PROCEDURE formal argument names (%s/%s) at %C"
  msgstr "Formella argumentnamnen till MODULE PROCEDURE stämmer inte (%s/%s) vid %C"
  
  #: fortran/decl.c:4876
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "double colon in MODULE PROCEDURE statement at %L"
+#, gcc-internal-format, gfc-internal-format
  msgid "Mismatch in number of MODULE PROCEDURE formal arguments at %C"
-msgstr "dubbelkolon i MODULE PROCEDURE-sats vid %L"
+msgstr "Antalet formella MODULE PROCEDURE-argument vid %C stämmer inte"
  
  #: fortran/decl.c:4915
  #, gcc-internal-format, gfc-internal-format
@@ -47771,10 +47623,9 @@ msgid "ENTRY statement at %C cannot appear within a MODULE"
  msgstr "ENTRY-sats vid %C kan inte förekomma inuti en MODULE"
  
  #: fortran/decl.c:5784
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "ENTRY statement at %C cannot appear within a MODULE"
+#, gcc-internal-format, gfc-internal-format
  msgid "ENTRY statement at %C cannot appear within a SUBMODULE"
-msgstr "ENTRY-sats vid %C kan inte förekomma inuti en MODULE"
+msgstr "ENTRY-sats vid %C kan inte förekomma inuti en SUBMODULE"
  
  #: fortran/decl.c:5787
  #, gcc-internal-format, gfc-internal-format
@@ -48108,10 +47959,9 @@ msgid "Syntax error in ASYNCHRONOUS statement at %C"
  msgstr "Syntaxfel i ASYNCHRONOUS-sats vid %C"
  
  #: fortran/decl.c:7719
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "PROCEDURE list at %C"
+#, gcc-internal-format, gfc-internal-format
  msgid "MODULE PROCEDURE declaration at %C"
-msgstr "PROCEDURE-lista vid %C"
+msgstr "MODULE PROCEDURE-deklaration vid %C"
  
  #: fortran/decl.c:7812
  #, gcc-internal-format, gfc-internal-format
@@ -48839,10 +48689,9 @@ msgid "Procedure pointer target %qs at %L must be either an intrinsic, host or u
  msgstr "Procedurpekarmålet %qs vid %L måste vara antingen en inbyggd, värd, värd- eller användningsassocierad, refererad eller ha attributet EXTERNAL"
  
  #: fortran/expr.c:3635
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Data-pointer-object &L must be unlimited polymorphic, a sequence derived type or of a type with the BIND attribute assignment at %L to be compatible with an unlimited polymorphic target"
+#, gcc-internal-format, gfc-internal-format
  msgid "Data-pointer-object at %L must be unlimited polymorphic, or of a type with the BIND or SEQUENCE attribute, to be compatible with an unlimited polymorphic target"
-msgstr "Datapekarobjekt &L måste vara obegränsat polymorft, en sekvens härledd typ eller av en typ med attibutet BIND-tilldelning vid %L för att vara kompatibel med ett obegränsat polymorft mål"
+msgstr "Datapekarobjekt vid %L måste vara obegränsat polymorft, eller av en typ med attributet BIND eller SEQUENCE, för att vara kompatibel med ett obegränsat polymorft mål"
  
  #: fortran/expr.c:3640
  #, gcc-internal-format, gfc-internal-format
@@ -48955,10 +48804,9 @@ msgid "Non-POINTER in pointer association context (%s) at %L"
  msgstr "Icke-POINTER i pekarassociationssammanhang (%s) vid %L"
  
  #: fortran/expr.c:4845
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Named constant %qs in variable definition context (%s) at %L"
+#, gcc-internal-format, gfc-internal-format
  msgid "Type inaccessible in variable definition context (%s) at %L"
-msgstr "Namngiven konstant %qs i variabeldefinitionssammanhang (%s) vid %L"
+msgstr "Typen är oåtkomlig i variabeldefinitionssammanhang (%s) vid %L"
  
  #: fortran/expr.c:4858
  #, gcc-internal-format, gfc-internal-format
@@ -48966,10 +48814,9 @@ msgid "LOCK_TYPE in variable definition context (%s) at %L"
  msgstr "LOCK_TYPE i variabeldefinitionssammanhang (%s) vid %L"
  
  #: fortran/expr.c:4871
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "LOCK_TYPE in variable definition context (%s) at %L"
+#, gcc-internal-format, gfc-internal-format
  msgid "LOCK_EVENT in variable definition context (%s) at %L"
-msgstr "LOCK_TYPE i variabeldefinitionssammanhang (%s) vid %L"
+msgstr "LOCK_EVENT i variabeldefinitionssammanhang (%s) vid %L"
  
  #: fortran/expr.c:4900
  #, gcc-internal-format
@@ -49007,10 +48854,9 @@ msgid "%qs at %L associated to expression can not be used in a variable definiti
  msgstr "%qs vid %L som är associerad med uttryck kan inte användas i ett variabeldefinitionssammanhang (%s)"
  
  #: fortran/expr.c:5015
-#, fuzzy, gcc-internal-format
-#| msgid "Associate-name '%s' can not appear in a variable definition context (%s) at %L because its target at %L can not, either"
+#, gcc-internal-format
  msgid "Associate-name %qs can not appear in a variable definition context (%s) at %L because its target at %L can not, either"
-msgstr "Associationsnamn ”%s” kan inte förekomma i ett variabeldefinitionssammanhang (%s) vid %L eftersom dess mål vid %L inte heller kan"
+msgstr "Associationsnamn %qs kan inte förekomma i ett variabeldefinitionssammanhang (%s) vid %L eftersom dess mål vid %L inte heller kan"
  
  #: fortran/expr.c:5057
  #, gcc-internal-format, gfc-internal-format
@@ -49045,28 +48891,24 @@ msgid "illegal OP in optimize_comparison"
  msgstr "otillåten OP i optimize_comparison"
  
  #: fortran/frontend-passes.c:1887
-#, fuzzy, gcc-internal-format
-#| msgid "Variable '%s' at %L set to undefined value inside loop  beginning at %L as INTENT(OUT) argument to subroutine '%s'"
+#, gcc-internal-format
  msgid "Variable %qs at %L set to undefined value inside loop  beginning at %L as INTENT(OUT) argument to subroutine %qs"
-msgstr "Variabeln ”%s” vid %L satt till odefinierad inuti en slinga som börjar vid %L är argument INTENT(OUT) till subrutin ”%s”"
+msgstr "Variabeln %qs vid %L satt till odefinierad inuti en slinga som börjar vid %L är argument INTENT(OUT) till subrutin %qs"
  
  #: fortran/frontend-passes.c:1894
-#, fuzzy, gcc-internal-format
-#| msgid "Variable '%s' at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine '%s'"
+#, gcc-internal-format
  msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to subroutine %qs"
-msgstr "Variabeln ”%s” vid %L ej definierbar inuti slingan som börjar vid %L är argument INTENT(INOUT) till subrutin ”%s”"
+msgstr "Variabeln %qs vid %L ej definierbar inuti slingan som börjar vid %L är argument INTENT(INOUT) till subrutin %qs"
  
  #: fortran/frontend-passes.c:1959
-#, fuzzy, gcc-internal-format
-#| msgid "Variable '%s' at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function '%s'"
+#, gcc-internal-format
  msgid "Variable %qs at %L set to undefined value inside loop beginning at %L as INTENT(OUT) argument to function %qs"
-msgstr "Variabeln ”%s” vid %L satt till odefinierad inuti slingan som börjar vid %L är argument INTENT(OUT) till funktionen ”%s”"
+msgstr "Variabeln %qs vid %L satt till odefinierad inuti slingan som börjar vid %L är argument INTENT(OUT) till funktionen %qs"
  
  #: fortran/frontend-passes.c:1965
-#, fuzzy, gcc-internal-format
-#| msgid "Variable '%s' at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function '%s'"
+#, gcc-internal-format
  msgid "Variable %qs at %L not definable inside loop beginning at %L as INTENT(INOUT) argument to function %qs"
-msgstr "Variabeln ”%s” vid %L ej definierbar inuti slingan som börjar vid %L är argument INTENT(INOUT) till funktionen ”%s”"
+msgstr "Variabeln %qs vid %L ej definierbar inuti slingan som börjar vid %L är argument INTENT(INOUT) till funktionen %qs"
  
  #: fortran/frontend-passes.c:2213 fortran/trans-expr.c:1522
  #, gcc-internal-format, gfc-internal-format
@@ -49329,10 +49171,9 @@ msgid "Corank mismatch in argument %qs at %L (%d and %d)"
  msgstr "Co-ordning stämmer inte i argument %qs vid %L (%d och %d)"
  
  #: fortran/interface.c:2142
-#, fuzzy, gcc-internal-format
-#| msgid "Actual argument to %qs at %L must be simply contiguous"
+#, gcc-internal-format
  msgid "Actual argument to %qs at %L must be simply contiguous or an element of such an array"
-msgstr "Aktuellt argument till %qs vid %L måste vara enkelt sammanhängande"
+msgstr "Aktuellt argument till %qs vid %L måste vara enkelt sammanhängande eller ett element i en sådan vektor"
  
  #: fortran/interface.c:2157
  #, gcc-internal-format
@@ -49340,10 +49181,9 @@ msgid "Actual argument to non-INTENT(INOUT) dummy %qs at %L, which is LOCK_TYPE
  msgstr "Aktuellt argument till icke-INTENT(INOUT)-attrappen %qs vid %L, som är LOCK_TYPE eller har en LOCK_TYPE-komponent"
  
  #: fortran/interface.c:2172
-#, fuzzy, gcc-internal-format
-#| msgid "Actual argument to non-INTENT(INOUT) dummy %qs at %L, which is LOCK_TYPE or has a LOCK_TYPE component"
+#, gcc-internal-format
  msgid "Actual argument to non-INTENT(INOUT) dummy %qs at %L, which is EVENT_TYPE or has a EVENT_TYPE component"
-msgstr "Aktuellt argument till icke-INTENT(INOUT)-attrappen %qs vid %L, som är LOCK_TYPE eller har en LOCK_TYPE-komponent"
+msgstr "Aktuellt argument till icke-INTENT(INOUT)-attrappen %qs vid %L, som är EVENT_TYPE eller har en EVENT_TYPE-komponent"
  
  #: fortran/interface.c:2191
  #, gcc-internal-format
@@ -49611,10 +49451,9 @@ msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires a
  msgstr "Aktuellt argument till LOCK_TYPE eller med LOCK_TYPE-komponent vid %L kräver ett explicit gränssnitt för proceduren %qs"
  
  #: fortran/interface.c:3413
-#, fuzzy, gcc-internal-format
-#| msgid "Actual argument of LOCK_TYPE or with LOCK_TYPE component at %L requires an explicit interface for procedure %qs"
+#, gcc-internal-format
  msgid "Actual argument of EVENT_TYPE or with EVENT_TYPE component at %L requires an explicit interface for procedure %qs"
-msgstr "Aktuellt argument till LOCK_TYPE eller med LOCK_TYPE-komponent vid %L kräver ett explicit gränssnitt för proceduren %qs"
+msgstr "Aktuellt argument till EVENT_TYPE eller med EVENT_TYPE-komponent vid %L kräver ett explicit gränssnitt för proceduren %qs"
  
  #: fortran/interface.c:3422
  #, gcc-internal-format, gfc-internal-format
@@ -49982,10 +49821,9 @@ msgid "Format statement in module main block at %C"
  msgstr "Formatsats i modulhuvudblock vid %C"
  
  #: fortran/io.c:1207
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
+#, gcc-internal-format, gfc-internal-format
  msgid "FORMAT statement at %C cannot appear within an INTERFACE"
-msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett INTERFACE"
+msgstr "FORMAT-sats vid %C kan inte förekomma inuti ett INTERFACE"
  
  #: fortran/io.c:1213
  #, gcc-internal-format, gfc-internal-format
@@ -50203,10 +50041,9 @@ msgid "%s statement not allowed in PURE procedure at %C"
  msgstr "%s-sats är inte tillåtet i PURE-procedur vid %C"
  
  #: fortran/io.c:2534
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "UNIT number in INQUIRE statement at %L can not be -1"
+#, gcc-internal-format, gfc-internal-format
  msgid "UNIT number missing in statement at %L"
-msgstr "UNIT-tal i INQUIRE-sats vid %L får inte vara -1"
+msgstr "UNIT-tal saknas i satsen vid %L"
  
  #: fortran/io.c:2542 fortran/io.c:2979
  #, gcc-internal-format, gfc-internal-format
@@ -50460,10 +50297,9 @@ msgid "Invalid character %<$%> at %L. Use %<-fdollar-ok%> to allow it as an exte
  msgstr "Ogiltigt tecken %<$%> vid %L.  Använd %<-fdollar-ok%> för att tillåta det som en utökning"
  
  #: fortran/match.c:882
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Loop variable at %C cannot be a coarray"
+#, gcc-internal-format, gfc-internal-format
  msgid "Loop variable at %C cannot be an array"
-msgstr "Slingvariabel vid %C får inte vara en co-vektor"
+msgstr "Slingvariabel vid %C får inte vara en vektor"
  
  #: fortran/match.c:889
  #, gcc-internal-format, gfc-internal-format
@@ -50732,22 +50568,19 @@ msgid "ERROR STOP statement at %C"
  msgstr "ERROR STOP-sats vid %C"
  
  #: fortran/match.c:2778
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Image control statement %s at %C in PURE procedure"
+#, gcc-internal-format, gfc-internal-format
  msgid "Image control statement EVENT %s at %C in PURE procedure"
-msgstr "Bildstyrsats %s vid %C i PURE-procedur"
+msgstr "Bildstyrsats EVENT %s vid %C i PURE-procedur"
  
  #: fortran/match.c:2793
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Image control statement %s at %C in CRITICAL block"
+#, gcc-internal-format, gfc-internal-format
  msgid "Image control statement EVENT %s at %C in CRITICAL block"
-msgstr "Bildkontrollsatsen %s vid %C i CRITICAL-block"
+msgstr "Bildkontrollsatsen EVENT %s vid %C i CRITICAL-block"
  
  #: fortran/match.c:2800
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Image control statement %s at %C in DO CONCURRENT block"
+#, gcc-internal-format, gfc-internal-format
  msgid "Image control statement EVENT %s at %C in DO CONCURRENT block"
-msgstr "Bildkontrollsatsen %s vid %C i DO CONCURRENT-block"
+msgstr "Bildkontrollsatsen EVENT %s vid %C i DO CONCURRENT-block"
  
  #: fortran/match.c:2830 fortran/match.c:3025 fortran/match.c:3237
  #: fortran/match.c:3747 fortran/match.c:4084
@@ -50762,22 +50595,19 @@ msgid "Redundant ERRMSG tag found at %L "
  msgstr "Överflödig ERRMSG-tagg funnen vid %L "
  
  #: fortran/match.c:2872
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Redundant STAT tag found at %L "
+#, gcc-internal-format, gfc-internal-format
  msgid "Redundant UNTIL_COUNT tag found at %L "
-msgstr "Överflödig STAT-tagg funnen vid %L "
+msgstr "Överflödig UNTIL_COUNT-tagg funnen vid %L "
  
  #: fortran/match.c:2938
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "ENTRY statement at %C"
+#, gcc-internal-format, gfc-internal-format
  msgid "EVENT POST statement at %C"
-msgstr "ENTRY-sats vid %C"
+msgstr "ENTRY POST-sats vid %C"
  
  #: fortran/match.c:2948
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "ENTRY statement at %C"
+#, gcc-internal-format, gfc-internal-format
  msgid "EVENT WAIT statement at %C"
-msgstr "ENTRY-sats vid %C"
+msgstr "ENTRY WAIT-sats vid %C"
  
  #: fortran/match.c:2973
  #, gcc-internal-format, gfc-internal-format
@@ -51023,10 +50853,9 @@ msgstr "Syntaxfel i common-blocknamn vid %C"
  #. cause it's just semantic, and we can see if there
  #. are more errors.
  #: fortran/match.c:4543
-#, fuzzy, gcc-internal-format
-#| msgid "Variable '%s' at %L in common block '%s' at %C must be declared with a C interoperable kind since common block '%s' is bind(c)"
+#, gcc-internal-format
  msgid "Variable %qs at %L in common block %qs at %C must be declared with a C interoperable kind since common block %qs is bind(c)"
-msgstr "Variabel ”%s” vid %L i common-block ”%s” vid %C måste deklareras med en C-interoperativ sort eftersom common-block ”%s” är bind(c)"
+msgstr "Variabel %qs vid %L i common-block %qs vid %C måste deklareras med en C-interoperativ sort eftersom common-block %qs är bind(c)"
  
  #: fortran/match.c:4552
  #, gcc-internal-format
@@ -51104,10 +50933,9 @@ msgid "Statement function at %L is recursive"
  msgstr "Satsfunktion vid %L är rekursiv"
  
  #: fortran/match.c:5124
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "ENTRY statement at %C cannot appear within an INTERFACE"
+#, gcc-internal-format, gfc-internal-format
  msgid "Statement function at %L cannot appear within an INTERFACE"
-msgstr "ENTRY-sats vid %C kan inte förekomma inuti ett INTERFACE"
+msgstr "Satsfunktion vid %L kan inte förekomma inuti ett INTERFACE"
  
  #: fortran/match.c:5129
  #, gcc-internal-format, gfc-internal-format
@@ -51115,10 +50943,9 @@ msgid "Statement function at %C"
  msgstr "Satsfunktion vid %C"
  
  #: fortran/match.c:5254 fortran/match.c:5270
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Expression in CASE statement at %L must be scalar"
+#, gcc-internal-format, gfc-internal-format
  msgid "Expression in CASE selector at %L cannot be %s"
-msgstr "Uttryck i CASE-sats vid %L måste vara skalärt"
+msgstr "Uttryck i CASE-sats vid %L får inte vara %s"
  
  #: fortran/match.c:5292
  #, gcc-internal-format, gfc-internal-format
@@ -51181,10 +51008,9 @@ msgid "Label %qs at %C doesn't match WHERE label %qs"
  msgstr "Etiketten %qs vid %C stämmer inte med WHERE-etikett %qs"
  
  #: fortran/matchexp.c:72
-#, fuzzy, gcc-internal-format
-#| msgid "Bad character %<%c%> in OPERATOR name at %C"
+#, gcc-internal-format
  msgid "Bad character %qc in OPERATOR name at %C"
-msgstr "Felaktigt tecken %<%c%> i OPERATOR-namn vid %C"
+msgstr "Felaktigt tecken %qc i OPERATOR-namn vid %C"
  
  #: fortran/matchexp.c:80
  #, gcc-internal-format
@@ -51273,16 +51099,14 @@ msgid "The name %qs at %C has already been used as an external module name."
  msgstr "Namnet %qs vid %C har redan använts som ett externt modulnamn."
  
  #: fortran/module.c:744
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Coarray declaration at %C"
+#, gcc-internal-format, gfc-internal-format
  msgid "SUBMODULE declaration at %C"
-msgstr "Co-vektordeklaration vid %C"
+msgstr "SUBMODULE-deklaration vid %C"
  
  #: fortran/module.c:814
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Syntax error in SAVE statement at %C"
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in SUBMODULE statement at %C"
-msgstr "Syntaxfel i SAVE-sats vid %C"
+msgstr "Syntaxfel i SUBMODULE-sats vid %C"
  
  #: fortran/module.c:1159
  #, gcc-internal-format
@@ -51496,10 +51320,9 @@ msgid "Cannot read module file %qs opened at %C, because it was created by a dif
  msgstr "Kan inte läsa modulfilen %qs öppnad vid %C, eftersom den skapades av en annan version av GNU Fortran"
  
  #: fortran/module.c:6967
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Can't USE the same module we're building!"
+#, gcc-internal-format, gfc-internal-format
  msgid "Can't USE the same %smodule we're building!"
-msgstr "Det går inta att USE samma modul vi bygger!"
+msgstr "Det går inta att USE samma %smodul vi bygger!"
  
  #: fortran/openmp.c:289 fortran/openmp.c:497 fortran/openmp.c:2399
  #: fortran/openmp.c:2473
@@ -51518,22 +51341,19 @@ msgid "Syntax error in OpenACC expression list at %C"
  msgstr "Syntaxfel i OpenACC-uttryckslista vid %C"
  
  #: fortran/openmp.c:465
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Threadprivate variable at %C is an element of a COMMON block"
+#, gcc-internal-format, gfc-internal-format
  msgid "Variable at %C is an element of a COMMON block"
-msgstr "Trådprivat variabel vid %C är ett element i ett COMMON-block"
+msgstr "Variabel vid %C är ett element i ett COMMON-block"
  
  #: fortran/openmp.c:525
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Unexpected junk after !$ACC ROUTINE at %C"
+#, gcc-internal-format, gfc-internal-format
  msgid "Unexpected junk after !$ACC DECLARE at %C"
-msgstr "Oväntat skräp efter !$ACC ROUTINE vid %C"
+msgstr "Oväntat skräp efter !$ACC DECLARE vid %C"
  
  #: fortran/openmp.c:535
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Syntax error in !$OMP DECLARE TARGET list at %C"
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in !$ACC DECLARE list at %C"
-msgstr "Syntaxfel i !$OMP DECLARE TARGET-lista vid %C"
+msgstr "Syntaxfel i !$OMP DECLARE-lista vid %C"
  
  #: fortran/openmp.c:991
  #, gcc-internal-format, gfc-internal-format
@@ -51546,10 +51366,9 @@ msgid "COLLAPSE clause argument not constant positive integer at %C"
  msgstr "COLLAPSE-klausulargument är inte ett konstant positivt heltal vid %C"
  
  #: fortran/openmp.c:1476
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Invalid argument to $!ACC WAIT at %L"
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid clause in module with $!ACC DECLARE at %L"
-msgstr "Ogiltiga argument till $!ACC WAIT vid %L"
+msgstr "Ogiltig klausul i modul med $!ACC DECLARE vid %L"
  
  #: fortran/openmp.c:1486
  #, gcc-internal-format, gfc-internal-format
@@ -51557,16 +51376,14 @@ msgid "Variable is USE-associated with $!ACC DECLARE at %L"
  msgstr "Variabel i USE-associated med $!ACC DECLARE vid %L"
  
  #: fortran/openmp.c:1494
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Assumed size array %qs in %s clause at %L"
+#, gcc-internal-format, gfc-internal-format
  msgid "Assumed-size dummy array with $!ACC DECLARE at %L"
-msgstr "Vektor %qs med antagen storlek i %s-klausul vid %L"
+msgstr "Attrappvektor med antagen storlek med $!ACC DECLARE at %L"
  
  #: fortran/openmp.c:1541
-#, fuzzy, gcc-internal-format
-#| msgid "%<#pragma acc update%> must contain at least one %<device%> or %<host/self%> clause"
+#, gcc-internal-format
  msgid "%<acc update%> must contain at least one %<device%> or %<host%> or %<self%> clause at %L"
-msgstr "%<#pragma acc update%> måste innehålla åtminstone en %<device%>- eller %<host/self%>-klausul"
+msgstr "%<acc update%> måste innehålla åtminstone en %<device%>- eller %<host%>- eller %<self%>-klausul vid %L"
  
  #: fortran/openmp.c:1591
  #, gcc-internal-format, gfc-internal-format
@@ -51589,10 +51406,9 @@ msgid "ACC CACHE directive must be inside of loop %C"
  msgstr "Direktivet ACC CACHE måste vara inuti en slinga %C"
  
  #: fortran/openmp.c:1669
-#, fuzzy, gcc-internal-format
-#| msgid "storage class specified for typename"
+#, gcc-internal-format
  msgid "Multiple loop axes specified for routine"
-msgstr "lagringsklass angiven för typnamn"
+msgstr "Multipla slingaxlar angivna för rutinen"
  
  #: fortran/openmp.c:1695
  #, gcc-internal-format, gfc-internal-format
@@ -51600,10 +51416,9 @@ msgid "Only the !$ACC ROUTINE form without list is allowed in interface block at
  msgstr "Endast formen !$ACC ROUTINE utan en lista är tillåten i gränssnittsblock vid %C"
  
  #: fortran/openmp.c:1722
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Syntax error in !$ACC ROUTINE ( NAME ) at %C, invalid function name %qs"
+#, gcc-internal-format, gfc-internal-format
  msgid "Syntax error in !$ACC ROUTINE ( NAME ) at %C, invalid function name %s"
-msgstr "Syntaxfel i !$ACC ROUTINE ( NAMN ) vid %C, felaktigt funktionsnamn %qs"
+msgstr "Syntaxfel i !$ACC ROUTINE ( NAMN ) vid %C, felaktigt funktionsnamn %s"
  
  #: fortran/openmp.c:1731
  #, gcc-internal-format, gfc-internal-format
@@ -51873,10 +51688,9 @@ msgid "Symbol %qs present on multiple clauses at %L"
  msgstr "Symbolen %qs finns i flera fall vid %L"
  
  #: fortran/openmp.c:3322
-#, fuzzy, gcc-internal-format
-#| msgid "Variable %qs cannot appear in the expression at %L"
+#, gcc-internal-format
  msgid "Array %qs is not permitted in reduction at %L"
-msgstr "Variabeln %qs kan inte förekomma i uttrycket vid %L"
+msgstr "Vektorn %qs får inte förekomma i reduktionen vid %L"
  
  #: fortran/openmp.c:3335
  #, gcc-internal-format
@@ -52205,10 +52019,9 @@ msgid "not enough DO loops for %s !$ACC LOOP at %L"
  msgstr "inte tillräckligt med DO-slingor för %s !$ACC LOOP vid %L"
  
  #: fortran/openmp.c:4747 fortran/openmp.c:4754
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "!$ACC LOOP %s in PARALLEL region doesn't allow non-static arguments at %L"
+#, gcc-internal-format, gfc-internal-format
  msgid "!$ACC LOOP %s in PARALLEL region doesn't allow %s arguments at %L"
-msgstr "!$ACC LOOP %s i PARALLEL-region tillåter inte icke-statiska argument vid %L"
+msgstr "!$ACC LOOP %s i PARALLEL-region tillåter inte %s-argument vid %L"
  
  #: fortran/openmp.c:4776
  #, gcc-internal-format, gfc-internal-format
@@ -52656,40 +52469,34 @@ msgid "Noncoarray component %s at %L of type LOCK_TYPE or with subcomponent of t
  msgstr "Icke co-vektorkomponenten %s vid %L av typen LOCK_TYPE eller med en underkomponent av typen LOCK_TYPE måste ha en co-dimension eller vara en underkomponent till en co-vektor.  (Variabler av typen %s får inte ha en co-dimension eftersom %s vid %L har en co-dimension eller en co-vektorunderkomponent)"
  
  #: fortran/parse.c:2889
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Component %s at %L of type LOCK_TYPE must have a codimension or be a subcomponent of a coarray, which is not possible as the component has the pointer attribute"
+#, gcc-internal-format, gfc-internal-format
  msgid "Component %s at %L of type EVENT_TYPE must have a codimension or be a subcomponent of a coarray, which is not possible as the component has the pointer attribute"
-msgstr "Komponenten %s vid %L av typen LOCK_TYPE måste ha en co-dimension eller vara en delkomponent till en co-vektor, vilket inte är möjligt eftersom komponenten har pekarattributet"
+msgstr "Komponenten %s vid %L av typen EVENT_TYPE måste ha en co-dimension eller vara en delkomponent till en co-vektor, vilket inte är möjligt eftersom komponenten har pekarattributet"
  
  #: fortran/parse.c:2895
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Pointer component %s at %L has a noncoarray subcomponent of type LOCK_TYPE, which must have a codimension or be a subcomponent of a coarray"
+#, gcc-internal-format, gfc-internal-format
  msgid "Pointer component %s at %L has a noncoarray subcomponent of type EVENT_TYPE, which must have a codimension or be a subcomponent of a coarray"
-msgstr "Pekarkomponenten %s vid %L har en icke co-vektordelkomponent av typen LOCK_TYPE, som måste ha en co-dimension eller vara en delkomponent av en co-vektor"
+msgstr "Pekarkomponenten %s vid %L har en icke co-vektordelkomponent av typen EVENT_TYPE, som måste ha en co-dimension eller vara en delkomponent av en co-vektor"
  
  #: fortran/parse.c:2900
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Allocatable component %s at %L of type LOCK_TYPE must have a codimension"
+#, gcc-internal-format, gfc-internal-format
  msgid "Allocatable component %s at %L of type EVENT_TYPE must have a codimension"
-msgstr "Allokerbar komponent %s vid %L av typen LOCK_TYPE måste ha en co-dimension"
+msgstr "Allokerbar komponent %s vid %L av typen EVENT_TYPE måste ha en co-dimension"
  
  #: fortran/parse.c:2904
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Allocatable component %s at %L must have a codimension as it has a noncoarray subcomponent of type LOCK_TYPE"
+#, gcc-internal-format, gfc-internal-format
  msgid "Allocatable component %s at %L must have a codimension as it has a noncoarray subcomponent of type EVENT_TYPE"
-msgstr "Den allokerbara komponenten %s vid %L måste ha en co-dimension eftersom den har en icke co-vektordelkomponent av typen LOCK_TYPE"
+msgstr "Den allokerbara komponenten %s vid %L måste ha en co-dimension eftersom den har en icke co-vektordelkomponent av typen EVENT_TYPE"
  
  #: fortran/parse.c:2909
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Noncoarray component %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as already a coarray subcomponent exists)"
+#, gcc-internal-format, gfc-internal-format
  msgid "Noncoarray component %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as already a coarray subcomponent exists)"
-msgstr "Icke co-vektorkomponenten %s vid %L av typen LOCK_TYPE eller med en underkomponent av typen LOCK_TYPE måste ha en co-dimension eller vara en underkomponent av en co-vektor.  (Variabler av typen %s får inte ha en co-dimension eftersom det redan finns en co-vektorunderkomponent)"
+msgstr "Icke co-vektorkomponenten %s vid %L av typen EVENT_TYPE eller med en underkomponent av typen LOCK_TYPE måste ha en co-dimension eller vara en underkomponent av en co-vektor.  (Variabler av typen %s får inte ha en co-dimension eftersom det redan finns en co-vektorunderkomponent)"
  
  #: fortran/parse.c:2916
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Noncoarray component %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as %s at %L has a codimension or a coarray subcomponent)"
+#, gcc-internal-format, gfc-internal-format
  msgid "Noncoarray component %s at %L of type EVENT_TYPE or with subcomponent of type EVENT_TYPE must have a codimension or be a subcomponent of a coarray. (Variables of type %s may not have a codimension as %s at %L has a codimension or a coarray subcomponent)"
-msgstr "Icke co-vektorkomponenten %s vid %L av typen LOCK_TYPE eller med en underkomponent av typen LOCK_TYPE måste ha en co-dimension eller vara en underkomponent till en co-vektor.  (Variabler av typen %s får inte ha en co-dimension eftersom %s vid %L har en co-dimension eller en co-vektorunderkomponent)"
+msgstr "Icke co-vektorkomponenten %s vid %L av typen EVENT_TYPE eller med en underkomponent av typen EVENT_TYPE måste ha en co-dimension eller vara en underkomponent till en co-vektor.  (Variabler av typen %s får inte ha en co-dimension eftersom %s vid %L har en co-dimension eller en co-vektorunderkomponent)"
  
  #: fortran/parse.c:2968
  #, gcc-internal-format, gfc-internal-format
@@ -52782,10 +52589,9 @@ msgid "Expected TYPE IS, CLASS IS or END SELECT statement following SELECT TYPE
  msgstr "En TYPE IS-, CLASS IS- eller END SELECT-sats förväntades följa efter SELECT TYPE vid %C"
  
  #: fortran/parse.c:3855
-#, fuzzy, gcc-internal-format
-#| msgid "Variable '%s' at %C cannot be redefined inside loop beginning at %L"
+#, gcc-internal-format
  msgid "Variable %qs at %C cannot be redefined inside loop beginning at %L"
-msgstr "Variabeln ”%s” vid %C får inte definieras om inuti slingan som börjar vid %L"
+msgstr "Variabeln %qs vid %C får inte definieras om inuti slingan som börjar vid %L"
  
  #: fortran/parse.c:3888
  #, gcc-internal-format, gfc-internal-format
@@ -52893,16 +52699,14 @@ msgid "gfc_global_used(): Bad type"
  msgstr "gfc_global_used(): Felaktig typ"
  
  #: fortran/parse.c:5306
-#, fuzzy, gcc-internal-format
-#| msgid "Global binding name '%s' at %L is already being used as a %s at %L"
+#, gcc-internal-format
  msgid "Global binding name %qs at %L is already being used as a %s at %L"
-msgstr "Globalt bindningsnamn ”%s” vid %L används redan som en %s vid %L"
+msgstr "Globalt bindningsnamn %qs vid %L används redan som en %s vid %L"
  
  #: fortran/parse.c:5309
-#, fuzzy, gcc-internal-format
-#| msgid "Global name '%s' at %L is already being used as a %s at %L"
+#, gcc-internal-format
  msgid "Global name %qs at %L is already being used as a %s at %L"
-msgstr "Globalt namn ”%s” vid %L används redan som en %s vid %L"
+msgstr "Globalt namn %qs vid %L används redan som en %s vid %L"
  
  #: fortran/parse.c:5330
  #, gcc-internal-format, gfc-internal-format
@@ -53118,10 +52922,9 @@ msgid "Syntax error in COMPLEX constant at %C"
  msgstr "Syntaxfel i COMPLEX-konstant vid %C"
  
  #: fortran/primary.c:1557
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Namelist %s cannot be renamed by USE association to %s"
+#, gcc-internal-format, gfc-internal-format
  msgid "Namelist '%s' can not be an argument at %L"
-msgstr "Namnlistan %s får inte namnändras av USE-association till %s"
+msgstr "Namnlistan ”%s” kan inte vara ett argument vid %L"
  
  #: fortran/primary.c:1643
  #, gcc-internal-format
@@ -53379,10 +53182,9 @@ msgid "Argument %qs of pure subroutine %qs at %L must have its INTENT specified
  msgstr "Argumentet %qs till pure-subrutin %qs vid %L måste ha sitt INTENT angivet eller ha attributet VALUE"
  
  #: fortran/resolve.c:419
-#, fuzzy, gcc-internal-format
-#| msgid "INTENT(OUT) argument '%s' of pure procedure %qs at %L may not be polymorphic"
+#, gcc-internal-format
  msgid "INTENT(OUT) argument %qs of pure procedure %qs at %L may not be polymorphic"
-msgstr "INTENT(OUT)-argumentet ”%s” till den rena proceduren %qs vid %L får inte vara polymorf"
+msgstr "INTENT(OUT)-argumentet %qs till den rena proceduren %qs vid %L får inte vara polymorf"
  
  #: fortran/resolve.c:452
  #, gcc-internal-format
@@ -53510,22 +53312,19 @@ msgid "Derived type variable %qs in COMMON at %L may not have default initialize
  msgstr "Härledd typvariabel %qs i COMMON vid %L får inte ha standardinitierare"
  
  #: fortran/resolve.c:1000
-#, fuzzy, gcc-internal-format
-#| msgid "In Fortran 2003 COMMON '%s' block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
+#, gcc-internal-format
  msgid "In Fortran 2003 COMMON %qs block at %L is a global identifier and must thus have the same binding name as the same-named COMMON block at %L: %s vs %s"
-msgstr "I Fortran 2003 är COMMON ”%s”-block vid %L en global identifierare och måste således ha samma bindningsnamn som COMMON-blocket med samma namn vid %L: %s resp %s"
+msgstr "I Fortran 2003 är COMMON %qs-block vid %L en global identifierare och måste således ha samma bindningsnamn som COMMON-blocket med samma namn vid %L: %s resp %s"
  
  #: fortran/resolve.c:1014
-#, fuzzy, gcc-internal-format
-#| msgid "COMMON block '%s' at %L uses the same global identifier as entity at %L"
+#, gcc-internal-format
  msgid "COMMON block %qs at %L uses the same global identifier as entity at %L"
-msgstr "COMMON-block ”%s” vid %L använder samma globala identifierare som en enhet vid %L"
+msgstr "COMMON-block %qs vid %L använder samma globala identifierare som en enhet vid %L"
  
  #: fortran/resolve.c:1022
-#, fuzzy, gcc-internal-format
-#| msgid "Fortran 2008: COMMON block '%s' with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
+#, gcc-internal-format
  msgid "Fortran 2008: COMMON block %qs with binding label at %L sharing the identifier with global non-COMMON-block entity at %L"
-msgstr "Fortran 2008: COMMON-block ”%s” med bindningsetikett vid %L delar identifierare med ett globalt ej-COMMON-blockenhet vid %L"
+msgstr "Fortran 2008: COMMON-block %qs med bindningsetikett vid %L delar identifierare med ett globalt ej-COMMON-blockenhet vid %L"
  
  #: fortran/resolve.c:1044
  #, gcc-internal-format, gfc-internal-format
@@ -53533,10 +53332,9 @@ msgid "COMMON block at %L with binding label %s uses the same global identifier
  msgstr "COMMON-block vid %L med bindningsetikett %s använder samma globala identifierare som enheten vid %L"
  
  #: fortran/resolve.c:1065
-#, fuzzy, gcc-internal-format
-#| msgid "COMMON block '%s' at %L is used as PARAMETER at %L"
+#, gcc-internal-format
  msgid "COMMON block %qs at %L is used as PARAMETER at %L"
-msgstr "COMMON-block ”%s” vid %L används som PARAMETER vid %L"
+msgstr "COMMON-block %qs vid %L används som PARAMETER vid %L"
  
  #: fortran/resolve.c:1069
  #, gcc-internal-format
@@ -53830,10 +53628,9 @@ msgid "Unable to resolve the specific subroutine %qs at %L"
  msgstr "Kan inte slå upp den specifika subrutinen %qs vid %L"
  
  #: fortran/resolve.c:3375
-#, fuzzy, gcc-internal-format
-#| msgid "'%s' at %L has a type, which is not consistent with the CALL at %L"
+#, gcc-internal-format
  msgid "%qs at %L has a type, which is not consistent with the CALL at %L"
-msgstr "”%s” vid %L har en typ som inte är konsistent med CALL vid %L"
+msgstr "%qs vid %L har en typ som inte är konsistent med CALL vid %L"
  
  #: fortran/resolve.c:3414
  #, gcc-internal-format
@@ -54240,10 +54037,9 @@ msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_
  msgstr "Källuttrycket vid %L skall varken vara av typen LOCK_TYPE eller ha en LOCK_TYPE-komponent om det allokerbara objektet vid %L är en co-vektor"
  
  #: fortran/resolve.c:7073
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "The source-expr at %L shall neither be of type LOCK_TYPE nor have a LOCK_TYPE component if allocate-object at %L is a coarray"
+#, gcc-internal-format, gfc-internal-format
  msgid "The source-expr at %L shall neither be of type EVENT_TYPE nor have a EVENT_TYPE component if allocate-object at %L is a coarray"
-msgstr "Källuttrycket vid %L skall varken vara av typen LOCK_TYPE eller ha en LOCK_TYPE-komponent om det allokerbara objektet vid %L är en co-vektor"
+msgstr "Källuttrycket vid %L skall varken vara av typen EVENT_TYPE eller ha en EVENT_TYPE-komponent om det allokerbara objektet vid %L är en co-vektor"
  
  #: fortran/resolve.c:7086
  #, gcc-internal-format, gfc-internal-format
@@ -54261,10 +54057,9 @@ msgid "Array specification required in ALLOCATE statement at %L"
  msgstr "Vektorspecifikation krävs i ALLOCATE-sats vid %L"
  
  #: fortran/resolve.c:7224
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Array specification required in ALLOCATE statement at %L"
+#, gcc-internal-format, gfc-internal-format
  msgid "Array specification or array-valued SOURCE= expression required in ALLOCATE statement at %L"
-msgstr "Vektorspecifikation krävs i ALLOCATE-sats vid %L"
+msgstr "Vektorspecifikation eller vektorvärt SOURCE=-uttryck krävs i ALLOCATE-sats vid %L"
  
  #: fortran/resolve.c:7247
  #, gcc-internal-format, gfc-internal-format
@@ -54482,22 +54277,19 @@ msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
  msgstr "Låsvariabel vid %L måste vara en skalär av typen LOCK_TYPE"
  
  #: fortran/resolve.c:8773
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Lock variable at %L must be a scalar of type LOCK_TYPE"
+#, gcc-internal-format, gfc-internal-format
  msgid "Event variable at %L must be a scalar of type EVENT_TYPE"
-msgstr "Låsvariabel vid %L måste vara en skalär av typen LOCK_TYPE"
+msgstr "Händelsevariabeln vid %L måste vara en skalär av typen EVENT_TYPE"
  
  #: fortran/resolve.c:8777
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Actual argument to %qs at %L must be a coarray"
+#, gcc-internal-format, gfc-internal-format
  msgid "Event variable argument at %L must be a coarray or coindexed"
-msgstr "Aktuellt argument till %qs vid %L måste vara en co-vektor"
+msgstr "Händelsevariabelargumentet vid %L måste vara en co-vektor eller co-indexerat"
  
  #: fortran/resolve.c:8780
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Actual argument to %qs at %L must be a coarray"
+#, gcc-internal-format, gfc-internal-format
  msgid "Event variable argument at %L must be a coarray but not coindexed"
-msgstr "Aktuellt argument till %qs vid %L måste vara en co-vektor"
+msgstr "Händelsevariabelargumentet vid %L måste vara en co-vektor men inte co-indexerat"
  
  #: fortran/resolve.c:8787 fortran/resolve.c:8905
  #, gcc-internal-format, gfc-internal-format
@@ -54515,10 +54307,9 @@ msgid "ACQUIRED_LOCK= argument at %L must be a scalar LOGICAL variable"
  msgstr "ACQUIRED_LOCK=-argumentet vid %L måste vara en skalär LOGICAL-variabel"
  
  #: fortran/resolve.c:8822
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Imageset argument at %L must be a scalar or rank-1 INTEGER expression"
+#, gcc-internal-format, gfc-internal-format
  msgid "UNTIL_COUNT= argument at %L must be a scalar INTEGER expression"
-msgstr "Bildmängdsargument vid %L måste vara ett skalärt eller ordning-1-uttryck"
+msgstr "UNTIL_COUNT=-argumentet vid %L måste vara ett skalärt INTEGER-uttryck"
  
  #: fortran/resolve.c:8882
  #, gcc-internal-format, gfc-internal-format
@@ -54664,16 +54455,14 @@ msgstr "ATT GÖRA: typbegränsad definierad tilldelning vid %L inte gjord för a
  #. Even if standard does not support this feature, continue to build
  #. the two statements to avoid upsetting frontend_passes.c.
  #: fortran/resolve.c:10250
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Invalid procedure pointer assignment at %L"
+#, gcc-internal-format, gfc-internal-format
  msgid "Pointer procedure assignment at %L"
-msgstr "Ogiltig procedurpekartilldelning vid %L"
+msgstr "Procedurpekartilldelning vid %L"
  
  #: fortran/resolve.c:10262
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Target expression in pointer assignment at %L must deliver a pointer result"
+#, gcc-internal-format, gfc-internal-format
  msgid "The function result on the lhs of the assignment at %L must have the pointer attribute."
-msgstr "Måluttryck i pekartilldelning vid %L måste leverera ett pekarresultat"
+msgstr "Funktionsresultatet på vänstersidan av tilldelningen vid %L måste ha attributet pointer."
  
  #: fortran/resolve.c:10489
  #, gcc-internal-format, gfc-internal-format
@@ -54696,16 +54485,14 @@ msgid "ASSIGN statement at %L requires a scalar default INTEGER variable"
  msgstr "ASSIGN-sats vid %L kräver en skalär standard-INTEGER-variabel"
  
  #: fortran/resolve.c:10600
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Invalid kind for %s at %L"
+#, gcc-internal-format, gfc-internal-format
  msgid "Invalid NULL at %L"
-msgstr "Ogiltig sort på %s vid %L"
+msgstr "Ogiltig NULL vid %L"
  
  #: fortran/resolve.c:10604
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Arithmetic IF statement at %L requires a numeric expression"
+#, gcc-internal-format, gfc-internal-format
  msgid "Arithmetic IF statement at %L requires a scalar REAL or INTEGER expression"
-msgstr "Aritmetisk IF-sats vid %L kräver ett numeriskt uttryck"
+msgstr "Aritmetisk IF-sats vid %L kräver ett skalärt REAL- eller INTEGER-uttryck"
  
  #: fortran/resolve.c:10660
  #, gcc-internal-format
@@ -54783,10 +54570,9 @@ msgid "CLASS variable %qs at %L must be dummy, allocatable or pointer"
  msgstr "CLASS-variabel %qs vid %L måste vara en attrapp, allokerbar eller pekare"
  
  #: fortran/resolve.c:11438
-#, fuzzy, gcc-internal-format
-#| msgid "The type '%s' cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
+#, gcc-internal-format
  msgid "The type %qs cannot be host associated at %L because it is blocked by an incompatible object of the same name declared at %L"
-msgstr "Typen ”%s” kan inte vara värdassocierad vid %L för att den blockeras av ett inkompatibelt objekt med samma namn deklarerat vid %L"
+msgstr "Typen %qs kan inte vara värdassocierad vid %L för att den blockeras av ett inkompatibelt objekt med samma namn deklarerat vid %L"
  
  #: fortran/resolve.c:11460
  #, gcc-internal-format
@@ -54796,10 +54582,9 @@ msgstr "Implicerad SAVE för modulvariabeln %qs vid %L, behövs på grund av sta
  #. The shape of a main program or module array needs to be
  #. constant.
  #: fortran/resolve.c:11508
-#, fuzzy, gcc-internal-format
-#| msgid "The module or main program array '%s' at %L must have constant shape"
+#, gcc-internal-format
  msgid "The module or main program array %qs at %L must have constant shape"
-msgstr "Modul- eller huvudprogramvektorn ”%s” vid %L måste ha konstant form"
+msgstr "Modul- eller huvudprogramvektorn %qs vid %L måste ha konstant form"
  
  #: fortran/resolve.c:11520
  #, gcc-internal-format
@@ -54812,10 +54597,9 @@ msgid "Entity with assumed character length at %L must be a dummy argument or a
  msgstr "Entitet med antagen teckenlängd vid %L måste vara ett attrappargument eller en PARAMETER"
  
  #: fortran/resolve.c:11557
-#, fuzzy, gcc-internal-format
-#| msgid "'%s' at %L must have constant character length in this context"
+#, gcc-internal-format
  msgid "%qs at %L must have constant character length in this context"
-msgstr "”%s” vid %L måste ha konstant teckenlängd i detta sammanhang"
+msgstr "%qs vid %L måste ha konstant teckenlängd i detta sammanhang"
  
  #: fortran/resolve.c:11564
  #, gcc-internal-format
@@ -54853,10 +54637,9 @@ msgid "Automatic array %qs at %L cannot have an initializer"
  msgstr "Automatisk vektor %qs vid %L kan inte ha en initierare"
  
  #: fortran/resolve.c:11669
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "in %s, at %s:%d"
+#, gcc-internal-format, gfc-internal-format
  msgid "%s at %L"
-msgstr "i %s, vid %s:%d"
+msgstr "%s vid %L"
  
  #: fortran/resolve.c:11696
  #, gcc-internal-format
@@ -55209,10 +54992,9 @@ msgid "Component %qs with CLASS at %L must be allocatable or pointer"
  msgstr "Procedur %qs med CLASS vid %L måste vara allokerbar eller en pekare"
  
  #: fortran/resolve.c:13380
-#, fuzzy, gcc-internal-format
-#| msgid "Generic name '%s' of function '%s' at %L being the same name as derived type at %L"
+#, gcc-internal-format
  msgid "Generic name %qs of function %qs at %L being the same name as derived type at %L"
-msgstr "Det generiska namnet ”%s” på funktionen ”%s” vid %L är samma namn som den härledda typen vid %L"
+msgstr "Det generiska namnet %qs på funktionen %qs vid %L är samma namn som den härledda typen vid %L"
  
  #: fortran/resolve.c:13436
  #, gcc-internal-format
@@ -55407,10 +55189,9 @@ msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYP
  msgstr "Variabeln %s vid %L av typen LOCK_TYPE eller med en delkomponent av typen LOCK_TYPE måste vara en co-vektor"
  
  #: fortran/resolve.c:14078
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Variable %s at %L of type LOCK_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
+#, gcc-internal-format, gfc-internal-format
  msgid "Variable %s at %L of type EVENT_TYPE or with subcomponent of type LOCK_TYPE must be a coarray"
-msgstr "Variabeln %s vid %L av typen LOCK_TYPE eller med en delkomponent av typen LOCK_TYPE måste vara en co-vektor"
+msgstr "Variabeln %s vid %L av typen EVENT_TYPE eller med en delkomponent av typen LOCK_TYPE måste vara en co-vektor"
  
  #: fortran/resolve.c:14096
  #, gcc-internal-format
@@ -55423,10 +55204,9 @@ msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
  msgstr "Attrappargumentet %qs vid %L av LOCK_TYPE får inte vara INTENT(OUT)"
  
  #: fortran/resolve.c:14117
-#, fuzzy, gcc-internal-format
-#| msgid "Dummy argument %qs at %L of LOCK_TYPE shall not be INTENT(OUT)"
+#, gcc-internal-format
  msgid "Dummy argument %qs at %L of EVENT_TYPE shall not be INTENT(OUT)"
-msgstr "Attrappargumentet %qs vid %L av LOCK_TYPE får inte vara INTENT(OUT)"
+msgstr "Attrappargumentet %qs vid %L av EVENT_TYPE får inte vara INTENT(OUT)"
  
  #: fortran/resolve.c:14129
  #, gcc-internal-format
@@ -55479,10 +55259,9 @@ msgid "LOGICAL result variable %qs at %L with non-C_Bool kind in BIND(C) procedu
  msgstr "LOGICAL-resultatvariabeln %qs vid %L med icke-C_Bool-sort i BIND(C)-proceduren %qs"
  
  #: fortran/resolve.c:14248
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Namelist %s cannot be renamed by USE association to %s"
+#, gcc-internal-format, gfc-internal-format
  msgid "Namelist '%s' can not be an argument to subroutine or function at %L"
-msgstr "Namnlistan %s får inte namnändras av USE-association till %s"
+msgstr "Namnlistan ”%s” får inte vara ett argument till en subrutin eller funktion vid %L"
  
  #: fortran/resolve.c:14317
  #, gcc-internal-format, gfc-internal-format
@@ -55720,16 +55499,14 @@ msgid "Nonconforming tab character in column %d of line %d"
  msgstr "Ej konformt tabulatortecken i kolumn %d på rad %d"
  
  #: fortran/scanner.c:2070
-#, fuzzy, gcc-internal-format
-#| msgid "%s:%d: file %s left but not entered"
+#, gcc-internal-format
  msgid "file %qs left but not entered"
-msgstr "%s:%d: gått ifrån men inte till filen %s"
+msgstr "gått ifrån men inte till filen %qs"
  
  #: fortran/scanner.c:2108
-#, fuzzy, gcc-internal-format
-#| msgid "%s:%d: Illegal preprocessor directive"
+#, gcc-internal-format
  msgid "Illegal preprocessor directive"
-msgstr "%s:%d: Ogiltigt preprocessordirektiv"
+msgstr "Ogiltigt preprocessordirektiv"
  
  #: fortran/scanner.c:2235
  #, gcc-internal-format
@@ -56018,16 +55795,14 @@ msgid "Failure getting length of a constant array."
  msgstr "Misslyckades att bestämma längden på en konstant vektor."
  
  #: fortran/simplify.c:6118
-#, fuzzy, gcc-internal-format
-#| msgid "The number of elements in the array constructor at %L requires an increase of the allowed %d upper limit.   See %<-fmax-array-constructor%> option"
+#, gcc-internal-format
  msgid "The number of elements (%d) in the array constructor at %L requires an increase of the allowed %d upper limit.  See %<-fmax-array-constructor%> option."
-msgstr "Antalet element i vektorkonstrueraren vid %L kräver en ökning av den tillåtna övre gränsen %d.  Se flaggan %<-fmax-array-constructor%>"
+msgstr "Antalet element (%d) i vektorkonstrueraren vid %L kräver en ökning av den tillåtna övre gränsen %d.  Se flaggan %<-fmax-array-constructor%>"
  
  #: fortran/simplify.c:6184
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "directive not yet implemented"
+#, gcc-internal-format, gfc-internal-format
  msgid "Simplification of SPREAD at %L not yet implemented"
-msgstr "direktivet är inte implementerat ännu"
+msgstr "Förenkling av SPREAD vid %L är inte implementerat ännu"
  
  #: fortran/simplify.c:6209
  #, gcc-internal-format, gfc-internal-format
@@ -56070,10 +55845,9 @@ msgid "IMPLICIT NONE (type) statement at %L following an IMPLICIT statement"
  msgstr "IMPLICIT NONE (type)-sats vid %L följer en IMPLICIT-sats"
  
  #: fortran/symbol.c:168
-#, fuzzy, gcc-internal-format
-#| msgid "Letter %<%c%> already set in IMPLICIT statement at %C"
+#, gcc-internal-format
  msgid "Letter %qc already set in IMPLICIT statement at %C"
-msgstr "Tecknet %<%c%> redan satt i IMPLICIT-sats vid %C"
+msgstr "Tecknet %qc redan satt i IMPLICIT-sats vid %C"
  
  #: fortran/symbol.c:190
  #, gcc-internal-format, gfc-internal-format
@@ -56081,10 +55855,9 @@ msgid "Cannot specify IMPLICIT at %C after IMPLICIT NONE"
  msgstr "Det går inte att ange IMPLICIT vid %C efter IMPLICIT NONE"
  
  #: fortran/symbol.c:200
-#, fuzzy, gcc-internal-format
-#| msgid "Letter %c already has an IMPLICIT type at %C"
+#, gcc-internal-format
  msgid "Letter %qc already has an IMPLICIT type at %C"
-msgstr "Tecknet %c har redan en IMPLICIT-typ vid %C"
+msgstr "Tecknet %qc har redan en IMPLICIT-typ vid %C"
  
  #: fortran/symbol.c:224
  #, gcc-internal-format
@@ -56135,10 +55908,9 @@ msgid "Namelist group name at %L cannot have the SAVE attribute"
  msgstr "Namnlistegruppnamnet vid %L kan inte ha attributet SAVE"
  
  #: fortran/symbol.c:468
-#, fuzzy, gcc-internal-format
-#| msgid "internal procedure '%s' at %L conflicts with DUMMY argument"
+#, gcc-internal-format
  msgid "internal procedure %qs at %L conflicts with DUMMY argument"
-msgstr "den interna proceduren ”%s” vid %L står i konflikt med DUMMY-argument"
+msgstr "den interna proceduren %qs vid %L står i konflikt med DUMMY-argument"
  
  #: fortran/symbol.c:494
  #, gcc-internal-format, gfc-internal-format
@@ -56300,10 +56072,9 @@ msgid "%qs at %L has attributes specified outside its INTERFACE body"
  msgstr "%qs vid %L har attribut angivna utanför dess INTERFACE-kropp"
  
  #: fortran/symbol.c:1813
-#, fuzzy, gcc-internal-format
-#| msgid "Symbol '%s' at %L conflicts with symbol from module '%s', use-associated at %L"
+#, gcc-internal-format
  msgid "Symbol %qs at %L conflicts with symbol from module %qs, use-associated at %L"
-msgstr "Symbolen ”%s” vid %L står i konflikt med symbolen från modulen ”%s”, användningsassocierad vid %L"
+msgstr "Symbolen %qs vid %L står i konflikt med symbolen från modulen %qs, användningsassocierad vid %L"
  
  #: fortran/symbol.c:1817
  #, gcc-internal-format
@@ -56321,16 +56092,14 @@ msgid "Symbol %qs at %L cannot have a type"
  msgstr "Symbolen %qs vid %L kan inte ha en typ"
  
  #: fortran/symbol.c:2057
-#, fuzzy, gcc-internal-format
-#| msgid "Component '%s' at %C already declared at %L"
+#, gcc-internal-format
  msgid "Component %qs at %C already declared at %L"
-msgstr "Komponenten ”%s” vid %C är redan deklarerad vid %L"
+msgstr "Komponenten %qs vid %C är redan deklarerad vid %L"
  
  #: fortran/symbol.c:2068
-#, fuzzy, gcc-internal-format
-#| msgid "Component '%s' at %C already in the parent type at %L"
+#, gcc-internal-format
  msgid "Component %qs at %C already in the parent type at %L"
-msgstr "Komponenten ”%s” vid %C finns redan i föräldratypen vid %L"
+msgstr "Komponenten %qs vid %C finns redan i föräldratypen vid %L"
  
  #: fortran/symbol.c:2153
  #, gcc-internal-format
@@ -56425,22 +56194,19 @@ msgid "Derived type %qs with BIND(C) attribute at %L is empty, and may be inacce
  msgstr "Härledd typ %qs med attributet BIND(C) vid %L är tom, och kan vara otillgängliga av C-följeslagarprocessorn"
  
  #: fortran/symbol.c:4074
-#, fuzzy, gcc-internal-format
-#| msgid "Component '%s' at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type '%s' at %L"
+#, gcc-internal-format
  msgid "Component %qs at %L cannot have the POINTER attribute because it is a member of the BIND(C) derived type %qs at %L"
-msgstr "Komponent ”%s” vid %L får inte ha attributet POINTER eftersom det är en medlem av den BIND(C)-härledda typen ”%s” vid %L"
+msgstr "Komponent %qs vid %L får inte ha attributet POINTER eftersom det är en medlem av den BIND(C)-härledda typen %qs vid %L"
  
  #: fortran/symbol.c:4084
-#, fuzzy, gcc-internal-format
-#| msgid "Procedure pointer component '%s' at %L cannot be a member of the BIND(C) derived type '%s' at %L"
+#, gcc-internal-format
  msgid "Procedure pointer component %qs at %L cannot be a member of the BIND(C) derived type %qs at %L"
-msgstr "Procedurpekarkomponenten ”%s” vid %L kan inte vara en medlem av den BIND(C)-härledda typen ”%s” vid %L"
+msgstr "Procedurpekarkomponenten %qs vid %L kan inte vara en medlem av den BIND(C)-härledda typen %qs vid %L"
  
  #: fortran/symbol.c:4095
-#, fuzzy, gcc-internal-format
-#| msgid "Component '%s' at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type '%s' at %L"
+#, gcc-internal-format
  msgid "Component %qs at %L cannot have the ALLOCATABLE attribute because it is a member of the BIND(C) derived type %qs at %L"
-msgstr "Komponent ”%s” vid %L får inte ha attributet ALLOCATABLE eftersom det är en medlem av den BIND(C)-härledda typen ”%s” vid %L"
+msgstr "Komponent %qs vid %L får inte ha attributet ALLOCATABLE eftersom det är en medlem av den BIND(C)-härledda typen %qs vid %L"
  
  #: fortran/symbol.c:4134
  #, gcc-internal-format
@@ -56535,10 +56301,9 @@ msgid "Illegal reference type at %L as EQUIVALENCE object"
  msgstr "Ogiltig referenstyp vid %L som EQUIVALENCE-objekt"
  
  #: fortran/trans-common.c:913
-#, fuzzy, gcc-internal-format
-#| msgid "Inconsistent equivalence rules involving '%s' at %L and '%s' at %L"
+#, gcc-internal-format
  msgid "Inconsistent equivalence rules involving %qs at %L and %qs at %L"
-msgstr "Inkonsistenta ekvivalensregler rörande ”%s” vid %L och ”%s” vid %L"
+msgstr "Inkonsistenta ekvivalensregler rörande %qs vid %L och %qs vid %L"
  
  #. Aligning this field would misalign a previous field.
  #: fortran/trans-common.c:1046
@@ -56567,10 +56332,9 @@ msgid "Padding of %d bytes required before %qs in COMMON at %L; reorder elements
  msgstr "Utfyllnad med %d byte krävs före %qs i COMMON vid %L, byt ordning på element eller använd -fno-align-commons"
  
  #: fortran/trans-common.c:1169
-#, fuzzy, gcc-internal-format
-#| msgid "COMMON '%s' at %L does not exist"
+#, gcc-internal-format
  msgid "COMMON %qs at %L does not exist"
-msgstr "COMMON ”%s” vid %L existerar inte"
+msgstr "COMMON %qs vid %L finns inte"
  
  #: fortran/trans-common.c:1178
  #, gcc-internal-format
@@ -56714,16 +56478,14 @@ msgid "%<dim%> argument of %s intrinsic at %L is not a valid dimension index"
  msgstr "%<dim%>-argumentet till inbyggd %s vid %L är inte ett giltigt dimensionsindex"
  
  #: fortran/trans-intrinsic.c:9366 fortran/trans-stmt.c:919
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Sorry, the lock component of derived type at %L is not yet supported"
+#, gcc-internal-format, gfc-internal-format
  msgid "Sorry, the event component of derived type at %L is not yet supported"
-msgstr "Ledsen, låskomponenten hos härledd typ vid %L stödjs inte ännu"
+msgstr "Ledsen, händelsekomponenten hos härledd typ vid %L stödjs inte ännu"
  
  #: fortran/trans-intrinsic.c:9373
-#, fuzzy, gcc-internal-format, gfc-internal-format
-#| msgid "Pointer object at %C shall not be coindexed"
+#, gcc-internal-format, gfc-internal-format
  msgid "The event variable at %L shall not be coindexed "
-msgstr "Pekarobjektet vid %C kan inte vara co-indexerat"
+msgstr "Händelsevariabeln vid %L får inte vara co-indexerat"
  
  #: fortran/trans-io.c:1849
  #, gcc-internal-format
@@ -57218,10 +56980,9 @@ msgid "previously defined here"
  msgstr "tidigare definition här"
  
  #: lto/lto-symtab.c:664
-#, fuzzy, gcc-internal-format
-#| msgid "type %qT violates one definition rule"
+#, gcc-internal-format
  msgid "%qD violates the C++ One Definition Rule "
-msgstr "typen %qT bryter mot endefinitionsregeln  "
+msgstr "%qD bryter mot C++ endefinitionsregel "
  
  #: lto/lto-symtab.c:669
  #, gcc-internal-format
@@ -57234,16 +56995,14 @@ msgid "alignment of %qD is bigger than original declaration"
  msgstr "justering av %qD är större än originaldeklarationen"
  
  #: lto/lto-symtab.c:695
-#, fuzzy, gcc-internal-format
-#| msgid "type of %qD does not match original declaration"
+#, gcc-internal-format
  msgid "size of %qD differ from the size of original declaration"
-msgstr "typen på %qD stämmer inte med originaldeklarationen"
+msgstr "storleken på %qD skiljer från storleken på originaldeklarationen"
  
  #: lto/lto-symtab.c:700
-#, fuzzy, gcc-internal-format
-#| msgid "%q#T was previously declared here"
+#, gcc-internal-format
  msgid "%qD was previously declared here"
-msgstr "%q#T deklarerades tidigare här"
+msgstr "%qD deklarerades tidigare här"
  
  #: lto/lto-symtab.c:703
  #, gcc-internal-format
@@ -58311,388 +58070,3 @@ msgstr "%<-fobjc-sjlj-exceptions%> ignoreras för %<-fnext-runtime%> när %<-fob
  #, gcc-internal-format
  msgid "creating selector for nonexistent method %qE"
  msgstr "skapar selektor för icke existerande metod %qE"
-
-#~ msgid "Use the same size for double as for float."
-#~ msgstr "Använd samma storlek för double som för float."
-
-#~ msgid "installation error, can't find crtoffloadend.o"
-#~ msgstr "installationsfel, kan inte hitta crtoffloadend.o"
-
-#~ msgid "try reducing the number of local variables"
-#~ msgstr "försök reducera antalet lokala variabler"
-
-#~ msgid "statement is indented as if it were guarded by..."
-#~ msgstr "satsen är indenterad som om den vore skyddad av …"
-
-#~ msgid "stabs debug format not supported"
-#~ msgstr "stabs felsökningsformat stödjs inte"
-
-#~ msgid "negative array subscript"
-#~ msgstr "negativt vektorindex"
-
-#~ msgid "array subscript out of bound"
-#~ msgstr "vektorindex är utanför gränserna"
-
-#~ msgid "comparison with string literal results in unspecified behaviour"
-#~ msgstr "jämförelse med strängkonstant resulterar i odefinierat beteende"
-
-#~ msgid "Bound on the number of variables in Omega constraint systems"
-#~ msgstr "Gräns för antalet variabler i Omegasystem av bivillkor"
-
-#~ msgid "Bound on the number of inequalities in Omega constraint systems"
-#~ msgstr "Gräns för antalet olikheter i Omegasystem av bivillkor"
-
-#~ msgid "Bound on the number of equalities in Omega constraint systems"
-#~ msgstr "Gräns för antalet likheter i Omegasystem av bivillkor"
-
-#~ msgid "Bound on the number of wild cards in Omega constraint systems"
-#~ msgstr "Gräns för antalet jokrar i Omegasystem av bivillkor"
-
-#~ msgid "Bound on the size of the hash table in Omega constraint systems"
-#~ msgstr "Gräns för storleken på hash-tabellen i Omegasystem av bivillkor"
-
-#~ msgid "Bound on the number of keys in Omega constraint systems"
-#~ msgstr "Gräns för antalet nycklar i Omegasystem av bivillkor"
-
-#~ msgid "When set to 1, use expensive methods to eliminate all redundant constraints"
-#~ msgstr "När satt till 1, använd dyra metoder för att eliminera alla överflödiga bivillkor"
-
-#~ msgid "size of unrolling factor for unroll-and-jam"
-#~ msgstr "storlek på utrullningsfaktorn för unroll-and-jam"
-
-#~ msgid "depth of unrolled loop for unroll-and-jam"
-#~ msgstr "djupet på utrullade slingor för unroll-and-jam"
-
-#~ msgid "invalid %%H value"
-#~ msgstr "ogiltigt %%H-värde"
-
-#~ msgid "invalid %%S value"
-#~ msgstr "ogiltigt %%S-värde"
-
-#~ msgid "memory reference expected for 'O' output modifier"
-#~ msgstr "minnesreferens förväntas för utmatningsmodifieraren ”O”"
-
-#~ msgid "memory reference expected for 'R' output modifier"
-#~ msgstr "minnesreferens förväntas för utmatningsmodifieraren ”R”"
-
-#~ msgid "long long constant not a valid immediate operand"
-#~ msgstr "long long-konstant inte en giltig omedelbar operand"
-
-#~ msgid "Warning:"
-#~ msgstr "Varning:"
-
-#~ msgid "Error:"
-#~ msgstr "Fel:"
-
-#~ msgid ""
-#~ "GNU Fortran comes with NO WARRANTY, to the extent permitted by law.\n"
-#~ "You may redistribute copies of GNU Fortran\n"
-#~ "under the terms of the GNU General Public License.\n"
-#~ "For more information about these matters, see the file named COPYING\n"
-#~ "\n"
-#~ msgstr ""
-#~ "GNU Fortran kommer UTAN GARANTI så långt lagen tillåter.  Du kan\n"
-#~ "vidaredistribuera kopior av GNU Fortran enligt villkoren i GNU General\n"
-#~ "Public License.  För mer information om detta ämne, se filen som heter\n"
-#~ "COPYING\n"
-#~ "\n"
-
-#~ msgid "Deprecated in favor of -Wc++11-compat"
-#~ msgstr "Bör undvikas till förmån för -Wc++11-compat"
-
-#~ msgid "Conform to the ISO 2014 C++ standard (experimental and incomplete support)"
-#~ msgstr "Följ standarden ISO 2014 C++ (experimentellt och ofullständigt stöd)"
-
-#~ msgid "Conform to the ISO 2011 C standard (experimental and incomplete support)"
-#~ msgstr "Följ standarden ISO 2011 C (experimentellt och ofullständigt stöd)"
-
-#~ msgid "Conform to the ISO 2011 C++ standard with GNU extensions (experimental and incomplete support)"
-#~ msgstr "Följ standarden ISO 2011 C++ med GNU-utökningar (experimentellt och ofullständigt stöd)"
-
-#~ msgid "Conform to the ISO 2014 C++ standard with GNU extensions (experimental and incomplete support)"
-#~ msgstr "Följ standarden ISO 2014 C++ med GNU-utökningar (experimentellt och ofullständigt stöd)"
-
-#~ msgid "Conform to the ISO 2011 C standard with GNU extensions (experimental and incomplete support)"
-#~ msgstr "Följ standarden ISO 2011 C med GNU-utökningar (experimentellt och ofullständigt stöd)"
-
-#~ msgid "Specify the name of the target architecture"
-#~ msgstr "Ange namnet på målarkitekturen"
-
-#~ msgid "Ignored (obsolete)"
-#~ msgstr "Ignorerad (föråldrad)"
-
-#~ msgid "mvcle use"
-#~ msgstr "använd mvcle"
-
-#~ msgid "Select hardware or software multiplication support."
-#~ msgstr "Välj hårdvaru- eller programvarustöd för multiplikation."
-
-#~ msgid "Target the RL78/G10 series"
-#~ msgstr "Sikta på serien RL78/G10"
-
-#~ msgid "Use big-endian byte order"
-#~ msgstr "Använd rak byteordning"
-
-#~ msgid "Use little-endian byte order"
-#~ msgstr "Använd omvänd byteordning"
-
-#~ msgid "Generate floating-point multiply-add instructions"
-#~ msgstr "Generera  multiplicera-/adderainstruktioner för flyttal"
-
-#~ msgid "Generate ARCompact 32-bit code for ARCtangent-A5 processor"
-#~ msgstr "Generera ARCompact 32-bitars kod för processorn ARCtangent-A5"
-
-#~ msgid "Disable generation of cfi for epilogues."
-#~ msgstr "Avaktivera generering av cfi för epiloger."
-
-#~ msgid "Enable generation of cfi for epilogues."
-#~ msgstr "Aktivera generering av cfi för epiloger."
-
-#~ msgid "Compare the results of several data dependence analyzers."
-#~ msgstr "Jämför resultaten av flera analyserare av databeroende."
-
-#~ msgid "Enable Loop Strip Mining transformation"
-#~ msgstr "Aktivera transformationen utgrävning av remsor (strip mining) i slingor"
-
-#~ msgid "Enable Loop Interchange transformation"
-#~ msgstr "Aktivera transformationen utbyte (interchange) i slingor"
-
-#~ msgid "Enable Loop Blocking transformation"
-#~ msgstr "Aktivera slingblockeringstransformation"
-
-#~ msgid "Enable Loop Unroll Jam transformation"
-#~ msgstr "Aktivera transformationen av utrullningsstockningar i slingor"
-
-#~ msgid "Enable coalescing of copy-related user variables that are inlined"
-#~ msgstr "Aktivera sammanläggning av kopieringsrelaterade användarvariabler som är inline:ade"
-
-#~ msgid "Replace SSA temporaries with better names in copies"
-#~ msgstr "Ersätt SSA-temporärer med bättre namn i kopieringar"
-
-#~ msgid "expected integer or boolean type"
-#~ msgstr "heltal eller boolesk typ förväntades"
-
-#~ msgid "invalid argument to %<__builtin_frame_address%>"
-#~ msgstr "ogiltigt argument till %<__builtin_frame_address%>"
-
-#~ msgid "invalid argument to %<__builtin_return_address%>"
-#~ msgstr "ogiltigt argument till %<__builtin_return_address%>"
-
-#~ msgid "unsupported argument to %<__builtin_frame_address%>"
-#~ msgstr "ej stött argument till %<__builtin_frame_address%>"
-
-#~ msgid "unsupported argument to %<__builtin_return_address%>"
-#~ msgstr "ej stött argument till %<__builtin_return_address%>"
-
-#~ msgid "assuming signed overflow does not occur when negating a division"
-#~ msgstr "antar att teckenspill inte förekommer vid negering av en division"
-
-#~ msgid "assuming signed overflow does not occur when changing X - Y cmp 0 to X cmp Y"
-#~ msgstr "antar att teckenspill inte förekommer vid ändring av X - Y jmf 0 till X jmf Y ± K2"
-
-#~ msgid "%qE not specified in enclosing parallel"
-#~ msgstr "%qE inte angiven i omgivande parallel"
-
-#~ msgid "enclosing parallel"
-#~ msgstr "omgivande parallel"
-
-#~ msgid "type %qT defined in anonymous namespace can not match type %qT"
-#~ msgstr "typen %qT är definierad i en anonym namnrymd och kan inte matcha typen %qT"
-
-#~ msgid "the incompatible type defined in anonymous namespace in another translation unit"
-#~ msgstr "den inkompatibla typen är definierad i en anonym namnrymd i en annan översättningsenhet"
-
-#~ msgid "type %qT should match type %qT but is defined in different namespace  "
-#~ msgstr "typen %qT borde matcha typen %qT men är definierad i en annan namnrymd "
-
-#~ msgid "type %qT should match type %qT that itself violate one definition rule"
-#~ msgstr "typen %qT borde matcha typen %qT som själv bryter mot endefinitionsregeln"
-
-#~ msgid "a type with attributes is defined in another translation unit"
-#~ msgstr "en typ med attribut är definierad i en annan översättningsenhet"
-
-#~ msgid "clause not supported yet"
-#~ msgstr "klausulen stödjs inte än"
-
-#~ msgid "no arguments allowed to gang, worker and vector clauses inside parallel"
-#~ msgstr "inga argument tillåtna i gang-, worker- och vector-klausuler inuti parallel"
-
-#~ msgid "gang, worker and vector may occur only once in a loop nest"
-#~ msgstr "gang, worker och vector får endast förekomma en gång i ett slingnäste"
-
-#~ msgid "gang, worker and vector must occur in this order in a loop nest"
-#~ msgstr "gang, worker och vector måste förekomma i denna ordning inuti ett slingnäste"
-
-#~ msgid "-fsanitize-recover=address is not supported"
-#~ msgstr "-fsanitize-recover=address stödjs inte"
-
-#~ msgid "-mcpu string too large"
-#~ msgstr "strängen till -mcpu är för stor"
-
-#~ msgid "%qs and floating point or vector arguments"
-#~ msgstr "%qs och flyttals- eller vektorargument"
-
-#~ msgid "operand 2 of %s instruction should be an unsigned %d-bit value"
-#~ msgstr "operand 2 till instruktionen %s skall vara ett teckenlöst %d-bits värde"
-
-#~ msgid "operand 2 of %s instruction should be an unsigned 8-bit value"
-#~ msgstr "operand 2 till instruktionen %s skall vara ett teckenlöst 8-bitars värde"
-
-#~ msgid "operand 1 of %s instruction should be an unsigned 3-bit value (DR0-DR7)"
-#~ msgstr "operand 1 till instruktionen %s skall vara ett teckenlöst 3-bitars värde (DR0-DR7)"
-
-#~ msgid "operand of %s instruction should be an unsigned 6-bit value"
-#~ msgstr "operanden till instruktionen %s skall vara ett teckenlöst 6-bitars värde"
-
-#~ msgid "operand 3 of %s instruction should be an unsigned 8-bit value"
-#~ msgstr "operand 3 till instruktionen %s skall vara ett teckenlöst 8-bitars värde"
-
-#~ msgid "incompatible type for argument %d, expected %<const int%>"
-#~ msgstr "inkompatibel typ för argument %d, %<const int%> förväntades"
-
-#~ msgid "unrecognizable argument of option -foffload-abi"
-#~ msgstr "okänt argument till flaggan -foffload-abi"
-
-#~ msgid "%q+D:'selectany' attribute applies only to initialized objects"
-#~ msgstr "%q+D: attributet ”selectany” tillämpas endast på initierade objekt"
-
-#~ msgid "-fPIC ignored for target (all code is position independent)"
-#~ msgstr "-fPIC ignoreras för målet (all kod är positionsoberoende)"
-
-#~ msgid "-f%s ignored for target (all code is position independent)"
-#~ msgstr "-f%s ignoreras för målet (all kod är positionsoberoende)"
-
-#~ msgid "-mbnu210 is ignored (option is obsolete)"
-#~ msgstr "-mbnu210 ignoreras (flaggan är föråldrad)"
-
-#~ msgid "the %<interrupt%> attribute requires %<-msoft-float%>"
-#~ msgstr "attributet %<interrupt%> kräver %<-msoft-float%>"
-
-#~ msgid "only register based stack limit is supported"
-#~ msgstr "endast registerbaserade stackgränser stödjs"
-
-#~ msgid "Transactional execution builtins not enabled (-mhtm)\n"
-#~ msgstr "Inbyggda för transaktionsvis körning är inte aktiverade (-mhtm)\n"
-
-#~ msgid "non-default Scalar_Storage_Order"
-#~ msgstr "ickestandard Scalar_Storage_Order"
-
-#~ msgid "%q+D in block scope inside of declare target directive"
-#~ msgstr "%q+D i blockräckvidd inuti ett deklarationsmålsdirektiv"
-
-#~ msgid "%<%s %E%> declared inside parameter list"
-#~ msgstr "%<%s %E%> deklarerad inuti parameterlista"
-
-#~ msgid "anonymous %s declared inside parameter list"
-#~ msgstr "anonym %s deklarerad inuti parameterlista"
-
-#~ msgid "its scope is only this definition or declaration, which is probably not what you want"
-#~ msgstr "dess scope-område är endast denna definition eller deklaration, vilket troligen inte är vad du vill."
-
-#~ msgid "selected for placement delete"
-#~ msgstr "vald för placerad delete"
-
-#~ msgid "%q+#D is private"
-#~ msgstr "%q+#D är privat"
-
-#~ msgid "%q+#D is protected"
-#~ msgstr "%q+#D är skyddad"
-
-#~ msgid "  initializing argument %P of %q+D"
-#~ msgstr "  initierar argument %P till %q+D"
-
-#~ msgid "  in call to %q+D"
-#~ msgstr "  i anrop till %q+D"
-
-#~ msgid "difference of two pointer expressions is not a constant expression"
-#~ msgstr "skillnaden mellan två pekaruttryck är inte ett konstant uttryck"
-
-#~ msgid "pointer comparison expression is not a constant expression"
-#~ msgstr "pekarjämförelseuttryck är inte ett konstant uttryck"
-
-#~ msgid "%qE implicitly determined as %<firstprivate%> has reference type"
-#~ msgstr "%qE som implicit bestämts som %<firstprivate%> har referenstyp"
-
-#~ msgid "variable %q+D set but not used"
-#~ msgstr "variabeln %q+D sätts men används inte"
-
-#~ msgid "declaration of %qF has a different exception specifier"
-#~ msgstr "deklaration av %qF har en annan undantagsspecificerare"
-
-#~ msgid "jump to label %q+D"
-#~ msgstr "hopp till etikett %q+D"
-
-#~ msgid "%<constexpr%> is not allowed in declaration of friend template specialization %qD"
-#~ msgstr "%<constexpr%> är inte tillåtet i deklaration av vänmallspecialisering %qD"
-
-#~ msgid "size of array %qs is too large"
-#~ msgstr "storleken på vektorn %qs är för stor"
-
-#~ msgid "type qualifiers specified for friend class declaration"
-#~ msgstr "typkvalificerare angivna för vänklassdeklaration"
-
-#~ msgid "no previous declaration for %q+D"
-#~ msgstr "ingen tidigare deklaration av %q+D"
-
-#~ msgid "parameter %q+D set but not used"
-#~ msgstr "parametern %q+D sätts men används inte"
-
-#~ msgid "%q+D declared here"
-#~ msgstr "%q+D är deklarerad här"
-
-#~ msgid "previous declaration %q+#D"
-#~ msgstr "tidigare deklaration %q+#D"
-
-#~ msgid "%qD is not an enumerator-name"
-#~ msgstr "%qD är inte ett uppräkningsnamn"
-
-#~ msgid "deprecated use of default argument for parameter of non-function"
-#~ msgstr "användning av standardargument för parametrar till annat än funktioner bör undvikas"
-
-#~ msgid "expected positive integer expression"
-#~ msgstr "positivt heltalsuttryck förväntades"
-
-#~ msgid "declaration of %q+#D"
-#~ msgstr "deklaration av %q+#D"
-
-#~ msgid " shadows template parm %q+#D"
-#~ msgstr " skuggar mallparameter %q+#D"
-
-#~ msgid "switch condition has type bool"
-#~ msgstr "switch-villkor har typen bool"
-
-#~ msgid "num_threads expression must be integral"
-#~ msgstr "num_threads-uttryck måste vara heltal"
-
-#~ msgid "%qE has reference type for %qs"
-#~ msgstr "%qE har referenstyp för %qs"
-
-#~ msgid "invalid use of non-static member function"
-#~ msgstr "ogiltig användning av icke-statisk medlemsfunktion"
-
-#~ msgid "\t%+#D"
-#~ msgstr "\t%+#D"
-
-#~ msgid "%q+D has incomplete type"
-#~ msgstr "%q+D har en ofullständig typ"
-
-#~ msgid "Conflict in attributes of function argument at %C"
-#~ msgstr "Konflikt i attribut för funktionsargument vid %C"
-
-#~ msgid "Error count reached limit of %d."
-#~ msgstr "Felantal nådde gränsen vid %d."
-
-#~ msgid "Clause GANG conflicts with WORKER at %L"
-#~ msgstr "Klausulen GANG står i konflikt med WORKER vid %L"
-
-#~ msgid "Clause GANG conflicts with VECTOR at %L"
-#~ msgstr "Klausulen GANG står i konflikt med VECTOR vid %L"
-
-#~ msgid "Clause WORKER conflicts with VECTOR at %L"
-#~ msgstr "WORKER-klausulen står i konflikt med VECTOR vid %L"
-
-#~ msgid "Sorry, !$ACC cache unimplemented yet"
-#~ msgstr "Ledsen, !$ACC-cache är fortfarande oimplementerat"
-
-#~ msgid "CHARACTER variable at %L has negative length %d, the length has been set to zero"
-#~ msgstr "CHARACTER-variabel vid %L har negativ längd %d, längden har satts till noll"
diff --git a/gcc/sched-deps.c b/gcc/sched-deps.c

index 8f3a124..dd1918d 100644 (file)
--- a/gcc/sched-deps.c
+++ b/gcc/sched-deps.c
@@ -2709,9 +2709,12 @@ sched_analyze_2 (struct deps_desc *deps, rtx x, rtx_insn *insn)
         return;
        }
  
-    /* Force pending stores to memory in case a trap handler needs them.  */
+    /* Force pending stores to memory in case a trap handler needs them.
+       Also force pending loads from memory; loads and stores can segfault
+       and the signal handler won't be triggered if the trap insn was moved
+       above load or store insn.  */
      case TRAP_IF:
-      flush_pending_lists (deps, insn, true, false);
+      flush_pending_lists (deps, insn, true, true);
        break;
  
      case PREFETCH:
diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog

index b438012..7da0536 100644 (file)
--- a/gcc/testsuite/ChangeLog
+++ b/gcc/testsuite/ChangeLog
@@ -1,3 +1,620 @@
+2016-06-14  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/70572
+       * g++.dg/cpp1y/auto-fn31.C: New.
+
+2016-06-14  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71516
+       * g++.dg/init/pr71516.C: New test.
+
+       Backported from mainline
+       2016-06-10  Jakub Jelinek  <jakub@redhat.com>
+
+       PR middle-end/71494
+       * gcc.c-torture/execute/pr71494.c: New test.
+
+       PR c/68657
+       * gcc.target/i386/pr68657.c: New test.
+
+       2016-06-08  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71448
+       * g++.dg/torture/pr71448.C: New test.
+
+       2016-06-04  Jakub Jelinek  <jakub@redhat.com>
+
+       PR tree-optimization/71405
+       * g++.dg/torture/pr71405.C: New test.
+
+2016-06-13  Jakub Jelinek  <jakub@redhat.com>
+
+       PR sanitizer/71498
+       * c-c++-common/ubsan/bounds-13.c: New test.
+
+2016-06-13  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * gnat.dg/renaming10.ad[sb]: New test.
+
+2016-06-12  Dominique d'Humieres  <dominiq@lps.ens.fr>
+
+       PR target/60751
+       * gfortran.dg/comma_IO_extension_1.f90: New test.
+       * gfortran.dg/comma_IO_extension_2.f90: Likewise.
+       * gfortran.dg/array_constructor_49.f90: Remove extra comma in WRITE
+       statement.
+       * gfortran.dg/graphite/pr38083.f90: Likewise.
+       * gfortran.dg/guality/pr41558.f90: Likewise.
+       * gfortran.dg/integer_exponentiation_6.F90: Likewise and add
+       missing format.
+
+2016-06-11  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * gnat.dg/case_character.adb: New test.
+
+2016-06-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+       PR middle-end/71373
+       Backport from trunk r237291:
+       2016-06-10  Thomas Schwinge  <thomas@codesourcery.com>
+                   Cesar Philippidis  <cesar@codesourcery.com>
+
+       * gcc.dg/goacc/nested-function-1.c: New file.
+       * gcc.dg/goacc/nested-function-2.c: Likewise.
+       * gcc.dg/goacc/pr71373.c: Likewise.
+       * gfortran.dg/goacc/cray-2.f95: Likewise.
+       * gfortran.dg/goacc/loop-1-2.f95: Likewise.
+       * gfortran.dg/goacc/loop-3-2.f95: Likewise.
+       * gfortran.dg/goacc/cray.f95: Update.
+       * gfortran.dg/goacc/loop-1.f95: Likewise.
+       * gfortran.dg/goacc/loop-3.f95: Likewise.
+       * gfortran.dg/goacc/subroutines.f90: Update, and rename to...
+       * gfortran.dg/goacc/nested-function-1.f90: ... this new file.
+
+       Backport from trunk r237291:
+       * c-c++-common/goacc/combined-directives.c: XFAIL tree scanning
+       for OpenACC tile clauses.
+       * gfortran.dg/goacc/combined-directives.f90: Likewise.
+
+       PR c/71381
+       Backport from trunk r237290:
+       * c-c++-common/goacc/cache-1.c: Update.  Move invalid usage tests
+       to...
+       * c-c++-common/goacc/cache-2.c: ... this new file.
+       * gfortran.dg/goacc/cache-1.f95: Move invalid usage tests to...
+       * gfortran.dg/goacc/cache-2.f95: ... this new file.
+       * gfortran.dg/goacc/coarray.f95: Update OpenACC cache directive
+       usage.
+       * gfortran.dg/goacc/cray.f95: Likewise.
+       * gfortran.dg/goacc/loop-1.f95: Likewise.
+
+2016-06-09  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       Back port from trunk
+       2016-05-31  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       * gcc.target/powerpc/p9-splat-4.c: New test.
+
+       Back port from trunk
+       2016-05-31  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       PR target/71186
+       * gcc.target/powerpc/pr71186.c: New test.
+
+       Back port from trunk
+       2016-05-18  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       * gcc.target/powerpc/p9-splat-1.c: New tests for ISA 3.0 word
+       splat operations and the XXSPLTIB instruction.
+       * gcc.target/powerpc/p9-splat-2.c: Likewise.
+       * gcc.target/powerpc/p9-splat-3.c: Likewise.
+       * gcc.target/powerpc/pr47755.c: Allow vspltisw in addition to
+       xxlxor to clear a register.
+
+2016-06-08  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71442
+       * g++.dg/cpp0x/Wunused-variable-1.C: New test.
+
+2016-06-08  Eric Botcazou  <ebotcazou@adacore.com>
+
+       Backport from mainline
+       2016-06-06  Jose E. Marchesi  <jose.marchesi@oracle.com>
+
+       * gcc.target/sparc/vis4misc.c: New file.
+       * gcc.target/sparc/fpcmp.c: Likewise.
+       * gcc.target/sparc/fpcmpu.c: Likewise.
+
+2016-06-08  Ilya Verbin  <ilya.verbin@intel.com>
+
+       Backport from mainline
+       2016-05-25  Ilya Verbin  <ilya.verbin@intel.com>
+
+       * gcc.target/i386/avx512f-ceil-vec-1.c: New test.
+       * gcc.target/i386/avx512f-ceil-vec-2.c: New test.
+       * gcc.target/i386/avx512f-ceilf-sfix-vec-1.c: New test.
+       * gcc.target/i386/avx512f-ceilf-sfix-vec-2.c: New test.
+       * gcc.target/i386/avx512f-ceilf-vec-1.c: New test.
+       * gcc.target/i386/avx512f-ceilf-vec-2.c: New test.
+       * gcc.target/i386/avx512f-floor-vec-1.c: New test.
+       * gcc.target/i386/avx512f-floor-vec-2.c: New test.
+       * gcc.target/i386/avx512f-floorf-sfix-vec-1.c: New test.
+       * gcc.target/i386/avx512f-floorf-sfix-vec-2.c: New test.
+       * gcc.target/i386/avx512f-floorf-vec-1.c: New test.
+       * gcc.target/i386/avx512f-floorf-vec-2.c: New test.
+       * gcc.target/i386/avx512f-rint-sfix-vec-1.c: New test.
+       * gcc.target/i386/avx512f-rint-sfix-vec-2.c: New test.
+       * gcc.target/i386/avx512f-rintf-sfix-vec-1.c: New test.
+       * gcc.target/i386/avx512f-rintf-sfix-vec-2.c: New test.
+       * gcc.target/i386/avx512f-round-sfix-vec-1.c: New test.
+       * gcc.target/i386/avx512f-round-sfix-vec-2.c: New test.
+       * gcc.target/i386/avx512f-roundf-sfix-vec-1.c: New test.
+       * gcc.target/i386/avx512f-roundf-sfix-vec-2.c: New test.
+       * gcc.target/i386/avx512f-trunc-vec-1.c: New test.
+       * gcc.target/i386/avx512f-trunc-vec-2.c: New test.
+       * gcc.target/i386/avx512f-truncf-vec-1.c: New test.
+       * gcc.target/i386/avx512f-truncf-vec-2.c: New test.
+
+2016-06-07  Uros Bizjak  <ubizjak@gmail.com>
+
+       PR target/71389
+       * g++.dg/pr71389.C: New test.
+
+2016-06-06  Jakub Jelinek  <jakub@redhat.com>
+           Patrick Palka  <ppalka@gcc.gnu.org>
+
+       PR c++/70847
+       PR c++/71330
+       PR c++/71393
+       * g++.dg/opt/pr70847.C: New test.
+       * g++.dg/ubsan/pr70847.C: New test.
+       * g++.dg/ubsan/pr71393.C: New test.
+
+2016-06-06  Jakub Jelinek  <jakub@redhat.com>
+
+       PR tree-optimization/71259
+       * gcc.dg/vect/pr71259.c: New test.
+
+2016-06-05  Andre Vehreschild  <vehre@gcc.gnu.org>
+
+       PR fortran/69659
+       * gfortran.dg/class_array_22.f03: New test.
+
+2016-06-03  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+       PR target/70957
+       * gcc.target/powerpc/vsx-elemrev-2.c: Require p9vector hardware
+       support.
+       * gcc.target/powerpc/vsx-elemrev-4.c: Likewise.
+
+2016-06-03  Jakub Jelinek  <jakub@redhat.com>
+
+       PR middle-end/71387
+       * g++.dg/opt/pr71387.C: New test.
+
+2016-06-02  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       Back port from trunk
+       2016-05-26  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       * gcc.target/powerpc/p9-minmax-1.c: New tests for ISA 3.0
+       floating point min/max/comparison instructions.
+       * gcc.target/powerpc/p9-minmax-2.c: Likewise.
+
+2016-06-02  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71372
+       * c-c++-common/pr71372.c: New test.
+
+2016-06-02  Kelvin Nilsen  <kelvin@gcc.gnu.org>
+
+       Back port from trunk
+       2016-05-19  Kelvin Nilsen  <kelvin@gcc.gnu.org>
+
+       * gcc.target/powerpc/darn-0.c: New test.
+       * gcc.target/powerpc/darn-1.c: New test.
+       * gcc.target/powerpc/darn-2.c: New test.
+
+2016-06-02  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/70972
+       * g++.dg/cpp0x/inh-ctor20.C: New.
+       * g++.dg/cpp0x/inh-ctor21.C: Likewise.
+
+2016-06-02  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       * g++.dg/cpp1y/lambda-generic-static1.C: Use target c++14.
+       * g++.dg/cpp1y/lambda-generic-static2.C: Likewise.
+
+2016-06-01  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       Back port from trunk
+       2016-05-23  Michael Meissner  <meissner@linux.vnet.ibm.com>
+                   Kelvin Nilsen  <kelvin@gcc.gnu.org>
+
+       * gcc.target/powerpc/p9-permute.c: Run test on big endian as well
+       as little endian.
+
+       Back port from trunk
+       2016-05-23  Michael Meissner  <meissner@linux.vnet.ibm.com>
+                   Kelvin Nilsen  <kelvin@gcc.gnu.org>
+
+       * gcc.target/powerpc/p9-vpermr.c: New test for ISA 3.0 vpermr
+       support.
+
+       Back port from trunk
+       2016-05-24  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       * gcc.target/powerpc/p9-vparity.c: New file to check ISA 3.0
+       vector parity built-in functions.
+       * gcc.target/powerpc/ctz-3.c: New file to check ISA 3.0 vector
+       count trailing zeros automatic vectorization.
+       * gcc.target/powerpc/ctz-4.c: New file to check ISA 3.0 vector
+       count trailing zeros built-in functions.
+
+       Back port from trunk
+       2016-05-24  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       * gcc.target/powerpc/p9-vneg.c: New test for ISA 3.0 VNEGW/VNEGD
+       instructions.
+
+       Back port from trunk
+       2016-05-11  Michael Meissner  <meissner@linux.vnet.ibm.com>
+
+       * gcc.target/powerpc/dform-3.c: New test for ISA 3.0 vector d-form
+       support.
+       * gcc.target/powerpc/dform-1.c: Add -mlra option to silence
+       warning when using -mvsx-timode.
+       * gcc.target/powerpc/p8vector-int128-1.c: Likewise.
+       * gcc.target/powerpc/dform-2.c: Likewise.
+       * gcc.target/powerpc/pr68805.c: Likewise.
+
+2016-06-01  Paul Thomas  <pault@gcc.gnu.org>
+
+       PR fortran/71156
+       * gfortran.dg/submodule_14.f08: Add missing recursive prefix
+       to the module procedure declaration.
+       * gfortran.dg/submodule_16.f08: New test.
+
+2016-06-01  Jakub Jelinek  <jakub@redhat.com>
+
+       PR middle-end/71371
+       * c-c++-common/gomp/pr71371.c: New test.
+
+       * gfortran.dg/gomp/order-1.f90: New test.
+       * gfortran.dg/gomp/order-2.f90: New test.
+
+2016-06-01  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * gnat.dg/opt56.ad[sb]: New test.
+
+2016-05-31  Martin Sebor  <msebor@redhat.com>
+
+       PR c++/71306
+       * g++.dg/warn/Wplacement-new-size-3.C: New test.
+
+2016-05-31  Richard Biener  <rguenther@suse.de>
+
+       Backport from mainline
+       2016-05-11  Richard Biener  <rguenther@suse.de>
+
+       PR debug/71057
+       * g++.dg/debug/pr71057.C: New testcase.
+
+2016-05-31  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+       PR target/71056
+       * gcc.target/arm/pr71056.c: New test.
+
+2016-05-31  Tom de Vries  <tom@codesourcery.com>
+
+       backport:
+       2016-05-31  Tom de Vries  <tom@codesourcery.com>
+
+       PR tree-optimization/69068
+       * gcc.dg/graphite/pr69068.c: New test.
+
+2016-05-30  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71349
+       * c-c++-common/gomp/clauses-1.c (bar): Add dd argument.  Add
+       nowait depend(inout: dd[0]) clauses where permitted.
+
+2016-05-30  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+       Backport from mainline
+       2016-04-29  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+       * gcc.target/powerpc/vsx-elemrev-1.c: New.
+       * gcc.target/powerpc/vsx-elemrev-2.c: New.
+       * gcc.target/powerpc/vsx-elemrev-3.c: New.
+       * gcc.target/powerpc/vsx-elemrev-4.c: New.
+
+2016-05-30  Tom de Vries  <tom@codesourcery.com>
+
+       backport:
+       2016-05-30  Tom de Vries  <tom@codesourcery.com>
+
+       * gcc.dg/graphite/pr69067.c (main): Remove superfluous argument in call
+       to ce.
+
+2016-05-30  Uros Bizjak  <ubizjak@gmail.com>
+
+       * gcc.target/i386/iamcu/args.h (clear_non_sret_int_hardware_registers):
+       Use correct register when clearing %edx.
+
+2016-05-30  Richard Biener  <rguenther@suse.de>
+
+       Backport from mainline
+       2016-05-11  Richard Biener  <rguenther@suse.de>
+
+       PR middle-end/71002
+       * g++.dg/torture/pr71002.C: New testcase.
+
+       2016-05-13  Jakub Jelinek  <jakub@redhat.com>
+
+       PR bootstrap/71071
+       * gcc.dg/pr71071.c: New test.
+
+2016-05-30  Tom de Vries  <tom@codesourcery.com>
+
+       backport:
+       2016-05-30  Tom de Vries  <tom@codesourcery.com>
+
+       PR tree-optimization/69067
+       * gcc.dg/graphite/pr69067.c: New test.
+
+2016-05-29  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/71105
+       * g++.dg/cpp0x/lambda/lambda-conv11.C: New.
+       * g++.dg/cpp1y/lambda-conv1.C: Likewise.
+       * g++.dg/cpp1y/lambda-conv2.C: Likewise.
+
+2016-05-27  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       Backport from mainline r236810.
+       2016-05-27  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       PR middle-end/71279
+       * gcc.dg/pr71279.c: New test.
+
+2016-05-26  Jerry DeLisle  <jvdelisle@gcc.gnu.org>
+
+       Backport from trunk.
+       PR fortran/66461
+       * gfortran.dg/unexpected_eof.f: New test
+
+2016-05-25  Eric Botcazou  <ebotcazou@adacore.com>
+
+       * gnat.dg/opt55.ad[sb]: New test.
+
+2016-05-24  Martin Sebor  <msebor@redhat.com>
+
+       PR c++/71147
+       * g++.dg/ext/flexary16.C: New test.
+
+2016-05-24  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/69872
+       * g++.dg/warn/Wno-narrowing1.C: New.
+
+2016-05-24  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71257
+       * g++.dg/vect/simd-clone-6.cc: New test.
+       * g++.dg/gomp/declare-simd-6.C: New test.
+
+2016-05-23  Martin Jambor  <mjambor@suse.cz>
+
+       PR tree-optimization/70884
+       * gcc.dg/tree-ssa/pr70919.c: New test.
+
+2016-05-20  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71210
+       * g++.dg/opt/pr71210-1.C: New test.
+       * g++.dg/opt/pr71210-2.C: New test.
+
+       PR fortran/71204
+       * gfortran.dg/pr71204.f90: New test.
+
+2016-05-19  David Malcolm  <dmalcolm@redhat.com>
+
+       Backport from trunk r236483.
+       PR c++/71184
+       * g++.dg/pr71184.C: New test case.
+
+2016-05-19  Marek Polacek  <polacek@redhat.com>
+
+       Backport from mainline
+       2016-05-19  Marek Polacek  <polacek@redhat.com>
+
+       PR tree-optimization/71031
+       * gcc.dg/tree-ssa/vrp100.c: New test.
+
+2016-05-19  Bernd Edlinger  <bernd.edlinger@hotmail.de>
+
+       Backport from mainline
+       2016-05-19  Bernd Edlinger  <bernd.edlinger@hotmail.de>
+
+       * c-c++-common/pr69669.c: Check the used mode.
+
+2016-05-19  Martin Jambor  <mjambor@suse.cz>
+
+       PR ipa/70646
+       * gcc.dg/ipa/pr70646.c: New test.
+
+2016-05-18  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/71100
+       * g++.dg/opt/pr71100.C: New test.
+
+2016-05-18  Paolo Carlini  <paolo.carlini@oracle.com>
+
+       PR c++/70466
+       * g++.dg/template/pr70466-1.C: New.
+       * g++.dg/template/pr70466-2.C: Likewise.
+
+2016-05-18  Christophe Lyon  <christophe.lyon@linaro.org>
+
+       Backport from mainline r236377.
+       2016-05-19  Christophe Lyon  <christophe.lyon@linaro.org>
+
+       * gcc.target/aarch64/noplt_3.c: Scan for "br\t".
+       * gcc.target/aarch64/tail_indirect_call_1.c: Scan for "br\t",
+       "blr\t" and switch to scan-assembler-times.
+
+2016-05-17  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+       Backport from mainline
+       2016-05-17  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+       PR target/70809
+       * gcc.target/aarch64/pr70809_1.c: New test.
+
+2016-05-15  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+       Backport from mainline
+       2016-05-11  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+       * gcc.target/powerpc/pr70963.c: Require at least power8 at both
+       compile and run time.
+
+2016-05-15  Harald Anlauf  <anlauf@gmx.de>
+
+       PR fortran/69603
+       * gfortran.dg/pr69603.f90: New testcase.
+
+2016-05-14  Fritz Reese  <fritzoreese@gmail.com>
+
+       Backport from trunk: r235999, r236241, r236242
+       * gfortran.dg/dec_union_4.f90: Fix endian issue.
+
+       PR fortran/71047
+       * gfortran.dg/pr71047.f08: New test.
+
+       PR fortran/56226
+       * gfortran.dg/dec_structure_1.f90: New testcase.
+       * gfortran.dg/dec_structure_2.f90: Ditto.
+       * gfortran.dg/dec_structure_3.f90: Ditto.
+       * gfortran.dg/dec_structure_4.f90: Ditto.
+       * gfortran.dg/dec_structure_5.f90: Ditto.
+       * gfortran.dg/dec_structure_6.f90: Ditto.
+       * gfortran.dg/dec_structure_7.f90: Ditto.
+       * gfortran.dg/dec_structure_8.f90: Ditto.
+       * gfortran.dg/dec_structure_9.f90: Ditto.
+       * gfortran.dg/dec_structure_10.f90: Ditto.
+       * gfortran.dg/dec_structure_11.f90: Ditto.
+       * gfortran.dg/dec_union_1.f90: Ditto.
+       * gfortran.dg/dec_union_2.f90: Ditto.
+       * gfortran.dg/dec_union_3.f90: Ditto.
+       * gfortran.dg/dec_union_4.f90: Ditto.
+       * gfortran.dg/dec_union_5.f90: Ditto.
+       * gfortran.dg/dec_union_6.f90: Ditto.
+       * gfortran.dg/dec_union_7.f90: Ditto.
+
+2016-05-13  Uros Bizjak  <ubizjak@gmail.com>
+
+       * gcc.dg/vect/tree-vect.h (check_vect): Handle AVX2,
+       remove XOP handling.
+       * gcc.dg/vect/pr66636.c (foo): Add __attribute__((noinline,noclone)).
+
+2016-05-13  Richard Biener  <rguenther@suse.de>
+
+       Backport from mainline
+       2016-04-27  Richard Biener  <rguenther@suse.de>
+
+       PR ipa/70760
+       * g++.dg/ipa/ipa-pta-2.C: New testcase.
+
+       2016-05-06  Richard Biener  <rguenther@suse.de>
+
+       PR middle-end/70931
+       * gfortran.dg/pr70931.f90: New testcase.
+
+       2016-05-06  Richard Biener  <rguenther@suse.de>
+
+       PR middle-end/70941
+       * gcc.dg/torture/pr70941.c: New testcase.
+
+       2016-05-06  Jakub Jelinek  <jakub@redhat.com>
+
+       PR middle-end/70941
+       * gcc.dg/torture/pr70941.c (abort): Remove prototype.
+       (a, b, c, d): Change type from char to signed char.
+       (main): Compare against (signed char) -1634678893 instead of
+       hardcoded -109.  Use __builtin_abort instead of abort.
+
+2016-05-12  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       Backport from mainline r236171.
+       2016-05-12  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       PR tree-optimization/71006
+       * gcc.dg/pr71006.c: New test.
+
+2016-05-12  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+       Backport from mainline
+       2016-05-12  Kyrylo Tkachov  <kyrylo.tkachov@arm.com>
+
+       PR target/70830
+       * gcc.target/arm/interrupt-1.c: Change dg-compile to dg-assemble.
+       Add -save-temps to dg-options.
+       Scan for ldmfd rather than pop instruction.
+       * gcc.target/arm/interrupt-2.c: Likewise.
+       * gcc.target/arm/pr70830.c: New test.
+
+2016-05-11  Jakub Jelinek  <jakub@redhat.com>
+
+       PR fortran/70855
+       * gfortran.dg/gomp/pr70855.f90: New test.
+
+2016-05-11  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       Backport from mainline r236088.
+       2016-05-10  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       PR middle-end/70877
+       * gcc.target/i386/pr70877.c: New test.
+
+2016-05-11  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       Backport from mainline r236086.
+       2016-05-10  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       PR tree-optimization/70876
+       * gcc.target/i386/pr70876.c: New test.
+
+2016-05-10  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+       Backport from mainline
+       2016-05-10  Bill Schmidt  <wschmidt@linux.vnet.ibm.com>
+
+       PR target/70963
+       * gcc.target/powerpc/pr70963.c: New.
+
+2016-05-10  Jakub Jelinek  <jakub@redhat.com>
+
+       Backported from mainline
+       2016-05-03  Jakub Jelinek  <jakub@redhat.com>
+
+       PR tree-optimization/70916
+       * gcc.c-torture/compile/pr70916.c: New test.
+
+2016-05-10  Yuri Rumyantsev  <ysrumyan@gmail.com>
+
+       Backport from mainline r235962.
+       2016-05-06  Yuri Rumyantsev  <ysrumyan@gmail.com>
+
+       PR debug/70935
+       * gcc.dg/torture/pr70935.c: New test.
+
+2016-05-09  Uros Bizjak  <ubizjak@gmail.com>
+
+       * gcc.target/i386/fabsneg-1.c New test.
+
  2016-05-07  Tom de Vries  <tom@codesourcery.com>
  
         backport:
diff --git a/gcc/testsuite/c-c++-common/goacc/cache-1.c b/gcc/testsuite/c-c++-common/goacc/cache-1.c

index 9503341..1d4759e 100644 (file)
--- a/gcc/testsuite/c-c++-common/goacc/cache-1.c
+++ b/gcc/testsuite/c-c++-common/goacc/cache-1.c
@@ -1,3 +1,7 @@
+/* OpenACC cache directive: valid usage.  */
+/* For execution testing, this file is "#include"d from
+   libgomp/testsuite/libgomp.oacc-c-c++-common/cache-1.c.  */
+
  int
  main (int argc, char **argv)
  {
@@ -21,57 +25,31 @@ main (int argc, char **argv)
          int n = 1;
          const int len = n;
  
-#pragma acc cache /* { dg-error "expected '\\\(' before end of line" } */
-
-#pragma acc cache a[0:N] /* { dg-error "expected '\\\(' before 'a'" } */
-       /* { dg-bogus "expected end of line before 'a'" "" { xfail c++ } 26 } */
-
-#pragma acc cache (a) /* { dg-error "expected '\\\['" } */
-
-#pragma acc cache ( /* { dg-error "expected (identifier|unqualified-id) before end of line" } */
-
-#pragma acc cache () /* { dg-error "expected (identifier|unqualified-id) before '\\\)' token" } */
-
-#pragma acc cache (,) /* { dg-error "expected (identifier|unqualified-id) before '(,|\\\))' token" } */
-
-#pragma acc cache (a[0:N] /* { dg-error "expected '\\\)' before end of line" } */
-
-#pragma acc cache (a[0:N],) /* { dg-error "expected (identifier|unqualified-id) before '(,|\\\))' token" "" { xfail c } } */
-
-#pragma acc cache (a[0:N]) copyin (a[0:N]) /* { dg-error "expected end of line before 'copyin'" } */
-
-#pragma acc cache () /* { dg-error "expected (identifier|unqualified-id) before '\\\)' token" } */
-
-#pragma acc cache (a[0:N] b[0:N]) /* { dg-error "expected '\\\)' before 'b'" } */
-
-#pragma acc cache (a[0:N] b[0:N}) /* { dg-error "expected '\\\)' before 'b'" } */
-       /* { dg-bogus "expected end of line before '\\\}' token" "" { xfail c++ } 47 } */
-
-#pragma acc cache (a[0:N] /* { dg-error "expected '\\\)' before end of line" } */
-
-#pragma acc cache (a[ii]) /* { dg-error "'ii' is not a constant" } */
-
-#pragma acc cache (a[idx:n]) /* { dg-error "'n' is not a constant" } */
-
-#pragma acc cache (a[0:N]) ( /* { dg-error "expected end of line before '\\(' token" } */
-
-#pragma acc cache (a[0:N]) ii /* { dg-error "expected end of line before 'ii'" } */
-
-#pragma acc cache (a[0:N] ii) /* { dg-error "expected '\\)' before 'ii'" } */
-
+       /* Have at it, GCC!  */
  #pragma acc cache (a[0:N])
-
  #pragma acc cache (a[0:N], a[0:N])
-
  #pragma acc cache (a[0:N], b[0:N])
-
  #pragma acc cache (a[0])
-
  #pragma acc cache (a[0], a[1], b[0:N])
-
+#pragma acc cache (a[i - 5])
+#pragma acc cache (a[i + 5:len])
+#pragma acc cache (a[i + 5:len - 1])
+#pragma acc cache (b[i])
+#pragma acc cache (b[i:len])
+#pragma acc cache (a[ii])
+#pragma acc cache (a[ii:len])
+#pragma acc cache (b[ii - 1])
+#pragma acc cache (b[ii - 1:len])
+#pragma acc cache (b[i - ii + 1])
+#pragma acc cache (b[i + ii - 1:len])
+#pragma acc cache (b[i * ii - 1:len + 1])
+#pragma acc cache (a[idx + 2])
+#pragma acc cache (a[idx:len + 2])
  #pragma acc cache (a[idx])
-
  #pragma acc cache (a[idx:len])
+#pragma acc cache (a[idx + 2:len])
+#pragma acc cache (a[idx + 2 + i:len])
+#pragma acc cache (a[idx + 2 + i + ii:len])
  
          b[ii] = a[ii];
      }
diff --git a/gcc/testsuite/c-c++-common/goacc/cache-2.c b/gcc/testsuite/c-c++-common/goacc/cache-2.c

new file mode 100644 (file)

index 0000000..f717515
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/goacc/cache-2.c
@@ -0,0 +1,57 @@
+/* OpenACC cache directive: invalid usage.  */
+
+int
+main (int argc, char **argv)
+{
+#define N   2
+    int a[N], b[N];
+    int i;
+
+    for (i = 0; i < N; i++)
+    {
+        a[i] = 3;
+        b[i] = 0;
+    }
+
+#pragma acc parallel copyin (a[0:N]) copyout (b[0:N])
+{
+    int ii;
+
+    for (ii = 0; ii < N; ii++)
+    {
+        const int idx = ii;
+        int n = 1;
+        const int len = n;
+
+#pragma acc cache /* { dg-error "expected '\\\(' before end of line" } */
+#pragma acc cache a[0:N] /* { dg-error "expected '\\\(' before 'a'" } */
+       /* { dg-bogus "expected end of line before 'a'" "" { xfail c++ } 27 } */
+#pragma acc cache (a) /* { dg-error "expected '\\\['" } */
+#pragma acc cache ( /* { dg-error "expected (identifier|unqualified-id) before end of line" } */
+#pragma acc cache () /* { dg-error "expected (identifier|unqualified-id) before '\\\)' token" } */
+#pragma acc cache (,) /* { dg-error "expected (identifier|unqualified-id) before '(,|\\\))' token" } */
+#pragma acc cache (a[0:N] /* { dg-error "expected '\\\)' before end of line" } */
+#pragma acc cache (a[0:N],) /* { dg-error "expected (identifier|unqualified-id) before '(,|\\\))' token" "" { xfail c } } */
+#pragma acc cache (a[0:N]) copyin (a[0:N]) /* { dg-error "expected end of line before 'copyin'" } */
+#pragma acc cache () /* { dg-error "expected (identifier|unqualified-id) before '\\\)' token" } */
+#pragma acc cache (a[0:N] b[0:N]) /* { dg-error "expected '\\\)' before 'b'" } */
+#pragma acc cache (a[0:N] b[0:N}) /* { dg-error "expected '\\\)' before 'b'" } */
+       /* { dg-bogus "expected end of line before '\\\}' token" "" { xfail c++ } 38 } */
+#pragma acc cache (a[0:N] /* { dg-error "expected '\\\)' before end of line" } */
+#pragma acc cache (a[0:N]) ( /* { dg-error "expected end of line before '\\(' token" } */
+#pragma acc cache (a[0:N]) ii /* { dg-error "expected end of line before 'ii'" } */
+#pragma acc cache (a[0:N] ii) /* { dg-error "expected '\\)' before 'ii'" } */
+
+        b[ii] = a[ii];
+    }
+}
+
+
+    for (i = 0; i < N; i++)
+    {
+        if (a[i] != b[i])
+            __builtin_abort ();
+    }
+
+    return 0;
+}
diff --git a/gcc/testsuite/c-c++-common/goacc/combined-directives.c b/gcc/testsuite/c-c++-common/goacc/combined-directives.c

index c2a3c57..3fa800d 100644 (file)
--- a/gcc/testsuite/c-c++-common/goacc/combined-directives.c
+++ b/gcc/testsuite/c-c++-common/goacc/combined-directives.c
@@ -111,6 +111,7 @@ test ()
  // { dg-final { scan-tree-dump-times "acc loop vector" 2 "gimple" } }
  // { dg-final { scan-tree-dump-times "acc loop seq" 2 "gimple" } }
  // { dg-final { scan-tree-dump-times "acc loop auto" 2 "gimple" } }
-// { dg-final { scan-tree-dump-times "acc loop tile.2, 3" 2 "gimple" } }
+// XFAILed: OpenACC tile clauses are discarded during gimplification.
+// { dg-final { scan-tree-dump-times "acc loop tile.2, 3" 2 "gimple" { xfail *-*-* } } }
  // { dg-final { scan-tree-dump-times "acc loop independent private.i" 2 "gimple" } }
  // { dg-final { scan-tree-dump-times "private.z" 2 "gimple" } }
diff --git a/gcc/testsuite/c-c++-common/gomp/clauses-1.c b/gcc/testsuite/c-c++-common/gomp/clauses-1.c

index 91aed39..fe90c24 100644 (file)
--- a/gcc/testsuite/c-c++-common/gomp/clauses-1.c
+++ b/gcc/testsuite/c-c++-common/gomp/clauses-1.c
@@ -34,7 +34,7 @@ foo (int d, int m, int i1, int i2, int p, int *idp, int s,
  
  void
  bar (int d, int m, int i1, int i2, int p, int *idp, int s,
-     int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q)
+     int nte, int tl, int nth, int g, int nta, int fi, int pp, int *q, int *dd)
  {
    #pragma omp for simd \
      private (p) firstprivate (f) lastprivate (l) linear (ll:1) reduction(+:r) schedule(static, 4) collapse(1) nowait \
@@ -63,29 +63,30 @@ bar (int d, int m, int i1, int i2, int p, int *idp, int s,
    }
    #pragma omp target parallel \
      device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) \
-    if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread)
+    if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) \
+    nowait depend(inout: dd[0])
      ;
    #pragma omp target parallel for \
      device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) \
      if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) \
-    lastprivate (l) linear (ll:1) ordered schedule(static, 4) collapse(1)
+    lastprivate (l) linear (ll:1) ordered schedule(static, 4) collapse(1) nowait depend(inout: dd[0])
    for (int i = 0; i < 64; i++)
      ll++;
    #pragma omp target parallel for simd \
      device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) \
      if (parallel: i2) default(shared) shared(s) reduction(+:r) num_threads (nth) proc_bind(spread) \
      lastprivate (l) linear (ll:1) schedule(static, 4) collapse(1) \
-    safelen(8) simdlen(4) aligned(q: 32)
+    safelen(8) simdlen(4) aligned(q: 32) nowait depend(inout: dd[0])
    for (int i = 0; i < 64; i++)
      ll++;
    #pragma omp target teams \
      device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) \
-    shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl)
+    shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) nowait depend(inout: dd[0])
      ;
    #pragma omp target teams distribute \
      device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) \
      shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) \
-    collapse(1) dist_schedule(static, 16)
+    collapse(1) dist_schedule(static, 16) nowait depend(inout: dd[0])
    for (int i = 0; i < 64; i++)
      ;
    #pragma omp target teams distribute parallel for \
@@ -93,7 +94,7 @@ bar (int d, int m, int i1, int i2, int p, int *idp, int s,
      shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) \
      collapse(1) dist_schedule(static, 16) \
      if (parallel: i2) num_threads (nth) proc_bind(spread) \
-    lastprivate (l) schedule(static, 4)
+    lastprivate (l) schedule(static, 4) nowait depend(inout: dd[0])
    for (int i = 0; i < 64; i++)
      ll++;
    #pragma omp target teams distribute parallel for simd \
@@ -102,19 +103,20 @@ bar (int d, int m, int i1, int i2, int p, int *idp, int s,
      collapse(1) dist_schedule(static, 16) \
      if (parallel: i2) num_threads (nth) proc_bind(spread) \
      lastprivate (l) schedule(static, 4) \
-    safelen(8) simdlen(4) aligned(q: 32)
+    safelen(8) simdlen(4) aligned(q: 32) nowait depend(inout: dd[0])
    for (int i = 0; i < 64; i++)
      ll++;
    #pragma omp target teams distribute simd \
      device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) \
      shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) \
      collapse(1) dist_schedule(static, 16) \
-    safelen(8) simdlen(4) aligned(q: 32)
+    safelen(8) simdlen(4) aligned(q: 32) nowait depend(inout: dd[0])
    for (int i = 0; i < 64; i++)
      ll++;
    #pragma omp target simd \
      device(d) map (tofrom: m) if (target: i1) private (p) firstprivate (f) defaultmap(tofrom: scalar) is_device_ptr (idp) \
-    safelen(8) simdlen(4) lastprivate (l) linear(ll: 1) aligned(q: 32) reduction(+:r)
+    safelen(8) simdlen(4) lastprivate (l) linear(ll: 1) aligned(q: 32) reduction(+:r) \
+     nowait depend(inout: dd[0])
    for (int i = 0; i < 64; i++)
      ll++;
    #pragma omp taskloop simd \
@@ -128,7 +130,7 @@ bar (int d, int m, int i1, int i2, int p, int *idp, int s,
      safelen(8) simdlen(4) linear(ll: 1) aligned(q: 32) reduction(+:r)
    for (int i = 0; i < 64; i++)
      ll++;
-  #pragma omp target
+  #pragma omp target nowait depend(inout: dd[0])
    #pragma omp teams distribute \
      private(p) firstprivate (f) shared(s) default(shared) reduction(+:r) num_teams(nte) thread_limit(tl) \
      collapse(1) dist_schedule(static, 16)
diff --git a/gcc/testsuite/c-c++-common/gomp/pr71371.c b/gcc/testsuite/c-c++-common/gomp/pr71371.c

new file mode 100644 (file)

index 0000000..da6e842
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/gomp/pr71371.c
@@ -0,0 +1,25 @@
+/* PR middle-end/71371 */
+/* { dg-do compile } */
+
+void baz (int *);
+
+void
+foo (void)
+{
+  int i;
+  #pragma omp taskloop
+  for (i = 0; i < 100; i++)
+    baz (&i);
+}
+
+void
+bar (void)
+{
+  int i;
+  #pragma omp parallel
+  {
+    #pragma omp for
+    for (i = 0; i < 100; i++)
+      baz (&i);
+  }
+}
diff --git a/gcc/testsuite/c-c++-common/pr69669.c b/gcc/testsuite/c-c++-common/pr69669.c

index 9940afe..ebeb410 100644 (file)
--- a/gcc/testsuite/c-c++-common/pr69669.c
+++ b/gcc/testsuite/c-c++-common/pr69669.c
@@ -1,5 +1,6 @@
  /* PR c/69669 */
  /* { dg-do compile } */
+/* { dg-options "-fdump-rtl-final" } */
  
  enum __attribute__((mode(QI))) E { F = 1 };
  
@@ -8,3 +9,5 @@ foo (enum E *x, int y)
  {
    *x = (enum E) y;
  }
+
+/* { dg-final { scan-rtl-dump-times "mem:QI" 1 "final" } } */
diff --git a/gcc/testsuite/c-c++-common/pr71372.c b/gcc/testsuite/c-c++-common/pr71372.c

new file mode 100644 (file)

index 0000000..943adab
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/pr71372.c
@@ -0,0 +1,14 @@
+/* PR c++/71372 */
+/* { dg-do compile } */
+/* { dg-options "-O2 -fdump-tree-optimized" } */
+
+void
+foo (volatile int *p, int q)
+{
+  *(volatile int *)p = 0;
+  *(p + (q - q) + 1) = 0;
+  *(p + (q - q) + 2) = 0;
+  *(p + (q - q) + 3) = 0;
+}
+
+/* { dg-final { scan-tree-dump-times " ={v} " 4 "optimized" } } */
diff --git a/gcc/testsuite/c-c++-common/ubsan/bounds-13.c b/gcc/testsuite/c-c++-common/ubsan/bounds-13.c

new file mode 100644 (file)

index 0000000..25b0467
--- /dev/null
+++ b/gcc/testsuite/c-c++-common/ubsan/bounds-13.c
@@ -0,0 +1,31 @@
+/* PR sanitizer/71498 */
+/* { dg-do run } */
+/* { dg-options "-fsanitize=bounds -Wno-array-bounds" } */
+
+struct S { int a[100]; int b, c; } s;
+
+__attribute__((noinline, noclone)) int
+foo (int x)
+{
+  return s.a[x];
+}
+
+__attribute__((noinline, noclone)) int
+bar (int x)
+{
+  static int *d = &s.a[99];
+  asm volatile ("" : : "r" (&d));
+  return s.a[x];
+}
+
+int
+main ()
+{
+  volatile int a = 0;
+  a += foo (100);
+  a += bar (100);
+  return 0;
+}
+
+/* { dg-output "index 100 out of bounds for type 'int \\\[100\\\]'\[^\n\r]*(\n|\r\n|\r)" } */
+/* { dg-output "\[^\n\r]*index 100 out of bounds for type 'int \\\[100\\\]'\[^\n\r]*(\n|\r\n|\r)" } */
diff --git a/gcc/testsuite/g++.dg/cpp0x/Wunused-variable-1.C b/gcc/testsuite/g++.dg/cpp0x/Wunused-variable-1.C

new file mode 100644 (file)

index 0000000..39592b2
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/Wunused-variable-1.C
@@ -0,0 +1,37 @@
+// PR c++/71442
+// { dg-do compile { target c++11 } }
+// { dg-options "-Wunused-variable" }
+
+struct C
+{
+  template<typename... Ts>
+  int operator()(Ts &&...)
+  {
+    return sizeof...(Ts);
+  }
+};
+
+int
+foo ()
+{
+  C {} (1, 1L, 1LL, 1.0);
+}
+
+template<int N>
+void
+bar ()
+{
+  char a;              // { dg-warning "unused variable" }
+  short b;             // { dg-warning "unused variable" }
+  int c;               // { dg-warning "unused variable" }
+  long d;              // { dg-warning "unused variable" }
+  long long e;         // { dg-warning "unused variable" }
+  float f;             // { dg-warning "unused variable" }
+  double g;            // { dg-warning "unused variable" }
+}
+
+void
+baz ()
+{
+  bar <0> ();
+}
diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-array16.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-array16.C

new file mode 100644 (file)

index 0000000..af2e58d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-array16.C
@@ -0,0 +1,23 @@
+// PR c++/71166
+// { dg-do compile { target c++11 } }
+
+struct Foo { int value; };
+
+constexpr Foo MakeFoo() { return Foo{0}; }
+
+struct Bar {
+       Foo color = MakeFoo();
+};
+
+struct BarContainer {
+       Bar array[1];
+};
+
+Foo X ()
+{
+  return MakeFoo ();
+}
+
+void Foo() {
+       new BarContainer();
+}
diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-recursion2.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-recursion2.C

index 978b998..ce2280c 100644 (file)
--- a/gcc/testsuite/g++.dg/cpp0x/constexpr-recursion2.C
+++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-recursion2.C
@@ -1,5 +1,6 @@
  // PR c++/70344
  // { dg-do compile { target c++11 } }
+// { dg-options -O }
  
  struct Z
  {
diff --git a/gcc/testsuite/g++.dg/cpp0x/inh-ctor20.C b/gcc/testsuite/g++.dg/cpp0x/inh-ctor20.C

new file mode 100644 (file)

index 0000000..f33056d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/inh-ctor20.C
@@ -0,0 +1,16 @@
+// PR c++/70972
+// { dg-do compile { target c++11 } }
+
+struct moveonly {
+    moveonly(moveonly&&) = default;
+    moveonly() = default;
+};
+
+struct A {
+    A(moveonly) {}
+};
+struct B : A {
+    using A::A;
+};
+
+B b(moveonly{});
diff --git a/gcc/testsuite/g++.dg/cpp0x/inh-ctor21.C b/gcc/testsuite/g++.dg/cpp0x/inh-ctor21.C

new file mode 100644 (file)

index 0000000..6465506
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/inh-ctor21.C
@@ -0,0 +1,19 @@
+// PR c++/70972
+// { dg-do run { target c++11 } }
+
+struct abort_on_copy{
+    abort_on_copy(abort_on_copy&&) = default;
+    abort_on_copy(const abort_on_copy&) { __builtin_abort(); }
+    abort_on_copy() = default;
+};
+
+struct A {
+    A(abort_on_copy) {}
+};
+struct B : A {
+    using A::A;
+};
+
+int main() {
+    B b(abort_on_copy{});
+}
diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-conv11.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-conv11.C

new file mode 100644 (file)

index 0000000..4b8d648
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-conv11.C
@@ -0,0 +1,10 @@
+// PR c++/71105
+// { dg-do compile { target c++11 } }
+
+void foo()
+{
+  int i;
+  static_cast<void(*)()>([i]{});  // { dg-error "invalid static_cast" }
+  static_cast<void(*)()>([=]{});  // { dg-error "invalid static_cast" }
+  static_cast<void(*)()>([&]{});  // { dg-error "invalid static_cast" }
+}
diff --git a/gcc/testsuite/g++.dg/cpp1y/auto-fn31.C b/gcc/testsuite/g++.dg/cpp1y/auto-fn31.C

new file mode 100644 (file)

index 0000000..c99c595
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/auto-fn31.C
@@ -0,0 +1,7 @@
+// PR c++/70572
+// { dg-do compile { target c++14 } }
+
+void foo ()
+{
+  decltype (auto) a = foo;  // { dg-error "initializer" }
+}
diff --git a/gcc/testsuite/g++.dg/cpp1y/lambda-conv1.C b/gcc/testsuite/g++.dg/cpp1y/lambda-conv1.C

new file mode 100644 (file)

index 0000000..2e4ec49
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/lambda-conv1.C
@@ -0,0 +1,13 @@
+// PR c++/71105
+// { dg-do compile { target c++14 } }
+
+void foo()
+{
+  int i;
+  static_cast<void(*)(int)>([i](auto){});  // { dg-error "invalid static_cast" }
+  static_cast<void(*)(int)>([=](auto){});  // { dg-error "invalid static_cast" }
+  static_cast<void(*)(int)>([&](auto){});  // { dg-error "invalid static_cast" }
+  static_cast<float(*)(float)>([i](auto x){ return x; });  // { dg-error "invalid static_cast" }
+  static_cast<float(*)(float)>([=](auto x){ return x; });  // { dg-error "invalid static_cast" }
+  static_cast<float(*)(float)>([&](auto x){ return x; });  // { dg-error "invalid static_cast" }
+}
diff --git a/gcc/testsuite/g++.dg/cpp1y/lambda-conv2.C b/gcc/testsuite/g++.dg/cpp1y/lambda-conv2.C

new file mode 100644 (file)

index 0000000..45c0f3f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/lambda-conv2.C
@@ -0,0 +1,23 @@
+// PR c++/71105
+// { dg-do compile { target c++14 } }
+
+template <typename T> T declval();
+template <typename, typename> struct is_same
+{ static constexpr bool value = false; };
+template <typename T> struct is_same<T, T>
+{ static constexpr bool value = true; };
+
+template <class F>
+struct indirected : F {
+  indirected(F f) : F(f) {}
+  template <class I>
+  auto operator()(I i) -> decltype(declval<F&>()(*i)) {
+    return static_cast<F&>(*this)(*i);
+  }
+};
+
+int main() {
+  auto f = [=](auto i) { return i + i; };
+  auto i = indirected<decltype(f)>{f};
+  static_assert(is_same<decltype(i(declval<int*>())), int>::value, "");
+}
diff --git a/gcc/testsuite/g++.dg/cpp1y/lambda-generic-static1.C b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-static1.C

new file mode 100644 (file)

index 0000000..6692268
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-static1.C
@@ -0,0 +1,13 @@
+// PR c++/70735
+// { dg-do run { target c++14 } }
+
+int main()
+{
+  static int a;
+  auto f = [](auto) { return a; };
+  if (f(0) != 0)
+    __builtin_abort();
+  a = 1;
+  if (f(0) != 1)
+    __builtin_abort();
+}
diff --git a/gcc/testsuite/g++.dg/cpp1y/lambda-generic-static2.C b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-static2.C

new file mode 100644 (file)

index 0000000..c8e251f
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/lambda-generic-static2.C
@@ -0,0 +1,19 @@
+// PR c++/70735
+// { dg-do run { target c++14 } }
+
+template <class T>
+static void g()
+{
+  static int a;
+  auto f = [](auto) { return a; };
+  if (f(0) != 0)
+    __builtin_abort();
+  a = 1;
+  if (f(0) != 1)
+    __builtin_abort();
+}
+
+int main()
+{
+  g<int>();
+}
diff --git a/gcc/testsuite/g++.dg/cpp1y/var-templ39.C b/gcc/testsuite/g++.dg/cpp1y/var-templ39.C

index e06519d..5170a5b 100644 (file)
--- a/gcc/testsuite/g++.dg/cpp1y/var-templ39.C
+++ b/gcc/testsuite/g++.dg/cpp1y/var-templ39.C
@@ -1,5 +1,5 @@
  // PR c++/66260
-// { dg-do compile { target c++14 } }
+// { dg-do assemble { target c++14 } }
  
  template <class>
  constexpr bool foo = false;
diff --git a/gcc/testsuite/g++.dg/cpp1y/var-templ39a.C b/gcc/testsuite/g++.dg/cpp1y/var-templ39a.C

new file mode 100644 (file)

index 0000000..5ba1b9d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/var-templ39a.C
@@ -0,0 +1,27 @@
+// PR c++/66260
+// { dg-do compile { target c++14 } }
+
+template <class>
+bool foo = false;
+template <>
+bool foo<int> = true;
+template <class T, int N>
+bool foo<T[N]> = foo<T>;
+
+#define assert(X) if (!(X)) __builtin_abort();
+
+int main()
+{
+  // { dg-final { scan-assembler "_Z3fooIiE" } }
+  assert(foo<int>);
+  // { dg-final { scan-assembler "_Z3fooIdE" } }
+  assert(!foo<double>);
+  // { dg-final { scan-assembler "_Z3fooIA3_iE" } }
+  assert(foo<int[3]>);
+  // { dg-final { scan-assembler "_Z3fooIA3_dE" } }
+  assert(!foo<double[3]>);
+  // { dg-final { scan-assembler "_Z3fooIA2_A5_A3_iE" } }
+  assert(foo<int[2][5][3]>);
+  // { dg-final { scan-assembler "_Z3fooIA2_A5_A3_dE" } }
+  assert(!foo<double[2][5][3]>);
+}
diff --git a/gcc/testsuite/g++.dg/cpp1y/var-templ51.C b/gcc/testsuite/g++.dg/cpp1y/var-templ51.C

new file mode 100644 (file)

index 0000000..f85ef9c
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/var-templ51.C
@@ -0,0 +1,11 @@
+// PR c++/60095
+// { dg-do link { target c++14 } }
+
+template <class>
+constexpr bool b = false;
+template<typename T>
+constexpr bool b<T*> = true;
+int main() {
+    b<int*>;
+    b<double*>;
+}
diff --git a/gcc/testsuite/g++.dg/cpp1y/var-templ52.C b/gcc/testsuite/g++.dg/cpp1y/var-templ52.C

new file mode 100644 (file)

index 0000000..61fd19e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/cpp1y/var-templ52.C
@@ -0,0 +1,14 @@
+// PR c++/69515
+// { dg-do link { target c++14 } }
+
+struct A { A(int = 0) {} };
+
+template<class...> class meow;
+
+template<typename T> A foo;
+template<typename... Ts> A foo<meow<Ts...>> = 1;
+
+auto&& a = foo<meow<int>>;
+auto&& b = foo<meow<int, int>>;
+
+int main() {}
diff --git a/gcc/testsuite/g++.dg/debug/pr71057.C b/gcc/testsuite/g++.dg/debug/pr71057.C

new file mode 100644 (file)

index 0000000..2ed1eed
--- /dev/null
+++ b/gcc/testsuite/g++.dg/debug/pr71057.C
@@ -0,0 +1,12 @@
+// { dg-do compile }
+// { dg-options "-g" }
+template <typename _Tp> using decay_t = _Tp;
+template <typename> struct A;
+template <typename> struct B { B(A<int>); };
+template <typename> struct C {
+      template <typename U> using constructor = B<decay_t<U>>;
+        typedef constructor<int> dummy;
+};
+template <typename> struct D {};
+C<int> a;
+D<B<int>> fn1() { fn1, a; }
diff --git a/gcc/testsuite/g++.dg/ext/flexary16.C b/gcc/testsuite/g++.dg/ext/flexary16.C

new file mode 100644 (file)

index 0000000..a3e040d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ext/flexary16.C
@@ -0,0 +1,37 @@
+// PR c++/71147 - [6 Regression] Flexible array member wrongly rejected
+//   in template
+// { dg-do compile }
+
+template <typename>
+struct container
+{
+  struct elem {
+    unsigned u;
+  };
+
+  struct incomplete {
+    int x;
+    elem array[];
+  };
+};
+
+unsigned f (container<void>::incomplete* i)
+{
+  return i->array [0].u;
+}
+
+
+template <typename T>
+struct D: container<T>
+{
+  struct S {
+    int x;
+    typename container<T>::elem array[];
+  };
+};
+
+
+unsigned g (D<void>::S *s)
+{
+  return s->array [0].u;
+}
diff --git a/gcc/testsuite/g++.dg/gomp/declare-simd-6.C b/gcc/testsuite/g++.dg/gomp/declare-simd-6.C

new file mode 100644 (file)

index 0000000..09137ee
--- /dev/null
+++ b/gcc/testsuite/g++.dg/gomp/declare-simd-6.C
@@ -0,0 +1,37 @@
+// PR c++/71257
+// { dg-do compile }
+// { dg-options "-fopenmp-simd" }
+
+struct S { int a; };
+#pragma omp declare simd linear(val(a):2)
+int f1 (int &a);
+#pragma omp declare simd linear(uval(a):2)
+unsigned short f2 (unsigned short &a);
+#pragma omp declare simd linear(ref(a):1)
+int f3 (long long int &a);
+#pragma omp declare simd linear(a:1)
+int f4 (int &a);
+#pragma omp declare simd linear(val(a))
+int f5 (int a);
+#pragma omp declare simd linear(uval(a):2)             // { dg-error "modifier applied to non-reference variable" }
+int f6 (unsigned short a);
+#pragma omp declare simd linear(ref(a):1)              // { dg-error "modifier applied to non-reference variable" }
+int f7 (unsigned long int a);
+#pragma omp declare simd linear(a:1)
+int f8 (int a);
+#pragma omp declare simd linear(val(a):2)              // { dg-error "applied to non-integral non-pointer variable" }
+int f9 (S &a);
+#pragma omp declare simd linear(uval(a):2)             // { dg-error "applied to non-integral non-pointer variable" }
+int f10 (S &a);
+#pragma omp declare simd linear(ref(a):1)              // { dg-bogus "applied to non-integral non-pointer variable" }
+int f11 (S &a);
+#pragma omp declare simd linear(a:1)                   // { dg-error "applied to non-integral non-pointer variable" }
+int f12 (S &a);
+#pragma omp declare simd linear(val(a))                        // { dg-error "applied to non-integral non-pointer variable" }
+int f13 (S a);
+#pragma omp declare simd linear(uval(a):2)             // { dg-error "modifier applied to non-reference variable" }
+int f14 (S a);
+#pragma omp declare simd linear(ref(a):1)              // { dg-error "modifier applied to non-reference variable" }
+int f15 (S a);
+#pragma omp declare simd linear(a:1)                   // { dg-error "applied to non-integral non-pointer variable" }
+int f16 (S a);
diff --git a/gcc/testsuite/g++.dg/init/pr71516.C b/gcc/testsuite/g++.dg/init/pr71516.C

new file mode 100644 (file)

index 0000000..0b9aec4
--- /dev/null
+++ b/gcc/testsuite/g++.dg/init/pr71516.C
@@ -0,0 +1,10 @@
+// PR c++/71516
+// { dg-do compile }
+
+struct A;      // { dg-message "forward declaration of" }
+struct B
+{ 
+  static A a;
+};
+A B::a = A();  // { dg-error "has initializer but incomplete type|invalid use of incomplete type" }
+struct A {};
diff --git a/gcc/testsuite/g++.dg/ipa/ipa-pta-2.C b/gcc/testsuite/g++.dg/ipa/ipa-pta-2.C

new file mode 100644 (file)

index 0000000..fd7c793
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ipa/ipa-pta-2.C
@@ -0,0 +1,37 @@
+// { dg-do run }
+// { dg-options "-O2 -fipa-pta" }
+
+extern "C" void abort (void);
+
+struct Y { ~Y(); int i; };
+
+Y::~Y () {}
+
+static Y __attribute__((noinline)) foo ()
+{
+  Y res;
+  res.i = 3;
+  return res;
+}
+
+static Y __attribute__((noinline)) bar ()
+{
+  Y res;
+  res.i = 42;
+  return res;
+}
+
+static Y (*fn) ();
+
+int a;
+int main()
+{
+  if (a)
+    fn = foo;
+  else
+    fn = bar;
+  Y res = fn ();
+  if (res.i != 42)
+    abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/lookup/scoped10.C b/gcc/testsuite/g++.dg/lookup/scoped10.C

new file mode 100644 (file)

index 0000000..c604297
--- /dev/null
+++ b/gcc/testsuite/g++.dg/lookup/scoped10.C
@@ -0,0 +1,5 @@
+namespace A { }
+namespace N { struct A; }
+using namespace N;
+
+struct ::A *p;
diff --git a/gcc/testsuite/g++.dg/lookup/scoped9.C b/gcc/testsuite/g++.dg/lookup/scoped9.C

new file mode 100644 (file)

index 0000000..06f0902
--- /dev/null
+++ b/gcc/testsuite/g++.dg/lookup/scoped9.C
@@ -0,0 +1,10 @@
+// PR c++/71173
+
+namespace foo {
+  namespace bar {
+    class foo {};
+  }
+  class baz {};
+}
+using namespace foo::bar;
+::foo::baz mybaz;
diff --git a/gcc/testsuite/g++.dg/opt/pr70847.C b/gcc/testsuite/g++.dg/opt/pr70847.C

new file mode 100644 (file)

index 0000000..2b54353
--- /dev/null
+++ b/gcc/testsuite/g++.dg/opt/pr70847.C
@@ -0,0 +1,11 @@
+// PR c++/70847
+// { dg-do compile }
+
+struct D { virtual D& f(); };
+
+void
+g()
+{
+  D d;
+  d.f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f();
+}
diff --git a/gcc/testsuite/g++.dg/opt/pr71100.C b/gcc/testsuite/g++.dg/opt/pr71100.C

new file mode 100644 (file)

index 0000000..ff739e2
--- /dev/null
+++ b/gcc/testsuite/g++.dg/opt/pr71100.C
@@ -0,0 +1,18 @@
+// PR c++/71100
+// { dg-do compile }
+// { dg-options "-O2" }
+
+struct D { ~D (); };
+struct E { D foo () { throw 1; } };
+
+inline void
+bar (D (E::*f) (), E *o)
+{
+  (o->*f) ();
+}
+
+void
+baz (E *o)
+{
+  bar (&E::foo, o);
+}
diff --git a/gcc/testsuite/g++.dg/opt/pr71210-1.C b/gcc/testsuite/g++.dg/opt/pr71210-1.C

new file mode 100644 (file)

index 0000000..03b1fb5
--- /dev/null
+++ b/gcc/testsuite/g++.dg/opt/pr71210-1.C
@@ -0,0 +1,14 @@
+// PR c++/71210
+// { dg-do compile }
+// { dg-options "-O2" }
+
+#include <typeinfo>
+
+void f1 (const std::type_info&) __attribute__((noreturn));
+struct S1 { ~S1 (); };
+struct S2
+{
+  virtual S1 f2 () const { f1 (typeid (*this)); }
+  S1 f3 () const { return f2 (); }
+};
+void f4 () { S2 a; a.f3 (); }
diff --git a/gcc/testsuite/g++.dg/opt/pr71210-2.C b/gcc/testsuite/g++.dg/opt/pr71210-2.C

new file mode 100644 (file)

index 0000000..02a31bd
--- /dev/null
+++ b/gcc/testsuite/g++.dg/opt/pr71210-2.C
@@ -0,0 +1,23 @@
+// PR c++/71210
+// { dg-do compile }
+// { dg-options "-O2" }
+
+struct C { int a; int b; C (); ~C (); };
+
+namespace
+{
+  struct A
+  {
+    A () {}
+    virtual C bar (int) = 0;
+    C baz (int x) { return bar (x); }
+  };
+}
+
+A *a;
+
+void
+foo ()
+{
+  C c = a->baz (0);
+}
diff --git a/gcc/testsuite/g++.dg/opt/pr71387.C b/gcc/testsuite/g++.dg/opt/pr71387.C

new file mode 100644 (file)

index 0000000..56f4a4d
--- /dev/null
+++ b/gcc/testsuite/g++.dg/opt/pr71387.C
@@ -0,0 +1,52 @@
+// PR middle-end/71387
+// { dg-do compile }
+// { dg-options "-Og" }
+
+struct A
+{
+  A ();
+  inline A (const A &);
+};
+
+struct B
+{
+  explicit B (unsigned long) : b(0), c(1) {}
+  A a;
+  unsigned long b;
+  int c;
+};
+
+struct C {};
+
+struct D
+{
+  explicit D (const C *) {}
+};
+
+struct E : public D
+{
+  E (const C *x) : D(x) {}
+  virtual A foo () const = 0;
+  virtual A bar () const = 0;
+};
+
+struct F : public B
+{
+  inline void baz ();
+  F (const E *);
+  const E *f;
+};
+
+inline void
+F::baz ()
+{
+  if (b == 0)
+    a = f->bar ();
+  else
+    a = f->foo ();
+}
+
+F::F (const E *) : B(4)
+{
+  baz ();
+}
diff --git a/gcc/testsuite/g++.dg/other/i386-10.C b/gcc/testsuite/g++.dg/other/i386-10.C

new file mode 100644 (file)

index 0000000..96def72
--- /dev/null
+++ b/gcc/testsuite/g++.dg/other/i386-10.C
@@ -0,0 +1,12 @@
+// { dg-do compile { target i?86-*-* x86_64-*-* } }
+// { dg-options -maes }
+
+typedef long long __m128i __attribute__ ((__vector_size__ (16), __may_alias__));
+
+int main()
+{
+    const char index = 1;
+    __m128i r = { };
+
+    r = __builtin_ia32_aeskeygenassist128 (r, (int)(index));
+}
diff --git a/gcc/testsuite/g++.dg/pr71184.C b/gcc/testsuite/g++.dg/pr71184.C

new file mode 100644 (file)

index 0000000..452303e
--- /dev/null
+++ b/gcc/testsuite/g++.dg/pr71184.C
@@ -0,0 +1 @@
+operator new[ // { dg-error "expected type-specifier before 'new'" }
diff --git a/gcc/testsuite/g++.dg/pr71389.C b/gcc/testsuite/g++.dg/pr71389.C

new file mode 100644 (file)

index 0000000..023abe1
--- /dev/null
+++ b/gcc/testsuite/g++.dg/pr71389.C
@@ -0,0 +1,23 @@
+// { dg-do compile { target i?86-*-* x86_64-*-* } }
+// { dg-options "-std=c++11 -O3 -march=ivybridge" }
+
+#include <functional>
+
+extern int le_s6, le_s9, le_s11;
+long foo_v14[16][16];
+
+void fn1() {
+  std::array<std::array<int, 16>, 16> v13;
+  for (; le_s6;)
+    for (int k1 = 2; k1 < 4; k1 = k1 + 1) {
+      for (int n1 = 0; n1 < le_s9; n1 = 8) {
+        *foo_v14[6] = 20923310;
+        for (int i2 = n1; i2 < n1 + 8; i2 = i2 + 1)
+          v13.at(5).at(i2 + 6 - n1) = 306146921;
+      }
+
+      for (int l2 = 0; l2 < le_s11; l2 = l2 + 1)
+          *(l2 + v13.at(5).begin()) = 306146921;
+    }
+  v13.at(le_s6 - 4);
+}
diff --git a/gcc/testsuite/g++.dg/template/friend62.C b/gcc/testsuite/g++.dg/template/friend62.C

new file mode 100644 (file)

index 0000000..c9796c4
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/friend62.C
@@ -0,0 +1,16 @@
+// PR c++/71227
+// { dg-options "" }
+
+class A {
+  public:
+    template<typename T>
+      friend int f(int x, T v) { // { dg-message "declaration" }
+        return x + v;
+      }
+};
+
+
+template<>
+int f(int x, int v) {          // { dg-warning "friend" }
+  return x + v;
+}
diff --git a/gcc/testsuite/g++.dg/template/pr70466-1.C b/gcc/testsuite/g++.dg/template/pr70466-1.C

new file mode 100644 (file)

index 0000000..7eb83ea
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/pr70466-1.C
@@ -0,0 +1,27 @@
+// PR c++/70466
+
+template < class T, class T >  // { dg-error "conflicting" }
+class A
+{
+public:
+  explicit A (T (S::*f) ()) {}  // { dg-error "expected" }
+};
+
+template < class T, class S > 
+A < T, S > foo (T (S::*f) ())
+{
+  return A < T, S > (f);
+}
+
+class B
+{
+public:
+  void bar () {}
+};
+
+int
+main ()
+{
+  foo (&B::bar);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/template/pr70466-2.C b/gcc/testsuite/g++.dg/template/pr70466-2.C

new file mode 100644 (file)

index 0000000..7a7458a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/template/pr70466-2.C
@@ -0,0 +1,25 @@
+// PR c++/70466
+
+template < class T, class S >
+struct A
+{
+  explicit A (...) {}
+};
+
+template < class T, class S >
+A < T, S > foo (T (S::*f) ())
+{
+  return A < T, S > (f);
+}
+
+struct B
+{
+  void bar () {}
+};
+
+int
+main ()
+{
+  foo (&B::bar);
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/torture/pr71002.C b/gcc/testsuite/g++.dg/torture/pr71002.C

new file mode 100644 (file)

index 0000000..8a72680
--- /dev/null
+++ b/gcc/testsuite/g++.dg/torture/pr71002.C
@@ -0,0 +1,160 @@
+// { dg-do run }
+
+using size_t = __SIZE_TYPE__;
+
+inline void* operator new(size_t, void* p) noexcept
+{ return p; }
+
+inline void operator delete(void*, void*)
+{ }
+
+struct long_t
+{
+  size_t is_short : 1;
+  size_t length   : (__SIZEOF_SIZE_T__ * __CHAR_BIT__ - 1);
+  size_t capacity;
+  char* pointer;
+};
+
+union long_raw_t {
+  unsigned char data[sizeof(long_t)];
+  struct __attribute__((aligned(alignof(long_t)))) { } align;
+};
+
+struct short_header
+{
+  unsigned char is_short : 1;
+  unsigned char length   : (__CHAR_BIT__ - 1);
+};
+
+struct short_t
+{
+  short_header h;
+  char data[23];
+};
+
+union repr_t
+{
+  long_raw_t  r;
+  short_t     s;
+
+  const short_t& short_repr() const
+  { return s; }
+
+  const long_t& long_repr() const
+  { return *static_cast<const long_t*>(static_cast<const void*>(&r)); }
+
+  short_t& short_repr()
+  { return s;  }
+
+  long_t& long_repr()
+  { return *static_cast<long_t*>(static_cast<void*>(&r)); }
+};
+
+class string
+{
+public:
+  string()
+  {
+    short_t& s = m_repr.short_repr();
+    s.h.is_short = 1;
+    s.h.length = 0;
+    s.data[0] = '\0';
+  }
+
+  string(const char* str)
+  {
+    size_t length = __builtin_strlen(str);
+    if (length + 1 > 23) {
+      long_t& l = m_repr.long_repr();
+      l.is_short = 0;
+      l.length = length;
+      l.capacity = length + 1;
+      l.pointer = new char[l.capacity];
+      __builtin_memcpy(l.pointer, str, length + 1);
+    } else {
+      short_t& s = m_repr.short_repr();
+      s.h.is_short = 1;
+      s.h.length = length;
+      __builtin_memcpy(s.data, str, length + 1);
+    }
+  }
+
+  string(string&& other)
+    : string{}
+  {
+    swap_data(other);
+  }
+
+  ~string()
+  {
+    if (!is_short()) {
+      delete[] m_repr.long_repr().pointer;
+    }
+  }
+
+  size_t length() const
+  { return is_short() ? short_length() : long_length(); }
+
+private:
+  bool is_short() const
+  { return m_repr.s.h.is_short != 0; }
+
+  size_t short_length() const
+  { return m_repr.short_repr().h.length; }
+
+  size_t long_length() const
+  { return m_repr.long_repr().length; }
+
+  void swap_data(string& other)
+  {
+    if (is_short()) {
+      if (other.is_short()) {
+        repr_t tmp(m_repr);
+        m_repr = other.m_repr;
+        other.m_repr = tmp;
+      } else {
+        short_t short_backup(m_repr.short_repr());
+        m_repr.short_repr().~short_t();
+        ::new(&m_repr.long_repr()) long_t(other.m_repr.long_repr());
+        other.m_repr.long_repr().~long_t();
+        ::new(&other.m_repr.short_repr()) short_t(short_backup);
+      }
+    } else {
+      if (other.is_short()) {
+        short_t short_backup(other.m_repr.short_repr());
+        other.m_repr.short_repr().~short_t();
+        ::new(&other.m_repr.long_repr()) long_t(m_repr.long_repr());
+        m_repr.long_repr().~long_t();
+        ::new(&m_repr.short_repr()) short_t(short_backup);
+      } else {
+        long_t tmp(m_repr.long_repr());
+        m_repr.long_repr() = other.m_repr.long_repr();
+        other.m_repr.long_repr() = tmp;
+      }
+    }
+  }
+
+  repr_t m_repr;
+};
+
+struct foo
+{
+  __attribute__((noinline))
+  foo(string str)
+    : m_str{static_cast<string&&>(str)},
+      m_len{m_str.length()}
+  { }
+
+  string m_str;
+  size_t m_len;
+};
+
+int main()
+{
+  foo f{"the quick brown fox jumps over the lazy dog"};
+  if (f.m_len == 0) {
+    __builtin_abort();
+  }
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/torture/pr71405.C b/gcc/testsuite/g++.dg/torture/pr71405.C

new file mode 100644 (file)

index 0000000..5260243
--- /dev/null
+++ b/gcc/testsuite/g++.dg/torture/pr71405.C
@@ -0,0 +1,22 @@
+// PR tree-optimization/71405
+// { dg-do compile }
+
+struct C
+{
+  C () {}
+  int i;
+};
+
+void *
+operator new (__SIZE_TYPE__ x, void *y)
+{
+  return y;
+}
+
+int
+main ()
+{
+  int a;
+  new (&a) C;
+  return a; 
+}
diff --git a/gcc/testsuite/g++.dg/torture/pr71448.C b/gcc/testsuite/g++.dg/torture/pr71448.C

new file mode 100644 (file)

index 0000000..ca00ca8
--- /dev/null
+++ b/gcc/testsuite/g++.dg/torture/pr71448.C
@@ -0,0 +1,27 @@
+// PR c++/71448
+// { dg-do compile }
+// { dg-additional-options "-std=c++11" }
+
+static constexpr const char foo[] = "foo";
+static constexpr const char *bar = "bar";
+
+static_assert ((foo + 3 - foo) == 3, "check");
+static_assert (foo + 2 != foo, "check");
+static_assert (foo + 2 >= foo, "check");
+static_assert (3 + foo >= foo, "check");
+static_assert (foo <= foo + 2, "check");
+static_assert (foo <= 3 + foo, "check");
+static_assert (foo + 2 > foo, "check");
+static_assert (3 + foo > foo, "check");
+static_assert (foo < 2 + foo, "check");
+static_assert (foo < foo + 3, "check");
+static_assert ((bar + 3 - bar) == 3, "check");
+static_assert (bar + 2 != bar, "check");
+static_assert (2 + bar >= bar, "check");
+static_assert (bar + 3 >= bar, "check");
+static_assert (bar <= bar + 2, "check");
+static_assert (bar <= 3 + bar, "check");
+static_assert (bar + 2 > bar, "check");
+static_assert (3 + bar > bar, "check");
+static_assert (bar < 2 + bar, "check");
+static_assert (bar < bar + 3, "check");
diff --git a/gcc/testsuite/g++.dg/ubsan/pr70847.C b/gcc/testsuite/g++.dg/ubsan/pr70847.C

new file mode 100644 (file)

index 0000000..2b54353
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ubsan/pr70847.C
@@ -0,0 +1,11 @@
+// PR c++/70847
+// { dg-do compile }
+
+struct D { virtual D& f(); };
+
+void
+g()
+{
+  D d;
+  d.f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f().f();
+}
diff --git a/gcc/testsuite/g++.dg/ubsan/pr71393.C b/gcc/testsuite/g++.dg/ubsan/pr71393.C

new file mode 100644 (file)

index 0000000..6011e3a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/ubsan/pr71393.C
@@ -0,0 +1,14 @@
+// PR c++/71393
+// { dg-do compile }
+// { dg-options "-fsanitize=undefined" }
+
+struct B { B &operator << (long); };
+struct A { A (); long a, b, c, d, e, f; };
+
+A::A ()
+{
+  B q;
+  q << 0 << a << 0 << b << 0 << (b / a) << 0 << c << 0 << (c / a) << 0
+    << d << 0 << (d / a) << 0 << e << 0 << (e / a) << 0 << f << 0
+    << (f / a) << 0;
+}
diff --git a/gcc/testsuite/g++.dg/vect/simd-clone-6.cc b/gcc/testsuite/g++.dg/vect/simd-clone-6.cc

new file mode 100644 (file)

index 0000000..fb00e88
--- /dev/null
+++ b/gcc/testsuite/g++.dg/vect/simd-clone-6.cc
@@ -0,0 +1,43 @@
+// PR c++/71257
+// { dg-require-effective-target vect_simd_clones }
+// { dg-additional-options "-fopenmp-simd -fno-inline" }
+// { dg-additional-options "-mavx" { target avx_runtime } }
+
+#include "../../gcc.dg/vect/tree-vect.h"
+
+#define N 1024
+struct S { int a; };
+int c[N], e[N], f[N];
+S d[N];
+
+#pragma omp declare simd linear(ref(b, c) : 1)
+int
+foo (int a, S &b, int &c)
+{
+  return a + b.a + c;
+}
+
+void
+do_main ()
+{
+  int i;
+  for (i = 0; i < N; i++)
+    {
+      c[i] = i;
+      d[i].a = 2 * i;
+      f[i] = 3 * i;
+    }
+  #pragma omp simd
+  for (i = 0; i < N; i++)
+    e[i] = foo (c[i], d[i], f[i]);
+  for (i = 0; i < N; i++)
+    if (e[i] != 6 * i)
+      __builtin_abort ();
+}
+
+int
+main ()
+{
+  check_vect ();
+  return 0;
+}
diff --git a/gcc/testsuite/g++.dg/warn/Wno-narrowing1.C b/gcc/testsuite/g++.dg/warn/Wno-narrowing1.C

new file mode 100644 (file)

index 0000000..285f05a
--- /dev/null
+++ b/gcc/testsuite/g++.dg/warn/Wno-narrowing1.C
@@ -0,0 +1,7 @@
+// PR c++/69872
+// { dg-options "-Wall -Wextra -pedantic -Wno-narrowing" }
+
+struct s { int x, y; };
+short offsets[1] = {
+  ((char*) &(((struct s*)16)->y) - (char *)16),  // { dg-bogus "note" }
+};
diff --git a/gcc/testsuite/g++.dg/warn/Wplacement-new-size-3.C b/gcc/testsuite/g++.dg/warn/Wplacement-new-size-3.C

new file mode 100644 (file)

index 0000000..c93e4e6
--- /dev/null
+++ b/gcc/testsuite/g++.dg/warn/Wplacement-new-size-3.C
@@ -0,0 +1,40 @@
+// PR c++/71306 - bogus -Wplacement-new with an array element
+// { dg-do compile }
+// { dg-options "-Wplacement-new" }
+
+void* operator new (__SIZE_TYPE__, void *p) { return p; }
+
+struct S64 { char c [64]; };
+
+S64 s2 [2];
+S64* ps2 [2];
+S64* ps2_2 [2][2];
+
+void* pv2 [2];
+
+void f ()
+{
+  char a [2][sizeof (S64)];
+
+  new (a) S64;
+  new (a [0]) S64;
+  new (a [1]) S64;
+
+  // Verify there is no warning with buffers of sufficient size.
+  new (&s2 [0]) S64;
+  new (&s2 [1]) S64;
+
+  // ..and no warning with pointers to buffers of unknown size.
+  new (ps2 [0]) S64;
+  new (ps2 [1]) S64;
+
+  // But a warning when using the ps2_2 array itself as opposed
+  // to the pointers it's elements might point to.
+  new (ps2_2 [0]) S64; // { dg-warning "placement new" }
+  new (ps2_2 [1]) S64; // { dg-warning "placement new" }
+
+  // ..and no warning again with pointers to buffers of unknown
+  // size.
+  new (pv2 [0]) S64;
+  new (pv2 [1]) S64;
+}
diff --git a/gcc/testsuite/gcc.c-torture/compile/pr70916.c b/gcc/testsuite/gcc.c-torture/compile/pr70916.c

new file mode 100644 (file)

index 0000000..c3ea69f
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/compile/pr70916.c
@@ -0,0 +1,28 @@
+/* PR tree-optimization/70916 */
+
+int a, b, c, d, i, k;
+int static *e = &b, *j;
+int **f;
+int static ***g = &f;
+int *h;
+void
+fn1 ()
+{
+  for (;;)
+    {
+      int l[1] = { };
+      int m = (__UINTPTR_TYPE__) l;
+      for (; d; d--)
+       {
+         int ****n;
+         int *****o = &n;
+         i = a & 7 ? : a;
+         *e = (((*o = &g) != (int ****) g) < h[c], 0) || k;
+         if (*e)
+           {
+             **n = &j;
+             *e = (__UINTPTR_TYPE__) h;
+           }
+       }
+    }
+}
diff --git a/gcc/testsuite/gcc.c-torture/execute/pr71494.c b/gcc/testsuite/gcc.c-torture/execute/pr71494.c

new file mode 100644 (file)

index 0000000..f962f2c
--- /dev/null
+++ b/gcc/testsuite/gcc.c-torture/execute/pr71494.c
@@ -0,0 +1,22 @@
+/* PR middle-end/71494 */
+
+int
+main ()
+{
+  void *label = &&out;
+  int i = 0;
+  void test (void)
+  {
+    label = &&out2;
+    goto *label;
+   out2:;
+    i++;
+  }
+  goto *label;
+ out:
+  i += 2;
+  test ();
+  if (i != 3)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/goacc/nested-function-1.c b/gcc/testsuite/gcc.dg/goacc/nested-function-1.c

new file mode 100644 (file)

index 0000000..e17c0e2
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/goacc/nested-function-1.c
@@ -0,0 +1,100 @@
+/* Exercise nested function decomposition, gcc/tree-nested.c.  */
+/* See gcc/testsuite/gfortran.dg/goacc/nested-function-1.f90 for the Fortran
+   version.  */
+
+int main ()
+{
+#define N 100
+  int nonlocal_arg;
+  int nonlocal_a[N];
+  int nonlocal_i;
+  int nonlocal_j;
+
+  for (int i = 0; i < N; ++i)
+    nonlocal_a[i] = 5;
+  nonlocal_arg = 5;
+
+  void local ()
+  {
+    int local_i;
+    int local_arg;
+    int local_a[N];
+    int local_j;
+
+    for (int i = 0; i < N; ++i)
+      local_a[i] = 5;
+    local_arg = 5;
+
+#pragma acc kernels loop \
+  gang(num:local_arg) worker(local_arg) vector(local_arg) \
+  wait async(local_arg)
+    for (local_i = 0; local_i < N; ++local_i)
+      {
+#pragma acc cache (local_a[local_i:5])
+       local_a[local_i] = 100;
+#pragma acc loop seq tile(*)
+       for (local_j = 0; local_j < N; ++local_j)
+         ;
+#pragma acc loop auto independent tile(1)
+       for (local_j = 0; local_j < N; ++local_j)
+         ;
+      }
+
+#pragma acc kernels loop \
+  gang(static:local_arg) worker(local_arg) vector(local_arg) \
+  wait(local_arg, local_arg + 1, local_arg + 2) async
+    for (local_i = 0; local_i < N; ++local_i)
+      {
+#pragma acc cache (local_a[local_i:4])
+       local_a[local_i] = 100;
+#pragma acc loop seq tile(1)
+       for (local_j = 0; local_j < N; ++local_j)
+         ;
+#pragma acc loop auto independent tile(*)
+       for (local_j = 0; local_j < N; ++local_j)
+         ;
+      }
+  }
+
+  void nonlocal ()
+  {
+    for (int i = 0; i < N; ++i)
+      nonlocal_a[i] = 5;
+    nonlocal_arg = 5;
+
+#pragma acc kernels loop \
+  gang(num:nonlocal_arg) worker(nonlocal_arg) vector(nonlocal_arg) \
+  wait async(nonlocal_arg)
+    for (nonlocal_i = 0; nonlocal_i < N; ++nonlocal_i)
+      {
+#pragma acc cache (nonlocal_a[nonlocal_i:3])
+       nonlocal_a[nonlocal_i] = 100;
+#pragma acc loop seq tile(2)
+       for (nonlocal_j = 0; nonlocal_j < N; ++nonlocal_j)
+         ;
+#pragma acc loop auto independent tile(3)
+       for (nonlocal_j = 0; nonlocal_j < N; ++nonlocal_j)
+         ;
+      }
+
+#pragma acc kernels loop \
+  gang(static:nonlocal_arg) worker(nonlocal_arg) vector(nonlocal_arg) \
+  wait(nonlocal_arg, nonlocal_arg + 1, nonlocal_arg + 2) async
+    for (nonlocal_i = 0; nonlocal_i < N; ++nonlocal_i)
+      {
+#pragma acc cache (nonlocal_a[nonlocal_i:2])
+       nonlocal_a[nonlocal_i] = 100;
+#pragma acc loop seq tile(*)
+       for (nonlocal_j = 0; nonlocal_j < N; ++nonlocal_j)
+         ;
+#pragma acc loop auto independent tile(*)
+       for (nonlocal_j = 0; nonlocal_j < N; ++nonlocal_j)
+         ;
+      }
+  }
+
+  local ();
+  nonlocal ();
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/goacc/nested-function-2.c b/gcc/testsuite/gcc.dg/goacc/nested-function-2.c

new file mode 100644 (file)

index 0000000..70c9ec8
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/goacc/nested-function-2.c
@@ -0,0 +1,45 @@
+/* Exercise nested function decomposition, gcc/tree-nested.c.  */
+
+int
+main (void)
+{
+  int j = 0, k = 6, l = 7, m = 8;
+  void simple (void)
+  {
+    int i;
+#pragma acc parallel
+    {
+#pragma acc loop
+      for (i = 0; i < m; i+= k)
+       j = (m + i - j) * l;
+    }
+  }
+  void collapse (void)
+  {
+    int x, y, z;
+#pragma acc parallel
+    {
+#pragma acc loop collapse (3)
+      for (x = 0; x < k; x++)
+       for (y = -5; y < l; y++)
+         for (z = 0; z < m; z++)
+           j += x + y + z;
+    }
+  }
+  void reduction (void)
+  {
+    int x, y, z;
+#pragma acc parallel reduction (+:j)
+    {
+#pragma acc loop reduction (+:j) collapse (3)
+      for (x = 0; x < k; x++)
+       for (y = -5; y < l; y++)
+         for (z = 0; z < m; z++)
+           j += x + y + z;
+    }
+  }
+  simple();
+  collapse();
+  reduction();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/goacc/pr71373.c b/gcc/testsuite/gcc.dg/goacc/pr71373.c

new file mode 100644 (file)

index 0000000..9381752
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/goacc/pr71373.c
@@ -0,0 +1,41 @@
+/* Unintentional nested function usage.  */
+/* Due to missing right braces '}', the following functions are parsed as
+   nested functions.  This ran into an ICE.  */
+
+void foo (void)
+{
+  #pragma acc parallel
+  {
+    #pragma acc loop independent
+    for (int i = 0; i < 16; i++)
+      ;
+  // Note right brace '}' commented out here.
+  //}
+}
+void bar (void)
+{
+}
+
+// Adding right brace '}' here, to make this compile.
+}
+
+
+// ..., and the other way round:
+
+void BAR (void)
+{
+// Note right brace '}' commented out here.
+//}
+
+void FOO (void)
+{
+  #pragma acc parallel
+  {
+    #pragma acc loop independent
+    for (int i = 0; i < 16; i++)
+      ;
+  }
+}
+
+// Adding right brace '}' here, to make this compile.
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr69067.c b/gcc/testsuite/gcc.dg/graphite/pr69067.c

new file mode 100644 (file)

index 0000000..145ac82
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr69067.c
@@ -0,0 +1,28 @@
+/* { dg-do link } */
+/* { dg-options " -O1 -floop-nest-optimize" } */
+/* { dg-additional-options "-flto" { target lto } } */
+
+int a1, c1, cr, kt;
+int aa[2];
+
+int
+ce (void)
+{
+  while (a1 < 1)
+    {
+      int g8;
+      for (g8 = 0; g8 < 3; ++g8)
+       if (c1 != 0)
+         cr = aa[a1 * 2] = kt;
+      for (c1 = 0; c1 < 2; ++c1)
+       aa[c1] = cr;
+      ++a1;
+    }
+  return 0;
+}
+
+int
+main (void)
+{
+  return ce ();
+}
diff --git a/gcc/testsuite/gcc.dg/graphite/pr69068.c b/gcc/testsuite/gcc.dg/graphite/pr69068.c

new file mode 100644 (file)

index 0000000..0abea06
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/graphite/pr69068.c
@@ -0,0 +1,14 @@
+/* { dg-do compile } */
+/* { dg-options "-O1 -fgraphite-identity" } */
+
+int qo;
+int zh[2];
+
+void
+td (void)
+{
+  int ly, en;
+  for (ly = 0; ly < 2; ++ly)
+    for (en = 0; en < 2; ++en)
+      zh[en] = ((qo == 0) || (((qo * 2) != 0))) ? 1 : -1;
+}
diff --git a/gcc/testsuite/gcc.dg/ipa/pr70646.c b/gcc/testsuite/gcc.dg/ipa/pr70646.c

new file mode 100644 (file)

index 0000000..f85816e
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/ipa/pr70646.c
@@ -0,0 +1,40 @@
+/* { dg-do run } */
+/* { dg-options "-O2" } */
+
+#pragma GCC optimize("no-unit-at-a-time")
+
+typedef unsigned char u8;
+typedef unsigned long long u64;
+
+static inline __attribute__((always_inline)) u64 __swab64p(const u64 *p)
+{
+ return (__builtin_constant_p((u64)(*p)) ? ((u64)( (((u64)(*p) & (u64)0x00000000000000ffULL) << 56) | (((u64)(*p) & (u64)0x000000000000ff00ULL) << 40) | (((u64)(*p) & (u64)0x0000000000ff0000ULL) << 24) | (((u64)(*p) & (u64)0x00000000ff000000ULL) << 8) | (((u64)(*p) & (u64)0x000000ff00000000ULL) >> 8) | (((u64)(*p) & (u64)0x0000ff0000000000ULL) >> 24) | (((u64)(*p) & (u64)0x00ff000000000000ULL) >> 40) | (((u64)(*p) & (u64)0xff00000000000000ULL) >> 56))) : __builtin_bswap64(*p));
+}
+
+static inline u64 wwn_to_u64(void *wwn)
+{
+ return __swab64p(wwn);
+}
+
+void __attribute__((noinline,noclone)) broken(u64* shost)
+{
+ u8 node_name[8] = { 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF, 0xFF};
+ *shost = wwn_to_u64(node_name);
+}
+
+void __attribute__((noinline,noclone)) dummy(void)
+{
+ __builtin_abort();
+}
+
+int main(int argc, char* argv[])
+{
+ u64 v;
+
+ broken(&v);
+
+ if(v != (u64)-1)
+  __builtin_abort();
+
+ return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/pr71006.c b/gcc/testsuite/gcc.dg/pr71006.c

new file mode 100644 (file)

index 0000000..2b45aa0
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr71006.c
@@ -0,0 +1,16 @@
+/* PR target/71006 */
+/* { dg-do compile } */
+/* { dg-options "-O1 -ftree-vectorize" } */
+
+unsigned char uu, gu, e2;
+
+void
+fs (void)
+{
+  char *nq = (char *)&gu, *k4 = (char *)&gu;
+  while (*k4 < 1)
+    {
+      uu += (*nq != 0 || e2 != 0);
+      ++*k4;
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/pr71071.c b/gcc/testsuite/gcc.dg/pr71071.c

new file mode 100644 (file)

index 0000000..582f1f1
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr71071.c
@@ -0,0 +1,12 @@
+/* PR bootstrap/71071 */
+/* { dg-do compile } *
+/* { dg-options "-O2" } */
+
+struct S { unsigned b : 1; } a;
+
+void
+foo ()
+{
+  if (a.b)
+    ;
+}
diff --git a/gcc/testsuite/gcc.dg/pr71279.c b/gcc/testsuite/gcc.dg/pr71279.c

new file mode 100644 (file)

index 0000000..4ecc84b
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/pr71279.c
@@ -0,0 +1,14 @@
+/* PR middle-end/71279 */
+/* { dg-do compile } */
+/* { dg-options "-O3" } */
+/* { dg-additional-options "-march=knl" { target { i?86-*-* x86_64-*-* } } } */
+
+extern int a, b;
+long c[1][1][1];
+long d[1][1];
+
+void fn1 ()
+{
+  for (int e = 0; e < b; e = e + 1)
+    *(e + **c) = (a && *d[1]) - 1;
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr70935.c b/gcc/testsuite/gcc.dg/torture/pr70935.c

new file mode 100644 (file)

index 0000000..eb7f034
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr70935.c
@@ -0,0 +1,39 @@
+/* { dg-do compile } */\r
+/* { dg-options "-O3 -g" } */\r
+\r
+int d0, sj, v0, rp, zi;\r
+\r
+void\r
+zn(void)\r
+{\r
+  if (v0 != 0)\r
+    {\r
+      int *js, *r3;\r
+      int pm, gc;\r
+\r
+      for (gc = 0; gc < 1; ++gc)\r
+        {\r
+          sj = 1;\r
+          while (sj != 0)\r
+            ;\r
+        }\r
+      r3 = &pm;\r
+      *js = (long)&gc;\r
+ka:\r
+      for (d0 = 0; d0 < 2; ++d0)\r
+        {\r
+          d0 = zi;\r
+          if (zi)\r
+            for (pm = 2; pm != 0; --pm)\r
+              ;\r
+        }\r
+      while (*r3 != 0)\r
+        {\r
+          while (pm)\r
+            ;\r
+          ++r3;\r
+        }\r
+    }\r
+  rp = 0;\r
+  goto ka;\r
+}
diff --git a/gcc/testsuite/gcc.dg/torture/pr70941.c b/gcc/testsuite/gcc.dg/torture/pr70941.c

new file mode 100644 (file)

index 0000000..eb37a1f
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/torture/pr70941.c
@@ -0,0 +1,12 @@
+/* { dg-do run } */
+/* { dg-require-effective-target int32plus } */
+
+signed char a = 0, b = 0, c = 0, d = 0;
+
+int main()
+{
+  a = -(b - 405418259) - ((d && c) ^ 2040097152);
+  if (a != (signed char) -1634678893)
+    __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/pr70919.c b/gcc/testsuite/gcc.dg/tree-ssa/pr70919.c

new file mode 100644 (file)

index 0000000..bed0ab3
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/pr70919.c
@@ -0,0 +1,46 @@
+/* { dg-do run } */
+/* { dg-options "-O" } */
+
+#pragma pack(1)
+struct S0
+{
+  int f0:24;
+};
+
+struct S1
+{
+  int f1;
+} a;
+
+int b, c;
+
+char
+fn1 (struct S1 p1)
+{
+  return 0;
+}
+
+int
+main ()
+{
+  c = fn1 (a);
+  if (b)
+    {
+      struct S0 f[3][9] =
+       { { { 0 }, { 0 }, { 1 }, { 1 }, { 0 }, { 0 }, { 0 }, { 1 }, { 1 } },
+         { { 0 }, { 0 }, { 1 }, { 1 }, { 0 }, { 0 }, { 0 }, { 1 }, { 1 } },
+         { { 0 }, { 0 }, { 1 }, { 1 }, { 0 }, { 0 }, { 0 }, { 1 }, { 1 } }
+       };
+      b = f[1][8].f0;
+    }
+  struct S0 g[3][9] =
+       { { { 0 }, { 0 }, { 1 }, { 1 }, { 0 }, { 0 }, { 0 }, { 1 }, { 1 } },
+         { { 0 }, { 0 }, { 1 }, { 1 }, { 0 }, { 0 }, { 0 }, { 1 }, { 1 } },
+         { { 0 }, { 0 }, { 1 }, { 1 }, { 0 }, { 0 }, { 0 }, { 1 }, { 1 } }
+       };
+
+  if (g[1][8].f0 != 1)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp100.c b/gcc/testsuite/gcc.dg/tree-ssa/vrp100.c

new file mode 100644 (file)

index 0000000..c0fe4b5
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp100.c
@@ -0,0 +1,32 @@
+/* PR tree-optimization/71031 */
+/* { dg-do compile } */
+/* { dg-options "-Os" } */
+
+int zj;
+int **yr;
+
+void
+nn (void)
+{
+  unsigned int od = 4;
+
+  for (;;)
+    {
+      int lk;
+
+      for (lk = 0; lk < 2; ++lk)
+        {
+          static int cm;
+
+          zj = 0;
+          if (od == 0)
+            return;
+          ++od;
+          for (cm = 0; cm < 2; ++cm)
+            {
+              --od;
+              **yr = 0;
+            }
+        }
+    }
+}
diff --git a/gcc/testsuite/gcc.dg/vect/pr66636.c b/gcc/testsuite/gcc.dg/vect/pr66636.c

index 7e6e5f6..c0733ff 100644 (file)
--- a/gcc/testsuite/gcc.dg/vect/pr66636.c
+++ b/gcc/testsuite/gcc.dg/vect/pr66636.c
@@ -6,7 +6,8 @@ extern void abort (void);
  
  struct X { double x; double y; };
  
-void foo (struct X *x, double px, int s)
+void __attribute__((noinline,noclone))
+foo (struct X *x, double px, int s)
  {
    int i;
    for (i = 0; i < 256; ++i)
diff --git a/gcc/testsuite/gcc.dg/vect/pr71259.c b/gcc/testsuite/gcc.dg/vect/pr71259.c

new file mode 100644 (file)

index 0000000..eefa243
--- /dev/null
+++ b/gcc/testsuite/gcc.dg/vect/pr71259.c
@@ -0,0 +1,28 @@
+/* PR tree-optimization/71259 */
+/* { dg-do run } */
+/* { dg-options "-O3" } */
+/* { dg-additional-options "-mavx" { target avx_runtime } } */
+
+#include "tree-vect.h"
+
+long a, b[1][44][2];
+long long c[44][17][2];
+
+int
+main ()
+{
+  int i, j, k;
+  check_vect ();
+  asm volatile ("" : : : "memory");
+  for (i = 0; i < 44; i++)
+    for (j = 0; j < 17; j++)
+      for (k = 0; k < 2; k++)
+       c[i][j][k] = (30995740 >= *(k + *(j + *b)) != (a != 8)) - 5105075050047261684;
+  asm volatile ("" : : : "memory");
+  for (i = 0; i < 44; i++) 
+    for (j = 0; j < 17; j++)
+      for (k = 0; k < 2; k++)
+       if (c[i][j][k] != -5105075050047261684)
+         __builtin_abort ();
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.dg/vect/tree-vect.h b/gcc/testsuite/gcc.dg/vect/tree-vect.h

index 0853e3f..faf91d5 100644 (file)
--- a/gcc/testsuite/gcc.dg/vect/tree-vect.h
+++ b/gcc/testsuite/gcc.dg/vect/tree-vect.h
@@ -32,25 +32,26 @@ check_vect (void)
    asm volatile (".long 0x10000484");
  #elif defined(__i386__) || defined(__x86_64__)
    {
-    unsigned int a, b, c, d, want_level, want_c, want_d;
+    unsigned int a, b, c, d,
+      want_level, want_b = 0, want_c = 0, want_d = 0;
  
      /* Determine what instruction set we've been compiled for, and detect
         that we're running with it.  This allows us to at least do a compile
         check for, e.g. SSE4.1 when the machine only supports SSE2.  */
-# ifdef __XOP__
-    want_level = 0x80000001, want_c = bit_XOP, want_d = 0;
+# if defined(__AVX2__)
+    want_level = 7, want_b = bit_AVX2;
  # elif defined(__AVX__)
-    want_level = 1, want_c = bit_AVX, want_d = 0;
+    want_level = 1, want_c = bit_AVX;
  # elif defined(__SSE4_1__)
-    want_level = 1, want_c = bit_SSE4_1, want_d = 0;
+    want_level = 1, want_c = bit_SSE4_1;
  # elif defined(__SSSE3__)
-    want_level = 1, want_c = bit_SSSE3, want_d = 0;
+    want_level = 1, want_c = bit_SSSE3;
  # else
-    want_level = 1, want_c = 0, want_d = bit_SSE2;
+    want_level = 1, want_d = bit_SSE2;
  # endif
  
      if (!__get_cpuid (want_level, &a, &b, &c, &d)
-       || ((c & want_c) | (d & want_d)) == 0)
+       || ((b & want_b) | (c & want_c) | (d & want_d)) == 0)
        exit (0);
    }
  #elif defined(__sparc__)
diff --git a/gcc/testsuite/gcc.target/aarch64/noplt_3.c b/gcc/testsuite/gcc.target/aarch64/noplt_3.c

index ef6e65d..a382618 100644 (file)
--- a/gcc/testsuite/gcc.target/aarch64/noplt_3.c
+++ b/gcc/testsuite/gcc.target/aarch64/noplt_3.c
@@ -16,5 +16,5 @@ cal_novalue (int a)
    dec (a);
  }
  
-/* { dg-final { scan-assembler-times "br" 2 } } */
+/* { dg-final { scan-assembler-times "br\t" 2 } } */
  /* { dg-final { scan-assembler-not "b\t" } } */
diff --git a/gcc/testsuite/gcc.target/aarch64/pr70809_1.c b/gcc/testsuite/gcc.target/aarch64/pr70809_1.c

new file mode 100644 (file)

index 0000000..df88c71
--- /dev/null
+++ b/gcc/testsuite/gcc.target/aarch64/pr70809_1.c
@@ -0,0 +1,18 @@
+/* PR target/70809.  */
+/* { dg-do compile } */
+/* { dg-options "-O2 -ftree-vectorize -ffp-contract=off -mtune=xgene1" } */
+
+/* Check that vector FMLS is not generated when contraction is disabled.  */
+
+void
+foo (float *__restrict__ __attribute__ ((aligned (16))) a,
+     float *__restrict__ __attribute__ ((aligned (16))) x,
+     float *__restrict__ __attribute__ ((aligned (16))) y,
+     float *__restrict__ __attribute__ ((aligned (16))) z)
+{
+  unsigned i = 0;
+  for (i = 0; i < 256; i++)
+    a[i] = x[i] - (y[i] * z[i]);
+}
+
+/* { dg-final { scan-assembler-not "fmls\tv.*" } } */
diff --git a/gcc/testsuite/gcc.target/aarch64/tail_indirect_call_1.c b/gcc/testsuite/gcc.target/aarch64/tail_indirect_call_1.c

index 4759d20..de8f12d 100644 (file)
--- a/gcc/testsuite/gcc.target/aarch64/tail_indirect_call_1.c
+++ b/gcc/testsuite/gcc.target/aarch64/tail_indirect_call_1.c
@@ -3,8 +3,8 @@
  
  typedef void FP (int);
  
-/* { dg-final { scan-assembler "br" } } */
-/* { dg-final { scan-assembler-not "blr" } } */
+/* { dg-final { scan-assembler-times "br\t" 2 } } */
+/* { dg-final { scan-assembler-not "blr\t" } } */
  void
  f1 (FP fp, int n)
  {
diff --git a/gcc/testsuite/gcc.target/arm/interrupt-1.c b/gcc/testsuite/gcc.target/arm/interrupt-1.c

index debbaf7..fe94877 100644 (file)
--- a/gcc/testsuite/gcc.target/arm/interrupt-1.c
+++ b/gcc/testsuite/gcc.target/arm/interrupt-1.c
@@ -1,8 +1,8 @@
  /* Verify that prologue and epilogue are correct for functions with
     __attribute__ ((interrupt)).  */
-/* { dg-do compile } */
+/* { dg-do assemble } */
  /* { dg-require-effective-target arm_nothumb } */
-/* { dg-options "-O0 -marm" } */
+/* { dg-options "-O0 -marm -save-temps" } */
  
  /* This test is not valid when -mthumb.  */
  extern void bar (int);
@@ -14,4 +14,4 @@ void foo ()
  }
  
  /* { dg-final { scan-assembler "push\t{r0, r1, r2, r3, r4, fp, ip, lr}" } } */
-/* { dg-final { scan-assembler "pop\t{r0, r1, r2, r3, r4, fp, ip, pc}\\^" } } */
+/* { dg-final { scan-assembler "ldmfd\tsp!, {r0, r1, r2, r3, r4, fp, ip, pc}\\^" } } */
diff --git a/gcc/testsuite/gcc.target/arm/interrupt-2.c b/gcc/testsuite/gcc.target/arm/interrupt-2.c

index 92f8630..289eca0 100644 (file)
--- a/gcc/testsuite/gcc.target/arm/interrupt-2.c
+++ b/gcc/testsuite/gcc.target/arm/interrupt-2.c
@@ -1,8 +1,8 @@
  /* Verify that prologue and epilogue are correct for functions with
     __attribute__ ((interrupt)).  */
-/* { dg-do compile } */
+/* { dg-do assemble } */
  /* { dg-require-effective-target arm_nothumb } */
-/* { dg-options "-O1 -marm" } */
+/* { dg-options "-O1 -marm -save-temps" } */
  
  /* This test is not valid when -mthumb.  */
  extern void bar (int);
@@ -16,4 +16,4 @@ void test()
  }
  
  /* { dg-final { scan-assembler "push\t{r0, r1, r2, r3, r4, r5, ip, lr}" } } */
-/* { dg-final { scan-assembler "pop\t{r0, r1, r2, r3, r4, r5, ip, pc}\\^" } } */
+/* { dg-final { scan-assembler "ldmfd\tsp!, {r0, r1, r2, r3, r4, r5, ip, pc}\\^" } } */
diff --git a/gcc/testsuite/gcc.target/arm/pr70830.c b/gcc/testsuite/gcc.target/arm/pr70830.c

new file mode 100644 (file)

index 0000000..cad903b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pr70830.c
@@ -0,0 +1,14 @@
+/* PR target/70830.  */
+/* { dg-do assemble } */
+/* { dg-require-effective-target arm_arm_ok } */
+/* { dg-options "-Os -marm -save-temps" } */
+
+/* This test is not valid when -mthumb.  */
+
+extern void prints (char *);
+
+void __attribute__ ((interrupt ("IRQ"))) dm3730_IRQHandler(void)
+{
+    prints("IRQ" );
+}
+/* { dg-final { scan-assembler "ldmfd\tsp!, {r0, r1, r2, r3, ip, pc}\\^" } } */
diff --git a/gcc/testsuite/gcc.target/arm/pr71056.c b/gcc/testsuite/gcc.target/arm/pr71056.c

new file mode 100644 (file)

index 0000000..136754e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/arm/pr71056.c
@@ -0,0 +1,32 @@
+/* PR target/71056.  */
+/* { dg-do compile } */
+/* { dg-require-effective-target arm_vfp3_ok } */
+/* { dg-options "-O3 -mfpu=vfpv3" } */
+
+/* Check that compiling for a non-NEON target doesn't try to introduce
+   a NEON vectorized builtin.  */
+
+extern char *buff;
+int f2 ();
+struct T1
+{
+  int reserved[2];
+  unsigned int ip;
+  unsigned short cs;
+  unsigned short rsrv2;
+};
+void
+f3 (const char *p)
+{
+  struct T1 x;
+  __builtin_memcpy (&x, p, sizeof (struct T1));
+  x.reserved[0] = __builtin_bswap32 (x.reserved[0]);
+  x.reserved[1] = __builtin_bswap32 (x.reserved[1]);
+  x.ip = __builtin_bswap32 (x.ip);
+  x.cs = x.cs << 8 | x.cs >> 8;
+  x.rsrv2 = x.rsrv2 << 8 | x.rsrv2 >> 8;
+  if (f2 ())
+    {
+      __builtin_memcpy (buff, "\n", 1);
+    }
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-ceil-vec-1.c b/gcc/testsuite/gcc.target/i386/avx512f-ceil-vec-1.c

new file mode 100644 (file)

index 0000000..fc48b15
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-ceil-vec-1.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+/* { dg-require-effective-target avx512f } */
+/* { dg-skip-if "no M_PI" { vxworks_kernel } } */
+
+#define __NO_MATH_INLINES
+#include <math.h>
+#include "avx512f-check.h"
+
+#define NUM 64
+
+static void
+__attribute__((__target__("fpmath=sse")))
+init_src (double *src)
+{
+  int i, sign = 1;
+  double f = rand ();
+
+  for (i = 0; i < NUM; i++)
+    {
+      src[i] = (i + 1) * f * M_PI * sign;
+      if (i < (NUM / 2))
+       {
+          if ((i % 6) == 0)
+           f = f * src[i];
+        }
+      else if (i == (NUM / 2))
+       f = rand ();
+      else if ((i % 6) == 0)
+       f = 1 / (f * (i + 1) * src[i] * M_PI * sign);
+      sign = -sign;
+    }
+}
+
+static void
+__attribute__((__target__("fpmath=387")))
+avx512f_test (void)
+{
+  double a[NUM];
+  double r[NUM];
+  int i;
+
+  init_src (a);
+
+  for (i = 0; i < NUM; i++)
+    r[i] = ceil (a[i]);
+
+  /* check results:  */
+  for (i = 0; i < NUM; i++)
+    if (r[i] != ceil (a[i]))
+      abort();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-ceil-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-ceil-vec-2.c

new file mode 100644 (file)

index 0000000..bf8af06
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-ceil-vec-2.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+
+#include "avx512f-ceil-vec-1.c"
+
+/* { dg-final { scan-assembler-times "vrndscalepd\[^\n\]+zmm\[0-9\](?:\n|\[ \\t\]+#)" 1 } } */
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-ceilf-sfix-vec-1.c b/gcc/testsuite/gcc.target/i386/avx512f-ceilf-sfix-vec-1.c

new file mode 100644 (file)

index 0000000..c6d53d8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-ceilf-sfix-vec-1.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+/* { dg-require-effective-target avx512f } */
+/* { dg-skip-if "no M_PI" { vxworks_kernel } } */
+
+#define __NO_MATH_INLINES
+#include <math.h>
+#include "avx512f-check.h"
+
+#define NUM 64
+
+static void
+__attribute__((__target__("fpmath=sse")))
+init_src (float *src)
+{
+  int i, sign = 1;
+  float f = rand ();
+
+  for (i = 0; i < NUM; i++)
+    {
+      src[i] = (i + 1) * f * M_PI * sign;
+      if (i < (NUM / 2))
+       {
+          if ((i % 6) == 0)
+           f = f * src[i];
+        }
+      else if (i == (NUM / 2))
+       f = rand ();
+      else if ((i % 6) == 0)
+       f = 1 / (f * (i + 1) * src[i] * M_PI * sign);
+      sign = -sign;
+    }
+}
+
+static void
+__attribute__((__target__("fpmath=387")))
+avx512f_test (void)
+{
+  float a[NUM];
+  int r[NUM];
+  int i;
+
+  init_src (a);
+
+  for (i = 0; i < NUM; i++)
+    r[i] = (int) ceilf (a[i]);
+
+  /* check results:  */
+  for (i = 0; i < NUM; i++)
+    if (r[i] != (int) ceilf (a[i]))
+      abort();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-ceilf-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-ceilf-sfix-vec-2.c

new file mode 100644 (file)

index 0000000..80e594d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-ceilf-sfix-vec-2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+
+#include "avx512f-ceilf-sfix-vec-1.c"
+
+/* { dg-final { scan-assembler-times "vrndscaleps\[^\n\]+zmm\[0-9\](?:\n|\[ \\t\]+#)" 1 } } */
+/* { dg-final { scan-assembler-times "vcvttps2dq\[^\n\]+zmm\[0-9\].{7}(?:\n|\[ \\t\]+#)" 1 } } */
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-ceilf-vec-1.c b/gcc/testsuite/gcc.target/i386/avx512f-ceilf-vec-1.c

new file mode 100644 (file)

index 0000000..4788825
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-ceilf-vec-1.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+/* { dg-require-effective-target avx512f } */
+/* { dg-skip-if "no M_PI" { vxworks_kernel } } */
+
+#define __NO_MATH_INLINES
+#include <math.h>
+#include "avx512f-check.h"
+
+#define NUM 64
+
+static void
+__attribute__((__target__("fpmath=sse")))
+init_src (float *src)
+{
+  int i, sign = 1;
+  float f = rand ();
+
+  for (i = 0; i < NUM; i++)
+    {
+      src[i] = (i + 1) * f * M_PI * sign;
+      if (i < (NUM / 2))
+       {
+          if ((i % 6) == 0)
+           f = f * src[i];
+        }
+      else if (i == (NUM / 2))
+       f = rand ();
+      else if ((i % 6) == 0)
+       f = 1 / (f * (i + 1) * src[i] * M_PI * sign);
+      sign = -sign;
+    }
+}
+
+static void
+__attribute__((__target__("fpmath=387")))
+avx512f_test (void)
+{
+  float a[NUM];
+  float r[NUM];
+  int i;
+
+  init_src (a);
+
+  for (i = 0; i < NUM; i++)
+    r[i] = ceilf (a[i]);
+
+  /* check results:  */
+  for (i = 0; i < NUM; i++)
+    if (r[i] != ceilf (a[i]))
+      abort();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-ceilf-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-ceilf-vec-2.c

new file mode 100644 (file)

index 0000000..95a79e2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-ceilf-vec-2.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+
+#include "avx512f-ceilf-vec-1.c"
+
+/* { dg-final { scan-assembler-times "vrndscaleps\[^\n\]+zmm\[0-9\](?:\n|\[ \\t\]+#)" 1 } } */
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-floor-vec-1.c b/gcc/testsuite/gcc.target/i386/avx512f-floor-vec-1.c

new file mode 100644 (file)

index 0000000..b7cbed0
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-floor-vec-1.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+/* { dg-require-effective-target avx512f } */
+/* { dg-skip-if "no M_PI" { vxworks_kernel } } */
+
+#define __NO_MATH_INLINES
+#include <math.h>
+#include "avx512f-check.h"
+
+#define NUM 64
+
+static void
+__attribute__((__target__("fpmath=sse")))
+init_src (double *src)
+{
+  int i, sign = 1;
+  double f = rand ();
+
+  for (i = 0; i < NUM; i++)
+    {
+      src[i] = (i + 1) * f * M_PI * sign;
+      if (i < (NUM / 2))
+       {
+          if ((i % 6) == 0)
+           f = f * src[i];
+        }
+      else if (i == (NUM / 2))
+       f = rand ();
+      else if ((i % 6) == 0)
+       f = 1 / (f * (i + 1) * src[i] * M_PI * sign);
+      sign = -sign;
+    }
+}
+
+static void
+__attribute__((__target__("fpmath=387")))
+avx512f_test (void)
+{
+  double a[NUM];
+  double r[NUM];
+  int i;
+
+  init_src (a);
+
+  for (i = 0; i < NUM; i++)
+    r[i] = floor (a[i]);
+
+  /* check results:  */
+  for (i = 0; i < NUM; i++)
+    if (r[i] != floor (a[i]))
+      abort();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-floor-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-floor-vec-2.c

new file mode 100644 (file)

index 0000000..0d401f7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-floor-vec-2.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+
+#include "avx512f-floor-vec-1.c"
+
+/* { dg-final { scan-assembler-times "vrndscalepd\[^\n\]+zmm\[0-9\](?:\n|\[ \\t\]+#)" 1 } } */
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-floorf-sfix-vec-1.c b/gcc/testsuite/gcc.target/i386/avx512f-floorf-sfix-vec-1.c

new file mode 100644 (file)

index 0000000..6a25f43
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-floorf-sfix-vec-1.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+/* { dg-require-effective-target avx512f } */
+/* { dg-skip-if "no M_PI" { vxworks_kernel } } */
+
+#define __NO_MATH_INLINES
+#include <math.h>
+#include "avx512f-check.h"
+
+#define NUM 64
+
+static void
+__attribute__((__target__("fpmath=sse")))
+init_src (float *src)
+{
+  int i, sign = 1;
+  float f = rand ();
+
+  for (i = 0; i < NUM; i++)
+    {
+      src[i] = (i + 1) * f * M_PI * sign;
+      if (i < (NUM / 2))
+       {
+          if ((i % 6) == 0)
+           f = f * src[i];
+        }
+      else if (i == (NUM / 2))
+       f = rand ();
+      else if ((i % 6) == 0)
+       f = 1 / (f * (i + 1) * src[i] * M_PI * sign);
+      sign = -sign;
+    }
+}
+
+static void
+__attribute__((__target__("fpmath=387")))
+avx512f_test (void)
+{
+  float a[NUM];
+  int r[NUM];
+  int i;
+
+  init_src (a);
+
+  for (i = 0; i < NUM; i++)
+    r[i] = (int) floorf (a[i]);
+
+  /* check results:  */
+  for (i = 0; i < NUM; i++)
+    if (r[i] != (int) floorf (a[i]))
+      abort();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-floorf-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-floorf-sfix-vec-2.c

new file mode 100644 (file)

index 0000000..f4bfec5
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-floorf-sfix-vec-2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+
+#include "avx512f-floorf-sfix-vec-1.c"
+
+/* { dg-final { scan-assembler-times "vrndscaleps\[^\n\]+zmm\[0-9\](?:\n|\[ \\t\]+#)" 1 } } */
+/* { dg-final { scan-assembler-times "vcvttps2dq\[^\n\]+zmm\[0-9\].{7}(?:\n|\[ \\t\]+#)" 1 } } */
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-floorf-vec-1.c b/gcc/testsuite/gcc.target/i386/avx512f-floorf-vec-1.c

new file mode 100644 (file)

index 0000000..69fc73d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-floorf-vec-1.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+/* { dg-require-effective-target avx512f } */
+/* { dg-skip-if "no M_PI" { vxworks_kernel } } */
+
+#define __NO_MATH_INLINES
+#include <math.h>
+#include "avx512f-check.h"
+
+#define NUM 64
+
+static void
+__attribute__((__target__("fpmath=sse")))
+init_src (float *src)
+{
+  int i, sign = 1;
+  float f = rand ();
+
+  for (i = 0; i < NUM; i++)
+    {
+      src[i] = (i + 1) * f * M_PI * sign;
+      if (i < (NUM / 2))
+       {
+          if ((i % 6) == 0)
+           f = f * src[i];
+        }
+      else if (i == (NUM / 2))
+       f = rand ();
+      else if ((i % 6) == 0)
+       f = 1 / (f * (i + 1) * src[i] * M_PI * sign);
+      sign = -sign;
+    }
+}
+
+static void
+__attribute__((__target__("fpmath=387")))
+avx512f_test (void)
+{
+  float a[NUM];
+  float r[NUM];
+  int i;
+
+  init_src (a);
+
+  for (i = 0; i < NUM; i++)
+    r[i] = floorf (a[i]);
+
+  /* check results:  */
+  for (i = 0; i < NUM; i++)
+    if (r[i] != floorf (a[i]))
+      abort();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-floorf-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-floorf-vec-2.c

new file mode 100644 (file)

index 0000000..90c6c0f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-floorf-vec-2.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+
+#include "avx512f-floorf-vec-1.c"
+
+/* { dg-final { scan-assembler-times "vrndscaleps\[^\n\]+zmm\[0-9\](?:\n|\[ \\t\]+#)" 1 } } */
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-rint-sfix-vec-1.c b/gcc/testsuite/gcc.target/i386/avx512f-rint-sfix-vec-1.c

new file mode 100644 (file)

index 0000000..8e1745a
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-rint-sfix-vec-1.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+/* { dg-require-effective-target avx512f } */
+/* { dg-skip-if "no M_PI" { vxworks_kernel } } */
+
+#define __NO_MATH_INLINES
+#include <math.h>
+#include "avx512f-check.h"
+
+#define NUM 64
+
+static void
+__attribute__((__target__("fpmath=sse")))
+init_src (double *src)
+{
+  int i, sign = 1;
+  double f = rand ();
+
+  for (i = 0; i < NUM; i++)
+    {
+      src[i] = (i + 1) * f * M_PI * sign;
+      if (i < (NUM / 2))
+       {
+          if ((i % 6) == 0)
+           f = f * src[i];
+        }
+      else if (i == (NUM / 2))
+       f = rand ();
+      else if ((i % 6) == 0)
+       f = 1 / (f * (i + 1) * src[i] * M_PI * sign);
+      sign = -sign;
+    }
+}
+
+static void
+__attribute__((__target__("fpmath=387")))
+avx512f_test (void)
+{
+  double a[NUM];
+  int r[NUM];
+  int i;
+
+  init_src (a);
+
+  for (i = 0; i < NUM; i++)
+    r[i] = (int) rint (a[i]);
+
+  /* check results:  */
+  for (i = 0; i < NUM; i++)
+    if (r[i] != (int) rint (a[i]))
+      abort();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-rint-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-rint-sfix-vec-2.c

new file mode 100644 (file)

index 0000000..c3f78ac
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-rint-sfix-vec-2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+
+#include "avx512f-rint-sfix-vec-1.c"
+
+/* { dg-final { scan-assembler-times "vcvtpd2dq\[^\n\]+ymm\[0-9\](?:\n|\[ \\t\]+#)" 2 } } */
+/* { dg-final { scan-assembler-times "vinserti64x4\[^\n\]+zmm\[0-9\](?:\n|\[ \\t\]+#)" 1 } } */
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-rintf-sfix-vec-1.c b/gcc/testsuite/gcc.target/i386/avx512f-rintf-sfix-vec-1.c

new file mode 100644 (file)

index 0000000..ac3e9a2
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-rintf-sfix-vec-1.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+/* { dg-require-effective-target avx512f } */
+/* { dg-skip-if "no M_PI" { vxworks_kernel } } */
+
+#define __NO_MATH_INLINES
+#include <math.h>
+#include "avx512f-check.h"
+
+#define NUM 64
+
+static void
+__attribute__((__target__("fpmath=sse")))
+init_src (float *src)
+{
+  int i, sign = 1;
+  float f = rand ();
+
+  for (i = 0; i < NUM; i++)
+    {
+      src[i] = (i + 1) * f * M_PI * sign;
+      if (i < (NUM / 2))
+       {
+          if ((i % 6) == 0)
+           f = f * src[i];
+        }
+      else if (i == (NUM / 2))
+       f = rand ();
+      else if ((i % 6) == 0)
+       f = 1 / (f * (i + 1) * src[i] * M_PI * sign);
+      sign = -sign;
+    }
+}
+
+static void
+__attribute__((__target__("fpmath=387")))
+avx512f_test (void)
+{
+  float a[NUM];
+  int r[NUM];
+  int i;
+
+  init_src (a);
+
+  for (i = 0; i < NUM; i++)
+    r[i] = (int) rintf (a[i]);
+
+  /* check results:  */
+  for (i = 0; i < NUM; i++)
+    if (r[i] != (int) rintf (a[i]))
+      abort();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-rintf-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-rintf-sfix-vec-2.c

new file mode 100644 (file)

index 0000000..c172e61
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-rintf-sfix-vec-2.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+
+#include "avx512f-rintf-sfix-vec-1.c"
+
+/* { dg-final { scan-assembler-times "vcvtps2dq\[^\n\]+zmm\[0-9\](?:\n|\[ \\t\]+#)" 1 } } */
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-round-sfix-vec-1.c b/gcc/testsuite/gcc.target/i386/avx512f-round-sfix-vec-1.c

new file mode 100644 (file)

index 0000000..61bea57
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-round-sfix-vec-1.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+/* { dg-require-effective-target avx512f } */
+/* { dg-skip-if "no M_PI" { vxworks_kernel } } */
+
+#define __NO_MATH_INLINES
+#include <math.h>
+#include "avx512f-check.h"
+
+#define NUM 64
+
+static void
+__attribute__((__target__("fpmath=sse")))
+init_src (double *src)
+{
+  int i, sign = 1;
+  double f = rand ();
+
+  for (i = 0; i < NUM; i++)
+    {
+      src[i] = (i + 1) * f * M_PI * sign;
+      if (i < (NUM / 2))
+       {
+          if ((i % 6) == 0)
+           f = f * src[i];
+        }
+      else if (i == (NUM / 2))
+       f = rand ();
+      else if ((i % 6) == 0)
+       f = 1 / (f * (i + 1) * src[i] * M_PI * sign);
+      sign = -sign;
+    }
+}
+
+static void
+__attribute__((__target__("fpmath=387")))
+avx512f_test (void)
+{
+  double a[NUM];
+  int r[NUM];
+  int i;
+
+  init_src (a);
+
+  for (i = 0; i < NUM; i++)
+    r[i] = (int) round (a[i]);
+
+  /* check results:  */
+  for (i = 0; i < NUM; i++)
+    if (r[i] != (int) round (a[i]))
+      abort();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-round-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-round-sfix-vec-2.c

new file mode 100644 (file)

index 0000000..5982c65
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-round-sfix-vec-2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+
+#include "avx512f-round-sfix-vec-1.c"
+
+/* { dg-final { scan-assembler-times "vrndscalepd\[^\n\]+zmm\[0-9\](?:\n|\[ \\t\]+#)" 2 } } */
+/* { dg-final { scan-assembler-times "vcvttpd2dq\[^\n\]+zmm\[0-9\].{7}(?:\n|\[ \\t\]+#)" 2 } } */
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-roundf-sfix-vec-1.c b/gcc/testsuite/gcc.target/i386/avx512f-roundf-sfix-vec-1.c

new file mode 100644 (file)

index 0000000..c5ec9e7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-roundf-sfix-vec-1.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+/* { dg-require-effective-target avx512f } */
+/* { dg-skip-if "no M_PI" { vxworks_kernel } } */
+
+#define __NO_MATH_INLINES
+#include <math.h>
+#include "avx512f-check.h"
+
+#define NUM 64
+
+static void
+__attribute__((__target__("fpmath=sse")))
+init_src (float *src)
+{
+  int i, sign = 1;
+  float f = rand ();
+
+  for (i = 0; i < NUM; i++)
+    {
+      src[i] = (i + 1) * f * M_PI * sign;
+      if (i < (NUM / 2))
+       {
+          if ((i % 6) == 0)
+           f = f * src[i];
+        }
+      else if (i == (NUM / 2))
+       f = rand ();
+      else if ((i % 6) == 0)
+       f = 1 / (f * (i + 1) * src[i] * M_PI * sign);
+      sign = -sign;
+    }
+}
+
+static void
+__attribute__((__target__("fpmath=387")))
+avx512f_test (void)
+{
+  float a[NUM];
+  int r[NUM];
+  int i;
+
+  init_src (a);
+
+  for (i = 0; i < NUM; i++)
+    r[i] = (int) roundf (a[i]);
+
+  /* check results:  */
+  for (i = 0; i < NUM; i++)
+    if (r[i] != (int) roundf (a[i]))
+      abort();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-roundf-sfix-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-roundf-sfix-vec-2.c

new file mode 100644 (file)

index 0000000..0d8abb8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-roundf-sfix-vec-2.c
@@ -0,0 +1,7 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+
+#include "avx512f-roundf-sfix-vec-1.c"
+
+/* { dg-final { scan-assembler-times "vrndscaleps\[^\n\]+zmm\[0-9\](?:\n|\[ \\t\]+#)" 1 } } */
+/* { dg-final { scan-assembler-times "vcvttps2dq\[^\n\]+zmm\[0-9\].{7}(?:\n|\[ \\t\]+#)" 1 } } */
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-trunc-vec-1.c b/gcc/testsuite/gcc.target/i386/avx512f-trunc-vec-1.c

new file mode 100644 (file)

index 0000000..dfb93d7
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-trunc-vec-1.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+/* { dg-require-effective-target avx512f } */
+/* { dg-skip-if "no M_PI" { vxworks_kernel } } */
+
+#define __NO_MATH_INLINES
+#include <math.h>
+#include "avx512f-check.h"
+
+#define NUM 64
+
+static void
+__attribute__((__target__("fpmath=sse")))
+init_src (double *src)
+{
+  int i, sign = 1;
+  double f = rand ();
+
+  for (i = 0; i < NUM; i++)
+    {
+      src[i] = (i + 1) * f * M_PI * sign;
+      if (i < (NUM / 2))
+       {
+          if ((i % 6) == 0)
+           f = f * src[i];
+        }
+      else if (i == (NUM / 2))
+       f = rand ();
+      else if ((i % 6) == 0)
+       f = 1 / (f * (i + 1) * src[i] * M_PI * sign);
+      sign = -sign;
+    }
+}
+
+static void
+__attribute__((__target__("fpmath=387")))
+avx512f_test (void)
+{
+  double a[NUM];
+  double r[NUM];
+  int i;
+
+  init_src (a);
+
+  for (i = 0; i < NUM; i++)
+    r[i] = trunc (a[i]);
+
+  /* check results:  */
+  for (i = 0; i < NUM; i++)
+    if (r[i] != trunc (a[i]))
+      abort();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-trunc-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-trunc-vec-2.c

new file mode 100644 (file)

index 0000000..e8ec022
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-trunc-vec-2.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+
+#include "avx512f-trunc-vec-1.c"
+
+/* { dg-final { scan-assembler-times "vrndscalepd\[^\n\]+zmm\[0-9\](?:\n|\[ \\t\]+#)" 1 } } */
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-truncf-vec-1.c b/gcc/testsuite/gcc.target/i386/avx512f-truncf-vec-1.c

new file mode 100644 (file)

index 0000000..db13e71
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-truncf-vec-1.c
@@ -0,0 +1,52 @@
+/* { dg-do run } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+/* { dg-require-effective-target avx512f } */
+/* { dg-skip-if "no M_PI" { vxworks_kernel } } */
+
+#define __NO_MATH_INLINES
+#include <math.h>
+#include "avx512f-check.h"
+
+#define NUM 64
+
+static void
+__attribute__((__target__("fpmath=sse")))
+init_src (float *src)
+{
+  int i, sign = 1;
+  float f = rand ();
+
+  for (i = 0; i < NUM; i++)
+    {
+      src[i] = (i + 1) * f * M_PI * sign;
+      if (i < (NUM / 2))
+       {
+          if ((i % 6) == 0)
+           f = f * src[i];
+        }
+      else if (i == (NUM / 2))
+       f = rand ();
+      else if ((i % 6) == 0)
+       f = 1 / (f * (i + 1) * src[i] * M_PI * sign);
+      sign = -sign;
+    }
+}
+
+static void
+__attribute__((__target__("fpmath=387")))
+avx512f_test (void)
+{
+  float a[NUM];
+  float r[NUM];
+  int i;
+
+  init_src (a);
+
+  for (i = 0; i < NUM; i++)
+    r[i] = truncf (a[i]);
+
+  /* check results:  */
+  for (i = 0; i < NUM; i++)
+    if (r[i] != truncf (a[i]))
+      abort();
+}
diff --git a/gcc/testsuite/gcc.target/i386/avx512f-truncf-vec-2.c b/gcc/testsuite/gcc.target/i386/avx512f-truncf-vec-2.c

new file mode 100644 (file)

index 0000000..ae542d8
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/avx512f-truncf-vec-2.c
@@ -0,0 +1,6 @@
+/* { dg-do compile } */
+/* { dg-options "-O2 -ffast-math -ftree-vectorize -mavx512f" } */
+
+#include "avx512f-truncf-vec-1.c"
+
+/* { dg-final { scan-assembler-times "vrndscaleps\[^\n\]+zmm\[0-9\](?:\n|\[ \\t\]+#)" 1 } } */
diff --git a/gcc/testsuite/gcc.target/i386/fabsneg-1.c b/gcc/testsuite/gcc.target/i386/fabsneg-1.c

new file mode 100644 (file)

index 0000000..3cdf456
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/fabsneg-1.c
@@ -0,0 +1,36 @@
+/* { dg-do run } */
+/* { dg-require-effective-target lp64 } */
+/* { dg-options "-O2 -mtune=nocona" } */
+
+double x;
+
+void
+__attribute__ ((noinline, noclone))
+test_fabs (double a)
+{
+  asm volatile ("" : "+r" (a));
+  x = __builtin_fabs (a);
+}
+
+void
+__attribute__ ((noinline, noclone))
+test_neg (double a)
+{
+  asm volatile ("" : "+r" (a));
+  x = -a;
+}
+
+int main ()
+{
+  test_fabs (-1.0);
+
+  if (x != 1.0)
+    __builtin_abort ();
+
+  test_neg (-1.0);
+
+  if (x != 1.0)
+    __builtin_abort ();
+
+  return 0;
+}
diff --git a/gcc/testsuite/gcc.target/i386/iamcu/args.h b/gcc/testsuite/gcc.target/i386/iamcu/args.h

index f8abde4..67808ff 100644 (file)
--- a/gcc/testsuite/gcc.target/i386/iamcu/args.h
+++ b/gcc/testsuite/gcc.target/i386/iamcu/args.h
@@ -30,7 +30,7 @@ extern void *iamcu_memset (void *, int, size_t);
  /* Clear all scratch integer registers, excluding the one used to return
     aggregate.  */
  #define clear_non_sret_int_hardware_registers \
-  asm __volatile__ ("xor %%edx, %%ebx\n\t" \
+  asm __volatile__ ("xor %%edx, %%edx\n\t" \
                     "xor %%ecx, %%ecx\n\t" \
                     ::: "edx", "ecx");
  
diff --git a/gcc/testsuite/gcc.target/i386/pr68657.c b/gcc/testsuite/gcc.target/i386/pr68657.c

new file mode 100644 (file)

index 0000000..6f0d498
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr68657.c
@@ -0,0 +1,15 @@
+/* PR c/68657 */
+/* { dg-options "-mno-avx512f -Werror=psabi" } */
+
+typedef int V __attribute__((vector_size (64)));
+
+void foo (V x, V *y) { /* { dg-error "AVX512F vector argument without AVX512F enabled" } */
+  *y = x;
+}
+
+V bar (V *x) {         /* { dg-error "AVX512F vector return without AVX512F enabled" } */
+  return *x;
+}
+
+/* { dg-message "The ABI for passing parameters with 64-byte alignment has changed" "" { target *-*-* } 6 } */
+/* { dg-message "some warnings being treated as errors" "" { target *-*-* } 0 } */
diff --git a/gcc/testsuite/gcc.target/i386/pr70876.c b/gcc/testsuite/gcc.target/i386/pr70876.c

new file mode 100644 (file)

index 0000000..c9bab69
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr70876.c
@@ -0,0 +1,13 @@
+/* { dg-do compile { target { ! x32 } } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx -Wno-implicit-function-declaration" } */
+
+void f (char *s1, char *s2)
+{
+  int z = 5;
+
+  struct { char a[z]; } x;
+
+  s1[0] = s2[0];
+
+  foo (x, x);
+}
diff --git a/gcc/testsuite/gcc.target/i386/pr70877.c b/gcc/testsuite/gcc.target/i386/pr70877.c

new file mode 100644 (file)

index 0000000..4269e84
--- /dev/null
+++ b/gcc/testsuite/gcc.target/i386/pr70877.c
@@ -0,0 +1,14 @@
+/* { dg-do compile { target { ! x32 } } } */
+/* { dg-options "-fcheck-pointer-bounds -mmpx" } */
+
+int foo(int);
+
+typedef struct {
+  double d;
+  int a;
+} str_t;
+
+void bar(double d, int i, str_t s)
+{
+  d = ((double (*) (int)) foo) (i); /* { dg-warning "function called through a non-compatible type" } */
+}
diff --git a/gcc/testsuite/gcc.target/powerpc/ctz-3.c b/gcc/testsuite/gcc.target/powerpc/ctz-3.c

new file mode 100644 (file)

index 0000000..468a1f9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/ctz-3.c
@@ -0,0 +1,62 @@
+/* { dg-do compile { target { powerpc*-*-* } } } */
+/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */
+/* { dg-require-effective-target powerpc_p9vector_ok } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-options "-mcpu=power9 -O2 -ftree-vectorize -fvect-cost-model=dynamic -fno-unroll-loops -fno-unroll-all-loops" } */
+
+#ifndef SIZE
+#define SIZE 1024
+#endif
+
+#ifndef ALIGN
+#define ALIGN 32
+#endif
+
+#define ALIGN_ATTR __attribute__((__aligned__(ALIGN)))
+
+#define DO_BUILTIN(PREFIX, TYPE, CTZ)                                  \
+TYPE PREFIX ## _a[SIZE] ALIGN_ATTR;                                    \
+TYPE PREFIX ## _b[SIZE] ALIGN_ATTR;                                    \
+                                                                       \
+void                                                                   \
+PREFIX ## _ctz (void)                                                  \
+{                                                                      \
+  unsigned long i;                                                     \
+                                                                       \
+  for (i = 0; i < SIZE; i++)                                           \
+    PREFIX ## _a[i] = CTZ (PREFIX ## _b[i]);                           \
+}
+
+#if !defined(DO_LONG_LONG) && !defined(DO_LONG) && !defined(DO_INT) && !defined(DO_SHORT) && !defined(DO_CHAR)
+#define DO_INT 1
+#endif
+
+#if DO_LONG_LONG
+/* At the moment, only int is auto vectorized.  */
+DO_BUILTIN (sll, long long,            __builtin_ctzll)
+DO_BUILTIN (ull, unsigned long long,   __builtin_ctzll)
+#endif
+
+#if defined(_ARCH_PPC64) && DO_LONG
+DO_BUILTIN (sl,  long,                 __builtin_ctzl)
+DO_BUILTIN (ul,  unsigned long,                __builtin_ctzl)
+#endif
+
+#if DO_INT
+DO_BUILTIN (si,  int,                  __builtin_ctz)
+DO_BUILTIN (ui,  unsigned int,         __builtin_ctz)
+#endif
+
+#if DO_SHORT
+DO_BUILTIN (ss,  short,                        __builtin_ctz)
+DO_BUILTIN (us,  unsigned short,       __builtin_ctz)
+#endif
+
+#if DO_CHAR
+DO_BUILTIN (sc,  signed char,          __builtin_ctz)
+DO_BUILTIN (uc,  unsigned char,                __builtin_ctz)
+#endif
+
+/* { dg-final { scan-assembler-times "vctzw" 2 } } */
+/* { dg-final { scan-assembler-not "cnttzd" } } */
+/* { dg-final { scan-assembler-not "cnttzw" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/ctz-4.c b/gcc/testsuite/gcc.target/powerpc/ctz-4.c

new file mode 100644 (file)

index 0000000..2d04a9b
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/ctz-4.c
@@ -0,0 +1,110 @@
+/* { dg-do compile { target { powerpc*-*-* } } } */
+/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */
+/* { dg-require-effective-target powerpc_p9vector_ok } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-options "-mcpu=power9 -O2" } */
+
+#include <altivec.h>
+
+vector signed char
+count_trailing_zeros_v16qi_1s (vector signed char a)
+{
+  return vec_vctz (a);
+}
+
+vector signed char
+count_trailing_zeros_v16qi_2s (vector signed char a)
+{
+  return vec_vctzb (a);
+}
+
+vector unsigned char
+count_trailing_zeros_v16qi_1u (vector unsigned char a)
+{
+  return vec_vctz (a);
+}
+
+vector unsigned char
+count_trailing_zeros_v16qi_2u (vector unsigned char a)
+{
+  return vec_vctzb (a);
+}
+
+vector short
+count_trailing_zeros_v8hi_1s (vector short a)
+{
+  return vec_vctz (a);
+}
+
+vector short
+count_trailing_zeros_v8hi_2s (vector short a)
+{
+  return vec_vctzh (a);
+}
+
+vector unsigned short
+count_trailing_zeros_v8hi_1u (vector unsigned short a)
+{
+  return vec_vctz (a);
+}
+
+vector unsigned short
+count_trailing_zeros_v8hi_2u (vector unsigned short a)
+{
+  return vec_vctzh (a);
+}
+
+vector int
+count_trailing_zeros_v4si_1s (vector int a)
+{
+  return vec_vctz (a);
+}
+
+vector int
+count_trailing_zeros_v4si_2s (vector int a)
+{
+  return vec_vctzw (a);
+}
+
+vector unsigned int
+count_trailing_zeros_v4si_1u (vector unsigned int a)
+{
+  return vec_vctz (a);
+}
+
+vector unsigned int
+count_trailing_zeros_v4si_2u (vector unsigned int a)
+{
+  return vec_vctzw (a);
+}
+
+vector long long
+count_trailing_zeros_v2di_1s (vector long long a)
+{
+  return vec_vctz (a);
+}
+
+vector long long
+count_trailing_zeros_v2di_2s (vector long long a)
+{
+  return vec_vctzd (a);
+}
+
+vector unsigned long long
+count_trailing_zeros_v2di_1u (vector unsigned long long a)
+{
+  return vec_vctz (a);
+}
+
+vector unsigned long long
+count_trailing_zeros_v2di_2u (vector unsigned long long a)
+{
+  return vec_vctzd (a);
+}
+
+/* { dg-final { scan-assembler "vctzb" } } */
+/* { dg-final { scan-assembler "vctzd" } } */
+/* { dg-final { scan-assembler "vctzh" } } */
+/* { dg-final { scan-assembler "vctzw" } } */
+/* { dg-final { scan-assembler-not "cnttzd" } } */
+/* { dg-final { scan-assembler-not "cnttzw" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/darn-0.c b/gcc/testsuite/gcc.target/powerpc/darn-0.c

new file mode 100644 (file)

index 0000000..ce2e25e
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/darn-0.c
@@ -0,0 +1,12 @@
+/* { dg-do compile { target { powerpc*-*-* } } } */
+/* { dg-options "-mcpu=power9" } */
+
+/* This test should succeed on both 32- and 64-bit configurations.  */
+#include <altivec.h>
+
+int get_random ()
+{
+  return __builtin_darn_32 ();
+}
+
+/* { dg-final { scan-assembler    "darn" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/darn-1.c b/gcc/testsuite/gcc.target/powerpc/darn-1.c

new file mode 100644 (file)

index 0000000..d79e5c1
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/darn-1.c
@@ -0,0 +1,12 @@
+/* { dg-do compile { target { powerpc*-*-* } } } */
+/* { dg-options "-mcpu=power9" } */
+/* { dg-require-effective-target lp64 } */
+
+#include <altivec.h>
+
+long long get_conditioned_random ()
+{
+  return __builtin_darn ();
+}
+
+/* { dg-final { scan-assembler    "darn" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/darn-2.c b/gcc/testsuite/gcc.target/powerpc/darn-2.c

new file mode 100644 (file)

index 0000000..7f47332
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/darn-2.c
@@ -0,0 +1,12 @@
+/* { dg-do compile { target { powerpc*-*-* } } } */
+/* { dg-options "-mcpu=power9" } */
+/* { dg-require-effective-target lp64 } */
+
+#include <altivec.h>
+
+long long get_raw_random ()
+{
+  return __builtin_darn_raw ();
+}
+
+/* { dg-final { scan-assembler    "darn" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/dform-1.c b/gcc/testsuite/gcc.target/powerpc/dform-1.c

index 37a30d1..12623f2 100644 (file)
--- a/gcc/testsuite/gcc.target/powerpc/dform-1.c
+++ b/gcc/testsuite/gcc.target/powerpc/dform-1.c
@@ -1,7 +1,7 @@
  /* { dg-do compile { target { powerpc*-*-* && lp64 } } } */
  /* { dg-require-effective-target powerpc_p9vector_ok } */
  /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
-/* { dg-options "-mcpu=power9 -mpower9-dform -O2" } */
+/* { dg-options "-mcpu=power9 -mpower9-dform -O2 -mlra" } */
  
  #ifndef TYPE
  #define TYPE double
diff --git a/gcc/testsuite/gcc.target/powerpc/dform-2.c b/gcc/testsuite/gcc.target/powerpc/dform-2.c

index b4c4199..86d65b5 100644 (file)
--- a/gcc/testsuite/gcc.target/powerpc/dform-2.c
+++ b/gcc/testsuite/gcc.target/powerpc/dform-2.c
@@ -1,7 +1,7 @@
  /* { dg-do compile { target { powerpc*-*-* && lp64 } } } */
  /* { dg-require-effective-target powerpc_p9vector_ok } */
  /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
-/* { dg-options "-mcpu=power9 -mpower9-dform -O2" } */
+/* { dg-options "-mcpu=power9 -mpower9-dform -O2 -mlra" } */
  
  #ifndef TYPE
  #define TYPE float
diff --git a/gcc/testsuite/gcc.target/powerpc/dform-3.c b/gcc/testsuite/gcc.target/powerpc/dform-3.c

new file mode 100644 (file)

index 0000000..b1c481f
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/dform-3.c
@@ -0,0 +1,39 @@
+/* { dg-do compile { target { powerpc*-*-* && lp64 } } } */
+/* { dg-require-effective-target powerpc_p9vector_ok } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-options "-mcpu=power9 -mpower9-dform -O2 -mlra" } */
+
+#ifndef TYPE
+#define TYPE vector double
+#endif
+
+struct foo {
+  TYPE a, b, c, d;
+};
+
+/* Test whether ISA 3.0 vector d-form instructions are implemented.  */
+void
+add (struct foo *p)
+{
+  p->b = p->c + p->d;
+}
+
+/* Make sure we don't use direct moves to get stuff into GPR registers.  */
+void
+gpr (struct foo *p)
+{
+  TYPE x = p->c;
+
+  __asm__ (" # reg = %0" : "+r" (x));
+
+  p->b = x;
+}
+
+/* { dg-final { scan-assembler     "lxv "      } } */
+/* { dg-final { scan-assembler     "stxv "     } } */
+/* { dg-final { scan-assembler-not "lxvx "     } } */
+/* { dg-final { scan-assembler-not "stxvx "    } } */
+/* { dg-final { scan-assembler-not "mfvsrd "   } } */
+/* { dg-final { scan-assembler-not "mfvsrld "  } } */
+/* { dg-final { scan-assembler     "l\[dq\] "  } } */
+/* { dg-final { scan-assembler     "st\[dq\] " } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/p8vector-int128-1.c b/gcc/testsuite/gcc.target/powerpc/p8vector-int128-1.c

index 31e07dd..5ba772f 100644 (file)
--- a/gcc/testsuite/gcc.target/powerpc/p8vector-int128-1.c
+++ b/gcc/testsuite/gcc.target/powerpc/p8vector-int128-1.c
@@ -2,7 +2,7 @@
  /* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */
  /* { dg-require-effective-target powerpc_p8vector_ok } */
  /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
-/* { dg-options "-mcpu=power8 -O3 -mvsx-timode" } */
+/* { dg-options "-mcpu=power8 -O3 -mvsx-timode -mlra" } */
  
  #include <altivec.h>
  
diff --git a/gcc/testsuite/gcc.target/powerpc/p9-minmax-1.c b/gcc/testsuite/gcc.target/powerpc/p9-minmax-1.c

new file mode 100644 (file)

index 0000000..c182da9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/p9-minmax-1.c
@@ -0,0 +1,171 @@
+/* { dg-do compile { target { powerpc*-*-* } } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-require-effective-target powerpc_p9vector_ok } */
+/* { dg-options "-mcpu=power9 -O2 -mpower9-minmax -ffast-math" } */
+/* { dg-final { scan-assembler-not "fsel"      } } */
+/* { dg-final { scan-assembler     "xscmpeqdp" } } */
+/* { dg-final { scan-assembler     "xscmpgtdp" } } */
+/* { dg-final { scan-assembler     "xscmpgedp" } } */
+/* { dg-final { scan-assembler-not "xscmpodp"  } } */
+/* { dg-final { scan-assembler-not "xscmpudp"  } } */
+/* { dg-final { scan-assembler     "xsmaxcdp"  } } */
+/* { dg-final { scan-assembler-not "xsmaxdp"   } } */
+/* { dg-final { scan-assembler     "xsmincdp"  } } */
+/* { dg-final { scan-assembler-not "xsmindp"   } } */
+/* { dg-final { scan-assembler     "xxsel"     } } */
+
+double
+dbl_max1 (double a, double b)
+{
+  return (a >= b) ? a : b;
+}
+
+double
+dbl_max2 (double a, double b)
+{
+  return (a > b) ? a : b;
+}
+
+double
+dbl_min1 (double a, double b)
+{
+  return (a < b) ? a : b;
+}
+
+double
+dbl_min2 (double a, double b)
+{
+  return (a <= b) ? a : b;
+}
+
+double
+dbl_cmp_eq (double a, double b, double c, double d)
+{
+  return (a == b) ? c : d;
+}
+
+double
+dbl_cmp_ne (double a, double b, double c, double d)
+{
+  return (a != b) ? c : d;
+}
+
+double
+dbl_cmp_gt (double a, double b, double c, double d)
+{
+  return (a > b) ? c : d;
+}
+
+double
+dbl_cmp_ge (double a, double b, double c, double d)
+{
+  return (a >= b) ? c : d;
+}
+
+double
+dbl_cmp_lt (double a, double b, double c, double d)
+{
+  return (a < b) ? c : d;
+}
+
+double
+dbl_cmp_le (double a, double b, double c, double d)
+{
+  return (a <= b) ? c : d;
+}
+
+float
+flt_max1 (float a, float b)
+{
+  return (a >= b) ? a : b;
+}
+
+float
+flt_max2 (float a, float b)
+{
+  return (a > b) ? a : b;
+}
+
+float
+flt_min1 (float a, float b)
+{
+  return (a < b) ? a : b;
+}
+
+float
+flt_min2 (float a, float b)
+{
+  return (a <= b) ? a : b;
+}
+
+float
+flt_cmp_eq (float a, float b, float c, float d)
+{
+  return (a == b) ? c : d;
+}
+
+float
+flt_cmp_ne (float a, float b, float c, float d)
+{
+  return (a != b) ? c : d;
+}
+
+float
+flt_cmp_gt (float a, float b, float c, float d)
+{
+  return (a > b) ? c : d;
+}
+
+float
+flt_cmp_ge (float a, float b, float c, float d)
+{
+  return (a >= b) ? c : d;
+}
+
+float
+flt_cmp_lt (float a, float b, float c, float d)
+{
+  return (a < b) ? c : d;
+}
+
+float
+flt_cmp_le (float a, float b, float c, float d)
+{
+  return (a <= b) ? c : d;
+}
+
+double
+dbl_flt_max1 (float a, float b)
+{
+  return (a > b) ? a : b;
+}
+
+double
+dbl_flt_max2 (double a, float b)
+{
+  return (a > b) ? a : b;
+}
+
+double
+dbl_flt_max3 (float a, double b)
+{
+  return (a > b) ? a : b;
+}
+
+double
+dbl_flt_min1 (float a, float b)
+{
+  return (a < b) ? a : b;
+}
+
+double
+dbl_flt_min2 (double a, float b)
+{
+  return (a < b) ? a : b;
+}
+
+double
+dbl_flt_min3 (float a, double b)
+{
+  return (a < b) ? a : b;
+}
diff --git a/gcc/testsuite/gcc.target/powerpc/p9-minmax-2.c b/gcc/testsuite/gcc.target/powerpc/p9-minmax-2.c

new file mode 100644 (file)

index 0000000..f674214
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/p9-minmax-2.c
@@ -0,0 +1,191 @@
+/* { dg-do compile { target { powerpc*-*-* } } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-require-effective-target powerpc_p9vector_ok } */
+/* { dg-options "-mcpu=power9 -O2 -mpower9-minmax" } */
+/* { dg-final { scan-assembler-not "fsel"      } } */
+/* { dg-final { scan-assembler     "xscmpeqdp" } } */
+/* { dg-final { scan-assembler     "xscmpgtdp" } } */
+/* { dg-final { scan-assembler-not "xscmpodp"  } } */
+/* { dg-final { scan-assembler-not "xscmpudp"  } } */
+/* { dg-final { scan-assembler     "xsmaxcdp"  } } */
+/* { dg-final { scan-assembler-not "xsmaxdp"   } } */
+/* { dg-final { scan-assembler     "xsmincdp"  } } */
+/* { dg-final { scan-assembler-not "xsmindp"   } } */
+/* { dg-final { scan-assembler     "xxsel"     } } */
+
+/* Due to NaN support, <= and >= are not handled presently unless -ffast-math
+   is used.  At some point this will be fixed and the xscmpgedp instruction can
+   be generated normally. The <= and >= tests are bracketed with
+   #ifdef DO_GE_LE.  */
+
+#ifdef DO_GE_LE
+double
+dbl_max1 (double a, double b)
+{
+  return (a >= b) ? a : b;
+}
+#endif
+
+double
+dbl_max2 (double a, double b)
+{
+  return (a > b) ? a : b;
+}
+
+double
+dbl_min1 (double a, double b)
+{
+  return (a < b) ? a : b;
+}
+
+#ifdef DO_GE_LE
+double
+dbl_min2 (double a, double b)
+{
+  return (a <= b) ? a : b;
+}
+#endif
+
+double
+dbl_cmp_eq (double a, double b, double c, double d)
+{
+  return (a == b) ? c : d;
+}
+
+double
+dbl_cmp_ne (double a, double b, double c, double d)
+{
+  return (a != b) ? c : d;
+}
+
+double
+dbl_cmp_gt (double a, double b, double c, double d)
+{
+  return (a > b) ? c : d;
+}
+
+#ifdef DO_GE_LE
+double
+dbl_cmp_ge (double a, double b, double c, double d)
+{
+  return (a >= b) ? c : d;
+}
+#endif
+
+double
+dbl_cmp_lt (double a, double b, double c, double d)
+{
+  return (a < b) ? c : d;
+}
+
+#ifdef DO_GE_LE
+double
+dbl_cmp_le (double a, double b, double c, double d)
+{
+  return (a <= b) ? c : d;
+}
+#endif
+
+#ifdef DO_GE_LE
+float
+flt_max1 (float a, float b)
+{
+  return (a >= b) ? a : b;
+}
+#endif
+
+float
+flt_max2 (float a, float b)
+{
+  return (a > b) ? a : b;
+}
+
+float
+flt_min1 (float a, float b)
+{
+  return (a < b) ? a : b;
+}
+
+#ifdef DO_GE_LE
+float
+flt_min2 (float a, float b)
+{
+  return (a <= b) ? a : b;
+}
+#endif
+
+float
+flt_cmp_eq (float a, float b, float c, float d)
+{
+  return (a == b) ? c : d;
+}
+
+float
+flt_cmp_ne (float a, float b, float c, float d)
+{
+  return (a != b) ? c : d;
+}
+
+float
+flt_cmp_gt (float a, float b, float c, float d)
+{
+  return (a > b) ? c : d;
+}
+
+#ifdef DO_GE_LE
+float
+flt_cmp_ge (float a, float b, float c, float d)
+{
+  return (a >= b) ? c : d;
+}
+#endif
+
+float
+flt_cmp_lt (float a, float b, float c, float d)
+{
+  return (a < b) ? c : d;
+}
+
+#ifdef DO_GE_LE
+float
+flt_cmp_le (float a, float b, float c, float d)
+{
+  return (a <= b) ? c : d;
+}
+#endif
+
+double
+dbl_flt_max1 (float a, float b)
+{
+  return (a > b) ? a : b;
+}
+
+double
+dbl_flt_max2 (double a, float b)
+{
+  return (a > b) ? a : b;
+}
+
+double
+dbl_flt_max3 (float a, double b)
+{
+  return (a > b) ? a : b;
+}
+
+double
+dbl_flt_min1 (float a, float b)
+{
+  return (a < b) ? a : b;
+}
+
+double
+dbl_flt_min2 (double a, float b)
+{
+  return (a < b) ? a : b;
+}
+
+double
+dbl_flt_min3 (float a, double b)
+{
+  return (a < b) ? a : b;
+}
diff --git a/gcc/testsuite/gcc.target/powerpc/p9-permute.c b/gcc/testsuite/gcc.target/powerpc/p9-permute.c

index f090f18..c29c85b 100644 (file)
--- a/gcc/testsuite/gcc.target/powerpc/p9-permute.c
+++ b/gcc/testsuite/gcc.target/powerpc/p9-permute.c
@@ -1,4 +1,4 @@
-/* { dg-do compile { target { powerpc64le-*-* } } } */
+/* { dg-do compile { target { powerpc64*-*-* } } } */
  /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
  /* { dg-options "-mcpu=power9 -O2" } */
  /* { dg-require-effective-target powerpc_p9vector_ok } */
@@ -17,5 +17,6 @@ permute (vector long long *p, vector long long *q, vector unsigned char mask)
    return vec_perm (a, b, mask);
  }
  
+/* expect xxpermr on little-endian, xxperm on big-endian */
  /* { dg-final { scan-assembler    "xxperm" } } */
  /* { dg-final { scan-assembler-not "vperm"  } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/p9-splat-1.c b/gcc/testsuite/gcc.target/powerpc/p9-splat-1.c

new file mode 100644 (file)

index 0000000..13b7287
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/p9-splat-1.c
@@ -0,0 +1,27 @@
+/* { dg-do compile { target { powerpc64le-*-* } } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-options "-mcpu=power9 -O2" } */
+/* { dg-require-effective-target powerpc_p9vector_ok } */
+
+#include <altivec.h>
+
+vector int
+foo_r (int a)
+{
+  return (vector int) { a, a, a, a };          /* mtvsrws */
+}
+
+vector int
+foo_r2 (int a)
+{
+  return vec_splats (a);                       /* mtvsrws */
+}
+
+vector int
+foo_p (int *a)
+{
+  return (vector int) { *a, *a, *a, *a };      /* lxvwsx */
+}
+
+/* { dg-final { scan-assembler-times "mtvsrws" 2 } } */
+/* { dg-final { scan-assembler-times "lxvwsx"  1 } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/p9-splat-2.c b/gcc/testsuite/gcc.target/powerpc/p9-splat-2.c

new file mode 100644 (file)

index 0000000..2468e92
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/p9-splat-2.c
@@ -0,0 +1,38 @@
+/* { dg-do compile { target { powerpc64le-*-* } } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-options "-mcpu=power9 -O2" } */
+/* { dg-require-effective-target powerpc_p9vector_ok } */
+
+#include <altivec.h>
+
+vector float
+foo_r (float a)
+{
+  return (vector float) { a, a, a, a };                        /* xscvdpspn/xxspltw */
+}
+
+vector float
+foo_r2 (float a)
+{
+  return vec_splats (a);                               /* xscvdpspn/xxspltw */
+}
+
+vector float
+foo_g (float *a)
+{
+  float f = *a;
+
+  __asm__ (" # %0" : "+r" (f));
+  return (vector float) { f, f, f, f };                        /* mtvsrws */
+}
+
+vector float
+foo_p (float *a)
+{
+  return (vector float) { *a, *a, *a, *a };            /* lxvwsx */
+}
+
+/* { dg-final { scan-assembler-times "xscvdpspn" 2 } } */
+/* { dg-final { scan-assembler-times "xxspltw"   2 } } */
+/* { dg-final { scan-assembler-times "mtvsrws"   1 } } */
+/* { dg-final { scan-assembler-times "lxvwsx"    1 } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/p9-splat-3.c b/gcc/testsuite/gcc.target/powerpc/p9-splat-3.c

new file mode 100644 (file)

index 0000000..8a121da
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/p9-splat-3.c
@@ -0,0 +1,61 @@
+/* { dg-do compile { target { powerpc64le-*-* } } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-options "-mcpu=power9 -O2" } */
+/* { dg-require-effective-target powerpc_p9vector_ok } */
+
+#include <altivec.h>
+
+typedef vector signed char     v16qi_t;
+typedef vector short           v8hi_t;
+typedef vector int             v4si_t;
+typedef vector long long       v2di_t;
+
+void v16qi_0a  (v16qi_t *p) { *p = (v16qi_t) { 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 }; }
+void v8hi_0a   (v8hi_t  *p) { *p = (v8hi_t)  { 0, 0, 0, 0, 0, 0, 0, 0 }; }
+void v4si_0a   (v4si_t  *p) { *p = (v4si_t)  { 0, 0, 0, 0 }; }
+void v2di_0a   (v2di_t  *p) { *p = (v2di_t)  { 0, 0 }; }
+
+void v16qi_0b  (v16qi_t *p) { *p = (v16qi_t) vec_splats ((signed char)0); }
+void v8hi_0b   (v8hi_t  *p) { *p = (v8hi_t)  vec_splats ((short)0); }
+void v4si_0b   (v4si_t  *p) { *p = (v4si_t)  vec_splats ((int)0); }
+void v2di_0b   (v2di_t  *p) { *p = (v2di_t)  vec_splats ((long long)0); }
+
+void v16qi_m1a (v16qi_t *p) { *p = (v16qi_t) { -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1 }; }
+void v8hi_m1a  (v8hi_t  *p) { *p = (v8hi_t)  { -1, -1, -1, -1, -1, -1, -1, -1 }; }
+void v4si_m1a  (v4si_t  *p) { *p = (v4si_t)  { -1, -1, -1, -1 }; }
+void v2di_m1a  (v2di_t  *p) { *p = (v2di_t)  { -1, -1 }; }
+
+void v16qi_m1b (v16qi_t *p) { *p = (v16qi_t) vec_splats ((signed char)-1); }
+void v8hi_m1b  (v8hi_t  *p) { *p = (v8hi_t)  vec_splats ((short)-1); }
+void v4si_m1b  (v4si_t  *p) { *p = (v4si_t)  vec_splats ((int)-1); }
+void v2di_m1b  (v2di_t  *p) { *p = (v2di_t)  vec_splats ((long long)-1); }
+
+void v16qi_5a  (v16qi_t *p) { *p = (v16qi_t) { 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5, 5 }; }
+void v8hi_5a   (v8hi_t  *p) { *p = (v8hi_t)  { 5, 5, 5, 5, 5, 5, 5, 5 }; }
+void v4si_5a   (v4si_t  *p) { *p = (v4si_t)  { 5, 5, 5, 5 }; }
+void v2di_5a   (v2di_t  *p) { *p = (v2di_t)  { 5, 5 }; }
+
+void v16qi_5b  (v16qi_t *p) { *p = (v16qi_t) vec_splats ((signed char)5); }
+void v8hi_5b   (v8hi_t  *p) { *p = (v8hi_t)  vec_splats ((short)5); }
+void v4si_5b   (v4si_t  *p) { *p = (v4si_t)  vec_splats ((int)5); }
+void v2di_5b   (v2di_t  *p) { *p = (v2di_t)  vec_splats ((long long)5); }
+
+void v16qi_33a (v16qi_t *p) { *p = (v16qi_t) { 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33, 33 }; }
+void v8hi_33a  (v8hi_t  *p) { *p = (v8hi_t)  { 33, 33, 33, 33, 33, 33, 33, 33 }; }
+void v4si_33a  (v4si_t  *p) { *p = (v4si_t)  { 33, 33, 33, 33 }; }
+void v2di_33a  (v2di_t  *p) { *p = (v2di_t)  { 33, 33 }; }
+
+void v16qi_33b (v16qi_t *p) { *p = (v16qi_t) vec_splats ((signed char)33); }
+void v8hi_33b  (v8hi_t  *p) { *p = (v8hi_t)  vec_splats ((short)33); }
+void v4si_33b  (v4si_t  *p) { *p = (v4si_t)  vec_splats ((int)33); }
+void v2di_33b  (v2di_t  *p) { *p = (v2di_t)  vec_splats ((long long)33); }
+
+/* { dg-final { scan-assembler     "xxspltib"     } } */
+/* { dg-final { scan-assembler     "vextsb2d"     } } */
+/* { dg-final { scan-assembler     "vextsb2w"     } } */
+/* { dg-final { scan-assembler     "vupk\[hl\]sb" } } */
+/* { dg-final { scan-assembler-not "lxvd2x"       } } */
+/* { dg-final { scan-assembler-not "lxvw4x"       } } */
+/* { dg-final { scan-assembler-not "lxv "         } } */
+/* { dg-final { scan-assembler-not "lxvx"         } } */
+/* { dg-final { scan-assembler-not "lvx"          } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/p9-splat-4.c b/gcc/testsuite/gcc.target/powerpc/p9-splat-4.c

new file mode 100644 (file)

index 0000000..d643324
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/p9-splat-4.c
@@ -0,0 +1,10 @@
+/* { dg-do compile { target { powerpc64*-*-* && lp64 } } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-options "-mcpu=power9 -O2" } */
+/* { dg-require-effective-target powerpc_p9vector_ok } */
+
+#include <altivec.h>
+
+vector long long foo (long long a) { return (vector long long) { a, a }; }
+
+/* { dg-final { scan-assembler "mtvsrdd" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/p9-vneg.c b/gcc/testsuite/gcc.target/powerpc/p9-vneg.c

new file mode 100644 (file)

index 0000000..10041c9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/p9-vneg.c
@@ -0,0 +1,12 @@
+/* { dg-do compile { target { powerpc64*-*-* } } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-require-effective-target powerpc_p9vector_ok } */
+/* { dg-options "-mcpu=power9 -O2" } */
+
+/* Verify P9 vector negate instructions.  */
+
+vector long long v2di_neg (vector long long a) { return -a; }
+vector int v4si_neg (vector int a) { return -a; }
+
+/* { dg-final { scan-assembler "vnegd" } } */
+/* { dg-final { scan-assembler "vnegw" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/p9-vparity.c b/gcc/testsuite/gcc.target/powerpc/p9-vparity.c

new file mode 100644 (file)

index 0000000..e4c2087
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/p9-vparity.c
@@ -0,0 +1,107 @@
+/* { dg-do compile { target { powerpc64*-*-* && lp64 } } } */
+/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */
+/* { dg-require-effective-target powerpc_p9vector_ok } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-options "-mcpu=power9 -O2 -mlra -mvsx-timode" } */
+
+#include <altivec.h>
+
+vector int
+parity_v4si_1s (vector int a)
+{
+  return vec_vprtyb (a);
+}
+
+vector int
+parity_v4si_2s (vector int a)
+{
+  return vec_vprtybw (a);
+}
+
+vector unsigned int
+parity_v4si_1u (vector unsigned int a)
+{
+  return vec_vprtyb (a);
+}
+
+vector unsigned int
+parity_v4si_2u (vector unsigned int a)
+{
+  return vec_vprtybw (a);
+}
+
+vector long long
+parity_v2di_1s (vector long long a)
+{
+  return vec_vprtyb (a);
+}
+
+vector long long
+parity_v2di_2s (vector long long a)
+{
+  return vec_vprtybd (a);
+}
+
+vector unsigned long long
+parity_v2di_1u (vector unsigned long long a)
+{
+  return vec_vprtyb (a);
+}
+
+vector unsigned long long
+parity_v2di_2u (vector unsigned long long a)
+{
+  return vec_vprtybd (a);
+}
+
+vector __int128_t
+parity_v1ti_1s (vector __int128_t a)
+{
+  return vec_vprtyb (a);
+}
+
+vector __int128_t
+parity_v1ti_2s (vector __int128_t a)
+{
+  return vec_vprtybq (a);
+}
+
+__int128_t
+parity_ti_3s (__int128_t a)
+{
+  return vec_vprtyb (a);
+}
+
+__int128_t
+parity_ti_4s (__int128_t a)
+{
+  return vec_vprtybq (a);
+}
+
+vector __uint128_t
+parity_v1ti_1u (vector __uint128_t a)
+{
+  return vec_vprtyb (a);
+}
+
+vector __uint128_t
+parity_v1ti_2u (vector __uint128_t a)
+{
+  return vec_vprtybq (a);
+}
+
+__uint128_t
+parity_ti_3u (__uint128_t a)
+{
+  return vec_vprtyb (a);
+}
+
+__uint128_t
+parity_ti_4u (__uint128_t a)
+{
+  return vec_vprtybq (a);
+}
+
+/* { dg-final { scan-assembler "vprtybd" } } */
+/* { dg-final { scan-assembler "vprtybq" } } */
+/* { dg-final { scan-assembler "vprtybw" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/p9-vpermr.c b/gcc/testsuite/gcc.target/powerpc/p9-vpermr.c

new file mode 100644 (file)

index 0000000..7e7a266
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/p9-vpermr.c
@@ -0,0 +1,21 @@
+/* { dg-do compile { target { powerpc64le-*-* } } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-options "-mcpu=power9 -O2" } */
+
+/* Test generation of VPERMR/XXPERMR on ISA 3.0 in little endian.  */
+
+#include <altivec.h>
+
+vector long long
+permute (vector long long *p, vector long long *q, vector unsigned char mask)
+{
+  vector long long a = *p;
+  vector long long b = *q;
+
+  /* Force a, b to be in altivec registers to select vpermr insn.  */
+  __asm__ (" # a: %x0, b: %x1" : "+v" (a), "+v" (b));
+
+  return vec_perm (a, b, mask);
+}
+
+/* { dg-final { scan-assembler "vpermr\|xxpermr" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/pr47755.c b/gcc/testsuite/gcc.target/powerpc/pr47755.c

index 8feef29..d5feeca 100644 (file)
--- a/gcc/testsuite/gcc.target/powerpc/pr47755.c
+++ b/gcc/testsuite/gcc.target/powerpc/pr47755.c
@@ -3,7 +3,7 @@
  /* { dg-require-effective-target powerpc_vsx_ok } */
  /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power7" } } */
  /* { dg-options "-O3 -mcpu=power7" } */
-/* { dg-final { scan-assembler "xxlxor" } } */
+/* { dg-final { scan-assembler "xxlxor\|vspltis\[bhw\]" } } */
  /* { dg-final { scan-assembler-not "lxvd2x" } } */
  /* { dg-final { scan-assembler-not "lxvw4x" } } */
  /* { dg-final { scan-assembler-not "lvx" } } */
diff --git a/gcc/testsuite/gcc.target/powerpc/pr68805.c b/gcc/testsuite/gcc.target/powerpc/pr68805.c

index f4454a9..5510811 100644 (file)
--- a/gcc/testsuite/gcc.target/powerpc/pr68805.c
+++ b/gcc/testsuite/gcc.target/powerpc/pr68805.c
@@ -1,6 +1,6 @@
  /* { dg-do compile { target powerpc64le-*-* } } */
  /* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
-/* { dg-options "-O2 -mvsx-timode -mcpu=power8" } */
+/* { dg-options "-O2 -mvsx-timode -mcpu=power8 -mlra" } */
  
  typedef struct bar {
    void *a;
diff --git a/gcc/testsuite/gcc.target/powerpc/pr70963.c b/gcc/testsuite/gcc.target/powerpc/pr70963.c

new file mode 100644 (file)

index 0000000..128ebd9
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr70963.c
@@ -0,0 +1,44 @@
+/* { dg-do run { target powerpc64*-*-* } } */
+/* { dg-require-effective-target p8vector_hw } */
+/* { dg-skip-if "" { powerpc*-*-darwin* } { "*" } { "" } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
+/* { dg-options "-mcpu=power8" } */
+
+#include <stdlib.h>
+#include <stdio.h>
+#include <altivec.h>
+
+static int failed;
+static void test (void);
+
+static void check (int result, const char *name)
+{
+  if (!result)
+    {
+      failed++;
+      printf ("fail %s\n", name);
+    }
+}
+    
+int main (void)
+{
+  test ();
+  if (failed)
+    abort ();
+  return 0;
+}
+
+vector double x = { 81.0, 76.0 };
+vector long long y = { 81, 76 };
+
+static void test()
+{
+  vector long long a = vec_cts (x, 0);
+  vector double b = vec_ctf (a, 0);
+  vector long long c = __builtin_vsx_xvcvdpuxds_scale (x, 0);
+  vector double d = vec_ctf (c, 0);
+  check (vec_all_eq (a, y), "vec_cts");
+  check (vec_all_eq (b, x), "vec_ctf");
+  check (vec_all_eq (c, y), "xvcvdpuxds");
+  check (vec_all_eq (d, x), "vec_ctf unsigned");
+}
diff --git a/gcc/testsuite/gcc.target/powerpc/pr71186.c b/gcc/testsuite/gcc.target/powerpc/pr71186.c

new file mode 100644 (file)

index 0000000..22762cc
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/pr71186.c
@@ -0,0 +1,32 @@
+/* { dg-do compile { target { powerpc64*-*-* && lp64 } } } */
+/* { dg-skip-if "do not override -mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-options "-mcpu=power9 -O2" } */
+/* { dg-require-effective-target powerpc_p9vector_ok } */
+
+static unsigned short x[(16384/sizeof(unsigned short))] __attribute__ ((aligned (16)));
+static unsigned short y[(16384/sizeof(unsigned short))] __attribute__ ((aligned (16)));
+static unsigned short a;
+
+void obfuscate(void *a, ...);
+
+static void __attribute__((noinline)) do_one(void)
+{
+ unsigned long i;
+
+ obfuscate(x, y, &a);
+
+ for (i = 0; i < (16384/sizeof(unsigned short)); i++)
+  y[i] = a * x[i];
+
+ obfuscate(x, y, &a);
+}
+
+int main(void)
+{
+ unsigned long i;
+
+ for (i = 0; i < 1000000; i++)
+  do_one();
+
+ return 0;
+}
diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-elemrev-1.c b/gcc/testsuite/gcc.target/powerpc/vsx-elemrev-1.c

new file mode 100644 (file)

index 0000000..7ab6d44
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/vsx-elemrev-1.c
@@ -0,0 +1,143 @@
+/* { dg-do compile { target { powerpc64le*-*-* } } } */
+/* { dg-skip-if "do not override mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
+/* { dg-options "-mcpu=power8 -O0" } */
+/* { dg-final { scan-assembler-times "lxvd2x" 18 } } */
+/* { dg-final { scan-assembler-times "lxvw4x" 6 } } */
+/* { dg-final { scan-assembler-times "stxvd2x" 18 } } */
+/* { dg-final { scan-assembler-times "stxvw4x" 6 } } */
+/* { dg-final { scan-assembler-times "xxpermdi" 24 } } */
+
+#include <altivec.h>
+
+extern vector double vd, *vdp;
+extern vector signed long long vsll, *vsllp;
+extern vector unsigned long long vull, *vullp;
+extern vector float vf, *vfp;
+extern vector signed int vsi, *vsip;
+extern vector unsigned int vui, *vuip;
+extern double *dp;
+extern signed long long *sllp;
+extern unsigned long long *ullp;
+extern float *fp;
+extern signed int *sip;
+extern unsigned int *uip;
+
+void foo0 (void)
+{
+  vd = vec_xl (0, vdp);
+}
+
+void foo1 (void)
+{
+  vsll = vec_xl (0, vsllp);
+}
+
+void foo2 (void)
+{
+  vull = vec_xl (0, vullp);
+}
+
+void foo3 (void)
+{
+  vf = vec_xl (0, vfp);
+}
+
+void foo4 (void)
+{
+  vsi = vec_xl (0, vsip);
+}
+
+void foo5 (void)
+{
+  vui = vec_xl (0, vuip);
+}
+
+void foo6 (void)
+{
+  vec_xst (vd, 0, vdp);
+}
+
+void foo7 (void)
+{
+  vec_xst (vsll, 0, vsllp);
+}
+
+void foo8 (void)
+{
+  vec_xst (vull, 0, vullp);
+}
+
+void foo9 (void)
+{
+  vec_xst (vf, 0, vfp);
+}
+
+void foo10 (void)
+{
+  vec_xst (vsi, 0, vsip);
+}
+
+void foo11 (void)
+{
+  vec_xst (vui, 0, vuip);
+}
+
+void foo20 (void)
+{
+  vd = vec_xl (0, dp);
+}
+
+void foo21 (void)
+{
+  vsll = vec_xl (0, sllp);
+}
+
+void foo22 (void)
+{
+  vull = vec_xl (0, ullp);
+}
+
+void foo23 (void)
+{
+  vf = vec_xl (0, fp);
+}
+
+void foo24 (void)
+{
+  vsi = vec_xl (0, sip);
+}
+
+void foo25 (void)
+{
+  vui = vec_xl (0, uip);
+}
+
+void foo26 (void)
+{
+  vec_xst (vd, 0, dp);
+}
+
+void foo27 (void)
+{
+  vec_xst (vsll, 0, sllp);
+}
+
+void foo28 (void)
+{
+  vec_xst (vull, 0, ullp);
+}
+
+void foo29 (void)
+{
+  vec_xst (vf, 0, fp);
+}
+
+void foo30 (void)
+{
+  vec_xst (vsi, 0, sip);
+}
+
+void foo31 (void)
+{
+  vec_xst (vui, 0, uip);
+}
diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-elemrev-2.c b/gcc/testsuite/gcc.target/powerpc/vsx-elemrev-2.c

new file mode 100644 (file)

index 0000000..28b6254
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/vsx-elemrev-2.c
@@ -0,0 +1,235 @@
+/* { dg-do compile { target { powerpc64le*-*-* } } } */
+/* { dg-skip-if "do not override mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-options "-mcpu=power9 -O0" } */
+/* { dg-require-effective-target p9vector_hw } */
+/* { dg-final { scan-assembler-times "lxvd2x" 6 } } */
+/* { dg-final { scan-assembler-times "lxvw4x" 6 } } */
+/* { dg-final { scan-assembler-times "lxvh8x" 4 } } */
+/* { dg-final { scan-assembler-times "lxvb16x" 4 } } */
+/* { dg-final { scan-assembler-times "stxvd2x" 6 } } */
+/* { dg-final { scan-assembler-times "stxvw4x" 6 } } */
+/* { dg-final { scan-assembler-times "stxvh8x" 4 } } */
+/* { dg-final { scan-assembler-times "stxvb16x" 4 } } */
+
+#include <altivec.h>
+
+extern vector double vd, *vdp;
+extern vector signed long long vsll, *vsllp;
+extern vector unsigned long long vull, *vullp;
+extern vector float vf, *vfp;
+extern vector signed int vsi, *vsip;
+extern vector unsigned int vui, *vuip;
+extern vector signed short vss, *vssp;
+extern vector unsigned short vus, *vusp;
+extern vector signed char vsc, *vscp;
+extern vector unsigned char vuc, *vucp;
+extern double *dp;
+extern signed long long *sllp;
+extern unsigned long long *ullp;
+extern float *fp;
+extern signed int *sip;
+extern unsigned int *uip;
+extern signed short *ssp;
+extern unsigned short *usp;
+extern signed char *scp;
+extern unsigned char *ucp;
+
+void foo0 (void)
+{
+  vd = vec_xl (0, vdp);
+}
+
+void foo1 (void)
+{
+  vsll = vec_xl (0, vsllp);
+}
+
+void foo2 (void)
+{
+  vull = vec_xl (0, vullp);
+}
+
+void foo3 (void)
+{
+  vf = vec_xl (0, vfp);
+}
+
+void foo4 (void)
+{
+  vsi = vec_xl (0, vsip);
+}
+
+void foo5 (void)
+{
+  vui = vec_xl (0, vuip);
+}
+
+void foo6 (void)
+{
+  vss = vec_xl (0, vssp);
+}
+
+void foo7 (void)
+{
+  vus = vec_xl (0, vusp);
+}
+
+void foo8 (void)
+{
+  vsc = vec_xl (0, vscp);
+}
+
+void foo9 (void)
+{
+  vuc = vec_xl (0, vucp);
+}
+
+void foo10 (void)
+{
+  vec_xst (vd, 0, vdp);
+}
+
+void foo11 (void)
+{
+  vec_xst (vsll, 0, vsllp);
+}
+
+void foo12 (void)
+{
+  vec_xst (vull, 0, vullp);
+}
+
+void foo13 (void)
+{
+  vec_xst (vf, 0, vfp);
+}
+
+void foo14 (void)
+{
+  vec_xst (vsi, 0, vsip);
+}
+
+void foo15 (void)
+{
+  vec_xst (vui, 0, vuip);
+}
+
+void foo16 (void)
+{
+  vec_xst (vss, 0, vssp);
+}
+
+void foo17 (void)
+{
+  vec_xst (vus, 0, vusp);
+}
+
+void foo18 (void)
+{
+  vec_xst (vsc, 0, vscp);
+}
+
+void foo19 (void)
+{
+  vec_xst (vuc, 0, vucp);
+}
+
+void foo20 (void)
+{
+  vd = vec_xl (0, dp);
+}
+
+void foo21 (void)
+{
+  vsll = vec_xl (0, sllp);
+}
+
+void foo22 (void)
+{
+  vull = vec_xl (0, ullp);
+}
+
+void foo23 (void)
+{
+  vf = vec_xl (0, fp);
+}
+
+void foo24 (void)
+{
+  vsi = vec_xl (0, sip);
+}
+
+void foo25 (void)
+{
+  vui = vec_xl (0, uip);
+}
+
+void foo26 (void)
+{
+  vss = vec_xl (0, ssp);
+}
+
+void foo27 (void)
+{
+  vus = vec_xl (0, usp);
+}
+
+void foo28 (void)
+{
+  vsc = vec_xl (0, scp);
+}
+
+void foo29 (void)
+{
+  vuc = vec_xl (0, ucp);
+}
+
+void foo30 (void)
+{
+  vec_xst (vd, 0, dp);
+}
+
+void foo31 (void)
+{
+  vec_xst (vsll, 0, sllp);
+}
+
+void foo32 (void)
+{
+  vec_xst (vull, 0, ullp);
+}
+
+void foo33 (void)
+{
+  vec_xst (vf, 0, fp);
+}
+
+void foo34 (void)
+{
+  vec_xst (vsi, 0, sip);
+}
+
+void foo35 (void)
+{
+  vec_xst (vui, 0, uip);
+}
+
+void foo36 (void)
+{
+  vec_xst (vss, 0, ssp);
+}
+
+void foo37 (void)
+{
+  vec_xst (vus, 0, usp);
+}
+
+void foo38 (void)
+{
+  vec_xst (vsc, 0, scp);
+}
+
+void foo39 (void)
+{
+  vec_xst (vuc, 0, ucp);
+}
diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-elemrev-3.c b/gcc/testsuite/gcc.target/powerpc/vsx-elemrev-3.c

new file mode 100644 (file)

index 0000000..2888c17
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/vsx-elemrev-3.c
@@ -0,0 +1,142 @@
+/* { dg-do compile { target { powerpc64-*-* } } } */
+/* { dg-skip-if "do not override mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power8" } } */
+/* { dg-options "-mcpu=power8 -O0" } */
+/* { dg-final { scan-assembler-times "lxvd2x" 16 } } */
+/* { dg-final { scan-assembler-times "lxvw4x" 8 } } */
+/* { dg-final { scan-assembler-times "stxvd2x" 16 } } */
+/* { dg-final { scan-assembler-times "stxvw4x" 8 } } */
+
+#include <altivec.h>
+
+extern vector double vd, *vdp;
+extern vector signed long long vsll, *vsllp;
+extern vector unsigned long long vull, *vullp;
+extern vector float vf, *vfp;
+extern vector signed int vsi, *vsip;
+extern vector unsigned int vui, *vuip;
+extern double *dp;
+extern signed long long *sllp;
+extern unsigned long long *ullp;
+extern float *fp;
+extern signed int *sip;
+extern unsigned int *uip;
+
+void foo0 (void)
+{
+  vd = vec_xl (0, vdp);
+}
+
+void foo1 (void)
+{
+  vsll = vec_xl (0, vsllp);
+}
+
+void foo2 (void)
+{
+  vull = vec_xl (0, vullp);
+}
+
+void foo3 (void)
+{
+  vf = vec_xl (0, vfp);
+}
+
+void foo4 (void)
+{
+  vsi = vec_xl (0, vsip);
+}
+
+void foo5 (void)
+{
+  vui = vec_xl (0, vuip);
+}
+
+void foo6 (void)
+{
+  vec_xst (vd, 0, vdp);
+}
+
+void foo7 (void)
+{
+  vec_xst (vsll, 0, vsllp);
+}
+
+void foo8 (void)
+{
+  vec_xst (vull, 0, vullp);
+}
+
+void foo9 (void)
+{
+  vec_xst (vf, 0, vfp);
+}
+
+void foo10 (void)
+{
+  vec_xst (vsi, 0, vsip);
+}
+
+void foo11 (void)
+{
+  vec_xst (vui, 0, vuip);
+}
+
+void foo20 (void)
+{
+  vd = vec_xl (0, dp);
+}
+
+void foo21 (void)
+{
+  vsll = vec_xl (0, sllp);
+}
+
+void foo22 (void)
+{
+  vull = vec_xl (0, ullp);
+}
+
+void foo23 (void)
+{
+  vf = vec_xl (0, fp);
+}
+
+void foo24 (void)
+{
+  vsi = vec_xl (0, sip);
+}
+
+void foo25 (void)
+{
+  vui = vec_xl (0, uip);
+}
+
+void foo26 (void)
+{
+  vec_xst (vd, 0, dp);
+}
+
+void foo27 (void)
+{
+  vec_xst (vsll, 0, sllp);
+}
+
+void foo28 (void)
+{
+  vec_xst (vull, 0, ullp);
+}
+
+void foo29 (void)
+{
+  vec_xst (vf, 0, fp);
+}
+
+void foo30 (void)
+{
+  vec_xst (vsi, 0, sip);
+}
+
+void foo31 (void)
+{
+  vec_xst (vui, 0, uip);
+}
diff --git a/gcc/testsuite/gcc.target/powerpc/vsx-elemrev-4.c b/gcc/testsuite/gcc.target/powerpc/vsx-elemrev-4.c

new file mode 100644 (file)

index 0000000..9a7a994
--- /dev/null
+++ b/gcc/testsuite/gcc.target/powerpc/vsx-elemrev-4.c
@@ -0,0 +1,229 @@
+/* { dg-do compile { target { powerpc64-*-* } } } */
+/* { dg-skip-if "do not override mcpu" { powerpc*-*-* } { "-mcpu=*" } { "-mcpu=power9" } } */
+/* { dg-options "-mcpu=power9 -O0" } */
+/* { dg-require-effective-target p9vector_hw } */
+/* { dg-final { scan-assembler-times "lxvx" 40 } } */
+/* { dg-final { scan-assembler-times "stxvx" 40 } } */
+
+#include <altivec.h>
+
+extern vector double vd, *vdp;
+extern vector signed long long vsll, *vsllp;
+extern vector unsigned long long vull, *vullp;
+extern vector float vf, *vfp;
+extern vector signed int vsi, *vsip;
+extern vector unsigned int vui, *vuip;
+extern vector signed short vss, *vssp;
+extern vector unsigned short vus, *vusp;
+extern vector signed char vsc, *vscp;
+extern vector unsigned char vuc, *vucp;
+extern double *dp;
+extern signed long long *sllp;
+extern unsigned long long *ullp;
+extern float *fp;
+extern signed int *sip;
+extern unsigned int *uip;
+extern signed short *ssp;
+extern unsigned short *usp;
+extern signed char *scp;
+extern unsigned char *ucp;
+
+void foo0 (void)
+{
+  vd = vec_xl (0, vdp);
+}
+
+void foo1 (void)
+{
+  vsll = vec_xl (0, vsllp);
+}
+
+void foo2 (void)
+{
+  vull = vec_xl (0, vullp);
+}
+
+void foo3 (void)
+{
+  vf = vec_xl (0, vfp);
+}
+
+void foo4 (void)
+{
+  vsi = vec_xl (0, vsip);
+}
+
+void foo5 (void)
+{
+  vui = vec_xl (0, vuip);
+}
+
+void foo6 (void)
+{
+  vss = vec_xl (0, vssp);
+}
+
+void foo7 (void)
+{
+  vus = vec_xl (0, vusp);
+}
+
+void foo8 (void)
+{
+  vsc = vec_xl (0, vscp);
+}
+
+void foo9 (void)
+{
+  vuc = vec_xl (0, vucp);
+}
+
+void foo10 (void)
+{
+  vec_xst (vd, 0, vdp);
+}
+
+void foo11 (void)
+{
+  vec_xst (vsll, 0, vsllp);
+}
+
+void foo12 (void)
+{
+  vec_xst (vull, 0, vullp);
+}
+
+void foo13 (void)
+{
+  vec_xst (vf, 0, vfp);
+}
+
+void foo14 (void)
+{
+  vec_xst (vsi, 0, vsip);
+}
+
+void foo15 (void)
+{
+  vec_xst (vui, 0, vuip);
+}
+
+void foo16 (void)
+{
+  vec_xst (vss, 0, vssp);
+}
+
+void foo17 (void)
+{
+  vec_xst (vus, 0, vusp);
+}
+
+void foo18 (void)
+{
+  vec_xst (vsc, 0, vscp);
+}
+
+void foo19 (void)
+{
+  vec_xst (vuc, 0, vucp);
+}
+
+void foo20 (void)
+{
+  vd = vec_xl (0, dp);
+}
+
+void foo21 (void)
+{
+  vsll = vec_xl (0, sllp);
+}
+
+void foo22 (void)
+{
+  vull = vec_xl (0, ullp);
+}
+
+void foo23 (void)
+{
+  vf = vec_xl (0, fp);
+}
+
+void foo24 (void)
+{
+  vsi = vec_xl (0, sip);
+}
+
+void foo25 (void)
+{
+  vui = vec_xl (0, uip);
+}
+
+void foo26 (void)
+{
+  vss = vec_xl (0, ssp);
+}
+
+void foo27 (void)
+{
+  vus = vec_xl (0, usp);
+}
+
+void foo28 (void)
+{
+  vsc = vec_xl (0, scp);
+}
+
+void foo29 (void)
+{
+  vuc = vec_xl (0, ucp);
+}
+
+void foo30 (void)
+{
+  vec_xst (vd, 0, dp);
+}
+
+void foo31 (void)
+{
+  vec_xst (vsll, 0, sllp);
+}
+
+void foo32 (void)
+{
+  vec_xst (vull, 0, ullp);
+}
+
+void foo33 (void)
+{
+  vec_xst (vf, 0, fp);
+}
+
+void foo34 (void)
+{
+  vec_xst (vsi, 0, sip);
+}
+
+void foo35 (void)
+{
+  vec_xst (vui, 0, uip);
+}
+
+void foo36 (void)
+{
+  vec_xst (vss, 0, ssp);
+}
+
+void foo37 (void)
+{
+  vec_xst (vus, 0, usp);
+}
+
+void foo38 (void)
+{
+  vec_xst (vsc, 0, scp);
+}
+
+void foo39 (void)
+{
+  vec_xst (vuc, 0, ucp);
+}
diff --git a/gcc/testsuite/gcc.target/sparc/fpcmp.c b/gcc/testsuite/gcc.target/sparc/fpcmp.c

new file mode 100644 (file)

index 0000000..1255d67
--- /dev/null
+++ b/gcc/testsuite/gcc.target/sparc/fpcmp.c
@@ -0,0 +1,18 @@
+/* { dg-do compile } */
+/* { dg-options "-mvis4" } */
+
+typedef unsigned char vec8 __attribute__((vector_size(8)));
+
+long test_fpcmple8 (vec8 a, vec8 b)
+{
+  return __builtin_vis_fpcmple8 (a, b);
+}
+
+long test_fpcmpgt8 (vec8 a, vec8 b)
+{
+  return __builtin_vis_fpcmpgt8 (a, b);
+}
+
+/* { dg-final { scan-assembler "fpcmple8\t%" } } */
+/* { dg-final { scan-assembler "fpcmpgt8\t%" } } */
+
diff --git a/gcc/testsuite/gcc.target/sparc/fpcmpu.c b/gcc/testsuite/gcc.target/sparc/fpcmpu.c

new file mode 100644 (file)

index 0000000..816a22d
--- /dev/null
+++ b/gcc/testsuite/gcc.target/sparc/fpcmpu.c
@@ -0,0 +1,31 @@
+/* { dg-do compile } */
+/* { dg-options "-mvis4" } */
+
+
+typedef short vec16 __attribute__((vector_size(8)));
+typedef int vec32 __attribute__((vector_size(8)));
+
+long test_fpcmpule16 (vec16 a, vec16 b)
+{
+  return __builtin_vis_fpcmpule16 (a, b);
+}
+
+long test_fpcmpugt16 (vec16 a, vec16 b)
+{
+  return __builtin_vis_fpcmpugt16 (a, b);
+}
+
+long test_fpcmpule32 (vec32 a, vec32 b)
+{
+  return __builtin_vis_fpcmpule32 (a, b);
+}
+
+long test_fpcmpugt32 (vec32 a, vec32 b)
+{
+  return __builtin_vis_fpcmpugt32 (a, b);
+}
+
+/* { dg-final { scan-assembler "fpcmpule16\t%" } } */
+/* { dg-final { scan-assembler "fpcmpugt16\t%" } } */
+/* { dg-final { scan-assembler "fpcmpule32\t%" } } */
+/* { dg-final { scan-assembler "fpcmpugt32\t%" } } */
diff --git a/gcc/testsuite/gcc.target/sparc/vis4misc.c b/gcc/testsuite/gcc.target/sparc/vis4misc.c

new file mode 100644 (file)

index 0000000..b520b12
--- /dev/null
+++ b/gcc/testsuite/gcc.target/sparc/vis4misc.c
@@ -0,0 +1,126 @@
+/* { dg-do compile } */
+/* { dg-options "-mvis4" } */
+typedef int __v2si __attribute__((vector_size(8)));
+typedef short __v4hi __attribute__((vector_size(8)));
+typedef unsigned char __v8qi __attribute__((vector_size(8)));
+
+__v8qi test_fpadd8 (__v8qi x, __v8qi y)
+{
+  return __builtin_vis_fpadd8 (x, y);
+}
+
+__v8qi test_fpadds8 (__v8qi x, __v8qi y)
+{
+  return __builtin_vis_fpadds8 (x, y);
+}
+
+__v8qi test_fpaddus8 (__v8qi x, __v8qi y)
+{
+  return __builtin_vis_fpaddus8 (x, y);
+}
+
+__v4hi test_fpaddus16 (__v4hi x, __v4hi y)
+{
+  return __builtin_vis_fpaddus16 (x, y);
+}
+
+__v8qi test_fpsub8 (__v8qi x, __v8qi y)
+{
+  return __builtin_vis_fpsub8 (x, y);
+}
+
+__v8qi test_fpsubs8 (__v8qi x, __v8qi y)
+{
+  return __builtin_vis_fpsubs8 (x, y);
+}
+
+__v8qi test_fpsubus8 (__v8qi x, __v8qi y)
+{
+  return __builtin_vis_fpsubus8 (x, y);
+}
+
+__v4hi test_fpsubus16 (__v4hi x, __v4hi y)
+{
+  return __builtin_vis_fpsubus16 (x, y);
+}
+
+__v8qi test_fpmax8 (__v8qi x, __v8qi y)
+{
+  return __builtin_vis_fpmax8 (x, y);
+}
+
+__v4hi test_fpmax16 (__v4hi x, __v4hi y)
+{
+  return __builtin_vis_fpmax16 (x, y);
+}
+
+__v2si test_fpmax32 (__v2si x, __v2si y)
+{
+  return __builtin_vis_fpmax32 (x, y);
+}
+
+__v8qi test_fpmaxu8 (__v8qi x, __v8qi y)
+{
+  return __builtin_vis_fpmaxu8 (x, y);
+}
+
+__v4hi test_fpmaxu16 (__v4hi x, __v4hi y)
+{
+  return __builtin_vis_fpmaxu16 (x, y);
+}
+
+__v2si test_fpmaxu32 (__v2si x, __v2si y)
+{
+  return __builtin_vis_fpmaxu32 (x, y);
+}
+
+__v8qi test_fpmin8 (__v8qi x, __v8qi y)
+{
+  return __builtin_vis_fpmin8 (x, y);
+}
+
+__v4hi test_fpmin16 (__v4hi x, __v4hi y)
+{
+  return __builtin_vis_fpmin16 (x, y);
+}
+
+__v2si test_fpmin32 (__v2si x, __v2si y)
+{
+  return __builtin_vis_fpmin32 (x, y);
+}
+
+__v8qi test_fpminu8 (__v8qi x, __v8qi y)
+{
+  return __builtin_vis_fpminu8 (x, y);
+}
+
+__v4hi test_fpminu16 (__v4hi x, __v4hi y)
+{
+  return __builtin_vis_fpminu16 (x, y);
+}
+
+__v2si test_fpminu32 (__v2si x, __v2si y)
+{
+  return __builtin_vis_fpminu32 (x, y);
+}
+
+/* { dg-final { scan-assembler "fpadd8\t%" } } */
+/* { dg-final { scan-assembler "fpadds8\t%" } } */
+/* { dg-final { scan-assembler "fpaddus8\t%" } } */
+/* { dg-final { scan-assembler "fpaddus16\t%" } } */
+/* { dg-final { scan-assembler "fpsub8\t%" } } */
+/* { dg-final { scan-assembler "fpsubs8\t%" } } */
+/* { dg-final { scan-assembler "fpsubus8\t%" } } */
+/* { dg-final { scan-assembler "fpsubus16\t%" } } */
+/* { dg-final { scan-assembler "fpmax8\t%" } } */
+/* { dg-final { scan-assembler "fpmax16\t%" } } */
+/* { dg-final { scan-assembler "fpmax32\t%" } } */
+/* { dg-final { scan-assembler "fpmaxu8\t%" } } */
+/* { dg-final { scan-assembler "fpmaxu16\t%" } } */
+/* { dg-final { scan-assembler "fpmaxu32\t%" } } */
+/* { dg-final { scan-assembler "fpmin8\t%" } } */
+/* { dg-final { scan-assembler "fpmin16\t%" } } */
+/* { dg-final { scan-assembler "fpmin32\t%" } } */
+/* { dg-final { scan-assembler "fpminu8\t%" } } */
+/* { dg-final { scan-assembler "fpminu16\t%" } } */
+/* { dg-final { scan-assembler "fpminu32\t%" } } */
diff --git a/gcc/testsuite/gfortran.dg/array_constructor_49.f90 b/gcc/testsuite/gfortran.dg/array_constructor_49.f90

index ca963d3..0f5036a 100644 (file)
--- a/gcc/testsuite/gfortran.dg/array_constructor_49.f90
+++ b/gcc/testsuite/gfortran.dg/array_constructor_49.f90
@@ -6,7 +6,7 @@
  program t
    integer :: ndim=2, ndfp=4, i
    character (len=8) :: line
-  write (unit=line,fmt='(4I2)'), (/ ( i, i = 1, ndfp ) /) + ndim
+  write (unit=line,fmt='(4I2)') (/ ( i, i = 1, ndfp ) /) + ndim
    if (line /= ' 3 4 5 6') call abort
  end program t
  ! { dg-final { scan-tree-dump-times "__var" 3 "original" } }
diff --git a/gcc/testsuite/gfortran.dg/class_array_22.f03 b/gcc/testsuite/gfortran.dg/class_array_22.f03

new file mode 100644 (file)

index 0000000..9410741
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/class_array_22.f03
@@ -0,0 +1,25 @@
+! { dg-do compile }
+! { dg-options "-frepack-arrays " }
+!
+! Original class_array_11.f03 but with -frepack-arrays a new
+! ICE was produced reported in
+! PR fortran/69659
+!
+! Original testcase by Ian Harvey <ian_harvey@bigpond.com>
+! Reduced by Janus Weil <Janus@gcc.gnu.org>
+
+  IMPLICIT NONE
+
+  TYPE :: ParentVector
+    INTEGER :: a
+  END TYPE ParentVector
+
+CONTAINS
+
+  SUBROUTINE vector_operation(pvec)
+    CLASS(ParentVector), INTENT(INOUT) :: pvec(:)
+    print *,pvec(1)%a
+  END SUBROUTINE
+
+END
+
diff --git a/gcc/testsuite/gfortran.dg/comma_IO_extension_1.f90 b/gcc/testsuite/gfortran.dg/comma_IO_extension_1.f90

new file mode 100644 (file)

index 0000000..abbb69d
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/comma_IO_extension_1.f90
@@ -0,0 +1,8 @@
+! { dg-do compile }
+! PR 60751
+! Contributed by Walter Spector <w6ws@earthlink.net>
+program extracomma
+  implicit none
+
+  write (*,*), 1, 2, 3 ! { dg-warning "Legacy Extension: Comma before i/o item list" }
+end program
diff --git a/gcc/testsuite/gfortran.dg/comma_IO_extension_2.f90 b/gcc/testsuite/gfortran.dg/comma_IO_extension_2.f90

new file mode 100644 (file)

index 0000000..5e80a17
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/comma_IO_extension_2.f90
@@ -0,0 +1,9 @@
+! { dg-do compile }
+! { dg-options "-std=legacy" }
+! PR 60751
+! Contributed by Walter Spector <w6ws@earthlink.net>
+program extracomma
+  implicit none
+
+  write (*,*), 1, 2, 3
+end program
diff --git a/gcc/testsuite/gfortran.dg/dec_structure_1.f90 b/gcc/testsuite/gfortran.dg/dec_structure_1.f90

new file mode 100644 (file)

index 0000000..4dfee3c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_structure_1.f90
@@ -0,0 +1,56 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Basic STRUCTURE test.
+!
+
+subroutine aborts (s)
+  character(*), intent(in) :: s
+  print *, s
+  call abort()
+end subroutine
+
+! Basic structure
+structure /s1/                ! type s1
+  integer i1
+  logical l1
+  real r1
+  character c1
+end structure                 ! end type s1
+
+record /s1/ r1                ! type (s1) r1
+record /s1/ r1_a(3)           ! type (s1) r1_a(3)
+
+! Basic records
+r1.i1 = 13579                  ! r1%i1 = ...
+r1.l1 = .true.
+r1.r1 = 13.579
+r1.c1 = 'F'
+r1_a(2) = r1
+r1_a(3).r1 = 135.79
+
+if (r1.i1 .ne. 13579) then
+  call aborts("r1.i1")
+endif
+
+if (r1.l1 .neqv. .true.) then
+  call aborts("r1.l1")
+endif
+
+if (r1.r1 .ne. 13.579) then
+  call aborts("r1.r1")
+endif
+
+if (r1.c1 .ne. 'F') then
+  call aborts("r1.c1")
+endif
+
+if (r1_a(2).i1 .ne. 13579) then
+  call aborts("r1_a(2).i1")
+endif
+
+if (r1_a(3).r1 .ne. 135.79) then
+  call aborts("r1_a(3).r1")
+endif
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_structure_10.f90 b/gcc/testsuite/gfortran.dg/dec_structure_10.f90

new file mode 100644 (file)

index 0000000..2d92b1a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_structure_10.f90
@@ -0,0 +1,119 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Runtime tests for rules governing dot ('.') as a member accessor, including
+! voodoo with aliased user-defined vs. intrinsic operators and nested members.
+! See gcc/fortran/match.c (gfc_match_member_sep).
+!
+
+module dec_structure_10
+  ! Operator overload tests with .ne. and constant member
+  structure /s1/
+    integer i
+    integer ne
+    logical b
+  end structure
+
+  ! Operator overload tests with .eq., .test. and nested members
+  structure /s2/
+    record /s1/ eq
+    record /s1/ test
+    record /s1/ and
+    integer i
+  end structure
+
+  ! Deep nested access tests
+  structure /s3/
+    record /s2/ r2
+  end structure
+  structure /s4/
+    record /s3/ r3
+  end structure
+  structure /s5/
+    record /s4/ r4
+  end structure
+  structure /s6/
+    record /s5/ r5
+  end structure
+  structure /s7/
+    record /s6/ r6
+  end structure
+
+  ! Operator overloads to mess with nested member accesses
+  interface operator (.ne.)
+    module procedure ne_func
+  end interface operator (.ne.)
+  interface operator (.eq.)
+    module procedure eq_func
+  end interface operator (.eq.)
+  interface operator (.test.)
+    module procedure tstfunc
+  end interface operator (.test.)
+  contains
+  ! ne_func will be called on (x) .ne. (y)
+  function ne_func (r, i)
+    integer, intent(in) :: i
+    type(s1), intent(in) :: r
+    integer ne_func
+    ne_func = r%i + i
+  end function
+  ! eq_func will be called on (x) .eq. (y)
+  function eq_func (r, i)
+    integer, intent(in) :: i
+    type(s2), intent(in) :: r
+    integer eq_func
+    eq_func = r%eq%i + i
+  end function eq_func
+  ! tstfunc will be called on (x) .test. (y)
+  function tstfunc (r, i)
+    integer, intent(in) :: i
+    type(s2), intent(in) :: r
+    integer tstfunc
+    tstfunc = r%i + i
+  end function tstfunc
+end module
+
+use dec_structure_10
+
+record /s1/ r
+record /s2/ struct
+record /s7/ r7
+integer i, j
+logical l
+struct%eq%i = 5
+i = -5
+
+! Nested access: struct has a member and which has a member b
+l =  struct .and. b   ! struct%and%b
+l =  struct .and. b .or. .false. ! (struct%and%b) .or. (.false.)
+
+! Intrinsic op: r has no member 'ne'
+j =  r .ne. i         ! <intrinsic> ne(r, i)
+j = (r) .ne. i        ! <intrinsic> ne(r, i)
+
+! Intrinsic op; r has a member 'ne' but it is not a record
+j =  r .ne. i         ! <intrinsic> ne(r, i)
+j = (r) .ne. i        ! <intrinsic> ne(r, i)
+
+! Nested access: struct has a member eq which has a member i
+j =  struct .eq. i    ! struct%eq%i
+if ( j .ne. struct%eq%i ) call abort()
+
+! User op: struct is compared to i with eq_func
+j = (struct) .eq. i   ! eq_func(struct, i) -> struct%eq%i + i
+if ( j .ne. struct%eq%i + i ) call abort()
+
+! User op: struct has a member test which has a member i, but test is a uop
+j =  struct .test. i  ! tstfunc(struct, i) -> struct%i + i
+if ( j .ne. struct%i + i ) call abort()
+
+! User op: struct is compared to i with eq_func
+j = (struct) .test. i ! tstfunc(struct, i) -> struct%i + i
+if ( j .ne. struct%i + i ) call abort()
+
+! Deep nested access tests
+r7.r6.r5.r4.r3.r2.i = 1337
+j = r7.r6.r5.r4.r3.r2.i
+if ( j .ne. 1337 ) call abort()
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_structure_11.f90 b/gcc/testsuite/gfortran.dg/dec_structure_11.f90

new file mode 100644 (file)

index 0000000..f6f5b6f
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_structure_11.f90
@@ -0,0 +1,20 @@
+! { dg-do compile }
+! { dg-options "-fdec-structure" }
+!
+! Tests for what CAN'T be done with dot ('.') as a member accessor.
+!
+
+structure /s1/
+  integer eq
+end structure
+
+record /s1/ r
+integer i, j, k
+
+j = i.j          ! { dg-error "nonderived-type variable" }
+j = r .eq. i     ! { dg-error "Operands of comparison" }
+j = r.i          ! { dg-error "is not a member of" }
+j = r.           ! { dg-error "Expected structure component or operator name" }
+j = .i           ! { dg-error "Invalid character in name" }
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_structure_2.f90 b/gcc/testsuite/gfortran.dg/dec_structure_2.f90

new file mode 100644 (file)

index 0000000..18db719
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_structure_2.f90
@@ -0,0 +1,41 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Test STRUCTUREs containin other STRUCTUREs.
+!
+
+subroutine aborts (s)
+  character(*), intent(in) :: s
+  print *, s
+  call abort()
+end subroutine
+
+! Basic structure
+structure /s1/
+  integer i1
+  logical l1
+  real r1
+  character c1
+end structure
+
+structure /s2/
+  integer i
+  record /s1/ r1
+endstructure
+
+record /s1/ r1
+record /s2/ r2, r2_a(10)
+
+! Nested and array records
+r2.r1.r1 = 135.79
+r2_a(3).r1.i1 = -13579
+
+if (r2.r1.r1 .ne. 135.79) then
+  call aborts("r1.r1.r1")
+endif
+
+if (r2_a(3).r1.i1 .ne. -13579) then
+  call aborts("r2_a(3).r1.i1")
+endif
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_structure_3.f90 b/gcc/testsuite/gfortran.dg/dec_structure_3.f90

new file mode 100644 (file)

index 0000000..9cb7adb
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_structure_3.f90
@@ -0,0 +1,52 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Test nested STRUCTURE definitions.
+!
+
+subroutine aborts (s)
+  character(*), intent(in) :: s
+  print *, s
+  call abort()
+end subroutine
+
+structure /s3/
+  real p
+  structure /s4/ recrd, recrd_a(3)
+    integer i, j
+  end structure
+  real q
+end structure
+
+record /s3/ r3
+record /s4/ r4
+
+r3.p = 1.3579
+r4.i = 0
+r4.j = 1
+r3.recrd = r4
+r3.recrd_a(1) = r3.recrd
+r3.recrd_a(2).i = 1
+r3.recrd_a(2).j = 0
+
+if (r3.p .ne. 1.3579) then
+  call aborts("r3.p")
+endif
+
+if (r4.i .ne. 0) then
+  call aborts("r4.i")
+endif
+
+if (r4.j .ne. 1) then
+  call aborts("r4.j")
+endif
+
+if (r3.recrd.i .ne. 0 .or. r3.recrd.j .ne. 1) then
+  call aborts("r3.recrd")
+endif
+
+if (r3.recrd_a(2).i .ne. 1 .or. r3.recrd_a(2).j .ne. 0) then
+  call aborts("r3.recrd_a(2)")
+endif
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_structure_4.f90 b/gcc/testsuite/gfortran.dg/dec_structure_4.f90

new file mode 100644 (file)

index 0000000..a941c22
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_structure_4.f90
@@ -0,0 +1,43 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Test anonymous STRUCTURE definitions.
+!
+
+subroutine aborts (s)
+  character(*), intent(in) :: s
+  print *, s
+  call abort()
+end subroutine
+
+structure /s5/
+  structure recrd, recrd_a(3)
+    real x, y
+  end structure
+end structure
+
+record /s5/ r5
+
+r5.recrd.x = 1.3
+r5.recrd.y = 5.7
+r5.recrd_a(1) = r5.recrd
+r5.recrd_a(2).x = 5.7
+r5.recrd_a(2).y = 1.3
+
+if (r5.recrd.x .ne. 1.3) then
+  call aborts("r5.recrd.x")
+endif
+
+if (r5.recrd.y .ne. 5.7) then
+  call aborts("r5.recrd.y")
+endif
+
+if (r5.recrd_a(1).x .ne. 1.3 .or. r5.recrd_a(1).y .ne. 5.7) then
+  call aborts("r5.recrd_a(1)")
+endif
+
+if (r5.recrd_a(2).x .ne. 5.7 .or. r5.recrd_a(2).y .ne. 1.3) then
+  call aborts("r5.recrd_a(2)")
+endif
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_structure_5.f90 b/gcc/testsuite/gfortran.dg/dec_structure_5.f90

new file mode 100644 (file)

index 0000000..abda3c3
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_structure_5.f90
@@ -0,0 +1,49 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Test STRUCTUREs which share names with variables.
+!
+
+subroutine aborts (s)
+  character(*), intent(in) :: s
+  print *, s
+  call abort()
+end subroutine
+
+! Special regression where shared names within a module caused an ICE
+! from gfc_get_module_backend_decl
+module dec_structure_5m
+  structure /s6/
+    integer i
+  end structure
+
+  record /s6/ s6
+end module
+
+program dec_structure_5
+  use dec_structure_5m
+
+  structure /s7/
+    real r
+  end structure
+
+  record /s7/ s7(3)
+
+  s6.i = 0
+  s7(1).r = 1.0
+  s7(2).r = 2.0
+  s7(3).r = 3.0
+
+  if (s6.i .ne. 0) then
+    call aborts("s6.i")
+  endif
+
+  if (s7(1).r .ne. 1.0) then
+    call aborts("s7(1).r")
+  endif
+
+  if (s7(2).r .ne. 2.0) then
+    call aborts("s7(2).r")
+  endif
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_structure_6.f90 b/gcc/testsuite/gfortran.dg/dec_structure_6.f90

new file mode 100644 (file)

index 0000000..6494d71
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_structure_6.f90
@@ -0,0 +1,46 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Test old-style CLIST initializers in STRUCTURE.
+!
+
+subroutine aborts (s)
+  character(*), intent(in) :: s
+  print *, s
+  call abort()
+end subroutine
+
+integer, parameter :: as = 3
+structure /s8/
+  character*20 c /"HELLO"/  ! ok
+  integer*2 j /300_4/       ! ok, converted
+  integer   k /65536_8/     ! ok, implicit
+  integer*4 l /200000/      ! ok, types match
+  integer   m(5) /5,4,3,2,1/! ok
+  integer   n(5) /1,3*2,1/  ! ok, with repeat spec (/1,2,2,2,1/)
+  integer   o(as) /as*9/    ! ok, parameter array spec
+  integer   p(2,2) /1,2,3,4/! ok
+  real      q(3) /1_2,3.5,2.4E-12_8/ ! ok, with some implicit conversions
+  integer :: canary = z'3D3D3D3D'
+end structure
+
+record /s8/ r8
+
+! Old-style (clist) initializers in structures
+if ( r8.c /= "HELLO" ) call aborts ("r8.c")
+if ( r8.j /= 300 ) call aborts ("r8.j")
+if ( r8.k /= 65536 ) call aborts ("r8.k")
+if ( r8.l /= 200000 ) call aborts ("r8.l")
+if (     r8.m(1) /= 5 .or. r8.m(2) /= 4 .or. r8.m(3) /= 3 &
+    .or. r8.m(4) /= 2 .or. r8.m(5) /= 1) &
+  call aborts ("r8.m")
+if (     r8.n(1) /= 1 .or. r8.n(2) /= 2 .or. r8.n(3) /= 2 .or. r8.n(4) /= 2 &
+    .or. r8.n(5) /= 1) &
+  call aborts ("r8.n")
+if ( r8.o(1) /= 9 .or. r8.o(2) /= 9 .or. r8.o(3) /= 9 ) call aborts ("r8.o")
+if (     r8.p(1,1) /= 1 .or. r8.p(2,1) /= 2 .or. r8.p(1,2) /= 3 &
+    .or. r8.p(2,2) /= 4) &
+  call aborts ("r8.p")
+if ( r8.canary /= z'3D3D3D3D' ) call aborts ("r8.canary")
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_structure_7.f90 b/gcc/testsuite/gfortran.dg/dec_structure_7.f90

new file mode 100644 (file)

index 0000000..baba1ef
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_structure_7.f90
@@ -0,0 +1,75 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Test passing STRUCTUREs through functions and subroutines.
+!
+
+subroutine aborts (s)
+  character(*), intent(in) :: s
+  print *, s
+  call abort()
+end subroutine
+
+module dec_structure_7m
+  structure /s1/
+    integer i1
+    logical l1
+    real r1
+    character c1
+  end structure
+
+  structure /s2/
+    integer i
+    record /s1/ r1
+  endstructure
+
+contains
+  ! Pass structure through subroutine
+  subroutine sub (rec1, i)
+    implicit none
+    integer, intent(in) :: i
+    record /s1/ rec1
+    rec1.i1 = i
+  end subroutine
+
+  ! Pass structure through function
+  function func (rec2, r)
+    implicit none
+    real, intent(in) :: r
+    record /s2/ rec2
+    real func
+    rec2.r1.r1 = r
+    func = rec2.r1.r1
+    return
+  end function
+end module
+
+program dec_structure_7
+  use dec_structure_7m
+
+  implicit none
+  record /s1/ r1
+  record /s2/ r2
+  real junk
+
+  ! Passing through functions and subroutines
+  r1.i1 = 0
+  call sub (r1, 10)
+
+  r2.r1.r1 = 0.0
+  junk = func (r2, -20.14)
+
+  if (r1.i1 .ne. 10) then
+    call aborts("sub(r1, 10)")
+  endif
+
+  if (r2.r1.r1 .ne. -20.14) then
+    call aborts("func(r2, -20.14)")
+  endif
+
+  if (junk .ne. -20.14) then
+    print *, junk
+    call aborts("junk = func()")
+  endif
+
+end program
diff --git a/gcc/testsuite/gfortran.dg/dec_structure_8.f90 b/gcc/testsuite/gfortran.dg/dec_structure_8.f90

new file mode 100644 (file)

index 0000000..160b92a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_structure_8.f90
@@ -0,0 +1,60 @@
+! { dg-do compile }
+! { dg-options "-fdec-structure -fmax-errors=0" }
+!
+! Comprehensive compile tests for what structures CAN'T do.
+!
+
+! Old-style (clist) initialization
+integer,parameter :: as = 3
+structure /t1/
+  integer*1 a /300_2/       ! { dg-error "Arithmetic overflow" }
+  integer   b //            ! { dg-error "Empty old style initializer list" }
+  integer   c /2*3/         ! { dg-error "Repeat spec invalid in scalar" }
+  integer   d /1,2,3/       ! { dg-error "End of scalar initializer expected" }
+  integer   e /"HI"/        ! { dg-error "Can't convert" }
+  integer   f(as) /4*9/     ! { dg-error "Too many elements" }
+  integer   g(3) /1,3/      ! { dg-error "Not enough elements" }
+  integer   h(3) /1,3,5,7/  ! { dg-error "Too many elements" }
+  integer   i(3) /2*1/      ! { dg-error "Not enough elements" }
+  integer   j(3) /10*1/     ! { dg-error "Too many elements" }
+  integer   k(3) /2.5*3/    ! { dg-error "Repeat spec must be an integer" }
+  integer   l(2) /2*/       ! { dg-error "Expected data constant" }
+  integer   m(1) /          ! { dg-error "Syntax error in old style" }
+  integer   n(2) /1         ! { dg-error "Syntax error in old style" }
+  integer   o(2) /1,        ! { dg-error "Syntax error in old style" }
+  integer   p(1) /x/        ! { dg-error "must be a PARAMETER" }
+end structure
+
+structure              ! { dg-error "Structure name expected" }
+structure /            ! { dg-error "Structure name expected" }
+structure //           ! { dg-error "Structure name expected" }
+structure /.or./       ! { dg-error "Structure name expected" }
+structure /integer/    ! { dg-error "Structure name.*cannot be the same" }
+structure /foo/ bar    ! { dg-error "Junk after" }
+structure /t1/         ! { dg-error "Type definition.*T1" }
+
+record                 ! { dg-error "Structure name expected" }
+record bar             ! { dg-error "Structure name expected" }
+record / bar           ! { dg-error "Structure name expected" }
+record // bar          ! { dg-error "Structure name expected" }
+record foo/ bar        ! { dg-error "Structure name expected" }
+record /foo bar        ! { dg-error "Structure name expected" }
+record /foo/ bar       ! { dg-error "used before it is defined" }
+record /t1/            ! { dg-error "Invalid character in name" }
+
+structure /t2/
+  ENTRY here           ! { dg-error "ENTRY statement.*cannot appear" }
+  integer a
+  integer a            ! { dg-error "Component.*already declared" }
+  structure $z         ! { dg-error "Invalid character in name" }
+  structure //         ! { dg-error "Invalid character in name" }
+  structure // x       ! { dg-error "Invalid character in name" }
+  structure /t3/       ! { dg-error "Invalid character in name" }
+  structure /t3/ x,$y  ! { dg-error "Invalid character in name" }
+  structure /t4/ y
+    integer i, j, k
+  end structure
+  structure /t4/ z     ! { dg-error "Type definition.*T4" }
+end structure
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_structure_9.f90 b/gcc/testsuite/gfortran.dg/dec_structure_9.f90

new file mode 100644 (file)

index 0000000..34c46c6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_structure_9.f90
@@ -0,0 +1,42 @@
+! { dg-do compile }
+! { dg-options "-fdec-structure" }
+!
+! Basic compile tests for what CAN be done with dot ('.') as a member accessor.
+!
+
+logical :: l, l2 = .true., l3 = .false., and
+integer i
+character(5) s
+real r
+
+structure /s1/
+  integer i
+  character(5) s
+  real r
+end structure
+
+record /s1/ r1
+
+! Basic 
+l = l .and. l2 .or. l3
+l = and .and. and .and. and
+l =  l2 .eqv. l3
+l = (l2) .eqv. l3
+
+! Integers
+l = .not. (i .eq. 0)
+l = .not. (0 .eq. i)
+l = .not. (r1.i .eq. 0)
+l = .not. (0 .eq. r1.i)
+! Characters
+l = .not. (s .eq. "hello")
+l = .not. ("hello" .eq. s)
+l = .not. (r1.s .eq. "hello")
+l = .not. ("hello" .eq. r1.s)
+! Reals
+l = .not. (r .eq. 3.14)
+l = .not. (3.14 .eq. r)
+l = .not. (r1.r .eq. 3.14)
+l = .not. (3.14 .eq. r1.r)
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_union_1.f90 b/gcc/testsuite/gfortran.dg/dec_union_1.f90

new file mode 100644 (file)

index 0000000..36af53a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_union_1.f90
@@ -0,0 +1,66 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Test whether union backend declarations are corrently _not_ copied when they
+! are not in fact equal. The structure defined in sub() is seen later, but
+! where siz has a different value.
+!
+
+subroutine aborts (s)
+  character(*), intent(in) :: s
+  print *, s
+  call abort()
+end subroutine
+
+subroutine sub ()
+  integer, parameter :: siz = 1024
+  structure /s6/
+    union ! U0
+      map ! M0
+        integer ibuf(siz)
+      end map
+      map ! M1
+        character(8) cbuf(siz)
+      end map
+      map ! M2
+        real rbuf(siz)
+      end map
+    end union
+  end structure
+  record /s6/ r6
+  r6.ibuf(1) = z'badbeef'
+  r6.ibuf(2) = z'badbeef'
+end subroutine
+
+! Repeat definition from subroutine sub with different size parameter.
+! If the structure definition is copied here the stack may get messed up.
+integer, parameter :: siz = 65536
+structure /s6/
+  union ! U12
+    map
+      integer ibuf(siz)
+    end map
+    map
+      character(8) cbuf(siz)
+    end map
+    map
+      real rbuf(siz)
+    end map
+  end union
+end structure
+
+record /s6/ r6
+integer :: r6_canary = 0
+
+! Copied type declaration - this should not cause problems
+i = 1
+do while (i < siz)
+  r6.ibuf(i) = z'badbeef'
+  i = i + 1
+end do
+
+if ( r6_canary .ne. 0 ) then
+  call aborts ('copied decls: overflow')
+endif
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_union_2.f90 b/gcc/testsuite/gfortran.dg/dec_union_2.f90

new file mode 100644 (file)

index 0000000..61e4fd8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_union_2.f90
@@ -0,0 +1,60 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Test basic UNION implementation.
+!
+
+subroutine aborts (s)
+  character(*), intent(in) :: s
+  print *, s
+  call abort()
+end subroutine
+
+! Empty union
+structure /s0/
+  union ! U0
+    map ! M0
+    end map
+    map ! M1
+    end map
+  end union
+end structure
+
+! Basic unions
+structure /s1/
+  union ! U1
+    map ! M2
+      integer(4) a
+    end map
+    map ! M3
+      real(4) b
+    end map
+  end union
+end structure
+structure /s2/
+  union ! U2
+    map ! M4
+      integer(2) w1, w2
+    end map
+    map ! M5
+      integer(4) long
+    end map
+  end union
+end structure
+
+record /s1/ r1
+record /s2/ r2
+
+! Basic unions
+r1.a = 0
+r1.b = 1.33e7
+if ( r1.a .eq. 0 ) call aborts ("basic union 1")
+
+! Endian-agnostic runtime check
+r2.long = z'12345678'
+if (.not. (     (r2.w1 .eq. z'1234' .and. r2.w2 .eq. z'5678') &
+           .or. (r2.w1 .eq. z'5678' .and. r2.w2 .eq. z'1234')) ) then
+    call aborts ("basic union 2")
+endif
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_union_3.f90 b/gcc/testsuite/gfortran.dg/dec_union_3.f90

new file mode 100644 (file)

index 0000000..ce5ae79
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_union_3.f90
@@ -0,0 +1,35 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Test UNIONs with initializations.
+!
+
+subroutine aborts (s)
+  character(*), intent(in) :: s
+  print *, s
+  call abort()
+end subroutine
+
+! Initialization expressions
+structure /s3/
+  integer(4) :: i = 8
+  union ! U7
+    map
+      integer(4) :: x = 1600
+      integer(4) :: y = 1800
+    end map
+    map
+      integer(2) a, b, c
+    end map
+  end union
+end structure
+
+record /s3/ r3
+
+! Initialized unions
+if ( r3.x .ne. 1600 .or. r3.y .ne. 1800) then
+  r3.x = r3.y ! If r3 isn't used the initializations are optimized out
+  call aborts ("union initialization")
+endif
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_union_4.f90 b/gcc/testsuite/gfortran.dg/dec_union_4.f90

new file mode 100644 (file)

index 0000000..4c1c6ef
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_union_4.f90
@@ -0,0 +1,63 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Test nested UNIONs.
+!
+
+subroutine aborts (s)
+  character(*), intent(in) :: s
+  print *, s
+  call abort()
+end subroutine
+
+! Nested unions
+structure /s4/
+  union ! U0                ! rax
+    map
+      character(16) rx
+    end map
+    map
+      character(8) rh         ! rah
+      union ! U1
+        map
+          character(8) rl     ! ral
+        end map
+        map
+          character(8) ex     ! eax
+        end map
+        map
+          character(4) eh     ! eah
+          union ! U2
+            map
+              character(4) el ! eal
+            end map
+            map
+              character(4) x  ! ax
+            end map
+            map
+              character(2) h  ! ah
+              character(2) l  ! al
+            end map
+          end union
+        end map
+      end union
+    end map
+  end union
+end structure
+record /s4/ r4
+
+
+! Nested unions
+r4.rx     =     'AAAAAAAA.BBB.C.D'
+
+if ( r4.rx .ne. 'AAAAAAAA.BBB.C.D' ) call aborts ("rax")
+if ( r4.rh .ne. 'AAAAAAAA'         ) call aborts ("rah")
+if ( r4.rl .ne.         '.BBB.C.D' ) call aborts ("ral")
+if ( r4.ex .ne.         '.BBB.C.D' ) call aborts ("eax")
+if ( r4.eh .ne.         '.BBB'     ) call aborts ("eah")
+if ( r4.el .ne.             '.C.D' ) call aborts ("eal")
+if ( r4.x  .ne.             '.C.D' ) call aborts ("ax")
+if ( r4.h  .ne.             '.C'   ) call aborts ("ah")
+if ( r4.l  .ne.               '.D' ) call aborts ("al")
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_union_5.f90 b/gcc/testsuite/gfortran.dg/dec_union_5.f90

new file mode 100644 (file)

index 0000000..bb1611a
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_union_5.f90
@@ -0,0 +1,41 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! Test UNIONs with array components.
+!
+
+subroutine aborts (s)
+  character(*), intent(in) :: s
+  print *, s
+  call abort()
+end subroutine
+
+! Unions with arrays
+structure /s5/
+  union
+    map
+      character :: s(5)
+    end map
+    map
+      integer(1) :: a(5)
+    end map
+  end union
+end structure
+
+record /s5/ r5
+
+! Unions with arrays
+r5.a(1) = z'41'
+r5.a(2) = z'42'
+r5.a(3) = z'43'
+r5.a(4) = z'44'
+r5.a(5) = z'45'
+if (     r5.s(1) .ne. 'A' &
+    .or. r5.s(2) .ne. 'B' &
+    .or. r5.s(3) .ne. 'C' &
+    .or. r5.s(4) .ne. 'D' &
+    .or. r5.s(5) .ne. 'E') then
+  call aborts ("arrays")
+endif
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_union_6.f90 b/gcc/testsuite/gfortran.dg/dec_union_6.f90

new file mode 100644 (file)

index 0000000..31059c4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_union_6.f90
@@ -0,0 +1,59 @@
+! { dg-do run }
+! { dg-options "-fdec-structure" }
+!
+! sub0 and sub1 test a regression where calling gfc_use_derived from
+! gfc_find_component on the structure type symbol being parsed caused the
+! symbol to be freed and swapped for the previously seen type symbol, leaving
+! dangling pointers and causing all sorts of mayhem.
+!
+
+subroutine sub0 (u)
+  structure /s/
+    union ! U0
+      map ! M0
+        integer i
+      end map
+    end union
+  end structure
+  record /s/ u
+  u.i = 0
+end subroutine sub0
+
+subroutine sub1 ()
+  structure /s/
+    union ! U1
+      map ! M1
+        integer i
+      end map
+    end union
+  end structure
+  record /s/ u
+  interface ! matches the declaration of sub0 above
+    subroutine sub0 (u)
+      structure /s/
+        union ! U2
+          map ! M2
+            integer i ! gfc_find_component should not call gfc_use_derived
+          end map     ! here, otherwise this structure's type symbol is freed
+        end union     ! out from under it
+      end structure
+      record /s/ u
+    end subroutine sub0
+  end interface
+  call sub0(u)
+end subroutine
+
+! If sub0 and sub1 aren't used they may be omitted
+structure /s/
+  union ! U1
+    map ! M3
+      integer i
+    end map
+  end union
+end structure
+record /s/ u
+
+call sub0(u)
+call sub1()
+
+end
diff --git a/gcc/testsuite/gfortran.dg/dec_union_7.f90 b/gcc/testsuite/gfortran.dg/dec_union_7.f90

new file mode 100644 (file)

index 0000000..270f0fb
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/dec_union_7.f90
@@ -0,0 +1,38 @@
+! { dg-do compile }
+! { dg-options "-fdec-structure" }
+!
+! Comprehensive compile tests for what unions CAN'T do.
+!
+
+! Syntax errors
+structure /s0/
+  union a b c      ! { dg-error "Junk after UNION" }
+  union
+    map a b c      ! { dg-error "Junk after MAP" }
+    integer x      ! { dg-error "Unexpected" }
+    structure /s2/ ! { dg-error "Unexpected" }
+    map
+      map          ! { dg-error "Unexpected" }
+    end map
+  end union
+end structure
+
+! Initialization expressions
+structure /s1/
+  union
+    map
+      integer(4) :: x = 1600 ! { dg-error "Conflicting initializers" }
+      integer(4) :: y = 1800
+    end map
+    map
+      integer(2) a, b, c, d
+      integer :: e = 0 ! { dg-error "Conflicting initializers" }
+    end map
+    map
+      real :: p = 1.3, q = 3.7 ! { dg-error "Conflicting initializers" }
+    end map
+  end union
+end structure
+record /s1/ r1
+
+end
diff --git a/gcc/testsuite/gfortran.dg/goacc/cache-1.f95 b/gcc/testsuite/gfortran.dg/goacc/cache-1.f95

index 2aa9e05..39fbf2c 100644 (file)
--- a/gcc/testsuite/gfortran.dg/goacc/cache-1.f95
+++ b/gcc/testsuite/gfortran.dg/goacc/cache-1.f95
@@ -1,4 +1,6 @@
-! { dg-do compile }
+! OpenACC cache directive: valid usage.
+! For execution testing, this file is "#include"d from
+! libgomp/testsuite/libgomp.oacc-fortran/cache-1.f95.
  ! { dg-additional-options "-std=f2008" }
  
  program test
@@ -6,11 +8,8 @@ program test
    integer :: i, d(10), e(5,13)
  
    do concurrent (i=1:5)
-    !$acc cache (d)
      !$acc cache (d(1:3))
      !$acc cache (d(i:i+2))
-
-    !$acc cache (e)
      !$acc cache (e(1:3,2:4))
      !$acc cache (e(i:i+2,i+1:i+3))
    enddo
diff --git a/gcc/testsuite/gfortran.dg/goacc/cache-2.f95 b/gcc/testsuite/gfortran.dg/goacc/cache-2.f95

new file mode 100644 (file)

index 0000000..be81878
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/goacc/cache-2.f95
@@ -0,0 +1,12 @@
+! OpenACC cache directive: invalid usage.
+! { dg-additional-options "-std=f2008" }
+
+program test
+  implicit none
+  integer :: i, d(10), e(5,13)
+
+  do concurrent (i=1:5)
+    !$acc cache (d) ! { dg-error "" "TODO" { xfail *-*-* } }
+    !$acc cache (e) ! { dg-error "" "TODO" { xfail *-*-* } }
+  enddo
+end
diff --git a/gcc/testsuite/gfortran.dg/goacc/coarray.f95 b/gcc/testsuite/gfortran.dg/goacc/coarray.f95

index 932e1f7..f30917b 100644 (file)
--- a/gcc/testsuite/gfortran.dg/goacc/coarray.f95
+++ b/gcc/testsuite/gfortran.dg/goacc/coarray.f95
@@ -24,7 +24,7 @@ contains
      !$acc end parallel loop
      !$acc parallel loop
      do i = 1,5
-      !$acc cache (a)
+      !$acc cache (a) ! { dg-error "" "TODO" { xfail *-*-* } }
      enddo
      !$acc end parallel loop
      !$acc update device (a)
diff --git a/gcc/testsuite/gfortran.dg/goacc/combined-directives.f90 b/gcc/testsuite/gfortran.dg/goacc/combined-directives.f90

index 42a447a..abb5e6b 100644 (file)
--- a/gcc/testsuite/gfortran.dg/goacc/combined-directives.f90
+++ b/gcc/testsuite/gfortran.dg/goacc/combined-directives.f90
@@ -143,7 +143,8 @@ end subroutine test
  ! { dg-final { scan-tree-dump-times "acc loop private.i. private.j. vector" 2 "gimple" } }
  ! { dg-final { scan-tree-dump-times "acc loop private.i. private.j. seq" 2 "gimple" } }
  ! { dg-final { scan-tree-dump-times "acc loop private.i. private.j. auto" 2 "gimple" } }
-! { dg-final { scan-tree-dump-times "acc loop private.i. private.j. tile.2, 3" 2 "gimple" } }
+! XFAILed: OpenACC tile clauses are discarded during gimplification.
+! { dg-final { scan-tree-dump-times "acc loop private.i. private.j. tile.2, 3" 2 "gimple" { xfail *-*-* } } }
  ! { dg-final { scan-tree-dump-times "acc loop private.i. independent" 2 "gimple" } }
  ! { dg-final { scan-tree-dump-times "private.z" 2 "gimple" } }
  ! { dg-final { scan-tree-dump-times "omp target oacc_\[^ \]+ map.force_tofrom:y" 2 "gimple" } }
diff --git a/gcc/testsuite/gfortran.dg/goacc/cray-2.f95 b/gcc/testsuite/gfortran.dg/goacc/cray-2.f95

new file mode 100644 (file)

index 0000000..51b79b5
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/goacc/cray-2.f95
@@ -0,0 +1,56 @@
+! { dg-additional-options "-fcray-pointer" }
+! See also cray.f95.
+
+program test
+  call oacc1
+contains
+  subroutine oacc1
+    implicit none
+    integer :: i
+    real :: pointee
+    pointer (ptr, pointee)
+    !$acc declare device_resident (pointee)
+    !$acc declare device_resident (ptr)
+    !$acc data copy (pointee) ! { dg-error "Cray pointee" }
+    !$acc end data
+    !$acc data deviceptr (pointee) ! { dg-error "Cray pointee" }
+    !$acc end data
+    !$acc parallel private (pointee) ! { dg-error "Cray pointee" }
+    !$acc end parallel
+    !$acc host_data use_device (pointee) ! { dg-error "Cray pointee" }
+    !$acc end host_data
+    !$acc parallel loop reduction(+:pointee) ! { dg-error "Cray pointee" }
+    do i = 1,5
+    enddo
+    !$acc end parallel loop
+    !$acc parallel loop
+    do i = 1,5
+      !$acc cache (pointee) ! { dg-error "Cray pointee" }
+    enddo
+    !$acc end parallel loop
+    !$acc update device (pointee) ! { dg-error "Cray pointee" }
+    !$acc update host (pointee) ! { dg-error "Cray pointee" }
+    !$acc update self (pointee) ! { dg-error "Cray pointee" }
+    !$acc data copy (ptr)
+    !$acc end data
+    !$acc data deviceptr (ptr) ! { dg-error "Cray pointer" }
+    !$acc end data
+    !$acc parallel private (ptr)
+    !$acc end parallel
+    !$acc host_data use_device (ptr) ! { dg-error "Cray pointer" }
+    !$acc end host_data
+    !$acc parallel loop reduction(+:ptr) ! { dg-error "Cray pointer" }
+    do i = 1,5
+    enddo
+    !$acc end parallel loop
+    !$acc parallel loop
+    do i = 1,5
+      !TODO: This must fail, as in openacc-1_0-branch.
+      !$acc cache (ptr) ! { dg-error "" "TODO" { xfail *-*-* } }
+    enddo
+    !$acc end parallel loop
+    !$acc update device (ptr)
+    !$acc update host (ptr)
+    !$acc update self (ptr)
+  end subroutine oacc1
+end program test
diff --git a/gcc/testsuite/gfortran.dg/goacc/cray.f95 b/gcc/testsuite/gfortran.dg/goacc/cray.f95

index a35ab0d..d6d5317 100644 (file)
--- a/gcc/testsuite/gfortran.dg/goacc/cray.f95
+++ b/gcc/testsuite/gfortran.dg/goacc/cray.f95
@@ -1,5 +1,5 @@
-! { dg-do compile } 
  ! { dg-additional-options "-fcray-pointer" }
+! See also cray-2.f95.
  
  module test
  contains
@@ -8,8 +8,8 @@ contains
      integer :: i
      real :: pointee
      pointer (ptr, pointee)
-    !$acc declare device_resident (pointee) 
-    !$acc declare device_resident (ptr) 
+    !$acc declare device_resident (pointee)
+    !$acc declare device_resident (ptr)
      !$acc data copy (pointee) ! { dg-error "Cray pointee" }
      !$acc end data
      !$acc data deviceptr (pointee) ! { dg-error "Cray pointee" }
@@ -44,7 +44,8 @@ contains
      !$acc end parallel loop
      !$acc parallel loop
      do i = 1,5
-      !$acc cache (ptr) ! TODO: This must fail, as in openacc-1_0-branch
+      !TODO: This must fail, as in openacc-1_0-branch.
+      !$acc cache (ptr) ! { dg-error "" "TODO" { xfail *-*-* } }
      enddo
      !$acc end parallel loop
      !$acc update device (ptr)
diff --git a/gcc/testsuite/gfortran.dg/goacc/loop-1-2.f95 b/gcc/testsuite/gfortran.dg/goacc/loop-1-2.f95

new file mode 100644 (file)

index 0000000..79665b9
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/goacc/loop-1-2.f95
@@ -0,0 +1,176 @@
+! See also loop-1.f95.
+
+program test
+  call test1
+contains
+
+subroutine test1
+  integer :: i, j, k, b(10)
+  integer, dimension (30) :: a
+  double precision :: d
+  real :: r
+  i = 0
+  !$acc loop
+  do 100 ! { dg-error "cannot be a DO WHILE or DO without loop control" }
+    if (i .gt. 0) exit ! { dg-error "EXIT statement" }
+  100 i = i + 1
+  i = 0
+  !$acc loop
+  do ! { dg-error "cannot be a DO WHILE or DO without loop control" }
+      if (i .gt. 0) exit ! { dg-error "EXIT statement" }
+       i = i + 1
+  end do
+  i = 0
+  !$acc loop
+  do 200 while (i .lt. 4) ! { dg-error "cannot be a DO WHILE or DO without loop control" }
+  200 i = i + 1
+  !$acc loop
+  do while (i .lt. 8) ! { dg-error "cannot be a DO WHILE or DO without loop control" }
+       i = i + 1
+  end do
+  !$acc loop
+  do 300 d = 1, 30, 6
+      i = d
+  300 a(i) = 1
+  ! { dg-warning "Deleted feature: Loop variable at .1. must be integer" "" { target *-*-* } 32 }
+  ! { dg-error "ACC LOOP iteration variable must be of type integer" "" { target *-*-* } 32 }
+  !$acc loop
+  do d = 1, 30, 5
+       i = d
+      a(i) = 2
+  end do
+  ! { dg-warning "Deleted feature: Loop variable at .1. must be integer" "" { target *-*-* } 38 }
+  ! { dg-error "ACC LOOP iteration variable must be of type integer" "" { target *-*-* } 38 }
+  !$acc loop
+  do i = 1, 30
+      if (i .eq. 16) exit ! { dg-error "EXIT statement" }
+  end do
+  !$acc loop
+  outer: do i = 1, 30
+      do j = 5, 10
+          if (i .eq. 6 .and. j .eq. 7) exit outer ! { dg-error "EXIT statement" }
+      end do
+  end do outer
+  last: do i = 1, 30
+   end do last
+
+  ! different types of loop are allowed
+  !$acc loop
+  do i = 1,10
+  end do
+  !$acc loop
+  do 400, i = 1,10
+400   a(i) = i
+
+  ! after loop directive must be loop
+  !$acc loop
+  a(1) = 1 ! { dg-error "Expected DO loop" }
+  do i = 1,10
+  enddo
+
+  ! combined directives may be used with/without end
+  !$acc parallel loop
+  do i = 1,10
+  enddo
+  !$acc parallel loop
+  do i = 1,10
+  enddo
+  !$acc end parallel loop
+  !$acc kernels loop
+  do i = 1,10
+  enddo
+  !$acc kernels loop
+  do i = 1,10
+  enddo
+  !$acc end kernels loop
+
+  !$acc kernels loop reduction(max:i)
+  do i = 1,10
+  enddo
+  !$acc kernels
+  !$acc loop reduction(max:i)
+  do i = 1,10
+  enddo
+  !$acc end kernels
+
+  !$acc parallel loop collapse(0) ! { dg-error "constant positive integer" }
+  do i = 1,10
+  enddo
+
+  !$acc parallel loop collapse(-1) ! { dg-error "constant positive integer" }
+  do i = 1,10
+  enddo
+
+  !$acc parallel loop collapse(i) ! { dg-error "Constant expression required" }
+  do i = 1,10
+  enddo
+
+  !$acc parallel loop collapse(4) ! { dg-error "not enough DO loops for collapsed" }
+    do i = 1, 3
+        do j = 4, 6
+          do k = 5, 7
+              a(i+j-k) = i + j + k
+          end do
+        end do
+    end do
+    !$acc parallel loop collapse(2)
+    do i = 1, 5, 2
+        do j = i + 1, 7, i  ! { dg-error "collapsed loops don.t form rectangular iteration space" }
+        end do
+    end do
+    !$acc parallel loop collapse(2)
+    do i = 1, 3
+        do j = 4, 6
+        end do
+    end do
+    !$acc parallel loop collapse(2)
+    do i = 1, 3
+        do j = 4, 6
+        end do
+        k = 4
+    end do
+    !$acc parallel loop collapse(3-1)
+    do i = 1, 3
+        do j = 4, 6
+        end do
+        k = 4
+    end do
+    !$acc parallel loop collapse(1+1)
+    do i = 1, 3
+        do j = 4, 6
+        end do
+        k = 4
+    end do
+    !$acc parallel loop collapse(2)
+    do i = 1, 3
+        do      ! { dg-error "cannot be a DO WHILE or DO without loop control" }
+        end do
+    end do
+    !$acc parallel loop collapse(2)
+    do i = 1, 3
+        do r = 4, 6
+        end do
+        ! { dg-warning "Deleted feature: Loop variable at .1. must be integer" "" { target *-*-* } 151 }
+        ! { dg-error "ACC LOOP iteration variable must be of type integer" "" { target *-*-* } 151 }
+    end do
+
+    ! Both seq and independent are not allowed
+  !$acc loop independent seq ! { dg-error "SEQ conflicts with INDEPENDENT" }
+  do i = 1,10
+  enddo
+
+
+  !$acc cache (a(1:10)) ! { dg-error "ACC CACHE directive must be inside of loop" }
+
+  do i = 1,10
+    !$acc cache(a(i:i+1))
+  enddo
+
+  do i = 1,10
+    !$acc cache(a(i:i+1))
+    a(i) = i
+    !$acc cache(a(i+2:i+2+1))
+  enddo
+
+end subroutine test1
+end program test
diff --git a/gcc/testsuite/gfortran.dg/goacc/loop-1.f95 b/gcc/testsuite/gfortran.dg/goacc/loop-1.f95

index b5f9e03..5f81b7a 100644 (file)
--- a/gcc/testsuite/gfortran.dg/goacc/loop-1.f95
+++ b/gcc/testsuite/gfortran.dg/goacc/loop-1.f95
@@ -1,8 +1,10 @@
+! See also loop-1-2.f95.
+
  module test
    implicit none
  contains
  
-subroutine test1  
+subroutine test1
    integer :: i, j, k, b(10)
    integer, dimension (30) :: a
    double precision :: d
@@ -30,15 +32,15 @@ subroutine test1
    do 300 d = 1, 30, 6
        i = d
    300 a(i) = 1
-  ! { dg-warning "Deleted feature: Loop variable at .1. must be integer" "" { target *-*-* } 30 }
-  ! { dg-error "ACC LOOP iteration variable must be of type integer" "" { target *-*-* } 30 }
+  ! { dg-warning "Deleted feature: Loop variable at .1. must be integer" "" { target *-*-* } 32 }
+  ! { dg-error "ACC LOOP iteration variable must be of type integer" "" { target *-*-* } 32 }
    !$acc loop
    do d = 1, 30, 5
         i = d
        a(i) = 2
    end do
-  ! { dg-warning "Deleted feature: Loop variable at .1. must be integer" "" { target *-*-* } 36 }
-  ! { dg-error "ACC LOOP iteration variable must be of type integer" "" { target *-*-* } 36 }
+  ! { dg-warning "Deleted feature: Loop variable at .1. must be integer" "" { target *-*-* } 38 }
+  ! { dg-error "ACC LOOP iteration variable must be of type integer" "" { target *-*-* } 38 }
    !$acc loop
    do i = 1, 30
        if (i .eq. 16) exit ! { dg-error "EXIT statement" }
@@ -53,7 +55,7 @@ subroutine test1
     end do last
  
    ! different types of loop are allowed
-  !$acc loop 
+  !$acc loop
    do i = 1,10
    end do
    !$acc loop
@@ -65,8 +67,8 @@ subroutine test1
    a(1) = 1 ! { dg-error "Expected DO loop" }
    do i = 1,10
    enddo
-  
-  ! combined directives may be used with/without end 
+
+  ! combined directives may be used with/without end
    !$acc parallel loop
    do i = 1,10
    enddo
@@ -82,11 +84,11 @@ subroutine test1
    enddo
    !$acc end kernels loop
  
-  !$acc kernels loop reduction(max:i) 
+  !$acc kernels loop reduction(max:i)
    do i = 1,10
    enddo
-  !$acc kernels 
-  !$acc loop reduction(max:i) 
+  !$acc kernels
+  !$acc loop reduction(max:i)
    do i = 1,10
    enddo
    !$acc end kernels
@@ -118,7 +120,7 @@ subroutine test1
      end do
      !$acc parallel loop collapse(2)
      do i = 1, 3
-        do j = 4, 6  
+        do j = 4, 6
          end do
      end do
      !$acc parallel loop collapse(2)
@@ -148,8 +150,8 @@ subroutine test1
      do i = 1, 3
          do r = 4, 6
          end do
-        ! { dg-warning "Deleted feature: Loop variable at .1. must be integer" "" { target *-*-* } 149 }
-        ! { dg-error "ACC LOOP iteration variable must be of type integer" "" { target *-*-* } 149 }
+        ! { dg-warning "Deleted feature: Loop variable at .1. must be integer" "" { target *-*-* } 151 }
+        ! { dg-error "ACC LOOP iteration variable must be of type integer" "" { target *-*-* } 151 }
      end do
  
      ! Both seq and independent are not allowed
@@ -158,15 +160,16 @@ subroutine test1
    enddo
  
  
-  !$acc cache (a) ! { dg-error "inside of loop" }
+  !$acc cache (a(1:10)) ! { dg-error "ACC CACHE directive must be inside of loop" }
  
    do i = 1,10
-    !$acc cache(a)
+    !$acc cache(a(i:i+1))
    enddo
  
    do i = 1,10
+    !$acc cache(a(i:i+1))
      a(i) = i
-    !$acc cache(a) 
+    !$acc cache(a(i+2:i+2+1))
    enddo
  
  end subroutine test1
diff --git a/gcc/testsuite/gfortran.dg/goacc/loop-3-2.f95 b/gcc/testsuite/gfortran.dg/goacc/loop-3-2.f95

new file mode 100644 (file)

index 0000000..9be74a8
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/goacc/loop-3-2.f95
@@ -0,0 +1,58 @@
+! { dg-additional-options "-std=f2008" }
+! See also loop-3.f95.
+
+program test
+  call test1
+contains
+subroutine test1
+  implicit none
+  integer :: i, j
+
+  ! !$acc end loop not required by spec
+  !$acc loop
+  do i = 1,5
+  enddo
+  !$acc end loop ! { dg-warning "Redundant" }
+
+  !$acc loop
+  do i = 1,5
+  enddo
+  j = 1
+  !$acc end loop ! { dg-error "Unexpected" }
+
+  !$acc parallel
+  !$acc loop
+  do i = 1,5
+  enddo
+  !$acc end parallel
+  !$acc end loop ! { dg-error "Unexpected" }
+
+  ! OpenACC supports Fortran 2008 do concurrent statement
+  !$acc loop
+  do concurrent (i = 1:5)
+  end do
+
+  !$acc loop
+  outer_loop: do i = 1, 5
+    inner_loop: do j = 1,5
+      if (i .eq. j) cycle outer_loop
+      if (i .ne. j) exit outer_loop ! { dg-error "EXIT statement" }
+    end do inner_loop
+  end do outer_loop
+
+  outer_loop1: do i = 1, 5
+    !$acc loop
+    inner_loop1: do j = 1,5
+      if (i .eq. j) cycle outer_loop1 ! { dg-error "CYCLE statement" }
+    end do inner_loop1
+  end do outer_loop1
+
+  !$acc loop collapse(2)
+  outer_loop2: do i = 1, 5
+    inner_loop2: do j = 1,5
+      if (i .eq. j) cycle outer_loop2 ! { dg-error "CYCLE statement" }
+      if (i .ne. j) exit outer_loop2 ! { dg-error "EXIT statement" }
+    end do inner_loop2
+  end do outer_loop2
+end subroutine test1
+end program test
diff --git a/gcc/testsuite/gfortran.dg/goacc/loop-3.f95 b/gcc/testsuite/gfortran.dg/goacc/loop-3.f95

index 2a866c7..30930f4 100644 (file)
--- a/gcc/testsuite/gfortran.dg/goacc/loop-3.f95
+++ b/gcc/testsuite/gfortran.dg/goacc/loop-3.f95
@@ -1,10 +1,10 @@
-! { dg-do compile }
  ! { dg-additional-options "-std=f2008" }
+! See also loop-3-2.f95.
  
  subroutine test1
    implicit none
    integer :: i, j
-  
+
    ! !$acc end loop not required by spec
    !$acc loop
    do i = 1,5
@@ -23,7 +23,7 @@ subroutine test1
    enddo
    !$acc end parallel
    !$acc end loop ! { dg-error "Unexpected" }
-  
+
    ! OpenACC supports Fortran 2008 do concurrent statement
    !$acc loop
    do concurrent (i = 1:5)
@@ -35,7 +35,7 @@ subroutine test1
        if (i .eq. j) cycle outer_loop
        if (i .ne. j) exit outer_loop ! { dg-error "EXIT statement" }
      end do inner_loop
-  end do outer_loop 
+  end do outer_loop
  
    outer_loop1: do i = 1, 5
      !$acc loop
@@ -50,6 +50,5 @@ subroutine test1
        if (i .eq. j) cycle outer_loop2 ! { dg-error "CYCLE statement" }
        if (i .ne. j) exit outer_loop2 ! { dg-error "EXIT statement" }
      end do inner_loop2
-  end do outer_loop2 
+  end do outer_loop2
  end subroutine test1
-
diff --git a/gcc/testsuite/gfortran.dg/goacc/nested-function-1.f90 b/gcc/testsuite/gfortran.dg/goacc/nested-function-1.f90

new file mode 100644 (file)

index 0000000..2fcaa40
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/goacc/nested-function-1.f90
@@ -0,0 +1,93 @@
+! Exercise nested function decomposition, gcc/tree-nested.c.
+! See gcc/testsuite/gcc.dg/goacc/nested-function-1.c for the C version.
+
+program main
+  integer, parameter :: N = 100
+  integer :: nonlocal_arg
+  integer :: nonlocal_a(N)
+  integer :: nonlocal_i
+  integer :: nonlocal_j
+
+  nonlocal_a (:) = 5
+  nonlocal_arg = 5
+
+  call local ()
+  call nonlocal ()
+
+contains
+
+  subroutine local ()
+    integer :: local_i
+    integer :: local_arg
+    integer :: local_a(N)
+    integer :: local_j
+
+    local_a (:) = 5
+    local_arg = 5
+
+    !$acc kernels loop &
+    !$acc gang(num:local_arg) worker(local_arg) vector(local_arg) &
+    !$acc wait async(local_arg)
+    do local_i = 1, N
+       !$acc cache (local_a(local_i:local_i + 5))
+       local_a(local_i) = 100
+       !$acc loop seq tile(*)
+       do local_j = 1, N
+       enddo
+       !$acc loop auto independent tile(1)
+       do local_j = 1, N
+       enddo
+    enddo
+    !$acc end kernels loop
+
+    !$acc kernels loop &
+    !$acc gang(static:local_arg) worker(local_arg) vector(local_arg) &
+    !$acc wait(local_arg, local_arg + 1, local_arg + 2) async
+    do local_i = 1, N
+       !$acc cache (local_a(local_i:local_i + 4))
+       local_a(local_i) = 100
+       !$acc loop seq tile(1)
+       do local_j = 1, N
+       enddo
+       !$acc loop auto independent tile(*)
+       do local_j = 1, N
+       enddo
+    enddo
+    !$acc end kernels loop
+  end subroutine local
+
+  subroutine nonlocal ()
+    nonlocal_a (:) = 5
+    nonlocal_arg = 5
+
+    !$acc kernels loop &
+    !$acc gang(num:nonlocal_arg) worker(nonlocal_arg) vector(nonlocal_arg) &
+    !$acc wait async(nonlocal_arg)
+    do nonlocal_i = 1, N
+       !$acc cache (nonlocal_a(nonlocal_i:nonlocal_i + 3))
+       nonlocal_a(nonlocal_i) = 100
+       !$acc loop seq tile(2)
+       do nonlocal_j = 1, N
+       enddo
+       !$acc loop auto independent tile(3)
+       do nonlocal_j = 1, N
+       enddo
+    enddo
+    !$acc end kernels loop
+
+    !$acc kernels loop &
+    !$acc gang(static:nonlocal_arg) worker(nonlocal_arg) vector(nonlocal_arg) &
+    !$acc wait(nonlocal_arg, nonlocal_arg + 1, nonlocal_arg + 2) async
+    do nonlocal_i = 1, N
+       !$acc cache (nonlocal_a(nonlocal_i:nonlocal_i + 2))
+       nonlocal_a(nonlocal_i) = 100
+       !$acc loop seq tile(*)
+       do nonlocal_j = 1, N
+       enddo
+       !$acc loop auto independent tile(*)
+       do nonlocal_j = 1, N
+       enddo
+    enddo
+    !$acc end kernels loop
+  end subroutine nonlocal
+end program main
diff --git a/gcc/testsuite/gfortran.dg/goacc/subroutines.f90 b/gcc/testsuite/gfortran.dg/goacc/subroutines.f90

deleted file mode 100644 (file)

index 6cab798..0000000
--- a/gcc/testsuite/gfortran.dg/goacc/subroutines.f90
+++ /dev/null
@@ -1,73 +0,0 @@
-! Exercise how tree-nested.c handles gang, worker vector and seq.
-
-! { dg-do compile } 
-
-program main
-  integer, parameter :: N = 100
-  integer :: nonlocal_arg
-  integer :: nonlocal_a(N)
-  integer :: nonlocal_i
-  integer :: nonlocal_j
-  
-  nonlocal_a (:) = 5
-  nonlocal_arg = 5
-  
-  call local ()
-  call nonlocal ()
-
-contains
-
-  subroutine local ()
-    integer :: local_i
-    integer :: local_arg
-    integer :: local_a(N)
-    integer :: local_j
-    
-    local_a (:) = 5
-    local_arg = 5
-
-    !$acc kernels loop gang(num:local_arg) worker(local_arg) vector(local_arg)
-    do local_i = 1, N
-       local_a(local_i) = 100
-       !$acc loop seq
-       do local_j = 1, N
-       enddo
-    enddo
-    !$acc end kernels loop
-
-    !$acc kernels loop gang(static:local_arg) worker(local_arg) &
-    !$acc vector(local_arg)
-    do local_i = 1, N
-       local_a(local_i) = 100
-       !$acc loop seq
-       do local_j = 1, N
-       enddo
-    enddo
-    !$acc end kernels loop
-  end subroutine local
-
-  subroutine nonlocal ()
-    nonlocal_a (:) = 5
-    nonlocal_arg = 5
-  
-    !$acc kernels loop gang(num:nonlocal_arg) worker(nonlocal_arg) &
-    !$acc vector(nonlocal_arg)
-    do nonlocal_i = 1, N
-       nonlocal_a(nonlocal_i) = 100
-       !$acc loop seq
-       do nonlocal_j = 1, N
-       enddo
-    enddo
-    !$acc end kernels loop
-
-    !$acc kernels loop gang(static:nonlocal_arg) worker(nonlocal_arg) &
-    !$acc vector(nonlocal_arg)
-    do nonlocal_i = 1, N
-       nonlocal_a(nonlocal_i) = 100
-       !$acc loop seq
-       do nonlocal_j = 1, N
-       enddo
-    enddo
-    !$acc end kernels loop
-  end subroutine nonlocal
-end program main
diff --git a/gcc/testsuite/gfortran.dg/gomp/order-1.f90 b/gcc/testsuite/gfortran.dg/gomp/order-1.f90

new file mode 100644 (file)

index 0000000..23db74c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gomp/order-1.f90
@@ -0,0 +1,92 @@
+! { dg-do compile }
+
+module m
+  integer :: i
+end module m
+subroutine f1
+  type t
+    integer :: i
+  end type t
+  interface
+    integer function f3 (a, b)
+      !$omp declare simd (f3) uniform (a)
+      use m
+      import :: t
+      implicit none
+      type (t) :: a
+      integer :: b
+    end function f3
+  end interface
+  interface
+    integer function f4 (a, b)
+      use m
+      !$omp declare simd (f4) uniform (a)
+      import :: t
+      implicit none
+      type (t) :: a
+      integer :: b
+    end function f4
+  end interface
+  interface
+    integer function f5 (a, b)
+      use m
+      import :: t
+      !$omp declare simd (f5) uniform (a)
+      implicit none
+      type (t) :: a
+      integer :: b
+    end function f5
+  end interface
+  interface
+    integer function f6 (a, b)
+      use m
+      import :: t
+      implicit none
+      !$omp declare simd (f6) uniform (a)
+      type (t) :: a
+      integer :: b
+    end function f6
+  end interface
+  interface
+    integer function f7 (a, b)
+      use m
+      import :: t
+      implicit none
+      type (t) :: a
+      !$omp declare simd (f7) uniform (a)
+      integer :: b
+    end function f7
+  end interface
+  call f2
+contains
+  subroutine f2
+    !$omp threadprivate (t1)
+    use m
+    !$omp threadprivate (t2)
+    implicit none
+    !$omp threadprivate (t3)
+    integer, save :: t1, t2, t3, t4
+    !$omp threadprivate (t4)
+    t1 = 1; t2 = 2; t3 = 3; t4 = 4
+  end subroutine f2
+  subroutine f8
+    !$omp declare reduction (f8_1:real:omp_out = omp_out + omp_in)
+    use m
+    !$omp declare reduction (f8_2:real:omp_out = omp_out + omp_in)
+    implicit none
+    !$omp declare reduction (f8_3:real:omp_out = omp_out + omp_in)
+    integer :: j
+    !$omp declare reduction (f8_4:real:omp_out = omp_out + omp_in)
+  end subroutine f8
+  subroutine f9
+    !$omp declare target (f9_1)
+    use m
+    !$omp declare target (f9_2)
+    implicit none
+    !$omp declare target (f9_3)
+    !$omp declare target
+    integer, save :: f9_1, f9_2, f9_3, f9_4
+    !$omp declare target (f9_4)
+    f9_1 = 1; f9_2 = 2; f9_3 = 3; f9_4 = 4
+  end subroutine f9
+end subroutine f1
diff --git a/gcc/testsuite/gfortran.dg/gomp/order-2.f90 b/gcc/testsuite/gfortran.dg/gomp/order-2.f90

new file mode 100644 (file)

index 0000000..4ee3a82
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gomp/order-2.f90
@@ -0,0 +1,37 @@
+! { dg-do compile }
+
+module m
+  integer :: i
+end module m
+subroutine f1
+  call f2
+contains
+  subroutine f2
+    use m
+    implicit none
+    integer, save :: t
+    t = 1
+    !$omp threadprivate (t1)   ! { dg-error "Unexpected" }
+  end subroutine f2
+  subroutine f3
+    use m
+    implicit none
+    integer :: j
+    j = 1
+    !$omp declare reduction (foo:real:omp_out = omp_out + omp_in)      ! { dg-error "Unexpected" }
+  end subroutine f3
+  subroutine f4
+    use m
+    implicit none
+    !$omp declare target
+    integer, save :: f4_1
+    f4_1 = 1
+    !$omp declare target (f4_1)        ! { dg-error "Unexpected" }
+    !$omp declare target       ! { dg-error "Unexpected" }
+  end subroutine f4
+  integer function f5 (a, b)
+    integer :: a, b
+    a = 1; b = 2
+    !$omp declare simd (f5) notinbranch        ! { dg-error "Unexpected" }
+  end function f5
+end subroutine f1
diff --git a/gcc/testsuite/gfortran.dg/gomp/pr70855.f90 b/gcc/testsuite/gfortran.dg/gomp/pr70855.f90

new file mode 100644 (file)

index 0000000..247e4ed
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/gomp/pr70855.f90
@@ -0,0 +1,18 @@
+! PR fortran/70855
+! { dg-do compile }
+! { dg-additional-options "-O2" }
+
+program pr70855
+   integer, parameter :: m = 4
+   integer, parameter :: n = 2
+   real :: a(m,n)
+   real :: x(n)
+   real :: y(m)
+   a = 1.0
+   x = 1.0
+!$omp parallel
+!$omp workshare
+   y(1:m) = matmul ( a(1:m,1:n), x(1:n) )
+!$omp end workshare
+!$omp end parallel
+end program pr70855
diff --git a/gcc/testsuite/gfortran.dg/graphite/pr38083.f90 b/gcc/testsuite/gfortran.dg/graphite/pr38083.f90

index da8c3cc..34d6ca8 100644 (file)
--- a/gcc/testsuite/gfortran.dg/graphite/pr38083.f90
+++ b/gcc/testsuite/gfortran.dg/graphite/pr38083.f90
@@ -8,7 +8,7 @@ SUBROUTINE IVSORT (IL,IH,NSEGS,IOUNIT)
  10 IF (IL .GE. IH) GO TO 80
  20 NSEGS = (IH + IL) / 2
    IF (NSEGS .GT. MAXSGS) THEN
-     WRITE (IOUNIT),MAXSGS
+     WRITE (IOUNIT) MAXSGS
    ENDIF
  80 NSEGS = NSEGS - 1
  90 IF (IH - IL .GE. 11) GO TO 20
diff --git a/gcc/testsuite/gfortran.dg/guality/pr41558.f90 b/gcc/testsuite/gfortran.dg/guality/pr41558.f90

index 8a84de4..840b238 100644 (file)
--- a/gcc/testsuite/gfortran.dg/guality/pr41558.f90
+++ b/gcc/testsuite/gfortran.dg/guality/pr41558.f90
@@ -5,7 +5,7 @@
  
  subroutine f (s)
    character(len=3) :: s
-  write (*,*), s ! { dg-final { gdb-test 7 "s" "'foo'" } }
+  write (*,*) s ! { dg-final { gdb-test 7 "s" "'foo'" } }
  end
    call f ('foo')
  end
diff --git a/gcc/testsuite/gfortran.dg/integer_exponentiation_6.F90 b/gcc/testsuite/gfortran.dg/integer_exponentiation_6.F90

index 55c2543..4236ee6 100644 (file)
--- a/gcc/testsuite/gfortran.dg/integer_exponentiation_6.F90
+++ b/gcc/testsuite/gfortran.dg/integer_exponentiation_6.F90
@@ -1,4 +1,4 @@
  ! { dg-options "-fno-range-check" }
  program test
-  write (*), (2_8 ** 64009999_8) / 2
+  write (*,*) (2_8 ** 64009999_8) / 2
  end program test
diff --git a/gcc/testsuite/gfortran.dg/pr69603.f90 b/gcc/testsuite/gfortran.dg/pr69603.f90

new file mode 100644 (file)

index 0000000..dca4eb1
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr69603.f90
@@ -0,0 +1,16 @@
+! { dg-do compile }
+! { dg-options "-fimplicit-none" }
+! PR fortran/69603 - segfault with -fimplicit-none and proc_ptr_comp_24.f90
+! Based on reduced testcase by Dominique d'Humieres
+PROGRAM prog
+  implicit none
+  TYPE object
+     PROCEDURE(), POINTER, NOPASS :: f
+  END TYPE object
+  TYPE (object) :: o1
+  CALL set_func(o1%f)
+CONTAINS
+  SUBROUTINE set_func(f)
+    PROCEDURE(), POINTER :: f
+  END SUBROUTINE set_func
+END PROGRAM prog
diff --git a/gcc/testsuite/gfortran.dg/pr70931.f90 b/gcc/testsuite/gfortran.dg/pr70931.f90

new file mode 100644 (file)

index 0000000..08ecd68
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr70931.f90
@@ -0,0 +1,10 @@
+! { dg-do compile }
+! { dg-options "-g" }
+program p
+   type t
+      integer :: a
+      integer :: b(0)
+   end type
+   type(t), parameter :: z = t(1, [2])
+   print *, z
+end
diff --git a/gcc/testsuite/gfortran.dg/pr71047.f08 b/gcc/testsuite/gfortran.dg/pr71047.f08

new file mode 100644 (file)

index 0000000..61a0ad4
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr71047.f08
@@ -0,0 +1,48 @@
+! { dg-do compile }
+! { dg-options "-fdump-tree-original" }
+!
+! Fortran/PR71047
+!
+
+module m
+ implicit none
+
+ type, abstract :: c_abstr
+  integer :: i = 0
+ end type c_abstr
+
+ type, extends(c_abstr) :: t_a
+  class(c_abstr), allocatable :: f
+ end type t_a
+ 
+ type, extends(c_abstr) :: t_b
+ end type t_b
+
+contains
+
+ subroutine set(y,x)
+  class(c_abstr), intent(in)  :: x
+  type(t_a),      intent(out) :: y
+   allocate( y%f , source=x )
+ end subroutine set
+
+end module m
+
+
+program p
+ use m
+ implicit none
+
+ type(t_a) :: res
+ type(t_b) :: var
+
+  call set( res , var )
+  write(*,*) res%i
+
+end program p
+
+!
+! Check to ensure the vtable is actually initialized.
+!
+! { dg-final { scan-tree-dump "t_a\\.\\d+\\.f\\._vptr =" "original" } }
+!
diff --git a/gcc/testsuite/gfortran.dg/pr71204.f90 b/gcc/testsuite/gfortran.dg/pr71204.f90

new file mode 100644 (file)

index 0000000..1d1ee5c
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/pr71204.f90
@@ -0,0 +1,17 @@
+! PR fortran/71204
+! { dg-do compile }
+! { dg-options "-O0" }
+
+module pr71204
+  character(10), allocatable :: z(:)
+end module
+
+subroutine s1
+  use pr71204
+  z(2) = z(1)
+end
+
+subroutine s2
+  use pr71204
+  z(2) = z(1)
+end
diff --git a/gcc/testsuite/gfortran.dg/submodule_14.f08 b/gcc/testsuite/gfortran.dg/submodule_14.f08

index 0e257d1..cbfc3d1 100644 (file)
--- a/gcc/testsuite/gfortran.dg/submodule_14.f08
+++ b/gcc/testsuite/gfortran.dg/submodule_14.f08
@@ -27,7 +27,7 @@ contains
          Call sub1 (x)
      End If
    End Procedure sub1
-  module function fcn1 (x) result(res)
+  recursive module function fcn1 (x) result(res)
      integer, intent (inout) :: x
      integer :: res
      res = x - 1
diff --git a/gcc/testsuite/gfortran.dg/submodule_16.f08 b/gcc/testsuite/gfortran.dg/submodule_16.f08

new file mode 100644 (file)

index 0000000..6e555b6
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/submodule_16.f08
@@ -0,0 +1,53 @@
+! { dg-do compile }
+!
+! Tests the fix for PR71156 in which the valid code (f7, f8 and f9 below)
+! triggered an error, while the invalid code (f1 to f6) compiled.
+!
+! Contributed by Damian Rousn  <damian@sourceryinstitute.org>
+!
+module my_interface
+  implicit none
+  interface
+    module subroutine f1
+    end subroutine
+    module subroutine f2
+    end subroutine
+    module subroutine f3
+    end subroutine
+    elemental module subroutine f4
+    end subroutine
+    pure module subroutine f5
+    end subroutine
+    recursive module subroutine f6
+    end subroutine
+    elemental module subroutine f7
+    end subroutine
+    pure module subroutine f8
+    end subroutine
+    recursive module subroutine f9
+    end subroutine
+  end interface
+end module
+
+submodule(my_interface) my_implementation
+  implicit none
+contains
+    elemental module subroutine f1 ! { dg-error "Mismatch in ELEMENTAL attribute" }
+    end subroutine
+    pure module subroutine f2 ! { dg-error "Mismatch in PURE attribute" }
+    end subroutine
+    recursive module subroutine f3 ! { dg-error "Mismatch in RECURSIVE attribute" }
+    end subroutine
+    module subroutine f4 ! { dg-error "ELEMENTAL prefix" }
+    end subroutine
+    module subroutine f5 ! { dg-error "PURE prefix" }
+    end subroutine
+    module subroutine f6 ! { dg-error "RECURSIVE prefix" }
+    end subroutine
+    elemental module subroutine f7
+    end subroutine
+    pure module subroutine f8
+    end subroutine
+    recursive module subroutine f9
+    end subroutine
+end submodule
diff --git a/gcc/testsuite/gfortran.dg/unexpected_eof.f b/gcc/testsuite/gfortran.dg/unexpected_eof.f

new file mode 100644 (file)

index 0000000..d3cdb99
--- /dev/null
+++ b/gcc/testsuite/gfortran.dg/unexpected_eof.f
@@ -0,0 +1,8 @@
+! { dg-do compile }
+! PR66461  ICE on missing end program in fixed source
+      program p
+         integer x(2)
+         x = -1
+         if ( x(1) < 0 .or.
+     &        x(2) < 0 ) print *, x
+! { dg-error "Unexpected end of file" "" { target *-*-* } 0 }
diff --git a/gcc/testsuite/gnat.dg/case_character.adb b/gcc/testsuite/gnat.dg/case_character.adb

new file mode 100644 (file)

index 0000000..59c9b66
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/case_character.adb
@@ -0,0 +1,19 @@
+-- { dg-do run }
+
+procedure Case_Character is
+
+  function Test (C : Character) return Integer is
+  begin
+    case C is
+      when ASCII.HT | ' ' .. Character'Last => return 1;
+      when others => return 0;
+    end case;
+  end;
+
+begin
+
+  if Test ('A') /= 1 then
+    raise Program_Error;
+  end if;
+
+end;
diff --git a/gcc/testsuite/gnat.dg/opt56.adb b/gcc/testsuite/gnat.dg/opt56.adb

new file mode 100644 (file)

index 0000000..9566f51
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/opt56.adb
@@ -0,0 +1,15 @@
+-- { dg-do compile }\r
+-- { dg-options "-O3" }\r
+\r
+package body Opt56 is\r
+\r
+   function F (Values : Vector) return Boolean is\r
+      Result : Boolean := True;\r
+   begin\r
+      for I in Values'Range loop\r
+         Result := Result and Values (I) >= 0.0;\r
+     end loop;\r
+     return Result;\r
+   end;\r
+\r
+end Opt56;\r
diff --git a/gcc/testsuite/gnat.dg/opt56.ads b/gcc/testsuite/gnat.dg/opt56.ads

new file mode 100644 (file)

index 0000000..31ee195
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/opt56.ads
@@ -0,0 +1,7 @@
+package Opt56 is\r
+\r
+   type Vector is array (Positive range <>) of Float;\r
+\r
+   function F (Values : Vector) return Boolean;\r
+\r
+end Opt56;\r
diff --git a/gcc/testsuite/gnat.dg/renaming10.adb b/gcc/testsuite/gnat.dg/renaming10.adb

new file mode 100644 (file)

index 0000000..07d4312
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/renaming10.adb
@@ -0,0 +1,12 @@
+-- { dg-do compile }
+
+package body Renaming10 is
+
+   function F (Input : Rec) return Natural is
+      Position : Natural renames Input.Position;
+      Index : Natural renames Natural'Succ(Position);
+   begin
+      return Index;
+   end;
+
+end Renaming10;
diff --git a/gcc/testsuite/gnat.dg/renaming10.ads b/gcc/testsuite/gnat.dg/renaming10.ads

new file mode 100644 (file)

index 0000000..aeb9fc1
--- /dev/null
+++ b/gcc/testsuite/gnat.dg/renaming10.ads
@@ -0,0 +1,9 @@
+package Renaming10 is
+
+   type Rec is record
+      Position : Natural;
+   end record;
+
+   function F (Input : Rec) return Natural;
+
+end Renaming10;
diff --git a/gcc/testsuite/opt55.adb b/gcc/testsuite/opt55.adb

new file mode 100644 (file)

index 0000000..70f486b
--- /dev/null
+++ b/gcc/testsuite/opt55.adb
@@ -0,0 +1,20 @@
+-- { dg-do compile }\r
+-- { dg-options "-O" }\r
+\r
+package body Opt55 is\r
+\r
+   function Cond (B : Boolean; If_True, If_False : Date) return Date is\r
+   begin\r
+      if B then\r
+         return If_True;\r
+      else\r
+         return If_False;\r
+      end if;\r
+   end;\r
+\r
+   function F (C : Rec2; B : Boolean) return Date is\r
+   begin\r
+      return Cond (B, C.D1, C.D2);\r
+   end;\r
+\r
+end Opt55;\r
diff --git a/gcc/testsuite/opt55.ads b/gcc/testsuite/opt55.ads

new file mode 100644 (file)

index 0000000..fec3c9a
--- /dev/null
+++ b/gcc/testsuite/opt55.ads
@@ -0,0 +1,22 @@
+package Opt55 is\r
+\r
+   type Date is record\r
+      D : Float;\r
+   end record;\r
+\r
+   type Rec1 (Kind : Boolean := False) is record\r
+      case Kind is\r
+         when True => N : Natural;\r
+         when False => null;\r
+      end case;\r
+   end record;\r
+\r
+   type Rec2 (D : Positive) is record\r
+      R  : Rec1;\r
+      D1 : Date;\r
+      D2 : Date;\r
+   end record;\r
+\r
+   function F (C : Rec2; B : Boolean) return Date;\r
+\r
+end Opt55;\r
diff --git a/gcc/tree-chkp.c b/gcc/tree-chkp.c

index 3fba12c..4ca2d34 100644 (file)
--- a/gcc/tree-chkp.c
+++ b/gcc/tree-chkp.c
@@ -1853,7 +1853,9 @@ chkp_add_bounds_to_call_stmt (gimple_stmt_iterator *gsi)
  
    /* If function decl is available then use it for
       formal arguments list.  Otherwise use function type.  */
-  if (fndecl && DECL_ARGUMENTS (fndecl))
+  if (fndecl
+      && DECL_ARGUMENTS (fndecl)
+      && gimple_call_fntype (call) == TREE_TYPE (fndecl))
      first_formal_arg = DECL_ARGUMENTS (fndecl);
    else
      {
@@ -1929,7 +1931,16 @@ chkp_add_bounds_to_call_stmt (gimple_stmt_iterator *gsi)
      {
        tree new_decl = chkp_maybe_create_clone (fndecl)->decl;
        gimple_call_set_fndecl (new_call, new_decl);
-      gimple_call_set_fntype (new_call, TREE_TYPE (new_decl));
+      /* In case of a type cast we should modify used function
+        type instead of using type of new fndecl.  */
+      if (gimple_call_fntype (call) != TREE_TYPE (fndecl))
+       {
+         tree type = gimple_call_fntype (call);
+         type = chkp_copy_function_type_adding_bounds (type);
+         gimple_call_set_fntype (new_call, type);
+       }
+      else
+       gimple_call_set_fntype (new_call, TREE_TYPE (new_decl));
      }
    /* For indirect call we should fix function pointer type if
       pass some bounds.  */
@@ -3646,6 +3657,7 @@ chkp_find_bounds_1 (tree ptr, tree ptr_src, gimple_stmt_iterator *iter)
        break;
  
      case ADDR_EXPR:
+    case WITH_SIZE_EXPR:
        bounds = chkp_make_addressed_object_bounds (TREE_OPERAND (ptr_src, 0), iter);
        break;
  
diff --git a/gcc/tree-inline.c b/gcc/tree-inline.c

index a4e044c..b6b6d6e 100644 (file)
--- a/gcc/tree-inline.c
+++ b/gcc/tree-inline.c
@@ -840,7 +840,7 @@ is_parm (tree decl)
  static unsigned short
  remap_dependence_clique (copy_body_data *id, unsigned short clique)
  {
-  if (clique == 0)
+  if (clique == 0 || processing_debug_stmt)
      return 0;
    if (!id->dependence_map)
      id->dependence_map = new hash_map<dependence_hash, unsigned short>;
diff --git a/gcc/tree-nested.c b/gcc/tree-nested.c

index 8563687..3507d32 100644 (file)
--- a/gcc/tree-nested.c
+++ b/gcc/tree-nested.c
@@ -1114,6 +1114,8 @@ convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
         case OMP_CLAUSE_GANG:
         case OMP_CLAUSE_WORKER:
         case OMP_CLAUSE_VECTOR:
+       case OMP_CLAUSE_ASYNC:
+       case OMP_CLAUSE_WAIT:
           /* Several OpenACC clauses have optional arguments.  Check if they
              are present.  */
           if (OMP_CLAUSE_OPERAND (clause, 0))
@@ -1197,8 +1199,22 @@ convert_nonlocal_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
         case OMP_CLAUSE_SIMD:
         case OMP_CLAUSE_DEFAULTMAP:
         case OMP_CLAUSE_SEQ:
+       case OMP_CLAUSE_INDEPENDENT:
+       case OMP_CLAUSE_AUTO:
           break;
  
+       case OMP_CLAUSE_TILE:
+         /* OpenACC tile clauses are discarded during gimplification, so we
+            don't expect to see anything here.  */
+         gcc_unreachable ();
+
+       case OMP_CLAUSE__CACHE_:
+         /* These clauses belong to the OpenACC cache directive, which is
+            discarded during gimplification, so we don't expect to see
+            anything here.  */
+         gcc_unreachable ();
+
+       case OMP_CLAUSE_DEVICE_RESIDENT:
         default:
           gcc_unreachable ();
         }
@@ -1332,7 +1348,7 @@ convert_nonlocal_reference_stmt (gimple_stmt_iterator *gsi, bool *handled_ops_p,
         {
           wi->val_only = true;
           wi->is_lhs = false;
-         *handled_ops_p = true;
+         *handled_ops_p = false;
           return NULL_TREE;
         }
        break;
@@ -1790,6 +1806,8 @@ convert_local_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
         case OMP_CLAUSE_GANG:
         case OMP_CLAUSE_WORKER:
         case OMP_CLAUSE_VECTOR:
+       case OMP_CLAUSE_ASYNC:
+       case OMP_CLAUSE_WAIT:
           /* Several OpenACC clauses have optional arguments.  Check if they
              are present.  */
           if (OMP_CLAUSE_OPERAND (clause, 0))
@@ -1878,8 +1896,22 @@ convert_local_omp_clauses (tree *pclauses, struct walk_stmt_info *wi)
         case OMP_CLAUSE_SIMD:
         case OMP_CLAUSE_DEFAULTMAP:
         case OMP_CLAUSE_SEQ:
+       case OMP_CLAUSE_INDEPENDENT:
+       case OMP_CLAUSE_AUTO:
           break;
  
+       case OMP_CLAUSE_TILE:
+         /* OpenACC tile clauses are discarded during gimplification, so we
+            don't expect to see anything here.  */
+         gcc_unreachable ();
+
+       case OMP_CLAUSE__CACHE_:
+         /* These clauses belong to the OpenACC cache directive, which is
+            discarded during gimplification, so we don't expect to see
+            anything here.  */
+         gcc_unreachable ();
+
+       case OMP_CLAUSE_DEVICE_RESIDENT:
         default:
           gcc_unreachable ();
         }
diff --git a/gcc/tree-sra.c b/gcc/tree-sra.c

index 6fafe55..2808875 100644 (file)
--- a/gcc/tree-sra.c
+++ b/gcc/tree-sra.c
@@ -2074,7 +2074,8 @@ sort_and_splice_var_accesses (tree var)
        access->grp_scalar_write = grp_scalar_write;
        access->grp_assignment_read = grp_assignment_read;
        access->grp_assignment_write = grp_assignment_write;
-      access->grp_hint = multiple_scalar_reads || total_scalarization;
+      access->grp_hint = total_scalarization
+       || (multiple_scalar_reads && !constant_decl_p (var));
        access->grp_total_scalarization = total_scalarization;
        access->grp_partial_lhs = grp_partial_lhs;
        access->grp_unscalarizable_region = unscalarizable_region;
@@ -3559,32 +3560,31 @@ initialize_constant_pool_replacements (void)
    unsigned i;
  
    EXECUTE_IF_SET_IN_BITMAP (candidate_bitmap, 0, i, bi)
-    if (bitmap_bit_p (should_scalarize_away_bitmap, i)
-       && !bitmap_bit_p (cannot_scalarize_away_bitmap, i))
-      {
-       tree var = candidate (i);
-       if (!constant_decl_p (var))
-         continue;
-       vec<access_p> *access_vec = get_base_access_vector (var);
-       if (!access_vec)
-         continue;
-       for (unsigned i = 0; i < access_vec->length (); i++)
-         {
-           struct access *access = (*access_vec)[i];
-           if (!access->replacement_decl)
-             continue;
-           gassign *stmt = gimple_build_assign (
-             get_access_replacement (access), unshare_expr (access->expr));
-           if (dump_file && (dump_flags & TDF_DETAILS))
-             {
-               fprintf (dump_file, "Generating constant initializer: ");
-               print_gimple_stmt (dump_file, stmt, 0, 1);
-               fprintf (dump_file, "\n");
-             }
-           gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
-           update_stmt (stmt);
-         }
-      }
+    {
+      tree var = candidate (i);
+      if (!constant_decl_p (var))
+       continue;
+      vec<access_p> *access_vec = get_base_access_vector (var);
+      if (!access_vec)
+       continue;
+      for (unsigned i = 0; i < access_vec->length (); i++)
+       {
+         struct access *access = (*access_vec)[i];
+         if (!access->replacement_decl)
+           continue;
+         gassign *stmt
+           = gimple_build_assign (get_access_replacement (access),
+                                  unshare_expr (access->expr));
+         if (dump_file && (dump_flags & TDF_DETAILS))
+           {
+             fprintf (dump_file, "Generating constant initializer: ");
+             print_gimple_stmt (dump_file, stmt, 0, 1);
+             fprintf (dump_file, "\n");
+           }
+         gsi_insert_after (&gsi, stmt, GSI_NEW_STMT);
+         update_stmt (stmt);
+       }
+    }
  
    seq = gsi_seq (gsi);
    if (seq)
diff --git a/gcc/tree-ssa-loop-unswitch.c b/gcc/tree-ssa-loop-unswitch.c

index dd6fd01..ba1f13c 100644 (file)
--- a/gcc/tree-ssa-loop-unswitch.c
+++ b/gcc/tree-ssa-loop-unswitch.c
@@ -532,6 +532,12 @@ find_loop_guard (struct loop *loop)
                  guard_edge->src->index, guard_edge->dest->index);
        return NULL;
      }
+  if (guard_edge->dest == loop->latch)
+    {
+      if (dump_file && (dump_flags & TDF_DETAILS))
+       fprintf (dump_file, "Guard edge destination is loop latch.\n");
+      return NULL;
+    }
  
    if (dump_file && (dump_flags & TDF_DETAILS))
      fprintf (dump_file,
diff --git a/gcc/tree-ssa-phiopt.c b/gcc/tree-ssa-phiopt.c

index a752fe0..caf591b 100644 (file)
--- a/gcc/tree-ssa-phiopt.c
+++ b/gcc/tree-ssa-phiopt.c
@@ -438,15 +438,18 @@ factor_out_conditional_conversion (edge e0, edge e1, gphi *phi,
    /* Check if arg0 is an SSA_NAME and the stmt which defines arg0 is
       a conversion.  */
    arg0_def_stmt = SSA_NAME_DEF_STMT (arg0);
-  if (!is_gimple_assign (arg0_def_stmt)
-      || !gimple_assign_cast_p (arg0_def_stmt))
+  if (!gimple_assign_cast_p (arg0_def_stmt))
      return NULL;
  
    /* Use the RHS as new_arg0.  */
    convert_code = gimple_assign_rhs_code (arg0_def_stmt);
    new_arg0 = gimple_assign_rhs1 (arg0_def_stmt);
    if (convert_code == VIEW_CONVERT_EXPR)
-    new_arg0 = TREE_OPERAND (new_arg0, 0);
+    {
+      new_arg0 = TREE_OPERAND (new_arg0, 0);
+      if (!is_gimple_reg_type (TREE_TYPE (new_arg0)))
+       return NULL;
+    }
  
    if (TREE_CODE (arg1) == SSA_NAME)
      {
diff --git a/gcc/tree-ssa-sccvn.c b/gcc/tree-ssa-sccvn.c

index 083f1ee..494a7fb 100644 (file)
--- a/gcc/tree-ssa-sccvn.c
+++ b/gcc/tree-ssa-sccvn.c
@@ -1976,11 +1976,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_,
        /* We need to pre-pend vr->operands[0..i] to rhs.  */
        vec<vn_reference_op_s> old = vr->operands;
        if (i + 1 + rhs.length () > vr->operands.length ())
-       {
-         vr->operands.safe_grow (i + 1 + rhs.length ());
-         if (old == shared_lookup_references)
-           shared_lookup_references = vr->operands;
-       }
+       vr->operands.safe_grow (i + 1 + rhs.length ());
        else
         vr->operands.truncate (i + 1 + rhs.length ());
        FOR_EACH_VEC_ELT (rhs, j, vro)
@@ -2131,8 +2127,7 @@ vn_reference_lookup_3 (ao_ref *ref, tree vuse, void *vr_,
         {
           vec<vn_reference_op_s> old = vr->operands;
           vr->operands.safe_grow_cleared (2);
-         if (old == shared_lookup_references
-             && vr->operands != old)
+         if (old == shared_lookup_references)
             shared_lookup_references = vr->operands;
         }
        else
diff --git a/gcc/tree-ssa-structalias.c b/gcc/tree-ssa-structalias.c

index f34236f..477e604 100644 (file)
--- a/gcc/tree-ssa-structalias.c
+++ b/gcc/tree-ssa-structalias.c
@@ -4639,12 +4639,11 @@ find_func_aliases_for_call (struct function *fn, gcall *t)
           auto_vec<ce_s, 2> lhsc;
           struct constraint_expr rhs;
           struct constraint_expr *lhsp;
+         bool aggr_p = aggregate_value_p (lhsop, gimple_call_fntype (t));
  
           get_constraint_for (lhsop, &lhsc);
           rhs = get_function_part_constraint (fi, fi_result);
-         if (fndecl
-             && DECL_RESULT (fndecl)
-             && DECL_BY_REFERENCE (DECL_RESULT (fndecl)))
+         if (aggr_p)
             {
               auto_vec<ce_s, 2> tem;
               tem.quick_push (rhs);
@@ -4654,22 +4653,19 @@ find_func_aliases_for_call (struct function *fn, gcall *t)
             }
           FOR_EACH_VEC_ELT (lhsc, j, lhsp)
             process_constraint (new_constraint (*lhsp, rhs));
-       }
  
-      /* If we pass the result decl by reference, honor that.  */
-      if (lhsop
-         && fndecl
-         && DECL_RESULT (fndecl)
-         && DECL_BY_REFERENCE (DECL_RESULT (fndecl)))
-       {
-         struct constraint_expr lhs;
-         struct constraint_expr *rhsp;
+         /* If we pass the result decl by reference, honor that.  */
+         if (aggr_p)
+           {
+             struct constraint_expr lhs;
+             struct constraint_expr *rhsp;
  
-         get_constraint_for_address_of (lhsop, &rhsc);
-         lhs = get_function_part_constraint (fi, fi_result);
-         FOR_EACH_VEC_ELT (rhsc, j, rhsp)
-           process_constraint (new_constraint (lhs, *rhsp));
-         rhsc.truncate (0);
+             get_constraint_for_address_of (lhsop, &rhsc);
+             lhs = get_function_part_constraint (fi, fi_result);
+             FOR_EACH_VEC_ELT (rhsc, j, rhsp)
+                 process_constraint (new_constraint (lhs, *rhsp));
+             rhsc.truncate (0);
+           }
         }
  
        /* If we use a static chain, pass it along.  */
diff --git a/gcc/tree-ssa-tail-merge.c b/gcc/tree-ssa-tail-merge.c

index e95879f..3df41fd 100644 (file)
--- a/gcc/tree-ssa-tail-merge.c
+++ b/gcc/tree-ssa-tail-merge.c
@@ -538,6 +538,9 @@ same_succ::equal (const same_succ *e1, const same_succ *e2)
    gimple *s1, *s2;
    basic_block bb1, bb2;
  
+  if (e1 == e2)
+    return 1;
+
    if (e1->hashval != e2->hashval)
      return 0;
  
diff --git a/gcc/tree-ssa.c b/gcc/tree-ssa.c

index 6a16d26..60b2c4c 100644 (file)
--- a/gcc/tree-ssa.c
+++ b/gcc/tree-ssa.c
@@ -1590,9 +1590,16 @@ execute_update_addresses_taken (void)
                 if (gimple_assign_lhs (stmt) != lhs
                     && !useless_type_conversion_p (TREE_TYPE (lhs),
                                                    TREE_TYPE (rhs)))
-                 rhs = fold_build1 (VIEW_CONVERT_EXPR,
-                                    TREE_TYPE (lhs), rhs);
-
+                 {
+                   if (gimple_clobber_p (stmt))
+                     {
+                       rhs = build_constructor (TREE_TYPE (lhs), NULL);
+                       TREE_THIS_VOLATILE (rhs) = 1;
+                     }
+                   else
+                     rhs = fold_build1 (VIEW_CONVERT_EXPR,
+                                        TREE_TYPE (lhs), rhs);
+                 }
                 if (gimple_assign_lhs (stmt) != lhs)
                   gimple_assign_set_lhs (stmt, lhs);
  
diff --git a/gcc/tree-vect-data-refs.c b/gcc/tree-vect-data-refs.c

index 7652e21..00d8900 100644 (file)
--- a/gcc/tree-vect-data-refs.c
+++ b/gcc/tree-vect-data-refs.c
@@ -2751,7 +2751,7 @@ vect_analyze_data_ref_accesses (vec_info *vinfo)
           /* Sorting has ensured that DR_INIT (dra) <= DR_INIT (drb).  */
           HOST_WIDE_INT init_a = TREE_INT_CST_LOW (DR_INIT (dra));
           HOST_WIDE_INT init_b = TREE_INT_CST_LOW (DR_INIT (drb));
-         gcc_assert (init_a < init_b);
+         gcc_assert (init_a <= init_b);
  
           /* If init_b == init_a + the size of the type * k, we have an
              interleaving, and DRA is accessed before DRB.  */
diff --git a/gcc/tree-vect-loop.c b/gcc/tree-vect-loop.c

index d813b86..1cb28d7 100644 (file)
--- a/gcc/tree-vect-loop.c
+++ b/gcc/tree-vect-loop.c
@@ -216,7 +216,8 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
  
           gcc_assert (stmt_info);
  
-         if (STMT_VINFO_RELEVANT_P (stmt_info))
+         if (STMT_VINFO_RELEVANT_P (stmt_info)
+             || STMT_VINFO_LIVE_P (stmt_info))
              {
               gcc_assert (!STMT_VINFO_VECTYPE (stmt_info));
                scalar_type = TREE_TYPE (PHI_RESULT (phi));
@@ -437,9 +438,12 @@ vect_determine_vectorization_factor (loop_vec_info loop_vinfo)
               /* Bool ops don't participate in vectorization factor
                  computation.  For comparison use compared types to
                  compute a factor.  */
-             if (TREE_CODE (scalar_type) == BOOLEAN_TYPE)
+             if (TREE_CODE (scalar_type) == BOOLEAN_TYPE
+                 && is_gimple_assign (stmt)
+                 && gimple_assign_rhs_code (stmt) != COND_EXPR)
                 {
-                 if (STMT_VINFO_RELEVANT_P (stmt_info))
+                 if (STMT_VINFO_RELEVANT_P (stmt_info)
+                     || STMT_VINFO_LIVE_P (stmt_info))
                     mask_producers.safe_push (stmt_info);
                   bool_result = true;
  
diff --git a/gcc/tree-vect-patterns.c b/gcc/tree-vect-patterns.c

index 27080d2..d08b454 100644 (file)
--- a/gcc/tree-vect-patterns.c
+++ b/gcc/tree-vect-patterns.c
@@ -3673,8 +3673,10 @@ vect_recog_mask_conversion_pattern (vec<gimple *> *stmts, tree *type_in,
           if (!rhs1_type)
             return NULL;
         }
-      else
+      else if (COMPARISON_CLASS_P (rhs1))
         rhs1_type = TREE_TYPE (TREE_OPERAND (rhs1, 0));
+      else
+       return NULL;
  
        vectype2 = get_mask_type_for_scalar_type (rhs1_type);
  
diff --git a/gcc/tree-vect-slp.c b/gcc/tree-vect-slp.c

index d713848..b6a6fde 100644 (file)
--- a/gcc/tree-vect-slp.c
+++ b/gcc/tree-vect-slp.c
@@ -3050,7 +3050,7 @@ vect_get_constant_vectors (tree op, slp_tree slp_node,
                       if (integer_zerop (op))
                         op = build_int_cst (TREE_TYPE (vector_type), 0);
                       else if (integer_onep (op))
-                       op = build_int_cst (TREE_TYPE (vector_type), 1);
+                       op = build_all_ones_cst (TREE_TYPE (vector_type));
                       else
                         gcc_unreachable ();
                     }
@@ -3065,8 +3065,14 @@ vect_get_constant_vectors (tree op, slp_tree slp_node,
                   gimple *init_stmt;
                   if (VECTOR_BOOLEAN_TYPE_P (vector_type))
                     {
+                     tree true_val
+                       = build_all_ones_cst (TREE_TYPE (vector_type));
+                     tree false_val
+                       = build_zero_cst (TREE_TYPE (vector_type));
                       gcc_assert (INTEGRAL_TYPE_P (TREE_TYPE (op)));
-                     init_stmt = gimple_build_assign (new_temp, NOP_EXPR, op);
+                     init_stmt = gimple_build_assign (new_temp, COND_EXPR,
+                                                      op, true_val,
+                                                      false_val);
                     }
                   else
                     {
diff --git a/gcc/tree-vect-stmts.c b/gcc/tree-vect-stmts.c

index c327f2a..d5a237d 100644 (file)
--- a/gcc/tree-vect-stmts.c
+++ b/gcc/tree-vect-stmts.c
@@ -3022,8 +3022,10 @@ vectorizable_simd_clone_call (gimple *stmt, gimple_stmt_iterator *gsi,
      {
        STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_push (bestn->decl);
        for (i = 0; i < nargs; i++)
-       if (bestn->simdclone->args[i].arg_type
-           == SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP)
+       if ((bestn->simdclone->args[i].arg_type
+            == SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP)
+           || (bestn->simdclone->args[i].arg_type
+               == SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP))
           {
             STMT_VINFO_SIMD_CLONE_INFO (stmt_info).safe_grow_cleared (i * 3
                                                                         + 1);
@@ -3159,6 +3161,7 @@ vectorizable_simd_clone_call (gimple *stmt, gimple_stmt_iterator *gsi,
               vargs.safe_push (op);
               break;
             case SIMD_CLONE_ARG_TYPE_LINEAR_CONSTANT_STEP:
+           case SIMD_CLONE_ARG_TYPE_LINEAR_REF_CONSTANT_STEP:
               if (j == 0)
                 {
                   gimple_seq stmts;
@@ -3222,6 +3225,8 @@ vectorizable_simd_clone_call (gimple *stmt, gimple_stmt_iterator *gsi,
                   vargs.safe_push (new_temp);
                 }
               break;
+           case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_CONSTANT_STEP:
+           case SIMD_CLONE_ARG_TYPE_LINEAR_UVAL_CONSTANT_STEP:
             case SIMD_CLONE_ARG_TYPE_LINEAR_VARIABLE_STEP:
             case SIMD_CLONE_ARG_TYPE_LINEAR_REF_VARIABLE_STEP:
             case SIMD_CLONE_ARG_TYPE_LINEAR_VAL_VARIABLE_STEP:
diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c

index bbdf9ce..f21a853 100644 (file)
--- a/gcc/tree-vrp.c
+++ b/gcc/tree-vrp.c
@@ -2519,20 +2519,13 @@ extract_range_from_binary_expr_1 (value_range *vr,
                   min = wide_int_to_tree (expr_type, tmin);
                   max = wide_int_to_tree (expr_type, tmax);
                 }
-             else if (min_ovf == -1 && max_ovf == 1)
-               {
-                 /* Underflow and overflow, drop to VR_VARYING.  */
-                 set_value_range_to_varying (vr);
-                 return;
-               }
-             else
+             else if ((min_ovf == -1 && max_ovf == 0)
+                      || (max_ovf == 1 && min_ovf == 0))
                 {
                   /* Min underflow or max overflow.  The range kind
                      changes to VR_ANTI_RANGE.  */
                   bool covers = false;
                   wide_int tem = tmin;
-                 gcc_assert ((min_ovf == -1 && max_ovf == 0)
-                             || (max_ovf == 1 && min_ovf == 0));
                   type = VR_ANTI_RANGE;
                   tmin = tmax + 1;
                   if (wi::cmp (tmin, tmax, sgn) < 0)
@@ -2551,6 +2544,12 @@ extract_range_from_binary_expr_1 (value_range *vr,
                   min = wide_int_to_tree (expr_type, tmin);
                   max = wide_int_to_tree (expr_type, tmax);
                 }
+             else
+               {
+                 /* Other underflow and/or overflow, drop to VR_VARYING.  */
+                 set_value_range_to_varying (vr);
+                 return;
+               }
             }
           else
             {
diff --git a/gcc/tree.h b/gcc/tree.h

index 87e7563..c39b58e 100644 (file)
--- a/gcc/tree.h
+++ b/gcc/tree.h
@@ -4730,6 +4730,17 @@ ptrofftype_p (tree type)
           && TYPE_UNSIGNED (type) == TYPE_UNSIGNED (sizetype));
  }
  
+/* Return true if the argument is a complete type or an array
+   of unknown bound (whose type is incomplete but) whose elements
+   have complete type.  */
+static inline bool
+complete_or_array_type_p (const_tree type)
+{
+  return COMPLETE_TYPE_P (type)
+        || (TREE_CODE (type) == ARRAY_TYPE
+            && COMPLETE_TYPE_P (TREE_TYPE (type)));
+}
+
  extern tree strip_float_extensions (tree);
  extern int really_constant_p (const_tree);
  extern bool decl_address_invariant_p (const_tree);
diff --git a/libatomic/ChangeLog b/libatomic/ChangeLog

index 84fddda..278948e 100644 (file)
--- a/libatomic/ChangeLog
+++ b/libatomic/ChangeLog
@@ -1,3 +1,13 @@
+2016-05-10  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+       Backport from mainline:
+       2016-04-27  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+       * configure.tgt (configure_tgt_pre_target_cpu_XCFLAGS): New variable.
+       (*-*-rtems*): New supported target.
+       * config/rtems/host-config.h: New file.
+       * config/rtems/lock.c: Likewise.
+
  2016-04-27  Release Manager
  
         * GCC 6.1.0 released.
diff --git a/libatomic/config/rtems/host-config.h b/libatomic/config/rtems/host-config.h

new file mode 100644 (file)

index 0000000..d11e9ef
--- /dev/null
+++ b/libatomic/config/rtems/host-config.h
@@ -0,0 +1,41 @@
+/* Copyright (C) 2016 Free Software Foundation, Inc.
+   Contributed by Sebastian Huber <sebastian.huber@embedded-brains.de>.
+
+   This file is part of the GNU Atomic Library (libatomic).
+
+   Libatomic is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   Libatomic is distributed in the hope that it will be useful, but WITHOUT ANY
+   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+   more details.
+
+   Under Section 7 of GPL version 3, you are granted additional
+   permissions described in the GCC Runtime Library Exception, version
+   3.1, as published by the Free Software Foundation.
+
+   You should have received a copy of the GNU General Public License and
+   a copy of the GCC Runtime Library Exception along with this program;
+   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+   <http://www.gnu.org/licenses/>.  */
+
+/* Included after all more target-specific host-config.h.  */
+
+#include <machine/_libatomic.h>
+
+static inline UWORD
+protect_start (void *ptr)
+{
+  return _Libatomic_Protect_start (ptr);
+}
+
+static inline void
+protect_end (void *ptr, UWORD isr_level)
+{
+  _Libatomic_Protect_end (ptr, isr_level);
+}
+
+#include_next <host-config.h>
diff --git a/libatomic/config/rtems/lock.c b/libatomic/config/rtems/lock.c

new file mode 100644 (file)

index 0000000..f999f9b
--- /dev/null
+++ b/libatomic/config/rtems/lock.c
@@ -0,0 +1,37 @@
+/* Copyright (C) 2016 Free Software Foundation, Inc.
+   Contributed by Sebastian Huber <sebastian.huber@embedded-brains.de>.
+
+   This file is part of the GNU Atomic Library (libatomic).
+
+   Libatomic is free software; you can redistribute it and/or modify it
+   under the terms of the GNU General Public License as published by
+   the Free Software Foundation; either version 3 of the License, or
+   (at your option) any later version.
+
+   Libatomic is distributed in the hope that it will be useful, but WITHOUT ANY
+   WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
+   FOR A PARTICULAR PURPOSE.  See the GNU General Public License for
+   more details.
+
+   Under Section 7 of GPL version 3, you are granted additional
+   permissions described in the GCC Runtime Library Exception, version
+   3.1, as published by the Free Software Foundation.
+
+   You should have received a copy of the GNU General Public License and
+   a copy of the GCC Runtime Library Exception along with this program;
+   see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
+   <http://www.gnu.org/licenses/>.  */
+
+#include "libatomic_i.h"
+
+void
+libat_lock_n (void *ptr, size_t n)
+{
+  _Libatomic_Lock_n (ptr, n);
+}
+
+void
+libat_unlock_n (void *ptr, size_t n)
+{
+  _Libatomic_Unlock_n (ptr, n);
+}
diff --git a/libatomic/configure.tgt b/libatomic/configure.tgt

index c5470d7..eab2765 100644 (file)
--- a/libatomic/configure.tgt
+++ b/libatomic/configure.tgt
@@ -26,6 +26,10 @@
  # Map the target cpu to an ARCH sub-directory.  At the same time,
  # work out any special compilation flags as necessary.
  
+# Give operating systems the opportunity to discard XCFLAGS modifications based
+# on ${target_cpu}.  For example to allow proper use of multilibs.
+configure_tgt_pre_target_cpu_XCFLAGS="${XCFLAGS}"
+
  case "${target_cpu}" in
    alpha*)
         # fenv.c needs this option to generate inexact exceptions.
@@ -128,6 +132,12 @@ case "${target}" in
              ;;
          esac
         ;;
+
+  *-*-rtems*)
+       XCFLAGS="${configure_tgt_pre_target_cpu_XCFLAGS}"
+       config_path="rtems"
+       ;;
+
    *-*-elf*)
         # ??? No target OS.  We could be targeting bare-metal kernel-mode,
         # or user-mode for some custom OS.  If the target supports TAS,
diff --git a/libbacktrace/ChangeLog b/libbacktrace/ChangeLog

index ece9eac..b4e0199 100644 (file)
--- a/libbacktrace/ChangeLog
+++ b/libbacktrace/ChangeLog
@@ -1,3 +1,9 @@
+2016-05-18  Uros Bizjak  <ubizjak@gmail.com>
+
+       PR target/71161
+       * elf.c (phdr_callback) [__i386__]: Add
+       __attribute__((__force_align_arg_pointer__)).
+
  2016-04-27  Release Manager
  
         * GCC 6.1.0 released.
@@ -19,12 +25,13 @@
  
  2015-12-18  Andris Pavenis  <andris.pavenis@iki.fi>
  
-       * configure.ac: Specify that DJGPP do not have mmap even when sys/mman.h exists
+       * configure.ac: Specify that DJGPP do not have mmap
+       even when sys/mman.h exists.
         * configure: Regenerate
  
  2015-12-09  John David Anglin  <danglin@gcc.gnu.org>
  
-       PR 68115/libfortran
+       PR libgfortran/68115
         * configure.ac: Set libbacktrace_cv_sys_sync to no on hppa*-*-hpux*.
         * configure: Regenerate.
         * elf.c (backtrace_initialize): Cast __sync_bool_compare_and_swap call
diff --git a/libbacktrace/elf.c b/libbacktrace/elf.c

index f85ac65..81ba344 100644 (file)
--- a/libbacktrace/elf.c
+++ b/libbacktrace/elf.c
@@ -866,6 +866,9 @@ struct phdr_data
     libraries.  */
  
  static int
+#ifdef __i386__
+__attribute__ ((__force_align_arg_pointer__))
+#endif
  phdr_callback (struct dl_phdr_info *info, size_t size ATTRIBUTE_UNUSED,
                void *pdata)
  {
diff --git a/libcpp/po/ChangeLog b/libcpp/po/ChangeLog

index 68bd602..0366fc0 100644 (file)
--- a/libcpp/po/ChangeLog
+++ b/libcpp/po/ChangeLog
@@ -1,3 +1,15 @@
+2016-06-03  Joseph Myers  <joseph@codesourcery.com>
+
+       * sr.po: Update.
+
+2016-05-18  Joseph Myers  <joseph@codesourcery.com>
+
+       * da.po: Update.
+
+2016-05-12  Joseph Myers  <joseph@codesourcery.com>
+
+       * fi.po: Update.
+
  2016-05-03  Joseph Myers  <joseph@codesourcery.com>
  
         * nl.po: Update.
diff --git a/libcpp/po/da.po b/libcpp/po/da.po

index 5c8e82a..3f8bf85 100644 (file)
--- a/libcpp/po/da.po
+++ b/libcpp/po/da.po
@@ -128,10 +128,10 @@
  #
  msgid ""
  msgstr ""
-"Project-Id-Version: cpplib 6.1-b20160131\n"
+"Project-Id-Version: cpplib 6.1.0\n"
  "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n"
  "POT-Creation-Date: 2016-04-21 15:24+0000\n"
-"PO-Revision-Date: 2016-03-27 18:00+0200\n"
+"PO-Revision-Date: 2016-05-16 18:00+0200\n"
  "Last-Translator: Joe Hansen <joedalton2@yahoo.dk>\n"
  "Language-Team: Danish <dansk@dansk-gruppen.dk>\n"
  "Language: da\n"
@@ -394,7 +394,7 @@ msgstr "»%s« efter # er ikke et positivt heltal"
  #: directives.c:1061
  #, c-format
  msgid "file \"%s\" linemarker ignored due to incorrect nesting"
-msgstr ""
+msgstr "filen »%s« linjemarkør ignoreret på grund af ukorrekt indlejring"
  
  #: directives.c:1120 directives.c:1122 directives.c:1124 directives.c:1710
  #, c-format
@@ -555,10 +555,8 @@ msgid "invalid prefix \"0b\" for floating constant"
  msgstr "ugyldigt præfiks »0b« i kommatalskonstant"
  
  #: expr.c:555
-#, fuzzy
-#| msgid "use of C++11 hexadecimal floating constant"
  msgid "use of C++1z hexadecimal floating constant"
-msgstr "brug af C++11 hexadecimal kommatalskonstant"
+msgstr "brug af C++1z hexadecimal kommatalskonstant"
  
  #: expr.c:558
  msgid "use of C99 hexadecimal floating constant"
diff --git a/libcpp/po/fi.po b/libcpp/po/fi.po

index bbf184e..0f0ea9b 100644 (file)
--- a/libcpp/po/fi.po
+++ b/libcpp/po/fi.po
@@ -6,10 +6,10 @@
  #
  msgid ""
  msgstr ""
-"Project-Id-Version: cpplib 6.1-b20160131\n"
+"Project-Id-Version: cpplib 6.1.0\n"
  "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n"
  "POT-Creation-Date: 2016-04-21 15:24+0000\n"
-"PO-Revision-Date: 2016-02-09 22:14+0200\n"
+"PO-Revision-Date: 2016-05-12 23:30+0300\n"
  "Last-Translator: Lauri Nurmi <lanurmi@iki.fi>\n"
  "Language-Team: Finnish <translation-team-fi@lists.sourceforge.net>\n"
  "Language: fi\n"
@@ -17,7 +17,7 @@ msgstr ""
  "Content-Type: text/plain; charset=UTF-8\n"
  "Content-Transfer-Encoding: 8bit\n"
  "Plural-Forms: nplurals=2; plural=(n != 1);\n"
-"X-Generator: Poedit 1.8.6\n"
+"X-Generator: Poedit 1.8.7\n"
  
  #: charset.c:674
  #, c-format
@@ -275,7 +275,7 @@ msgstr "#:n jälkeinen ”%s” ei ole positiivinen kokonaisluku"
  #: directives.c:1061
  #, c-format
  msgid "file \"%s\" linemarker ignored due to incorrect nesting"
-msgstr ""
+msgstr "tiedoston ”%s” rivinmerkitsin jätetään huomiotta virheellisen sisäkkäisyyden vuoksi"
  
  #: directives.c:1120 directives.c:1122 directives.c:1124 directives.c:1710
  #, c-format
@@ -437,10 +437,8 @@ msgid "invalid prefix \"0b\" for floating constant"
  msgstr "virheellinen etuliite ”0b” liukulukuvakiolle"
  
  #: expr.c:555
-#, fuzzy
-#| msgid "use of C++11 hexadecimal floating constant"
  msgid "use of C++1z hexadecimal floating constant"
-msgstr "C++11:n heksadesimaaliliukulukuvakion käyttö"
+msgstr "C++1z:n heksadesimaaliliukulukuvakion käyttö"
  
  #: expr.c:558
  msgid "use of C99 hexadecimal floating constant"
diff --git a/libcpp/po/sr.po b/libcpp/po/sr.po

index 7cbf354..feca5bf 100644 (file)
--- a/libcpp/po/sr.po
+++ b/libcpp/po/sr.po
@@ -4,10 +4,10 @@
  # Мирослав Николић <miroslavnikolic@rocketmail.com>, 2012—2016.
  msgid ""
  msgstr ""
-"Project-Id-Version: cpplib-6.1-b20160131\n"
+"Project-Id-Version: cpplib-6.1.0\n"
  "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n"
  "POT-Creation-Date: 2016-04-21 15:24+0000\n"
-"PO-Revision-Date: 2016-03-05 08:37+0200\n"
+"PO-Revision-Date: 2016-05-29 19:20+0200\n"
  "Last-Translator: Мирослав Николић <miroslavnikolic@rocketmail.com>\n"
  "Language-Team: Serbian <(nothing)>\n"
  "Language: sr\n"
@@ -271,7 +271,7 @@ msgstr "„%s“ након „#“ није позитиван цео број"
  #: directives.c:1061
  #, c-format
  msgid "file \"%s\" linemarker ignored due to incorrect nesting"
-msgstr ""
+msgstr "датотека „%s“ означавач реда занемаренa због нетачног угњежђавања"
  
  #: directives.c:1120 directives.c:1122 directives.c:1124 directives.c:1710
  #, c-format
@@ -432,10 +432,8 @@ msgid "invalid prefix \"0b\" for floating constant"
  msgstr "неисправан префикс „0b“ за покретну константу"
  
  #: expr.c:555
-#, fuzzy
-#| msgid "use of C++11 hexadecimal floating constant"
  msgid "use of C++1z hexadecimal floating constant"
-msgstr "употреба Ц+11 хексадецималне покретне константе"
+msgstr "употреба Ц+1z хексадецималне покретне константе"
  
  #: expr.c:558
  msgid "use of C99 hexadecimal floating constant"
diff --git a/libffi/ChangeLog b/libffi/ChangeLog

index e00113c..c851366 100644 (file)
--- a/libffi/ChangeLog
+++ b/libffi/ChangeLog
@@ -1,3 +1,10 @@
+2016-05-23  Thomas Schwinge  <thomas@codesourcery.com>
+
+       Backport trunk r236594:
+
+       PR libffi/65567
+       * testsuite/lib/libffi.exp (libffi_feature_test): Fix, and simply.
+
  2016-04-27  Release Manager
  
         * GCC 6.1.0 released.
diff --git a/libffi/testsuite/lib/libffi.exp b/libffi/testsuite/lib/libffi.exp

index 169fe74..a0f6ab3 100644 (file)
--- a/libffi/testsuite/lib/libffi.exp
+++ b/libffi/testsuite/lib/libffi.exp
@@ -227,20 +227,21 @@ proc libffi_target_compile { source dest type options } {
  
  # TEST should be a preprocessor condition.  Returns true if it holds.
  proc libffi_feature_test { test } {
-    set src "ffitest.c"
+    set src "ffitest[pid].c"
  
      set f [open $src "w"]
      puts $f "#include <ffi.h>"
      puts $f $test
-    puts $f "xyzzy"
+    puts $f "/* OK */"
+    puts $f "#else"
+    puts $f "# error Failed $test"
      puts $f "#endif"
      close $f
  
-    set lines [libffi_target_compile $src "" "preprocess" ""]
+    set lines [libffi_target_compile $src /dev/null assembly ""]
      file delete $src
  
-    set last [lindex [split $lines] end]
-    return [regexp -- "xyzzy" $last]
+    return [string match "" $lines]
  }
  
  # Utility routines.
diff --git a/libgcc/ChangeLog b/libgcc/ChangeLog

index 6559564..f1ae9fe 100644 (file)
--- a/libgcc/ChangeLog
+++ b/libgcc/ChangeLog
@@ -1,3 +1,13 @@
+2016-05-17  Sebastian Huber  <sebastian.huber@embedded-brains.de>
+
+       Backport from mainline
+       2016-05-10  Joel Sherrill <joel@rtems.org>
+
+       PR libgcc/70720
+       * config.host (moxie-*-rtems*): Merge this stanza with other moxie
+       targets so the same extra_parts are built.  Also have tmake_file add
+       on to its value rather than override.
+
  2016-04-27  Release Manager
  
         * GCC 6.1.0 released.
diff --git a/libgcc/config.host b/libgcc/config.host

index b61a579..16a45c8 100644 (file)
--- a/libgcc/config.host
+++ b/libgcc/config.host
@@ -931,14 +931,9 @@ mmix-knuth-mmixware)
  mn10300-*-*)
         tmake_file=t-fdpbit
         ;;
-moxie-*-elf | moxie-*-moxiebox* | moxie-*-uclinux*)
-       tmake_file="moxie/t-moxie t-softfp-sfdf t-softfp-excl t-softfp"
-       extra_parts="$extra_parts crti.o crtn.o crtbegin.o crtend.o"
-       ;;
-moxie-*-rtems*)
+moxie-*-elf | moxie-*-moxiebox* | moxie-*-uclinux* | moxie-*-rtems*)
         tmake_file="$tmake_file moxie/t-moxie t-softfp-sfdf t-softfp-excl t-softfp"
-       # Don't use default.
-       extra_parts=
+       extra_parts="$extra_parts crti.o crtn.o crtbegin.o crtend.o"
         ;;
  msp430*-*-elf)
         tmake_file="$tm_file t-crtstuff t-fdpbit msp430/t-msp430"
diff --git a/libgomp/ChangeLog b/libgomp/ChangeLog

index 082d6b8..620ddb4 100644 (file)
--- a/libgomp/ChangeLog
+++ b/libgomp/ChangeLog
@@ -1,3 +1,30 @@
+2016-06-10  Thomas Schwinge  <thomas@codesourcery.com>
+
+       PR middle-end/71373
+       Backport from trunk r237291:
+       2016-06-10  Thomas Schwinge  <thomas@codesourcery.com>
+                   Cesar Philippidis  <cesar@codesourcery.com>
+
+       * libgomp.oacc-c/nested-function-1.c: New file.
+       * libgomp.oacc-c/nested-function-2.c: Likewise.
+       * libgomp.oacc-fortran/nested-function-1.f90: Likewise.
+       * libgomp.oacc-fortran/nested-function-2.f90: Likewise.
+       * libgomp.oacc-fortran/nested-function-3.f90: Likewise.
+
+       PR c/71381
+       Backport from trunk r237290:
+       * testsuite/libgomp.oacc-c-c++-common/cache-1.c: #include
+       "../../../gcc/testsuite/c-c++-common/goacc/cache-1.c".
+       * testsuite/libgomp.oacc-fortran/cache-1.f95: New file.
+
+2016-05-23  Martin Jambor  <mjambor@suse.cz>
+
+       * testsuite/libgomp.hsa.c/switch-sbr-2.c: New test.
+
+2016-05-16  Martin Jambor  <mjambor@suse.cz>
+
+        * testsuite/libgomp.hsa.c/complex-align-2.c: New test.
+
  2016-04-29  Cesar Philippidis  <cesar@codesourcery.com>
  
         PR middle-end/70626
diff --git a/libgomp/testsuite/libgomp.hsa.c/complex-align-2.c b/libgomp/testsuite/libgomp.hsa.c/complex-align-2.c

new file mode 100644 (file)

index 0000000..b2d7acf
--- /dev/null
+++ b/libgomp/testsuite/libgomp.hsa.c/complex-align-2.c
@@ -0,0 +1,27 @@
+#pragma omp declare target
+    _Complex int *g;
+#pragma omp end declare target
+
+
+
+_Complex float f(void);
+
+int
+main ()
+{
+  _Complex int y;
+#pragma omp target map(from:y)
+  {
+    _Complex int x;
+    g = &x;
+    __imag__ x = 1;
+    __real__ x = 2;
+    y = x;
+  }
+
+  if ((__imag__ y != 1)
+      || (__real__ y != 2))
+    __builtin_abort ();
+  return 0;
+}
+
diff --git a/libgomp/testsuite/libgomp.hsa.c/switch-sbr-2.c b/libgomp/testsuite/libgomp.hsa.c/switch-sbr-2.c

new file mode 100644 (file)

index 0000000..06990d1
--- /dev/null
+++ b/libgomp/testsuite/libgomp.hsa.c/switch-sbr-2.c
@@ -0,0 +1,59 @@
+/* { dg-additional-options "-fno-tree-switch-conversion" } */
+
+#pragma omp declare target
+int
+foo (unsigned a)
+{
+  switch (a)
+    {
+    case 1 ... 5:
+      return 1;
+    case 9 ... 11:
+      return a + 3;
+    case 12 ... 13:
+      return a + 3;
+    default:
+      return 44;
+    }
+}
+#pragma omp end declare target
+
+#define s 100
+
+void __attribute__((noinline, noclone))
+verify(int *a)
+{
+  if (a[0] != 44)
+    __builtin_abort ();
+  
+  for (int i = 1; i <= 5; i++)
+    if (a[i] != 1)
+      __builtin_abort ();
+
+  for (int i = 6; i <= 8; i++)
+    if (a[i] != 44)
+      __builtin_abort ();
+
+  for (int i = 9; i <= 13; i++)
+    if (a[i] != i + 3)
+      __builtin_abort ();
+
+  for (int i = 14; i < s; i++)
+    if (a[i] != 44)
+      __builtin_abort ();
+}
+
+int main(int argc)
+{
+  int array[s];
+#pragma omp target
+  {
+    for (int i = 0; i < s; i++)
+      {
+       int v = foo (i);
+       array[i] = v;
+      }
+  }
+  verify (array);
+  return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c-c++-common/cache-1.c b/libgomp/testsuite/libgomp.oacc-c-c++-common/cache-1.c

index 3f1f0bb..16aaed5 100644 (file)
--- a/libgomp/testsuite/libgomp.oacc-c-c++-common/cache-1.c
+++ b/libgomp/testsuite/libgomp.oacc-c-c++-common/cache-1.c
@@ -1,48 +1,3 @@
-int
-main (int argc, char **argv)
-{
-#define N   2
-    int a[N], b[N];
-    int i;
+/* OpenACC cache directive.  */
  
-    for (i = 0; i < N; i++)
-    {
-        a[i] = 3;
-        b[i] = 0;
-    }
-
-#pragma acc parallel copyin (a[0:N]) copyout (b[0:N])
-{
-    int ii;
-
-    for (ii = 0; ii < N; ii++)
-    {
-        const int idx = ii;
-        int n = 1;
-        const int len = n;
-
-#pragma acc cache (a[0:N])
-
-#pragma acc cache (a[0:N], b[0:N])
-
-#pragma acc cache (a[0])
-
-#pragma acc cache (a[0], a[1], b[0:N])
-
-#pragma acc cache (a[idx])
-
-#pragma acc cache (a[idx:len])
-
-        b[ii] = a[ii];
-    }
-}
-
-
-    for (i = 0; i < N; i++)
-    {
-        if (a[i] != b[i])
-            __builtin_abort ();
-    }
-
-    return 0;
-}
+#include "../../../gcc/testsuite/c-c++-common/goacc/cache-1.c"
diff --git a/libgomp/testsuite/libgomp.oacc-c/nested-function-1.c b/libgomp/testsuite/libgomp.oacc-c/nested-function-1.c

new file mode 100644 (file)

index 0000000..fb2a3ac
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c/nested-function-1.c
@@ -0,0 +1,52 @@
+/* Exercise nested function decomposition, gcc/tree-nested.c.  */
+
+int
+main (void)
+{
+  void test1 ()
+  {
+    int i, j, k;
+    int a[4][7][8];
+
+    __builtin_memset (a, 0, sizeof (a));
+
+#pragma acc parallel
+#pragma acc loop collapse(4 - 1)
+    for (i = 1; i <= 3; i++)
+      for (j = 4; j <= 6; j++)
+       for (k = 5; k <= 7; k++)
+         a[i][j][k] = i + j + k;
+
+    for (i = 1; i <= 3; i++)
+      for (j = 4; j <= 6; j++)
+       for (k = 5; k <= 7; k++)
+         if (a[i][j][k] != i + j + k)
+           __builtin_abort();
+  }
+
+  void test2 ()
+  {
+    int i, j, k;
+    int a[4][4][4];
+
+    __builtin_memset (a, 0, sizeof (a));
+
+#pragma acc parallel
+#pragma acc loop collapse(3)
+    for (i = 1; i <= 3; i++)
+      for (j = 1; j <= 3; j++)
+       for (k = 1; k <= 3; k++)
+         a[i][j][k] = 1;
+
+    for (i = 1; i <= 3; i++)
+      for (j = 1; j <= 3; j++)
+       for (k = 1; k <= 3; k++)
+         if (a[i][j][k] != 1)
+           __builtin_abort ();
+  }
+
+  test1 ();
+  test2 ();
+
+  return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-c/nested-function-2.c b/libgomp/testsuite/libgomp.oacc-c/nested-function-2.c

new file mode 100644 (file)

index 0000000..2c3f3fe
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-c/nested-function-2.c
@@ -0,0 +1,155 @@
+/* Exercise nested function decomposition, gcc/tree-nested.c.  */
+
+int
+main (void)
+{
+  int p1 = 2, p2 = 6, p3 = 0, p4 = 4, p5 = 13, p6 = 18, p7 = 1, p8 = 1, p9 = 1;
+
+  void test1 ()
+  {
+    int i, j, k;
+    int a[4][4][4];
+
+    __builtin_memset (a, '\0', sizeof (a));
+
+#pragma acc parallel
+#pragma acc loop collapse(3)
+    for (i = 1; i <= 3; i++)
+      for (j = 1; j <= 3; j++)
+       for (k = 2; k <= 3; k++)
+         a[i][j][k] = 1;
+
+    for (i = 1; i <= 3; i++)
+      for (j = 1; j <= 3; j++)
+       for (k = 2; k <= 3; k++)
+         if (a[i][j][k] != 1)
+           __builtin_abort();
+  }
+
+  void test2 (int v1, int v2, int v3, int v4, int v5, int v6)
+  {
+    int i, j, k, l = 0, r = 0;
+    int a[7][5][19];
+    int b[7][5][19];
+
+    __builtin_memset (a, '\0', sizeof (a));
+    __builtin_memset (b, '\0', sizeof (b));
+
+#pragma acc parallel reduction (||:l)
+#pragma acc loop reduction (||:l) collapse(3)
+    for (i = v1; i <= v2; i++)
+      for (j = v3; j <= v4; j++)
+       for (k = v5; k <= v6; k++)
+         {
+           l = l || i < 2 || i > 6 || j < 0 || j > 4 || k < 13 || k > 18;
+           if (!l)
+             a[i][j][k] += 1;
+         }
+
+    for (i = v1; i <= v2; i++)
+      for (j = v3; j <= v4; j++)
+       for (k = v5; k <= v6; k++)
+         {
+           r = r || i < 2 || i > 6 || j < 0 || j > 4 || k < 13 || k > 18;
+           if (!r)
+             b[i][j][k] += 1;
+         }
+
+    if (l != r)
+      __builtin_abort ();
+
+    for (i = v1; i <= v2; i++)
+      for (j = v3; j <= v4; j++)
+       for (k = v5; k <= v6; k++)
+         if (b[i][j][k] != a[i][j][k])
+           __builtin_abort ();
+  }
+
+  void test3 (int v1, int v2, int v3, int v4, int v5, int v6, int v7, int v8,
+      int v9)
+  {
+    int i, j, k, l = 0, r = 0;
+    int a[7][5][19];
+    int b[7][5][19];
+
+    __builtin_memset (a, '\0', sizeof (a));
+    __builtin_memset (b, '\0', sizeof (b));
+
+#pragma acc parallel reduction (||:l)
+#pragma acc loop reduction (||:l) collapse(3)
+    for (i = v1; i <= v2; i += v7)
+      for (j = v3; j <= v4; j += v8)
+       for (k = v5; k <= v6; k += v9)
+         {
+           l = l || i < 2 || i > 6 || j < 0 || j > 4 || k < 13 || k > 18;
+           if (!l)
+             a[i][j][k] += 1;
+         }
+
+    for (i = v1; i <= v2; i += v7)
+      for (j = v3; j <= v4; j += v8)
+       for (k = v5; k <= v6; k += v9)
+         {
+           r = r || i < 2 || i > 6 || j < 0 || j > 4 || k < 13 || k > 18;
+           if (!r)
+             b[i][j][k] += 1;
+         }
+
+    if (l != r)
+      __builtin_abort ();
+
+    for (i = v1; i <= v2; i++)
+      for (j = v3; j <= v4; j++)
+       for (k = v5; k <= v6; k++)
+         if (b[i][j][k] != a[i][j][k])
+           __builtin_abort ();
+  }
+
+  void test4 ()
+  {
+    int i, j, k, l = 0, r = 0;
+    int a[7][5][19];
+    int b[7][5][19];
+    int v1 = p1, v2 = p2, v3 = p3, v4 = p4, v5 = p5, v6 = p6, v7 = p7, v8 = p8,
+      v9 = p9;
+
+    __builtin_memset (a, '\0', sizeof (a));
+    __builtin_memset (b, '\0', sizeof (b));
+
+#pragma acc parallel reduction (||:l)
+#pragma acc loop reduction (||:l) collapse(3)
+    for (i = v1; i <= v2; i += v7)
+      for (j = v3; j <= v4; j += v8)
+       for (k = v5; k <= v6; k += v9)
+         {
+           l = l || i < 2 || i > 6 || j < 0 || j > 4 || k < 13 || k > 18;
+           if (!l)
+             a[i][j][k] += 1;
+         }
+
+    for (i = v1; i <= v2; i += v7)
+      for (j = v3; j <= v4; j += v8)
+       for (k = v5; k <= v6; k += v9)
+         {
+           r = r || i < 2 || i > 6 || j < 0 || j > 4 || k < 13 || k > 18;
+           if (!r)
+             b[i][j][k] += 1;
+         }
+
+    if (l != r)
+      __builtin_abort ();
+
+    for (i = v1; i <= v2; i++)
+      for (j = v3; j <= v4; j++)
+       for (k = v5; k <= v6; k++)
+         if (b[i][j][k] != a[i][j][k])
+           __builtin_abort ();
+  }
+
+  test1 ();
+  test2 (p1, p2, p3, p4, p5, p6);
+  test3 (p1, p2, p3, p4, p5, p6, p7, p8, p9);
+  test4 ();
+
+  return 0;
+}
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/cache-1.f95 b/libgomp/testsuite/libgomp.oacc-fortran/cache-1.f95

new file mode 100644 (file)

index 0000000..37313d8
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-fortran/cache-1.f95
@@ -0,0 +1,6 @@
+! OpenACC cache directive.
+! { dg-do run }
+! { dg-additional-options "-std=f2008" }
+! { dg-additional-options "-cpp" }
+
+#include "../../../gcc/testsuite/gfortran.dg/goacc/cache-1.f95"
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/nested-function-1.f90 b/libgomp/testsuite/libgomp.oacc-fortran/nested-function-1.f90

new file mode 100644 (file)

index 0000000..fdbca44
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-fortran/nested-function-1.f90
@@ -0,0 +1,70 @@
+! Exercise nested function decomposition, gcc/tree-nested.c.
+
+! { dg-do run }
+
+program collapse2
+  call test1
+  call test2
+contains
+  subroutine test1
+    integer :: i, j, k, a(1:3, 4:6, 5:7)
+    logical :: l
+    l = .false.
+    a(:, :, :) = 0
+    !$acc parallel reduction (.or.:l)
+    !$acc loop worker vector collapse(4 - 1)
+      do 164 i = 1, 3
+        do 164 j = 4, 6
+          do 164 k = 5, 7
+            a(i, j, k) = i + j + k
+164      end do
+    !$acc loop worker vector reduction(.or.:l) collapse(2)
+firstdo: do i = 1, 3
+        do j = 4, 6
+          do k = 5, 7
+            if (a(i, j, k) .ne. (i + j + k)) l = .true.
+          end do
+        end do
+      end do firstdo
+    !$acc end parallel
+    if (l) call abort
+  end subroutine test1
+
+  subroutine test2
+    integer :: a(3,3,3), k, kk, kkk, l, ll, lll
+    a = 0
+    !$acc parallel
+    ! Use "gang(static:1)" here and below to effectively turn gang-redundant
+    ! execution mode into something like gang-single.
+    !$acc loop gang(static:1) collapse(1)
+      do 115 k=1,3
+         !$acc loop collapse(2)
+  dokk: do kk=1,3
+          do kkk=1,3
+            a(k,kk,kkk) = 1
+          enddo
+        enddo dokk
+115   continue
+    !$acc loop gang(static:1) collapse(1)
+      do k=1,3
+         if (any(a(k,1:3,1:3).ne.1)) call abort
+      enddo
+    ! Use "gang(static:1)" here and below to effectively turn gang-redundant
+    ! execution mode into something like gang-single.
+    !$acc loop gang(static:1) collapse(1)
+ dol: do 120 l=1,3
+    !$acc loop collapse(2)
+  doll: do ll=1,3
+          do lll=1,3
+            a(l,ll,lll) = 2
+          enddo
+        enddo doll
+120   end do dol
+    !$acc loop gang(static:1) collapse(1)
+     do l=1,3
+        if (any(a(l,1:3,1:3).ne.2)) call abort
+     enddo
+    !$acc end parallel
+  end subroutine test2
+
+end program collapse2
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/nested-function-2.f90 b/libgomp/testsuite/libgomp.oacc-fortran/nested-function-2.f90

new file mode 100644 (file)

index 0000000..4e28196
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-fortran/nested-function-2.f90
@@ -0,0 +1,173 @@
+! Exercise nested function decomposition, gcc/tree-nested.c.
+
+! { dg-do run }
+
+program collapse3
+  integer :: p1, p2, p3, p4, p5, p6, p7, p8, p9
+  p1 = 2
+  p2 = 6
+  p3 = -2
+  p4 = 4
+  p5 = 13
+  p6 = 18
+  p7 = 1
+  p8 = 1
+  p9 = 1
+  call test1
+  call test2 (p1, p2, p3, p4, p5, p6)
+  call test3 (p1, p2, p3, p4, p5, p6, p7, p8, p9)
+  call test4
+contains
+  subroutine test1
+    integer :: a(3,3,3), k, kk, kkk, l, ll, lll
+    !$acc parallel
+    !$acc loop collapse(3)
+      do 115 k=1,3
+dokk:   do kk=1,3
+          do kkk=1,3
+            a(k,kk,kkk) = 1
+          enddo
+        enddo dokk
+115   continue
+    !$acc end parallel
+    if (any(a(1:3,1:3,1:3).ne.1)) call abort
+    !$acc parallel
+    !$acc loop collapse(3)
+dol:  do 120 l=1,3
+doll:   do ll=1,3
+          do lll=1,3
+            a(l,ll,lll) = 2
+          enddo
+        enddo doll
+120   end do dol
+    !$acc end parallel
+    if (any(a(1:3,1:3,1:3).ne.2)) call abort
+    end subroutine test1
+
+  subroutine test2(v1, v2, v3, v4, v5, v6)
+    integer :: i, j, k, a(1:7, -3:5, 12:19), b(1:7, -3:5, 12:19)
+    integer :: v1, v2, v3, v4, v5, v6
+    logical :: l, r
+    l = .false.
+    r = .false.
+    a(:, :, :) = 0
+    b(:, :, :) = 0
+    !$acc parallel reduction (.or.:l)
+    !$acc loop reduction (.or.:l) collapse (3)
+      do i = v1, v2
+        do j = v3, v4
+          do k = v5, v6
+            l = l.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+            l = l.or.k.lt.13.or.k.gt.18
+            if (.not.l) a(i, j, k) = a(i, j, k) + 1
+          end do
+        end do
+      end do
+    !$acc end parallel
+    do i = v1, v2
+      do j = v3, v4
+        do k = v5, v6
+          r = r.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+          r = r.or.k.lt.13.or.k.gt.18
+          if (.not.l) b(i, j, k) = b(i, j, k) + 1
+        end do
+      end do
+    end do
+    if (l .neqv. r) call abort
+    do i = v1, v2
+      do j = v3, v4
+        do k = v5, v6
+           if (a(i, j, k) .ne. b(i, j, k)) call abort
+        end do
+      end do
+    end do
+  end subroutine test2
+
+  subroutine test3(v1, v2, v3, v4, v5, v6, v7, v8, v9)
+    integer :: i, j, k, a(1:7, -3:5, 12:19), b(1:7, -3:5, 12:19)
+    integer :: v1, v2, v3, v4, v5, v6, v7, v8, v9
+    logical :: l, r
+    l = .false.
+    r = .false.
+    a(:, :, :) = 0
+    b(:, :, :) = 0
+    !$acc parallel reduction (.or.:l)
+    !$acc loop reduction (.or.:l) collapse (3)
+      do i = v1, v2, v7
+        do j = v3, v4, v8
+          do k = v5, v6, v9
+            l = l.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+            l = l.or.k.lt.13.or.k.gt.18
+            if (.not.l) a(i, j, k) = a(i, j, k) + 1
+          end do
+        end do
+      end do
+    !$acc end parallel
+    do i = v1, v2, v7
+      do j = v3, v4, v8
+        do k = v5, v6, v9
+          r = r.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+          r = r.or.k.lt.13.or.k.gt.18
+          if (.not.l) b(i, j, k) = b(i, j, k) + 1
+        end do
+      end do
+    end do
+    if (l .neqv. r) call abort
+    do i = v1, v2, v7
+      do j = v3, v4, v8
+        do k = v5, v6, v9
+           if (a(i, j, k) .ne. b(i, j, k)) call abort
+        end do
+      end do
+    end do
+  end subroutine test3
+
+  subroutine test4
+    integer :: i, j, k, a(1:7, -3:5, 12:19), b(1:7, -3:5, 12:19)
+    integer :: v1, v2, v3, v4, v5, v6, v7, v8, v9
+    logical :: l, r
+    l = .false.
+    r = .false.
+    a(:, :, :) = 0
+    b(:, :, :) = 0
+    v1 = p1
+    v2 = p2
+    v3 = p3
+    v4 = p4
+    v5 = p5
+    v6 = p6
+    v7 = p7
+    v8 = p8
+    v9 = p9
+    !$acc parallel reduction (.or.:l)
+    !$acc loop reduction (.or.:l) collapse (3)
+      do i = v1, v2, v7
+        do j = v3, v4, v8
+          do k = v5, v6, v9
+            l = l.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+            l = l.or.k.lt.13.or.k.gt.18
+            if (.not.l) a(i, j, k) = a(i, j, k) + 1
+          end do
+        end do
+      end do
+    !$acc end parallel
+    do i = v1, v2, v7
+      do j = v3, v4, v8
+        do k = v5, v6, v9
+          r = r.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+          r = r.or.k.lt.13.or.k.gt.18
+          if (.not.r) b(i, j, k) = b(i, j, k) + 1
+        end do
+      end do
+    end do
+    if (l .neqv. r) call abort
+    do i = v1, v2, v7
+      do j = v3, v4, v8
+         do k = v5, v6, v9
+           if (a(i, j, k) .ne. b(i, j, k)) call abort
+         end do
+      end do
+    end do
+  end subroutine test4
+
+end program collapse3
diff --git a/libgomp/testsuite/libgomp.oacc-fortran/nested-function-3.f90 b/libgomp/testsuite/libgomp.oacc-fortran/nested-function-3.f90

new file mode 100644 (file)

index 0000000..2f6485e
--- /dev/null
+++ b/libgomp/testsuite/libgomp.oacc-fortran/nested-function-3.f90
@@ -0,0 +1,244 @@
+! Exercise nested function decomposition, gcc/tree-nested.c.
+
+! { dg-do run }
+
+program sub_collapse_3
+  call test1
+  call test2 (2, 6, -2, 4, 13, 18)
+  call test3 (2, 6, -2, 4, 13, 18, 1, 1, 1)
+  call test4
+  call test5 (2, 6, -2, 4, 13, 18)
+  call test6 (2, 6, -2, 4, 13, 18, 1, 1, 1)
+contains
+  subroutine test1
+    integer :: a(3,3,3), k, kk, kkk, l, ll, lll
+    !$acc parallel
+    !$acc loop collapse(3)
+      do 115 k=1,3
+dokk:   do kk=1,3
+          do kkk=1,3
+            a(k,kk,kkk) = 1
+          enddo
+        enddo dokk
+115   continue
+    !$acc end parallel
+    if (any(a(1:3,1:3,1:3).ne.1)) call abort
+    !$acc parallel
+    !$acc loop collapse(3)
+dol:  do 120 l=1,3
+doll:   do ll=1,3
+          do lll=1,3
+            a(l,ll,lll) = 2
+          enddo
+        enddo doll
+120   end do dol
+    !$acc end parallel
+    if (any(a(1:3,1:3,1:3).ne.2)) call abort
+  end subroutine test1
+
+  subroutine test2(v1, v2, v3, v4, v5, v6)
+    integer :: i, j, k, a(1:7, -3:5, 12:19), b(1:7, -3:5, 12:19)
+    integer :: v1, v2, v3, v4, v5, v6
+    logical :: l, r
+    l = .false.
+    r = .false.
+    a(:, :, :) = 0
+    b(:, :, :) = 0
+    !$acc parallel pcopyin (v1, v2, v3, v4, v5, v6) reduction (.or.:l)
+    !$acc loop reduction (.or.:l) collapse (3)
+      do i = v1, v2
+        do j = v3, v4
+          do k = v5, v6
+            l = l.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+            l = l.or.k.lt.13.or.k.gt.18
+            if (.not.l) a(i, j, k) = a(i, j, k) + 1
+          end do
+        end do
+      end do
+    !$acc end parallel
+    do i = v1, v2
+      do j = v3, v4
+        do k = v5, v6
+          r = r.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+          r = r.or.k.lt.13.or.k.gt.18
+          if (.not.l) b(i, j, k) = b(i, j, k) + 1
+        end do
+      end do
+    end do
+    if (l .neqv. r) call abort
+    do i = v1, v2
+      do j = v3, v4
+        do k = v5, v6
+           if (a(i, j, k) .ne. b(i, j, k)) call abort
+        end do
+      end do
+    end do
+  end subroutine test2
+
+  subroutine test3(v1, v2, v3, v4, v5, v6, v7, v8, v9)
+    integer :: i, j, k, a(1:7, -3:5, 12:19), b(1:7, -3:5, 12:19)
+    integer :: v1, v2, v3, v4, v5, v6, v7, v8, v9
+    logical :: l, r
+    l = .false.
+    r = .false.
+    a(:, :, :) = 0
+    b(:, :, :) = 0
+    !$acc parallel pcopyin (v1, v2, v3, v4, v5, v6, v7, v8, v9) reduction (.or.:l)
+    !$acc loop reduction (.or.:l) collapse (3)
+      do i = v1, v2, v7
+        do j = v3, v4, v8
+          do k = v5, v6, v9
+            l = l.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+            l = l.or.k.lt.13.or.k.gt.18
+            if (.not.l) a(i, j, k) = a(i, j, k) + 1
+          end do
+        end do
+      end do
+    !$acc end parallel
+    do i = v1, v2, v7
+      do j = v3, v4, v8
+        do k = v5, v6, v9
+          r = r.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+          r = r.or.k.lt.13.or.k.gt.18
+          if (.not.l) b(i, j, k) = b(i, j, k) + 1
+        end do
+      end do
+    end do
+    if (l .neqv. r) call abort
+    do i = v1, v2, v7
+      do j = v3, v4, v8
+        do k = v5, v6, v9
+           if (a(i, j, k) .ne. b(i, j, k)) call abort
+        end do
+      end do
+    end do
+  end subroutine test3
+
+  subroutine test4
+    integer :: i, j, k, a(1:7, -3:5, 12:19), b(1:7, -3:5, 12:19)
+    integer :: v1, v2, v3, v4, v5, v6, v7, v8, v9
+    logical :: l, r
+    l = .false.
+    r = .false.
+    a(:, :, :) = 0
+    b(:, :, :) = 0
+    v1 = 2
+    v2 = 6
+    v3 = -2
+    v4 = 4
+    v5 = 13
+    v6 = 18
+    v7 = 1
+    v8 = 1
+    v9 = 1
+    !$acc parallel pcopyin (v1, v2, v3, v4, v5, v6, v7, v8, v9) reduction (.or.:l)
+    !$acc loop reduction (.or.:l) collapse (3)
+      do i = v1, v2, v7
+        do j = v3, v4, v8
+          do k = v5, v6, v9
+            l = l.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+            l = l.or.k.lt.13.or.k.gt.18
+            if (.not.l) a(i, j, k) = a(i, j, k) + 1
+          end do
+        end do
+      end do
+    !$acc end parallel
+    do i = v1, v2, v7
+      do j = v3, v4, v8
+        do k = v5, v6, v9
+          r = r.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+          r = r.or.k.lt.13.or.k.gt.18
+          if (.not.r) b(i, j, k) = b(i, j, k) + 1
+        end do
+      end do
+    end do
+    if (l .neqv. r) call abort
+    do i = v1, v2, v7
+      do j = v3, v4, v8
+         do k = v5, v6, v9
+           if (a(i, j, k) .ne. b(i, j, k)) call abort
+         end do
+      end do
+    end do
+  end subroutine test4
+
+  subroutine test5(v1, v2, v3, v4, v5, v6)
+    integer :: i, j, k, a(1:7, -3:5, 12:19), b(1:7, -3:5, 12:19)
+    integer :: v1, v2, v3, v4, v5, v6
+    logical :: l, r
+    l = .false.
+    r = .false.
+    a(:, :, :) = 0
+    b(:, :, :) = 0
+    !$acc parallel pcopyin (v1, v2, v3, v4, v5, v6) reduction (.or.:l)
+    !$acc loop reduction (.or.:l) collapse (3)
+      do i = v1, v2
+        do j = v3, v4
+          do k = v5, v6
+            l = l.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+            l = l.or.k.lt.13.or.k.gt.18
+            if (.not.l) a(i, j, k) = a(i, j, k) + 1
+          end do
+        end do
+      end do
+    !$acc end parallel
+    do i = v1, v2
+      do j = v3, v4
+        do k = v5, v6
+          r = r.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+          r = r.or.k.lt.13.or.k.gt.18
+          if (.not.r) b(i, j, k) = b(i, j, k) + 1
+        end do
+      end do
+    end do
+    if (l .neqv. r) call abort
+    do i = v1, v2
+      do j = v3, v4
+        do k = v5, v6
+           if (a(i, j, k) .ne. b(i, j, k)) call abort
+        end do
+      end do
+    end do
+  end subroutine test5
+
+  subroutine test6(v1, v2, v3, v4, v5, v6, v7, v8, v9)
+    integer :: i, j, k, a(1:7, -3:5, 12:19), b(1:7, -3:5, 12:19)
+    integer :: v1, v2, v3, v4, v5, v6, v7, v8, v9
+    logical :: l, r
+    l = .false.
+    r = .false.
+    a(:, :, :) = 0
+    b(:, :, :) = 0
+    !$acc parallel pcopyin (v1, v2, v3, v4, v5, v6, v7, v8, v9) reduction (.or.:l)
+    !$acc loop reduction (.or.:l) collapse (3)
+      do i = v1, v2, v7
+        do j = v3, v4, v8
+          do k = v5, v6, v9
+            l = l.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+            l = l.or.k.lt.13.or.k.gt.18
+            if (.not.l) a(i, j, k) = a(i, j, k) + 1
+            m = i * 100 + j * 10 + k
+          end do
+        end do
+      end do
+    !$acc end parallel
+    do i = v1, v2, v7
+      do j = v3, v4, v8
+        do k = v5, v6, v9
+          r = r.or.i.lt.2.or.i.gt.6.or.j.lt.-2.or.j.gt.4
+          r = r.or.k.lt.13.or.k.gt.18
+          if (.not.r) b(i, j, k) = b(i, j, k) + 1
+        end do
+      end do
+    end do
+    if (l .neqv. r) call abort
+    do i = v1, v2, v7
+      do j = v3, v4, v8
+        do k = v5, v6, v9
+           if (a(i, j, k) .ne. b(i, j, k)) call abort
+        end do
+      end do
+    end do
+  end subroutine test6
+
+end program sub_collapse_3
diff --git a/libiberty/ChangeLog b/libiberty/ChangeLog

index 49f1d47..4a6b38a 100644 (file)
--- a/libiberty/ChangeLog
+++ b/libiberty/ChangeLog
@@ -1,3 +1,30 @@
+2016-05-19  Jakub Jelinek  <jakub@redhat.com>
+
+       Backported from mainline
+       2016-05-19  Jakub Jelinek  <jakub@redhat.com>
+
+       PR c++/70498
+       * cp-demangle.c (d_expression_1): Formatting fix.
+
+       2016-05-02  Marcel Böhme  <boehme.marcel@gmail.com>
+
+       PR c++/70498
+       * cp-demangle.c: Parse numbers as integer instead of long to avoid
+       overflow after sanity checks. Include <limits.h> if available.
+       (INT_MAX): Define if necessary.
+       (d_make_template_param): Takes integer argument instead of long.
+       (d_make_function_param): Likewise.
+       (d_append_num): Likewise.
+       (d_identifier): Likewise.
+       (d_number): Parse as and return integer.
+       (d_compact_number): Handle overflow.
+       (d_source_name): Change variable type to integer for parsed number.
+       (d_java_resource): Likewise.
+       (d_special_name): Likewise.
+       (d_discriminator): Likewise.
+       (d_unnamed_type): Likewise.
+       * testsuite/demangle-expected: Add regression test cases.
+
  2016-04-27  Release Manager
  
         * GCC 6.1.0 released.
@@ -16,7 +43,7 @@
         -1.
  
  2016-03-31  Mikhail Maltsev  <maltsevm@gmail.com>
-           Marcel Bohme  boehme.marcel@gmail.com
+           Marcel Bohme  <boehme.marcel@gmail.com>
  
         PR c++/67394
         PR c++/70481
@@ -2037,7 +2064,7 @@
         that are locale-independent.
         * Makefile.in (filename_cmp.o): Add dependency on safe-ctype.h.
  
-2007-04-11  Thomas Neumann  tneumann@users.sourceforge.net
+2007-04-11  Thomas Neumann  <tneumann@users.sourceforge.net>
  
         * argv.c: Use ANSI C declarations.
         * make-relative-prefix.c: Likewise.
diff --git a/libiberty/cp-demangle.c b/libiberty/cp-demangle.c

index bd64bef..09d6469 100644 (file)
--- a/libiberty/cp-demangle.c
+++ b/libiberty/cp-demangle.c
@@ -128,6 +128,13 @@ extern char *alloca ();
  # endif /* alloca */
  #endif /* HAVE_ALLOCA_H */
  
+#ifdef HAVE_LIMITS_H
+#include <limits.h>
+#endif
+#ifndef INT_MAX
+# define INT_MAX       (int)(((unsigned int) ~0) >> 1)          /* 0x7FFFFFFF */ 
+#endif
+
  #include "ansidecl.h"
  #include "libiberty.h"
  #include "demangle.h"
@@ -398,7 +405,7 @@ d_make_dtor (struct d_info *, enum gnu_v3_dtor_kinds,
               struct demangle_component *);
  
  static struct demangle_component *
-d_make_template_param (struct d_info *, long);
+d_make_template_param (struct d_info *, int);
  
  static struct demangle_component *
  d_make_sub (struct d_info *, const char *, int);
@@ -421,9 +428,9 @@ static struct demangle_component *d_unqualified_name (struct d_info *);
  
  static struct demangle_component *d_source_name (struct d_info *);
  
-static long d_number (struct d_info *);
+static int d_number (struct d_info *);
  
-static struct demangle_component *d_identifier (struct d_info *, long);
+static struct demangle_component *d_identifier (struct d_info *, int);
  
  static struct demangle_component *d_operator_name (struct d_info *);
  
@@ -1119,7 +1126,7 @@ d_make_dtor (struct d_info *di, enum gnu_v3_dtor_kinds kind,
  /* Add a new template parameter.  */
  
  static struct demangle_component *
-d_make_template_param (struct d_info *di, long i)
+d_make_template_param (struct d_info *di, int i)
  {
    struct demangle_component *p;
  
@@ -1135,7 +1142,7 @@ d_make_template_param (struct d_info *di, long i)
  /* Add a new function parameter.  */
  
  static struct demangle_component *
-d_make_function_param (struct d_info *di, long i)
+d_make_function_param (struct d_info *di, int i)
  {
    struct demangle_component *p;
  
@@ -1620,7 +1627,7 @@ d_unqualified_name (struct d_info *di)
  static struct demangle_component *
  d_source_name (struct d_info *di)
  {
-  long len;
+  int len;
    struct demangle_component *ret;
  
    len = d_number (di);
@@ -1633,12 +1640,12 @@ d_source_name (struct d_info *di)
  
  /* number ::= [n] <(non-negative decimal integer)>  */
  
-static long
+static int
  d_number (struct d_info *di)
  {
    int negative;
    char peek;
-  long ret;
+  int ret;
  
    negative = 0;
    peek = d_peek_char (di);
@@ -1681,7 +1688,7 @@ d_number_component (struct d_info *di)
  /* identifier ::= <(unqualified source code identifier)>  */
  
  static struct demangle_component *
-d_identifier (struct d_info *di, long len)
+d_identifier (struct d_info *di, int len)
  {
    const char *name;
  
@@ -1702,7 +1709,7 @@ d_identifier (struct d_info *di, long len)
    /* Look for something which looks like a gcc encoding of an
       anonymous namespace, and replace it with a more user friendly
       name.  */
-  if (len >= (long) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
+  if (len >= (int) ANONYMOUS_NAMESPACE_PREFIX_LEN + 2
        && memcmp (name, ANONYMOUS_NAMESPACE_PREFIX,
                  ANONYMOUS_NAMESPACE_PREFIX_LEN) == 0)
      {
@@ -1870,7 +1877,7 @@ d_java_resource (struct d_info *di)
  {
    struct demangle_component *p = NULL;
    struct demangle_component *next = NULL;
-  long len, i;
+  int len, i;
    char c;
    const char *str;
  
@@ -2012,7 +2019,7 @@ d_special_name (struct d_info *di)
         case 'C':
           {
             struct demangle_component *derived_type;
-           long offset;
+           int offset;
             struct demangle_component *base_type;
  
             derived_type = cplus_demangle_type (di);
@@ -2946,10 +2953,10 @@ d_pointer_to_member_type (struct d_info *di)
  
  /* <non-negative number> _ */
  
-static long
+static int
  d_compact_number (struct d_info *di)
  {
-  long num;
+  int num;
    if (d_peek_char (di) == '_')
      num = 0;
    else if (d_peek_char (di) == 'n')
@@ -2957,7 +2964,7 @@ d_compact_number (struct d_info *di)
    else
      num = d_number (di) + 1;
  
-  if (! d_check_char (di, '_'))
+  if (num < 0 || ! d_check_char (di, '_'))
      return -1;
    return num;
  }
@@ -2969,7 +2976,7 @@ d_compact_number (struct d_info *di)
  static struct demangle_component *
  d_template_param (struct d_info *di)
  {
-  long param;
+  int param;
  
    if (! d_check_char (di, 'T'))
      return NULL;
@@ -3171,9 +3178,10 @@ d_expression_1 (struct d_info *di)
         }
        else
         {
-         index = d_compact_number (di) + 1;
-         if (index == 0)
+         index = d_compact_number (di);
+         if (index == INT_MAX || index == -1)
             return NULL;
+         index++;
         }
        return d_make_function_param (di, index);
      }
@@ -3502,7 +3510,7 @@ d_local_name (struct d_info *di)
  static int
  d_discriminator (struct d_info *di)
  {
-  long discrim;
+  int discrim;
  
    if (d_peek_char (di) != '_')
      return 1;
@@ -3558,7 +3566,7 @@ static struct demangle_component *
  d_unnamed_type (struct d_info *di)
  {
    struct demangle_component *ret;
-  long num;
+  int num;
  
    if (! d_check_char (di, 'U'))
      return NULL;
@@ -4086,10 +4094,10 @@ d_append_string (struct d_print_info *dpi, const char *s)
  }
  
  static inline void
-d_append_num (struct d_print_info *dpi, long l)
+d_append_num (struct d_print_info *dpi, int l)
  {
    char buf[25];
-  sprintf (buf,"%ld", l);
+  sprintf (buf,"%d", l);
    d_append_string (dpi, buf);
  }
  
diff --git a/libiberty/testsuite/demangle-expected b/libiberty/testsuite/demangle-expected

index e214ee5..d124261 100644 (file)
--- a/libiberty/testsuite/demangle-expected
+++ b/libiberty/testsuite/demangle-expected
@@ -4422,12 +4422,22 @@ void baz<int>(A<sizeof (foo((int)(), (floatcomplex )00000000_00000000))>*)
  _Z3fooI1FEN1XIXszdtcl1PclcvT__EEE5arrayEE4TypeEv
  X<sizeof ((P(((F)())())).array)>::Type foo<F>()
  #
-# Tests a use-after-free problem
+# Tests a use-after-free problem PR70481
  
  _Q.__0
  ::Q.(void)
  #
-# Tests a use-after-free problem
+# Tests a use-after-free problem PR70481
  
  _Q10-__9cafebabe.
  cafebabe.::-(void)
+#
+# Tests integer overflow problem PR70492
+
+__vt_90000000000cafebabe
+__vt_90000000000cafebabe
+#
+# Tests write access violation PR70498
+
+_Z80800000000000000000000
+_Z80800000000000000000000
diff --git a/libmpx/ChangeLog b/libmpx/ChangeLog

index 47146d1..98bb557 100644 (file)
--- a/libmpx/ChangeLog
+++ b/libmpx/ChangeLog
@@ -1,3 +1,10 @@
+2016-06-10  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       Backport from mainline r237292.
+       2016-06-10  Ilya Enkovich  <ilya.enkovich@intel.com>
+
+       * mpxwrap/mpx_wrappers.c (move_bounds): Fix overflow bug.
+
  2016-04-27  Release Manager
  
         * GCC 6.1.0 released.
diff --git a/libmpx/mpxwrap/mpx_wrappers.c b/libmpx/mpxwrap/mpx_wrappers.c

index d4c83ef..171a780 100644 (file)
--- a/libmpx/mpxwrap/mpx_wrappers.c
+++ b/libmpx/mpxwrap/mpx_wrappers.c
@@ -27,6 +27,7 @@
  #include "string.h"
  #include <sys/mman.h>
  #include <stdint.h>
+#include <assert.h>
  #include "mpxrt/mpxrt.h"
  
  void *
@@ -418,7 +419,16 @@ move_bounds (void *dst, const void *src, size_t n)
            else
              elems_to_copy -= src_bt_index_end + 1;
          }
-      src_bd_index_end--;
+      /* Go to previous table but beware of overflow.
+        We should have copied all required element
+        in case src_bd_index_end is 0.  */
+      if (src_bd_index_end)
+       src_bd_index_end--;
+      else
+       {
+         assert (!elems_to_copy);
+         return;
+       }
        /* For each bounds table we check if there are valid pointers inside.
           If there are some, we copy table in pre-counted portions.  */
        for (; src_bd_index_end > src_bd_index; src_bd_index_end--)
diff --git a/libsanitizer/ChangeLog b/libsanitizer/ChangeLog

index 93c2360..9689b26 100644 (file)
--- a/libsanitizer/ChangeLog
+++ b/libsanitizer/ChangeLog
@@ -1,3 +1,12 @@
+2016-05-18  Jakub Jelinek  <jakub@redhat.com>
+
+       Backported from mainline
+       2016-05-17  Jakub Jelinek  <jakub@redhat.com>
+
+       PR sanitizer/71160
+       * asan/asan_malloc_linux.cc: Cherry pick upstream r254395
+       and r269633.
+
  2016-04-27  Release Manager
  
         * GCC 6.1.0 released.
diff --git a/libsanitizer/asan/asan_malloc_linux.cc b/libsanitizer/asan/asan_malloc_linux.cc

index d03f1bb..bfe72af 100644 (file)
--- a/libsanitizer/asan/asan_malloc_linux.cc
+++ b/libsanitizer/asan/asan_malloc_linux.cc
@@ -24,39 +24,62 @@
  // ---------------------- Replacement functions ---------------- {{{1
  using namespace __asan;  // NOLINT
  
+static uptr allocated_for_dlsym;
+static const uptr kDlsymAllocPoolSize = 1024;
+static uptr alloc_memory_for_dlsym[kDlsymAllocPoolSize];
+
+static bool IsInDlsymAllocPool(const void *ptr) {
+  uptr off = (uptr)ptr - (uptr)alloc_memory_for_dlsym;
+  return off < sizeof(alloc_memory_for_dlsym);
+}
+
+static void *AllocateFromLocalPool(uptr size_in_bytes) {
+  uptr size_in_words = RoundUpTo(size_in_bytes, kWordSize) / kWordSize;
+  void *mem = (void*)&alloc_memory_for_dlsym[allocated_for_dlsym];
+  allocated_for_dlsym += size_in_words;
+  CHECK_LT(allocated_for_dlsym, kDlsymAllocPoolSize);
+  return mem;
+}
+
  INTERCEPTOR(void, free, void *ptr) {
    GET_STACK_TRACE_FREE;
+  if (UNLIKELY(IsInDlsymAllocPool(ptr)))
+    return;
    asan_free(ptr, &stack, FROM_MALLOC);
  }
  
  INTERCEPTOR(void, cfree, void *ptr) {
    GET_STACK_TRACE_FREE;
+  if (UNLIKELY(IsInDlsymAllocPool(ptr)))
+    return;
    asan_free(ptr, &stack, FROM_MALLOC);
  }
  
  INTERCEPTOR(void*, malloc, uptr size) {
+  if (UNLIKELY(!asan_inited))
+    // Hack: dlsym calls malloc before REAL(malloc) is retrieved from dlsym.
+    return AllocateFromLocalPool(size);
    GET_STACK_TRACE_MALLOC;
    return asan_malloc(size, &stack);
  }
  
  INTERCEPTOR(void*, calloc, uptr nmemb, uptr size) {
-  if (UNLIKELY(!asan_inited)) {
+  if (UNLIKELY(!asan_inited))
      // Hack: dlsym calls calloc before REAL(calloc) is retrieved from dlsym.
-    const uptr kCallocPoolSize = 1024;
-    static uptr calloc_memory_for_dlsym[kCallocPoolSize];
-    static uptr allocated;
-    uptr size_in_words = ((nmemb * size) + kWordSize - 1) / kWordSize;
-    void *mem = (void*)&calloc_memory_for_dlsym[allocated];
-    allocated += size_in_words;
-    CHECK(allocated < kCallocPoolSize);
-    return mem;
-  }
+    return AllocateFromLocalPool(nmemb * size);
    GET_STACK_TRACE_MALLOC;
    return asan_calloc(nmemb, size, &stack);
  }
  
  INTERCEPTOR(void*, realloc, void *ptr, uptr size) {
    GET_STACK_TRACE_MALLOC;
+  if (UNLIKELY(IsInDlsymAllocPool(ptr))) {
+    uptr offset = (uptr)ptr - (uptr)alloc_memory_for_dlsym;
+    uptr copy_size = Min(size, kDlsymAllocPoolSize - offset);
+    void *new_ptr = asan_malloc(size, &stack);
+    internal_memcpy(new_ptr, ptr, copy_size);
+    return new_ptr;
+  }
    return asan_realloc(ptr, size, &stack);
  }
  
diff --git a/libstdc++-v3/ChangeLog b/libstdc++-v3/ChangeLog

index 58e7d07..3c3fda9 100644 (file)
--- a/libstdc++-v3/ChangeLog
+++ b/libstdc++-v3/ChangeLog
@@ -1,3 +1,132 @@
+2016-05-26  Jonathan Wakely  <jwakely@redhat.com>
+
+       Backport from mainline
+       2016-04-24  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR libstdc++/70762
+       * testsuite/util/testsuite_fs.h (__gnu_test::nonexistent_path): Use
+       static counter to return a different path on every call.
+
+       * testsuite/experimental/filesystem/path/native/string.cc: Add
+       dg-require-filesystem-ts directive.
+
+2016-05-25  Jonathan Wakely  <jwakely@redhat.com>
+
+       Backport from mainline
+       2016-04-20  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR libstdc++/69703
+       * src/c++11/codecvt.cc (__codecvt_utf8_base<char16_t>::do_in,
+       __codecvt_utf8_utf16_base<char16_t>::do_in): Fix mask operations.
+
+       Backport from mainline
+       2016-04-19  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR libstdc++/69703
+       * src/c++11/codecvt.cc (__codecvt_utf8_base<char16_t>::do_in)):
+       Override endianness bit in mode.
+       * testsuite/22_locale/codecvt/codecvt_utf8/69703.cc: New test.
+       * testsuite/22_locale/codecvt/codecvt_utf8_utf16/66855.cc: Test
+       that little_endian mode is ignored.
+       * testsuite/experimental/filesystem/path/native/string.cc: New test.
+
+       Backport from mainline
+       2016-05-10  Jonathan Wakely  <jwakely@redhat.com>
+
+       * include/experimental/bits/fs_dir.h (begin, end): Add noexcept.
+       * testsuite/experimental/filesystem/iterators/directory_iterator.cc:
+       Test begin and end functions.
+       * testsuite/experimental/filesystem/iterators/
+       recursive_directory_iterator.cc: Likewise.
+
+       Backport from mainline
+       2016-05-10  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR libstdc++/71038
+       * src/filesystem/ops.cc (do_copy_file): Fix backwards conditions.
+       * testsuite/experimental/filesystem/operations/copy_file.cc: New test.
+
+       Backport from mainline
+       2016-05-10  Jonathan Wakely  <jwakely@redhat.com>
+
+       * include/experimental/bits/fs_dir.h (__directory_iterator_proxy):
+       Overload operator* to move from rvalues.
+
+       Backport from mainline
+       2016-05-10  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR libstdc++/71036
+       * src/filesystem/ops.cc (create_dir): Handle EEXIST from mkdir.
+       * testsuite/experimental/filesystem/operations/create_directory.cc:
+       New test.
+
+       Backport from mainline
+       2016-05-10  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR libstdc++/71037
+       * src/filesystem/ops.cc (canonical(const path&, const path&)): Add
+       base path to exception.
+       * testsuite/experimental/filesystem/operations/canonical.cc: Test
+       paths contained in exception.
+
+       Backport from mainline
+       2016-05-10  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR libstdc++/71005
+       * include/experimental/bits/fs_dir.h (__directory_iterator_proxy):
+       New type.
+       (directory_iterator::operator++(int)): Return proxy.
+       (recursive_directory_iterator::operator++(int)): Likewise.
+       * testsuite/experimental/filesystem/iterators/directory_iterator.cc:
+       Test post-increment.
+       * testsuite/experimental/filesystem/iterators/
+       recursive_directory_iterator.cc: Likewise.
+
+       Backport from mainline
+       2016-05-09  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR libstdc++/71004
+       * include/experimental/bits/fs_dir.h (recursive_directory_iterator):
+       Initialize scalar member variables in default constructor.
+       * testsuite/experimental/filesystem/iterators/
+       recursive_directory_iterator.cc: Test default construction.
+
+       Backport from mainline
+       2016-04-19  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR libstdc++/70609
+       * src/filesystem/ops.cc (close_fd): New function.
+       (do_copy_file): Set permissions before copying file contents. Check
+       result of closing file descriptors. Don't copy streambuf when file
+       is empty.
+       (copy(const path&, const path&, copy_options, error_code&)): Use
+       lstat for source file when copy_symlinks is set.
+       * testsuite/experimental/filesystem/operations/copy.cc: Test copy().
+
+       Backport from mainline
+       2016-04-19  Jonathan Wakely  <jwakely@redhat.com>
+
+       * include/experimental/bits/fs_fwd.h (operator&, operator|, operator^,
+       operator~ operator&=, operator|=, operator^=): Add noexcept to
+       overloaded operators for copy_options, perms and directory_options.
+       * src/filesystem/ops.cc (make_file_type, make_file_status,
+       is_not_found_errno, file_time): Add noexcept.
+
+2016-05-11  Jonathan Wakely  <jwakely@redhat.com>
+
+       PR libstdc++/71049
+       * src/c++11/cow-stdexcept.cc [!_GLIBCXX_USE_DUAL_ABI]: Don't define
+       exception constructors with __sso_string parameters.
+
+2016-05-09  Ville Voutilainen  <ville.voutilainen@gmail.com>
+
+       Avoid endless run-time recursion for copying single-element
+       tuples where the element type is by-value constructible
+       from any type.
+       * include/std/tuple (_NotSameTuple): New.
+       * include/std/tuple (tuple(_UElements&&...): Use it.
+       * testsuite/20_util/tuple/cons/element_accepts_anything_byval.cc: New.
+
  2016-04-27  Release Manager
  
         * GCC 6.1.0 released.
diff --git a/libstdc++-v3/include/experimental/bits/fs_dir.h b/libstdc++-v3/include/experimental/bits/fs_dir.h

index 4e28c8e..70a95eb 100644 (file)
--- a/libstdc++-v3/include/experimental/bits/fs_dir.h
+++ b/libstdc++-v3/include/experimental/bits/fs_dir.h
@@ -153,8 +153,25 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
    };
  
    struct _Dir;
+  class directory_iterator;
    class recursive_directory_iterator;
  
+  struct __directory_iterator_proxy
+  {
+    const directory_entry& operator*() const& noexcept { return _M_entry; }
+
+    directory_entry operator*() && noexcept { return std::move(_M_entry); }
+
+  private:
+    friend class directory_iterator;
+    friend class recursive_directory_iterator;
+
+    explicit
+    __directory_iterator_proxy(const directory_entry& __e) : _M_entry(__e) { }
+
+    directory_entry _M_entry;
+  };
+
    class directory_iterator
    {
    public:
@@ -177,7 +194,8 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
      : directory_iterator(__p, directory_options::none, __ec) { }
  
      directory_iterator(const path& __p,
-      directory_options __options, error_code& __ec) noexcept
+                      directory_options __options,
+                      error_code& __ec) noexcept
      : directory_iterator(__p, __options, &__ec) { }
  
      directory_iterator(const directory_iterator& __rhs) = default;
@@ -186,19 +204,22 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
  
      ~directory_iterator() = default;
  
-    directory_iterator& operator=(const directory_iterator& __rhs) = default;
-    directory_iterator& operator=(directory_iterator&& __rhs) noexcept = default;
+    directory_iterator&
+    operator=(const directory_iterator& __rhs) = default;
+
+    directory_iterator&
+    operator=(directory_iterator&& __rhs) noexcept = default;
  
      const directory_entry& operator*() const;
      const directory_entry* operator->() const { return &**this; }
      directory_iterator&    operator++();
      directory_iterator&    increment(error_code& __ec) noexcept;
  
-    directory_iterator operator++(int)
+    __directory_iterator_proxy operator++(int)
      {
-      auto __tmp = *this;
+      __directory_iterator_proxy __pr{**this};
        ++*this;
-      return __tmp;
+      return __pr;
      }
  
    private:
@@ -214,10 +235,12 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
    };
  
    inline directory_iterator
-  begin(directory_iterator __iter) { return __iter; }
+  begin(directory_iterator __iter) noexcept
+  { return __iter; }
  
    inline directory_iterator
-  end(directory_iterator) { return directory_iterator(); }
+  end(directory_iterator) noexcept
+  { return directory_iterator(); }
  
    inline bool
    operator==(const directory_iterator& __lhs, const directory_iterator& __rhs)
@@ -274,18 +297,18 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
  
      // modifiers
      recursive_directory_iterator&
-      operator=(const recursive_directory_iterator& __rhs) noexcept;
+    operator=(const recursive_directory_iterator& __rhs) noexcept;
      recursive_directory_iterator&
-      operator=(recursive_directory_iterator&& __rhs) noexcept;
+    operator=(recursive_directory_iterator&& __rhs) noexcept;
  
      recursive_directory_iterator& operator++();
      recursive_directory_iterator& increment(error_code& __ec) noexcept;
  
-    recursive_directory_iterator operator++(int)
+    __directory_iterator_proxy operator++(int)
      {
-      auto __tmp = *this;
+      __directory_iterator_proxy __pr{**this};
        ++*this;
-      return __tmp;
+      return __pr;
      }
  
      void pop();
@@ -301,15 +324,17 @@ _GLIBCXX_BEGIN_NAMESPACE_CXX11
  
      struct _Dir_stack;
      std::shared_ptr<_Dir_stack> _M_dirs;
-    directory_options _M_options;
-    bool _M_pending;
+    directory_options _M_options = {};
+    bool _M_pending = false;
    };
  
    inline recursive_directory_iterator
-  begin(recursive_directory_iterator __iter) { return __iter; }
+  begin(recursive_directory_iterator __iter) noexcept
+  { return __iter; }
  
    inline recursive_directory_iterator
-  end(recursive_directory_iterator) { return recursive_directory_iterator(); }
+  end(recursive_directory_iterator) noexcept
+  { return recursive_directory_iterator(); }
  
    inline bool
    operator==(const recursive_directory_iterator& __lhs,
diff --git a/libstdc++-v3/include/experimental/bits/fs_fwd.h b/libstdc++-v3/include/experimental/bits/fs_fwd.h

index 1482e18..57aa4d3 100644 (file)
--- a/libstdc++-v3/include/experimental/bits/fs_fwd.h
+++ b/libstdc++-v3/include/experimental/bits/fs_fwd.h
@@ -93,7 +93,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
    };
  
    constexpr copy_options
-  operator&(copy_options __x, copy_options __y)
+  operator&(copy_options __x, copy_options __y) noexcept
    {
      using __utype = typename std::underlying_type<copy_options>::type;
      return static_cast<copy_options>(
@@ -101,7 +101,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
    }
  
    constexpr copy_options
-  operator|(copy_options __x, copy_options __y)
+  operator|(copy_options __x, copy_options __y) noexcept
    {
      using __utype = typename std::underlying_type<copy_options>::type;
      return static_cast<copy_options>(
@@ -109,7 +109,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
    }
  
    constexpr copy_options
-  operator^(copy_options __x, copy_options __y)
+  operator^(copy_options __x, copy_options __y) noexcept
    {
      using __utype = typename std::underlying_type<copy_options>::type;
      return static_cast<copy_options>(
@@ -117,22 +117,22 @@ _GLIBCXX_END_NAMESPACE_CXX11
    }
  
    constexpr copy_options
-  operator~(copy_options __x)
+  operator~(copy_options __x) noexcept
    {
      using __utype = typename std::underlying_type<copy_options>::type;
      return static_cast<copy_options>(~static_cast<__utype>(__x));
    }
  
    inline copy_options&
-  operator&=(copy_options& __x, copy_options __y)
+  operator&=(copy_options& __x, copy_options __y) noexcept
    { return __x = __x & __y; }
  
    inline copy_options&
-  operator|=(copy_options& __x, copy_options __y)
+  operator|=(copy_options& __x, copy_options __y) noexcept
    { return __x = __x | __y; }
  
    inline copy_options&
-  operator^=(copy_options& __x, copy_options __y)
+  operator^=(copy_options& __x, copy_options __y) noexcept
    { return __x = __x ^ __y; }
  
  
@@ -163,7 +163,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
    };
  
    constexpr perms
-  operator&(perms __x, perms __y)
+  operator&(perms __x, perms __y) noexcept
    {
      using __utype = typename std::underlying_type<perms>::type;
      return static_cast<perms>(
@@ -171,7 +171,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
    }
  
    constexpr perms
-  operator|(perms __x, perms __y)
+  operator|(perms __x, perms __y) noexcept
    {
      using __utype = typename std::underlying_type<perms>::type;
      return static_cast<perms>(
@@ -179,7 +179,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
    }
  
    constexpr perms
-  operator^(perms __x, perms __y)
+  operator^(perms __x, perms __y) noexcept
    {
      using __utype = typename std::underlying_type<perms>::type;
      return static_cast<perms>(
@@ -187,22 +187,22 @@ _GLIBCXX_END_NAMESPACE_CXX11
    }
  
    constexpr perms
-  operator~(perms __x)
+  operator~(perms __x) noexcept
    {
      using __utype = typename std::underlying_type<perms>::type;
      return static_cast<perms>(~static_cast<__utype>(__x));
    }
  
    inline perms&
-  operator&=(perms& __x, perms __y)
+  operator&=(perms& __x, perms __y) noexcept
    { return __x = __x & __y; }
  
    inline perms&
-  operator|=(perms& __x, perms __y)
+  operator|=(perms& __x, perms __y) noexcept
    { return __x = __x | __y; }
  
    inline perms&
-  operator^=(perms& __x, perms __y)
+  operator^=(perms& __x, perms __y) noexcept
    { return __x = __x ^ __y; }
  
    // Bitmask type
@@ -211,7 +211,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
    };
  
    constexpr directory_options
-  operator&(directory_options __x, directory_options __y)
+  operator&(directory_options __x, directory_options __y) noexcept
    {
      using __utype = typename std::underlying_type<directory_options>::type;
      return static_cast<directory_options>(
@@ -219,7 +219,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
    }
  
    constexpr directory_options
-  operator|(directory_options __x, directory_options __y)
+  operator|(directory_options __x, directory_options __y) noexcept
    {
      using __utype = typename std::underlying_type<directory_options>::type;
      return static_cast<directory_options>(
@@ -227,7 +227,7 @@ _GLIBCXX_END_NAMESPACE_CXX11
    }
  
    constexpr directory_options
-  operator^(directory_options __x, directory_options __y)
+  operator^(directory_options __x, directory_options __y) noexcept
    {
      using __utype = typename std::underlying_type<directory_options>::type;
      return static_cast<directory_options>(
@@ -235,22 +235,22 @@ _GLIBCXX_END_NAMESPACE_CXX11
    }
  
    constexpr directory_options
-  operator~(directory_options __x)
+  operator~(directory_options __x) noexcept
    {
      using __utype = typename std::underlying_type<directory_options>::type;
      return static_cast<directory_options>(~static_cast<__utype>(__x));
    }
  
    inline directory_options&
-  operator&=(directory_options& __x, directory_options __y)
+  operator&=(directory_options& __x, directory_options __y) noexcept
    { return __x = __x & __y; }
  
    inline directory_options&
-  operator|=(directory_options& __x, directory_options __y)
+  operator|=(directory_options& __x, directory_options __y) noexcept
    { return __x = __x | __y; }
  
    inline directory_options&
-  operator^=(directory_options& __x, directory_options __y)
+  operator^=(directory_options& __x, directory_options __y) noexcept
    { return __x = __x ^ __y; }
  
    typedef chrono::time_point<chrono::system_clock> file_time_type;
diff --git a/libstdc++-v3/include/std/tuple b/libstdc++-v3/include/std/tuple

index 53f3184..7522e43 100644 (file)
--- a/libstdc++-v3/include/std/tuple
+++ b/libstdc++-v3/include/std/tuple
@@ -500,6 +500,14 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
                       __not_<is_constructible<_Elements..., _SrcTuple>>
                >::value;
      }
+    template<typename... _UElements>
+    static constexpr bool _NotSameTuple()
+    {
+      return  __not_<is_same<tuple<_Elements...>,
+                            typename remove_const<
+                              typename remove_reference<_UElements...>::type
+                              >::type>>::value;
+    }
    };
  
    template<typename... _Elements>
@@ -534,6 +542,11 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
      {
        return true;
      }
+    template<typename... _UElements>
+    static constexpr bool _NotSameTuple()
+    {
+      return  true;
+    }
    };
  
    /// Primary class template, tuple
@@ -611,7 +624,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
                        _Elements...>;
  
        template<typename... _UElements, typename
-        enable_if<_TMC<_UElements...>::template
+              enable_if<
+                 _TC<sizeof...(_UElements) == 1, _Elements...>::template
+                   _NotSameTuple<_UElements...>()
+                 && _TMC<_UElements...>::template
                      _MoveConstructibleTuple<_UElements...>()
                    && _TMC<_UElements...>::template
                      _ImplicitlyMoveConvertibleTuple<_UElements...>()
@@ -621,7 +637,10 @@ _GLIBCXX_BEGIN_NAMESPACE_VERSION
          : _Inherited(std::forward<_UElements>(__elements)...) { }
  
        template<typename... _UElements, typename
-        enable_if<_TMC<_UElements...>::template
+        enable_if<
+                 _TC<sizeof...(_UElements) == 1, _Elements...>::template
+                   _NotSameTuple<_UElements...>()
+                 && _TMC<_UElements...>::template
                      _MoveConstructibleTuple<_UElements...>()
                    && !_TMC<_UElements...>::template
                      _ImplicitlyMoveConvertibleTuple<_UElements...>()
diff --git a/libstdc++-v3/src/c++11/codecvt.cc b/libstdc++-v3/src/c++11/codecvt.cc

index 327beb6..b60691c 100644 (file)
--- a/libstdc++-v3/src/c++11/codecvt.cc
+++ b/libstdc++-v3/src/c++11/codecvt.cc
@@ -789,7 +789,11 @@ do_in(state_type&, const extern_type* __from, const extern_type* __from_end,
  {
    range<const char> from{ __from, __from_end };
    range<char16_t> to{ __to, __to_end };
-  auto res = ucs2_in(from, to, _M_maxcode, _M_mode);
+  codecvt_mode mode = codecvt_mode(_M_mode & (consume_header|generate_header));
+#if __BYTE_ORDER__ != __ORDER_BIG_ENDIAN__
+  mode = codecvt_mode(mode | little_endian);
+#endif
+  auto res = ucs2_in(from, to, _M_maxcode, mode);
    __from_next = from.next;
    __to_next = to.next;
    return res;
@@ -1264,7 +1268,7 @@ do_in(state_type&, const extern_type* __from, const extern_type* __from_end,
  {
    range<const char> from{ __from, __from_end };
    range<char16_t> to{ __to, __to_end };
-  codecvt_mode mode = codecvt_mode(_M_mode | (consume_header|generate_header));
+  codecvt_mode mode = codecvt_mode(_M_mode & (consume_header|generate_header));
  #if __BYTE_ORDER__ != __ORDER_BIG_ENDIAN__
    mode = codecvt_mode(mode | little_endian);
  #endif
diff --git a/libstdc++-v3/src/c++11/cow-stdexcept.cc b/libstdc++-v3/src/c++11/cow-stdexcept.cc

index a0f505c..31a89df 100644 (file)
--- a/libstdc++-v3/src/c++11/cow-stdexcept.cc
+++ b/libstdc++-v3/src/c++11/cow-stdexcept.cc
@@ -292,6 +292,7 @@ _txnal_cow_string_c_str(const void* that)
    return (const char*) txnal_read_ptr((void**)&bs->_M_dataplus._M_p);
  }
  
+#if _GLIBCXX_USE_DUAL_ABI
  const char*
  _txnal_sso_string_c_str(const void* that)
  {
@@ -299,6 +300,7 @@ _txnal_sso_string_c_str(const void* that)
        (void* const*)const_cast<char* const*>(
           &((const std::__sso_string*) that)->_M_s._M_p));
  }
+#endif
  
  void
  _txnal_cow_string_D1_commit(void* data)
@@ -344,9 +346,24 @@ _txnal_runtime_error_get_msg(void* e)
  // result in undefined behavior, which is in this case not initializing this
  // string.
  #if _GLIBCXX_USE_DUAL_ABI
-#define CTORDTORSTRINGCSTR(s) _txnal_sso_string_c_str((s))
+#define CTORS_FROM_SSOSTRING(NAME, CLASS, BASE)                        \
+void                                                                   \
+_ZGTtNSt##NAME##C1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE( \
+    CLASS* that, const std::__sso_string& s)                           \
+{                                                                      \
+  CLASS e("");                                                         \
+  _ITM_memcpyRnWt(that, &e, sizeof(CLASS));                            \
+  /* Get the C string from the SSO string.  */                         \
+  _txnal_cow_string_C1_for_exceptions(_txnal_##BASE##_get_msg(that),   \
+                                     _txnal_sso_string_c_str(&s), that); \
+}                                                                      \
+void                                                                   \
+_ZGTtNSt##NAME##C2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE( \
+    CLASS*, const std::__sso_string&) __attribute__((alias             \
+("_ZGTtNSt" #NAME                                                      \
+  "C1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE")));
  #else
-#define CTORDTORSTRINGCSTR(s) ""
+#define CTORS_FROM_SSOSTRING(NAME, CLASS, BASE)
  #endif
  
  // This macro defines transaction constructors and destructors for a specific
@@ -373,21 +390,7 @@ _ZGTtNSt##NAME##C1EPKc (CLASS* that, const char* s)                        \
  void                                                                   \
  _ZGTtNSt##NAME##C2EPKc (CLASS*, const char*)                           \
    __attribute__((alias ("_ZGTtNSt" #NAME "C1EPKc")));                  \
-void                                                                   \
-_ZGTtNSt##NAME##C1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE( \
-    CLASS* that, const std::__sso_string& s)                           \
-{                                                                      \
-  CLASS e("");                                                         \
-  _ITM_memcpyRnWt(that, &e, sizeof(CLASS));                            \
-  /* Get the C string from the SSO string.  */                         \
-  _txnal_cow_string_C1_for_exceptions(_txnal_##BASE##_get_msg(that),   \
-                                     CTORDTORSTRINGCSTR(&s), that);    \
-}                                                                      \
-void                                                                   \
-_ZGTtNSt##NAME##C2ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE( \
-    CLASS*, const std::__sso_string&) __attribute__((alias             \
-("_ZGTtNSt" #NAME                                                      \
-  "C1ERKNSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE")));      \
+CTORS_FROM_SSOSTRING(NAME, CLASS, BASE)                                        \
  void                                                                   \
  _ZGTtNSt##NAME##D1Ev(CLASS* that)                                      \
  { _txnal_cow_string_D1(_txnal_##BASE##_get_msg(that)); }               \
diff --git a/libstdc++-v3/src/filesystem/ops.cc b/libstdc++-v3/src/filesystem/ops.cc

index c32197e..5b82088 100644 (file)
--- a/libstdc++-v3/src/filesystem/ops.cc
+++ b/libstdc++-v3/src/filesystem/ops.cc
@@ -220,8 +220,9 @@ fs::canonical(const path& p, const path& base)
  {
    error_code ec;
    path can = canonical(p, base, ec);
-  if (ec.value())
-    _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot canonicalize", p, ec));
+  if (ec)
+    _GLIBCXX_THROW_OR_ABORT(filesystem_error("cannot canonicalize", p, base,
+                                            ec));
    return can;
  }
  
@@ -249,7 +250,7 @@ namespace
    typedef struct ::stat stat_type;
  
    inline fs::file_type
-  make_file_type(const stat_type& st)
+  make_file_type(const stat_type& st) noexcept
    {
      using fs::file_type;
  #ifdef _GLIBCXX_HAVE_S_ISREG
@@ -273,7 +274,7 @@ namespace
    }
  
    inline fs::file_status
-  make_file_status(const stat_type& st)
+  make_file_status(const stat_type& st) noexcept
    {
      return fs::file_status{
         make_file_type(st),
@@ -282,13 +283,13 @@ namespace
    }
  
    inline bool
-  is_not_found_errno(int err)
+  is_not_found_errno(int err) noexcept
    {
      return err == ENOENT || err == ENOTDIR;
    }
  
    inline fs::file_time_type
-  file_time(const stat_type& st)
+  file_time(const stat_type& st) noexcept
    {
      using namespace std::chrono;
      return fs::file_time_type{
@@ -300,6 +301,17 @@ namespace
      };
    }
  
+  // Returns true if the file descriptor was successfully closed,
+  // otherwise returns false and the reason will be in errno.
+  inline bool
+  close_fd(int fd)
+  {
+    while (::close(fd))
+      if (errno != EINTR)
+       return false;
+    return true;
+  }
+
    bool
    do_copy_file(const fs::path& from, const fs::path& to,
                fs::copy_options option,
@@ -376,7 +388,8 @@ namespace
        }
  
      struct CloseFD {
-      ~CloseFD() { if (fd != -1) ::close(fd); }
+      ~CloseFD() { if (fd != -1) close_fd(fd); }
+      bool close() { return close_fd(std::exchange(fd, -1)); }
        int fd;
      };
  
@@ -401,34 +414,49 @@ namespace
         return false;
        }
  
+#ifdef _GLIBCXX_USE_FCHMOD
+    if (::fchmod(out.fd, from_st->st_mode))
+#elif _GLIBCXX_USE_FCHMODAT
+    if (::fchmodat(AT_FDCWD, to.c_str(), from_st->st_mode, 0))
+#else
+    if (::chmod(to.c_str(), from_st->st_mode))
+#endif
+      {
+       ec.assign(errno, std::generic_category());
+       return false;
+      }
+
  #ifdef _GLIBCXX_USE_SENDFILE
-    auto n = ::sendfile(out.fd, in.fd, nullptr, from_st->st_size);
+    const auto n = ::sendfile(out.fd, in.fd, nullptr, from_st->st_size);
      if (n != from_st->st_size)
        {
         ec.assign(errno, std::generic_category());
         return false;
        }
+    if (!out.close() || !in.close())
+      {
+       ec.assign(errno, std::generic_category());
+       return false;
+      }
  #else
      __gnu_cxx::stdio_filebuf<char> sbin(in.fd, std::ios::in);
      __gnu_cxx::stdio_filebuf<char> sbout(out.fd, std::ios::out);
-    if ( !(std::ostream(&sbout) << &sbin) )
+    if (sbin.is_open())
+      in.fd = -1;
+    if (sbout.is_open())
+      out.fd = -1;
+    if (from_st->st_size && !(std::ostream(&sbout) << &sbin))
        {
         ec = std::make_error_code(std::errc::io_error);
         return false;
        }
-#endif
-
-#ifdef _GLIBCXX_USE_FCHMOD
-    if (::fchmod(out.fd, from_st->st_mode))
-#elif _GLIBCXX_USE_FCHMODAT
-    if (::fchmodat(AT_FDCWD, to.c_str(), from_st->st_mode, 0))
-#else
-    if (::chmod(to.c_str(), from_st->st_mode))
-#endif
+    if (!sbout.close() || !sbin.close())
        {
         ec.assign(errno, std::generic_category());
         return false;
        }
+#endif
+
      ec.clear();
      return true;
    }
@@ -439,13 +467,15 @@ void
  fs::copy(const path& from, const path& to, copy_options options,
          error_code& ec) noexcept
  {
-  bool skip_symlinks = is_set(options, copy_options::skip_symlinks);
-  bool create_symlinks = is_set(options, copy_options::create_symlinks);
-  bool use_lstat = create_symlinks || skip_symlinks;
+  const bool skip_symlinks = is_set(options, copy_options::skip_symlinks);
+  const bool create_symlinks = is_set(options, copy_options::create_symlinks);
+  const bool copy_symlinks = is_set(options, copy_options::copy_symlinks);
+  const bool use_lstat = create_symlinks || skip_symlinks;
  
    file_status f, t;
    stat_type from_st, to_st;
-  if (use_lstat
+  // N4099 doesn't check copy_symlinks here, but I think that's a defect.
+  if (use_lstat || copy_symlinks
        ? ::lstat(from.c_str(), &from_st)
        : ::stat(from.c_str(), &from_st))
      {
@@ -488,7 +518,7 @@ fs::copy(const path& from, const path& to, copy_options options,
      {
        if (skip_symlinks)
         ec.clear();
-      else if (!exists(t) && is_set(options, copy_options::copy_symlinks))
+      else if (!exists(t) && copy_symlinks)
         copy_symlink(from, to, ec);
        else
         // Not clear what should be done here.
@@ -630,22 +660,26 @@ namespace
    bool
    create_dir(const fs::path& p, fs::perms perm, std::error_code& ec)
    {
+    bool created = false;
  #ifdef _GLIBCXX_HAVE_SYS_STAT_H
      ::mode_t mode = static_cast<std::underlying_type_t<fs::perms>>(perm);
      if (::mkdir(p.c_str(), mode))
        {
-       ec.assign(errno, std::generic_category());
-       return false;
+       const int err = errno;
+       if (err != EEXIST || !is_directory(p))
+         ec.assign(err, std::generic_category());
+       else
+         ec.clear();
        }
      else
        {
         ec.clear();
-       return true;
+       created = true;
        }
  #else
      ec = std::make_error_code(std::errc::not_supported);
-    return false;
  #endif
+    return created;
    }
  } // namespace
  
diff --git a/libstdc++-v3/testsuite/20_util/tuple/cons/element_accepts_anything_byval.cc b/libstdc++-v3/testsuite/20_util/tuple/cons/element_accepts_anything_byval.cc

new file mode 100644 (file)

index 0000000..fe9bea6
--- /dev/null
+++ b/libstdc++-v3/testsuite/20_util/tuple/cons/element_accepts_anything_byval.cc
@@ -0,0 +1,30 @@
+// Copyright (C) 2016 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+#include <tuple>
+using namespace std;
+
+struct Something {
+    Something() { }
+    template <typename T> Something(T) { }
+};
+
+int main() {
+    tuple<Something> t1;
+    tuple<Something> t2 = t1;
+}
+
diff --git a/libstdc++-v3/testsuite/22_locale/codecvt/codecvt_utf8/69703.cc b/libstdc++-v3/testsuite/22_locale/codecvt/codecvt_utf8/69703.cc

new file mode 100644 (file)

index 0000000..745d2c2
--- /dev/null
+++ b/libstdc++-v3/testsuite/22_locale/codecvt/codecvt_utf8/69703.cc
@@ -0,0 +1,103 @@
+// Copyright (C) 2016 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++11" }
+
+#include <codecvt>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  const char out[] = "abc";
+  char16_t in[4];
+  std::codecvt_utf8<char16_t> cvt;
+  std::mbstate_t st;
+  const char* no;
+  char16_t* ni;
+  auto res = cvt.in(st, out, out+3, no, in, in+3, ni);
+  VERIFY( res == std::codecvt_base::ok );
+  VERIFY( in[0] == u'a' );
+  VERIFY( in[1] == u'b' );
+  VERIFY( in[2] == u'c' );
+}
+
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  const char out[] = "abc";
+  char16_t in[4];
+  std::codecvt_utf8<char16_t, 0x10ffff, std::little_endian> cvt;
+  std::mbstate_t st;
+  const char* no;
+  char16_t* ni;
+  auto res = cvt.in(st, out, out+3, no, in, in+3, ni);
+  VERIFY( res == std::codecvt_base::ok );
+  VERIFY( in[0] == u'a' );
+  VERIFY( in[1] == u'b' );
+  VERIFY( in[2] == u'c' );
+}
+
+void
+test03()
+{
+  bool test __attribute__((unused)) = true;
+
+  const char out[] = "abc";
+  char32_t in[4];
+  std::codecvt_utf8<char32_t> cvt;
+  std::mbstate_t st;
+  const char* no;
+  char32_t* ni;
+  auto res = cvt.in(st, out, out+3, no, in, in+3, ni);
+  VERIFY( res == std::codecvt_base::ok );
+  VERIFY( in[0] == U'a' );
+  VERIFY( in[1] == U'b' );
+  VERIFY( in[2] == U'c' );
+}
+
+
+void
+test04()
+{
+  bool test __attribute__((unused)) = true;
+
+  const char out[] = "abc";
+  char32_t in[4];
+  std::codecvt_utf8<char32_t, 0x10ffff, std::little_endian> cvt;
+  std::mbstate_t st;
+  const char* no;
+  char32_t* ni;
+  auto res = cvt.in(st, out, out+3, no, in, in+3, ni);
+  VERIFY( res == std::codecvt_base::ok );
+  VERIFY( in[0] == U'a' );
+  VERIFY( in[1] == U'b' );
+  VERIFY( in[2] == U'c' );
+}
+
+int
+main()
+{
+  test01();
+  test02();
+  test01();
+  test02();
+}
diff --git a/libstdc++-v3/testsuite/22_locale/codecvt/codecvt_utf8_utf16/66855.cc b/libstdc++-v3/testsuite/22_locale/codecvt/codecvt_utf8_utf16/66855.cc

index 05e5bc6..49b750f 100644 (file)
--- a/libstdc++-v3/testsuite/22_locale/codecvt/codecvt_utf8_utf16/66855.cc
+++ b/libstdc++-v3/testsuite/22_locale/codecvt/codecvt_utf8_utf16/66855.cc
@@ -45,8 +45,35 @@ test01()
    VERIFY( buf[3] == utf16[3] );
  }
  
+void
+test02()
+{
+  // Endianness flag should make no difference.
+  std::codecvt_utf8_utf16<char16_t, 0x10ffff, std::little_endian> cvt;
+  char16_t utf16[] = u"\ub098\ub294\ud0dc\uc624";
+  const char16_t* nf16;
+  char utf8[16];
+  char* nt8;
+  std::mbstate_t st{};
+  auto res = cvt.out(st, utf16, utf16+4, nf16, utf8, utf8+16, nt8);
+  VERIFY( res == std::codecvt_base::ok );
+
+  st = {};
+  char16_t buf[4] = {};
+  const char* nf8 = nt8;
+  char16_t* nt16;
+  res = cvt.in(st, utf8, nf8, nf8, buf, buf+4, nt16);
+  VERIFY( res == std::codecvt_base::ok );
+  VERIFY( nt16 == buf+4 );
+  VERIFY( buf[0] == utf16[0] );
+  VERIFY( buf[1] == utf16[1] );
+  VERIFY( buf[2] == utf16[2] );
+  VERIFY( buf[3] == utf16[3] );
+}
+
  int
  main()
  {
    test01();
+  test02();
  }
diff --git a/libstdc++-v3/testsuite/experimental/filesystem/iterators/directory_iterator.cc b/libstdc++-v3/testsuite/experimental/filesystem/iterators/directory_iterator.cc

index 28b948f..ffd97ce 100644 (file)
--- a/libstdc++-v3/testsuite/experimental/filesystem/iterators/directory_iterator.cc
+++ b/libstdc++-v3/testsuite/experimental/filesystem/iterators/directory_iterator.cc
@@ -70,8 +70,79 @@ test01()
    remove_all(p, ec);
  }
  
+void
+test02()
+{
+  bool test __attribute__((unused)) = false;
+
+  std::error_code ec;
+  const auto p = __gnu_test::nonexistent_path();
+  create_directory(p, fs::current_path(), ec);
+  create_directory_symlink(p, p / "l", ec);
+  VERIFY( !ec );
+
+  // Test post-increment (libstdc++/71005)
+  auto iter = fs::directory_iterator(p, ec);
+  VERIFY( !ec );
+  VERIFY( iter != fs::directory_iterator() );
+  const auto entry1 = *iter;
+  const auto entry2 = *iter++;
+  VERIFY( entry1 == entry2 );
+  VERIFY( entry1.path() == p/"l" );
+  VERIFY( iter == fs::directory_iterator() );
+
+  remove_all(p, ec);
+}
+
+void
+test03()
+{
+  bool test __attribute__((unused)) = false;
+
+  std::error_code ec;
+  const auto p = __gnu_test::nonexistent_path();
+  create_directories(p / "longer_than_small_string_buffer", ec);
+  VERIFY( !ec );
+
+  // Test for no reallocation on each dereference (this is a GNU extension)
+  auto iter = fs::directory_iterator(p, ec);
+  const auto* s1 = iter->path().c_str();
+  const auto* s2 = iter->path().c_str();
+  VERIFY( s1 == s2 );
+
+  remove_all(p, ec);
+}
+
+void
+test04()
+{
+  bool test __attribute__((unused)) = false;
+
+  const fs::directory_iterator it;
+  VERIFY( it == fs::directory_iterator() );
+}
+
+void
+test05()
+{
+  bool test __attribute__((unused)) = false;
+
+  auto p = __gnu_test::nonexistent_path();
+  create_directory(p);
+  create_directory_symlink(p, p / "l");
+  fs::directory_iterator it(p), endit;
+  VERIFY( begin(it) == it );
+  static_assert( noexcept(begin(it)), "begin is noexcept" );
+  VERIFY( end(it) == endit );
+  static_assert( noexcept(end(it)), "end is noexcept" );
+}
+
  int
  main()
  {
    test01();
+  test02();
+  test03();
+  test04();
+  test05();
  }
diff --git a/libstdc++-v3/testsuite/experimental/filesystem/iterators/recursive_directory_iterator.cc b/libstdc++-v3/testsuite/experimental/filesystem/iterators/recursive_directory_iterator.cc

index 5d2e45b..b44ff3f 100644 (file)
--- a/libstdc++-v3/testsuite/experimental/filesystem/iterators/recursive_directory_iterator.cc
+++ b/libstdc++-v3/testsuite/experimental/filesystem/iterators/recursive_directory_iterator.cc
@@ -97,8 +97,83 @@ test01()
    remove_all(p, ec);
  }
  
+void
+test02()
+{
+  bool test __attribute__((unused)) = false;
+
+  std::error_code ec;
+  const auto p = __gnu_test::nonexistent_path();
+  create_directories(p / "d1/d2", ec);
+  VERIFY( !ec );
+
+  // Test post-increment (libstdc++/71005)
+  auto iter = fs::recursive_directory_iterator(p, ec);
+  VERIFY( !ec );
+  VERIFY( iter != fs::recursive_directory_iterator() );
+  const auto entry1 = *iter;
+  const auto entry2 = *iter++;
+  VERIFY( entry1 == entry2 );
+  VERIFY( entry1.path() == p/"d1" );
+  const auto entry3 = *iter;
+  const auto entry4 = *iter++;
+  VERIFY( entry3 == entry4 );
+  VERIFY( entry3.path() == p/"d1/d2" );
+  VERIFY( iter == fs::recursive_directory_iterator() );
+
+  remove_all(p, ec);
+}
+
+void
+test03()
+{
+  bool test __attribute__((unused)) = false;
+
+  std::error_code ec;
+  const auto p = __gnu_test::nonexistent_path();
+  create_directories(p / "longer_than_small_string_buffer", ec);
+  VERIFY( !ec );
+
+  // Test for no reallocation on each dereference (this is a GNU extension)
+  auto iter = fs::recursive_directory_iterator(p, ec);
+  const auto* s1 = iter->path().c_str();
+  const auto* s2 = iter->path().c_str();
+  VERIFY( s1 == s2 );
+
+  remove_all(p, ec);
+}
+
+void
+test04()
+{
+  bool test __attribute__((unused)) = false;
+
+  // libstdc++/71004
+  const fs::recursive_directory_iterator it;
+  VERIFY( it == fs::recursive_directory_iterator() );
+}
+
+void
+test05()
+{
+  bool test __attribute__((unused)) = false;
+
+  auto p = __gnu_test::nonexistent_path();
+  create_directory(p);
+  create_directory_symlink(p, p / "l");
+  fs::recursive_directory_iterator it(p), endit;
+  VERIFY( begin(it) == it );
+  static_assert( noexcept(begin(it)), "begin is noexcept" );
+  VERIFY( end(it) == endit );
+  static_assert( noexcept(end(it)), "end is noexcept" );
+}
+
  int
  main()
  {
    test01();
+  test02();
+  test03();
+  test04();
+  test05();
  }
diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/canonical.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/canonical.cc

index e13c4bf..5b4c573 100644 (file)
--- a/libstdc++-v3/testsuite/experimental/filesystem/operations/canonical.cc
+++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/canonical.cc
@@ -59,8 +59,28 @@ test01()
    VERIFY( !ec );
  }
  
+void
+test02()
+{
+#if __cpp_exceptions
+  bool test __attribute__((unused)) = false;
+
+  fs::path p = "rel", base = __gnu_test::nonexistent_path();
+  fs::path e1, e2;
+  try {
+    canonical(p, base);
+  } catch (const fs::filesystem_error& e) {
+    e1 = e.path1();
+    e2 = e.path2();
+  }
+  VERIFY( e1 == p );
+  VERIFY( e2 == base );
+#endif
+}
+
  int
  main()
  {
    test01();
+  test02();
  }
diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/copy.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/copy.cc

index 9e89002..a5f6a3e 100644 (file)
--- a/libstdc++-v3/testsuite/experimental/filesystem/operations/copy.cc
+++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/copy.cc
@@ -21,34 +21,127 @@
  // 15.3 Copy [fs.op.copy]
  
  #include <experimental/filesystem>
+#include <fstream>
  #include <testsuite_fs.h>
  #include <testsuite_hooks.h>
  
-using std::experimental::filesystem::path;
+namespace fs = std::experimental::filesystem;
  
+// Test error conditions.
  void
  test01()
  {
    bool test __attribute__((unused)) = false;
  
-  for (const path& p : __gnu_test::test_paths)
-    VERIFY( absolute(p).is_absolute() );
+  auto p = __gnu_test::nonexistent_path();
+  std::error_code ec;
+
+  VERIFY( !fs::exists(p) );
+  fs::copy(p, ".", fs::copy_options::none, ec);
+  VERIFY( ec );
+
+  ec.clear();
+  fs::copy(".", ".", fs::copy_options::none, ec);
+  VERIFY( ec );
+
+  std::ofstream{p.native()};
+  VERIFY( fs::is_directory(".") );
+  VERIFY( fs::is_regular_file(p) );
+  ec.clear();
+  fs::copy(".", p, fs::copy_options::none, ec);
+  VERIFY( ec );
+
+  remove(p, ec);
  }
  
+// Test is_symlink(f) case.
  void
  test02()
  {
    bool test __attribute__((unused)) = false;
  
-  path p1("/");
-  VERIFY( absolute(p1) == p1 );
-  VERIFY( absolute(p1, "/bar") == p1 );
-  path p2("/foo");
-  VERIFY( absolute(p2) == p2 );
-  VERIFY( absolute(p2, "/bar") == p2 );
-  path p3("foo");
-  VERIFY( absolute(p3) != p3 );
-  VERIFY( absolute(p3, "/bar") == "/bar/foo" );
+  auto from = __gnu_test::nonexistent_path();
+  auto to = __gnu_test::nonexistent_path();
+  std::error_code ec;
+
+  fs::create_symlink(".", from, ec);
+  VERIFY( !ec );
+  VERIFY( fs::exists(from) );
+
+  fs::copy(from, to, fs::copy_options::skip_symlinks, ec);
+  VERIFY( !ec );
+  VERIFY( !fs::exists(to) );
+
+  fs::copy(from, to, fs::copy_options::skip_symlinks, ec);
+  VERIFY( !ec );
+  VERIFY( !fs::exists(to) );
+
+  fs::copy(from, to,
+           fs::copy_options::skip_symlinks|fs::copy_options::copy_symlinks,
+           ec);
+  VERIFY( !ec );
+  VERIFY( !fs::exists(to) );
+
+  fs::copy(from, to, fs::copy_options::copy_symlinks, ec);
+  VERIFY( !ec );
+  VERIFY( fs::exists(to) );
+
+  fs::copy(from, to, fs::copy_options::copy_symlinks, ec);
+  VERIFY( ec );
+
+  remove(from, ec);
+  remove(to, ec);
+}
+
+// Test is_regular_file(f) case.
+void
+test03()
+{
+  bool test __attribute__((unused)) = false;
+
+  auto from = __gnu_test::nonexistent_path();
+  auto to = __gnu_test::nonexistent_path();
+
+  // test empty file
+  std::ofstream{from.native()};
+  VERIFY( fs::exists(from) );
+  VERIFY( fs::file_size(from) == 0 );
+  fs::copy(from, to);
+  VERIFY( fs::exists(to) );
+  VERIFY( fs::file_size(to) == 0 );
+
+  remove(to);
+  VERIFY( !fs::exists(to) );
+  std::ofstream{from.native()} << "Hello, filesystem!";
+  VERIFY( fs::file_size(from) != 0 );
+  fs::copy(from, to);
+  VERIFY( fs::exists(to) );
+  VERIFY( fs::file_size(to) == fs::file_size(from) );
+}
+
+// Test is_directory(f) case.
+void
+test04()
+{
+  bool test __attribute__((unused)) = false;
+
+  auto from = __gnu_test::nonexistent_path();
+  auto to = __gnu_test::nonexistent_path();
+  std::error_code ec;
+
+}
+
+// Test no-op cases.
+void
+test05()
+{
+  bool test __attribute__((unused)) = false;
+
+  auto to = __gnu_test::nonexistent_path();
+  std::error_code ec;
+
+  fs::copy("/", to, fs::copy_options::create_symlinks, ec);
+  VERIFY( !ec );
  }
  
  int
@@ -56,4 +149,7 @@ main()
  {
    test01();
    test02();
+  test03();
+  test04();
+  test05();
  }
diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/copy_file.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/copy_file.cc

new file mode 100644 (file)

index 0000000..cdb7911
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/copy_file.cc
@@ -0,0 +1,82 @@
+// Copyright (C) 2016 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++11 -lstdc++fs" }
+// { dg-require-filesystem-ts "" }
+
+// 15.4 Copy [fs.op.copy_file]
+
+#include <experimental/filesystem>
+#include <fstream>
+#include <testsuite_fs.h>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+  bool test __attribute__((unused)) = false;
+  using std::experimental::filesystem::copy_options;
+  std::error_code ec;
+
+  auto from = __gnu_test::nonexistent_path();
+  auto to = __gnu_test::nonexistent_path();
+
+  // test non-existent file
+  bool b = copy_file(from, to, ec);
+  VERIFY( !b );
+  VERIFY( ec );
+  VERIFY( !exists(to) );
+
+  // test empty file
+  std::ofstream{from.native()};
+  VERIFY( exists(from) );
+  VERIFY( file_size(from) == 0 );
+
+  b = copy_file(from, to);
+  VERIFY( b );
+  VERIFY( exists(to) );
+  VERIFY( file_size(to) == 0 );
+  remove(to);
+  VERIFY( !exists(to) );
+  b = copy_file(from, to, copy_options::none, ec);
+  VERIFY( b );
+  VERIFY( !ec );
+  VERIFY( exists(to) );
+  VERIFY( file_size(to) == 0 );
+
+  std::ofstream{from.native()} << "Hello, filesystem!";
+  VERIFY( file_size(from) != 0 );
+  remove(to);
+  VERIFY( !exists(to) );
+  b = copy_file(from, to);
+  VERIFY( b );
+  VERIFY( exists(to) );
+  VERIFY( file_size(to) == file_size(from) );
+  remove(to);
+  VERIFY( !exists(to) );
+  b = copy_file(from, to);
+  VERIFY( b );
+  VERIFY( !ec );
+  VERIFY( exists(to) );
+  VERIFY( file_size(to) == file_size(from) );
+}
+
+int
+main()
+{
+  test01();
+}
diff --git a/libstdc++-v3/testsuite/experimental/filesystem/operations/create_directory.cc b/libstdc++-v3/testsuite/experimental/filesystem/operations/create_directory.cc

new file mode 100644 (file)

index 0000000..66c2b3f
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/filesystem/operations/create_directory.cc
@@ -0,0 +1,63 @@
+// Copyright (C) 2016 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++11 -lstdc++fs" }
+// { dg-require-filesystem-ts "" }
+
+#include <experimental/filesystem>
+#include <testsuite_hooks.h>
+#include <testsuite_fs.h>
+
+namespace fs = std::experimental::filesystem;
+
+void
+test01()
+{
+  bool test __attribute__((unused)) = false;
+  std::error_code ec;
+
+  // Test empty path.
+  fs::path p;
+  bool b = create_directory( p, ec );
+  VERIFY( ec );
+  VERIFY( !b );
+
+  // Test non-existent path
+  p = __gnu_test::nonexistent_path();
+  VERIFY( !exists(p) );
+
+  b = create_directory(p, ec); // create the directory once
+  VERIFY( !ec );
+  VERIFY( b );
+  VERIFY( exists(p) );
+
+  // Test existing path (libstdc++/71036).
+  b = create_directory(p, ec);
+  VERIFY( !ec );
+  VERIFY( !b );
+  b = create_directory(p);
+  VERIFY( !ec );
+  VERIFY( !b );
+
+  remove_all(p, ec);
+}
+
+int
+main()
+{
+  test01();
+}
diff --git a/libstdc++-v3/testsuite/experimental/filesystem/path/native/string.cc b/libstdc++-v3/testsuite/experimental/filesystem/path/native/string.cc

new file mode 100644 (file)

index 0000000..e56fda7
--- /dev/null
+++ b/libstdc++-v3/testsuite/experimental/filesystem/path/native/string.cc
@@ -0,0 +1,73 @@
+// Copyright (C) 2016 Free Software Foundation, Inc.
+//
+// This file is part of the GNU ISO C++ Library.  This library is free
+// software; you can redistribute it and/or modify it under the
+// terms of the GNU General Public License as published by the
+// Free Software Foundation; either version 3, or (at your option)
+// any later version.
+
+// This library is distributed in the hope that it will be useful,
+// but WITHOUT ANY WARRANTY; without even the implied warranty of
+// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+// GNU General Public License for more details.
+
+// You should have received a copy of the GNU General Public License along
+// with this library; see the file COPYING3.  If not see
+// <http://www.gnu.org/licenses/>.
+
+// { dg-options "-std=gnu++11 -lstdc++fs" }
+// { dg-require-filesystem-ts "" }
+
+#include <experimental/filesystem>
+#include <string>
+#include <testsuite_hooks.h>
+
+void
+test01()
+{
+  bool test __attribute__((unused)) = true;
+
+  using namespace std::experimental::filesystem;
+  const std::string s = "abc";
+  path p(s);
+
+  VERIFY( p.native() == s );
+  VERIFY( p.c_str() == s );
+  VERIFY( static_cast<std::string>(p) == s );
+
+  std::string s2 = p; // implicit conversion
+  VERIFY( s2 == p.native() );
+}
+
+void
+test02()
+{
+  bool test __attribute__((unused)) = true;
+
+  using namespace std::experimental::filesystem;
+  const char* s = "abc";
+  path p(s);
+
+  auto str = p.string<char>();
+  VERIFY( str == u"abc" );
+  VERIFY( str == p.string() );
+
+  auto strw = p.string<wchar_t>();
+  VERIFY( strw == L"abc" );
+  VERIFY( strw == p.wstring() );
+
+  auto str16 = p.string<char16_t>();
+  VERIFY( str16 == u"abc" );
+  VERIFY( str16 == p.u16string() );
+
+  auto str32 = p.string<char32_t>();
+  VERIFY( str32 == U"abc" );
+  VERIFY( str32 == p.u32string() );
+}
+
+int
+main()
+{
+  test01();
+  test02();
+}
diff --git a/libstdc++-v3/testsuite/util/testsuite_fs.h b/libstdc++-v3/testsuite/util/testsuite_fs.h

index d2b3b18..f1e0bfc 100644 (file)
--- a/libstdc++-v3/testsuite/util/testsuite_fs.h
+++ b/libstdc++-v3/testsuite/util/testsuite_fs.h
@@ -83,11 +83,13 @@ namespace __gnu_test
      p = tmp;
  #else
      char buf[64];
+    static int counter;
  #if _GLIBCXX_USE_C99_STDIO
-    std::snprintf(buf, 64, "filesystem-ts-test.%lu", (unsigned long)::getpid());
+    std::snprintf(buf, 64,
  #else
-    std::sprintf(buf, "filesystem-ts-test.%lu", (unsigned long)::getpid());
+    std::sprintf(buf,
  #endif
+      "filesystem-ts-test.%d.%lu", counter++, (unsigned long) ::getpid());
      p = buf;
  #endif
      return p;
diff --git a/maintainer-scripts/ChangeLog b/maintainer-scripts/ChangeLog

index 1014033..485a48c 100644 (file)
--- a/maintainer-scripts/ChangeLog
+++ b/maintainer-scripts/ChangeLog
@@ -1,3 +1,8 @@
+2016-06-13  Jonathan Wakely  <jwakely@redhat.com>
+
+       * generate_libstdcxx_web_docs: Use realpath to get absolute path.
+       Add comment about LaTeX errors.
+
  2016-04-27  Release Manager
  
         * GCC 6.1.0 released.
diff --git a/maintainer-scripts/generate_libstdcxx_web_docs b/maintainer-scripts/generate_libstdcxx_web_docs

index 700e522..00ebcbf 100755 (executable)
--- a/maintainer-scripts/generate_libstdcxx_web_docs
+++ b/maintainer-scripts/generate_libstdcxx_web_docs
@@ -3,7 +3,7 @@
  # i.e. http://gcc.gnu.org/onlinedocs/gcc-x.y.z/libstdc++*
  
  SRCDIR=${1}
-DOCSDIR=${2}
+DOCSDIR=$(realpath ${2})
  
  if ! [ $# -eq 2 -a -x "${SRCDIR}/configure" -a -d "${DOCSDIR}" ]
  then
@@ -34,6 +34,9 @@ set -x
  ${SRCDIR}/configure --enable-languages=c,c++ --disable-gcc $disabled_libs --docdir=/docs
  eval `grep '^target=' config.log`
  make configure-target
+# If the following step fails with an error like
+# ! LaTeX Error: File `xtab.sty' not found.
+# then you need to install the relevant TeX package e.g. texlive-xtab
  make -C $target/libstdc++-v3 doc-install-html doc-install-xml doc-install-pdf DESTDIR=$DESTDIR
  cd $DESTDIR/docs
  mkdir libstdc++
author	Yvan Roux <yvan.roux@linaro.org>
	Wed, 15 Jun 2016 08:42:05 +0000 (10:42 +0200)
committer	Yvan Roux <yvan.roux@linaro.org>
	Wed, 15 Jun 2016 08:42:05 +0000 (10:42 +0200)