diff options
| author | bstarynk <bstarynk@138bc75d-0d04-0410-961f-82ee72b054a4> | 2013-07-12 08:41:26 +0000 |
|---|---|---|
| committer | bstarynk <bstarynk@138bc75d-0d04-0410-961f-82ee72b054a4> | 2013-07-12 08:41:26 +0000 |
| commit | 7173826daf929b5d925bbb183f1d1e0c4f2e7be8 (patch) | |
| tree | d5fa37d59785f9f27547b58ef19a4983866c4ff8 /gcc | |
| parent | 5ea851c7f59adf0fde5892c34d5059da38ea7dee (diff) | |
| download | gcc-7173826daf929b5d925bbb183f1d1e0c4f2e7be8.tar.gz | |
2013-07-12 Basile Starynkevitch <basile@starynkevitch.net>
MELT branch merged with trunk rev 200918 using svnmerge.py
git-svn-id: svn+ssh://gcc.gnu.org/svn/gcc/branches/melt-branch@200920 138bc75d-0d04-0410-961f-82ee72b054a4
Diffstat (limited to 'gcc')
213 files changed, 15536 insertions, 10736 deletions
diff --git a/gcc/ChangeLog b/gcc/ChangeLog index 23c3cdeb172..1d8c05a4807 100644 --- a/gcc/ChangeLog +++ b/gcc/ChangeLog @@ -1,3 +1,290 @@ +2013-07-11 Steve Ellcey <sellcey@mips.com> + + * config/mips/mips.c (mips_conditional_register_usage): Do not + use t[0-7] registers in MIPS16 mode when optimizing for size. + +2013-07-11 Sriraman Tallam <tmsriram@google.com> + + * config/i386/i386.c (dispatch_function_versions): Fix array + indexing of function_version_info to match actual_versions. + +2013-07-11 Teresa Johnson <tejohnson@google.com> + + * vec.h (struct va_gc): Move release out-of-line. + (va_gc::release): Call ggc_free on released vec. + +2013-07-11 Ulrich Weigand <Ulrich.Weigand@de.ibm.com> + + * config/rs6000/rs6000.md (""*tls_gd_low<TLSmode:tls_abi_suffix>"): + Require GOT register as additional operand in UNSPEC. + ("*tls_ld_low<TLSmode:tls_abi_suffix>"): Likewise. + ("*tls_got_dtprel_low<TLSmode:tls_abi_suffix>"): Likewise. + ("*tls_got_tprel_low<TLSmode:tls_abi_suffix>"): Likewise. + ("*tls_gd<TLSmode:tls_abi_suffix>"): Update splitter. + ("*tls_ld<TLSmode:tls_abi_suffix>"): Likewise. + ("tls_got_dtprel_<TLSmode:tls_abi_suffix>"): Likewise. + ("tls_got_tprel_<TLSmode:tls_abi_suffix>"): Likewise. + +2013-07-11 Georg-Johann Lay <avr@gjlay.de> + + PR target/57631 + * config/avr/avr.c (avr_set_current_function): Sanity-check signal + name seen by assembler/linker rather if available. + +2013-07-11 Andreas Schwab <schwab@suse.de> + + * config/aarch64/aarch64-linux.h (CPP_SPEC): Define. + +2013-07-10 Vladimir Makarov <vmakarov@redhat.com> + + * lra-constraints.c (curr_insn_transform): Switch off optional + reloads. + +2013-07-10 Joseph Myers <joseph@codesourcery.com> + + * doc/tm.texi.in: Move hook documentation to .... + * target.def: ... here. + + * doc/tm.texi.in (TARGET_CANONICALIZE_COMPARISON): Remove stray + text on @hook line. + * doc/tm.texi: Regenerate. + +2013-07-10 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/57869 + * doc/invoke.texi: Document -Wconditionally-supported. + +2013-07-10 Georg-Johann Lay <avr@gjlay.de> + + PR target/57844 + * config/avr/avr.c (avr_prologue_setup_frame): Trunk -size to mode + of my_fp. + +2013-07-10 Georg-Johann Lay <avr@gjlay.de> + + PR target/57506 + * config/avr/avr-mcus.def (atmega16hva, atmega16hva2, atmega16hvb) + (atmega16m1, atmega16u4, atmega32a, atmega32c1, atmega32hvb) + (atmega32m1, atmega32u4, atmega32u6, atmega64c1, atmega64m1): + Remove duplicate devices. + * config/avr/gen-avr-mmcu-texi.c (print_mcus): Fail on duplicate MCUs. + * config/avr/t-multilib: Regenerate. + * config/avr/avr-tables.opt: Regenerate. + * doc/avr-mmcu.texi: Regenerate. + +2013-07-10 Georg-Johann Lay <avr@gjlay.de> + + PR target/56987 + * config/avr/avr.opt (Waddr-space-convert): Fix typo. + +2013-07-10 Graham Stott <graham.stott@btinternet.com> + + * config/mips/mips.c (mips_rtx_costs): Very slightly increase + the cost of MULT when optimizing for size. + +2013-07-10 Jan-Benedict Glaw <jbglaw@lug-owl.de> + + * config/cr16/cr16-protos.h: Don't include target.h. + +2013-07-09 Joseph Myers <joseph@codesourcery.com> + + * config/rs6000/rs6000.c (rs6000_init_hard_regno_mode_ok): Only + adjust register size for TDmode and TFmode for VSX registers. + +2013-07-08 Kai Tietz <ktietz@redhat.com> + + PR target/56892 + * config/i386/i386.c (TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P): Define as + hook_bool_const_tree_true. + +2013-07-08 Andreas Krebbel <Andreas.Krebbel@de.ibm.com> + + * config/s390/s390.c: Replace F*_REGNUM with FPR*_REGNUM. + * config/s390/s390.h: Remove F*_REGNUM macro definitions. + * config/s390/s390.md: Define FPR*_REGNUM constants. + Fix FPR2_REGNUM constant (18 -> 17). + ("*trunc<BFP:mode><DFP_ALL:mode>2") + ("*trunc<DFP_ALL:mode><BFP:mode>2") + ("trunc<BFP:mode><DFP_ALL:mode>2") + ("trunc<DFP_ALL:mode><BFP:mode>2") + ("*extend<BFP:mode><DFP_ALL:mode>2") + ("*extend<DFP_ALL:mode><BFP:mode>2") + ("extend<BFP:mode><DFP_ALL:mode>2") + ("extend<DFP_ALL:mode><BFP:mode>2"): Replace FPR2_REGNUM with + FPR4_REGNUM. + +2013-07-08 Graham Stott <graham.stott@btinternet.com> + + * Makefile.in: (c-family-warn): Define to $(STRICT_WARN) + +2013-07-08 Andreas Krebbel <Andreas.Krebbel@de.ibm.com> + + * config/s390/s390.c: Rename cfun_set_fpr_bit to cfun_set_fpr_save + and cfun_fpr_bit_p to cfun_fpr_save_p. + (s390_frame_area, s390_register_info, s390_frame_info) + (s390_emit_prologue, s390_emit_epilogue) + (s390_conditional_register_usage): Use the *_REGNUM macros for FPR + register numbers. + * config/s390/s390.h: Define *_REGNUM macros for floating point + register numbers. + +2013-07-08 Eric Botcazou <ebotcazou@adacore.com> + + * Makefile.in (tree-ssa-reassoc.o): Add dependency on $(PARAMS_H). + +2013-07-08 Po-Chun Chang <pchang9@cs.wisc.edu> + + PR rtl-optimization/57786 + * combine.c (distribute_notes) <case REG_DEAD>: Change all_used to bool + and break out of the loop when it is set to false. + +2013-07-08 Jakub Jelinek <jakub@redhat.com> + + PR target/57819 + * simplify-rtx.c (simplify_unary_operation_1) <case ZERO_EXTEND>: + Simplify (zero_extend:SI (subreg:QI (and:SI (reg:SI) + (const_int 63)) 0)). + * combine.c (make_extraction): Create ZERO_EXTEND or SIGN_EXTEND + using simplify_gen_unary instead of gen_rtx_*_EXTEND. + * config/i386/i386.md (*jcc_bt<mode>_1): New define_insn_and_split. + + PR rtl-optimization/57829 + * simplify-rtx.c (simplify_binary_operation_1) <case IOR>: Ensure that + mask bits outside of mode are just sign-extension from mode to HWI. + +2013-07-08 Michael Zolotukhin <michael.v.zolotukhin@gmail.com> + + * config/i386/i386-opts.h (enum stringop_alg): Add vector_loop. + * config/i386/i386.c (expand_set_or_movmem_via_loop): Use + adjust_address instead of change_address to keep info about alignment. + (emit_strmov): Remove. + (emit_memmov): New function. + (expand_movmem_epilogue): Refactor to properly handle bigger sizes. + (expand_movmem_epilogue): Likewise and return updated rtx for + destination. + (expand_constant_movmem_prologue): Likewise and return updated rtx for + destination and source. + (decide_alignment): Refactor, handle vector_loop. + (ix86_expand_movmem): Likewise. + (ix86_expand_setmem): Likewise. + * config/i386/i386.opt (Enum): Add vector_loop to option stringop_alg. + +2013-07-07 Uros Bizjak <ubizjak@gmail.com> + + * config/i386/driver-i386.c (host_detect_local_cpu): Do not check + signature_TM2_ebx, it interferes with signature_INTEL_ebx. + +2013-07-06 Uros Bizjak <ubizjak@gmail.com> + + * config/i386/sse.md (sse_movlhps): Change alternative 3 + of operand 2 to "m". + +2013-07-06 Uros Bizjak <ubizjak@gmail.com> + + PR target/57807 + * config/i386/sse.md (iptr): New mode attribute. + (sse2_movq128): Add pointer size overrides for Intel asm dialect. + (<sse>_vm<plusminus_insn><mode>3): Ditto. + (<sse>_vmmul<mode>3): Ditto. + (<sse>_vmdiv<mode>3): Ditto. + (sse_vmrcpv4sf2): Ditto. + (<sse>_vmsqrt<mode>2): Ditto. + (sse_vmrsqrtv4sf2): Ditto. + (<sse>_vm<code><mode>3): Ditto. + (avx_vmcmp<mode>3): Ditto. + (<sse>_vmmaskcmp<mode>3): Ditto. + (<sse>_comi): Ditto. + (<sse>_ucomi): Ditto. + (*xop_vmfrcz_<mode>): Ditto. + (*fmai_fmadd_<mode>): Ditto. + (*fmai_fmsub_<mode>): Ditto. + (*fmai_fnmadd_<mode>): Ditto. + (*fmai_fnmsub_<mode>): Ditto. + (*fma4i_vmfmadd_<mode>): Ditto. + (*fma4i_vmfmsub_<mode>): Ditto. + (*fma4i_vmfnmadd_<mode>): Ditto. + (*fma4i_vmfnmsub_<mode>): Ditto. + (*xop_vmfrcz_<mode>): Ditto. + (sse_cvtps2pi): Ditto. + (sse_cvttps2pi): Ditto. + (sse_cvtss2si): Ditto. + (sse_cvtss2si_2): Ditto. + (sse_cvtss2siq_2): Ditto. + (sse_cvttss2si): Ditto. + (sse_cvttss2siq): Ditto. + (sse_cvtsd2si): Ditto. + (sse_cvtsd2si_2): Ditto. + (sse_cvtsd2siq_2): Ditto. + (sse_cvttsd2si): Ditto. + (sse_cvttsd2siq): Ditto. + (sse_cvtsd2ss): Ditto. + (sse_cvtss2sd): Ditto. + (avx2_pbroadcast<mode>): Ditto. + (avx2_pbroadcast<mode>_1): Ditto. + (*avx_vperm_broadcast_v4sf): Ditto. + + (sse_movhlps): Ditto for movlp[sd]/movhp[sd] alternatives. + (sse_movlhps): Ditto. + (sse_storehps): Ditto. + (sse_loadhps): Ditto. + (sse_storelps): Ditto. + (sse_loadlps): Ditto. + (*vec_concatv4sf): Ditto. + (*vec_interleave_highv2df): Ditto. + (*vec_interleave_lowv2df): Ditto. + (*vec_extractv2df_1_sse): Ditto. + (*vec_extractv2df_0_sse): Ditto. + (sse2_storelpd): Ditto. + (sse2_loadlpd): Ditto. + (sse2_movsd): Ditto. + (*vec_concatv4si): Ditto. + (vec_concatv2di): Ditto. + + * config/i386/mmx.md (mmx_punpcklbw): Add pointer size overrides + for Intel asm dialect. + (mmx_punpcklwd): Ditto. + (mmx_punpckldq): Ditto. + + * config/i386/i386.c (ix86_print_operand) ['H']: Output 'qword ptr' + for intel assembler dialect. + +2013-07-06 Jakub Jelinek <jakub@redhat.com> + + PR target/29776 + * fold-const.c (tree_call_nonnegative_warnv_p): Return true + for BUILT_IN_C{LZ,LRSB}*. + * tree.h (CASE_INT_FN): Add FN##IMAX case. + * tree-vrp.c (extract_range_basic): Handle + BUILT_IN_{FFS,PARITY,POPCOUNT,C{LZ,TZ,LRSB}}*. For + BUILT_IN_CONSTANT_P if argument isn't (D) of PARM_DECL, + fall thru to code calling set_value*. + * builtins.c (expand_builtin): Remove *IMAX cases. + (fold_builtin_bitop): For BUILT_IN_CLRSB* return NULL_TREE + if width is bigger than 2*HWI. + +2013-07-05 Vladimir Makarov <vmakarov@redhat.com> + + PR rtl-optimization/55342 + * lra-int.h (lra_subreg_reload_pseudos): New. + * lra.c: Add undoing optional reloads to the block diagram. + (lra_subreg_reload_pseudos): New. + (lra_optional_reload_pseudos): Change comments. + (lra): Init and clear lra_subreg_reload_pseudos. Clear + lra_optional_reload_pseudos after undo transformations. + * lra-assigns.c (pseudo_prefix_title): New. + (lra_setup_reg_renumber): Use it. + (spill_for): Ditto. Check subreg reload pseudos too. + (assign_by_spills): Consider subreg reload pseudos too. + * lra-constraints.c (simplify_operand_subreg): Use + lra_subreg_reload_pseudos instead of lra_optional_reload_pseudos. + (curr_insn_transform): Recognize and do optional reloads. + (undo_optional_reloads): New. + (lra_undo_inheritance): Call undo_optional_reloads. + +2013-07-05 Thomas Quinot <quinot@adacore.com> + + * tree-complex.c (expand_complex_operations_1): Fix typo. + 2013-07-04 Tejas Belagod <tejas.belagod@arm.com> * config/aarch64/aarch64-protos.h (cpu_vector_cost): New. @@ -48,8 +335,8 @@ 2013-07-02 Sriraman Tallam <tmsriram@google.com> - * config/i386/i386.c (gate_insert_vzeroupper): Check if target - ISA is AVX. + * config/i386/i386.c (gate_insert_vzeroupper): Check if + target ISA is AVX. (ix86_option_override_internal):Turn on all -mavx target flags by default as they are dependent on AVX anyway. @@ -71,8 +358,7 @@ 2013-07-02 Ian Bolton <ian.bolton@arm.com> - * config/aarch64/aarch64-simd.md (absdi2): Support abs for - DI mode. + * config/aarch64/aarch64-simd.md (absdi2): Support abs for DI mode. 2013-07-02 Ian Bolton <ian.bolton@arm.com> @@ -281,8 +567,7 @@ 2013-06-29 Yufeng Zhang <yufeng.zhang@arm.com> - * config/aarch64/aarch64.c: Remove junk from the beginning of the - file. + * config/aarch64/aarch64.c: Remove junk from the beginning of the file. 2013-06-28 Vladimir Makarov <vmakarov@redhat.com> @@ -297,9 +582,8 @@ 2013-06-28 Jakub Jelinek <jakub@redhat.com> PR target/57736 - * config/i386/i386.c (ix86_expand_builtin): If target == NULL - and mode is VOIDmode, don't create a VOIDmode pseudo to copy result - into. + * config/i386/i386.c (ix86_expand_builtin): If target == NULL and + mode is VOIDmode, don't create a VOIDmode pseudo to copy result into. 2013-06-28 Balaji V. Iyer <balaji.v.iyer@intel.com> @@ -331,8 +615,8 @@ 2013-06-28 Marcus Shawcroft <marcus.shawcroft@arm.com> - * config/aarch64/aarch64-protos.h - aarch64_classify_symbol_expression): Define. + * config/aarch64/aarch64-protos.h (aarch64_classify_symbol_expression): + Define. (aarch64_symbolic_constant_p): Remove. * config/aarch64/aarch64.c (aarch64_classify_symbol_expression): Remove static. Fix line length and white space. @@ -465,8 +749,7 @@ * config/mips/mips-tables.opt: Regenerate. * config/mips/mips-cpus.def: Add m14ke and m14kec. - * config/mips/mips.h (BASE_DRIVER_SELF_SPECS): m14ke* implies - -mdspr2. + * config/mips/mips.h (BASE_DRIVER_SELF_SPECS): m14ke* implies -mdspr2. * doc/invoke.texi: Add -m14kc. 2013-06-27 Jakub Jelinek <jakub@redhat.com> @@ -482,8 +765,8 @@ 2013-06-27 Vladimir Makarov <vmakarov@redhat.com> - * lra-constraints.c (inherit_in_ebb): Process static hard regs - too. Process OP_INOUT regs for splitting too. + * lra-constraints.c (inherit_in_ebb): Process static hard regs too. + Process OP_INOUT regs for splitting too. 2013-06-27 Jakub Jelinek <jakub@redhat.com> @@ -539,8 +822,7 @@ (s390_expand_builtin): New function. (TARGET_INIT_BUILTINS): Define. (TARGET_EXPAND_BUILTIN): Define. - * common/config/s390/s390-common.c (processor_flags_table): Add - PF_TX. + * common/config/s390/s390-common.c (processor_flags_table): Add PF_TX. * config/s390/predicates.md (s390_comparison): Handle CCRAWmode. (s390_alc_comparison): Likewise. * config/s390/s390-modes.def: Add CCRAWmode. @@ -551,8 +833,7 @@ * config/s390/s390.md: Rename UNSPEC_CCU_TO_INT to UNSPEC_STRCMPCC_TO_INT and UNSPEC_CCZ_TO_INT to UNSPEC_CC_TO_INT. (UNSPECV_TBEGIN, UNSPECV_TBEGINC, UNSPECV_TEND, UNSPECV_TABORT) - (UNSPECV_ETND, UNSPECV_NTSTG, UNSPECV_PPA): New unspecv enum - values. + (UNSPECV_ETND, UNSPECV_NTSTG, UNSPECV_PPA): New unspecv enum values. (TBEGIN_MASK, TBEGINC_MASK): New constants. ("*cc_to_int"): Move up. ("*mov<mode>cc", "*cjump_64", "*cjump_31"): Accept integer @@ -574,8 +855,7 @@ 2013-06-26 Thomas Schwinge <thomas@codesourcery.com> * config/i386/gnu.h [TARGET_LIBC_PROVIDES_SSP] - (TARGET_CAN_SPLIT_STACK, TARGET_THREAD_SPLIT_STACK_OFFSET): - Undefine. + (TARGET_CAN_SPLIT_STACK, TARGET_THREAD_SPLIT_STACK_OFFSET): Undefine. 2013-06-26 Michael Meissner <meissner@linux.vnet.ibm.com> Pat Haugen <pthaugen@us.ibm.com> @@ -608,8 +888,7 @@ PR tree-optimization/57705 * tree-vect-loop.c (vect_is_simple_iv_evolution): Allow SSA_NAME step, provided that it is not defined inside the loop. - (vect_analyze_scalar_cycles_1): Disallow SSA_NAME step in nested - loop. + (vect_analyze_scalar_cycles_1): Disallow SSA_NAME step in nested loop. (get_initial_def_for_induction): Handle SSA_NAME IV step. 2013-06-25 Martin Jambor <mjambor@suse.cz> @@ -659,8 +938,7 @@ 2013-06-24 Richard Biener <rguenther@suse.de> - * pointer-set.h (struct pointer_set_t): Move here from - pointer-set.c. + * pointer-set.h (struct pointer_set_t): Move here from pointer-set.c. (pointer_set_lookup): Declare. (class pointer_map): New template class implementing a generic pointer to T map. @@ -724,7 +1002,8 @@ when current target options does not apply. * config/i386/i386-protos.h (ix86_reset_previous_fndecl): New function. * config/i386/i386.c (ix86_reset_previous_fndecl): Ditto. - * config/i386/bmiintrin.h: Pass appropriate target attributes to header. + * config/i386/bmiintrin.h: Pass appropriate target + attributes to header. * config/i386/mmintrin.h: Ditto. * config/i386/nmmintrin.h: Ditto. * config/i386/avx2intrin.h: Ditto. @@ -772,8 +1051,7 @@ 2013-06-21 Andi Kleen <ak@linux.intel.com> - * doc/extend.texi: Dont use __atomic_clear in HLE - example. Fix typo. + * doc/extend.texi: Dont use __atomic_clear in HLE example. Fix typo. 2013-06-21 Andi Kleen <ak@linux.intel.com> diff --git a/gcc/DATESTAMP b/gcc/DATESTAMP index 2b025137aee..d3cad067949 100644 --- a/gcc/DATESTAMP +++ b/gcc/DATESTAMP @@ -1 +1 @@ -20130704 +20130712 diff --git a/gcc/Makefile.in b/gcc/Makefile.in index a14c03ae59f..f295e23b856 100644 --- a/gcc/Makefile.in +++ b/gcc/Makefile.in @@ -1142,6 +1142,8 @@ FORTRAN_TARGET_OBJS=@fortran_target_objs@ # Object files for gcc many-languages driver. GCC_OBJS = gcc.o ggc-none.o +c-family-warn = $(STRICT_WARN) + # Language-specific object files shared by all C-family front ends. # FIXME: tree-mudflap is C-family only, but it is also part of the middle-end. # The mudflap machinery should be properly separated from the front ends, and @@ -2538,7 +2540,7 @@ tree-ssa-reassoc.o : tree-ssa-reassoc.c $(TREE_FLOW_H) $(CONFIG_H) \ $(TM_H) coretypes.h $(TREE_PASS_H) $(FLAGS_H) \ tree-iterator.h $(BASIC_BLOCK_H) $(GIMPLE_H) $(TREE_INLINE_H) \ $(VEC_H) langhooks.h alloc-pool.h pointer-set.h $(CFGLOOP_H) \ - $(TARGET_H) $(GIMPLE_PRETTY_PRINT_H) $(DIAGNOSTIC_CORE_H) + $(TARGET_H) $(GIMPLE_PRETTY_PRINT_H) $(DIAGNOSTIC_CORE_H) $(PARAMS_H) tree-optimize.o : tree-optimize.c $(TREE_FLOW_H) $(CONFIG_H) $(SYSTEM_H) \ $(TREE_H) $(TM_P_H) $(GGC_H) \ $(DIAGNOSTIC_H) $(BASIC_BLOCK_H) $(FLAGS_H) $(TM_H) \ diff --git a/gcc/ada/ChangeLog b/gcc/ada/ChangeLog index 4122896c915..9178fc86714 100644 --- a/gcc/ada/ChangeLog +++ b/gcc/ada/ChangeLog @@ -1,3 +1,603 @@ +2013-07-08 Hristian Kirtchev <kirtchev@adacore.com> + + * einfo.adb (Get_Pragma): Handle the retrieval of delayed + pragmas stored in N_Contract nodes. + * einfo.ads (Get_Pragma): Update the comment on usage. + * sem_prag.adb (Check_Precondition_Postcondition): Retain a copy + of the pragma when it applies to a body that acts as a spec. The + copy is preanalyzed and chained on the contract of the body. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * rtsfind.adb: Minor comment fix. + +2013-07-08 Hristian Kirtchev <kirtchev@adacore.com> + + * sem_ch4.adb (Check_Ghost_Subprogram_Call): Do not check the placement + of a Ghost function call when the enclosing context is being + preanalyzed. + +2013-07-08 Ed Schonberg <schonberg@adacore.com> + + * exp_ch6.adb (Expand_Inlined_Call, Process_Formals): If the + expression in a return statement is a numeric literal, qualify + it with the return type for proper resolution. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * sem.ads: Minor comment updates. + * s-restri.ads, exp_ch6.adb, lib-load.ads, exp_ch3.adb, sem_ch10.adb: + Minor reformatting. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * exp_attr.adb (Expand_N_Attribute_Reference): Add dummy entry + for Restriction_Set. + * gnat_rm.texi: Add missing menu entry for Attribute Ref Add + documentation for attribute Restriction_Set. + * lib-writ.adb (Write_With_Lines): Generate special W lines + for Restriction_Set. + * lib-writ.ads: Document special use of W lines for + Restriction_Set. + * lib.ads (Restriction_Set_Dependences): New table. + * par-ch4.adb (Is_Parameterless_Attribute): Add Loop_Entry to + list (Scan_Name_Extension_Apostrophe): Remove kludge test for + Loop_Entry (Scan_Name_Extension_Apostrophe): Handle No_Dependence + for Restricton_Set. + * restrict.adb (Check_SPARK_Restriction): Put in Alfa order + (OK_No_Dependence_Unit_Name): New function. + * restrict.ads (OK_No_Dependence_Unit_Name): New function. + * rtsfind.adb: Minor reformatting Minor code reorganization. + * sem_attr.adb (Analyze_Attribute): Add processing for + Restriction_Set. + * sem_prag.adb (Process_Restrictions_Or_Restriction_Warnings): + Remove Check_Unit_Name and use new function + OK_No_Dependence_Unit_Name instead. + * sinfo.ads: Minor comment updates. + * snames.ads-tmpl: Add entry for Restriction_Set attribute. + +2013-07-08 Hristian Kirtchev <kirtchev@adacore.com> + + * exp_ch4.adb (Apply_Accessibility_Check): Remove local constant + Pool_Id and local variable Free_Stmt. Do not deallocate the faulty + object as "free" is not available on all targets/profiles. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * sem_ch13.adb (Analyze_Aspect_Specifications): Handle + Storage_Size aspect for task type in case discriminant is + referenced. + (Analyze_Attribute_Definition_Clause): Do not flag Storage_Size + attribute definition clause as obsolescent if from aspect. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * gnat_rm.texi: Add documentation for Img returning a function. + * par-prag.adb: Minor reformatting. + * restrict.adb: Minor reformatting and code reorganization. + +2013-07-08 Ed Schonberg <schonberg@adacore.com> + + * sem_res.adb: add guard to ASIS transform. + +2013-07-08 Ed Schonberg <schonberg@adacore.com> + + * exp_ch9.adb (Expand_N_Asynchronous_Select): If the trigger + of the asynchronous select is a dispatching call, transform the + abortable part into a procedure, to avoid duplication of local + loop variables that may appear within. + +2013-07-08 Vincent Celier <celier@adacore.com> + + * projects.texi: Update the documentation of suffixes in package + Naming. + +2013-07-08 Ed Schonberg <schonberg@adacore.com> + + * sem_ch6.adb (Conforming_Types): Anonymous_access_to_subprograsm + types are type conformant if the designated type of one is + protected and the other is not. Convention only matters when + checking subtype conformance. + +2013-07-08 Ed Schonberg <schonberg@adacore.com> + + * sem_res.adb (Make_Call_Into_Operator): In ASIS mode, propagate + back the fully resolved operands to the original function call + so that all semantic information remains available to ASIS. + +2013-07-08 Ed Schonberg <schonberg@adacore.com> + + * sem_ch4.adb: minor reformatting (remove obsolete comment). + * sem_ch9.adb: improve error message on illegal trigger. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * sem_prag.adb: Minor reformatting. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * gnatcmd.adb: Minor reformatting. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * targparm.adb (Get_Target_Parameters): Recognize pragma + Partition_Elaboration_Policy. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * gnat_ugn.texi: Minor update to mention partition elaboration policy. + +2013-07-08 Ed Schonberg <schonberg@adacore.com> + + * sem_ch4.adb (Comple_Object_Operation): Revert previous change. + (Analyze_Indexed_Component_Form): In ASIS mode, if node has been + transformed but not rewritten as a function call (as is the case + in a generic), analyze it as such. + +2013-07-08 Thomas Quinot <quinot@adacore.com> + + * gnat_rm.texi: Minor rewording: add missing word "operators" + in documentation for restriction No_Direct_Boolean_Operator. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * errout.adb (Set_Msg_Txt): No longer sets Is_Style_Msg, + Is_Warning_Msg, or Is_Unconditional_Msg (all are set elsewhere + now). + * errout.ads: Insertions ! and !! no longer have to be at the + end of the message, they can be anywhere in the message. + * erroutc.adb (Test_Style_Warning_Serious_Unconditional_Msg): + Replaces Test_Style_Warning_Serious_Msg + * erroutc.ads (Has_Double_Exclam): New flag New comments for + existing flags (Test_Style_Warning_Serious_Unconditional_Msg): + Replaces Test_Style_Warning_Serious_Msg + * errutil.adb (Test_Style_Warning_Serious_Unconditional_Msg): + Replaces Test_Style_Warning_Serious_Msg + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * par-prag.adb (Process_Restrictions_Or_Restriction_Warnings): + Recognize SPARK_05 as synonym for SPARK in restrictions pragma. + * restrict.ads, restrict.adb (SPARK_Hides): Table moved to body, only + referenced there. + * scng.adb, sem_ch3.adb, sem_ch4.adb, sem_ch5.adb, sem_ch8.adb, + sem_res.adb, sem_util.adb: Use restriction SPARK_05 instead of SPARK. + * snames.ads-tmpl (Name_No_Obsolescent_Features): New entry. + +2013-07-08 Vincent Celier <celier@adacore.com> + + * gnatcmd.adb (Check_Files): Use a response file for gnatls + when possible. + +2013-07-08 Gary Dismukes <dismukes@adacore.com> + + * freeze.adb: Minor typo fixes. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * gnat_rm.texi: Document SPARK_05 (replaces SPARK) Document + obsolete recognition of SPARK Document all other obsolete synonyms + for old restrictions. + * restrict.adb (Check_SPARK_Restriction): SPARK_05 replaces + SPARK (Process_Restriction_Synonyms): Handle SPARK as synonym + for SPARK_05. + * restrict.ads: Restriction SPARK_05 replaces SPARK. + * s-rident.ads: Replace restriction SPARK by SPARK_05 Add SPARK + as synonym for SPARK_05. + * sem_prag.adb: Minor reformatting. + * snames.ads-tmpl: Add entries for Name_SPARK and Name_SPARK_05. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * sem_dim.adb: Minor error message change. + * freeze.adb (Freeze_Entity, array type case): Extend handling + of Implicit_Packing to handle multi-dimensional array case. + * gnat_rm.texi: Update doc on Implicit_Packing. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * exp_ch4.adb: Minor reformatting. + +2013-07-08 Ed Schonberg <schonberg@adacore.com> + + * sem_ch4.adb (Complete_Object_Operation): In ASIS mode, if + the parent node is a selected component and the analysis as a + call is successful, set the type of the selector in the parent + node for subsequent checks, because the rewriting of the node + does not take place during pre-analysis. + + 2013-07-08 Robert Dewar <dewar@adacore.com> + + * sem_ch8.adb, exp_ch3.adb: Minor reformatting. + +2013-07-08 Hristian Kirtchev <kirtchev@adacore.com> + + * exp_ch4.adb (Expand_N_Op_Eq): When comparing two + Bounded_Strings, use the predefined equality function of the + root Super_String type. + +2013-07-08 Hristian Kirtchev <kirtchev@adacore.com> + + * exp_ch4.adb (Create_Alternative): Removed. + (Expand_N_If_Expression): Remove constant + In_Case_Or_If_Expression. Add local variable + Ptr_Typ. Inspect the "then" and "else" action lists + for transient controlled objects and generate code to + finalize them. (Is_Controlled_Function_Call): Removed. + (Process_Action): Update the comment on usage. Update the call + to Process_Transient_Object. There is no need to continue the + traversal of the object itself. + (Process_Actions): New routine. + (Process_Transient_Object): Moved to the top level of Exp_Ch4. Add + a new formal and update the related comment on usage. + * exp_util.adb (Within_Case_Or_If_Expression): Start the search + from the parent of the node. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * a-cusyqu.ads, a-cbprqu.ads, s-interr.ads, a-cuprqu.ads, + a-cbsyqu.ads: Minor reformatting (proper formatting of overriding). + +2013-07-08 Ed Schonberg <schonberg@adacore.com> + + * sem_ch8.adb (Attribute_Renaming): Treat 'Img as an attribute + that can be renamed as a function. + +2013-07-08 Thomas Quinot <quinot@adacore.com> + + * g-socket.ads: Document target dependency: FIONBIO may or may not + be inherited from listening socket by accepted socket. + +2013-07-08 Hristian Kirtchev <kirtchev@adacore.com> + + * exp_ch4.adb (Apply_Accessibility_Check): Do not deallocate the object + on targets that can't deallocate. + +2013-07-08 Hristian Kirtchev <kirtchev@adacore.com> + + * exp_ch3.adb (Freeze_Type): Generate a + subpools-related accessibility check only on profiles that + include the corresponding library unit. + +2013-07-08 Gary Dismukes <dismukes@adacore.com> + + * sem_ch8.adb: Minor typo fixes. + +2013-07-08 Javier Miranda <miranda@adacore.com> + + * sem_ch8.adb (Save_Scope_Stack): Adding documentation. + (Restore_Scope_Stack): Remove the elements of the list when the + visibility of each entity is restored. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * exp_ch9.adb, sem.ads, sem_util.adb: Minor reformatting. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * sem_ch8.adb, sem_ch8.ads: Minor reformatting. + +2013-07-08 Gary Dismukes <dismukes@adacore.com> + + * gnat_rm.texi: Minor reformatting and rewording for consistency. + +2013-07-08 Bob Duff <duff@adacore.com> + + * exp_ch3.adb (Build_Master): If Desig_Type is an incomplete + view coming from a limited-with'ed package, use the nonlimited + view in case it has tasks. + +2013-07-08 Javier Miranda <miranda@adacore.com> + + * sem_ch8.ad[sb] (Save_Scope_Stack): Modified to return the list + of entities which have been temporarily removed from immediate + visibility. + (Restore_Scope_Stack): Modified to receive an + additional parameter with the list of entities whose immediate + visibility must be restored. + * sem.adb (Do_Analyze): Use new version of + Save_Scope_Stack/Restore_Scope_Stack + * sem_ch12.adb (Inline_Instance_Body): Use new version of + Save_Scope_Stack and Restore_Scope_Stack + +2013-07-08 Hristian Kirtchev <kirtchev@adacore.com> + + * sem_prag.adb (Analyze_Pragma): Remove + variable Unit_Prag. Remove the check on duplicate mode for the + configuration form of the pragma. + (Redefinition_Error): Removed. + +2013-07-08 Robert Dewar <dewar@adacore.com> + + * lib.ads, gnat_rm.texi, einfo.ads, sem_ch13.adb: Minor reformatting + and editing. + +2013-07-08 Ed Schonberg <schonberg@adacore.com> + + * sem_prag.adb (Analyze_PPC_In_Decl_Part): In ASIS mode, + pre-analyze only the original expression attached to the source + aspect, not the relocated expression of the pragma, to prevent + malformed trees in ASIS mode. + * sem_ch13.adb (Analyze_Aspect_Specifications): Revert previous + patch: the expression in the aspect for pre/post must be relocated + to the pragma for proper analysis. + +2013-07-05 Hristian Kirtchev <kirtchev@adacore.com> + + * aspects.adb: Add an entry for SPARK_Mode in table Canonical_Aspect. + * aspects.ads: Add an entry for SPARK_Mode in tables Aspect_Id, + Aspect_Argument, Aspect_Names. + * atree.adb (Node32): New routine. + (Set_Node32): New routine. + * atree.ads (Node32): New routine. + (Set_Node32): New routine. + * einfo.adb: Node32 is now used as SPARK_Mode_Pragmas. + (Set_SPARK_Mode_Pragmas): New routine. + (SPARK_Mode_Pragmas): New routine. + (Write_Field32_Name): Add and entry for SPARK_Modes. + * einfo.ads: Add attribute SPARK_Mode_Pragmas along with usage + in various entities. + (Set_SPARK_Mode_Pragmas): New routine and + pragma Inline. + (SPARK_Mode_Pragmas): New routine and pragma Inline. + * gnat_rm.texi: Add sections explaining the syntax and semantics + of aspect/pragma SPARK_Mode. + * gnat_ugn.texi: Add pragma SPARK_Mode to the list of + configuration pragmas. + * lib.adb (Set_SPARK_Mode_Pragma): New routine. + (SPARK_Mode_Pragma): New routine. + * lib.ads: Alphabetize the comments on fields of record + Unit_Record. Add new field SPARK_Mode_Pragma along with + comment on its usage. Update the layout of record Unit_Record. + (Set_SPARK_Mode_Pragma): New routine and pragma Inline. + (SPARK_Mode_Pragma): New routine and pragma Inline. + * lib-load.adb (Create_Dummy_Package_Unit): Initialize + field SPARK_Mode_Pragma. + (Load_Main_Source): Initialize field SPARK_Mode_Pragma. + (Load_Unit): Initialize field SPARK_Mode_Pragma. + * lib-writ.adb (Add_Preprocessing_Dependency): Initialize field + SPARK_Mode_Pragma. + (Ensure_System_Dependency): Initialize field SPARK_Mode_Pragma. + * opt.ads: Alphabetize verification flags. Store the + compilation-wide SPARK mode in variable Global_SPARK_Mode. + * par-prag.adb: Pragma SPARK_Mode does not need special processing + by the parser. + * sem_ch13.adb (Analyze_Aspect_Specifications): Convert aspect + SPARK_Mode into a pragma. + (Check_Aspect_At_Freeze_Point): Aspect SPARK_Mode does not need + delayed processing. + * sem_prag.adb: Add an entry for SPARK_Mode in table Sig_Flags. + (Analyze_Pragma): Add processing for pragma SPARK_Mode. + (Get_SPARK_Mode_Id): New routine. + (Is_Elaboration_SPARK_Mode): New routine. + (Is_Private_SPARK_Mode): New routine. + * sem_prag.ads (Get_SPARK_Mode_Id): New routine. + (Is_Elaboration_SPARK_Mode): New routine. + (Is_Private_SPARK_Mode): New routine. + * sinfo.ads: Update the comment on the usage of field Next_Pragma. + * snames.ads-tmpl: Add new predefined name for SPARK_Mode and + Auto. Add new pragma Id for SPARK_Mode. + * types.ads: Add new type SPARK_Mode_Id. + +2013-07-05 Ed Schonberg <schonberg@adacore.com> + + * sem_ch13.adb (Analyze_Aspect_Specifications): For + pre/postconditions copy the expression to the generated pragma, + to avoid sharing between the original aspect and the pragma node, + because in ASIS_Mode both will be independently analyzed. + +2013-07-05 Ed Schonberg <schonberg@adacore.com> + + * exp_ch3.adb (Build_Variant_Record_Equality): Add pairs of + formals for each discriminant of an unchecked union. + (Make_Eq_Case): Suprogram accepts a list of discriminants. Nested + variants are supported. New helper function Corresponding_Formal. + * exp_ch4.adb (Build_Equality_Call): For unchecked unions, + loop through discriminants to create list of inferred values, + and modify call to equality routine accordingly. + +2013-07-05 Claire Dross <dross@adacore.com> + + * a-cfdlli.ads, a-cfhama.ads, a-cfhase.ads, a-cforma.ads, + a-cforse.ads, a-cofove.ads: Add preconditions when needed + + container types are not tagged any more. + +2013-07-05 Thomas Quinot <quinot@adacore.com> + + * freeze.adb (Freeze_Entity): For an object with captured + initialization statements, do not remove Init_Stmts from the + enclosing list, as Freeze_All might rely on it to know where to + stop freezing. + +2013-07-05 Robert Dewar <dewar@adacore.com> + + * exp_ch4.adb, a-cfdlli.ads, a-ngelfu.ads, s-bignum.adb: Minor + reformatting. + +2013-07-05 Hristian Kirtchev <kirtchev@adacore.com> + + * exp_ch4.adb (Expand_Composite_Equality): Use the full view + when the base type is private. + +2013-07-05 Claire Dross <dross@adacore.com> + + * a-cfdlli.ads: Add preconditions when needed. + +2013-07-05 Robert Dewar <dewar@adacore.com> + + * sem_ch8.adb: Minor reformatting. + +2013-07-05 Ed Schonberg <schonberg@adacore.com> + + * sem_ch3.adb (Access_Subprogram_Declaration): Use + Generate_Reference_To_Formals. + * lib-xref.adb (Generate_Reference_To_Formals): In the case of + access to subprograms, the formals are found in the designated + subprogram type. + +2013-07-05 Robert Dewar <dewar@adacore.com> + + * gnat_ugn.texi: Document that comments can be lined up with + previous non-blank line. + * styleg.adb (Check_Comment): Allow indentation to match previous + non-blank line (Same_Column_As_Previous_Line): New function + +2013-07-05 Robert Dewar <dewar@adacore.com> + + * gnat_rm.texi: Update doc on missing pragmas. + * sem_ch12.adb: Minor comment additions. + +2013-07-05 Hristian Kirtchev <kirtchev@adacore.com> + + * sem_prag.adb (Analyze_Pragma): Ensure that + Contract_Cases, Depends and Global are analyzed when they apply + to a subprogram compilation unit. The pragmas are all added + unconditionally to the construct's contract. This ensures that + proof tools can locate the pragmas. + +2013-07-05 Ed Schonberg <schonberg@adacore.com> + + * sem_ch8.adb (Freeze_Actual_Profile): An instance within + a generic unit does not freeze a generic private type of the + enclosing generic. This rule must also apply to a type derived + from a generic private type. + +2013-07-05 Arnaud Charlet <charlet@adacore.com> + + * gnat_rm.texi: Add missing documentation for pragmas. + +2013-07-05 Yannick Moy <moy@adacore.com> + + * sem_ch12.adb: Minor comment. + +2013-07-05 Robert Dewar <dewar@adacore.com> + + * gnat_rm.texi: Document that -gnatR and -gnatD cannot be used + together. + * switch-c.adb: Do not allow -gnatD and -gnatR to both be + specified. + +2013-07-05 Robert Dewar <dewar@adacore.com> + + * gnat_rm.texi: Add missing documentation for pragmas. + * sem_ch8.adb: Minor reformatting. + * gnat_ugn.texi: Document that -gnatR and -gnatD cannot be used + together. + +2013-07-05 Yannick Moy <moy@adacore.com> + + * sem_ch12.ads, sem_ch12.adb (Need_Subprogram_Instance_Body): Force + instance of subprogram body in SPARK mode, by testing Expander_Active + (set in SPARK mode) instead of Full_Expander_Active (not set in + SPARK mode). + * sem_ch8.adb: Minor reformatting. + +2013-07-05 Robert Dewar <dewar@adacore.com> + + * freeze.adb (Freeze_Entity): Remove test of obsolete flag + Propagate_Exceptions, and associated useless code that did + nothing. + * gnat_rm.texi: Add documentation for obsolete pragma + Propagate_Exceptions. + * opt.ads (Propagate_Exceptions): Obsolete flag removed. + * sem_prag.adb (Analyze_Pragma, case Propagate_Exceptions): + Remove useless and obsolete setting of Propagate_Exceptions flag. + +2013-07-05 Robert Dewar <dewar@adacore.com> + + * gnat_rm.texi, sem_prag.adb: Minor comment/text fixes. + +2013-07-05 Robert Dewar <dewar@adacore.com> + + * gnat_rm.texi: Add missing doc for various pragmas. + +2013-07-05 Robert Dewar <dewar@adacore.com> + + * par_sco.adb, sem_ch12.adb, par-ch5.adb: Minor reformatting. + * gnat_rm.texi: Document pragma Profile_Warnings. + * restrict.ads, sem_prag.adb: Minor reformatting. + +2013-07-05 Ed Schonberg <schonberg@adacore.com> + + * sem_ch12.adb (Check_Formal_Package_Instance): Handle properly + a formal subprogram that was defaulted in the formal package. + +2013-07-05 Thomas Quinot <quinot@adacore.com> + + * par_sco.adb (Traverse_Declarations_Or_Statements): Ignore + N_Implicit_Label_Declaration nodes. + +2013-07-05 Robert Dewar <dewar@adacore.com> + + * a-cfhase.adb, sem_prag.adb, a-cfhama.adb: Minor reformatting. + +2013-07-05 Ed Schonberg <schonberg@adacore.com> + + * sem_ch12.adb (Copy_Generic_Node): Check that name in function + call is a valid entity name before preserving entity in generic + copy. + +2013-07-05 Thomas Quinot <quinot@adacore.com> + + * par-ch5.adb: Minor reformatting. + +2013-07-05 Thomas Quinot <quinot@adacore.com> + + * sinfo.ads: Minor clarification to documentation for + N_Implicit_Label_Declaration. + +2013-07-05 Hristian Kirtchev <kirtchev@adacore.com> + + * a-except-2005.adb, a-except.adb: Add constant Rmsg_17. Correct the + values of all remaining constants. + (Rcheck_35): New routine along with pragmas Export and No_Return. + (Rcheck_PE_Aliased_Parameters): New routine along with pragmas + Export and No_Return. + (Rcheck_PE_All_Guards_Closed, + Rcheck_PE_Bad_Predicated_Generic_Type, + Rcheck_PE_Current_Task_In_Entry_Body, + Rcheck_PE_Duplicated_Entry_Address, Rcheck_PE_Explicit_Raise, + Rcheck_PE_Implicit_Return, Rcheck_PE_Misaligned_Address_Value, + Rcheck_PE_Missing_Return, Rcheck_PE_Overlaid_Controlled_Object, + Rcheck_PE_Potentially_Blocking_Operation + Rcheck_PE_Stubbed_Subprogram_Called, + Rcheck_PE_Unchecked_Union_Restriction, + Rcheck_PE_Non_Transportable_Actual, Rcheck_SE_Empty_Storage_Pool, + Rcheck_SE_Explicit_Raise, Rcheck_SE_Infinite_Recursion, + Rcheck_SE_Object_Too_Large, Rcheck_PE_Finalize_Raised_Exception): + Update the use of Rmsg_XX. + (Rcheck_17, Rcheck_18, Rcheck_19, + Rcheck_20, Rcheck_21, Rcheck_22, Rcheck_23, Rcheck_24, Rcheck_25, + Rcheck_26, Rcheck_27, Rcheck_28, Rcheck_29, Rcheck_30, Rcheck_31, + Rcheck_32, Rcheck_33, Rcheck_34, Rcheck_35): Update corresponding + renamed subprograms. + * checks.adb: Add with and use clause for Stringt. + (Apply_Parameter_Aliasing_Checks): Make constant Loc visible in + all subprograms of Apply_Parameter_Aliasing_Checks. Remove local + variable Cond. Initialize Check at the start of the routine. Use + routine Overlap_Check to construct a simple or a detailed run-time + check. Update the creation of the simple check. + (Overlap_Check): New routine. + * exp_ch11.adb (Get_RT_Exception_Name): Add a value for + PE_Aliased_Parameters. + * types.ads: Add new enumeration literal + PE_Aliased_Parameters. Update the corresponding integer values + of all RT_Exception_Code literals. + * types.h: Add new constant PE_Aliased_Parameters. Correct the + values of all remaining constants. + +2013-07-05 Yannick Moy <moy@adacore.com> + + * gnat_rm.texi: Minor renaming of SPARK into SPARK 2005 in + documentation. + +2013-07-05 Ed Schonberg <schonberg@adacore.com> + + * sem_prag.adb (Analyze_PPC_In_Decl_Part): For a class-wide + condition, when replacing the name of a formal by a conversion + to the class-wide type, exempt selector names that appear in + parameter associations. + 2013-06-13 Eric Botcazou <ebotcazou@adacore.com> * gcc-interface/ada-tree.h (DECL_BY_DOUBLE_REF_P): Delete. diff --git a/gcc/ada/a-cbprqu.ads b/gcc/ada/a-cbprqu.ads index aa184a1cc5a..fb44d02c1dd 100644 --- a/gcc/ada/a-cbprqu.ads +++ b/gcc/ada/a-cbprqu.ads @@ -6,7 +6,7 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 2011, Free Software Foundation, Inc. -- +-- Copyright (C) 2011-2013, Free Software Foundation, Inc. -- -- -- -- This specification is derived from the Ada Reference Manual for use with -- -- GNAT. The copyright notice above, and the license provisions that follow -- @@ -101,13 +101,13 @@ package Ada.Containers.Bounded_Priority_Queues is protected type Queue (Capacity : Count_Type := Default_Capacity; Ceiling : System.Any_Priority := Default_Ceiling) - with Priority => Ceiling is new Queue_Interfaces.Queue with + with + Priority => Ceiling + is new Queue_Interfaces.Queue with - overriding - entry Enqueue (New_Item : Queue_Interfaces.Element_Type); + overriding entry Enqueue (New_Item : Queue_Interfaces.Element_Type); - overriding - entry Dequeue (Element : out Queue_Interfaces.Element_Type); + overriding entry Dequeue (Element : out Queue_Interfaces.Element_Type); -- The priority queue operation Dequeue_Only_High_Priority had been a -- protected entry in early drafts of AI05-0159, but it was discovered @@ -116,22 +116,17 @@ package Ada.Containers.Bounded_Priority_Queues is -- ARG meeting in Edinburgh (June 2011), with a different signature and -- semantics. - not overriding procedure Dequeue_Only_High_Priority (At_Least : Queue_Priority; Element : in out Queue_Interfaces.Element_Type; Success : out Boolean); - overriding - function Current_Use return Count_Type; + overriding function Current_Use return Count_Type; - overriding - function Peak_Use return Count_Type; + overriding function Peak_Use return Count_Type; private - List : Implementation.List_Type (Capacity); - end Queue; end Ada.Containers.Bounded_Priority_Queues; diff --git a/gcc/ada/a-cbsyqu.ads b/gcc/ada/a-cbsyqu.ads index 0d6e3c39958..908463906ce 100644 --- a/gcc/ada/a-cbsyqu.ads +++ b/gcc/ada/a-cbsyqu.ads @@ -6,7 +6,7 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 2011, Free Software Foundation, Inc. -- +-- Copyright (C) 2011-2013, Free Software Foundation, Inc. -- -- -- -- This specification is derived from the Ada Reference Manual for use with -- -- GNAT. The copyright notice above, and the license provisions that follow -- @@ -83,24 +83,20 @@ package Ada.Containers.Bounded_Synchronized_Queues is protected type Queue (Capacity : Count_Type := Default_Capacity; Ceiling : System.Any_Priority := Default_Ceiling) - with Priority => Ceiling is new Queue_Interfaces.Queue with + with + Priority => Ceiling + is new Queue_Interfaces.Queue with - overriding - entry Enqueue (New_Item : Queue_Interfaces.Element_Type); + overriding entry Enqueue (New_Item : Queue_Interfaces.Element_Type); - overriding - entry Dequeue (Element : out Queue_Interfaces.Element_Type); + overriding entry Dequeue (Element : out Queue_Interfaces.Element_Type); - overriding - function Current_Use return Count_Type; + overriding function Current_Use return Count_Type; - overriding - function Peak_Use return Count_Type; + overriding function Peak_Use return Count_Type; private - List : Implementation.List_Type (Capacity); - end Queue; end Ada.Containers.Bounded_Synchronized_Queues; diff --git a/gcc/ada/a-cfdlli.ads b/gcc/ada/a-cfdlli.ads index 1078c1f5a34..bfa8ffbcb90 100644 --- a/gcc/ada/a-cfdlli.ads +++ b/gcc/ada/a-cfdlli.ads @@ -78,52 +78,78 @@ package Ada.Containers.Formal_Doubly_Linked_Lists is procedure Clear (Container : in out List); - procedure Assign (Target : in out List; Source : List); + procedure Assign (Target : in out List; Source : List) with + Pre => Target.Capacity >= Length (Source); function Copy (Source : List; Capacity : Count_Type := 0) return List; - function Element (Container : List; Position : Cursor) return Element_Type; + function Element + (Container : List; + Position : Cursor) return Element_Type + with + Pre => Has_Element (Container, Position); procedure Replace_Element (Container : in out List; Position : Cursor; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Has_Element (Container, Position); - procedure Move (Target : in out List; Source : in out List); + procedure Move (Target : in out List; Source : in out List) with + Pre => Target.Capacity >= Length (Source); procedure Insert (Container : in out List; Before : Cursor; New_Item : Element_Type; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => Length (Container) + Count <= Container.Capacity + and then (Has_Element (Container, Before) + or else Before = No_Element); procedure Insert (Container : in out List; Before : Cursor; New_Item : Element_Type; Position : out Cursor; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => Length (Container) + Count <= Container.Capacity + and then (Has_Element (Container, Before) + or else Before = No_Element); procedure Insert (Container : in out List; Before : Cursor; Position : out Cursor; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => Length (Container) + Count <= Container.Capacity + and then (Has_Element (Container, Before) + or else Before = No_Element); procedure Prepend (Container : in out List; New_Item : Element_Type; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => Length (Container) + Count <= Container.Capacity; procedure Append (Container : in out List; New_Item : Element_Type; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => Length (Container) + Count <= Container.Capacity; procedure Delete (Container : in out List; Position : in out Cursor; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => Has_Element (Container, Position); procedure Delete_First (Container : in out List; @@ -137,53 +163,81 @@ package Ada.Containers.Formal_Doubly_Linked_Lists is procedure Swap (Container : in out List; - I, J : Cursor); + I, J : Cursor) + with + Pre => Has_Element (Container, I) and then Has_Element (Container, J); procedure Swap_Links (Container : in out List; - I, J : Cursor); + I, J : Cursor) + with + Pre => Has_Element (Container, I) and then Has_Element (Container, J); procedure Splice (Target : in out List; Before : Cursor; - Source : in out List); + Source : in out List) + with + Pre => Length (Source) + Length (Target) <= Target.Capacity + and then (Has_Element (Target, Before) + or else Before = No_Element); procedure Splice (Target : in out List; Before : Cursor; Source : in out List; - Position : in out Cursor); + Position : in out Cursor) + with + Pre => Length (Source) + Length (Target) <= Target.Capacity + and then (Has_Element (Target, Before) + or else Before = No_Element) + and then Has_Element (Source, Position); procedure Splice (Container : in out List; Before : Cursor; - Position : Cursor); + Position : Cursor) + with + Pre => 2 * Length (Container) <= Container.Capacity + and then (Has_Element (Container, Before) + or else Before = No_Element) + and then Has_Element (Container, Position); function First (Container : List) return Cursor; - function First_Element (Container : List) return Element_Type; + function First_Element (Container : List) return Element_Type with + Pre => not Is_Empty (Container); function Last (Container : List) return Cursor; - function Last_Element (Container : List) return Element_Type; + function Last_Element (Container : List) return Element_Type with + Pre => not Is_Empty (Container); - function Next (Container : List; Position : Cursor) return Cursor; + function Next (Container : List; Position : Cursor) return Cursor with + Pre => Has_Element (Container, Position) or else Position = No_Element; - procedure Next (Container : List; Position : in out Cursor); + procedure Next (Container : List; Position : in out Cursor) with + Pre => Has_Element (Container, Position) or else Position = No_Element; - function Previous (Container : List; Position : Cursor) return Cursor; + function Previous (Container : List; Position : Cursor) return Cursor with + Pre => Has_Element (Container, Position) or else Position = No_Element; - procedure Previous (Container : List; Position : in out Cursor); + procedure Previous (Container : List; Position : in out Cursor) with + Pre => Has_Element (Container, Position) or else Position = No_Element; function Find (Container : List; Item : Element_Type; - Position : Cursor := No_Element) return Cursor; + Position : Cursor := No_Element) return Cursor + with + Pre => Has_Element (Container, Position) or else Position = No_Element; function Reverse_Find (Container : List; Item : Element_Type; - Position : Cursor := No_Element) return Cursor; + Position : Cursor := No_Element) return Cursor + with + Pre => Has_Element (Container, Position) or else Position = No_Element; function Contains (Container : List; @@ -208,8 +262,10 @@ package Ada.Containers.Formal_Doubly_Linked_Lists is -- they are structurally equal (function "=" returns True) and that they -- have the same set of cursors. - function Left (Container : List; Position : Cursor) return List; - function Right (Container : List; Position : Cursor) return List; + function Left (Container : List; Position : Cursor) return List with + Pre => Has_Element (Container, Position) or else Position = No_Element; + function Right (Container : List; Position : Cursor) return List with + Pre => Has_Element (Container, Position) or else Position = No_Element; -- Left returns a container containing all elements preceding Position -- (excluded) in Container. Right returns a container containing all -- elements following Position (included) in Container. These two new diff --git a/gcc/ada/a-cfhama.adb b/gcc/ada/a-cfhama.adb index fc5c986ec2a..3ab4af23e78 100644 --- a/gcc/ada/a-cfhama.adb +++ b/gcc/ada/a-cfhama.adb @@ -488,7 +488,6 @@ package body Ada.Containers.Formal_Hashed_Maps is Insert (Container, Key, New_Item, Position, Inserted); if not Inserted then - declare N : Node_Type renames Container.Nodes (Position.Node); begin diff --git a/gcc/ada/a-cfhama.ads b/gcc/ada/a-cfhama.ads index fdbd7a0a8a4..93a47c56817 100644 --- a/gcc/ada/a-cfhama.ads +++ b/gcc/ada/a-cfhama.ads @@ -64,7 +64,7 @@ generic package Ada.Containers.Formal_Hashed_Maps is pragma Pure; - type Map (Capacity : Count_Type; Modulus : Hash_Type) is tagged private; + type Map (Capacity : Count_Type; Modulus : Hash_Type) is private; pragma Preelaborable_Initialization (Map); type Cursor is private; @@ -80,7 +80,9 @@ package Ada.Containers.Formal_Hashed_Maps is procedure Reserve_Capacity (Container : in out Map; - Capacity : Count_Type); + Capacity : Count_Type) + with + Pre => Capacity <= Container.Capacity; function Length (Container : Map) return Count_Type; @@ -88,67 +90,91 @@ package Ada.Containers.Formal_Hashed_Maps is procedure Clear (Container : in out Map); - procedure Assign (Target : in out Map; Source : Map); + procedure Assign (Target : in out Map; Source : Map) with + Pre => Target.Capacity >= Length (Source); - -- Copy returns a container stricty equal to Source - -- It must have the same cursors associated to each element - -- Therefore: - -- - capacity=0 means use container.capacity as cap of tgt - -- - the modulus cannot be changed. function Copy (Source : Map; - Capacity : Count_Type := 0) return Map; + Capacity : Count_Type := 0) return Map + with + Pre => Capacity >= Source.Capacity; + -- Copy returns a container stricty equal to Source. It must have + -- the same cursors associated with each element. Therefore: + -- - capacity=0 means use container.capacity as capacity of target + -- - the modulus cannot be changed. - function Key (Container : Map; Position : Cursor) return Key_Type; + function Key (Container : Map; Position : Cursor) return Key_Type with + Pre => Has_Element (Container, Position); - function Element (Container : Map; Position : Cursor) return Element_Type; + function Element + (Container : Map; + Position : Cursor) return Element_Type + with + Pre => Has_Element (Container, Position); procedure Replace_Element (Container : in out Map; Position : Cursor; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Has_Element (Container, Position); - procedure Move (Target : in out Map; Source : in out Map); + procedure Move (Target : in out Map; Source : in out Map) with + Pre => Target.Capacity >= Length (Source); procedure Insert (Container : in out Map; Key : Key_Type; New_Item : Element_Type; Position : out Cursor; - Inserted : out Boolean); + Inserted : out Boolean) + with + Pre => Length (Container) < Container.Capacity; procedure Insert (Container : in out Map; Key : Key_Type; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Length (Container) < Container.Capacity + and then (not Contains (Container, Key)); procedure Include (Container : in out Map; Key : Key_Type; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Length (Container) < Container.Capacity; procedure Replace (Container : in out Map; Key : Key_Type; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Contains (Container, Key); procedure Exclude (Container : in out Map; Key : Key_Type); - procedure Delete (Container : in out Map; Key : Key_Type); + procedure Delete (Container : in out Map; Key : Key_Type) with + Pre => Contains (Container, Key); - procedure Delete (Container : in out Map; Position : in out Cursor); + procedure Delete (Container : in out Map; Position : in out Cursor) with + Pre => Has_Element (Container, Position); function First (Container : Map) return Cursor; - function Next (Container : Map; Position : Cursor) return Cursor; + function Next (Container : Map; Position : Cursor) return Cursor with + Pre => Has_Element (Container, Position) or else Position = No_Element; - procedure Next (Container : Map; Position : in out Cursor); + procedure Next (Container : Map; Position : in out Cursor) with + Pre => Has_Element (Container, Position) or else Position = No_Element; function Find (Container : Map; Key : Key_Type) return Cursor; function Contains (Container : Map; Key : Key_Type) return Boolean; - function Element (Container : Map; Key : Key_Type) return Element_Type; + function Element (Container : Map; Key : Key_Type) return Element_Type with + Pre => Contains (Container, Key); function Has_Element (Container : Map; Position : Cursor) return Boolean; @@ -175,8 +201,10 @@ package Ada.Containers.Formal_Hashed_Maps is -- they are structurally equal (function "=" returns True) and that they -- have the same set of cursors. - function Left (Container : Map; Position : Cursor) return Map; - function Right (Container : Map; Position : Cursor) return Map; + function Left (Container : Map; Position : Cursor) return Map with + Pre => Has_Element (Container, Position) or else Position = No_Element; + function Right (Container : Map; Position : Cursor) return Map with + Pre => Has_Element (Container, Position) or else Position = No_Element; -- Left returns a container containing all elements preceding Position -- (excluded) in Container. Right returns a container containing all -- elements following Position (included) in Container. These two new diff --git a/gcc/ada/a-cfhase.adb b/gcc/ada/a-cfhase.adb index 539a0a88fe6..451ec32a886 100644 --- a/gcc/ada/a-cfhase.adb +++ b/gcc/ada/a-cfhase.adb @@ -687,7 +687,6 @@ package body Ada.Containers.Formal_Hashed_Sets is Insert (Container, New_Item, Position, Inserted); if not Inserted then - Container.Nodes (Position.Node).Element := New_Item; end if; end Include; diff --git a/gcc/ada/a-cfhase.ads b/gcc/ada/a-cfhase.ads index a9278dcdbf0..22bfda97e89 100644 --- a/gcc/ada/a-cfhase.ads +++ b/gcc/ada/a-cfhase.ads @@ -66,7 +66,7 @@ generic package Ada.Containers.Formal_Hashed_Sets is pragma Pure; - type Set (Capacity : Count_Type; Modulus : Hash_Type) is tagged private; + type Set (Capacity : Count_Type; Modulus : Hash_Type) is private; pragma Preelaborable_Initialization (Set); type Cursor is private; @@ -86,7 +86,9 @@ package Ada.Containers.Formal_Hashed_Sets is procedure Reserve_Capacity (Container : in out Set; - Capacity : Count_Type); + Capacity : Count_Type) + with + Pre => Capacity <= Container.Capacity; function Length (Container : Set) return Count_Type; @@ -94,39 +96,60 @@ package Ada.Containers.Formal_Hashed_Sets is procedure Clear (Container : in out Set); - procedure Assign (Target : in out Set; Source : Set); + procedure Assign (Target : in out Set; Source : Set) with + Pre => Target.Capacity >= Length (Source); - function Copy (Source : Set; - Capacity : Count_Type := 0) return Set; + function Copy + (Source : Set; + Capacity : Count_Type := 0) return Set + with + Pre => Capacity >= Source.Capacity; - function Element (Container : Set; Position : Cursor) return Element_Type; + function Element + (Container : Set; + Position : Cursor) return Element_Type + with + Pre => Has_Element (Container, Position); procedure Replace_Element (Container : in out Set; Position : Cursor; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Has_Element (Container, Position); - procedure Move (Target : in out Set; Source : in out Set); + procedure Move (Target : in out Set; Source : in out Set) with + Pre => Target.Capacity >= Length (Source); procedure Insert (Container : in out Set; New_Item : Element_Type; Position : out Cursor; - Inserted : out Boolean); + Inserted : out Boolean) + with + Pre => Length (Container) < Container.Capacity; - procedure Insert (Container : in out Set; New_Item : Element_Type); + procedure Insert (Container : in out Set; New_Item : Element_Type) with + Pre => Length (Container) < Container.Capacity + and then (not Contains (Container, New_Item)); - procedure Include (Container : in out Set; New_Item : Element_Type); + procedure Include (Container : in out Set; New_Item : Element_Type) with + Pre => Length (Container) < Container.Capacity; - procedure Replace (Container : in out Set; New_Item : Element_Type); + procedure Replace (Container : in out Set; New_Item : Element_Type) with + Pre => Contains (Container, New_Item); procedure Exclude (Container : in out Set; Item : Element_Type); - procedure Delete (Container : in out Set; Item : Element_Type); + procedure Delete (Container : in out Set; Item : Element_Type) with + Pre => Contains (Container, Item); - procedure Delete (Container : in out Set; Position : in out Cursor); + procedure Delete (Container : in out Set; Position : in out Cursor) with + Pre => Has_Element (Container, Position); - procedure Union (Target : in out Set; Source : Set); + procedure Union (Target : in out Set; Source : Set) with + Pre => Length (Target) + Length (Source) - + Length (Intersection (Target, Source)) <= Target.Capacity; function Union (Left, Right : Set) return Set; @@ -149,7 +172,7 @@ package Ada.Containers.Formal_Hashed_Sets is function Symmetric_Difference (Left, Right : Set) return Set; function "xor" (Left, Right : Set) return Set - renames Symmetric_Difference; + renames Symmetric_Difference; function Overlap (Left, Right : Set) return Boolean; @@ -157,9 +180,11 @@ package Ada.Containers.Formal_Hashed_Sets is function First (Container : Set) return Cursor; - function Next (Container : Set; Position : Cursor) return Cursor; + function Next (Container : Set; Position : Cursor) return Cursor with + Pre => Has_Element (Container, Position) or else Position = No_Element; - procedure Next (Container : Set; Position : in out Cursor); + procedure Next (Container : Set; Position : in out Cursor) with + Pre => Has_Element (Container, Position) or else Position = No_Element; function Find (Container : Set; @@ -217,8 +242,10 @@ package Ada.Containers.Formal_Hashed_Sets is -- they are structurally equal (function "=" returns True) and that they -- have the same set of cursors. - function Left (Container : Set; Position : Cursor) return Set; - function Right (Container : Set; Position : Cursor) return Set; + function Left (Container : Set; Position : Cursor) return Set with + Pre => Has_Element (Container, Position) or else Position = No_Element; + function Right (Container : Set; Position : Cursor) return Set with + Pre => Has_Element (Container, Position) or else Position = No_Element; -- Left returns a container containing all elements preceding Position -- (excluded) in Container. Right returns a container containing all -- elements following Position (included) in Container. These two new diff --git a/gcc/ada/a-cforma.ads b/gcc/ada/a-cforma.ads index c96fee02d51..8e323e19dfb 100644 --- a/gcc/ada/a-cforma.ads +++ b/gcc/ada/a-cforma.ads @@ -67,7 +67,7 @@ package Ada.Containers.Formal_Ordered_Maps is function Equivalent_Keys (Left, Right : Key_Type) return Boolean; - type Map (Capacity : Count_Type) is tagged private; + type Map (Capacity : Count_Type) is private; pragma Preelaborable_Initialization (Map); type Cursor is private; @@ -85,48 +85,69 @@ package Ada.Containers.Formal_Ordered_Maps is procedure Clear (Container : in out Map); - procedure Assign (Target : in out Map; Source : Map); + procedure Assign (Target : in out Map; Source : Map) with + Pre => Target.Capacity >= Length (Source); - function Copy (Source : Map; Capacity : Count_Type := 0) return Map; + function Copy (Source : Map; Capacity : Count_Type := 0) return Map with + Pre => Capacity >= Source.Capacity; - function Key (Container : Map; Position : Cursor) return Key_Type; + function Key (Container : Map; Position : Cursor) return Key_Type with + Pre => Has_Element (Container, Position); - function Element (Container : Map; Position : Cursor) return Element_Type; + function Element + (Container : Map; + Position : Cursor) return Element_Type + with + Pre => Has_Element (Container, Position); procedure Replace_Element (Container : in out Map; Position : Cursor; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Has_Element (Container, Position); - procedure Move (Target : in out Map; Source : in out Map); + procedure Move (Target : in out Map; Source : in out Map) with + Pre => Target.Capacity >= Length (Source); procedure Insert (Container : in out Map; Key : Key_Type; New_Item : Element_Type; Position : out Cursor; - Inserted : out Boolean); + Inserted : out Boolean) + with + Pre => Length (Container) < Container.Capacity; procedure Insert (Container : in out Map; Key : Key_Type; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Length (Container) < Container.Capacity + and then (not Contains (Container, Key)); procedure Include (Container : in out Map; Key : Key_Type; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Length (Container) < Container.Capacity; procedure Replace (Container : in out Map; Key : Key_Type; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Contains (Container, Key); procedure Exclude (Container : in out Map; Key : Key_Type); - procedure Delete (Container : in out Map; Key : Key_Type); + procedure Delete (Container : in out Map; Key : Key_Type) with + Pre => Contains (Container, Key); - procedure Delete (Container : in out Map; Position : in out Cursor); + procedure Delete (Container : in out Map; Position : in out Cursor) with + Pre => Has_Element (Container, Position); procedure Delete_First (Container : in out Map); @@ -134,27 +155,36 @@ package Ada.Containers.Formal_Ordered_Maps is function First (Container : Map) return Cursor; - function First_Element (Container : Map) return Element_Type; + function First_Element (Container : Map) return Element_Type with + Pre => not Is_Empty (Container); - function First_Key (Container : Map) return Key_Type; + function First_Key (Container : Map) return Key_Type with + Pre => not Is_Empty (Container); function Last (Container : Map) return Cursor; - function Last_Element (Container : Map) return Element_Type; + function Last_Element (Container : Map) return Element_Type with + Pre => not Is_Empty (Container); - function Last_Key (Container : Map) return Key_Type; + function Last_Key (Container : Map) return Key_Type with + Pre => not Is_Empty (Container); - function Next (Container : Map; Position : Cursor) return Cursor; + function Next (Container : Map; Position : Cursor) return Cursor with + Pre => Has_Element (Container, Position) or else Position = No_Element; - procedure Next (Container : Map; Position : in out Cursor); + procedure Next (Container : Map; Position : in out Cursor) with + Pre => Has_Element (Container, Position) or else Position = No_Element; - function Previous (Container : Map; Position : Cursor) return Cursor; + function Previous (Container : Map; Position : Cursor) return Cursor with + Pre => Has_Element (Container, Position) or else Position = No_Element; - procedure Previous (Container : Map; Position : in out Cursor); + procedure Previous (Container : Map; Position : in out Cursor) with + Pre => Has_Element (Container, Position) or else Position = No_Element; function Find (Container : Map; Key : Key_Type) return Cursor; - function Element (Container : Map; Key : Key_Type) return Element_Type; + function Element (Container : Map; Key : Key_Type) return Element_Type with + Pre => Contains (Container, Key); function Floor (Container : Map; Key : Key_Type) return Cursor; @@ -169,8 +199,10 @@ package Ada.Containers.Formal_Ordered_Maps is -- they are structurally equal (function "=" returns True) and that they -- have the same set of cursors. - function Left (Container : Map; Position : Cursor) return Map; - function Right (Container : Map; Position : Cursor) return Map; + function Left (Container : Map; Position : Cursor) return Map with + Pre => Has_Element (Container, Position) or else Position = No_Element; + function Right (Container : Map; Position : Cursor) return Map with + Pre => Has_Element (Container, Position) or else Position = No_Element; -- Left returns a container containing all elements preceding Position -- (excluded) in Container. Right returns a container containing all -- elements following Position (included) in Container. These two new diff --git a/gcc/ada/a-cforse.ads b/gcc/ada/a-cforse.ads index 77862a6df34..35e4613b9a8 100644 --- a/gcc/ada/a-cforse.ads +++ b/gcc/ada/a-cforse.ads @@ -65,9 +65,8 @@ package Ada.Containers.Formal_Ordered_Sets is function Equivalent_Elements (Left, Right : Element_Type) return Boolean; - type Set (Capacity : Count_Type) is tagged private; - -- why is this commented out ??? - -- pragma Preelaborable_Initialization (Set); + type Set (Capacity : Count_Type) is private; + pragma Preelaborable_Initialization (Set); type Cursor is private; pragma Preelaborable_Initialization (Cursor); @@ -88,36 +87,54 @@ package Ada.Containers.Formal_Ordered_Sets is procedure Clear (Container : in out Set); - procedure Assign (Target : in out Set; Source : Set); + procedure Assign (Target : in out Set; Source : Set) with + Pre => Target.Capacity >= Length (Source); - function Copy (Source : Set; Capacity : Count_Type := 0) return Set; + function Copy (Source : Set; Capacity : Count_Type := 0) return Set with + Pre => Capacity >= Source.Capacity; - function Element (Container : Set; Position : Cursor) return Element_Type; + function Element + (Container : Set; + Position : Cursor) return Element_Type + with + Pre => Has_Element (Container, Position); procedure Replace_Element (Container : in out Set; Position : Cursor; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Has_Element (Container, Position); - procedure Move (Target : in out Set; Source : in out Set); + procedure Move (Target : in out Set; Source : in out Set) with + Pre => Target.Capacity >= Length (Source); procedure Insert (Container : in out Set; New_Item : Element_Type; Position : out Cursor; - Inserted : out Boolean); + Inserted : out Boolean) + with + Pre => Length (Container) < Container.Capacity; procedure Insert (Container : in out Set; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Length (Container) < Container.Capacity + and then (not Contains (Container, New_Item)); procedure Include (Container : in out Set; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Length (Container) < Container.Capacity; procedure Replace (Container : in out Set; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Contains (Container, New_Item); procedure Exclude (Container : in out Set; @@ -125,17 +142,23 @@ package Ada.Containers.Formal_Ordered_Sets is procedure Delete (Container : in out Set; - Item : Element_Type); + Item : Element_Type) + with + Pre => Contains (Container, Item); procedure Delete (Container : in out Set; - Position : in out Cursor); + Position : in out Cursor) + with + Pre => Has_Element (Container, Position); procedure Delete_First (Container : in out Set); procedure Delete_Last (Container : in out Set); - procedure Union (Target : in out Set; Source : Set); + procedure Union (Target : in out Set; Source : Set) with + Pre => Length (Target) + Length (Source) - + Length (Intersection (Target, Source)) <= Target.Capacity; function Union (Left, Right : Set) return Set; @@ -165,19 +188,25 @@ package Ada.Containers.Formal_Ordered_Sets is function First (Container : Set) return Cursor; - function First_Element (Container : Set) return Element_Type; + function First_Element (Container : Set) return Element_Type with + Pre => not Is_Empty (Container); function Last (Container : Set) return Cursor; - function Last_Element (Container : Set) return Element_Type; + function Last_Element (Container : Set) return Element_Type with + Pre => not Is_Empty (Container); - function Next (Container : Set; Position : Cursor) return Cursor; + function Next (Container : Set; Position : Cursor) return Cursor with + Pre => Has_Element (Container, Position) or else Position = No_Element; - procedure Next (Container : Set; Position : in out Cursor); + procedure Next (Container : Set; Position : in out Cursor) with + Pre => Has_Element (Container, Position) or else Position = No_Element; - function Previous (Container : Set; Position : Cursor) return Cursor; + function Previous (Container : Set; Position : Cursor) return Cursor with + Pre => Has_Element (Container, Position) or else Position = No_Element; - procedure Previous (Container : Set; Position : in out Cursor); + procedure Previous (Container : Set; Position : in out Cursor) with + Pre => Has_Element (Container, Position) or else Position = No_Element; function Find (Container : Set; Item : Element_Type) return Cursor; @@ -228,8 +257,10 @@ package Ada.Containers.Formal_Ordered_Sets is -- they are structurally equal (function "=" returns True) and that they -- have the same set of cursors. - function Left (Container : Set; Position : Cursor) return Set; - function Right (Container : Set; Position : Cursor) return Set; + function Left (Container : Set; Position : Cursor) return Set with + Pre => Has_Element (Container, Position) or else Position = No_Element; + function Right (Container : Set; Position : Cursor) return Set with + Pre => Has_Element (Container, Position) or else Position = No_Element; -- Left returns a container containing all elements preceding Position -- (excluded) in Container. Right returns a container containing all -- elements following Position (included) in Container. These two new diff --git a/gcc/ada/a-cofove.adb b/gcc/ada/a-cofove.adb index 69de29db5d4..240715dca75 100644 --- a/gcc/ada/a-cofove.adb +++ b/gcc/ada/a-cofove.adb @@ -251,7 +251,7 @@ package body Ada.Containers.Formal_Vectors is raise Constraint_Error; end if; - Target.Clear; + Clear (Target); Target.Elements (1 .. LS) := Source.Elements (1 .. LS); Target.Last := Source.Last; @@ -641,10 +641,10 @@ package body Ada.Containers.Formal_Vectors is -- I think we're missing this check in a-convec.adb... ??? I := Length (Target); - Target.Set_Length (I + Length (Source)); + Set_Length (Target, I + Length (Source)); J := Length (Target); - while not Source.Is_Empty loop + while not Is_Empty (Source) loop pragma Assert (Length (Source) <= 1 or else not (SA (Length (Source)) < SA (Length (Source) - 1))); @@ -1487,20 +1487,20 @@ package body Ada.Containers.Formal_Vectors is procedure Set_Length (Container : in out Vector; - Length : Count_Type) + New_Length : Count_Type) is begin - if Length = Formal_Vectors.Length (Container) then + if New_Length = Formal_Vectors.Length (Container) then return; end if; - if Length > Container.Capacity then + if New_Length > Container.Capacity then raise Constraint_Error; -- ??? end if; declare Last_As_Int : constant Int'Base := - Int (Index_Type'First) + Int (Length) - 1; + Int (Index_Type'First) + Int (New_Length) - 1; begin Container.Last := Index_Type'Base (Last_As_Int); end; diff --git a/gcc/ada/a-cofove.ads b/gcc/ada/a-cofove.ads index 4d943837b82..9ca84da460f 100644 --- a/gcc/ada/a-cofove.ads +++ b/gcc/ada/a-cofove.ads @@ -73,7 +73,7 @@ package Ada.Containers.Formal_Vectors is No_Index : constant Extended_Index := Extended_Index'First; - type Vector (Capacity : Count_Type) is tagged private; + type Vector (Capacity : Count_Type) is private; type Cursor is private; pragma Preelaborable_Initialization (Cursor); @@ -100,23 +100,30 @@ package Ada.Containers.Formal_Vectors is procedure Reserve_Capacity (Container : in out Vector; - Capacity : Count_Type); + Capacity : Count_Type) + with + Pre => Capacity <= Container.Capacity; function Length (Container : Vector) return Count_Type; procedure Set_Length (Container : in out Vector; - Length : Count_Type); + New_Length : Count_Type) + with + Pre => New_Length <= Length (Container); function Is_Empty (Container : Vector) return Boolean; procedure Clear (Container : in out Vector); - procedure Assign (Target : in out Vector; Source : Vector); + procedure Assign (Target : in out Vector; Source : Vector) with + Pre => Length (Source) <= Target.Capacity; function Copy (Source : Vector; - Capacity : Count_Type := 0) return Vector; + Capacity : Count_Type := 0) return Vector + with + Pre => Length (Source) <= Capacity; function To_Cursor (Container : Vector; @@ -126,86 +133,134 @@ package Ada.Containers.Formal_Vectors is function Element (Container : Vector; - Index : Index_Type) return Element_Type; + Index : Index_Type) return Element_Type + with + Pre => First_Index (Container) <= Index + and then Index <= Last_Index (Container); function Element (Container : Vector; - Position : Cursor) return Element_Type; + Position : Cursor) return Element_Type + with + Pre => Has_Element (Container, Position); procedure Replace_Element (Container : in out Vector; Index : Index_Type; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => First_Index (Container) <= Index + and then Index <= Last_Index (Container); procedure Replace_Element (Container : in out Vector; Position : Cursor; - New_Item : Element_Type); + New_Item : Element_Type) + with + Pre => Has_Element (Container, Position); - procedure Move (Target : in out Vector; Source : in out Vector); + procedure Move (Target : in out Vector; Source : in out Vector) with + Pre => Length (Source) <= Target.Capacity; procedure Insert (Container : in out Vector; Before : Extended_Index; - New_Item : Vector); + New_Item : Vector) + with + Pre => First_Index (Container) <= Before + and then Before <= Last_Index (Container) + 1 + and then Length (Container) < Container.Capacity; procedure Insert (Container : in out Vector; Before : Cursor; - New_Item : Vector); + New_Item : Vector) + with + Pre => Length (Container) < Container.Capacity + and then (Has_Element (Container, Before) + or else Before = No_Element); procedure Insert (Container : in out Vector; Before : Cursor; New_Item : Vector; - Position : out Cursor); + Position : out Cursor) + with + Pre => Length (Container) < Container.Capacity + and then (Has_Element (Container, Before) + or else Before = No_Element); procedure Insert (Container : in out Vector; Before : Extended_Index; New_Item : Element_Type; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => First_Index (Container) <= Before + and then Before <= Last_Index (Container) + 1 + and then Length (Container) + Count <= Container.Capacity; procedure Insert (Container : in out Vector; Before : Cursor; New_Item : Element_Type; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => Length (Container) + Count <= Container.Capacity + and then (Has_Element (Container, Before) + or else Before = No_Element); procedure Insert (Container : in out Vector; Before : Cursor; New_Item : Element_Type; Position : out Cursor; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => Length (Container) + Count <= Container.Capacity + and then (Has_Element (Container, Before) + or else Before = No_Element); procedure Prepend (Container : in out Vector; - New_Item : Vector); + New_Item : Vector) + with + Pre => Length (Container) < Container.Capacity; procedure Prepend (Container : in out Vector; New_Item : Element_Type; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => Length (Container) + Count <= Container.Capacity; procedure Append (Container : in out Vector; - New_Item : Vector); + New_Item : Vector) + with + Pre => Length (Container) < Container.Capacity; procedure Append (Container : in out Vector; New_Item : Element_Type; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => Length (Container) + Count <= Container.Capacity; procedure Delete (Container : in out Vector; Index : Extended_Index; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => First_Index (Container) <= Index + and then Index <= Last_Index (Container) + 1; procedure Delete (Container : in out Vector; Position : in out Cursor; - Count : Count_Type := 1); + Count : Count_Type := 1) + with + Pre => Has_Element (Container, Position); procedure Delete_First (Container : in out Vector; @@ -217,29 +272,39 @@ package Ada.Containers.Formal_Vectors is procedure Reverse_Elements (Container : in out Vector); - procedure Swap (Container : in out Vector; I, J : Index_Type); + procedure Swap (Container : in out Vector; I, J : Index_Type) with + Pre => First_Index (Container) <= I and then I <= Last_Index (Container) + and then First_Index (Container) <= J + and then J <= Last_Index (Container); - procedure Swap (Container : in out Vector; I, J : Cursor); + procedure Swap (Container : in out Vector; I, J : Cursor) with + Pre => Has_Element (Container, I) and then Has_Element (Container, J); function First_Index (Container : Vector) return Index_Type; function First (Container : Vector) return Cursor; - function First_Element (Container : Vector) return Element_Type; + function First_Element (Container : Vector) return Element_Type with + Pre => not Is_Empty (Container); function Last_Index (Container : Vector) return Extended_Index; function Last (Container : Vector) return Cursor; - function Last_Element (Container : Vector) return Element_Type; + function Last_Element (Container : Vector) return Element_Type with + Pre => not Is_Empty (Container); - function Next (Container : Vector; Position : Cursor) return Cursor; + function Next (Container : Vector; Position : Cursor) return Cursor with + Pre => Has_Element (Container, Position) or else Position = No_Element; - procedure Next (Container : Vector; Position : in out Cursor); + procedure Next (Container : Vector; Position : in out Cursor) with + Pre => Has_Element (Container, Position) or else Position = No_Element; - function Previous (Container : Vector; Position : Cursor) return Cursor; + function Previous (Container : Vector; Position : Cursor) return Cursor with + Pre => Has_Element (Container, Position) or else Position = No_Element; - procedure Previous (Container : Vector; Position : in out Cursor); + procedure Previous (Container : Vector; Position : in out Cursor) with + Pre => Has_Element (Container, Position) or else Position = No_Element; function Find_Index (Container : Vector; @@ -249,7 +314,9 @@ package Ada.Containers.Formal_Vectors is function Find (Container : Vector; Item : Element_Type; - Position : Cursor := No_Element) return Cursor; + Position : Cursor := No_Element) return Cursor + with + Pre => Has_Element (Container, Position) or else Position = No_Element; function Reverse_Find_Index (Container : Vector; @@ -259,7 +326,9 @@ package Ada.Containers.Formal_Vectors is function Reverse_Find (Container : Vector; Item : Element_Type; - Position : Cursor := No_Element) return Cursor; + Position : Cursor := No_Element) return Cursor + with + Pre => Has_Element (Container, Position) or else Position = No_Element; function Contains (Container : Vector; @@ -279,9 +348,11 @@ package Ada.Containers.Formal_Vectors is end Generic_Sorting; - function Left (Container : Vector; Position : Cursor) return Vector; + function Left (Container : Vector; Position : Cursor) return Vector with + Pre => Has_Element (Container, Position) or else Position = No_Element; - function Right (Container : Vector; Position : Cursor) return Vector; + function Right (Container : Vector; Position : Cursor) return Vector with + Pre => Has_Element (Container, Position) or else Position = No_Element; private @@ -298,7 +369,7 @@ private type Elements_Array is array (Count_Type range <>) of Element_Type; function "=" (L, R : Elements_Array) return Boolean is abstract; - type Vector (Capacity : Count_Type) is tagged record + type Vector (Capacity : Count_Type) is record Elements : Elements_Array (1 .. Capacity); Last : Extended_Index := No_Index; end record; diff --git a/gcc/ada/a-cuprqu.ads b/gcc/ada/a-cuprqu.ads index 3709f42aa29..4e11d6eef05 100644 --- a/gcc/ada/a-cuprqu.ads +++ b/gcc/ada/a-cuprqu.ads @@ -6,7 +6,7 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 2011, Free Software Foundation, Inc. -- +-- Copyright (C) 2011-2013, Free Software Foundation, Inc. -- -- -- -- This specification is derived from the Ada Reference Manual for use with -- -- GNAT. The copyright notice above, and the license provisions that follow -- @@ -94,19 +94,18 @@ package Ada.Containers.Unbounded_Priority_Queues is Max_Length : Count_Type := 0; end record; - overriding - procedure Finalize (List : in out List_Type); + overriding procedure Finalize (List : in out List_Type); end Implementation; protected type Queue (Ceiling : System.Any_Priority := Default_Ceiling) - with Priority => Ceiling is new Queue_Interfaces.Queue with + with + Priority => Ceiling + is new Queue_Interfaces.Queue with - overriding - entry Enqueue (New_Item : Queue_Interfaces.Element_Type); + overriding entry Enqueue (New_Item : Queue_Interfaces.Element_Type); - overriding - entry Dequeue (Element : out Queue_Interfaces.Element_Type); + overriding entry Dequeue (Element : out Queue_Interfaces.Element_Type); -- The priority queue operation Dequeue_Only_High_Priority had been a -- protected entry in early drafts of AI05-0159, but it was discovered @@ -115,22 +114,17 @@ package Ada.Containers.Unbounded_Priority_Queues is -- ARG meeting in Edinburgh (June 2011), with a different signature and -- semantics. - not overriding procedure Dequeue_Only_High_Priority (At_Least : Queue_Priority; Element : in out Queue_Interfaces.Element_Type; Success : out Boolean); - overriding - function Current_Use return Count_Type; + overriding function Current_Use return Count_Type; - overriding - function Peak_Use return Count_Type; + overriding function Peak_Use return Count_Type; private - List : Implementation.List_Type; - end Queue; end Ada.Containers.Unbounded_Priority_Queues; diff --git a/gcc/ada/a-cusyqu.ads b/gcc/ada/a-cusyqu.ads index c4f9d7f7d59..c4f18020356 100644 --- a/gcc/ada/a-cusyqu.ads +++ b/gcc/ada/a-cusyqu.ads @@ -6,7 +6,7 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 2011, Free Software Foundation, Inc. -- +-- Copyright (C) 2011-2013, Free Software Foundation, Inc. -- -- -- -- This specification is derived from the Ada Reference Manual for use with -- -- GNAT. The copyright notice above, and the license provisions that follow -- @@ -80,30 +80,26 @@ package Ada.Containers.Unbounded_Synchronized_Queues is Max_Length : Count_Type := 0; end record; - overriding - procedure Finalize (List : in out List_Type); + overriding procedure Finalize (List : in out List_Type); end Implementation; - protected type Queue (Ceiling : System.Any_Priority := Default_Ceiling) - with Priority => Ceiling is new Queue_Interfaces.Queue with + protected type Queue + (Ceiling : System.Any_Priority := Default_Ceiling) + with + Priority => Ceiling + is new Queue_Interfaces.Queue with - overriding - entry Enqueue (New_Item : Queue_Interfaces.Element_Type); + overriding entry Enqueue (New_Item : Queue_Interfaces.Element_Type); - overriding - entry Dequeue (Element : out Queue_Interfaces.Element_Type); + overriding entry Dequeue (Element : out Queue_Interfaces.Element_Type); - overriding - function Current_Use return Count_Type; + overriding function Current_Use return Count_Type; - overriding - function Peak_Use return Count_Type; + overriding function Peak_Use return Count_Type; private - List : Implementation.List_Type; - end Queue; end Ada.Containers.Unbounded_Synchronized_Queues; diff --git a/gcc/ada/a-except-2005.adb b/gcc/ada/a-except-2005.adb index fd3f04b115c..3453eae90ab 100644 --- a/gcc/ada/a-except-2005.adb +++ b/gcc/ada/a-except-2005.adb @@ -6,7 +6,7 @@ -- -- -- B o d y -- -- -- --- Copyright (C) 1992-2012, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- @@ -447,6 +447,8 @@ package body Ada.Exceptions is (File : System.Address; Line : Integer); procedure Rcheck_PE_Address_Of_Intrinsic (File : System.Address; Line : Integer); + procedure Rcheck_PE_Aliased_Parameters + (File : System.Address; Line : Integer); procedure Rcheck_PE_All_Guards_Closed (File : System.Address; Line : Integer); procedure Rcheck_PE_Bad_Predicated_Generic_Type @@ -532,6 +534,8 @@ package body Ada.Exceptions is "__gnat_rcheck_PE_Accessibility_Check"); pragma Export (C, Rcheck_PE_Address_Of_Intrinsic, "__gnat_rcheck_PE_Address_Of_Intrinsic"); + pragma Export (C, Rcheck_PE_Aliased_Parameters, + "__gnat_rcheck_PE_Aliased_Parameters"); pragma Export (C, Rcheck_PE_All_Guards_Closed, "__gnat_rcheck_PE_All_Guards_Closed"); pragma Export (C, Rcheck_PE_Bad_Predicated_Generic_Type, @@ -599,6 +603,7 @@ package body Ada.Exceptions is pragma No_Return (Rcheck_PE_Access_Before_Elaboration); pragma No_Return (Rcheck_PE_Accessibility_Check); pragma No_Return (Rcheck_PE_Address_Of_Intrinsic); + pragma No_Return (Rcheck_PE_Aliased_Parameters); pragma No_Return (Rcheck_PE_All_Guards_Closed); pragma No_Return (Rcheck_PE_Bad_Predicated_Generic_Type); pragma No_Return (Rcheck_PE_Current_Task_In_Entry_Body); @@ -650,27 +655,28 @@ package body Ada.Exceptions is Rmsg_15 : constant String := "accessibility check failed" & NUL; Rmsg_16 : constant String := "attempt to take address of" & " intrinsic subprogram" & NUL; - Rmsg_17 : constant String := "all guards closed" & NUL; - Rmsg_18 : constant String := "improper use of generic subtype" & + Rmsg_17 : constant String := "aliased parameters" & NUL; + Rmsg_18 : constant String := "all guards closed" & NUL; + Rmsg_19 : constant String := "improper use of generic subtype" & " with predicate" & NUL; - Rmsg_19 : constant String := "Current_Task referenced in entry" & + Rmsg_20 : constant String := "Current_Task referenced in entry" & " body" & NUL; - Rmsg_20 : constant String := "duplicated entry address" & NUL; - Rmsg_21 : constant String := "explicit raise" & NUL; - Rmsg_22 : constant String := "finalize/adjust raised exception" & NUL; - Rmsg_23 : constant String := "implicit return with No_Return" & NUL; - Rmsg_24 : constant String := "misaligned address value" & NUL; - Rmsg_25 : constant String := "missing return" & NUL; - Rmsg_26 : constant String := "overlaid controlled object" & NUL; - Rmsg_27 : constant String := "potentially blocking operation" & NUL; - Rmsg_28 : constant String := "stubbed subprogram called" & NUL; - Rmsg_29 : constant String := "unchecked union restriction" & NUL; - Rmsg_30 : constant String := "actual/returned class-wide" & + Rmsg_21 : constant String := "duplicated entry address" & NUL; + Rmsg_22 : constant String := "explicit raise" & NUL; + Rmsg_23 : constant String := "finalize/adjust raised exception" & NUL; + Rmsg_24 : constant String := "implicit return with No_Return" & NUL; + Rmsg_25 : constant String := "misaligned address value" & NUL; + Rmsg_26 : constant String := "missing return" & NUL; + Rmsg_27 : constant String := "overlaid controlled object" & NUL; + Rmsg_28 : constant String := "potentially blocking operation" & NUL; + Rmsg_29 : constant String := "stubbed subprogram called" & NUL; + Rmsg_30 : constant String := "unchecked union restriction" & NUL; + Rmsg_31 : constant String := "actual/returned class-wide" & " value not transportable" & NUL; - Rmsg_31 : constant String := "empty storage pool" & NUL; - Rmsg_32 : constant String := "explicit raise" & NUL; - Rmsg_33 : constant String := "infinite recursion" & NUL; - Rmsg_34 : constant String := "object too large" & NUL; + Rmsg_32 : constant String := "empty storage pool" & NUL; + Rmsg_33 : constant String := "explicit raise" & NUL; + Rmsg_34 : constant String := "infinite recursion" & NUL; + Rmsg_35 : constant String := "object too large" & NUL; ----------------------- -- Polling Interface -- @@ -1316,123 +1322,130 @@ package body Ada.Exceptions is Raise_Program_Error_Msg (File, Line, Rmsg_16'Address); end Rcheck_PE_Address_Of_Intrinsic; - procedure Rcheck_PE_All_Guards_Closed + procedure Rcheck_PE_Aliased_Parameters (File : System.Address; Line : Integer) is begin Raise_Program_Error_Msg (File, Line, Rmsg_17'Address); + end Rcheck_PE_Aliased_Parameters; + + procedure Rcheck_PE_All_Guards_Closed + (File : System.Address; Line : Integer) + is + begin + Raise_Program_Error_Msg (File, Line, Rmsg_18'Address); end Rcheck_PE_All_Guards_Closed; procedure Rcheck_PE_Bad_Predicated_Generic_Type (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_18'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_19'Address); end Rcheck_PE_Bad_Predicated_Generic_Type; procedure Rcheck_PE_Current_Task_In_Entry_Body (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_19'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_20'Address); end Rcheck_PE_Current_Task_In_Entry_Body; procedure Rcheck_PE_Duplicated_Entry_Address (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_20'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_21'Address); end Rcheck_PE_Duplicated_Entry_Address; procedure Rcheck_PE_Explicit_Raise (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_21'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_22'Address); end Rcheck_PE_Explicit_Raise; procedure Rcheck_PE_Implicit_Return (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_23'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_24'Address); end Rcheck_PE_Implicit_Return; procedure Rcheck_PE_Misaligned_Address_Value (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_24'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_25'Address); end Rcheck_PE_Misaligned_Address_Value; procedure Rcheck_PE_Missing_Return (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_25'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_26'Address); end Rcheck_PE_Missing_Return; procedure Rcheck_PE_Overlaid_Controlled_Object (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_26'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_27'Address); end Rcheck_PE_Overlaid_Controlled_Object; procedure Rcheck_PE_Potentially_Blocking_Operation (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_27'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_28'Address); end Rcheck_PE_Potentially_Blocking_Operation; procedure Rcheck_PE_Stubbed_Subprogram_Called (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_28'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_29'Address); end Rcheck_PE_Stubbed_Subprogram_Called; procedure Rcheck_PE_Unchecked_Union_Restriction (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_29'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_30'Address); end Rcheck_PE_Unchecked_Union_Restriction; procedure Rcheck_PE_Non_Transportable_Actual (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_30'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_31'Address); end Rcheck_PE_Non_Transportable_Actual; procedure Rcheck_SE_Empty_Storage_Pool (File : System.Address; Line : Integer) is begin - Raise_Storage_Error_Msg (File, Line, Rmsg_31'Address); + Raise_Storage_Error_Msg (File, Line, Rmsg_32'Address); end Rcheck_SE_Empty_Storage_Pool; procedure Rcheck_SE_Explicit_Raise (File : System.Address; Line : Integer) is begin - Raise_Storage_Error_Msg (File, Line, Rmsg_32'Address); + Raise_Storage_Error_Msg (File, Line, Rmsg_33'Address); end Rcheck_SE_Explicit_Raise; procedure Rcheck_SE_Infinite_Recursion (File : System.Address; Line : Integer) is begin - Raise_Storage_Error_Msg (File, Line, Rmsg_33'Address); + Raise_Storage_Error_Msg (File, Line, Rmsg_34'Address); end Rcheck_SE_Infinite_Recursion; procedure Rcheck_SE_Object_Too_Large (File : System.Address; Line : Integer) is begin - Raise_Storage_Error_Msg (File, Line, Rmsg_34'Address); + Raise_Storage_Error_Msg (File, Line, Rmsg_35'Address); end Rcheck_SE_Object_Too_Large; procedure Rcheck_CE_Access_Check_Ext @@ -1488,7 +1501,7 @@ package body Ada.Exceptions is -- This is consistent with Raise_From_Controlled_Operation Exception_Data.Set_Exception_C_Msg - (X, Program_Error_Def'Access, File, Line, 0, Rmsg_22'Address); + (X, Program_Error_Def'Access, File, Line, 0, Rmsg_23'Address); Complete_And_Propagate_Occurrence (X); end Rcheck_PE_Finalize_Raised_Exception; diff --git a/gcc/ada/a-except.adb b/gcc/ada/a-except.adb index 3dae9c4dda1..65687d72266 100644 --- a/gcc/ada/a-except.adb +++ b/gcc/ada/a-except.adb @@ -6,7 +6,7 @@ -- -- -- B o d y -- -- -- --- Copyright (C) 1992-2012, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- @@ -394,6 +394,8 @@ package body Ada.Exceptions is (File : System.Address; Line : Integer); procedure Rcheck_PE_Address_Of_Intrinsic (File : System.Address; Line : Integer); + procedure Rcheck_PE_Aliased_Parameters + (File : System.Address; Line : Integer); procedure Rcheck_PE_All_Guards_Closed (File : System.Address; Line : Integer); procedure Rcheck_PE_Bad_Predicated_Generic_Type @@ -470,6 +472,8 @@ package body Ada.Exceptions is "__gnat_rcheck_PE_Accessibility_Check"); pragma Export (C, Rcheck_PE_Address_Of_Intrinsic, "__gnat_rcheck_PE_Address_Of_Intrinsic"); + pragma Export (C, Rcheck_PE_Aliased_Parameters, + "__gnat_rcheck_PE_Aliased_Parameters"); pragma Export (C, Rcheck_PE_All_Guards_Closed, "__gnat_rcheck_PE_All_Guards_Closed"); pragma Export (C, Rcheck_PE_Bad_Predicated_Generic_Type, @@ -528,6 +532,7 @@ package body Ada.Exceptions is pragma No_Return (Rcheck_PE_Access_Before_Elaboration); pragma No_Return (Rcheck_PE_Accessibility_Check); pragma No_Return (Rcheck_PE_Address_Of_Intrinsic); + pragma No_Return (Rcheck_PE_Aliased_Parameters); pragma No_Return (Rcheck_PE_All_Guards_Closed); pragma No_Return (Rcheck_PE_Bad_Predicated_Generic_Type); pragma No_Return (Rcheck_PE_Current_Task_In_Entry_Body); @@ -583,6 +588,7 @@ package body Ada.Exceptions is procedure Rcheck_32 (File : System.Address; Line : Integer); procedure Rcheck_33 (File : System.Address; Line : Integer); procedure Rcheck_34 (File : System.Address; Line : Integer); + procedure Rcheck_35 (File : System.Address; Line : Integer); procedure Rcheck_22 (File : System.Address; Line : Integer); @@ -621,6 +627,7 @@ package body Ada.Exceptions is pragma Export (C, Rcheck_32, "__gnat_rcheck_32"); pragma Export (C, Rcheck_33, "__gnat_rcheck_33"); pragma Export (C, Rcheck_34, "__gnat_rcheck_34"); + pragma Export (C, Rcheck_35, "__gnat_rcheck_35"); -- None of these procedures ever returns (they raise an exception!). By -- using pragma No_Return, we ensure that any junk code after the call, @@ -660,6 +667,7 @@ package body Ada.Exceptions is pragma No_Return (Rcheck_32); pragma No_Return (Rcheck_33); pragma No_Return (Rcheck_34); + pragma No_Return (Rcheck_35); --------------------------------------------- -- Reason Strings for Run-Time Check Calls -- @@ -688,27 +696,28 @@ package body Ada.Exceptions is Rmsg_15 : constant String := "accessibility check failed" & NUL; Rmsg_16 : constant String := "attempt to take address of" & " intrinsic subprogram" & NUL; - Rmsg_17 : constant String := "all guards closed" & NUL; - Rmsg_18 : constant String := "improper use of generic subtype" & + Rmsg_17 : constant String := "aliased parameters" & NUL; + Rmsg_18 : constant String := "all guards closed" & NUL; + Rmsg_19 : constant String := "improper use of generic subtype" & " with predicate" & NUL; - Rmsg_19 : constant String := "Current_Task referenced in entry" & + Rmsg_20 : constant String := "Current_Task referenced in entry" & " body" & NUL; - Rmsg_20 : constant String := "duplicated entry address" & NUL; - Rmsg_21 : constant String := "explicit raise" & NUL; - Rmsg_22 : constant String := "finalize/adjust raised exception" & NUL; - Rmsg_23 : constant String := "implicit return with No_Return" & NUL; - Rmsg_24 : constant String := "misaligned address value" & NUL; - Rmsg_25 : constant String := "missing return" & NUL; - Rmsg_26 : constant String := "overlaid controlled object" & NUL; - Rmsg_27 : constant String := "potentially blocking operation" & NUL; - Rmsg_28 : constant String := "stubbed subprogram called" & NUL; - Rmsg_29 : constant String := "unchecked union restriction" & NUL; - Rmsg_30 : constant String := "actual/returned class-wide" & + Rmsg_21 : constant String := "duplicated entry address" & NUL; + Rmsg_22 : constant String := "explicit raise" & NUL; + Rmsg_23 : constant String := "finalize/adjust raised exception" & NUL; + Rmsg_24 : constant String := "implicit return with No_Return" & NUL; + Rmsg_25 : constant String := "misaligned address value" & NUL; + Rmsg_26 : constant String := "missing return" & NUL; + Rmsg_27 : constant String := "overlaid controlled object" & NUL; + Rmsg_28 : constant String := "potentially blocking operation" & NUL; + Rmsg_29 : constant String := "stubbed subprogram called" & NUL; + Rmsg_30 : constant String := "unchecked union restriction" & NUL; + Rmsg_31 : constant String := "actual/returned class-wide" & " value not transportable" & NUL; - Rmsg_31 : constant String := "empty storage pool" & NUL; - Rmsg_32 : constant String := "explicit raise" & NUL; - Rmsg_33 : constant String := "infinite recursion" & NUL; - Rmsg_34 : constant String := "object too large" & NUL; + Rmsg_32 : constant String := "empty storage pool" & NUL; + Rmsg_33 : constant String := "explicit raise" & NUL; + Rmsg_34 : constant String := "infinite recursion" & NUL; + Rmsg_35 : constant String := "object too large" & NUL; ----------------------- -- Polling Interface -- @@ -1285,123 +1294,130 @@ package body Ada.Exceptions is Raise_Program_Error_Msg (File, Line, Rmsg_16'Address); end Rcheck_PE_Address_Of_Intrinsic; - procedure Rcheck_PE_All_Guards_Closed + procedure Rcheck_PE_Aliased_Parameters (File : System.Address; Line : Integer) is begin Raise_Program_Error_Msg (File, Line, Rmsg_17'Address); + end Rcheck_PE_Aliased_Parameters; + + procedure Rcheck_PE_All_Guards_Closed + (File : System.Address; Line : Integer) + is + begin + Raise_Program_Error_Msg (File, Line, Rmsg_18'Address); end Rcheck_PE_All_Guards_Closed; procedure Rcheck_PE_Bad_Predicated_Generic_Type (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_18'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_19'Address); end Rcheck_PE_Bad_Predicated_Generic_Type; procedure Rcheck_PE_Current_Task_In_Entry_Body (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_19'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_20'Address); end Rcheck_PE_Current_Task_In_Entry_Body; procedure Rcheck_PE_Duplicated_Entry_Address (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_20'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_21'Address); end Rcheck_PE_Duplicated_Entry_Address; procedure Rcheck_PE_Explicit_Raise (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_21'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_22'Address); end Rcheck_PE_Explicit_Raise; procedure Rcheck_PE_Implicit_Return (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_23'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_24'Address); end Rcheck_PE_Implicit_Return; procedure Rcheck_PE_Misaligned_Address_Value (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_24'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_25'Address); end Rcheck_PE_Misaligned_Address_Value; procedure Rcheck_PE_Missing_Return (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_25'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_26'Address); end Rcheck_PE_Missing_Return; procedure Rcheck_PE_Overlaid_Controlled_Object (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_26'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_27'Address); end Rcheck_PE_Overlaid_Controlled_Object; procedure Rcheck_PE_Potentially_Blocking_Operation (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_27'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_28'Address); end Rcheck_PE_Potentially_Blocking_Operation; procedure Rcheck_PE_Stubbed_Subprogram_Called (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_28'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_29'Address); end Rcheck_PE_Stubbed_Subprogram_Called; procedure Rcheck_PE_Unchecked_Union_Restriction (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_29'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_30'Address); end Rcheck_PE_Unchecked_Union_Restriction; procedure Rcheck_PE_Non_Transportable_Actual (File : System.Address; Line : Integer) is begin - Raise_Program_Error_Msg (File, Line, Rmsg_30'Address); + Raise_Program_Error_Msg (File, Line, Rmsg_31'Address); end Rcheck_PE_Non_Transportable_Actual; procedure Rcheck_SE_Empty_Storage_Pool (File : System.Address; Line : Integer) is begin - Raise_Storage_Error_Msg (File, Line, Rmsg_31'Address); + Raise_Storage_Error_Msg (File, Line, Rmsg_32'Address); end Rcheck_SE_Empty_Storage_Pool; procedure Rcheck_SE_Explicit_Raise (File : System.Address; Line : Integer) is begin - Raise_Storage_Error_Msg (File, Line, Rmsg_32'Address); + Raise_Storage_Error_Msg (File, Line, Rmsg_33'Address); end Rcheck_SE_Explicit_Raise; procedure Rcheck_SE_Infinite_Recursion (File : System.Address; Line : Integer) is begin - Raise_Storage_Error_Msg (File, Line, Rmsg_33'Address); + Raise_Storage_Error_Msg (File, Line, Rmsg_34'Address); end Rcheck_SE_Infinite_Recursion; procedure Rcheck_SE_Object_Too_Large (File : System.Address; Line : Integer) is begin - Raise_Storage_Error_Msg (File, Line, Rmsg_34'Address); + Raise_Storage_Error_Msg (File, Line, Rmsg_35'Address); end Rcheck_SE_Object_Too_Large; procedure Rcheck_PE_Finalize_Raised_Exception @@ -1417,7 +1433,7 @@ package body Ada.Exceptions is -- This is consistent with Raise_From_Controlled_Operation Exception_Data.Set_Exception_C_Msg (Excep, E, File, Line, 0, - Rmsg_22'Address); + Rmsg_23'Address); Raise_Current_Excep (E); end Rcheck_PE_Finalize_Raised_Exception; @@ -1456,41 +1472,43 @@ package body Ada.Exceptions is procedure Rcheck_16 (File : System.Address; Line : Integer) renames Rcheck_PE_Address_Of_Intrinsic; procedure Rcheck_17 (File : System.Address; Line : Integer) - renames Rcheck_PE_All_Guards_Closed; + renames Rcheck_PE_Aliased_Parameters; procedure Rcheck_18 (File : System.Address; Line : Integer) - renames Rcheck_PE_Bad_Predicated_Generic_Type; + renames Rcheck_PE_All_Guards_Closed; procedure Rcheck_19 (File : System.Address; Line : Integer) - renames Rcheck_PE_Current_Task_In_Entry_Body; + renames Rcheck_PE_Bad_Predicated_Generic_Type; procedure Rcheck_20 (File : System.Address; Line : Integer) - renames Rcheck_PE_Duplicated_Entry_Address; + renames Rcheck_PE_Current_Task_In_Entry_Body; procedure Rcheck_21 (File : System.Address; Line : Integer) + renames Rcheck_PE_Duplicated_Entry_Address; + procedure Rcheck_22 (File : System.Address; Line : Integer) renames Rcheck_PE_Explicit_Raise; - procedure Rcheck_23 (File : System.Address; Line : Integer) - renames Rcheck_PE_Implicit_Return; procedure Rcheck_24 (File : System.Address; Line : Integer) - renames Rcheck_PE_Misaligned_Address_Value; + renames Rcheck_PE_Implicit_Return; procedure Rcheck_25 (File : System.Address; Line : Integer) - renames Rcheck_PE_Missing_Return; + renames Rcheck_PE_Misaligned_Address_Value; procedure Rcheck_26 (File : System.Address; Line : Integer) - renames Rcheck_PE_Overlaid_Controlled_Object; + renames Rcheck_PE_Missing_Return; procedure Rcheck_27 (File : System.Address; Line : Integer) - renames Rcheck_PE_Potentially_Blocking_Operation; + renames Rcheck_PE_Overlaid_Controlled_Object; procedure Rcheck_28 (File : System.Address; Line : Integer) - renames Rcheck_PE_Stubbed_Subprogram_Called; + renames Rcheck_PE_Potentially_Blocking_Operation; procedure Rcheck_29 (File : System.Address; Line : Integer) - renames Rcheck_PE_Unchecked_Union_Restriction; + renames Rcheck_PE_Stubbed_Subprogram_Called; procedure Rcheck_30 (File : System.Address; Line : Integer) - renames Rcheck_PE_Non_Transportable_Actual; + renames Rcheck_PE_Unchecked_Union_Restriction; procedure Rcheck_31 (File : System.Address; Line : Integer) - renames Rcheck_SE_Empty_Storage_Pool; + renames Rcheck_PE_Non_Transportable_Actual; procedure Rcheck_32 (File : System.Address; Line : Integer) - renames Rcheck_SE_Explicit_Raise; + renames Rcheck_SE_Empty_Storage_Pool; procedure Rcheck_33 (File : System.Address; Line : Integer) - renames Rcheck_SE_Infinite_Recursion; + renames Rcheck_SE_Explicit_Raise; procedure Rcheck_34 (File : System.Address; Line : Integer) + renames Rcheck_SE_Infinite_Recursion; + procedure Rcheck_35 (File : System.Address; Line : Integer) renames Rcheck_SE_Object_Too_Large; - procedure Rcheck_22 (File : System.Address; Line : Integer) + procedure Rcheck_23 (File : System.Address; Line : Integer) renames Rcheck_PE_Finalize_Raised_Exception; ------------- diff --git a/gcc/ada/a-ngelfu.ads b/gcc/ada/a-ngelfu.ads index 9f7d3a3a168..91e1cf7cf51 100644 --- a/gcc/ada/a-ngelfu.ads +++ b/gcc/ada/a-ngelfu.ads @@ -6,7 +6,7 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 2012, Free Software Foundation, Inc. -- +-- Copyright (C) 2012-2013, Free Software Foundation, Inc. -- -- -- -- This specification is derived from the Ada Reference Manual for use with -- -- GNAT. The copyright notice above, and the license provisions that follow -- @@ -39,139 +39,114 @@ generic package Ada.Numerics.Generic_Elementary_Functions is pragma Pure; - function Sqrt (X : Float_Type'Base) return Float_Type'Base - with + function Sqrt (X : Float_Type'Base) return Float_Type'Base with Post => Sqrt'Result >= 0.0 - and then (if X = 0.0 then Sqrt'Result = 0.0) - and then (if X = 1.0 then Sqrt'Result = 1.0); + and then (if X = 0.0 then Sqrt'Result = 0.0) + and then (if X = 1.0 then Sqrt'Result = 1.0); function Log (X : Float_Type'Base) return Float_Type'Base with Post => (if X = 1.0 then Log'Result = 0.0); - function Log (X, Base : Float_Type'Base) return Float_Type'Base - with + function Log (X, Base : Float_Type'Base) return Float_Type'Base with Post => (if X = 1.0 then Log'Result = 0.0); - function Exp (X : Float_Type'Base) return Float_Type'Base - with + function Exp (X : Float_Type'Base) return Float_Type'Base with Post => (if X = 0.0 then Exp'Result = 1.0); - function "**" (Left, Right : Float_Type'Base) return Float_Type'Base - with + function "**" (Left, Right : Float_Type'Base) return Float_Type'Base with Post => "**"'Result >= 0.0 - and then (if Right = 0.0 then "**"'Result = 1.0) - and then (if Right = 1.0 then "**"'Result = Left) - and then (if Left = 1.0 then "**"'Result = 1.0) - and then (if Left = 0.0 then "**"'Result = 0.0); + and then (if Right = 0.0 then "**"'Result = 1.0) + and then (if Right = 1.0 then "**"'Result = Left) + and then (if Left = 1.0 then "**"'Result = 1.0) + and then (if Left = 0.0 then "**"'Result = 0.0); - function Sin (X : Float_Type'Base) return Float_Type'Base - with + function Sin (X : Float_Type'Base) return Float_Type'Base with Post => Sin'Result in -1.0 .. 1.0 - and then (if X = 0.0 then Sin'Result = 0.0); + and then (if X = 0.0 then Sin'Result = 0.0); - function Sin (X, Cycle : Float_Type'Base) return Float_Type'Base - with + function Sin (X, Cycle : Float_Type'Base) return Float_Type'Base with Post => Sin'Result in -1.0 .. 1.0 - and then (if X = 0.0 then Sin'Result = 0.0); + and then (if X = 0.0 then Sin'Result = 0.0); - function Cos (X : Float_Type'Base) return Float_Type'Base - with + function Cos (X : Float_Type'Base) return Float_Type'Base with Post => Cos'Result in -1.0 .. 1.0 - and then (if X = 0.0 then Cos'Result = 1.0); + and then (if X = 0.0 then Cos'Result = 1.0); - function Cos (X, Cycle : Float_Type'Base) return Float_Type'Base - with + function Cos (X, Cycle : Float_Type'Base) return Float_Type'Base with Post => Cos'Result in -1.0 .. 1.0 - and then (if X = 0.0 then Cos'Result = 1.0); + and then (if X = 0.0 then Cos'Result = 1.0); - function Tan (X : Float_Type'Base) return Float_Type'Base - with + function Tan (X : Float_Type'Base) return Float_Type'Base with Post => (if X = 0.0 then Tan'Result = 0.0); - function Tan (X, Cycle : Float_Type'Base) return Float_Type'Base - with + function Tan (X, Cycle : Float_Type'Base) return Float_Type'Base with Post => (if X = 0.0 then Tan'Result = 0.0); function Cot (X : Float_Type'Base) return Float_Type'Base; function Cot (X, Cycle : Float_Type'Base) return Float_Type'Base; - function Arcsin (X : Float_Type'Base) return Float_Type'Base - with + function Arcsin (X : Float_Type'Base) return Float_Type'Base with Post => (if X = 0.0 then Arcsin'Result = 0.0); - function Arcsin (X, Cycle : Float_Type'Base) return Float_Type'Base - with + function Arcsin (X, Cycle : Float_Type'Base) return Float_Type'Base with Post => (if X = 0.0 then Arcsin'Result = 0.0); - function Arccos (X : Float_Type'Base) return Float_Type'Base - with + function Arccos (X : Float_Type'Base) return Float_Type'Base with Post => (if X = 1.0 then Arccos'Result = 0.0); - function Arccos (X, Cycle : Float_Type'Base) return Float_Type'Base - with + function Arccos (X, Cycle : Float_Type'Base) return Float_Type'Base with Post => (if X = 1.0 then Arccos'Result = 0.0); function Arctan - (Y : Float_Type'Base; - X : Float_Type'Base := 1.0) - return Float_Type'Base + (Y : Float_Type'Base; + X : Float_Type'Base := 1.0) return Float_Type'Base with Post => (if X > 0.0 and Y = 0.0 then Arctan'Result = 0.0); function Arctan (Y : Float_Type'Base; X : Float_Type'Base := 1.0; - Cycle : Float_Type'Base) - return Float_Type'Base + Cycle : Float_Type'Base) return Float_Type'Base with Post => (if X > 0.0 and Y = 0.0 then Arctan'Result = 0.0); function Arccot (X : Float_Type'Base; - Y : Float_Type'Base := 1.0) - return Float_Type'Base + Y : Float_Type'Base := 1.0) return Float_Type'Base with Post => (if X > 0.0 and Y = 0.0 then Arccot'Result = 0.0); function Arccot (X : Float_Type'Base; Y : Float_Type'Base := 1.0; - Cycle : Float_Type'Base) - return Float_Type'Base + Cycle : Float_Type'Base) return Float_Type'Base with Post => (if X > 0.0 and Y = 0.0 then Arccot'Result = 0.0); - function Sinh (X : Float_Type'Base) return Float_Type'Base - with + function Sinh (X : Float_Type'Base) return Float_Type'Base with Post => (if X = 0.0 then Sinh'Result = 0.0); - function Cosh (X : Float_Type'Base) return Float_Type'Base - with + function Cosh (X : Float_Type'Base) return Float_Type'Base with Post => Cosh'Result >= 1.0 - and then (if X = 0.0 then Cosh'Result = 1.0); + and then (if X = 0.0 then Cosh'Result = 1.0); - function Tanh (X : Float_Type'Base) return Float_Type'Base - with + function Tanh (X : Float_Type'Base) return Float_Type'Base with Post => Tanh'Result in -1.0 .. 1.0 - and then (if X = 0.0 then Tanh'Result = 0.0); + and then (if X = 0.0 then Tanh'Result = 0.0); - function Coth (X : Float_Type'Base) return Float_Type'Base - with + function Coth (X : Float_Type'Base) return Float_Type'Base with Post => abs Coth'Result >= 1.0; - function Arcsinh (X : Float_Type'Base) return Float_Type'Base - with + function Arcsinh (X : Float_Type'Base) return Float_Type'Base with Post => (if X = 0.0 then Arcsinh'Result = 0.0); - function Arccosh (X : Float_Type'Base) return Float_Type'Base - with + function Arccosh (X : Float_Type'Base) return Float_Type'Base with Post => Arccosh'Result >= 0.0 - and then (if X = 1.0 then Arccosh'Result = 0.0); + and then (if X = 1.0 then Arccosh'Result = 0.0); - function Arctanh (X : Float_Type'Base) return Float_Type'Base - with + function Arctanh (X : Float_Type'Base) return Float_Type'Base with Post => (if X = 0.0 then Arctanh'Result = 0.0); function Arccoth (X : Float_Type'Base) return Float_Type'Base; diff --git a/gcc/ada/aspects.adb b/gcc/ada/aspects.adb index 71f74939ca4..d02edb25702 100644 --- a/gcc/ada/aspects.adb +++ b/gcc/ada/aspects.adb @@ -403,6 +403,7 @@ package body Aspects is Aspect_Simple_Storage_Pool_Type => Aspect_Simple_Storage_Pool_Type, Aspect_Size => Aspect_Size, Aspect_Small => Aspect_Small, + Aspect_SPARK_Mode => Aspect_SPARK_Mode, Aspect_Static_Predicate => Aspect_Predicate, Aspect_Storage_Pool => Aspect_Storage_Pool, Aspect_Storage_Size => Aspect_Storage_Size, diff --git a/gcc/ada/aspects.ads b/gcc/ada/aspects.ads index 6941cc1c666..5a093af21cf 100644 --- a/gcc/ada/aspects.ads +++ b/gcc/ada/aspects.ads @@ -116,6 +116,7 @@ package Aspects is Aspect_Simple_Storage_Pool, -- GNAT Aspect_Size, Aspect_Small, + Aspect_SPARK_Mode, -- GNAT Aspect_Static_Predicate, Aspect_Storage_Pool, Aspect_Storage_Size, @@ -322,6 +323,7 @@ package Aspects is Aspect_Simple_Storage_Pool => Name, Aspect_Size => Expression, Aspect_Small => Expression, + Aspect_SPARK_Mode => Name, Aspect_Static_Predicate => Expression, Aspect_Storage_Pool => Name, Aspect_Storage_Size => Expression, @@ -423,6 +425,7 @@ package Aspects is Aspect_Simple_Storage_Pool_Type => Name_Simple_Storage_Pool_Type, Aspect_Size => Name_Size, Aspect_Small => Name_Small, + Aspect_SPARK_Mode => Name_SPARK_Mode, Aspect_Static_Predicate => Name_Static_Predicate, Aspect_Storage_Pool => Name_Storage_Pool, Aspect_Storage_Size => Name_Storage_Size, diff --git a/gcc/ada/atree.adb b/gcc/ada/atree.adb index 40a27a1fb74..a6105e2c427 100644 --- a/gcc/ada/atree.adb +++ b/gcc/ada/atree.adb @@ -2532,6 +2532,12 @@ package body Atree is return Node_Id (Nodes.Table (N + 5).Field7); end Node31; + function Node32 (N : Node_Id) return Node_Id is + begin + pragma Assert (Nkind (N) in N_Entity); + return Node_Id (Nodes.Table (N + 5).Field8); + end Node32; + function List1 (N : Node_Id) return List_Id is begin pragma Assert (N <= Nodes.Last); @@ -5243,6 +5249,12 @@ package body Atree is Nodes.Table (N + 5).Field7 := Union_Id (Val); end Set_Node31; + procedure Set_Node32 (N : Node_Id; Val : Node_Id) is + begin + pragma Assert (Nkind (N) in N_Entity); + Nodes.Table (N + 5).Field8 := Union_Id (Val); + end Set_Node32; + procedure Set_List1 (N : Node_Id; Val : List_Id) is begin pragma Assert (N <= Nodes.Last); diff --git a/gcc/ada/atree.ads b/gcc/ada/atree.ads index 07e8e512a57..d1056b07a32 100644 --- a/gcc/ada/atree.ads +++ b/gcc/ada/atree.ads @@ -1174,6 +1174,9 @@ package Atree is function Node31 (N : Node_Id) return Node_Id; pragma Inline (Node31); + function Node32 (N : Node_Id) return Node_Id; + pragma Inline (Node32); + function List1 (N : Node_Id) return List_Id; pragma Inline (List1); @@ -2459,6 +2462,9 @@ package Atree is procedure Set_Node31 (N : Node_Id; Val : Node_Id); pragma Inline (Set_Node31); + procedure Set_Node32 (N : Node_Id; Val : Node_Id); + pragma Inline (Set_Node32); + procedure Set_List1 (N : Node_Id; Val : List_Id); pragma Inline (Set_List1); diff --git a/gcc/ada/checks.adb b/gcc/ada/checks.adb index 570bfbc8a14..29a18593167 100644 --- a/gcc/ada/checks.adb +++ b/gcc/ada/checks.adb @@ -58,6 +58,7 @@ with Sinput; use Sinput; with Snames; use Snames; with Sprint; use Sprint; with Stand; use Stand; +with Stringt; use Stringt; with Targparm; use Targparm; with Tbuild; use Tbuild; with Ttypes; use Ttypes; @@ -2093,6 +2094,8 @@ package body Checks is (Call : Node_Id; Subp : Entity_Id) is + Loc : constant Source_Ptr := Sloc (Call); + function May_Cause_Aliasing (Formal_1 : Entity_Id; Formal_2 : Entity_Id) return Boolean; @@ -2105,6 +2108,20 @@ package body Checks is -- it does not share the address of the actual. This routine attempts -- to retrieve the original actual. + procedure Overlap_Check + (Actual_1 : Node_Id; + Actual_2 : Node_Id; + Formal_1 : Entity_Id; + Formal_2 : Entity_Id; + Check : in out Node_Id); + -- Create a check to determine whether Actual_1 overlaps with Actual_2. + -- If detailed exception messages are enabled, the check is augmented to + -- provide information about the names of the corresponding formals. See + -- the body for details. Actual_1 and Actual_2 denote the two actuals to + -- be tested. Formal_1 and Formal_2 denote the corresponding formals. + -- Check contains all and-ed simple tests generated so far or remains + -- unchanged in the case of detailed exception messaged. + ------------------------ -- May_Cause_Aliasing -- ------------------------ @@ -2161,20 +2178,89 @@ package body Checks is return N; end Original_Actual; + ------------------- + -- Overlap_Check -- + ------------------- + + procedure Overlap_Check + (Actual_1 : Node_Id; + Actual_2 : Node_Id; + Formal_1 : Entity_Id; + Formal_2 : Entity_Id; + Check : in out Node_Id) + is + Cond : Node_Id; + + begin + -- Generate: + -- Actual_1'Overlaps_Storage (Actual_2) + + Cond := + Make_Attribute_Reference (Loc, + Prefix => New_Copy_Tree (Original_Actual (Actual_1)), + Attribute_Name => Name_Overlaps_Storage, + Expressions => + New_List (New_Copy_Tree (Original_Actual (Actual_2)))); + + -- Generate the following check when detailed exception messages are + -- enabled: + + -- if Actual_1'Overlaps_Storage (Actual_2) then + -- raise Program_Error with <detailed message>; + -- end if; + + if Exception_Extra_Info then + Start_String; + + -- Do not generate location information for internal calls + + if Comes_From_Source (Call) then + Store_String_Chars (Build_Location_String (Loc)); + Store_String_Char (' '); + end if; + + Store_String_Chars ("aliased parameters, actuals for """); + Store_String_Chars (Get_Name_String (Chars (Formal_1))); + Store_String_Chars (""" and """); + Store_String_Chars (Get_Name_String (Chars (Formal_2))); + Store_String_Chars (""" overlap"); + + Insert_Action (Call, + Make_If_Statement (Loc, + Condition => Cond, + Then_Statements => New_List ( + Make_Raise_Statement (Loc, + Name => + New_Reference_To (Standard_Program_Error, Loc), + Expression => Make_String_Literal (Loc, End_String))))); + + -- Create a sequence of overlapping checks by and-ing them all + -- together. + + else + if No (Check) then + Check := Cond; + else + Check := + Make_And_Then (Loc, + Left_Opnd => Check, + Right_Opnd => Cond); + end if; + end if; + end Overlap_Check; + -- Local variables - Loc : constant Source_Ptr := Sloc (Call); Actual_1 : Node_Id; Actual_2 : Node_Id; Check : Node_Id; - Cond : Node_Id; Formal_1 : Entity_Id; Formal_2 : Entity_Id; -- Start of processing for Apply_Parameter_Aliasing_Checks begin - Cond := Empty; + Check := Empty; Actual_1 := First_Actual (Call); Formal_1 := First_Formal (Subp); @@ -2200,25 +2286,12 @@ package body Checks is Is_Elementary_Type (Etype (Original_Actual (Actual_2))) and then May_Cause_Aliasing (Formal_1, Formal_2) then - -- Generate: - -- Actual_1'Overlaps_Storage (Actual_2) - - Check := - Make_Attribute_Reference (Loc, - Prefix => - New_Copy_Tree (Original_Actual (Actual_1)), - Attribute_Name => Name_Overlaps_Storage, - Expressions => - New_List (New_Copy_Tree (Original_Actual (Actual_2)))); - - if No (Cond) then - Cond := Check; - else - Cond := - Make_And_Then (Loc, - Left_Opnd => Cond, - Right_Opnd => Check); - end if; + Overlap_Check + (Actual_1 => Actual_1, + Actual_2 => Actual_2, + Formal_1 => Formal_1, + Formal_2 => Formal_2, + Check => Check); end if; Next_Actual (Actual_2); @@ -2230,13 +2303,13 @@ package body Checks is Next_Formal (Formal_1); end loop; - -- Place the check right before the call + -- Place a simple check right before the call - if Present (Cond) then + if Present (Check) and then not Exception_Extra_Info then Insert_Action (Call, Make_Raise_Program_Error (Loc, - Condition => Cond, - Reason => PE_Explicit_Raise)); + Condition => Check, + Reason => PE_Aliased_Parameters)); end if; end Apply_Parameter_Aliasing_Checks; diff --git a/gcc/ada/einfo.adb b/gcc/ada/einfo.adb index bfe5b37dad1..0ed05608afb 100644 --- a/gcc/ada/einfo.adb +++ b/gcc/ada/einfo.adb @@ -246,7 +246,7 @@ package body Einfo is -- Thunk_Entity Node31 - -- (unused) Node32 + -- SPARK_Mode_Pragmas Node32 -- (unused) Node33 @@ -2825,6 +2825,21 @@ package body Einfo is return Ureal21 (Id); end Small_Value; + function SPARK_Mode_Pragmas (Id : E) return N is + begin + pragma Assert + (Ekind_In (Id, E_Function, -- subprogram variants + E_Generic_Function, + E_Generic_Procedure, + E_Procedure, + E_Subprogram_Body) + or else + Ekind_In (Id, E_Generic_Package, -- package variants + E_Package, + E_Package_Body)); + return Node32 (Id); + end SPARK_Mode_Pragmas; + function Spec_Entity (Id : E) return E is begin pragma Assert (Ekind (Id) = E_Package_Body or else Is_Formal (Id)); @@ -5469,6 +5484,22 @@ package body Einfo is Set_Ureal21 (Id, V); end Set_Small_Value; + procedure Set_SPARK_Mode_Pragmas (Id : E; V : N) is + begin + pragma Assert + (Ekind_In (Id, E_Function, -- subprogram variants + E_Generic_Function, + E_Generic_Procedure, + E_Procedure, + E_Subprogram_Body) + or else + Ekind_In (Id, E_Generic_Package, -- package variants + E_Package, + E_Package_Body)); + + Set_Node32 (Id, V); + end Set_SPARK_Mode_Pragmas; + procedure Set_Spec_Entity (Id : E; V : E) is begin pragma Assert (Ekind (Id) = E_Package_Body or else Is_Formal (Id)); @@ -6249,19 +6280,58 @@ package body Einfo is -- Get_Pragma -- ---------------- - function Get_Pragma (E : Entity_Id; Id : Pragma_Id) return Node_Id - is - N : Node_Id; + function Get_Pragma (E : Entity_Id; Id : Pragma_Id) return Node_Id is + Is_CDG : constant Boolean := + Id = Pragma_Depends or else Id = Pragma_Global; + Is_CTC : constant Boolean := + Id = Pragma_Contract_Cases or else Id = Pragma_Test_Case; + Is_PPC : constant Boolean := + Id = Pragma_Precondition or else Id = Pragma_Postcondition; + Delayed : constant Boolean := Is_CDG or else Is_CTC or else Is_PPC; + Item : Node_Id; + Items : Node_Id; begin - N := First_Rep_Item (E); - while Present (N) loop - if Nkind (N) = N_Pragma - and then Get_Pragma_Id (Pragma_Name (N)) = Id + -- Handle delayed pragmas that appear in N_Contract nodes. Those have to + -- be extracted from their specialized list. + + if Delayed then + Items := Contract (E); + + if No (Items) then + return Empty; + + elsif Is_CDG then + Item := Classifications (Items); + + elsif Is_CTC then + Item := Contract_Test_Cases (Items); + + else + Item := Pre_Post_Conditions (Items); + end if; + + -- Regular pragmas + + else + Item := First_Rep_Item (E); + end if; + + while Present (Item) loop + if Nkind (Item) = N_Pragma + and then Get_Pragma_Id (Pragma_Name (Item)) = Id then - return N; + return Item; + + -- All nodes in N_Contract are chained using Next_Pragma + + elsif Delayed then + Item := Next_Pragma (Item); + + -- Regular pragmas + else - Next_Rep_Item (N); + Next_Rep_Item (Item); end if; end loop; @@ -9149,6 +9219,16 @@ package body Einfo is procedure Write_Field32_Name (Id : Entity_Id) is begin case Ekind (Id) is + when E_Function | + E_Generic_Function | + E_Generic_Package | + E_Generic_Procedure | + E_Package | + E_Package_Body | + E_Procedure | + E_Subprogram_Body => + Write_Str ("SPARK_Mode_Pragmas"); + when others => Write_Str ("Field32??"); end case; diff --git a/gcc/ada/einfo.ads b/gcc/ada/einfo.ads index a3d05d8c8a0..24bb12cf797 100644 --- a/gcc/ada/einfo.ads +++ b/gcc/ada/einfo.ads @@ -1,7 +1,6 @@ ------------------------------------------------------------------------------ -- -- -- GNAT COMPILER COMPONENTS -- --- -- -- E I N F O -- -- -- -- S p e c -- @@ -3757,6 +3756,11 @@ package Einfo is -- Small of the type, either as given in a representation clause, or -- as computed (as a power of two) by the compiler. +-- SPARK_Mode_Pragmas (Node32) +-- Present in the entities of subprogram specs and bodies as well as in +-- package specs and bodies. Points to a list of SPARK_Mode pragmas that +-- apply to the related construct. Add note of what this is used for ??? + -- Spec_Entity (Node19) -- Defined in package body entities. Points to corresponding package -- spec entity. Also defined in subprogram body parameters in the @@ -5394,6 +5398,7 @@ package Einfo is -- Subprograms_For_Type (Node29) -- Corresponding_Equality (Node30) (implicit /= only) -- Thunk_Entity (Node31) (thunk case only) + -- SPARK_Mode_Pragmas (Node32) -- Body_Needed_For_SAL (Flag40) -- Elaboration_Entity_Required (Flag174) -- Default_Expressions_Processed (Flag108) @@ -5591,6 +5596,7 @@ package Einfo is -- Abstract_States (Elist25) -- Package_Instantiation (Node26) -- Current_Use_Clause (Node27) + -- SPARK_Mode_Pragmas (Node32) -- Delay_Subprogram_Descriptors (Flag50) -- Body_Needed_For_SAL (Flag40) -- Discard_Names (Flag88) @@ -5621,6 +5627,7 @@ package Einfo is -- Last_Entity (Node20) -- Scope_Depth_Value (Uint22) -- Finalizer (Node24) (non-generic case only) + -- SPARK_Mode_Pragmas (Node32) -- Delay_Subprogram_Descriptors (Flag50) -- Has_Anonymous_Master (Flag253) -- Scope_Depth (synth) @@ -5667,6 +5674,7 @@ package Einfo is -- Extra_Formals (Node28) -- Static_Initialization (Node30) (init_proc only) -- Thunk_Entity (Node31) (thunk case only) + -- SPARK_Mode_Pragmas (Node32) -- Body_Needed_For_SAL (Flag40) -- Delay_Cleanups (Flag114) -- Discard_Names (Flag88) @@ -5837,6 +5845,7 @@ package Einfo is -- Last_Entity (Node20) -- Scope_Depth_Value (Uint22) -- Extra_Formals (Node28) + -- SPARK_Mode_Pragmas (Node32) -- Scope_Depth (synth) -- E_Subprogram_Type @@ -6531,6 +6540,7 @@ package Einfo is function Size_Depends_On_Discriminant (Id : E) return B; function Size_Known_At_Compile_Time (Id : E) return B; function Small_Value (Id : E) return R; + function SPARK_Mode_Pragmas (Id : E) return N; function Spec_Entity (Id : E) return E; function Static_Elaboration_Desired (Id : E) return B; function Static_Initialization (Id : E) return N; @@ -7145,6 +7155,7 @@ package Einfo is procedure Set_Size_Depends_On_Discriminant (Id : E; V : B := True); procedure Set_Size_Known_At_Compile_Time (Id : E; V : B := True); procedure Set_Small_Value (Id : E; V : R); + procedure Set_SPARK_Mode_Pragmas (Id : E; V : N); procedure Set_Spec_Entity (Id : E; V : E); procedure Set_Static_Elaboration_Desired (Id : E; V : B); procedure Set_Static_Initialization (Id : E; V : N); @@ -7364,7 +7375,9 @@ package Einfo is function Get_Pragma (E : Entity_Id; Id : Pragma_Id) return Node_Id; -- Searches the Rep_Item chain for a given entity E, for an instance of -- a pragma with the given pragma Id. If found, the value returned is the - -- N_Pragma node, otherwise Empty is returned. + -- N_Pragma node, otherwise Empty is returned. Delayed pragmas such as + -- Precondition, Postcondition, Contract_Cases, Depends and Global appear + -- in the N_Contract node of entity E and are also handled by this routine. function Get_Record_Representation_Clause (E : Entity_Id) return Node_Id; -- Searches the Rep_Item chain for a given entity E, for a record @@ -7891,6 +7904,7 @@ package Einfo is pragma Inline (Size_Depends_On_Discriminant); pragma Inline (Size_Known_At_Compile_Time); pragma Inline (Small_Value); + pragma Inline (SPARK_Mode_Pragmas); pragma Inline (Spec_Entity); pragma Inline (Static_Elaboration_Desired); pragma Inline (Static_Initialization); @@ -8305,6 +8319,7 @@ package Einfo is pragma Inline (Set_Size_Depends_On_Discriminant); pragma Inline (Set_Size_Known_At_Compile_Time); pragma Inline (Set_Small_Value); + pragma Inline (Set_SPARK_Mode_Pragmas); pragma Inline (Set_Spec_Entity); pragma Inline (Set_Static_Elaboration_Desired); pragma Inline (Set_Static_Initialization); diff --git a/gcc/ada/errout.adb b/gcc/ada/errout.adb index b8d044e3d34..5e3e72381fd 100644 --- a/gcc/ada/errout.adb +++ b/gcc/ada/errout.adb @@ -153,8 +153,7 @@ package body Errout is -- be one of the special insertion characters (see documentation in spec). -- Flag is the location at which the error is to be posted, which is used -- to determine whether or not the # insertion needs a file name. The - -- variables Msg_Buffer, Msglen, Is_Style_Msg, Is_Warning_Msg, and - -- Is_Unconditional_Msg are set on return. + -- variables Msg_Buffer are set on return Msglen. procedure Set_Posted (N : Node_Id); -- Sets the Error_Posted flag on the given node, and all its parents @@ -283,7 +282,7 @@ package body Errout is -- Start of processing for new message Sindex := Get_Source_File_Index (Flag_Location); - Test_Style_Warning_Serious_Msg (Msg); + Test_Style_Warning_Serious_Unconditional_Msg (Msg); Orig_Loc := Original_Location (Flag_Location); -- If the current location is in an instantiation, the issue arises of @@ -726,7 +725,7 @@ package body Errout is if Suppress_Message and then not All_Errors_Mode and then not Is_Warning_Msg - and then Msg (Msg'Last) /= '!' + and then not Is_Unconditional_Msg then if not Continuation then Last_Killed := True; @@ -787,9 +786,9 @@ package body Errout is elsif Debug_Flag_GG then null; - -- Keep warning if message text ends in !! + -- Keep warning if message text contains !! - elsif Msg (Msg'Last) = '!' and then Msg (Msg'Last - 1) = '!' then + elsif Has_Double_Exclam then null; -- Here is where we delete a warning from a with'ed unit @@ -1123,7 +1122,7 @@ package body Errout is return; end if; - Test_Style_Warning_Serious_Msg (Msg); + Test_Style_Warning_Serious_Unconditional_Msg (Msg); -- Special handling for warning messages @@ -1163,7 +1162,7 @@ package body Errout is -- Test for message to be output if All_Errors_Mode - or else Msg (Msg'Last) = '!' + or else Is_Unconditional_Msg or else Is_Warning_Msg or else OK_Node (N) or else (Msg (Msg'First) = '\' and then not Last_Killed) @@ -2711,7 +2710,6 @@ package body Errout is begin Manual_Quote_Mode := False; - Is_Unconditional_Msg := False; Msglen := 0; Flag_Source := Get_Source_File_Index (Flag); @@ -2776,7 +2774,7 @@ package body Errout is Set_Msg_Char ('"'); when '!' => - Is_Unconditional_Msg := True; + null; -- already dealt with when '?' => Set_Msg_Insertion_Warning; diff --git a/gcc/ada/errout.ads b/gcc/ada/errout.ads index 4b30a0663a0..9afc4dfd34a 100644 --- a/gcc/ada/errout.ads +++ b/gcc/ada/errout.ads @@ -101,10 +101,9 @@ package Errout is -- messages. Warning messages are only suppressed for case 1, and -- when they come from other than the main extended unit. - -- This normal suppression action may be overridden in cases 2-5 (but not - -- in case 1) by setting All_Errors mode, or by setting the special - -- unconditional message insertion character (!) at the end of the message - -- text as described below. + -- This normal suppression action may be overridden in cases 2-5 (but + -- not in case 1) by setting All_Errors mode, or by setting the special + -- unconditional message insertion character (!) as described below. --------------------------------------------------------- -- Error Message Text and Message Insertion Characters -- @@ -230,7 +229,7 @@ package Errout is -- name is defined, this insertion character has no effect. -- Insertion character ! (Exclamation: unconditional message) - -- The character ! appearing as the last character of a message makes + -- The character ! appearing anywhere in the text of a message makes -- the message unconditional which means that it is output even if it -- would normally be suppressed. See section above for a description -- of the cases in which messages are normally suppressed. Note that @@ -249,7 +248,7 @@ package Errout is -- Insertion character !! (Double exclamation: unconditional warning) -- Normally warning messages issued in other than the main unit are - -- suppressed. If the message ends with !! then this suppression is + -- suppressed. If the message contains !! then this suppression is -- avoided. This is currently used by the Compile_Time_Warning pragma -- to ensure the message for a with'ed unit is output, and for warnings -- on ineffective back-end inlining, which is detected in units that diff --git a/gcc/ada/erroutc.adb b/gcc/ada/erroutc.adb index a0da2304bc4..97ce9d77891 100644 --- a/gcc/ada/erroutc.adb +++ b/gcc/ada/erroutc.adb @@ -1226,22 +1226,24 @@ package body Erroutc is -- Test_Style_Warning_Serious_Msg -- ------------------------------------ - procedure Test_Style_Warning_Serious_Msg (Msg : String) is + procedure Test_Style_Warning_Serious_Unconditional_Msg (Msg : String) is begin + -- Nothing to do for continuation line + if Msg (Msg'First) = '\' then return; end if; - Is_Serious_Error := True; - Is_Warning_Msg := False; + -- Set initial values of globals (may be changed during scan) + + Is_Serious_Error := True; + Is_Unconditional_Msg := False; + Is_Warning_Msg := False; + Has_Double_Exclam := False; Is_Style_Msg := (Msg'Length > 7 and then Msg (Msg'First .. Msg'First + 6) = "(style)"); - if Is_Style_Msg then - Is_Serious_Error := False; - end if; - for J in Msg'Range loop if Msg (J) = '?' and then (J = Msg'First or else Msg (J - 1) /= ''') @@ -1249,6 +1251,16 @@ package body Erroutc is Is_Warning_Msg := True; Warning_Msg_Char := ' '; + elsif Msg (J) = '!' + and then (J = Msg'First or else Msg (J - 1) /= ''') + then + Is_Unconditional_Msg := True; + Warning_Msg_Char := ' '; + + if J < Msg'Last and then Msg (J + 1) = '!' then + Has_Double_Exclam := True; + end if; + elsif Msg (J) = '<' and then (J = Msg'First or else Msg (J - 1) /= ''') then @@ -1265,7 +1277,7 @@ package body Erroutc is if Is_Warning_Msg or Is_Style_Msg then Is_Serious_Error := False; end if; - end Test_Style_Warning_Serious_Msg; + end Test_Style_Warning_Serious_Unconditional_Msg; -------------------------------- -- Validate_Specific_Warnings -- diff --git a/gcc/ada/erroutc.ads b/gcc/ada/erroutc.ads index 4e38fbd30fb..02101852d44 100644 --- a/gcc/ada/erroutc.ads +++ b/gcc/ada/erroutc.ads @@ -6,7 +6,7 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 1992-2012, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- @@ -47,8 +47,20 @@ package Erroutc is Flag_Source : Source_File_Index; -- Source file index for source file where error is being posted + Has_Double_Exclam : Boolean := False; + -- Set true to indicate that the current message contains the insertion + -- sequence !! (force warnings even in non-main unit source files). + + Is_Serious_Error : Boolean := False; + -- Set True for a serious error (i.e. any message that is not a warning + -- or style message, and that does not contain a | insertion character). + + Is_Unconditional_Msg : Boolean := False; + -- Set True to indicate that the current message contains the insertion + -- character ! and is thus to be treated as an unconditional message. + Is_Warning_Msg : Boolean := False; - -- Set True to indicate if current message is warning message + -- Set True to indicate if current message is warning message (contains ?) Warning_Msg_Char : Character; -- Warning character, valid only if Is_Warning_Msg is True @@ -61,12 +73,6 @@ package Erroutc is -- Set True to indicate if the current message is a style message -- (i.e. a message whose text starts with the characters "(style)"). - Is_Serious_Error : Boolean := False; - -- Set by Set_Msg_Text to indicate if current message is serious error - - Is_Unconditional_Msg : Boolean := False; - -- Set by Set_Msg_Text to indicate if current message is unconditional - Kill_Message : Boolean := False; -- A flag used to kill weird messages (e.g. those containing uninterpreted -- implicit type references) if we have already seen at least one message @@ -490,14 +496,26 @@ package Erroutc is -- Called in response to a pragma Warnings (On) to record the source -- location from which warnings are to be turned back on. - procedure Test_Style_Warning_Serious_Msg (Msg : String); - -- Sets Is_Warning_Msg true if Msg is a warning message (contains a - -- question mark character), and False otherwise. Is_Style_Msg is set true - -- if Msg is a style message (starts with "(style)". Sets Is_Serious_Error - -- True unless the message is a warning or style/info message or contains - -- the character | indicating a non-serious error message. Note that the - -- call has no effect for continuation messages (those whose first - -- character is '\'). + procedure Test_Style_Warning_Serious_Unconditional_Msg (Msg : String); + -- Scans message text and sets the following variables: + -- + -- Is_Warning_Msg is set True if Msg is a warning message (contains a + -- question mark character), and False otherwise. + -- + -- Is_Style_Msg is set True if Msg is a style message (starts with + -- "(style)") and False otherwise. + -- + -- Is_Serious_Error is set to True unless the message is a warning or + -- style message or contains the character | (non-serious error). + -- + -- Is_Unconditional_Msg is set True if the message contains the character + -- ! and is otherwise set False. + -- + -- Has_Double_Exclam is set True if the message contains the sequence !! + -- and is otherwise set False. + -- + -- Note that the call has no effect for continuation messages (those whose + -- first character is '\'), and all variables are left unchanged. function Warnings_Suppressed (Loc : Source_Ptr) return Boolean; -- Determines if given location is covered by a warnings off suppression diff --git a/gcc/ada/errutil.adb b/gcc/ada/errutil.adb index 3a087caac66..b79ea027f50 100644 --- a/gcc/ada/errutil.adb +++ b/gcc/ada/errutil.adb @@ -6,7 +6,7 @@ -- -- -- B o d y -- -- -- --- Copyright (C) 1991-2012, Free Software Foundation, Inc. -- +-- Copyright (C) 1991-2013, 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- -- @@ -163,9 +163,9 @@ package body Errutil is -- Corresponds to the Sptr value in the error message object Optr : Source_Ptr renames Flag_Location; - -- Corresponds to the Optr value in the error message object. Note - -- that for this usage, Sptr and Optr always have the same value, - -- since we do not have to worry about generic instantiations. + -- Corresponds to the Optr value in the error message object. Note that + -- for this usage, Sptr and Optr always have the same value, since we do + -- not have to worry about generic instantiations. begin if Errors_Must_Be_Ignored then @@ -176,7 +176,7 @@ package body Errutil is raise Error_Msg_Exception; end if; - Test_Style_Warning_Serious_Msg (Msg); + Test_Style_Warning_Serious_Unconditional_Msg (Msg); Set_Msg_Text (Msg, Sptr); -- Kill continuation if parent message killed @@ -680,8 +680,8 @@ package body Errutil is ------------------ procedure Set_Msg_Text (Text : String; Flag : Source_Ptr) is - C : Character; -- Current character - P : Natural; -- Current index; + C : Character; -- Current character + P : Natural; -- Current index; begin Manual_Quote_Mode := False; @@ -744,7 +744,7 @@ package body Errutil is Set_Msg_Char ('"'); elsif C = '!' then - Is_Unconditional_Msg := True; + null; elsif C = '?' then null; diff --git a/gcc/ada/exp_attr.adb b/gcc/ada/exp_attr.adb index 9e48afe8882..00347672511 100644 --- a/gcc/ada/exp_attr.adb +++ b/gcc/ada/exp_attr.adb @@ -6500,6 +6500,7 @@ package body Exp_Attr is Attribute_Modulus | Attribute_Partition_ID | Attribute_Range | + Attribute_Restriction_Set | Attribute_Safe_Emax | Attribute_Safe_First | Attribute_Safe_Large | diff --git a/gcc/ada/exp_ch11.adb b/gcc/ada/exp_ch11.adb index 2f2506918e8..90ca6dae79b 100644 --- a/gcc/ada/exp_ch11.adb +++ b/gcc/ada/exp_ch11.adb @@ -2132,6 +2132,8 @@ package body Exp_Ch11 is Add_Str_To_Name_Buffer ("PE_Accessibility_Check"); when PE_Address_Of_Intrinsic => Add_Str_To_Name_Buffer ("PE_Address_Of_Intrinsic"); + when PE_Aliased_Parameters => + Add_Str_To_Name_Buffer ("PE_Aliased_Parameters"); when PE_All_Guards_Closed => Add_Str_To_Name_Buffer ("PE_All_Guards_Closed"); when PE_Bad_Predicated_Generic_Type => diff --git a/gcc/ada/exp_ch3.adb b/gcc/ada/exp_ch3.adb index 1e500367625..a21de7edb16 100644 --- a/gcc/ada/exp_ch3.adb +++ b/gcc/ada/exp_ch3.adb @@ -237,16 +237,19 @@ package body Exp_Ch3 is -- user-defined equality. Factored out of Predefined_Primitive_Bodies. function Make_Eq_Case - (E : Entity_Id; - CL : Node_Id; - Discr : Entity_Id := Empty) return List_Id; + (E : Entity_Id; + CL : Node_Id; + Discrs : Elist_Id := New_Elmt_List) return List_Id; -- Building block for variant record equality. Defined to share the code -- between the tagged and non-tagged case. Given a Component_List node CL, -- it generates an 'if' followed by a 'case' statement that compares all -- components of local temporaries named X and Y (that are declared as -- formals at some upper level). E provides the Sloc to be used for the - -- generated code. Discr is used as the case statement switch in the case - -- of Unchecked_Union equality. + -- generated code. + -- + -- IF E is an unchecked_union, Discrs is the list of formals created for + -- the inferred discriminants of one operand. These formals are used in + -- the generated case statements for each variant of the unchecked union. function Make_Eq_If (E : Entity_Id; @@ -4335,8 +4338,7 @@ package body Exp_Ch3 is Result_Definition => New_Reference_To (Standard_Boolean, Loc)), Declarations => New_List, Handled_Statement_Sequence => - Make_Handled_Sequence_Of_Statements (Loc, - Statements => Stmts))); + Make_Handled_Sequence_Of_Statements (Loc, Statements => Stmts))); Append_To (Pspecs, Make_Parameter_Specification (Loc, @@ -4350,57 +4352,71 @@ package body Exp_Ch3 is -- Unchecked_Unions require additional machinery to support equality. -- Two extra parameters (A and B) are added to the equality function - -- parameter list in order to capture the inferred values of the - -- discriminants in later calls. + -- parameter list for each discriminant of the type, in order to + -- capture the inferred values of the discriminants in equality calls. + -- The names of the parameters match the names of the corresponding + -- discriminant, with an added suffix. if Is_Unchecked_Union (Typ) then declare - Discr_Type : constant Node_Id := Etype (First_Discriminant (Typ)); + Discr : Entity_Id; + Discr_Type : Entity_Id; + A, B : Entity_Id; + New_Discrs : Elist_Id; - A : constant Node_Id := - Make_Defining_Identifier (Loc, - Chars => Name_A); + begin + New_Discrs := New_Elmt_List; - B : constant Node_Id := - Make_Defining_Identifier (Loc, - Chars => Name_B); + Discr := First_Discriminant (Typ); + while Present (Discr) loop + Discr_Type := Etype (Discr); + A := Make_Defining_Identifier (Loc, + Chars => New_External_Name (Chars (Discr), 'A')); - begin - -- Add A and B to the parameter list + B := Make_Defining_Identifier (Loc, + Chars => New_External_Name (Chars (Discr), 'B')); - Append_To (Pspecs, - Make_Parameter_Specification (Loc, - Defining_Identifier => A, - Parameter_Type => New_Reference_To (Discr_Type, Loc))); + -- Add new parameters to the parameter list - Append_To (Pspecs, - Make_Parameter_Specification (Loc, - Defining_Identifier => B, - Parameter_Type => New_Reference_To (Discr_Type, Loc))); + Append_To (Pspecs, + Make_Parameter_Specification (Loc, + Defining_Identifier => A, + Parameter_Type => New_Reference_To (Discr_Type, Loc))); - -- Generate the following header code to compare the inferred - -- discriminants: + Append_To (Pspecs, + Make_Parameter_Specification (Loc, + Defining_Identifier => B, + Parameter_Type => New_Reference_To (Discr_Type, Loc))); - -- if a /= b then - -- return False; - -- end if; + Append_Elmt (A, New_Discrs); - Append_To (Stmts, - Make_If_Statement (Loc, - Condition => - Make_Op_Ne (Loc, - Left_Opnd => New_Reference_To (A, Loc), - Right_Opnd => New_Reference_To (B, Loc)), - Then_Statements => New_List ( - Make_Simple_Return_Statement (Loc, - Expression => New_Occurrence_Of (Standard_False, Loc))))); + -- Generate the following code to compare each of the inferred + -- discriminants: + + -- if a /= b then + -- return False; + -- end if; + + Append_To (Stmts, + Make_If_Statement (Loc, + Condition => + Make_Op_Ne (Loc, + Left_Opnd => New_Reference_To (A, Loc), + Right_Opnd => New_Reference_To (B, Loc)), + Then_Statements => New_List ( + Make_Simple_Return_Statement (Loc, + Expression => + New_Occurrence_Of (Standard_False, Loc))))); + Next_Discriminant (Discr); + end loop; -- Generate component-by-component comparison. Note that we must - -- propagate one of the inferred discriminant formals to act as - -- the case statement switch. + -- propagate the inferred discriminants formals to act as + -- the case statement switch. Their value is added when an + -- equality call on unchecked unions is expanded. Append_List_To (Stmts, - Make_Eq_Case (Typ, Comps, A)); + Make_Eq_Case (Typ, Comps, New_Discrs)); end; -- Normal case (not unchecked union) @@ -4616,9 +4632,19 @@ package body Exp_Ch3 is ------------------ procedure Build_Master (Ptr_Typ : Entity_Id) is - Desig_Typ : constant Entity_Id := Designated_Type (Ptr_Typ); + Desig_Typ : Entity_Id := Designated_Type (Ptr_Typ); begin + -- If the designated type is an incomplete view coming from a + -- limited-with'ed package, we need to use the nonlimited view in + -- case it has tasks. + + if Ekind (Desig_Typ) in Incomplete_Kind + and then Present (Non_Limited_View (Desig_Typ)) + then + Desig_Typ := Non_Limited_View (Desig_Typ); + end if; + -- Anonymous access types are created for the components of the -- record parameter for an entry declaration. No master is created -- for such a type. @@ -7257,12 +7283,19 @@ package body Exp_Ch3 is -- When compiling in Ada 2012 mode, ensure that the accessibility -- level of the subpool access type is not deeper than that of the - -- pool_with_subpools. This check is not performed on .NET/JVM - -- since those targets do not support pools. + -- pool_with_subpools. elsif Ada_Version >= Ada_2012 and then Present (Associated_Storage_Pool (Def_Id)) + + -- Omit this check on .NET/JVM where pools are not supported + and then VM_Target = No_VM + + -- Omit this check for the case of a configurable run-time that + -- does not provide package System.Storage_Pools.Subpools. + + and then RTE_Available (RE_Root_Storage_Pool_With_Subpools) then declare Loc : constant Source_Ptr := Sloc (Def_Id); @@ -8576,15 +8609,60 @@ package body Exp_Ch3 is -- end case; function Make_Eq_Case - (E : Entity_Id; - CL : Node_Id; - Discr : Entity_Id := Empty) return List_Id + (E : Entity_Id; + CL : Node_Id; + Discrs : Elist_Id := New_Elmt_List) return List_Id is Loc : constant Source_Ptr := Sloc (E); Result : constant List_Id := New_List; Variant : Node_Id; Alt_List : List_Id; + function Corresponding_Formal (C : Node_Id) return Entity_Id; + -- Given the discriminant that controls a given variant of an unchecked + -- union, find the formal of the equality function that carries the + -- inferred value of the discriminant. + + function External_Name (E : Entity_Id) return Name_Id; + -- The value of a given discriminant is conveyed in the corresponding + -- formal parameter of the equality routine. The name of this formal + -- parameter carries a one-character suffix which is removed here. + + -------------------------- + -- Corresponding_Formal -- + -------------------------- + + function Corresponding_Formal (C : Node_Id) return Entity_Id is + Discr : constant Entity_Id := Entity (Name (Variant_Part (C))); + Elm : Elmt_Id; + + begin + Elm := First_Elmt (Discrs); + while Present (Elm) loop + if Chars (Discr) = External_Name (Node (Elm)) then + return Node (Elm); + end if; + Next_Elmt (Elm); + end loop; + + -- A formal of the proper name must be found + + raise Program_Error; + end Corresponding_Formal; + + ------------------- + -- External_Name -- + ------------------- + + function External_Name (E : Entity_Id) return Name_Id is + begin + Get_Name_String (Chars (E)); + Name_Len := Name_Len - 1; + return Name_Find; + end External_Name; + + -- Start of processing for Make_Eq_Case + begin Append_To (Result, Make_Eq_If (E, Component_Items (CL))); @@ -8604,18 +8682,21 @@ package body Exp_Ch3 is Append_To (Alt_List, Make_Case_Statement_Alternative (Loc, Discrete_Choices => New_Copy_List (Discrete_Choices (Variant)), - Statements => Make_Eq_Case (E, Component_List (Variant)))); + Statements => + Make_Eq_Case (E, Component_List (Variant), Discrs))); Next_Non_Pragma (Variant); end loop; - -- If we have an Unchecked_Union, use one of the parameters that - -- captures the discriminants. + -- If we have an Unchecked_Union, use one of the parameters of the + -- enclosing equality routine that captures the discriminant, to use + -- as the expression in the generated case statement. if Is_Unchecked_Union (E) then Append_To (Result, Make_Case_Statement (Loc, - Expression => New_Reference_To (Discr, Loc), + Expression => + New_Reference_To (Corresponding_Formal (CL), Loc), Alternatives => Alt_List)); else diff --git a/gcc/ada/exp_ch4.adb b/gcc/ada/exp_ch4.adb index 70dfce97e1d..6fec955113c 100644 --- a/gcc/ada/exp_ch4.adb +++ b/gcc/ada/exp_ch4.adb @@ -233,6 +233,16 @@ package body Exp_Ch4 is -- simple entity, and op is a comparison operator, optimizes it into a -- comparison of First and Last. + procedure Process_Transient_Object + (Decl : Node_Id; + Rel_Node : Node_Id); + -- Subsidiary routine to the expansion of expression_with_actions and if + -- expressions. Generate all the necessary code to finalize a transient + -- controlled object when the enclosing context is elaborated or evaluated. + -- Decl denotes the declaration of the transient controlled object which is + -- usually the result of a controlled function call. Rel_Node denotes the + -- context, either an expression_with_actions or an if expression. + procedure Rewrite_Comparison (N : Node_Id); -- If N is the node for a comparison whose outcome can be determined at -- compile time, then the node N can be rewritten with True or False. If @@ -715,11 +725,9 @@ package body Exp_Ch4 is (Ref : Node_Id; Built_In_Place : Boolean := False) is - Pool_Id : constant Entity_Id := Associated_Storage_Pool (PtrT); - Cond : Node_Id; - Free_Stmt : Node_Id; - Obj_Ref : Node_Id; - Stmts : List_Id; + Cond : Node_Id; + Obj_Ref : Node_Id; + Stmts : List_Id; begin if Ada_Version >= Ada_2005 @@ -751,51 +759,27 @@ package body Exp_Ch4 is Stmts := New_List; - -- Create an explicit free statement to clean up the allocated - -- object in case the accessibility check fails. Generate: - - -- Free (Obj_Ref); - - Free_Stmt := Make_Free_Statement (Loc, New_Copy (Obj_Ref)); - Set_Storage_Pool (Free_Stmt, Pool_Id); + -- Why don't we free the object ??? discussion and explanation + -- needed of why old approach did not work ??? - Append_To (Stmts, Free_Stmt); - - -- Finalize the object (if applicable), but wrap the call inside - -- a block to ensure that the object would still be deallocated in - -- case the finalization fails. Generate: - - -- begin - -- [Deep_]Finalize (Obj_Ref.all); - -- exception - -- when others => - -- Free (Obj_Ref); - -- raise; - -- end; + -- Generate: + -- [Deep_]Finalize (Obj_Ref.all); if Needs_Finalization (DesigT) then - Prepend_To (Stmts, - Make_Block_Statement (Loc, - Handled_Statement_Sequence => - Make_Handled_Sequence_Of_Statements (Loc, - Statements => New_List ( - Make_Final_Call ( - Obj_Ref => - Make_Explicit_Dereference (Loc, - Prefix => New_Copy (Obj_Ref)), - Typ => DesigT)), - - Exception_Handlers => New_List ( - Make_Exception_Handler (Loc, - Exception_Choices => New_List ( - Make_Others_Choice (Loc)), - Statements => New_List ( - New_Copy_Tree (Free_Stmt), - Make_Raise_Statement (Loc))))))); + Append_To (Stmts, + Make_Final_Call ( + Obj_Ref => + Make_Explicit_Dereference (Loc, New_Copy (Obj_Ref)), + Typ => DesigT)); end if; -- Signal the accessibility failure through a Program_Error + -- Since we may have a storage leak, I would be inclined to + -- define a new PE_ code that warns of this possibility where + -- the message would be Accessibility_Check_Failed (causing + -- storage leak) ??? + Append_To (Stmts, Make_Raise_Program_Error (Loc, Condition => New_Reference_To (Standard_True, Loc), @@ -2580,6 +2564,15 @@ package body Exp_Ch4 is Full_Type := Base_Type (Full_Type); + -- When the base type itself is private, use the full view to expand + -- the composite equality. + + if Is_Private_Type (Full_Type) then + Full_Type := Underlying_Type (Full_Type); + end if; + + -- Case of array types + if Is_Array_Type (Full_Type) then -- If the operand is an elementary type other than a floating-point @@ -2602,6 +2595,8 @@ package body Exp_Ch4 is return Expand_Array_Equality (Nod, Lhs, Rhs, Bodies, Full_Type); end if; + -- Case of tagged record types + elsif Is_Tagged_Type (Full_Type) then -- Call the primitive operation "=" of this type @@ -2646,6 +2641,8 @@ package body Exp_Ch4 is (Unchecked_Convert_To (Etype (First_Formal (Eq_Op)), Lhs), Unchecked_Convert_To (Etype (First_Formal (Eq_Op)), Rhs))); + -- Case of untagged record types + elsif Is_Record_Type (Full_Type) then Eq_Op := TSS (Full_Type, TSS_Composite_Equality); @@ -2793,7 +2790,7 @@ package body Exp_Ch4 is elsif Ada_Version >= Ada_2012 or else Is_Bounded_String (Typ) then - -- if no TSS has been created for the type, check whether there is + -- If no TSS has been created for the type, check whether there is -- a primitive equality declared for it. declare @@ -2814,9 +2811,9 @@ package body Exp_Ch4 is return Expand_Record_Equality (Nod, Full_Type, Lhs, Rhs, Bodies); end if; - else - -- If not array or record type, it is predefined equality. + -- Non-composite types (always use predefined equality) + else return Make_Op_Eq (Loc, Left_Opnd => Lhs, Right_Opnd => Rhs); end if; end Expand_Composite_Equality; @@ -5020,306 +5017,23 @@ package body Exp_Ch4 is -------------------------------------- procedure Expand_N_Expression_With_Actions (N : Node_Id) is - In_Case_Or_If_Expression : constant Boolean := - Within_Case_Or_If_Expression (N); - function Process_Action (Act : Node_Id) return Traverse_Result; - -- Inspect and process a single action of an expression_with_actions + -- Inspect and process a single action of an expression_with_actions for + -- transient controlled objects. If such objects are found, the routine + -- generates code to clean them up when the context of the expression is + -- evaluated or elaborated. -------------------- -- Process_Action -- -------------------- function Process_Action (Act : Node_Id) return Traverse_Result is - procedure Process_Transient_Object (Obj_Decl : Node_Id); - -- Obj_Decl denotes the declaration of a transient controlled object. - -- Generate all necessary types and hooks to properly finalize the - -- result when the enclosing context is elaborated/evaluated. - - ------------------------------ - -- Process_Transient_Object -- - ------------------------------ - - procedure Process_Transient_Object (Obj_Decl : Node_Id) is - function Find_Enclosing_Context return Node_Id; - -- Find the context where the expression_with_actions appears - - ---------------------------- - -- Find_Enclosing_Context -- - ---------------------------- - - function Find_Enclosing_Context return Node_Id is - Par : Node_Id; - Top : Node_Id; - - begin - -- The expression_with_actions is in a case/if expression and - -- the lifetime of any temporary controlled object is therefore - -- extended. Find a suitable insertion node by locating the top - -- most case or if expressions. - - if In_Case_Or_If_Expression then - Par := N; - Top := N; - while Present (Par) loop - if Nkind_In (Original_Node (Par), N_Case_Expression, - N_If_Expression) - then - Top := Par; - - -- Prevent the search from going too far - - elsif Is_Body_Or_Package_Declaration (Par) then - exit; - end if; - - Par := Parent (Par); - end loop; - - -- The topmost case or if expression is now recovered, but - -- it may still not be the correct place to add all the - -- generated code. Climb to find a parent that is part of a - -- declarative or statement list. - - Par := Top; - while Present (Par) loop - if Is_List_Member (Par) - and then - not Nkind_In (Par, N_Component_Association, - N_Discriminant_Association, - N_Parameter_Association, - N_Pragma_Argument_Association) - then - return Par; - - -- Prevent the search from going too far - - elsif Is_Body_Or_Package_Declaration (Par) then - exit; - end if; - - Par := Parent (Par); - end loop; - - return Par; - - -- Short circuit operators in complex expressions are converted - -- into expression_with_actions. - - else - -- Take care of the case where the expression_with_actions - -- is buried deep inside an IF statement. The temporary - -- function result must be finalized before the then, elsif - -- or else statements are evaluated. - - -- if Something - -- and then Ctrl_Func_Call - -- then - -- <result must be finalized at this point> - -- <statements> - -- end if; - - -- To achieve this, find the topmost logical operator. The - -- generated actions are then inserted before/after it. - - Par := N; - while Present (Par) loop - - -- Keep climbing past various operators - - if Nkind (Parent (Par)) in N_Op - or else Nkind_In (Parent (Par), N_And_Then, N_Or_Else) - then - Par := Parent (Par); - else - exit; - end if; - end loop; - - Top := Par; - - -- The expression_with_actions might be located in a pragma - -- in which case locate the pragma itself: - - -- pragma Precondition (... and then Ctrl_Func_Call ...); - - -- Similar case occurs when the expression_with_actions is - -- related to an object declaration or assignment: - - -- Obj [: Some_Typ] := ... and then Ctrl_Func_Call ...; - - -- Another case to consider is an expression_with_actions as - -- part of a return statement: - - -- return ... and then Ctrl_Func_Call ...; - - -- Yet another case: a formal in a procedure call statement: - - -- Proc (... and then Ctrl_Func_Call ...); - - while Present (Par) loop - if Nkind_In (Par, N_Assignment_Statement, - N_Object_Declaration, - N_Pragma, - N_Procedure_Call_Statement, - N_Simple_Return_Statement) - then - return Par; - - -- Prevent the search from going too far - - elsif Is_Body_Or_Package_Declaration (Par) then - exit; - end if; - - Par := Parent (Par); - end loop; - - -- Return the topmost short circuit operator - - return Top; - end if; - end Find_Enclosing_Context; - - -- Local variables - - Context : constant Node_Id := Find_Enclosing_Context; - Loc : constant Source_Ptr := Sloc (Obj_Decl); - Obj_Id : constant Entity_Id := Defining_Identifier (Obj_Decl); - Obj_Typ : constant Node_Id := Etype (Obj_Id); - Desig_Typ : Entity_Id; - Expr : Node_Id; - Fin_Call : Node_Id; - Ptr_Id : Entity_Id; - Temp_Id : Entity_Id; - - -- Start of processing for Process_Transient_Object - - begin - -- Step 1: Create the access type which provides a reference to - -- the transient object. - - if Is_Access_Type (Obj_Typ) then - Desig_Typ := Directly_Designated_Type (Obj_Typ); - else - Desig_Typ := Obj_Typ; - end if; - - Desig_Typ := Base_Type (Desig_Typ); - - -- Generate: - -- Ann : access [all] <Desig_Typ>; - - Ptr_Id := Make_Temporary (Loc, 'A'); - - Insert_Action (Context, - Make_Full_Type_Declaration (Loc, - Defining_Identifier => Ptr_Id, - Type_Definition => - Make_Access_To_Object_Definition (Loc, - All_Present => - Ekind (Obj_Typ) = E_General_Access_Type, - Subtype_Indication => New_Reference_To (Desig_Typ, Loc)))); - - -- Step 2: Create a temporary which acts as a hook to the - -- transient object. Generate: - - -- Temp : Ptr_Id := null; - - Temp_Id := Make_Temporary (Loc, 'T'); - - Insert_Action (Context, - Make_Object_Declaration (Loc, - Defining_Identifier => Temp_Id, - Object_Definition => New_Reference_To (Ptr_Id, Loc))); - - -- Mark this temporary as created for the purposes of exporting - -- the transient declaration out of the Actions list. This signals - -- the machinery in Build_Finalizer to recognize this special - -- case. - - Set_Status_Flag_Or_Transient_Decl (Temp_Id, Obj_Decl); - - -- Step 3: Hook the transient object to the temporary - - -- The use of unchecked conversion / unrestricted access is needed - -- to avoid an accessibility violation. Note that the finalization - -- code is structured in such a way that the "hook" is processed - -- only when it points to an existing object. - - if Is_Access_Type (Obj_Typ) then - Expr := - Unchecked_Convert_To (Ptr_Id, New_Reference_To (Obj_Id, Loc)); - else - Expr := - Make_Attribute_Reference (Loc, - Prefix => New_Reference_To (Obj_Id, Loc), - Attribute_Name => Name_Unrestricted_Access); - end if; - - -- Generate: - -- Temp := Ptr_Id (Obj_Id); - -- <or> - -- Temp := Obj_Id'Unrestricted_Access; - - Insert_After_And_Analyze (Obj_Decl, - Make_Assignment_Statement (Loc, - Name => New_Reference_To (Temp_Id, Loc), - Expression => Expr)); - - -- Step 4: Finalize the function result after the context has been - -- evaluated/elaborated. Generate: - - -- if Temp /= null then - -- [Deep_]Finalize (Temp.all); - -- Temp := null; - -- end if; - - -- When the expression_with_actions is part of a return statement, - -- there is no need to insert a finalization call, as the general - -- finalization mechanism (see Build_Finalizer) would take care of - -- the temporary function result on subprogram exit. Note that it - -- would also be impossible to insert the finalization code after - -- the return statement as this would make it unreachable. - - if Nkind (Context) /= N_Simple_Return_Statement then - Fin_Call := - Make_Implicit_If_Statement (Obj_Decl, - Condition => - Make_Op_Ne (Loc, - Left_Opnd => New_Reference_To (Temp_Id, Loc), - Right_Opnd => Make_Null (Loc)), - - Then_Statements => New_List ( - Make_Final_Call - (Obj_Ref => - Make_Explicit_Dereference (Loc, - Prefix => New_Reference_To (Temp_Id, Loc)), - Typ => Desig_Typ), - - Make_Assignment_Statement (Loc, - Name => New_Reference_To (Temp_Id, Loc), - Expression => Make_Null (Loc)))); - - -- Use the Actions list of logical operators when inserting the - -- finalization call. This ensures that all transient objects - -- are finalized after the operators are evaluated. - - if Nkind_In (Context, N_And_Then, N_Or_Else) then - Insert_Action (Context, Fin_Call); - else - Insert_Action_After (Context, Fin_Call); - end if; - end if; - end Process_Transient_Object; - - -- Start of processing for Process_Action - begin if Nkind (Act) = N_Object_Declaration and then Is_Finalizable_Transient (Act, N) then - Process_Transient_Object (Act); + Process_Transient_Object (Act, N); + return Abandon; -- Avoid processing temporary function results multiple times when -- dealing with nested expression_with_actions. @@ -5327,8 +5041,8 @@ package body Exp_Ch4 is elsif Nkind (Act) = N_Expression_With_Actions then return Abandon; - -- Do not process temporary function results in loops. This is - -- done by Expand_N_Loop_Statement and Build_Finalizer. + -- Do not process temporary function results in loops. This is done + -- by Expand_N_Loop_Statement and Build_Finalizer. elsif Nkind (Act) = N_Loop_Statement then return Abandon; @@ -5361,67 +5075,31 @@ package body Exp_Ch4 is -- Deal with limited types and condition actions procedure Expand_N_If_Expression (N : Node_Id) is - function Create_Alternative - (Loc : Source_Ptr; - Temp_Id : Entity_Id; - Flag_Id : Entity_Id; - Expr : Node_Id) return List_Id; - -- Build the statements of a "then" or "else" dependent expression - -- alternative. Temp_Id is the if expression result, Flag_Id is a - -- finalization flag created to service expression Expr. - - function Is_Controlled_Function_Call (Expr : Node_Id) return Boolean; - -- Determine if expression Expr is a rewritten controlled function call + procedure Process_Actions (Actions : List_Id); + -- Inspect and process a single action list of an if expression for + -- transient controlled objects. If such objects are found, the routine + -- generates code to clean them up when the context of the expression is + -- evaluated or elaborated. - ------------------------ - -- Create_Alternative -- - ------------------------ + --------------------- + -- Process_Actions -- + --------------------- - function Create_Alternative - (Loc : Source_Ptr; - Temp_Id : Entity_Id; - Flag_Id : Entity_Id; - Expr : Node_Id) return List_Id - is - Result : constant List_Id := New_List; + procedure Process_Actions (Actions : List_Id) is + Act : Node_Id; begin - -- Generate: - -- Fnn := True; - - if Present (Flag_Id) - and then not Is_Controlled_Function_Call (Expr) - then - Append_To (Result, - Make_Assignment_Statement (Loc, - Name => New_Reference_To (Flag_Id, Loc), - Expression => New_Reference_To (Standard_True, Loc))); - end if; - - -- Generate: - -- Cnn := <expr>'Unrestricted_Access; - - Append_To (Result, - Make_Assignment_Statement (Loc, - Name => New_Reference_To (Temp_Id, Loc), - Expression => - Make_Attribute_Reference (Loc, - Prefix => Relocate_Node (Expr), - Attribute_Name => Name_Unrestricted_Access))); - - return Result; - end Create_Alternative; - - --------------------------------- - -- Is_Controlled_Function_Call -- - --------------------------------- + Act := First (Actions); + while Present (Act) loop + if Nkind (Act) = N_Object_Declaration + and then Is_Finalizable_Transient (Act, N) + then + Process_Transient_Object (Act, N); + end if; - function Is_Controlled_Function_Call (Expr : Node_Id) return Boolean is - begin - return - Nkind (Original_Node (Expr)) = N_Function_Call - and then Needs_Finalization (Etype (Expr)); - end Is_Controlled_Function_Call; + Next (Act); + end loop; + end Process_Actions; -- Local variables @@ -5437,6 +5115,7 @@ package body Exp_Ch4 is Expr : Node_Id; New_If : Node_Id; New_N : Node_Id; + Ptr_Typ : Entity_Id; -- Start of processing for Expand_N_If_Expression @@ -5509,70 +5188,66 @@ package body Exp_Ch4 is if Is_By_Reference_Type (Typ) and then not Back_End_Handles_Limited_Types then - declare - Flag_Id : Entity_Id; - Ptr_Typ : Entity_Id; + -- When the "then" or "else" expressions involve controlled function + -- calls, generated temporaries are chained on the corresponding list + -- of actions. These temporaries need to be finalized after the if + -- expression is evaluated. - begin - Flag_Id := Empty; + Process_Actions (Then_Actions (N)); + Process_Actions (Else_Actions (N)); - -- At least one of the if expression dependent expressions uses a - -- controlled function to provide the result. Create a status flag - -- to signal the finalization machinery that Cnn needs special - -- handling. - - if Is_Controlled_Function_Call (Thenx) - or else - Is_Controlled_Function_Call (Elsex) - then - Flag_Id := Make_Temporary (Loc, 'F'); + -- Generate: + -- type Ann is access all Typ; - Insert_Action (N, - Make_Object_Declaration (Loc, - Defining_Identifier => Flag_Id, - Object_Definition => - New_Reference_To (Standard_Boolean, Loc), - Expression => - New_Reference_To (Standard_False, Loc))); - end if; + Ptr_Typ := Make_Temporary (Loc, 'A'); - -- Generate: - -- type Ann is access all Typ; + Insert_Action (N, + Make_Full_Type_Declaration (Loc, + Defining_Identifier => Ptr_Typ, + Type_Definition => + Make_Access_To_Object_Definition (Loc, + All_Present => True, + Subtype_Indication => New_Reference_To (Typ, Loc)))); - Ptr_Typ := Make_Temporary (Loc, 'A'); + -- Generate: + -- Cnn : Ann; - Insert_Action (N, - Make_Full_Type_Declaration (Loc, - Defining_Identifier => Ptr_Typ, - Type_Definition => - Make_Access_To_Object_Definition (Loc, - All_Present => True, - Subtype_Indication => New_Reference_To (Typ, Loc)))); + Cnn := Make_Temporary (Loc, 'C', N); - -- Generate: - -- Cnn : Ann; + Decl := + Make_Object_Declaration (Loc, + Defining_Identifier => Cnn, + Object_Definition => New_Occurrence_Of (Ptr_Typ, Loc)); - Cnn := Make_Temporary (Loc, 'C', N); - Set_Ekind (Cnn, E_Variable); - Set_Status_Flag_Or_Transient_Decl (Cnn, Flag_Id); + -- Generate: + -- if Cond then + -- Cnn := <Thenx>'Unrestricted_Access; + -- else + -- Cnn := <Elsex>'Unrestricted_Access; + -- end if; - Decl := - Make_Object_Declaration (Loc, - Defining_Identifier => Cnn, - Object_Definition => New_Occurrence_Of (Ptr_Typ, Loc)); + New_If := + Make_Implicit_If_Statement (N, + Condition => Relocate_Node (Cond), + Then_Statements => New_List ( + Make_Assignment_Statement (Sloc (Thenx), + Name => New_Reference_To (Cnn, Sloc (Thenx)), + Expression => + Make_Attribute_Reference (Loc, + Prefix => Relocate_Node (Thenx), + Attribute_Name => Name_Unrestricted_Access))), - New_If := - Make_Implicit_If_Statement (N, - Condition => Relocate_Node (Cond), - Then_Statements => - Create_Alternative (Sloc (Thenx), Cnn, Flag_Id, Thenx), - Else_Statements => - Create_Alternative (Sloc (Elsex), Cnn, Flag_Id, Elsex)); + Else_Statements => New_List ( + Make_Assignment_Statement (Sloc (Elsex), + Name => New_Reference_To (Cnn, Sloc (Elsex)), + Expression => + Make_Attribute_Reference (Loc, + Prefix => Relocate_Node (Elsex), + Attribute_Name => Name_Unrestricted_Access)))); New_N := Make_Explicit_Dereference (Loc, Prefix => New_Occurrence_Of (Cnn, Loc)); - end; -- For other types, we only need to expand if there are other actions -- associated with either branch. @@ -5583,26 +5258,28 @@ package body Exp_Ch4 is if Present (Then_Actions (N)) then Rewrite (Thenx, - Make_Expression_With_Actions (Sloc (Thenx), - Actions => Then_Actions (N), - Expression => Relocate_Node (Thenx))); + Make_Expression_With_Actions (Sloc (Thenx), + Actions => Then_Actions (N), + Expression => Relocate_Node (Thenx))); + Set_Then_Actions (N, No_List); Analyze_And_Resolve (Thenx, Typ); end if; if Present (Else_Actions (N)) then Rewrite (Elsex, - Make_Expression_With_Actions (Sloc (Elsex), - Actions => Else_Actions (N), - Expression => Relocate_Node (Elsex))); + Make_Expression_With_Actions (Sloc (Elsex), + Actions => Else_Actions (N), + Expression => Relocate_Node (Elsex))); + Set_Else_Actions (N, No_List); Analyze_And_Resolve (Elsex, Typ); end if; return; - -- If no actions then no expansion needed, gigi will handle it using - -- the same approach as a C conditional expression. + -- If no actions then no expansion needed, gigi will handle it using the + -- same approach as a C conditional expression. else return; @@ -6926,17 +6603,26 @@ package body Exp_Ch4 is if Is_Unchecked_Union (Op_Type) then declare - Lhs_Type : constant Node_Id := Etype (L_Exp); - Rhs_Type : constant Node_Id := Etype (R_Exp); - Lhs_Discr_Val : Node_Id; - Rhs_Discr_Val : Node_Id; + Lhs_Type : constant Node_Id := Etype (L_Exp); + Rhs_Type : constant Node_Id := Etype (R_Exp); + + Lhs_Discr_Vals : Elist_Id; + -- List of inferred discriminant values for left operand. + + Rhs_Discr_Vals : Elist_Id; + -- List of inferred discriminant values for right operand. + + Discr : Entity_Id; begin + Lhs_Discr_Vals := New_Elmt_List; + Rhs_Discr_Vals := New_Elmt_List; + -- Per-object constrained selected components require special -- attention. If the enclosing scope of the component is an -- Unchecked_Union, we cannot reference its discriminants - -- directly. This is why we use the two extra parameters of - -- the equality function of the enclosing Unchecked_Union. + -- directly. This is why we use the extra parameters of the + -- equality function of the enclosing Unchecked_Union. -- type UU_Type (Discr : Integer := 0) is -- . . . @@ -6963,7 +6649,8 @@ package body Exp_Ch4 is -- A and B are the formal parameters of the equality function -- of Enclosing_UU_Type. The function always has two extra - -- formals to capture the inferred discriminant values. + -- formals to capture the inferred discriminant values for + -- each discriminant of the type. -- 2. Non-Unchecked_Union enclosing record: @@ -6988,86 +6675,140 @@ package body Exp_Ch4 is -- In this case we can directly reference the discriminants of -- the enclosing record. - -- Lhs of equality + -- Process left operand of equality if Nkind (Lhs) = N_Selected_Component and then Has_Per_Object_Constraint (Entity (Selector_Name (Lhs))) then - -- Enclosing record is an Unchecked_Union, use formal A + -- If enclosing record is an Unchecked_Union, use formals + -- corresponding to each discriminant. The name of the + -- formal is that of the discriminant, with added suffix, + -- see Exp_Ch3.Build_Record_Equality for details. if Is_Unchecked_Union (Scope (Entity (Selector_Name (Lhs)))) then - Lhs_Discr_Val := Make_Identifier (Loc, Name_A); + Discr := + First_Discriminant + (Scope (Entity (Selector_Name (Lhs)))); + while Present (Discr) loop + Append_Elmt ( + Make_Identifier (Loc, + Chars => New_External_Name (Chars (Discr), 'A')), + To => Lhs_Discr_Vals); + Next_Discriminant (Discr); + end loop; - -- Enclosing record is of a non-Unchecked_Union type, it is - -- possible to reference the discriminant. + -- If enclosing record is of a non-Unchecked_Union type, it + -- is possible to reference its discriminants directly. else - Lhs_Discr_Val := - Make_Selected_Component (Loc, - Prefix => Prefix (Lhs), - Selector_Name => - New_Copy - (Get_Discriminant_Value - (First_Discriminant (Lhs_Type), - Lhs_Type, - Stored_Constraint (Lhs_Type)))); + Discr := First_Discriminant (Lhs_Type); + while Present (Discr) loop + Append_Elmt ( + Make_Selected_Component (Loc, + Prefix => Prefix (Lhs), + Selector_Name => + New_Copy + (Get_Discriminant_Value (Discr, + Lhs_Type, + Stored_Constraint (Lhs_Type)))), + To => Lhs_Discr_Vals); + Next_Discriminant (Discr); + end loop; end if; - -- Comment needed here ??? + -- Otherwise operand is on object with a constrained type. + -- Infer the discriminant values from the constraint. else - -- Infer the discriminant value - - Lhs_Discr_Val := - New_Copy - (Get_Discriminant_Value - (First_Discriminant (Lhs_Type), - Lhs_Type, - Stored_Constraint (Lhs_Type))); + + Discr := First_Discriminant (Lhs_Type); + while Present (Discr) loop + Append_Elmt ( + New_Copy + (Get_Discriminant_Value (Discr, + Lhs_Type, + Stored_Constraint (Lhs_Type))), + To => Lhs_Discr_Vals); + Next_Discriminant (Discr); + end loop; end if; - -- Rhs of equality + -- Similar processing for right operand of equality if Nkind (Rhs) = N_Selected_Component and then Has_Per_Object_Constraint (Entity (Selector_Name (Rhs))) then if Is_Unchecked_Union - (Scope (Entity (Selector_Name (Rhs)))) + (Scope (Entity (Selector_Name (Rhs)))) then - Rhs_Discr_Val := Make_Identifier (Loc, Name_B); + Discr := + First_Discriminant + (Scope (Entity (Selector_Name (Rhs)))); + while Present (Discr) loop + Append_Elmt ( + Make_Identifier (Loc, + Chars => New_External_Name (Chars (Discr), 'B')), + To => Rhs_Discr_Vals); + Next_Discriminant (Discr); + end loop; else - Rhs_Discr_Val := - Make_Selected_Component (Loc, - Prefix => Prefix (Rhs), - Selector_Name => - New_Copy (Get_Discriminant_Value ( - First_Discriminant (Rhs_Type), - Rhs_Type, - Stored_Constraint (Rhs_Type)))); - + Discr := First_Discriminant (Rhs_Type); + while Present (Discr) loop + Append_Elmt ( + Make_Selected_Component (Loc, + Prefix => Prefix (Rhs), + Selector_Name => + New_Copy (Get_Discriminant_Value + (Discr, + Rhs_Type, + Stored_Constraint (Rhs_Type)))), + To => Rhs_Discr_Vals); + Next_Discriminant (Discr); + end loop; end if; - else - Rhs_Discr_Val := - New_Copy (Get_Discriminant_Value ( - First_Discriminant (Rhs_Type), - Rhs_Type, - Stored_Constraint (Rhs_Type))); + else + Discr := First_Discriminant (Rhs_Type); + while Present (Discr) loop + Append_Elmt ( + New_Copy (Get_Discriminant_Value + (Discr, + Rhs_Type, + Stored_Constraint (Rhs_Type))), + To => Rhs_Discr_Vals); + Next_Discriminant (Discr); + end loop; end if; - Rewrite (N, - Make_Function_Call (Loc, - Name => New_Reference_To (Eq, Loc), - Parameter_Associations => New_List ( - L_Exp, - R_Exp, - Lhs_Discr_Val, - Rhs_Discr_Val))); + -- Now merge the list of discriminant values so that values + -- of corresponding discriminants are adjacent. + + declare + Params : List_Id; + L_Elmt : Elmt_Id; + R_Elmt : Elmt_Id; + + begin + Params := New_List (L_Exp, R_Exp); + L_Elmt := First_Elmt (Lhs_Discr_Vals); + R_Elmt := First_Elmt (Rhs_Discr_Vals); + while Present (L_Elmt) loop + Append_To (Params, Node (L_Elmt)); + Append_To (Params, Node (R_Elmt)); + Next_Elmt (L_Elmt); + Next_Elmt (R_Elmt); + end loop; + + Rewrite (N, + Make_Function_Call (Loc, + Name => New_Reference_To (Eq, Loc), + Parameter_Associations => Params)); + end; end; -- Normal case, not an unchecked union @@ -7075,7 +6816,7 @@ package body Exp_Ch4 is else Rewrite (N, Make_Function_Call (Loc, - Name => New_Reference_To (Eq, Loc), + Name => New_Reference_To (Eq, Loc), Parameter_Associations => New_List (L_Exp, R_Exp))); end if; @@ -7456,6 +7197,27 @@ package body Exp_Ch4 is Build_Equality_Call (TSS (Root_Type (Typl), TSS_Composite_Equality)); + -- When comparing two Bounded_Strings, use the primitive equality of + -- the root Super_String type. + + elsif Is_Bounded_String (Typl) then + Prim := + First_Elmt (Collect_Primitive_Operations (Root_Type (Typl))); + + while Present (Prim) loop + exit when Chars (Node (Prim)) = Name_Op_Eq + and then Etype (First_Formal (Node (Prim))) = + Etype (Next_Formal (First_Formal (Node (Prim)))) + and then Base_Type (Etype (Node (Prim))) = Standard_Boolean; + + Next_Elmt (Prim); + end loop; + + -- A Super_String type should always have a primitive equality + + pragma Assert (Present (Prim)); + Build_Equality_Call (Node (Prim)); + -- Otherwise expand the component by component equality. Note that -- we never use block-bit comparisons for records, because of the -- problems with gaps. The backend will often be able to recombine @@ -10932,11 +10694,11 @@ package body Exp_Ch4 is Expand_Composite_Equality (Nod, Etype (C), Lhs => Make_Selected_Component (Loc, - Prefix => New_Lhs, + Prefix => New_Lhs, Selector_Name => New_Reference_To (C, Loc)), Rhs => Make_Selected_Component (Loc, - Prefix => New_Rhs, + Prefix => New_Rhs, Selector_Name => New_Reference_To (C, Loc)), Bodies => Bodies); @@ -12291,6 +12053,282 @@ package body Exp_Ch4 is return; end Optimize_Length_Comparison; + ------------------------------ + -- Process_Transient_Object -- + ------------------------------ + + procedure Process_Transient_Object + (Decl : Node_Id; + Rel_Node : Node_Id) + is + function Find_Enclosing_Context (N : Node_Id) return Node_Id; + -- Find the logical context where N appears. The context is chosen such + -- that it is possible to insert before and after it. + + ---------------------------- + -- Find_Enclosing_Context -- + ---------------------------- + + function Find_Enclosing_Context (N : Node_Id) return Node_Id is + Par : Node_Id; + Top : Node_Id; + + begin + -- When the node is inside a case/if expression, the lifetime of any + -- temporary controlled object is extended. Find a suitable insertion + -- node by locating the topmost case or if expressions. + + if Within_Case_Or_If_Expression (N) then + Par := N; + Top := N; + while Present (Par) loop + if Nkind_In (Original_Node (Par), N_Case_Expression, + N_If_Expression) + then + Top := Par; + + -- Prevent the search from going too far + + elsif Is_Body_Or_Package_Declaration (Par) then + exit; + end if; + + Par := Parent (Par); + end loop; + + -- The topmost case or if expression is now recovered, but it may + -- still not be the correct place to add generated code. Climb to + -- find a parent that is part of a declarative or statement list. + + Par := Top; + while Present (Par) loop + if Is_List_Member (Par) + and then not Nkind_In (Par, N_Component_Association, + N_Discriminant_Association, + N_Parameter_Association, + N_Pragma_Argument_Association) + then + return Par; + + -- Prevent the search from going too far + + elsif Is_Body_Or_Package_Declaration (Par) then + exit; + end if; + + Par := Parent (Par); + end loop; + + return Par; + + -- Short circuit operators in complex expressions are converted into + -- expression_with_actions. + + else + -- Handle the case where the node is buried deep inside an if + -- statement. The temporary controlled object must be finalized + -- before the then, elsif or else statements are evaluated. + + -- if Something + -- and then Ctrl_Func_Call + -- then + -- <result must be finalized at this point> + -- <statements> + -- end if; + + -- To achieve this, find the topmost logical operator. Generated + -- actions are then inserted before/after it. + + Par := N; + while Present (Par) loop + + -- Keep climbing past various operators + + if Nkind (Parent (Par)) in N_Op + or else Nkind_In (Parent (Par), N_And_Then, N_Or_Else) + then + Par := Parent (Par); + else + exit; + end if; + end loop; + + Top := Par; + + -- The node may be located in a pragma in which case return the + -- pragma itself: + + -- pragma Precondition (... and then Ctrl_Func_Call ...); + + -- Similar case occurs when the node is related to an object + -- declaration or assignment: + + -- Obj [: Some_Typ] := ... and then Ctrl_Func_Call ...; + + -- Another case to consider is when the node is part of a return + -- statement: + + -- return ... and then Ctrl_Func_Call ...; + + -- Another case is when the node acts as a formal in a procedure + -- call statement: + + -- Proc (... and then Ctrl_Func_Call ...); + + while Present (Par) loop + if Nkind_In (Par, N_Assignment_Statement, + N_Object_Declaration, + N_Pragma, + N_Procedure_Call_Statement, + N_Simple_Return_Statement) + then + return Par; + + -- Prevent the search from going too far + + elsif Is_Body_Or_Package_Declaration (Par) then + exit; + end if; + + Par := Parent (Par); + end loop; + + -- Return the topmost short circuit operator + + return Top; + end if; + end Find_Enclosing_Context; + + -- Local variables + + Context : constant Node_Id := Find_Enclosing_Context (Rel_Node); + Loc : constant Source_Ptr := Sloc (Decl); + Obj_Id : constant Entity_Id := Defining_Identifier (Decl); + Obj_Typ : constant Node_Id := Etype (Obj_Id); + Desig_Typ : Entity_Id; + Expr : Node_Id; + Fin_Call : Node_Id; + Ptr_Id : Entity_Id; + Temp_Id : Entity_Id; + + -- Start of processing for Process_Transient_Object + + begin + -- Step 1: Create the access type which provides a reference to the + -- transient controlled object. + + if Is_Access_Type (Obj_Typ) then + Desig_Typ := Directly_Designated_Type (Obj_Typ); + else + Desig_Typ := Obj_Typ; + end if; + + Desig_Typ := Base_Type (Desig_Typ); + + -- Generate: + -- Ann : access [all] <Desig_Typ>; + + Ptr_Id := Make_Temporary (Loc, 'A'); + + Insert_Action (Context, + Make_Full_Type_Declaration (Loc, + Defining_Identifier => Ptr_Id, + Type_Definition => + Make_Access_To_Object_Definition (Loc, + All_Present => Ekind (Obj_Typ) = E_General_Access_Type, + Subtype_Indication => New_Reference_To (Desig_Typ, Loc)))); + + -- Step 2: Create a temporary which acts as a hook to the transient + -- controlled object. Generate: + + -- Temp : Ptr_Id := null; + + Temp_Id := Make_Temporary (Loc, 'T'); + + Insert_Action (Context, + Make_Object_Declaration (Loc, + Defining_Identifier => Temp_Id, + Object_Definition => New_Reference_To (Ptr_Id, Loc))); + + -- Mark the temporary as created for the purposes of exporting the + -- transient controlled object out of the expression_with_action or if + -- expression. This signals the machinery in Build_Finalizer to treat + -- this case specially. + + Set_Status_Flag_Or_Transient_Decl (Temp_Id, Decl); + + -- Step 3: Hook the transient object to the temporary + + -- The use of unchecked conversion / unrestricted access is needed to + -- avoid an accessibility violation. Note that the finalization code is + -- structured in such a way that the "hook" is processed only when it + -- points to an existing object. + + if Is_Access_Type (Obj_Typ) then + Expr := Unchecked_Convert_To (Ptr_Id, New_Reference_To (Obj_Id, Loc)); + else + Expr := + Make_Attribute_Reference (Loc, + Prefix => New_Reference_To (Obj_Id, Loc), + Attribute_Name => Name_Unrestricted_Access); + end if; + + -- Generate: + -- Temp := Ptr_Id (Obj_Id); + -- <or> + -- Temp := Obj_Id'Unrestricted_Access; + + Insert_After_And_Analyze (Decl, + Make_Assignment_Statement (Loc, + Name => New_Reference_To (Temp_Id, Loc), + Expression => Expr)); + + -- Step 4: Finalize the transient controlled object after the context + -- has been evaluated/elaborated. Generate: + + -- if Temp /= null then + -- [Deep_]Finalize (Temp.all); + -- Temp := null; + -- end if; + + -- When the node is part of a return statement, there is no need to + -- insert a finalization call, as the general finalization mechanism + -- (see Build_Finalizer) would take care of the transient controlled + -- object on subprogram exit. Note that it would also be impossible to + -- insert the finalization code after the return statement as this will + -- render it unreachable. + + if Nkind (Context) /= N_Simple_Return_Statement then + Fin_Call := + Make_Implicit_If_Statement (Decl, + Condition => + Make_Op_Ne (Loc, + Left_Opnd => New_Reference_To (Temp_Id, Loc), + Right_Opnd => Make_Null (Loc)), + + Then_Statements => New_List ( + Make_Final_Call + (Obj_Ref => + Make_Explicit_Dereference (Loc, + Prefix => New_Reference_To (Temp_Id, Loc)), + Typ => Desig_Typ), + + Make_Assignment_Statement (Loc, + Name => New_Reference_To (Temp_Id, Loc), + Expression => Make_Null (Loc)))); + + -- Use the Actions list of logical operators when inserting the + -- finalization call. This ensures that all transient controlled + -- objects are finalized after the operators are evaluated. + + if Nkind_In (Context, N_And_Then, N_Or_Else) then + Insert_Action (Context, Fin_Call); + else + Insert_Action_After (Context, Fin_Call); + end if; + end if; + end Process_Transient_Object; + ------------------------ -- Rewrite_Comparison -- ------------------------ diff --git a/gcc/ada/exp_ch6.adb b/gcc/ada/exp_ch6.adb index 34f61c894d6..d48544fdada 100644 --- a/gcc/ada/exp_ch6.adb +++ b/gcc/ada/exp_ch6.adb @@ -3782,7 +3782,7 @@ package body Exp_Ch6 is -- We perform these optimization regardless of whether we are in the -- main unit or in a unit in the context of the main unit, to ensure - -- that tree generated is the same in both cases, for Inspector use. + -- that tree generated is the same in both cases, for CodePeer use. if Is_RTE (Subp, RE_To_Address) then Rewrite (Call_Node, @@ -4680,7 +4680,8 @@ package body Exp_Ch6 is function Process_Formals (N : Node_Id) return Traverse_Result; -- Replace occurrence of a formal with the corresponding actual, or the - -- thunk generated for it. + -- thunk generated for it. Replace a return statement with an assignment + -- to the target of the call, with appropriate conversions if needed. function Process_Sloc (Nod : Node_Id) return Traverse_Result; -- If the call being expanded is that of an internal subprogram, set the @@ -4808,9 +4809,14 @@ package body Exp_Ch6 is -- errors, e.g. when the expression is a numeric literal and -- the context is private. If the expression is an aggregate, -- use a qualified expression, because an aggregate is not a - -- legal argument of a conversion. + -- legal argument of a conversion. Ditto for numeric literals, + -- which must be resolved to a specific type. - if Nkind_In (Expression (N), N_Aggregate, N_Null) then + if Nkind_In (Expression (N), N_Aggregate, + N_Null, + N_Real_Literal, + N_Integer_Literal) + then Ret := Make_Qualified_Expression (Sloc (N), Subtype_Mark => New_Occurrence_Of (Ret_Type, Sloc (N)), diff --git a/gcc/ada/exp_ch9.adb b/gcc/ada/exp_ch9.adb index 20a346ceec2..fdafd22a6d2 100644 --- a/gcc/ada/exp_ch9.adb +++ b/gcc/ada/exp_ch9.adb @@ -3347,7 +3347,7 @@ package body Exp_Ch9 is if Known_Static_Esize (Comp_Type) then Typ_Size := UI_To_Int (Esize (Comp_Type)); - -- If the Esize (Object_Size) is unknown at compile-time, look at + -- If the Esize (Object_Size) is unknown at compile time, look at -- the RM_Size (Value_Size) since it may have been set by an -- explicit representation clause. @@ -6756,6 +6756,40 @@ package body Exp_Ch9 is S : Entity_Id; -- Primitive operation slot T : Entity_Id; -- Additional status flag + procedure Rewrite_Abortable_Part; + -- If the trigger is a dispatching call, the expansion inserts multiple + -- copies of the abortable part. This is both inefficient, and may lead + -- to duplicate definitions that the back-end will reject, when the + -- abortable part includes loops. This procedure rewrites the abortable + -- part into a call to a generated procedure. + + ---------------------------- + -- Rewrite_Abortable_Part -- + ---------------------------- + + procedure Rewrite_Abortable_Part is + Proc : constant Entity_Id := Make_Defining_Identifier (Loc, Name_uA); + Decl : Node_Id; + + begin + Decl := + Make_Subprogram_Body (Loc, + Specification => + Make_Procedure_Specification (Loc, Defining_Unit_Name => Proc), + Declarations => New_List, + Handled_Statement_Sequence => + Make_Handled_Sequence_Of_Statements (Loc, Astats)); + Insert_Before (N, Decl); + Analyze (Decl); + + -- Rewrite abortable part into a call to this procedure. + + Astats := + New_List ( + Make_Procedure_Call_Statement (Loc, + Name => New_Occurrence_Of (Proc, Loc))); + end Rewrite_Abortable_Part; + begin Process_Statements_For_Controlled_Objects (Trig); Process_Statements_For_Controlled_Objects (Abrt); @@ -6791,12 +6825,13 @@ package body Exp_Ch9 is if Ada_Version >= Ada_2005 and then (No (Original_Node (Ecall)) - or else not Nkind_In (Original_Node (Ecall), - N_Delay_Relative_Statement, - N_Delay_Until_Statement)) + or else not Nkind_In (Original_Node (Ecall), + N_Delay_Relative_Statement, + N_Delay_Until_Statement)) then Extract_Dispatching_Call (Ecall, Call_Ent, Obj, Actuals, Formals); + Rewrite_Abortable_Part; Decls := New_List; Stmts := New_List; @@ -6831,9 +6866,9 @@ package body Exp_Ch9 is Make_Object_Declaration (Loc, Defining_Identifier => Make_Defining_Identifier (Loc, Name_uD), - Object_Definition => - New_Reference_To ( - RTE (RE_Dummy_Communication_Block), Loc))); + Object_Definition => + New_Reference_To + (RTE (RE_Dummy_Communication_Block), Loc))); K := Build_K (Loc, Decls, Obj); @@ -6875,8 +6910,7 @@ package body Exp_Ch9 is Prepend_To (Cleanup_Stmts, Make_Assignment_Statement (Loc, - Name => - New_Reference_To (Bnn, Loc), + Name => New_Reference_To (Bnn, Loc), Expression => Make_Unchecked_Type_Conversion (Loc, Subtype_Mark => @@ -6889,10 +6923,10 @@ package body Exp_Ch9 is Prepend_To (Cleanup_Stmts, Make_Procedure_Call_Statement (Loc, Name => - New_Reference_To ( - Find_Prim_Op (Etype (Etype (Obj)), - Name_uDisp_Asynchronous_Select), - Loc), + New_Reference_To + (Find_Prim_Op + (Etype (Etype (Obj)), Name_uDisp_Asynchronous_Select), + Loc), Parameter_Associations => New_List ( New_Copy_Tree (Obj), -- <object> @@ -7117,10 +7151,10 @@ package body Exp_Ch9 is Append_To (Conc_Typ_Stmts, Make_Procedure_Call_Statement (Loc, Name => - New_Reference_To ( - Find_Prim_Op (Etype (Etype (Obj)), - Name_uDisp_Get_Prim_Op_Kind), - Loc), + New_Reference_To + (Find_Prim_Op (Etype (Etype (Obj)), + Name_uDisp_Get_Prim_Op_Kind), + Loc), Parameter_Associations => New_List ( New_Copy_Tree (Obj), @@ -7240,11 +7274,11 @@ package body Exp_Ch9 is Abortable_Block := Make_Block_Statement (Loc, - Identifier => New_Reference_To (Blk_Ent, Loc), + Identifier => New_Reference_To (Blk_Ent, Loc), Handled_Statement_Sequence => Make_Handled_Sequence_Of_Statements (Loc, Statements => Astats), - Has_Created_Identifier => True, + Has_Created_Identifier => True, Is_Asynchronous_Call_Block => True); -- Append call to if Enqueue (When, DB'Unchecked_Access) then @@ -7292,8 +7326,8 @@ package body Exp_Ch9 is Make_Object_Declaration (Loc, Defining_Identifier => Dblock_Ent, Aliased_Present => True, - Object_Definition => New_Reference_To ( - RTE (RE_Delay_Block), Loc))), + Object_Definition => + New_Reference_To (RTE (RE_Delay_Block), Loc))), Handled_Statement_Sequence => Make_Handled_Sequence_Of_Statements (Loc, Stmts))); @@ -7318,10 +7352,9 @@ package body Exp_Ch9 is Decl := First (Decls); while Present (Decl) - and then - (Nkind (Decl) /= N_Object_Declaration - or else not Is_RTE (Etype (Object_Definition (Decl)), - RE_Communication_Block)) + and then (Nkind (Decl) /= N_Object_Declaration + or else not Is_RTE (Etype (Object_Definition (Decl)), + RE_Communication_Block)) loop Next (Decl); end loop; @@ -7338,13 +7371,12 @@ package body Exp_Ch9 is -- Mode => Asynchronous_Call; -- Block => Bnn); - Stmt := First (Stmts); - -- Skip assignments to temporaries created for in-out parameters -- This makes unwarranted assumptions about the shape of the expanded -- tree for the call, and should be cleaned up ??? + Stmt := First (Stmts); while Nkind (Stmt) /= N_Procedure_Call_Statement loop Next (Stmt); end loop; diff --git a/gcc/ada/exp_util.adb b/gcc/ada/exp_util.adb index 0473bfafc1d..ca8bc9839ab 100644 --- a/gcc/ada/exp_util.adb +++ b/gcc/ada/exp_util.adb @@ -8040,11 +8040,11 @@ package body Exp_Util is Par : Node_Id; begin - -- Locate an enclosing case or if expression. Note: these constructs can - -- get expanded into Expression_With_Actions, hence the need to test - -- using the original node. + -- Locate an enclosing case or if expression. Note that these constructs + -- can be expanded into Expression_With_Actions, hence the test of the + -- original node. - Par := N; + Par := Parent (N); while Present (Par) loop if Nkind_In (Original_Node (Par), N_Case_Expression, N_If_Expression) diff --git a/gcc/ada/freeze.adb b/gcc/ada/freeze.adb index 88a8f6df656..8a5b927c570 100644 --- a/gcc/ada/freeze.adb +++ b/gcc/ada/freeze.adb @@ -3360,7 +3360,16 @@ package body Freeze is and then Nkind (Expression (Init_Stmts)) = N_Null_Statement then Insert_List_Before (Init_Stmts, Actions (Init_Stmts)); - Remove (Init_Stmts); + + -- Note that we rewrite Init_Stmts into a NULL statement, + -- rather than just removing it, because Freeze_All may + -- depend on this particular Node_Id still being present + -- in the enclosing list to signal where to stop + -- freezing. + + Rewrite (Init_Stmts, + Make_Null_Statement (Sloc (Init_Stmts))); + Set_Initialization_Statements (E, Empty); end if; end; @@ -3404,20 +3413,32 @@ package body Freeze is -- Before we do anything else, a specialized test for the case of -- a size given for an array where the array needs to be packed, - -- but was not so the size cannot be honored. This would of course - -- be caught by the backend, and indeed we don't catch all cases. - -- The point is that we can give a better error message in those - -- cases that we do catch with the circuitry here. Also if pragma - -- Implicit_Packing is set, this is where the packing occurs. - - -- The reason we do this so early is that the processing in the - -- automatic packing case affects the layout of the base type, so - -- it must be done before we freeze the base type. + -- but was not so the size cannot be honored. This is the case + -- where implicit packing may apply. The reason we do this so + -- early is that if we have implicit packing, the layout of the + -- base type is affected, so we must do this before we freeze + -- the base type. + + -- We could do this processing only if implicit packing is enabled + -- since in all other cases, the error would be caught by the back + -- end. However, we choose to do the check even if we do not have + -- implicit packing enabled, since this allows us to give a more + -- useful error message (advising use of pragmas Implicit_Packing + -- or Pack). if Is_Array_Type (E) then declare - Lo, Hi : Node_Id; - Ctyp : constant Entity_Id := Component_Type (E); + Ctyp : constant Entity_Id := Component_Type (E); + Rsiz : constant Uint := RM_Size (Ctyp); + SZ : constant Node_Id := Size_Clause (E); + Btyp : constant Entity_Id := Base_Type (E); + + Lo : Node_Id; + Hi : Node_Id; + Indx : Node_Id; + + Num_Elmts : Uint; + -- Number of elements in array begin -- Check enabling conditions. These are straightforward @@ -3432,87 +3453,90 @@ package body Freeze is -- a chance to freeze the base type (and it is that freeze -- action that causes stuff to be inherited). - if Present (Size_Clause (E)) + if Has_Size_Clause (E) and then Known_Static_RM_Size (E) and then not Is_Packed (E) and then not Has_Pragma_Pack (E) - and then Number_Dimensions (E) = 1 and then not Has_Component_Size_Clause (E) and then Known_Static_RM_Size (Ctyp) + and then RM_Size (Ctyp) < 64 and then not Is_Limited_Composite (E) and then not Is_Packed (Root_Type (E)) and then not Has_Component_Size_Clause (Root_Type (E)) and then not (CodePeer_Mode or SPARK_Mode) then - Get_Index_Bounds (First_Index (E), Lo, Hi); + -- Compute number of elements in array - if Compile_Time_Known_Value (Lo) - and then Compile_Time_Known_Value (Hi) - and then Known_Static_RM_Size (Ctyp) - and then RM_Size (Ctyp) < 64 - then - declare - Lov : constant Uint := Expr_Value (Lo); - Hiv : constant Uint := Expr_Value (Hi); - Len : constant Uint := UI_Max - (Uint_0, - Hiv - Lov + 1); - Rsiz : constant Uint := RM_Size (Ctyp); - SZ : constant Node_Id := Size_Clause (E); - Btyp : constant Entity_Id := Base_Type (E); - - -- What we are looking for here is the situation where - -- the RM_Size given would be exactly right if there - -- was a pragma Pack (resulting in the component size - -- being the same as the RM_Size). Furthermore, the - -- component type size must be an odd size (not a - -- multiple of storage unit). If the component RM size - -- is an exact number of storage units that is a power - -- of two, the array is not packed and has a standard - -- representation. + Num_Elmts := Uint_1; + Indx := First_Index (E); + while Present (Indx) loop + Get_Index_Bounds (Indx, Lo, Hi); - begin - if RM_Size (E) = Len * Rsiz - and then Rsiz mod System_Storage_Unit /= 0 - then - -- For implicit packing mode, just set the - -- component size silently. + if not (Compile_Time_Known_Value (Lo) + and then + Compile_Time_Known_Value (Hi)) + then + goto No_Implicit_Packing; + end if; - if Implicit_Packing then - Set_Component_Size (Btyp, Rsiz); - Set_Is_Bit_Packed_Array (Btyp); - Set_Is_Packed (Btyp); - Set_Has_Non_Standard_Rep (Btyp); + Num_Elmts := + Num_Elmts * + UI_Max (Uint_0, + Expr_Value (Hi) - Expr_Value (Lo) + 1); + Next_Index (Indx); + end loop; - -- Otherwise give an error message + -- What we are looking for here is the situation where + -- the RM_Size given would be exactly right if there was + -- a pragma Pack (resulting in the component size being + -- the same as the RM_Size). Furthermore, the component + -- type size must be an odd size (not a multiple of + -- storage unit). If the component RM size is an exact + -- number of storage units that is a power of two, the + -- array is not packed and has a standard representation. + + if RM_Size (E) = Num_Elmts * Rsiz + and then Rsiz mod System_Storage_Unit /= 0 + then + -- For implicit packing mode, just set the component + -- size silently. - else - Error_Msg_NE - ("size given for& too small", SZ, E); - Error_Msg_N -- CODEFIX - ("\use explicit pragma Pack " - & "or use pragma Implicit_Packing", SZ); - end if; + if Implicit_Packing then + Set_Component_Size (Btyp, Rsiz); + Set_Is_Bit_Packed_Array (Btyp); + Set_Is_Packed (Btyp); + Set_Has_Non_Standard_Rep (Btyp); - elsif RM_Size (E) = Len * Rsiz - and then Implicit_Packing - and then - (Rsiz / System_Storage_Unit = 1 - or else Rsiz / System_Storage_Unit = 2 - or else Rsiz / System_Storage_Unit = 4) - then + -- Otherwise give an error message - -- Not a packed array, but indicate the desired - -- component size, for the back-end. + else + Error_Msg_NE + ("size given for& too small", SZ, E); + Error_Msg_N -- CODEFIX + ("\use explicit pragma Pack " + & "or use pragma Implicit_Packing", SZ); + end if; - Set_Component_Size (Btyp, Rsiz); - end if; - end; + elsif RM_Size (E) = Num_Elmts * Rsiz + and then Implicit_Packing + and then + (Rsiz / System_Storage_Unit = 1 + or else + Rsiz / System_Storage_Unit = 2 + or else + Rsiz / System_Storage_Unit = 4) + then + -- Not a packed array, but indicate the desired + -- component size, for the back-end. + + Set_Component_Size (Btyp, Rsiz); end if; end if; end; end if; + <<No_Implicit_Packing>> + -- If ancestor subtype present, freeze that first. Note that this -- will also get the base type frozen. Need RM reference ??? @@ -4940,21 +4964,6 @@ package body Freeze is and then not Is_Library_Level_Entity (E) then Set_Is_Public (E, False); - - -- If no address clause and not intrinsic, then for imported - -- subprogram in main unit, generate descriptor if we are in - -- Propagate_Exceptions mode. - - -- This is very odd code, it makes a null result, why ??? - - elsif Propagate_Exceptions - and then Is_Imported (E) - and then not Is_Intrinsic_Subprogram (E) - and then Convention (E) /= Convention_Stubbed - then - if Result = No_List then - Result := Empty_List; - end if; end if; end if; diff --git a/gcc/ada/g-socket.ads b/gcc/ada/g-socket.ads index c543707097a..06add2c63a9 100644 --- a/gcc/ada/g-socket.ads +++ b/gcc/ada/g-socket.ads @@ -816,7 +816,8 @@ package GNAT.Sockets is -- connections, creates a new connected socket with mostly the same -- properties as Server, and allocates a new socket. The returned Address -- is filled in with the address of the connection. Raises Socket_Error on - -- error. + -- error. Note: if Server is a non-blocking socket, whether or not this + -- aspect is inherited by Socket is platform-dependent. procedure Accept_Socket (Server : Socket_Type; diff --git a/gcc/ada/gnat_rm.texi b/gcc/ada/gnat_rm.texi index 7f3596bdeb5..03bf61191a2 100644 --- a/gcc/ada/gnat_rm.texi +++ b/gcc/ada/gnat_rm.texi @@ -117,6 +117,7 @@ Implementation Defined Pragmas * Pragma Check_Float_Overflow:: * Pragma Check_Name:: * Pragma Check_Policy:: +* Pragma CIL_Constructor:: * Pragma Comment:: * Pragma Common_Object:: * Pragma Compile_Time_Error:: @@ -136,9 +137,11 @@ Implementation Defined Pragmas * Pragma Debug_Policy:: * Pragma Default_Storage_Pool:: * Pragma Detect_Blocking:: +* Pragma Disable_Atomic_Synchronization:: * Pragma Dispatching_Domain:: * Pragma Elaboration_Checks:: * Pragma Eliminate:: +* Pragma Enable_Atomic_Synchronization:: * Pragma Export_Exception:: * Pragma Export_Function:: * Pragma Export_Object:: @@ -172,6 +175,8 @@ Implementation Defined Pragmas * Pragma Interrupt_Handler:: * Pragma Interrupt_State:: * Pragma Invariant:: +* Pragma Java_Constructor:: +* Pragma Java_Interface:: * Pragma Keep_Names:: * Pragma License:: * Pragma Link_With:: @@ -189,28 +194,37 @@ Implementation Defined Pragmas * Pragma No_Body:: * Pragma No_Inline:: * Pragma No_Return:: +* Pragma No_Run_Time:: * Pragma No_Strict_Aliasing :: * Pragma Normalize_Scalars:: * Pragma Obsolescent:: * Pragma Optimize_Alignment:: * Pragma Ordered:: * Pragma Overflow_Mode:: +* Pragma Overriding_Renamings:: * Pragma Partition_Elaboration_Policy:: * Pragma Passive:: * Pragma Persistent_BSS:: * Pragma Polling:: * Pragma Postcondition:: * Pragma Precondition:: +* Pragma Predicate:: * Pragma Preelaborable_Initialization:: +* Pragma Preelaborate_05:: * Pragma Priority_Specific_Dispatching:: -* Pragma Profile (Ravenscar):: -* Pragma Profile (Restricted):: -* Pragma Profile (Rational):: +* Pragma Profile:: +* Pragma Profile_Warnings:: +* Pragma Propagate_Exceptions:: * Pragma Psect_Object:: +* Pragma Pure_05:: +* Pragma Pure_12:: * Pragma Pure_Function:: +* Pragma Ravenscar:: * Pragma Relative_Deadline:: * Pragma Remote_Access_Type:: +* Pragma Restricted_Run_Time:: * Pragma Restriction_Warnings:: +* Pragma Share_Generic:: * Pragma Shared:: * Pragma Short_Circuit_And_Or:: * Pragma Short_Descriptors:: @@ -218,12 +232,14 @@ Implementation Defined Pragmas * Pragma Source_File_Name:: * Pragma Source_File_Name_Project:: * Pragma Source_Reference:: +* Pragma SPARK_Mode:: * Pragma Static_Elaboration_Desired:: * Pragma Stream_Convert:: * Pragma Style_Checks:: * Pragma Subtitle:: * Pragma Suppress:: * Pragma Suppress_All:: +* Pragma Suppress_Debug_Info:: * Pragma Suppress_Exception_Locations:: * Pragma Suppress_Initialization:: * Pragma Task_Info:: @@ -275,6 +291,7 @@ Implementation Defined Aspects * Aspect Shared:: * Aspect Simple_Storage_Pool:: * Aspect Simple_Storage_Pool_Type:: +* Aspect SPARK_Mode:: * Aspect Suppress_Debug_Info:: * Aspect Test_Case:: * Aspect Universal_Aliasing:: @@ -326,6 +343,8 @@ Implementation Defined Attributes * Attribute Passed_By_Reference:: * Attribute Pool_Address:: * Attribute Range_Length:: +* Attribute Ref:: +* Attribute Restriction_Set:: * Attribute Result:: * Attribute Safe_Emax:: * Attribute Safe_Large:: @@ -437,7 +456,7 @@ Program Unit Level Restrictions * No_Implicit_Aliasing:: * No_Obsolescent_Features:: * No_Wide_Characters:: -* SPARK:: +* SPARK_05:: The Implementation of Standard I/O @@ -914,6 +933,7 @@ consideration, the use of these pragmas should be minimized. * Pragma Check_Float_Overflow:: * Pragma Check_Name:: * Pragma Check_Policy:: +* Pragma CIL_Constructor:: * Pragma Comment:: * Pragma Common_Object:: * Pragma Compile_Time_Error:: @@ -933,9 +953,11 @@ consideration, the use of these pragmas should be minimized. * Pragma Debug_Policy:: * Pragma Default_Storage_Pool:: * Pragma Detect_Blocking:: +* Pragma Disable_Atomic_Synchronization:: * Pragma Dispatching_Domain:: * Pragma Elaboration_Checks:: * Pragma Eliminate:: +* Pragma Enable_Atomic_Synchronization:: * Pragma Export_Exception:: * Pragma Export_Function:: * Pragma Export_Object:: @@ -969,6 +991,8 @@ consideration, the use of these pragmas should be minimized. * Pragma Interrupt_Handler:: * Pragma Interrupt_State:: * Pragma Invariant:: +* Pragma Java_Constructor:: +* Pragma Java_Interface:: * Pragma Keep_Names:: * Pragma License:: * Pragma Link_With:: @@ -986,6 +1010,7 @@ consideration, the use of these pragmas should be minimized. * Pragma No_Body:: * Pragma No_Inline:: * Pragma No_Return:: +* Pragma No_Run_Time:: * Pragma No_Strict_Aliasing:: * Pragma Normalize_Scalars:: * Pragma Obsolescent:: @@ -999,16 +1024,23 @@ consideration, the use of these pragmas should be minimized. * Pragma Polling:: * Pragma Postcondition:: * Pragma Precondition:: +* Pragma Predicate:: * Pragma Preelaborable_Initialization:: +* Pragma Preelaborate_05:: * Pragma Priority_Specific_Dispatching:: -* Pragma Profile (Ravenscar):: -* Pragma Profile (Restricted):: -* Pragma Profile (Rational):: +* Pragma Profile:: +* Pragma Profile_Warnings:: +* Pragma Propagate_Exceptions:: * Pragma Psect_Object:: +* Pragma Pure_05:: +* Pragma Pure_12:: * Pragma Pure_Function:: +* Pragma Ravenscar:: * Pragma Relative_Deadline:: * Pragma Remote_Access_Type:: +* Pragma Restricted_Run_Time:: * Pragma Restriction_Warnings:: +* Pragma Share_Generic:: * Pragma Shared:: * Pragma Short_Circuit_And_Or:: * Pragma Short_Descriptors:: @@ -1016,12 +1048,14 @@ consideration, the use of these pragmas should be minimized. * Pragma Source_File_Name:: * Pragma Source_File_Name_Project:: * Pragma Source_Reference:: +* Pragma SPARK_Mode:: * Pragma Static_Elaboration_Desired:: * Pragma Stream_Convert:: * Pragma Style_Checks:: * Pragma Subtitle:: * Pragma Suppress:: * Pragma Suppress_All:: +* Pragma Suppress_Debug_Info:: * Pragma Suppress_Exception_Locations:: * Pragma Suppress_Initialization:: * Pragma Task_Info:: @@ -1750,6 +1784,24 @@ compatibility with the standard @code{Assertion_Policy} pragma. The check policy setting @code{DISABLE} causes the second argument of a corresponding @code{Check} pragma to be completely ignored and not analyzed. +@node Pragma CIL_Constructor +@unnumberedsec Pragma CIL_Constructor +@findex CIL_Constructor +@noindent +Syntax: + +@smallexample @c ada +pragma CIL_Constructor ([Entity =>] function_LOCAL_NAME); +@end smallexample + +@noindent +This pragma is used to assert that the specified Ada function should be +mapped to the .NET constructor for some Ada tagged record type. + +See section 4.1 of the +@code{GNAT User's Guide: Supplement for the .NET Platform.} +for related information. + @node Pragma Comment @unnumberedsec Pragma Comment @findex Comment @@ -2202,8 +2254,12 @@ that is, they never return an object whose type is a descendant of type T. @cindex Interfacing to C++ @findex CPP_Virtual @noindent -This pragma is now obsolete has has no effect because GNAT generates -the same object layout than the G++ compiler. +This pragma is now obsolete and, other than generating a warning if warnings +on obsolescent features are enabled, is completely ignored. +It is retained for compatibility +purposes. It used to be required to ensure compoatibility with C++, but +is no longer required for that purpose because GNAT generates +the same object layout as the G++ compiler by default. See @ref{Interfacing to C++} for related information. @@ -2212,8 +2268,11 @@ See @ref{Interfacing to C++} for related information. @cindex Interfacing with C++ @findex CPP_Vtable @noindent -This pragma is now obsolete has has no effect because GNAT generates -the same object layout than the G++ compiler. +This pragma is now obsolete and, other than generating a warning if warnings +on obsolescent features are enabled, is completely ignored. +It used to be required to ensure compatibility with C++, but +is no longer required for that purpose because GNAT generates +the same object layout than the G++ compiler by default. See @ref{Interfacing to C++} for related information. @@ -2308,6 +2367,31 @@ This is a configuration pragma that forces the detection of potentially blocking operations within a protected operation, and to raise Program_Error if that happens. +@node Pragma Disable_Atomic_Synchronization +@unnumberedsec Pragma Disable_Atomic_Synchronization +@cindex Atomic Synchronization +@findex Disable_Atomic_Synchronization +@noindent +Syntax: + +@smallexample @c ada +pragma Disable_Atomic_Synchronization [(Entity)]; +@end smallexample + +@noindent +Ada requires that accesses (reads or writes) of an atomic variable be +regarded as synchronization points in the case of multiple tasks. +Particularly in the case of multi-processors this may require special +handling, e.g. the generation of memory barriers. This capability may +be turned off using this pragma in cases where it is known not to be +required. + +The placement and scope rules for this pragma are the same as those +for @code{pragma Suppress}. In particular it can be used as a +configuration pragma, or in a declaration sequence where it applies +till the end of the scope. If an @code{Entity} argument is present, +the action applies only to that entity. + @node Pragma Dispatching_Domain @unnumberedsec Pragma Dispatching_Domain @findex Dispatching_Domain @@ -2425,6 +2509,33 @@ operation. In this case all the subprograms to which the given operation can dispatch are considered to be unused (are never called as a result of a direct or a dispatching call). +@node Pragma Enable_Atomic_Synchronization +@unnumberedsec Pragma Enable_Atomic_Synchronization +@cindex Atomic Synchronization +@findex Enable_Atomic_Synchronization +@noindent +Syntax: + +@smallexample @c ada +pragma Enable_Atomic_Synchronization [(Entity)]; +@end smallexample + +@noindent +Ada requires that accesses (reads or writes) of an atomic variable be +regarded as synchronization points in the case of multiple tasks. +Particularly in the case of multi-processors this may require special +handling, e.g. the generation of memory barriers. This synchronization +is performed by default, but can be turned off using +@code{pragma Disable_Atomic_Synchronization}. The +@code{Enable_Atomic_Synchronization} pragma can be used to turn +it back on. + +The placement and scope rules for this pragma are the same as those +for @code{pragma Unsuppress}. In particular it can be used as a +configuration pragma, or in a declaration sequence where it applies +till the end of the scope. If an @code{Entity} argument is present, +the action applies only to that entity. + @node Pragma Export_Exception @unnumberedsec Pragma Export_Exception @cindex OpenVMS @@ -3146,8 +3257,10 @@ of the configuration pragma Implicit_Packing, then the Size clause in this and similar examples will cause implicit packing and thus be accepted. For this implicit packing to occur, the type in question must be an array of small components whose size is known at compile time, and the Size clause must -specify the exact size that corresponds to the length of the array multiplied -by the size in bits of the component type. +specify the exact size that corresponds to the number of elements in the array +multiplied by the size in bits of the component type (both single and +multi-dimensioned arrays can be controlled with this pragma). + @cindex Array packing Similarly, the following example shows the use in the record case @@ -3538,13 +3651,16 @@ happens regardless of whether these options are used. Syntax: @smallexample @c ada -pragma Inline_Generic (generic_package_NAME); +pragma Inline_Generic (GNAME @{, GNAME@}); + +GNAME ::= generic_unit_NAME | generic_instance_NAME @end smallexample @noindent -This is implemented for compatibility with DEC Ada 83 and is recognized, -but otherwise ignored, by GNAT@. All generic instantiations are inlined -by default when using GNAT@. +This pragma is provided for compatibility with Dec Ada 83. It has +no effect in @code{GNAT} (which always inlines generics), other +than to check that the given names are all names of generic units or +generic instances. @node Pragma Interface @unnumberedsec Pragma Interface @@ -3729,6 +3845,42 @@ invariant pragma for the same entity. For further details on the use of this pragma, see the Ada 2012 documentation of the Type_Invariant aspect. +@node Pragma Java_Constructor +@unnumberedsec Pragma Java_Constructor +@findex Java_Constructor +@noindent +Syntax: + +@smallexample @c ada +pragma Java_Constructor ([Entity =>] function_LOCAL_NAME); +@end smallexample + +@noindent +This pragma is used to assert that the specified Ada function should be +mapped to the Java constructor for some Ada tagged record type. + +See section 7.3.2 of the +@code{GNAT User's Guide: Supplement for the JVM Platform.} +for related information. + +@node Pragma Java_Interface +@unnumberedsec Pragma Java_Interface +@findex Java_Interface +@noindent +Syntax: + +@smallexample @c ada +pragma Java_Interface ([Entity =>] abstract_tagged_type_LOCAL_NAME); +@end smallexample + +@noindent +This pragma is used to assert that the specified Ada abstract tagged type +is to be mapped to a Java interface name. + +See sections 7.1 and 7.2 of the +@code{GNAT User's Guide: Supplement for the JVM Platform.} +for related information. + @node Pragma Keep_Names @unnumberedsec Pragma Keep_Names @findex Keep_Names @@ -4040,9 +4192,9 @@ this pragma, the standard runtime libraries must be recompiled. @findex Loop_Invariant @noindent Syntax: + @smallexample @c ada pragma Loop_Invariant ( boolean_EXPRESSION ); - @end smallexample @noindent @@ -4289,6 +4441,24 @@ Note that in Ada 2005 mode, this pragma is part of the language. It is available in all earlier versions of Ada as an implementation-defined pragma. +@node Pragma No_Run_Time +@unnumberedsec Pragma No_Run_Time +@findex No_Run_Time +@noindent +Syntax: + +@smallexample @c ada +pragma No_Run_Time; +@end smallexample + +@noindent +This is an obsolete configuration pragma that historically was used to +setup what is now called the "zero footprint" library. It causes any +library units outside this basic library to be ignored. The use of +this pragma has been superseded by the general configurable run-time +capability of @code{GNAT} where the compiler takes into account whatever +units happen to be accessible in the library. + @node Pragma No_Strict_Aliasing @unnumberedsec Pragma No_Strict_Aliasing @findex No_Strict_Aliasing @@ -4703,6 +4873,7 @@ overflow checking, but does not affect the overflow mode. @unnumberedsec Pragma Overriding_Renamings @findex Overriding_Renamings @cindex Rational profile +@cindex Rational compatibility @noindent Syntax: @@ -4711,10 +4882,23 @@ pragma Overriding_Renamings; @end smallexample @noindent - -This is a GNAT pragma to simplify porting legacy code accepted by the Rational +This is a GNAT configuration pragma to simplify porting +legacy code accepted by the Rational Ada compiler. In the presence of this pragma, a renaming declaration that -renames an inherited operation declared in the same scope is legal, even though +renames an inherited operation declared in the same scope is legal if selected +notation is used as in: + +@smallexample @c ada +pragma Overriding_Renamings; +... +package R is + function F (..); + ... + function F (..) renames R.F; +end R; +@end smallexample + +even though RM 8.3 (15) stipulates that an overridden operation is not visible within the declaration of the overriding operation. @@ -4832,7 +5016,7 @@ details. @node Pragma Postcondition @unnumberedsec Pragma Postcondition -@cindex Postconditions +@cindex Postcondition @cindex Checks, postconditions @findex Postconditions @noindent @@ -4987,45 +5171,6 @@ inlining (-gnatN option set) are accepted and legality-checked by the compiler, but are ignored at run-time even if postcondition checking is enabled. -@node Pragma Preelaborable_Initialization -@unnumberedsec Pragma Preelaborable_Initialization -@findex Preelaborable_Initialization -@noindent -Syntax: - -@smallexample @c ada -pragma Preelaborable_Initialization (DIRECT_NAME); -@end smallexample - -@noindent -This pragma is standard in Ada 2005, but is available in all earlier -versions of Ada as an implementation-defined pragma. -See Ada 2012 Reference Manual for details. - -@node Pragma Priority_Specific_Dispatching -@unnumberedsec Pragma Priority_Specific_Dispatching -@findex Priority_Specific_Dispatching -@noindent -Syntax: - -@smallexample @c ada -pragma Priority_Specific_Dispatching ( - POLICY_IDENTIFIER, - first_priority_EXPRESSION, - last_priority_EXPRESSION) - -POLICY_IDENTIFIER ::= - EDF_Across_Priorities | - FIFO_Within_Priorities | - Non_Preemptive_Within_Priorities | - Round_Robin_Within_Priorities -@end smallexample - -@noindent -This pragma is standard in Ada 2005, but is available in all earlier -versions of Ada as an implementation-defined pragma. -See Ada 2012 Reference Manual for details. - @node Pragma Precondition @unnumberedsec Pragma Precondition @cindex Preconditions @@ -5068,27 +5213,139 @@ declarations of a subprogram body. Only other pragmas may intervene postconditions, or appear before the postcondition in the declaration sequence in a subprogram body). -Note: postcondition pragmas associated with subprograms that are +Note: precondition pragmas associated with subprograms that are marked as Inline_Always, or those marked as Inline with front-end inlining (-gnatN option set) are accepted and legality-checked -by the compiler, but are ignored at run-time even if postcondition +by the compiler, but are ignored at run-time even if precondition checking is enabled. -@node Pragma Profile (Ravenscar) -@unnumberedsec Pragma Profile (Ravenscar) -@findex Ravenscar +@node Pragma Predicate +@unnumberedsec Pragma Predicate +@findex Predicate +@findex Predicate pragma @noindent Syntax: @smallexample @c ada -pragma Profile (Ravenscar | Restricted); +pragma Predicate + ([Entity =>] type_LOCAL_NAME, + [Check =>] EXPRESSION); +@end smallexample + +@noindent +This pragma (available in all versions of Ada in GNAT) encompasses both +the @code{Static_Predicate} and @code{Dynamic_Predicate} aspects in +Ada 2012. A predicate is regarded as static if it has an allowed form +for @code{Static_Predicate} and is otherwise treated as a +@code{Dynamic_Predicate}. Otherwise, predicates specified by this +pragma behave exactly as described in the Ada 2012 reference manual. +For example, if we have + +@smallexample @c ada +type R is range 1 .. 10; +subtype S is R; +pragma Predicate (Entity => S, Check => S not in 4 .. 6); +subtype Q is R +pragma Predicate (Entity => Q, Check => F(Q) or G(Q)); +@end smallexample + +@noindent +the effect is identical to the following Ada 2012 code: + +@smallexample @c ada +type R is range 1 .. 10; +subtype S is R with + Static_Predicate => S not in 4 .. 6; +subtype Q is R with + Dynamic_Predicate => F(Q) or G(Q); +@end smallexample + +@node Pragma Preelaborable_Initialization +@unnumberedsec Pragma Preelaborable_Initialization +@findex Preelaborable_Initialization +@noindent +Syntax: + +@smallexample @c ada +pragma Preelaborable_Initialization (DIRECT_NAME); +@end smallexample + +@noindent +This pragma is standard in Ada 2005, but is available in all earlier +versions of Ada as an implementation-defined pragma. +See Ada 2012 Reference Manual for details. + +@node Pragma Preelaborate_05 +@unnumberedsec Pragma Preelaborate_05 +@findex Preelaborate_05 +@noindent +Syntax: + +@smallexample @c ada +pragma Preelaborate_05 [(library_unit_NAME)]; +@end smallexample + +@noindent +This pragma is only available in GNAT mode (@option{-gnatg} switch set) +and is intended for use in the standard run-time library only. It has +no effect in Ada 83 or Ada 95 mode, but is +equivalent to @code{pragma Prelaborate} when operating in later +Ada versions. This is used to handle some cases where packages +not previously preelaborable became so in Ada 2005. + +@node Pragma Priority_Specific_Dispatching +@unnumberedsec Pragma Priority_Specific_Dispatching +@findex Priority_Specific_Dispatching +@noindent +Syntax: + +@smallexample @c ada +pragma Priority_Specific_Dispatching ( + POLICY_IDENTIFIER, + first_priority_EXPRESSION, + last_priority_EXPRESSION) + +POLICY_IDENTIFIER ::= + EDF_Across_Priorities | + FIFO_Within_Priorities | + Non_Preemptive_Within_Priorities | + Round_Robin_Within_Priorities +@end smallexample + +@noindent +This pragma is standard in Ada 2005, but is available in all earlier +versions of Ada as an implementation-defined pragma. +See Ada 2012 Reference Manual for details. + +@node Pragma Profile +@unnumberedsec Pragma Profile +@findex Profile +@noindent +Syntax: + +@smallexample @c ada +pragma Profile (Ravenscar | Restricted | Rational); @end smallexample @noindent This pragma is standard in Ada 2005, but is available in all earlier versions of Ada as an implementation-defined pragma. This is a -configuration pragma that establishes the following set of configuration -pragmas: +configuration pragma that establishes a set of configiuration pragmas +that depend on the argument. @code{Ravenscar} is standard in Ada 2005. +The other two possibilities (@code{Restricted} or @code{Rational}) +are implementation-defined. The set of configuration pragmas +is defined in the following sections. + +@itemize + +@item Pragma Profile (Ravenscar) +@findex Ravenscar +@noindent + +The @code{Ravenscar} profile is standard in Ada 2005, +but is available in all earlier +versions of Ada as an implementation-defined pragma. This profile +establishes the following set of configuration pragmas: @table @code @item Task_Dispatching_Policy (FIFO_Within_Priorities) @@ -5172,20 +5429,11 @@ that pragma @code{Profile (Ravenscar)}, like the pragma automatically causes the use of a simplified, more efficient version of the tasking run-time system. -@node Pragma Profile (Restricted) -@unnumberedsec Pragma Profile (Restricted) +@item Pragma Profile (Restricted) @findex Restricted Run Time @noindent -Syntax: - -@smallexample @c ada -pragma Profile (Restricted); -@end smallexample - -@noindent -This is an implementation-defined version of the standard pragma defined -in Ada 2005. It is available in all versions of Ada. It is a -configuration pragma that establishes the following set of restrictions: +This profile corresponds to the GNAT restricted run time. It +establishes the following set of restrictions: @itemize @bullet @item No_Abort_Statements @@ -5210,29 +5458,57 @@ This set of restrictions causes the automatic selection of a simplified version of the run time that provides improved performance for the limited set of tasking functionality permitted by this set of restrictions. -@node Pragma Profile (Rational) -@unnumberedsec Pragma Profile (Rational) +@item Pragma Profile (Rational) @findex Rational compatibility mode @noindent -Syntax: - -@smallexample @c ada -pragma Profile (Rational); -@end smallexample - -@noindent The Rational profile is intended to facilitate porting legacy code that compiles with the Rational APEX compiler, even when the code includes non- conforming Ada constructs. The profile enables the following three pragmas: - @itemize @bullet @item pragma Implicit_Packing @item pragma Overriding_Renamings @item pragma Use_VADS_Size @end itemize +@end itemize + +@node Pragma Profile_Warnings +@unnumberedsec Pragma Profile_Warnings +@findex Profile_Warnings @noindent +Syntax: + +@smallexample @c ada +pragma Profile_Warnings (Ravenscar | Restricted | Rational); +@end smallexample + +@noindent +This is an implementation-defined pragma that is similar in +effect to @code{pragma Profile} except that instead of +generating @code{Restrictions} pragmas, it generates +@code{Restriction_Warnings} pragmas. The result is that +violations of the profile generate warning messages instead +of error messages. + +@node Pragma Propagate_Exceptions +@unnumberedsec Pragma Propagate_Exceptions +@cindex Interfacing to C++ +@findex Propagate_Exceptions +@noindent +Syntax: + +@smallexample @c ada +pragma Propagate_Exceptions; +@end smallexample + +@noindent +This pragma is now obsolete and, other than generating a warning if warnings +on obsolescent features are enabled, is ignored. +It is retained for compatibility +purposes. It used to be used in connection with optimization of +a now-obsolete mechanism for implementation of exceptions. + @node Pragma Psect_Object @unnumberedsec Pragma Psect_Object @findex Psect_Object @@ -5253,6 +5529,42 @@ EXTERNAL_SYMBOL ::= @noindent This pragma is identical in effect to pragma @code{Common_Object}. +@node Pragma Pure_05 +@unnumberedsec Pragma Pure_05 +@findex Pure_05 +@noindent +Syntax: + +@smallexample @c ada +pragma Pure_05 [(library_unit_NAME)]; +@end smallexample + +@noindent +This pragma is only available in GNAT mode (@option{-gnatg} switch set) +and is intended for use in the standard run-time library only. It has +no effect in Ada 83 or Ada 95 mode, but is +equivalent to @code{pragma Pure} when operating in later +Ada versions. This is used to handle some cases where packages +not previously pure became so in Ada 2005. + +@node Pragma Pure_12 +@unnumberedsec Pragma Pure_12 +@findex Pure_12 +@noindent +Syntax: + +@smallexample @c ada +pragma Pure_12 [(library_unit_NAME)]; +@end smallexample + +@noindent +This pragma is only available in GNAT mode (@option{-gnatg} switch set) +and is intended for use in the standard run-time library only. It has +no effect in Ada 83, Ada 95, or Ada 2005 modes, but is +equivalent to @code{pragma Pure} when operating in later +Ada versions. This is used to handle some cases where packages +not previously pure became so in Ada 2012. + @node Pragma Pure_Function @unnumberedsec Pragma Pure_Function @findex Pure_Function @@ -5316,6 +5628,27 @@ function is also considered pure from an optimization point of view, but the unit is not a Pure unit in the categorization sense. So for example, a function thus marked is free to @code{with} non-pure units. +@node Pragma Ravenscar +@unnumberedsec Pragma Ravenscar +@findex Pragma Ravenscar +@noindent +Syntax: + +@smallexample @c ada +pragma Ravenscar; +@end smallexample + +@noindent +This pragma is considered obsolescent, but is retained for +compatibility purposes. It is equivalent to: + +@smallexample @c ada +pragma Profile (Ravenscar); +@end smallexample + +@noindent +which is the preferred method of setting the @code{Ravenscar} profile. + @node Pragma Relative_Deadline @unnumberedsec Pragma Relative_Deadline @findex Relative_Deadline @@ -5357,6 +5690,28 @@ In the generic unit, the formal type is subject to all restrictions pertaining to remote access to class-wide types. At instantiation, the actual type must be a remote access to class-wide type. +@node Pragma Restricted_Run_Time +@unnumberedsec Pragma Restricted_Run_Time +@findex Pragma Restricted_Run_Time +@noindent +Syntax: + +@smallexample @c ada +pragma Restricted_Run_Time; +@end smallexample + +@noindent +This pragma is considered obsolescent, but is retained for +compatibility purposes. It is equivalent to: + +@smallexample @c ada +pragma Profile (Restricted); +@end smallexample + +@noindent +which is the preferred method of setting the restricted run time +profile. + @node Pragma Restriction_Warnings @unnumberedsec Pragma Restriction_Warnings @findex Restriction_Warnings @@ -5376,6 +5731,24 @@ the compiler checks for violations of the restriction, but generates a warning message rather than an error message if the restriction is violated. +@node Pragma Share_Generic +@unnumberedsec Pragma Share_Generic +@findex Share_Generic +@noindent +Syntax: + +@smallexample @c ada +pragma Share_Generic (GNAME @{, GNAME@}); + +GNAME ::= generic_unit_NAME | generic_instance_NAME +@end smallexample + +@noindent +This pragma is provided for compatibility with Dec Ada 83. It has +no effect in @code{GNAT} (which does not implement shared generics), other +than to check that the given names are all names of generic units or +generic instances. + @node Pragma Shared @unnumberedsec Pragma Shared @findex Shared @@ -5387,6 +5760,12 @@ semantics are identical to pragma Atomic. @node Pragma Short_Circuit_And_Or @unnumberedsec Pragma Short_Circuit_And_Or @findex Short_Circuit_And_Or +@noindent +Syntax: + +@smallexample @c ada +pragma Short_Circuit_And_Or; +@end smallexample @noindent This configuration pragma causes any occurrence of the AND operator applied to @@ -5624,6 +6003,90 @@ The second argument must be a string literal, it cannot be a static string expression other than a string literal. This is because its value is needed for error messages issued by all phases of the compiler. +@node Pragma SPARK_Mode +@unnumberedsec Pragma SPARK_Mode +@findex SPARK_Mode +@noindent +Syntax: + +@smallexample @c ada +pragma SPARK_Mode [ (On | Off | Auto) ] ; +@end smallexample + +@noindent +This pragma is used to designate whether a contract and its implementation must +follow the SPARK 2014 programming language syntactic and semantic rules. The +pragma is intended for use with formal verification tools and has no effect on +the generated code. + +When used as a configuration pragma over a whole compilation or in a particular +compilation unit, it sets the mode of the units involved, in particular: + +@itemize @bullet + +@item +@code{On}: All entities in the units must follow the SPARK 2014 language, and +an error will be generated if not, unless locally overridden by a local +SPARK_Mode pragma or aspect. @code{On} is the default mode when pragma +SPARK_Mode is used without an argument. + +@item +@code{Off}: The units are considered to be in Ada by default and therefore not +part of SPARK 2014 unless overridden locally. These units may be called by +SPARK 2014 units. + +@item +@code{Auto}: The formal verification tools will automatically detect whether +each entity is in SPARK 2014 or in Ada. + +@end itemize + +Pragma SPARK_Mode can be used as a local pragma with the following semantics: + +@itemize @bullet + +@item +Auto cannot be used as a mode argument. + +@item +When the pragma at the start of the visible declarations (preceded only +by other pragmas) of a package declaration, it marks the whole package +(declaration and body) in or out of SPARK 2014. + +@item +When the pragma appears at the start of the private declarations of a +package (only other pragmas can appear between the @code{private} keyword +and the @code{SPARK_Mode} pragma), it marks the private part in or +out of SPARK 2014 (overriding the default mode of the visible part). + +@item +When the pragma appears immediately at the start of the declarations of a +package body (preceded only by other pragmas), +it marks the whole body in or out of SPARK 2014 (overriding the default +mode set by the declaration). + +@item +When the pragma appears at the start of the elaboration statements of +a package body (only other pragmas can appear between the @code{begin} +keyword and the @code{SPARK_Mode} pragma), +it marks the elaboration statements in or out of SPARK 2014 (overriding +the default mode of the package body). + +@item +When the pragma appears after a subprogram declaration (with only other +pragmas intervening), it marks the whole +subprogram (spec and body) in or out of SPARK 2014. + +@item +When the pragma appears at the start of the declarations of a subprogram +body (preceded only by other pragmas), it marks the whole body in or out +of SPARK 2014 (overriding the default mode set by the declaration). + +@item +Any other use of the pragma is illegal. + +@end itemize + @node Pragma Static_Elaboration_Desired @unnumberedsec Pragma Static_Elaboration_Desired @findex Static_Elaboration_Desired @@ -5676,8 +6139,7 @@ of this type. It must name a function whose argument type may be any subtype, and whose returned type must be the type given as the first argument to the pragma. -The meaning of the @var{Read} -parameter is that if a stream attribute directly +The meaning of the @var{Read} parameter is that if a stream attribute directly or indirectly specifies reading of the type given as the first parameter, then a value of the type given as the argument to the Read function is read from the stream, and then the Read function is used to convert this @@ -5892,6 +6354,21 @@ with Rational Ada, where it appears as a program unit pragma. The use of the standard Ada pragma @code{Suppress (All_Checks)} as a normal configuration pragma is the preferred usage in GNAT@. +@node Pragma Suppress_Debug_Info +@unnumberedsec Pragma Suppress_Debug_Info +@findex Suppress_Debug_Info +@noindent +Syntax: + +@smallexample @c ada +Suppress_Debug_Info ([Entity =>] LOCAL_NAME); +@end smallexample + +@noindent +This pragma can be used to suppress generation of debug information +for the specified entity. It is intended primarily for use in debugging +the debugger, and navigating around debugger problems. + @node Pragma Suppress_Exception_Locations @unnumberedsec Pragma Suppress_Exception_Locations @findex Suppress_Exception_Locations @@ -6793,6 +7270,7 @@ clause. * Aspect Shared:: * Aspect Simple_Storage_Pool:: * Aspect Simple_Storage_Pool_Type:: +* Aspect SPARK_Mode:: * Aspect Suppress_Debug_Info:: * Aspect Test_Case:: * Aspect Universal_Aliasing:: @@ -7046,6 +7524,12 @@ attribute definition clause. @noindent This aspect is equivalent to pragma @code{Simple_Storage_Pool_Type}. +@node Aspect SPARK_Mode +@unnumberedsec Aspect SPARK_Mode +@findex SPARK_Mode +@noindent +This aspect is equivalent to pragma @code{SPARK_Mode}. + @node Aspect Suppress_Debug_Info @unnumberedsec Aspect Suppress_Debug_Info @findex Suppress_Debug_Info @@ -7163,6 +7647,7 @@ consideration, you should minimize the use of these attributes. * Attribute Pool_Address:: * Attribute Range_Length:: * Attribute Ref:: +* Attribute Restriction_Set:: * Attribute Result:: * Attribute Safe_Emax:: * Attribute Safe_Large:: @@ -7575,8 +8060,8 @@ indicates whether or not the corresponding actual type has discriminants. @unnumberedsec Attribute Img @findex Img @noindent -The @code{Img} attribute differs from @code{Image} in that it may be -applied to objects as well as types, in which case it gives the +The @code{Img} attribute differs from @code{Image} in that it is applied +directly to an object, and yields the same result as @code{Image} for the subtype of the object. This is convenient for debugging: @@ -7594,6 +8079,12 @@ Put_Line ("X = " & @var{T}'Image (X)); @noindent where @var{T} is the (sub)type of the object @code{X}. +Note that technically, in analogy to @code{Image}, +@code{X'Img} returns a parameterless function +that returns the appropriate string when called. This means that +@code{X'Img} can be renamed as a function-returning-string, or used +in an instantiation as a function parameter. + @node Attribute Integer_Value @unnumberedsec Attribute Integer_Value @findex Integer_Value @@ -7844,11 +8335,75 @@ same result as @code{Length} applied to the array itself. @unnumberedsec Attribute Ref @findex Ref @noindent -The @code{System.Address'Ref} -(@code{System.Address} is the only permissible prefix) -denotes a function identical to -@code{System.Storage_Elements.To_Address} except that -it is a static attribute. See @ref{Attribute To_Address} for more details. + + +@node Attribute Restriction_Set +@unnumberedsec Attribute Restriction_Set +@findex Restriction_Set +@cindex Restrictions +@noindent +This attribute allows compile time testing of restrictions that +are currently in effect. It is primarily intended for specializing +code in the run-time based on restrictions that are active (e.g. +don't need to save fpt registers if restriction No_Floating_Point +is known to be in effect), but can be used anywhere. + +There are two forms: + +@smallexample @c ada +System'Restriction_Set (partition_boolean_restriction_NAME) +System'Restriction_Set (No_Dependence => library_unit_NAME); +@end smallexample + +@noindent +In the case of the first form, the only restriction names +allowed are parameterless restrictions that are checked +for consistency at bind time. For a complete list see the +subtype @code{System.Rident.Partition_Boolean_Restrictions}. + +The result returned is True if the restriction is known to +be in effect, and False if the restriction is known not to +be in effect. An important guarantee is that the value of +a Restriction_Set attribute is known to be consistent throughout +all the code of a partition. + +This is trivially achieved if the entire partition is compiled +with a consistent set of restriction pragmas. However, the +compilation model does not require this. It is possible to +compile one set of units with one set of pragmas, and another +set of units with another set of pragmas. It is even possible +to compile a spec with one set of pragmas, and then WITH the +same spec with a different set of pragmas. Inconsistencies +in the actual use of the restriction are checked at bind time. + +In order to achieve the guarantee of consistency for the +Restriction_Set pragma, we consider that a use of the pragma +that yields False is equivalent to a violation of the +restriction. + +So for example if you write + +@smallexample @c ada +if System'Restriction_Set (No_Floating_Point) then + ... +else + ... +end if; +@end smallexample + +@noindent +And the result is False, so that the else branch is executed, +you can assume that this restriction is not set for any unit +in the partition. This is checked by considering this use of +the restriction pragma to be a violation of the restriction +No_Floating_Point. This means that no other unit can attempt +to set this restriction (if some unit does attempt to set it, +the binder will refuse to bind the partition). + +Technical note: The restriction name and the unit name are +intepreted entirely syntactically, as in the corresponding +Restrictions pragma, they are not analyzed semantically, +so they do not have a type. @node Attribute Result @unnumberedsec Attribute Result @@ -8469,6 +9024,12 @@ Note that this restriction is checked at run time. Violation of this restriction results in the raising of Program_Error exception at the point of the call. +@findex Max_Entry_Queue_Depth +The restriction @code{Max_Entry_Queue_Depth} is recognized as a +synonym for @code{Max_Entry_Queue_Length}. This is retained for historical +compatibility purposes (and a warning will be generated for its use if +warnings on obsolescent features are activated). + @node Max_Protected_Entries @unnumberedsubsec Max_Protected_Entries @findex Max_Protected_Entries @@ -8578,11 +9139,11 @@ dependence on a library unit. @node No_Direct_Boolean_Operators @unnumberedsubsec No_Direct_Boolean_Operators @findex No_Direct_Boolean_Operators -[GNAT] This restriction ensures that no logical (and/or/xor) are used on -operands of type Boolean (or any type derived -from Boolean). This is intended for use in safety critical programs -where the certification protocol requires the use of short-circuit -(and then, or else) forms for all composite boolean operations. +[GNAT] This restriction ensures that no logical operators (and/or/xor) +are used on operands of type Boolean (or any type derived from Boolean). +This is intended for use in safety critical programs where the certification +protocol requires the use of short-circuit (and then, or else) forms for all +composite boolean operations. @node No_Dispatch @unnumberedsubsec No_Dispatch @@ -8655,6 +9216,12 @@ operations defined in package Ada.Interrupts (Is_Reserved, Is_Attached, Current_Handler, Attach_Handler, Exchange_Handler, Detach_Handler, and Reference). +@findex No_Dynamic_Interrupts +The restriction @code{No_Dynamic_Interrupts} is recognized as a +synonym for @code{No_Dynamic_Attachment}. This is retained for historical +compatibility purposes (and a warning will be generated for its use if +warnings on obsolescent features are activated). + @node No_Dynamic_Priorities @unnumberedsubsec No_Dynamic_Priorities @findex No_Dynamic_Priorities @@ -8896,6 +9463,12 @@ appearing in source code. are permitted and prevents keyword @code{requeue} from being used in source code. +@findex No_Requeue +The restriction @code{No_Requeue} is recognized as a +synonym for @code{No_Requeue_Statements}. This is retained for historical +compatibility purposes (and a warning will be generated for its use if +warnings on oNobsolescent features are activated). + @node No_Secondary_Stack @unnumberedsubsec No_Secondary_Stack @findex No_Secondary_Stack @@ -8977,6 +9550,12 @@ or types containing task subcomponents. [GNAT] This restriction ensures at compile time that there are no implicit or explicit dependencies on the package @code{Ada.Task_Attributes}. +@findex No_Task_Attributes +The restriction @code{No_Task_Attributes} is recognized as a synonym +for @code{No_Task_Attributes_Package}. This is retained for historical +compatibility purposes (and a warning will be generated for its use if +warnings on obsolescent features are activated). + @node No_Task_Hierarchy @unnumberedsubsec No_Task_Hierarchy @findex No_Task_Hierarchy @@ -9016,6 +9595,12 @@ declarations for protected types are restricted to either static boolean expressions or references to simple boolean variables defined in the private part of the protected type. No other form of entry barriers is permitted. +@findex Boolean_Entry_Barriers +The restriction @code{Boolean_Entry_Barriers} is recognized as a +synonym for @code{Simple_Barriers}. This is retained for historical +compatibility purposes (and a warning will be generated for its use if +warnings on obsolescent features are activated). + @node Static_Priorities @unnumberedsubsec Static_Priorities @findex Static_Priorities @@ -9051,7 +9636,7 @@ other compilation units in the partition. * No_Implicit_Aliasing:: * No_Obsolescent_Features:: * No_Wide_Characters:: -* SPARK:: +* SPARK_05:: @end menu @node No_Elaboration_Code @@ -9181,15 +9766,18 @@ appear, and that no wide or wide wide string or character literals appear in the program (that is literals representing characters not in type @code{Character}). -@node SPARK -@unnumberedsubsec SPARK -@findex SPARK +@node SPARK_05 +@unnumberedsubsec SPARK_05 +@findex SPARK_05 [GNAT] This restriction checks at compile time that some constructs -forbidden in SPARK are not present. The SPARK version used as a -reference is the same as the Ada mode for the unit, so a unit compiled -in Ada 95 mode with SPARK restrictions will be checked for constructs -forbidden in SPARK 95. Error messages related to SPARK restriction have -the form: +forbidden in SPARK 2005 are not present. Error messages related to +SPARK restriction have the form: + +@findex SPARK +The restriction @code{SPARK} is recognized as a +synonym for @code{SPARK_05}. This is retained for historical +compatibility purposes (and an unconditional warning will be generated +for its use, advising replacement by @code{SPARK}. @smallexample violation of restriction "SPARK" at <file> @@ -9198,18 +9786,22 @@ violation of restriction "SPARK" at <file> This is not a replacement for the semantic checks performed by the SPARK Examiner tool, as the compiler only deals currently with code, -not at all with SPARK annotations and does not guarantee catching all -cases of constructs forbidden by SPARK. +not at all with SPARK 2005 annotations and does not guarantee catching all +cases of constructs forbidden by SPARK 2005. -Thus it may well be the case that code which -passes the compiler in SPARK mode is rejected by the SPARK Examiner, -e.g. due to the different visibility rules of the Examiner based on -SPARK @code{inherit} annotations. +Thus it may well be the case that code which passes the compiler with +the SPARK restriction is rejected by the SPARK Examiner, e.g. due to +the different visibility rules of the Examiner based on SPARK 2005 +@code{inherit} annotations. -This restriction can be useful in providing an initial filter for -code developed using SPARK, or in examining legacy code to see how far +This restriction can be useful in providing an initial filter for code +developed using SPARK 2005, or in examining legacy code to see how far it is from meeting SPARK restrictions. +Note that if a unit is compiled in Ada 95 mode with SPARK restriction, +violations will be reported for constructs forbidden in SPARK 95, +instead of SPARK 2005. + @c ------------------------ @node Implementation Advice @chapter Implementation Advice @@ -20435,3 +21027,5 @@ this kind of implementation dependent addition. @contents @bye +tablishes the following set of restrictions: +Pragma Shared diff --git a/gcc/ada/gnat_ugn.texi b/gcc/ada/gnat_ugn.texi index af5209c5f8b..4099ace5c67 100644 --- a/gcc/ada/gnat_ugn.texi +++ b/gcc/ada/gnat_ugn.texi @@ -3726,7 +3726,8 @@ users guide. @end ifset Create expanded source files for source level debugging. This switch also suppress generation of cross-reference information -(see @option{-gnatx}). +(see @option{-gnatx}). Note that this switch is not allowed if a previous +-gnatR switch has been given, since these two switches are not compatible. @item ^-gnateA^/ALIASING_CHECK^ @cindex @option{-gnateA} (@command{gcc}) @@ -4005,6 +4006,8 @@ Treat pragma Restrictions as Restriction_Warnings. @item ^-gnatR@r{[}0@r{/}1@r{/}2@r{/}3@r{[}s@r{]]}^/REPRESENTATION_INFO^ @cindex @option{-gnatR} (@command{gcc}) Output representation information for declared types and objects. +Note that this switch is not allowed if a previous +-gnatD switch has been given, since these two switches are not compatible. @item -gnats @cindex @option{-gnats} (@command{gcc}) @@ -6062,7 +6065,8 @@ the examples in the Ada Reference Manual. Full line comments must be aligned with the @code{--} starting on a column that is a multiple of the alignment level, or they may be aligned the same way as the following non-blank line (this is useful when full line comments appear in the middle -of a statement. +of a statement, or they may be aligned with the source line on the previous +non-blank line. @item ^a^ATTRIBUTE^ @emph{Check attribute casing.} @@ -11607,6 +11611,7 @@ recognized by GNAT: Short_Circuit_And_Or Source_File_Name Source_File_Name_Project + SPARK_Mode Style_Checks Suppress Suppress_Exception_Locations @@ -17246,6 +17251,7 @@ The pragmas listed below should be used with caution inside libraries, as they can create incompatibilities with other Ada libraries: @itemize @bullet @item pragma @code{Locking_Policy} +@item pragma @code{Partition_Elaboration_Policy} @item pragma @code{Queuing_Policy} @item pragma @code{Task_Dispatching_Policy} @item pragma @code{Unreserve_All_Interrupts} diff --git a/gcc/ada/gnatcmd.adb b/gcc/ada/gnatcmd.adb index be1567089af..d879cb7813a 100644 --- a/gcc/ada/gnatcmd.adb +++ b/gcc/ada/gnatcmd.adb @@ -406,18 +406,19 @@ procedure GNATCmd is end if; end loop; - -- If all arguments are switches and there is no switch -files=, add - -- the path names of all the sources of the main project. + -- If all arguments are switches and there is no switch -files=, add the + -- path names of all the sources of the main project. if Add_Sources then - -- For gnatcheck, gnatpp, and gnatmetric, create a temporary file - -- and put the list of sources in it. For gnatstack create a - -- temporary file with the list of .ci files. + -- For gnatcheck, gnatpp, and gnatmetric, create a temporary file and + -- put the list of sources in it. For gnatstack create a temporary + -- file with the list of .ci files. if The_Command = Check or else The_Command = Pretty or else The_Command = Metric or else + The_Command = List or else The_Command = Stack then Tempdir.Create_Temp_File (FD, Temp_File_Name); @@ -552,12 +553,10 @@ procedure GNATCmd is end if; if not Subunit then - Last_Switches.Increment_Last; - Last_Switches.Table (Last_Switches.Last) := - new String' - (Get_Name_String - (Unit.File_Names - (Impl).Display_File)); + Add_To_Response_File + (Get_Name_String + (Unit.File_Names (Impl).Display_File), + Check_File => False); end if; end if; @@ -570,10 +569,10 @@ procedure GNATCmd is if All_Projects or else Unit.File_Names (Spec).Project = Project then - Last_Switches.Increment_Last; - Last_Switches.Table (Last_Switches.Last) := - new String'(Get_Name_String - (Unit.File_Names (Spec).Display_File)); + Add_To_Response_File + (Get_Name_String + (Unit.File_Names (Spec).Display_File), + Check_File => False); end if; end if; diff --git a/gcc/ada/lib-load.adb b/gcc/ada/lib-load.adb index be4c5376c36..6d65c81383c 100644 --- a/gcc/ada/lib-load.adb +++ b/gcc/ada/lib-load.adb @@ -6,7 +6,7 @@ -- -- -- B o d y -- -- -- --- Copyright (C) 1992-2012, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- @@ -206,28 +206,29 @@ package body Lib.Load is Unum := Units.Last; Units.Table (Unum) := ( - Cunit => Cunit, - Cunit_Entity => Cunit_Entity, - Dependency_Num => 0, - Dynamic_Elab => False, - Error_Location => Sloc (With_Node), - Expected_Unit => Spec_Name, - Fatal_Error => True, - Generate_Code => False, - Has_Allocator => False, - Has_RACW => False, - Is_Compiler_Unit => False, - Ident_String => Empty, - Loading => False, - Main_Priority => Default_Main_Priority, - Main_CPU => Default_Main_CPU, - Munit_Index => 0, - Serial_Number => 0, - Source_Index => No_Source_File, - Unit_File_Name => Get_File_Name (Spec_Name, Subunit => False), - Unit_Name => Spec_Name, - Version => 0, - OA_Setting => 'O'); + Cunit => Cunit, + Cunit_Entity => Cunit_Entity, + Dependency_Num => 0, + Dynamic_Elab => False, + Error_Location => Sloc (With_Node), + Expected_Unit => Spec_Name, + Fatal_Error => True, + Generate_Code => False, + Has_Allocator => False, + Has_RACW => False, + Is_Compiler_Unit => False, + Ident_String => Empty, + Loading => False, + Main_Priority => Default_Main_Priority, + Main_CPU => Default_Main_CPU, + Munit_Index => 0, + Serial_Number => 0, + Source_Index => No_Source_File, + Unit_File_Name => Get_File_Name (Spec_Name, Subunit => False), + Unit_Name => Spec_Name, + Version => 0, + OA_Setting => 'O', + SPARK_Mode_Pragma => Empty); Set_Comes_From_Source_Default (Save_CS); Set_Error_Posted (Cunit_Entity); @@ -312,28 +313,29 @@ package body Lib.Load is end if; Units.Table (Main_Unit) := ( - Cunit => Empty, - Cunit_Entity => Empty, - Dependency_Num => 0, - Dynamic_Elab => False, - Error_Location => No_Location, - Expected_Unit => No_Unit_Name, - Fatal_Error => False, - Generate_Code => False, - Has_Allocator => False, - Has_RACW => False, - Is_Compiler_Unit => False, - Ident_String => Empty, - Loading => True, - Main_Priority => Default_Main_Priority, - Main_CPU => Default_Main_CPU, - Munit_Index => 0, - Serial_Number => 0, - Source_Index => Main_Source_File, - Unit_File_Name => Fname, - Unit_Name => No_Unit_Name, - Version => Version, - OA_Setting => 'O'); + Cunit => Empty, + Cunit_Entity => Empty, + Dependency_Num => 0, + Dynamic_Elab => False, + Error_Location => No_Location, + Expected_Unit => No_Unit_Name, + Fatal_Error => False, + Generate_Code => False, + Has_Allocator => False, + Has_RACW => False, + Is_Compiler_Unit => False, + Ident_String => Empty, + Loading => True, + Main_Priority => Default_Main_Priority, + Main_CPU => Default_Main_CPU, + Munit_Index => 0, + Serial_Number => 0, + Source_Index => Main_Source_File, + Unit_File_Name => Fname, + Unit_Name => No_Unit_Name, + Version => Version, + OA_Setting => 'O', + SPARK_Mode_Pragma => Empty); end if; end Load_Main_Source; @@ -675,28 +677,29 @@ package body Lib.Load is if Src_Ind /= No_Source_File then Units.Table (Unum) := ( - Cunit => Empty, - Cunit_Entity => Empty, - Dependency_Num => 0, - Dynamic_Elab => False, - Error_Location => Sloc (Error_Node), - Expected_Unit => Uname_Actual, - Fatal_Error => False, - Generate_Code => False, - Has_Allocator => False, - Has_RACW => False, - Is_Compiler_Unit => False, - Ident_String => Empty, - Loading => True, - Main_Priority => Default_Main_Priority, - Main_CPU => Default_Main_CPU, - Munit_Index => 0, - Serial_Number => 0, - Source_Index => Src_Ind, - Unit_File_Name => Fname, - Unit_Name => Uname_Actual, - Version => Source_Checksum (Src_Ind), - OA_Setting => 'O'); + Cunit => Empty, + Cunit_Entity => Empty, + Dependency_Num => 0, + Dynamic_Elab => False, + Error_Location => Sloc (Error_Node), + Expected_Unit => Uname_Actual, + Fatal_Error => False, + Generate_Code => False, + Has_Allocator => False, + Has_RACW => False, + Is_Compiler_Unit => False, + Ident_String => Empty, + Loading => True, + Main_Priority => Default_Main_Priority, + Main_CPU => Default_Main_CPU, + Munit_Index => 0, + Serial_Number => 0, + Source_Index => Src_Ind, + Unit_File_Name => Fname, + Unit_Name => Uname_Actual, + Version => Source_Checksum (Src_Ind), + OA_Setting => 'O', + SPARK_Mode_Pragma => Empty); -- Parse the new unit diff --git a/gcc/ada/lib-load.ads b/gcc/ada/lib-load.ads index a029d3793b0..3ae9ccaf1aa 100644 --- a/gcc/ada/lib-load.ads +++ b/gcc/ada/lib-load.ads @@ -6,7 +6,7 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 1992-2011, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- @@ -193,7 +193,7 @@ package Lib.Load is -- generate a compilation unit node for it, and we need to make an entry -- for it in the units table, so as to maintain a one-to-one mapping -- between table and nodes. The table entry is used among other things to - -- provide a canonical traversal order for context units for Inspector. + -- provide a canonical traversal order for context units for CodePeer. -- The flag In_Main indicates whether the instance is the main unit. procedure Version_Update (U : Node_Id; From : Node_Id); diff --git a/gcc/ada/lib-writ.adb b/gcc/ada/lib-writ.adb index e786f473add..c95b9dc4f83 100644 --- a/gcc/ada/lib-writ.adb +++ b/gcc/ada/lib-writ.adb @@ -71,28 +71,29 @@ package body Lib.Writ is begin Units.Increment_Last; Units.Table (Units.Last) := - (Unit_File_Name => File_Name (S), - Unit_Name => No_Unit_Name, - Expected_Unit => No_Unit_Name, - Source_Index => S, - Cunit => Empty, - Cunit_Entity => Empty, - Dependency_Num => 0, - Dynamic_Elab => False, - Fatal_Error => False, - Generate_Code => False, - Has_Allocator => False, - Has_RACW => False, - Is_Compiler_Unit => False, - Ident_String => Empty, - Loading => False, - Main_Priority => -1, - Main_CPU => -1, - Munit_Index => 0, - Serial_Number => 0, - Version => 0, - Error_Location => No_Location, - OA_Setting => 'O'); + (Unit_File_Name => File_Name (S), + Unit_Name => No_Unit_Name, + Expected_Unit => No_Unit_Name, + Source_Index => S, + Cunit => Empty, + Cunit_Entity => Empty, + Dependency_Num => 0, + Dynamic_Elab => False, + Fatal_Error => False, + Generate_Code => False, + Has_Allocator => False, + Has_RACW => False, + Is_Compiler_Unit => False, + Ident_String => Empty, + Loading => False, + Main_Priority => -1, + Main_CPU => -1, + Munit_Index => 0, + Serial_Number => 0, + Version => 0, + Error_Location => No_Location, + OA_Setting => 'O', + SPARK_Mode_Pragma => Empty); end Add_Preprocessing_Dependency; ------------------------------ @@ -128,28 +129,29 @@ package body Lib.Writ is Units.Increment_Last; Units.Table (Units.Last) := ( - Unit_File_Name => System_Fname, - Unit_Name => System_Uname, - Expected_Unit => System_Uname, - Source_Index => System_Source_File_Index, - Cunit => Empty, - Cunit_Entity => Empty, - Dependency_Num => 0, - Dynamic_Elab => False, - Fatal_Error => False, - Generate_Code => False, - Has_Allocator => False, - Has_RACW => False, - Is_Compiler_Unit => False, - Ident_String => Empty, - Loading => False, - Main_Priority => -1, - Main_CPU => -1, - Munit_Index => 0, - Serial_Number => 0, - Version => 0, - Error_Location => No_Location, - OA_Setting => 'O'); + Unit_File_Name => System_Fname, + Unit_Name => System_Uname, + Expected_Unit => System_Uname, + Source_Index => System_Source_File_Index, + Cunit => Empty, + Cunit_Entity => Empty, + Dependency_Num => 0, + Dynamic_Elab => False, + Fatal_Error => False, + Generate_Code => False, + Has_Allocator => False, + Has_RACW => False, + Is_Compiler_Unit => False, + Ident_String => Empty, + Loading => False, + Main_Priority => -1, + Main_CPU => -1, + Munit_Index => 0, + Serial_Number => 0, + Version => 0, + Error_Location => No_Location, + OA_Setting => 'O', + SPARK_Mode_Pragma => Empty); -- Parse system.ads so that the checksum is set right -- Style checks are not applied. @@ -880,6 +882,38 @@ package body Lib.Writ is Write_Info_EOL; end loop; + + -- Finally generate the special lines for cases of Restriction_Set + -- with No_Dependence and no restriction present. + + declare + Unam : Unit_Name_Type; + + begin + for J in Restriction_Set_Dependences.First .. + Restriction_Set_Dependences.Last + loop + Unam := Restriction_Set_Dependences.Table (J); + + -- Don't need an entry if already in the unit table + + for U in 0 .. Last_Unit loop + if Unit_Name (U) = Unam then + goto Continue; + end if; + end loop; + + -- Otherwise generate the entry + + Write_Info_Initiate ('W'); + Write_Info_Char (' '); + Write_Info_Name (Unam); + Write_Info_EOL; + + <<Continue>> + null; + end loop; + end; end Write_With_Lines; -- Start of processing for Write_ALI diff --git a/gcc/ada/lib-writ.ads b/gcc/ada/lib-writ.ads index b631b2aa43a..b9d69c2c99c 100644 --- a/gcc/ada/lib-writ.ads +++ b/gcc/ada/lib-writ.ads @@ -402,7 +402,9 @@ package Lib.Writ is -- No restriction pragma is present for the named boolean restriction. -- However, the compiler did detect one or more violations of this - -- restriction, which may require a binder consistency check. + -- restriction, which may require a binder consistency check. Note that + -- one case of a violation is the use of a Restriction_Set attribute for + -- the restriction that yielded False. -- For the case of restrictions that take a parameter, we need both the -- information from pragma if present, and the actual information about @@ -618,9 +620,9 @@ package Lib.Writ is -- Following each U line, is a series of lines of the form -- W unit-name [source-name lib-name] [E] [EA] [ED] [AD] - -- or + -- or -- Y unit-name [source-name lib-name] [E] [EA] [ED] [AD] - -- or + -- or -- Z unit-name [source-name lib-name] [E] [EA] [ED] [AD] -- -- One W line is present for each unit that is mentioned in an explicit @@ -655,6 +657,14 @@ package Lib.Writ is -- The parameter source-name and lib-name are omitted for the case of a -- generic unit compiled with earlier versions of GNAT which did not -- generate object or ali files for generics. + -- + -- The parameter source-name and lib-name are also omitted for the W + -- lines that result from use of a Restriction_Set attribute which gets + -- a result of False from a No_Dependence check, in the case where the + -- unit is not in the semantic closure. In such a case, the bare W + -- line is generated, but no D (dependency) line. This will make the + -- binder do the consistency check, but not include the unit in the + -- partition closure (unless it is properly With'ed somewhere). -- ----------------------- -- -- L Linker_Options -- diff --git a/gcc/ada/lib-xref.adb b/gcc/ada/lib-xref.adb index 8825f066f4e..182c2b0a979 100644 --- a/gcc/ada/lib-xref.adb +++ b/gcc/ada/lib-xref.adb @@ -1079,6 +1079,9 @@ package body Lib.Xref is Next_Entity (Formal); end loop; + elsif Ekind (E) in Access_Subprogram_Kind then + Formal := First_Formal (Designated_Type (E)); + else Formal := First_Formal (E); end if; diff --git a/gcc/ada/lib-xref.ads b/gcc/ada/lib-xref.ads index cfb43d8b1dc..baa07daade9 100644 --- a/gcc/ada/lib-xref.ads +++ b/gcc/ada/lib-xref.ads @@ -718,7 +718,7 @@ package Lib.Xref is procedure Generate_Reference_To_Formals (E : Entity_Id); -- Add a reference to the definition of each formal on the line for - -- a subprogram. + -- a subprogram or an access_to_subprogram type. procedure Generate_Reference_To_Generic_Formals (E : Entity_Id); -- Add a reference to the definition of each generic formal on the line diff --git a/gcc/ada/lib.adb b/gcc/ada/lib.adb index fc62239b29e..e220b20e08e 100644 --- a/gcc/ada/lib.adb +++ b/gcc/ada/lib.adb @@ -6,7 +6,7 @@ -- -- -- B o d y -- -- -- --- Copyright (C) 1992-2012, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- @@ -166,6 +166,11 @@ package body Lib is return Units.Table (U).Source_Index; end Source_Index; + function SPARK_Mode_Pragma (U : Unit_Number_Type) return Node_Id is + begin + return Units.Table (U).SPARK_Mode_Pragma; + end SPARK_Mode_Pragma; + function Unit_File_Name (U : Unit_Number_Type) return File_Name_Type is begin return Units.Table (U).Unit_File_Name; @@ -254,6 +259,11 @@ package body Lib is Units.Table (U).OA_Setting := C; end Set_OA_Setting; + procedure Set_SPARK_Mode_Pragma (U : Unit_Number_Type; N : Node_Id) is + begin + Units.Table (U).SPARK_Mode_Pragma := N; + end Set_SPARK_Mode_Pragma; + procedure Set_Unit_Name (U : Unit_Number_Type; N : Unit_Name_Type) is begin Units.Table (U).Unit_Name := N; diff --git a/gcc/ada/lib.ads b/gcc/ada/lib.ads index f2cc330fdb9..5370e4ad907 100644 --- a/gcc/ada/lib.ads +++ b/gcc/ada/lib.ads @@ -6,7 +6,7 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 1992-2012, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- @@ -265,38 +265,6 @@ package Lib is -- The first entry in the table, subscript Main_Unit, is for the main file. -- Each entry in this units table contains the following data. - -- Unit_File_Name - -- The name of the source file containing the unit. Set when the entry - -- is created by a call to Lib.Load, and then cannot be changed. - - -- Source_Index - -- The index in the source file table of the corresponding source file. - -- Set when the entry is created by a call to Lib.Load and then cannot - -- be changed. - - -- Munit_Index - -- The index of the unit within the file for multiple unit per file - -- mode. Set to zero in normal single unit per file mode. - - -- Error_Location - -- This is copied from the Sloc field of the Enode argument passed - -- to Load_Unit. It refers to the enclosing construct which caused - -- this unit to be loaded, e.g. most typically the with clause that - -- referenced the unit, and is used for error handling in Par.Load. - - -- Expected_Unit - -- This is the expected unit name for a file other than the main unit, - -- since these are cases where we load the unit using Lib.Load and we - -- know the unit that is expected. It must be the same as Unit_Name - -- if it is set (see test in Par.Load). Expected_Unit is set to - -- No_Name for the main unit. - - -- Unit_Name - -- The name of the unit. Initialized to No_Name by Lib.Load, and then - -- set by the parser when the unit is parsed to the unit name actually - -- found in the file (which should, in the absence of errors) be the - -- same name as Expected_Unit. - -- Cunit -- Pointer to the N_Compilation_Unit node. Initially set to Empty by -- Lib.Load, and then reset to the required node by the parser when @@ -320,6 +288,19 @@ package Lib is -- checks specified (as the result of using the -gnatE compilation -- option or a pragma Elaboration_Checks (Dynamic). + -- Error_Location + -- This is copied from the Sloc field of the Enode argument passed + -- to Load_Unit. It refers to the enclosing construct which caused + -- this unit to be loaded, e.g. most typically the with clause that + -- referenced the unit, and is used for error handling in Par.Load. + + -- Expected_Unit + -- This is the expected unit name for a file other than the main unit, + -- since these are cases where we load the unit using Lib.Load and we + -- know the unit that is expected. It must be the same as Unit_Name + -- if it is set (see test in Par.Load). Expected_Unit is set to + -- No_Name for the main unit. + -- Fatal_Error -- A flag that is initialized to False, and gets set to True if a fatal -- error occurs during the processing of a unit. A fatal error is one @@ -335,6 +316,10 @@ package Lib is -- code is to be generated. This includes the unit explicitly compiled, -- together with its specification, and any subunits. + -- Has_Allocator + -- This flag is set if a subprogram unit has an allocator after the + -- BEGIN (it is used to set the AB flag in the M ALI line). + -- Has_RACW -- A Boolean flag, initially set to False when a unit entry is created, -- and set to True if the unit defines a remote access to class wide @@ -366,9 +351,9 @@ package Lib is -- that the default affinity is to be used (and is also used for -- entries that do not correspond to possible main programs). - -- Has_Allocator - -- This flag is set if a subprogram unit has an allocator after the - -- BEGIN (it is used to set the AB flag in the M ALI line). + -- Munit_Index + -- The index of the unit within the file for multiple unit per file + -- mode. Set to zero in normal single unit per file mode. -- OA_Setting -- This is a character field containing L if Optimize_Alignment mode @@ -381,6 +366,25 @@ package Lib is -- routine which increments the current value and returns it. This -- serial number is separate for each unit. + -- Source_Index + -- The index in the source file table of the corresponding source file. + -- Set when the entry is created by a call to Lib.Load and then cannot + -- be changed. + + -- SPARK_Mode_Pragma + -- Pointer to the configuration pragma SPARK_Mode that applies to the + -- whole unit. Add note of what this is used for ??? + + -- Unit_File_Name + -- The name of the source file containing the unit. Set when the entry + -- is created by a call to Lib.Load, and then cannot be changed. + + -- Unit_Name + -- The name of the unit. Initialized to No_Name by Lib.Load, and then + -- set by the parser when the unit is parsed to the unit name actually + -- found in the file (which should, in the absence of errors) be the + -- same name as Expected_Unit. + -- Version -- This field holds the version of the unit, which is computed as -- the exclusive or of the checksums of this unit, and all its @@ -404,43 +408,45 @@ package Lib is Default_Main_CPU : constant Int := -1; -- Value used in Main_CPU field to indicate default main affinity - function Cunit (U : Unit_Number_Type) return Node_Id; - function Cunit_Entity (U : Unit_Number_Type) return Entity_Id; - function Dependency_Num (U : Unit_Number_Type) return Nat; - function Dynamic_Elab (U : Unit_Number_Type) return Boolean; - function Error_Location (U : Unit_Number_Type) return Source_Ptr; - function Expected_Unit (U : Unit_Number_Type) return Unit_Name_Type; - function Fatal_Error (U : Unit_Number_Type) return Boolean; - function Generate_Code (U : Unit_Number_Type) return Boolean; - function Ident_String (U : Unit_Number_Type) return Node_Id; - function Has_Allocator (U : Unit_Number_Type) return Boolean; - function Has_RACW (U : Unit_Number_Type) return Boolean; - function Is_Compiler_Unit (U : Unit_Number_Type) return Boolean; - function Loading (U : Unit_Number_Type) return Boolean; - function Main_CPU (U : Unit_Number_Type) return Int; - function Main_Priority (U : Unit_Number_Type) return Int; - function Munit_Index (U : Unit_Number_Type) return Nat; - function OA_Setting (U : Unit_Number_Type) return Character; - function Source_Index (U : Unit_Number_Type) return Source_File_Index; - function Unit_File_Name (U : Unit_Number_Type) return File_Name_Type; - function Unit_Name (U : Unit_Number_Type) return Unit_Name_Type; + function Cunit (U : Unit_Number_Type) return Node_Id; + function Cunit_Entity (U : Unit_Number_Type) return Entity_Id; + function Dependency_Num (U : Unit_Number_Type) return Nat; + function Dynamic_Elab (U : Unit_Number_Type) return Boolean; + function Error_Location (U : Unit_Number_Type) return Source_Ptr; + function Expected_Unit (U : Unit_Number_Type) return Unit_Name_Type; + function Fatal_Error (U : Unit_Number_Type) return Boolean; + function Generate_Code (U : Unit_Number_Type) return Boolean; + function Ident_String (U : Unit_Number_Type) return Node_Id; + function Has_Allocator (U : Unit_Number_Type) return Boolean; + function Has_RACW (U : Unit_Number_Type) return Boolean; + function Is_Compiler_Unit (U : Unit_Number_Type) return Boolean; + function Loading (U : Unit_Number_Type) return Boolean; + function Main_CPU (U : Unit_Number_Type) return Int; + function Main_Priority (U : Unit_Number_Type) return Int; + function Munit_Index (U : Unit_Number_Type) return Nat; + function OA_Setting (U : Unit_Number_Type) return Character; + function Source_Index (U : Unit_Number_Type) return Source_File_Index; + function SPARK_Mode_Pragma (U : Unit_Number_Type) return Node_Id; + function Unit_File_Name (U : Unit_Number_Type) return File_Name_Type; + function Unit_Name (U : Unit_Number_Type) return Unit_Name_Type; -- Get value of named field from given units table entry - procedure Set_Cunit (U : Unit_Number_Type; N : Node_Id); - procedure Set_Cunit_Entity (U : Unit_Number_Type; E : Entity_Id); - procedure Set_Dynamic_Elab (U : Unit_Number_Type; B : Boolean := True); - procedure Set_Error_Location (U : Unit_Number_Type; W : Source_Ptr); - procedure Set_Fatal_Error (U : Unit_Number_Type; B : Boolean := True); - procedure Set_Generate_Code (U : Unit_Number_Type; B : Boolean := True); - procedure Set_Has_RACW (U : Unit_Number_Type; B : Boolean := True); - procedure Set_Has_Allocator (U : Unit_Number_Type; B : Boolean := True); - procedure Set_Is_Compiler_Unit (U : Unit_Number_Type; B : Boolean := True); - procedure Set_Ident_String (U : Unit_Number_Type; N : Node_Id); - procedure Set_Loading (U : Unit_Number_Type; B : Boolean := True); - procedure Set_Main_CPU (U : Unit_Number_Type; P : Int); - procedure Set_Main_Priority (U : Unit_Number_Type; P : Int); - procedure Set_OA_Setting (U : Unit_Number_Type; C : Character); - procedure Set_Unit_Name (U : Unit_Number_Type; N : Unit_Name_Type); + procedure Set_Cunit (U : Unit_Number_Type; N : Node_Id); + procedure Set_Cunit_Entity (U : Unit_Number_Type; E : Entity_Id); + procedure Set_Dynamic_Elab (U : Unit_Number_Type; B : Boolean := True); + procedure Set_Error_Location (U : Unit_Number_Type; W : Source_Ptr); + procedure Set_Fatal_Error (U : Unit_Number_Type; B : Boolean := True); + procedure Set_Generate_Code (U : Unit_Number_Type; B : Boolean := True); + procedure Set_Has_RACW (U : Unit_Number_Type; B : Boolean := True); + procedure Set_Has_Allocator (U : Unit_Number_Type; B : Boolean := True); + procedure Set_Is_Compiler_Unit (U : Unit_Number_Type; B : Boolean := True); + procedure Set_Ident_String (U : Unit_Number_Type; N : Node_Id); + procedure Set_Loading (U : Unit_Number_Type; B : Boolean := True); + procedure Set_Main_CPU (U : Unit_Number_Type; P : Int); + procedure Set_Main_Priority (U : Unit_Number_Type; P : Int); + procedure Set_OA_Setting (U : Unit_Number_Type; C : Character); + procedure Set_SPARK_Mode_Pragma (U : Unit_Number_Type; N : Node_Id); + procedure Set_Unit_Name (U : Unit_Number_Type; N : Unit_Name_Type); -- Set value of named field for given units table entry. Note that we -- do not have an entry for each possible field, since some of the fields -- can only be set by specialized interfaces (defined below). @@ -682,6 +688,42 @@ package Lib is -- of the printout. If Withs is True, we print out units with'ed by this -- unit (not counting limited withs). + --------------------------------------------------------------- + -- Special Handling for Restriction_Set (No_Dependence) Case -- + --------------------------------------------------------------- + + -- If we have a Restriction_Set attribute for No_Dependence => unit, + -- and the unit is not given in a No_Dependence restriction that we + -- can see, the attribute will return False. + + -- We have to ensure in this case that the binder will reject any attempt + -- to set a No_Dependence restriction in some other unit in the partition. + + -- If the unit is in the semantic closure, then of course it is properly + -- WITH'ed by someone, and the binder will do this job automatically as + -- part of its normal processing. + + -- But if the unit is not in the semantic closure, we must make sure the + -- binder knows about it. The use of the Restriction_Set attribute giving + -- a result of False does not mean of itself that we have to include the + -- unit in the partition. So what we do is to generate a with (W) line in + -- the ali file (with no file name information), but no corresponding D + -- (dependency) line. This is recognized by the binder as meaning "Don't + -- let anyone specify No_Dependence for this unit, but you don't have to + -- include it if there is no real W line for the unit". + + -- The following table keeps track of relevant units. It is used in the + -- Lib.Writ circuit for outputting With lines to output the special with + -- line with RA if the unit is not in the semantic closure. + + package Restriction_Set_Dependences is new Table.Table ( + Table_Component_Type => Unit_Name_Type, + Table_Index_Type => Int, + Table_Low_Bound => 0, + Table_Initial => 10, + Table_Increment => 100, + Table_Name => "Restriction_Attribute_Dependences"); + private pragma Inline (Cunit); pragma Inline (Cunit_Entity); @@ -707,34 +749,37 @@ private pragma Inline (Set_Main_CPU); pragma Inline (Set_Main_Priority); pragma Inline (Set_OA_Setting); + pragma Inline (Set_SPARK_Mode_Pragma); pragma Inline (Set_Unit_Name); pragma Inline (Source_Index); + pragma Inline (SPARK_Mode_Pragma); pragma Inline (Unit_File_Name); pragma Inline (Unit_Name); type Unit_Record is record - Unit_File_Name : File_Name_Type; - Unit_Name : Unit_Name_Type; - Munit_Index : Nat; - Expected_Unit : Unit_Name_Type; - Source_Index : Source_File_Index; - Cunit : Node_Id; - Cunit_Entity : Entity_Id; - Dependency_Num : Int; - Ident_String : Node_Id; - Main_Priority : Int; - Main_CPU : Int; - Serial_Number : Nat; - Version : Word; - Error_Location : Source_Ptr; - Fatal_Error : Boolean; - Generate_Code : Boolean; - Has_RACW : Boolean; - Is_Compiler_Unit : Boolean; - Dynamic_Elab : Boolean; - Loading : Boolean; - Has_Allocator : Boolean; - OA_Setting : Character; + Unit_File_Name : File_Name_Type; + Unit_Name : Unit_Name_Type; + Munit_Index : Nat; + Expected_Unit : Unit_Name_Type; + Source_Index : Source_File_Index; + Cunit : Node_Id; + Cunit_Entity : Entity_Id; + Dependency_Num : Int; + Ident_String : Node_Id; + Main_Priority : Int; + Main_CPU : Int; + Serial_Number : Nat; + Version : Word; + Error_Location : Source_Ptr; + Fatal_Error : Boolean; + Generate_Code : Boolean; + Has_RACW : Boolean; + Is_Compiler_Unit : Boolean; + Dynamic_Elab : Boolean; + Loading : Boolean; + Has_Allocator : Boolean; + OA_Setting : Character; + SPARK_Mode_Pragma : Node_Id; end record; -- The following representation clause ensures that the above record @@ -742,31 +787,32 @@ private -- written by Tree_Gen, we do not write uninitialized values to the file. for Unit_Record use record - Unit_File_Name at 0 range 0 .. 31; - Unit_Name at 4 range 0 .. 31; - Munit_Index at 8 range 0 .. 31; - Expected_Unit at 12 range 0 .. 31; - Source_Index at 16 range 0 .. 31; - Cunit at 20 range 0 .. 31; - Cunit_Entity at 24 range 0 .. 31; - Dependency_Num at 28 range 0 .. 31; - Ident_String at 32 range 0 .. 31; - Main_Priority at 36 range 0 .. 31; - Main_CPU at 40 range 0 .. 31; - Serial_Number at 44 range 0 .. 31; - Version at 48 range 0 .. 31; - Error_Location at 52 range 0 .. 31; - Fatal_Error at 56 range 0 .. 7; - Generate_Code at 57 range 0 .. 7; - Has_RACW at 58 range 0 .. 7; - Dynamic_Elab at 59 range 0 .. 7; - Is_Compiler_Unit at 60 range 0 .. 7; - OA_Setting at 61 range 0 .. 7; - Loading at 62 range 0 .. 7; - Has_Allocator at 63 range 0 .. 7; + Unit_File_Name at 0 range 0 .. 31; + Unit_Name at 4 range 0 .. 31; + Munit_Index at 8 range 0 .. 31; + Expected_Unit at 12 range 0 .. 31; + Source_Index at 16 range 0 .. 31; + Cunit at 20 range 0 .. 31; + Cunit_Entity at 24 range 0 .. 31; + Dependency_Num at 28 range 0 .. 31; + Ident_String at 32 range 0 .. 31; + Main_Priority at 36 range 0 .. 31; + Main_CPU at 40 range 0 .. 31; + Serial_Number at 44 range 0 .. 31; + Version at 48 range 0 .. 31; + Error_Location at 52 range 0 .. 31; + Fatal_Error at 56 range 0 .. 7; + Generate_Code at 57 range 0 .. 7; + Has_RACW at 58 range 0 .. 7; + Dynamic_Elab at 59 range 0 .. 7; + Is_Compiler_Unit at 60 range 0 .. 7; + OA_Setting at 61 range 0 .. 7; + Loading at 62 range 0 .. 7; + Has_Allocator at 63 range 0 .. 7; + SPARK_Mode_Pragma at 64 range 0 .. 31; end record; - for Unit_Record'Size use 64 * 8; + for Unit_Record'Size use 68 * 8; -- This ensures that we did not leave out any fields package Units is new Table.Table ( diff --git a/gcc/ada/opt.ads b/gcc/ada/opt.ads index 01cbad1fc9a..a4cbafd3888 100644 --- a/gcc/ada/opt.ads +++ b/gcc/ada/opt.ads @@ -1147,12 +1147,6 @@ package Opt is -- Set to true to enable printing of package standard in source form. -- This flag is set by the -gnatS switch - Propagate_Exceptions : Boolean := False; - -- GNAT - -- Indicates if subprogram descriptor exception tables should be - -- built for imported subprograms. Set True if a Propagate_Exceptions - -- pragma applies to the extended main unit. - type Usage is (Unknown, Not_In_Use, In_Use); Project_File_In_Use : Usage := Unknown; -- GNAT @@ -1976,6 +1970,21 @@ package Opt is -- Modes for Formal Verification -- ----------------------------------- + Frame_Condition_Mode : Boolean := False; + -- Specific mode to be used in combination with SPARK_Mode. If set to + -- true, ALI files containing the frame conditions (global effects) are + -- generated, and Why files are *not* generated. If not true, Why files + -- are generated. Set by debug flag -gnatd.G. + + Formal_Extensions : Boolean := False; + -- When this flag is set, new aspects/pragmas/attributes are accepted, + -- whose main purpose is to facilitate formal verification. Set by debug + -- flag -gnatd.V. + + Global_SPARK_Mode : SPARK_Mode_Id := None; + -- The mode applicable to the whole compilation. The global mode can be set + -- in a configuration file such as gnat.adc. + SPARK_Mode : Boolean := False; -- Specific compiling mode targeting formal verification through the -- generation of Why code for those parts of the input code that belong to @@ -1984,22 +1993,11 @@ package Opt is -- from the SPARK restriction defined in GNAT to detect violations of a -- subset of SPARK 2005 rules. - Frame_Condition_Mode : Boolean := False; - -- Specific mode to be used in combination with SPARK_Mode. If set to - -- true, ALI files containing the frame conditions (global effects) are - -- generated, and Why files are *not* generated. If not true, Why files - -- are generated. Set by debug flag -gnatd.G. - SPARK_Strict_Mode : Boolean := False; -- Interpret compiler permissions as strictly as possible. E.g. base ranges -- for integers are limited to the strict minimum with this option. Set by -- debug flag -gnatd.D. - Formal_Extensions : Boolean := False; - -- When this flag is set, new aspects/pragmas/attributes are accepted, - -- whose main purpose is to facilitate formal verification. Set by debug - -- flag -gnatd.V. - function Full_Expander_Active return Boolean; pragma Inline (Full_Expander_Active); -- Returns the value of (Expander_Active and not SPARK_Mode). This "flag" diff --git a/gcc/ada/par-ch4.adb b/gcc/ada/par-ch4.adb index e1e634a9e96..38fd00e1fbb 100644 --- a/gcc/ada/par-ch4.adb +++ b/gcc/ada/par-ch4.adb @@ -40,6 +40,7 @@ package body Ch4 is Attribute_Class => True, Attribute_External_Tag => True, Attribute_Img => True, + Attribute_Loop_Entry => True, Attribute_Stub_Type => True, Attribute_Version => True, Attribute_Type_Key => True, @@ -50,6 +51,13 @@ package body Ch4 is -- list because it may denote a slice operation (X'Img (1 .. 2)) or -- a type conversion (X'Class (Y)). + -- Note: Loop_Entry is in this list because, although it can take an + -- optional argument (the loop name), we can't distinguish that at parse + -- time from the case where no loop name is given and a legitimate index + -- expression is present. So we parse the argument as an indexed component + -- and the semantic analysis sorts out this syntactic ambiguity based on + -- the type and form of the expression. + -- Note that this map designates the minimum set of attributes where a -- construct in parentheses that is not an argument can appear right -- after the attribute. For attributes like 'Size, we do not put them @@ -503,29 +511,24 @@ package body Ch4 is Set_Attribute_Name (Name_Node, Attr_Name); -- Scan attribute arguments/designator. We skip this if we know - -- that the attribute cannot have an argument. + -- that the attribute cannot have an argument (see documentation + -- of Is_Parameterless_Attribute for further details). if Token = Tok_Left_Paren and then not Is_Parameterless_Attribute (Get_Attribute_Id (Attr_Name)) then - -- Attribute Loop_Entry has no effect on the name extension - -- parsing logic, as if the attribute never existed in the - -- source. Continue parsing the subsequent expressions or - -- ranges. - - if Attr_Name = Name_Loop_Entry then - Scan; -- past left paren - goto Scan_Name_Extension_Left_Paren; - -- Attribute Update contains an array or record association -- list which provides new values for various components or - -- elements. The list is parsed as an aggregate. + -- elements. The list is parsed as an aggregate, and we get + -- better error handling by knowing that in the parser. - elsif Attr_Name = Name_Update then + if Attr_Name = Name_Update then Set_Expressions (Name_Node, New_List); Append (P_Aggregate, Expressions (Name_Node)); + -- All other cases of parsing attribute arguments + else Set_Expressions (Name_Node, New_List); Scan; -- past left paren @@ -533,12 +536,40 @@ package body Ch4 is loop declare Expr : constant Node_Id := P_Expression_If_OK; + Rnam : Node_Id; begin + -- Case of => for named notation + if Token = Tok_Arrow then - Error_Msg_SC - ("named parameters not permitted for attributes"); - Scan; -- past junk arrow + + -- Named notation allowed only for the special + -- case of System'Restriction_Set (No_Dependence => + -- unit_NAME), in which case construct a parameter + -- assocation node and append to the arguments. + + if Attr_Name = Name_Restriction_Set + and then Nkind (Expr) = N_Identifier + and then Chars (Expr) = Name_No_Dependence + then + Scan; -- past arrow + Rnam := P_Name; + Append_To (Expressions (Name_Node), + Make_Parameter_Association (Sloc (Rnam), + Selector_Name => Expr, + Explicit_Actual_Parameter => Rnam)); + exit; + + -- For all other cases named notation is illegal + + else + Error_Msg_SC + ("named parameters not permitted " + & "for attributes"); + Scan; -- past junk arrow + end if; + + -- Here for normal case (not => for named parameter) else Append (Expr, Expressions (Name_Node)); diff --git a/gcc/ada/par-ch5.adb b/gcc/ada/par-ch5.adb index d6d6b2f276d..e9b0a2c8e95 100644 --- a/gcc/ada/par-ch5.adb +++ b/gcc/ada/par-ch5.adb @@ -6,7 +6,7 @@ -- -- -- B o d y -- -- -- --- Copyright (C) 1992-2012, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- diff --git a/gcc/ada/par-prag.adb b/gcc/ada/par-prag.adb index 3587dff4d12..4d01db09d12 100644 --- a/gcc/ada/par-prag.adb +++ b/gcc/ada/par-prag.adb @@ -232,18 +232,16 @@ function Prag (Pragma_Node : Node_Id; Semi : Source_Ptr) return Node_Id is Id := Chars (Arg); Expr := Expression (Arg); - if Id = No_Name - and then Nkind (Expr) = N_Identifier - then - case Get_Restriction_Id (Chars (Expr)) is - when No_Obsolescent_Features => + if Id = No_Name and then Nkind (Expr) = N_Identifier then + case Chars (Expr) is + when Name_No_Obsolescent_Features => Set_Restriction (No_Obsolescent_Features, Pragma_Node); Restriction_Warnings (No_Obsolescent_Features) := Prag_Id = Pragma_Restriction_Warnings; - when SPARK => - Set_Restriction (SPARK, Pragma_Node); - Restriction_Warnings (SPARK) := + when Name_SPARK | Name_SPARK_05 => + Set_Restriction (SPARK_05, Pragma_Node); + Restriction_Warnings (SPARK_05) := Prag_Id = Pragma_Restriction_Warnings; when others => @@ -1262,6 +1260,7 @@ begin Pragma_Short_Circuit_And_Or | Pragma_Short_Descriptors | Pragma_Simple_Storage_Pool_Type | + Pragma_SPARK_Mode | Pragma_Storage_Size | Pragma_Storage_Unit | Pragma_Static_Elaboration_Desired | diff --git a/gcc/ada/par_sco.adb b/gcc/ada/par_sco.adb index 29c2daa89e1..ce54f117e34 100644 --- a/gcc/ada/par_sco.adb +++ b/gcc/ada/par_sco.adb @@ -2095,7 +2095,14 @@ package body Par_SCO is if Is_Non_Empty_List (L) then N := First (L); while Present (N) loop - Traverse_One (N); + + -- Note: For separate bodies, we see the tree after Par.Labl has + -- introduced implicit labels, so we need to ignore those nodes. + + if Nkind (N) /= N_Implicit_Label_Declaration then + Traverse_One (N); + end if; + Next (N); end loop; diff --git a/gcc/ada/projects.texi b/gcc/ada/projects.texi index 2c334686b54..7072e0e6ada 100644 --- a/gcc/ada/projects.texi +++ b/gcc/ada/projects.texi @@ -926,16 +926,21 @@ The following attributes can be defined in package @code{Naming}: that contain declaration (header files in C for instance). The attribute is indexed on the language. The two attributes are equivalent, but the latter is obsolescent. + + If the value of the attribute is the empty string, it indicates to the + Project Manager that the only specifications/header files for the language + are those specified with attributes @code{Spec} or + @code{Specification_Exceptions}. + If @code{Spec_Suffix ("Ada")} is not specified, then the default is @code{"^.ads^.ADS^"}. - The value must satisfy the following requirements: + + A non empty value must satisfy the following requirements: @itemize - - @item It must not be empty - @item It cannot start with an alphanumeric character - @item It cannot start with an underscore followed by an alphanumeric character @item It must include at least one dot - + @item If @code{Dot_Replacement} is a single dot, then it cannot include + more than one dot. @end itemize @item @b{Body_Suffix} and @b{Implementation_Suffix}: @@ -945,6 +950,14 @@ The following attributes can be defined in package @code{Naming}: code (bodies in Ada). They are indexed on the language. The second version is obsolescent and fully replaced by the first attribute. + For each language of a project, one of these two attributes need to be + specified, either in the project itself or in the configuration project file. + + If the value of the attribute is the empty string, it indicates to the + Project Manager that the only source files for the language + are those specified with attributes @code{Body} or + @code{Implementation_Exceptions}. + These attributes must satisfy the same requirements as @code{Spec_Suffix}. In addition, they must be different from any of the values in @code{Spec_Suffix}. @@ -956,10 +969,10 @@ The following attributes can be defined in package @code{Naming}: suffixes will be a body if the longest suffix is @code{Body_Suffix ("Ada")} or a spec if the longest suffix is @code{Spec_Suffix ("Ada")}. - If the suffix does not start with a '.', a file with a name exactly equal - to the suffix will also be part of the project (for instance if you define - the suffix as @code{Makefile}, a file called @file{Makefile} will be part - of the project. This capability is usually not interesting when building. + If the suffix does not start with a '.', a file with a name exactly equal to + the suffix will also be part of the project (for instance if you define the + suffix as @code{Makefile.in}, a file called @file{Makefile.in} will be part + of the project. This capability is usually not interesting when building. However, it might become useful when a project is also used to find the list of source files in an editor, like the GNAT Programming System (GPS). @@ -968,7 +981,11 @@ The following attributes can be defined in package @code{Naming}: @cindex @code{Separate_Suffix} This attribute is specific to Ada. It denotes the suffix used in file names that contain separate bodies. If it is not specified, then it defaults to - same value as @code{Body_Suffix ("Ada")}. The same rules apply as for the + same value as @code{Body_Suffix ("Ada")}. + + The value of this attribute cannot be the empty string. + + Otherwise, the same rules apply as for the @code{Body_Suffix} attribute. The only accepted index is "Ada". @item @b{Spec} or @b{Specification}: diff --git a/gcc/ada/restrict.adb b/gcc/ada/restrict.adb index 2e5d2beb753..ea0f89c43bc 100644 --- a/gcc/ada/restrict.adb +++ b/gcc/ada/restrict.adb @@ -41,6 +41,38 @@ with Uname; use Uname; package body Restrict is + ------------------------------- + -- SPARK Restriction Control -- + ------------------------------- + + -- SPARK HIDE directives allow the effect of the SPARK_05 restriction to be + -- turned off for a specified region of code, and the following tables are + -- the data structures used to keep track of these regions. + + -- The table contains pairs of source locations, the first being the start + -- location for hidden region, and the second being the end location. + + -- Note that the start location is included in the hidden region, while + -- the end location is excluded from it. (It typically corresponds to the + -- next token during scanning.) + + type SPARK_Hide_Entry is record + Start : Source_Ptr; + Stop : Source_Ptr; + end record; + + package SPARK_Hides is new Table.Table ( + Table_Component_Type => SPARK_Hide_Entry, + Table_Index_Type => Natural, + Table_Low_Bound => 1, + Table_Initial => 100, + Table_Increment => 200, + Table_Name => "SPARK Hides"); + + -------------------------------- + -- Package Local Declarations -- + -------------------------------- + Config_Cunit_Boolean_Restrictions : Save_Cunit_Boolean_Restrictions; -- Save compilation unit restrictions set by config pragma files @@ -152,69 +184,6 @@ package body Restrict is Check_Restriction (No_Elaboration_Code, N); end Check_Elaboration_Code_Allowed; - ----------------------------- - -- Check_SPARK_Restriction -- - ----------------------------- - - procedure Check_SPARK_Restriction - (Msg : String; - N : Node_Id; - Force : Boolean := False) - is - Msg_Issued : Boolean; - Save_Error_Msg_Sloc : Source_Ptr; - begin - if Force or else Comes_From_Source (Original_Node (N)) then - - if Restriction_Check_Required (SPARK) - and then Is_In_Hidden_Part_In_SPARK (Sloc (N)) - then - return; - end if; - - -- Since the call to Restriction_Msg from Check_Restriction may set - -- Error_Msg_Sloc to the location of the pragma restriction, save and - -- restore the previous value of the global variable around the call. - - Save_Error_Msg_Sloc := Error_Msg_Sloc; - Check_Restriction (Msg_Issued, SPARK, First_Node (N)); - Error_Msg_Sloc := Save_Error_Msg_Sloc; - - if Msg_Issued then - Error_Msg_F ("\\| " & Msg, N); - end if; - end if; - end Check_SPARK_Restriction; - - procedure Check_SPARK_Restriction (Msg1, Msg2 : String; N : Node_Id) is - Msg_Issued : Boolean; - Save_Error_Msg_Sloc : Source_Ptr; - begin - pragma Assert (Msg2'Length /= 0 and then Msg2 (Msg2'First) = '\'); - - if Comes_From_Source (Original_Node (N)) then - - if Restriction_Check_Required (SPARK) - and then Is_In_Hidden_Part_In_SPARK (Sloc (N)) - then - return; - end if; - - -- Since the call to Restriction_Msg from Check_Restriction may set - -- Error_Msg_Sloc to the location of the pragma restriction, save and - -- restore the previous value of the global variable around the call. - - Save_Error_Msg_Sloc := Error_Msg_Sloc; - Check_Restriction (Msg_Issued, SPARK, First_Node (N)); - Error_Msg_Sloc := Save_Error_Msg_Sloc; - - if Msg_Issued then - Error_Msg_F ("\\| " & Msg1, N); - Error_Msg_F (Msg2, N); - end if; - end if; - end Check_SPARK_Restriction; - -------------------------------- -- Check_No_Implicit_Aliasing -- -------------------------------- @@ -851,6 +820,27 @@ package body Restrict is and then Restriction_Active (No_Exception_Propagation); end No_Exception_Propagation_Active; + -------------------------------- + -- OK_No_Dependence_Unit_Name -- + -------------------------------- + + function OK_No_Dependence_Unit_Name (N : Node_Id) return Boolean is + begin + if Nkind (N) = N_Selected_Component then + return + OK_No_Dependence_Unit_Name (Prefix (N)) + and then + OK_No_Dependence_Unit_Name (Selector_Name (N)); + + elsif Nkind (N) = N_Identifier then + return True; + + else + Error_Msg_N ("wrong form for unit name for No_Dependence", N); + return False; + end if; + end OK_No_Dependence_Unit_Name; + ---------------------------------- -- Process_Restriction_Synonyms -- ---------------------------------- @@ -880,10 +870,22 @@ package body Restrict is when Name_No_Task_Attributes => New_Name := Name_No_Task_Attributes_Package; + -- SPARK is special in that we unconditionally warn + + when Name_SPARK => + Error_Msg_Name_1 := Name_SPARK; + Error_Msg_N ("restriction identifier % is obsolescent??", N); + Error_Msg_Name_1 := Name_SPARK_05; + Error_Msg_N ("|use restriction identifier % instead??", N); + return Name_SPARK_05; + when others => return Old_Name; end case; + -- Output warning if we are warning on obsolescent features for all + -- cases other than SPARK. + if Warn_On_Obsolescent_Feature then Error_Msg_Name_1 := Old_Name; Error_Msg_N ("restriction identifier % is obsolescent?j?", N); @@ -983,10 +985,10 @@ package body Restrict is procedure Id_Case (S : String; Quotes : Boolean := True); -- Given a string S, case it according to current identifier casing, - -- except for SPARK (an acronym) which is set all upper case, and store - -- in Error_Msg_String. Then append `~` to the message buffer to output - -- the string unchanged surrounded in quotes. The quotes are suppressed - -- if Quotes = False. + -- except for SPARK_05 (an acronym) which is set all upper case, and + -- store in Error_Msg_String. Then append `~` to the message buffer + -- to output the string unchanged surrounded in quotes. The quotes + -- are suppressed if Quotes = False. -------------- -- Add_Char -- @@ -1017,7 +1019,7 @@ package body Restrict is Name_Buffer (1 .. S'Last) := S; Name_Len := S'Length; - if R = SPARK then + if R = SPARK_05 then Set_All_Upper_Case; else Set_Casing (Identifier_Casing (Get_Source_File_Index (Sloc (N)))); @@ -1127,20 +1129,16 @@ package body Restrict is function Same_Unit (U1, U2 : Node_Id) return Boolean is begin - if Nkind (U1) = N_Identifier then - return Nkind (U2) = N_Identifier and then Chars (U1) = Chars (U2); + if Nkind (U1) = N_Identifier and then Nkind (U2) = N_Identifier then + return Chars (U1) = Chars (U2); - elsif Nkind (U2) = N_Identifier then - return False; - - elsif (Nkind (U1) = N_Selected_Component - or else Nkind (U1) = N_Expanded_Name) - and then - (Nkind (U2) = N_Selected_Component - or else Nkind (U2) = N_Expanded_Name) + elsif Nkind_In (U1, N_Selected_Component, N_Expanded_Name) + and then + Nkind_In (U2, N_Selected_Component, N_Expanded_Name) then return Same_Unit (Prefix (U1), Prefix (U2)) - and then Same_Unit (Selector_Name (U1), Selector_Name (U2)); + and then + Same_Unit (Selector_Name (U1), Selector_Name (U2)); else return False; end if; @@ -1397,6 +1395,69 @@ package body Restrict is end if; end Set_Restriction_No_Use_Of_Pragma; + ----------------------------- + -- Check_SPARK_Restriction -- + ----------------------------- + + procedure Check_SPARK_Restriction + (Msg : String; + N : Node_Id; + Force : Boolean := False) + is + Msg_Issued : Boolean; + Save_Error_Msg_Sloc : Source_Ptr; + + begin + if Force or else Comes_From_Source (Original_Node (N)) then + if Restriction_Check_Required (SPARK_05) + and then Is_In_Hidden_Part_In_SPARK (Sloc (N)) + then + return; + end if; + + -- Since the call to Restriction_Msg from Check_Restriction may set + -- Error_Msg_Sloc to the location of the pragma restriction, save and + -- restore the previous value of the global variable around the call. + + Save_Error_Msg_Sloc := Error_Msg_Sloc; + Check_Restriction (Msg_Issued, SPARK_05, First_Node (N)); + Error_Msg_Sloc := Save_Error_Msg_Sloc; + + if Msg_Issued then + Error_Msg_F ("\\| " & Msg, N); + end if; + end if; + end Check_SPARK_Restriction; + + procedure Check_SPARK_Restriction (Msg1, Msg2 : String; N : Node_Id) is + Msg_Issued : Boolean; + Save_Error_Msg_Sloc : Source_Ptr; + + begin + pragma Assert (Msg2'Length /= 0 and then Msg2 (Msg2'First) = '\'); + + if Comes_From_Source (Original_Node (N)) then + if Restriction_Check_Required (SPARK_05) + and then Is_In_Hidden_Part_In_SPARK (Sloc (N)) + then + return; + end if; + + -- Since the call to Restriction_Msg from Check_Restriction may set + -- Error_Msg_Sloc to the location of the pragma restriction, save and + -- restore the previous value of the global variable around the call. + + Save_Error_Msg_Sloc := Error_Msg_Sloc; + Check_Restriction (Msg_Issued, SPARK_05, First_Node (N)); + Error_Msg_Sloc := Save_Error_Msg_Sloc; + + if Msg_Issued then + Error_Msg_F ("\\| " & Msg1, N); + Error_Msg_F (Msg2, N); + end if; + end if; + end Check_SPARK_Restriction; + ---------------------------------- -- Suppress_Restriction_Message -- ---------------------------------- diff --git a/gcc/ada/restrict.ads b/gcc/ada/restrict.ads index f54fb4b811a..19439731a37 100644 --- a/gcc/ada/restrict.ads +++ b/gcc/ada/restrict.ads @@ -101,9 +101,9 @@ package Restrict is (No_Unchecked_Deallocation, "a-uncdea"), (No_Unchecked_Deallocation, "unchdeal")); - -- The following map has True for all GNAT pragmas. It is used to - -- implement pragma Restrictions (No_Implementation_Restrictions) - -- (which is why this restriction itself is excluded from the list). + -- The following map has True for all GNAT-defined Restrictions. It is used + -- to implement pragma Restrictions (No_Implementation_Restrictions) (which + -- is why this restriction itself is excluded from the list). Implementation_Restriction : array (All_Restrictions) of Boolean := (Simple_Barriers => True, @@ -142,7 +142,7 @@ package Restrict is No_Wide_Characters => True, Static_Priorities => True, Static_Storage_Size => True, - SPARK => True, + SPARK_05 => True, others => False); -- The following table records entries made by Restrictions pragmas @@ -176,34 +176,6 @@ package Restrict is Table_Increment => 200, Table_Name => "Name_No_Dependences"); - ------------------------------- - -- SPARK Restriction Control -- - ------------------------------- - - -- SPARK HIDE directives allow the effect of the SPARK restriction to be - -- turned off for a specified region of code, and the following tables are - -- the data structures used to keep track of these regions. - - -- The table contains pairs of source locations, the first being the start - -- location for hidden region, and the second being the end location. - - -- Note that the start location is included in the hidden region, while - -- the end location is excluded from it. (It typically corresponds to the - -- next token during scanning.) - - type SPARK_Hide_Entry is record - Start : Source_Ptr; - Stop : Source_Ptr; - end record; - - package SPARK_Hides is new Table.Table ( - Table_Component_Type => SPARK_Hide_Entry, - Table_Index_Type => Natural, - Table_Low_Bound => 1, - Table_Initial => 100, - Table_Increment => 200, - Table_Name => "SPARK Hides"); - ----------------- -- Subprograms -- ----------------- @@ -282,10 +254,10 @@ package Restrict is (Msg : String; N : Node_Id; Force : Boolean := False); - -- Node N represents a construct not allowed in formal mode. If this is a - -- source node, or if the restriction is forced (Force = True), and the - -- SPARK restriction is set, then an error is issued on N. Msg is appended - -- to the restriction failure message. + -- Node N represents a construct not allowed in formal mode. If this is + -- a source node, or if the restriction is forced (Force = True), and + -- the SPARK_05 restriction is set, then an error is issued on N. Msg + -- is appended to the restriction failure message. procedure Check_SPARK_Restriction (Msg1, Msg2 : String; N : Node_Id); -- Same as Check_SPARK_Restriction except there is a continuation message @@ -330,6 +302,11 @@ package Restrict is -- identifier, and if so returns the corresponding Restriction_Id value, -- otherwise returns Not_A_Restriction_Id. + function OK_No_Dependence_Unit_Name (N : Node_Id) return Boolean; + -- Used in checking No_Dependence argument of pragma Restrictions or + -- pragma Restrictions_Warning, or attribute Restriction_Set. Returns + -- True if N has the proper form for a unit name, False otherwise. + function Is_In_Hidden_Part_In_SPARK (Loc : Source_Ptr) return Boolean; -- Determine if given location is covered by a hidden region range in the -- SPARK hides table. @@ -380,7 +357,9 @@ package Restrict is -- restrictions are set. procedure Set_Hidden_Part_In_SPARK (Loc1, Loc2 : Source_Ptr); - -- Insert a new hidden region range in the SPARK hides table + -- Insert a new hidden region range in the SPARK hides table. The effect + -- is to hide any SPARK violation messages which are in the range Loc1 to + -- Loc2-1 (i.e. Loc2 is the first location for reenabling checks). procedure Set_Profile_Restrictions (P : Profile_Name; diff --git a/gcc/ada/rtsfind.adb b/gcc/ada/rtsfind.adb index 382d2d1b015..22abb9a581f 100644 --- a/gcc/ada/rtsfind.adb +++ b/gcc/ada/rtsfind.adb @@ -82,7 +82,7 @@ package body Rtsfind is -- A unit retrieved through rtsfind may end up in the context of several -- other units, in addition to the main unit. These additional with_clauses - -- are needed to generate a proper traversal order for Inspector. To + -- are needed to generate a proper traversal order for CodePeer. To -- minimize somewhat the redundancy created by numerous calls to rtsfind -- from different units, we keep track of the list of implicit with_clauses -- already created for the current loaded unit. @@ -123,7 +123,7 @@ package body Rtsfind is -- with_clauses to the extended main unit if needed, and also to whatever -- unit needs them, which is not necessarily the main unit. The former -- ensures that the object is correctly loaded by the binder. The latter - -- is necessary for SofCheck Inspector. + -- is necessary for CodePeer. -- The field First_Implicit_With in the unit table record are used to -- avoid creating duplicate with_clauses. @@ -827,10 +827,9 @@ package body Rtsfind is -- We do not need to generate a with_clause for a call issued from -- RTE_Component_Available. However, for CodePeer, we need these -- additional with's, because for a sequence like "if RTE_Available (X) - -- then ... RTE (X)" the RTE call fails to create some necessary - -- with's. + -- then ... RTE (X)" the RTE call fails to create some necessary with's. - if RTE_Available_Call and then not Generate_SCIL then + if RTE_Available_Call and not Generate_SCIL then return; end if; @@ -840,8 +839,8 @@ package body Rtsfind is return; end if; - -- Add the with_clause, if not already in the context of the - -- current compilation unit. + -- Add the with_clause, if we have not already added an implicit with + -- for this unit to the current compilation unit. declare LibUnit : constant Node_Id := Unit (Cunit (U.Unum)); diff --git a/gcc/ada/s-bignum.adb b/gcc/ada/s-bignum.adb index 7cafbf3d5ae..cfcf7edf063 100644 --- a/gcc/ada/s-bignum.adb +++ b/gcc/ada/s-bignum.adb @@ -6,7 +6,7 @@ -- -- -- B o d y -- -- -- --- Copyright (C) 2012, Free Software Foundation, Inc. -- +-- Copyright (C) 2012-2013, 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- -- @@ -64,14 +64,18 @@ package body System.Bignums is -- Local Subprograms -- ----------------------- - function Add (X, Y : Digit_Vector; X_Neg, Y_Neg : Boolean) return Bignum - with Pre => X'First = 1 and then Y'First = 1; + function Add + (X, Y : Digit_Vector; + X_Neg : Boolean; + Y_Neg : Boolean) return Bignum + with + Pre => X'First = 1 and then Y'First = 1; -- This procedure adds two signed numbers returning the Sum, it is used -- for both addition and subtraction. The value computed is X + Y, with -- X_Neg and Y_Neg giving the signs of the operands. - function Allocate_Bignum (Len : Length) return Bignum - with Post => Allocate_Bignum'Result.Len = Len; + function Allocate_Bignum (Len : Length) return Bignum with + Post => Allocate_Bignum'Result.Len = Len; -- Allocate Bignum value of indicated length on secondary stack. On return -- the Neg and D fields are left uninitialized. @@ -81,7 +85,8 @@ package body System.Bignums is function Compare (X, Y : Digit_Vector; X_Neg, Y_Neg : Boolean) return Compare_Result - with Pre => X'First = 1 and then Y'First = 1; + with + Pre => X'First = 1 and then Y'First = 1; -- Compare (X with sign X_Neg) with (Y with sign Y_Neg), and return the -- result of the signed comparison. @@ -113,7 +118,11 @@ package body System.Bignums is -- Add -- --------- - function Add (X, Y : Digit_Vector; X_Neg, Y_Neg : Boolean) return Bignum is + function Add + (X, Y : Digit_Vector; + X_Neg : Boolean; + Y_Neg : Boolean) return Bignum + is begin -- If signs are the same, we are doing an addition, it is convenient to -- ensure that the first operand is the longer of the two. diff --git a/gcc/ada/s-interr.ads b/gcc/ada/s-interr.ads index 1d936f5a5f0..a771db6f8a3 100644 --- a/gcc/ada/s-interr.ads +++ b/gcc/ada/s-interr.ads @@ -6,7 +6,7 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 1992-2011, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- @@ -256,8 +256,7 @@ package System.Interrupts is (Object : access Static_Interrupt_Protection) return Boolean; -- Returns True - overriding - procedure Finalize (Object : in out Static_Interrupt_Protection); + overriding procedure Finalize (Object : in out Static_Interrupt_Protection); -- Restore previous handlers as required by C.3.1(12) then call -- Finalize (Protection). diff --git a/gcc/ada/s-restri.ads b/gcc/ada/s-restri.ads index 0085548f984..a0cb1e9d2cc 100644 --- a/gcc/ada/s-restri.ads +++ b/gcc/ada/s-restri.ads @@ -6,7 +6,7 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 2004-2011, Free Software Foundation, Inc. -- +-- Copyright (C) 2004-2013, 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- -- @@ -47,6 +47,7 @@ package System.Restrictions is pragma Discard_Names; package Rident is new System.Rident; + -- Instantiate a copy of System.Rident without enumeration image names Run_Time_Restrictions : Rident.Restrictions_Info; -- Restrictions as set by the user, or detected by the binder. See details @@ -54,8 +55,8 @@ package System.Restrictions is -- and the format of the information. -- -- Note that a restriction which is both Set and Violated at run-time means - -- that the violation was detected as part of the Ada run-time and not - -- as part of user code. + -- that the violation was detected as part of the Ada run-time and not as + -- part of user code. ------------------ -- Subprograms -- @@ -64,13 +65,13 @@ package System.Restrictions is function Abort_Allowed return Boolean; pragma Inline (Abort_Allowed); -- Tests to see if abort is allowed by the current restrictions settings. - -- For abort to be allowed, either No_Abort_Statements must be False, - -- or Max_Asynchronous_Select_Nesting must be non-zero. + -- For abort to be allowed, either No_Abort_Statements must be False, or + -- Max_Asynchronous_Select_Nesting must be non-zero. function Tasking_Allowed return Boolean; pragma Inline (Tasking_Allowed); -- Tests to see if tasking operations are allowed by the current - -- restrictions settings. For tasking to be allowed, No_Tasking - -- must be False, and Max_Tasks must not be set to zero. + -- restrictions settings. For tasking to be allowed, No_Tasking must + -- be False, and Max_Tasks must not be set to zero. end System.Restrictions; diff --git a/gcc/ada/s-rident.ads b/gcc/ada/s-rident.ads index 480c5a573a4..2fb2941811f 100644 --- a/gcc/ada/s-rident.ads +++ b/gcc/ada/s-rident.ads @@ -175,7 +175,7 @@ package System.Rident is No_Elaboration_Code, -- GNAT No_Obsolescent_Features, -- Ada 2005 AI-368 No_Wide_Characters, -- GNAT - SPARK, -- GNAT + SPARK_05, -- GNAT -- The following cases require a parameter value @@ -223,13 +223,14 @@ package System.Rident is No_Dynamic_Interrupts : Restriction_Id renames No_Dynamic_Attachment; No_Requeue : Restriction_Id renames No_Requeue_Statements; No_Task_Attributes : Restriction_Id renames No_Task_Attributes_Package; + SPARK : Restriction_Id renames SPARK_05; subtype All_Restrictions is Restriction_Id range Simple_Barriers .. Max_Storage_At_Blocking; -- All restrictions (excluding only Not_A_Restriction_Id) subtype All_Boolean_Restrictions is Restriction_Id range - Simple_Barriers .. SPARK; + Simple_Barriers .. SPARK_05; -- All restrictions which do not take a parameter subtype Partition_Boolean_Restrictions is All_Boolean_Restrictions range @@ -240,7 +241,7 @@ package System.Rident is -- case of Boolean restrictions. subtype Cunit_Boolean_Restrictions is All_Boolean_Restrictions range - Immediate_Reclamation .. SPARK; + Immediate_Reclamation .. SPARK_05; -- Boolean restrictions that are not checked for partition consistency -- and that thus apply only to the current unit. Note that for these -- restrictions, the compiler does not apply restrictions found in diff --git a/gcc/ada/scng.adb b/gcc/ada/scng.adb index e27c91d14f2..e05d1d692ad 100644 --- a/gcc/ada/scng.adb +++ b/gcc/ada/scng.adb @@ -6,7 +6,7 @@ -- -- -- B o d y -- -- -- --- Copyright (C) 1992-2012, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- @@ -1796,7 +1796,7 @@ package body Scng is -- If the SPARK restriction is set for this unit, then generate -- a token Tok_SPARK_Hide for a SPARK HIDE directive. - if Restriction_Check_Required (SPARK) + if Restriction_Check_Required (SPARK_05) and then Source (Start_Of_Comment) = '#' then declare diff --git a/gcc/ada/sem.adb b/gcc/ada/sem.adb index d3ec497188d..4249ad95595 100644 --- a/gcc/ada/sem.adb +++ b/gcc/ada/sem.adb @@ -1340,8 +1340,10 @@ package body Sem is ---------------- procedure Do_Analyze is + List : Elist_Id; + begin - Save_Scope_Stack; + List := Save_Scope_Stack; Push_Scope (Standard_Standard); Scope_Suppress := Suppress_Options; Scope_Stack.Table @@ -1362,7 +1364,7 @@ package body Sem is -- Then pop entry for Standard, and pop implicit types Pop_Scope; - Restore_Scope_Stack; + Restore_Scope_Stack (List); end Do_Analyze; Already_Analyzed : constant Boolean := Analyzed (Comp_Unit); diff --git a/gcc/ada/sem.ads b/gcc/ada/sem.ads index 545aadc6a53..9bc7ff757bc 100644 --- a/gcc/ada/sem.ads +++ b/gcc/ada/sem.ads @@ -562,7 +562,7 @@ package Sem is -- Note: for integer and real literals, the analyzer sets the flag to -- indicate that the result is a static expression. If the expander -- generates a literal that does NOT correspond to a static expression, - -- e.g. by folding an expression whose value is known at compile-time, + -- e.g. by folding an expression whose value is known at compile time, -- but is not technically static, then the caller should reset the -- Is_Static_Expression flag after analyzing but before resolving. -- @@ -654,12 +654,12 @@ package Sem is generic with procedure Action (Item : Node_Id); procedure Walk_Library_Items; - -- Primarily for use by SofCheck Inspector. Must be called after semantic - -- analysis (and expansion) are complete. Walks each relevant library item, - -- calling Action for each, in an order such that one will not run across - -- forward references. Each Item passed to Action is the declaration or - -- body of a library unit, including generics and renamings. The first item - -- is the N_Package_Declaration node for package Standard. Bodies are not + -- Primarily for use by CodePeer. Must be called after semantic analysis + -- (and expansion) are complete. Walks each relevant library item, calling + -- Action for each, in an order such that one will not run across forward + -- references. Each Item passed to Action is the declaration or body of + -- a library unit, including generics and renamings. The first item is + -- the N_Package_Declaration node for package Standard. Bodies are not -- included, except for the main unit itself, which always comes last. -- -- Item is never a subunit @@ -667,7 +667,9 @@ package Sem is -- Item is never an instantiation. Instead, the instance declaration is -- passed, and (if the instantiation is the main unit), the instance body. - -- Debugging: + ------------------------ + -- Debugging Routines -- + ------------------------ function ss (Index : Int) return Scope_Stack_Entry; pragma Export (Ada, ss); diff --git a/gcc/ada/sem_attr.adb b/gcc/ada/sem_attr.adb index f52abe98702..f5d12ed1c7b 100644 --- a/gcc/ada/sem_attr.adb +++ b/gcc/ada/sem_attr.adb @@ -72,6 +72,7 @@ with Targparm; use Targparm; with Ttypes; use Ttypes; with Tbuild; use Tbuild; with Uintp; use Uintp; +with Uname; use Uname; with Urealp; use Urealp; package body Sem_Attr is @@ -1642,9 +1643,7 @@ package body Sem_Attr is begin Check_E0; - if Nkind (P) /= N_Identifier - or else Chars (P) /= Name_Standard - then + if Nkind (P) /= N_Identifier or else Chars (P) /= Name_Standard then Error_Attr ("only allowed prefix for % attribute is Standard", P); end if; end Check_Standard_Prefix; @@ -1658,12 +1657,11 @@ package body Sem_Attr is Btyp : Entity_Id; In_Shared_Var_Procs : Boolean; - -- True when compiling the body of System.Shared_Storage. - -- Shared_Var_Procs. For this runtime package (always compiled in - -- GNAT mode), we allow stream attributes references for limited - -- types for the case where shared passive objects are implemented - -- using stream attributes, which is the default in GNAT's persistent - -- storage implementation. + -- True when compiling System.Shared_Storage.Shared_Var_Procs body. + -- For this runtime package (always compiled in GNAT mode), we allow + -- stream attributes references for limited types for the case where + -- shared passive objects are implemented using stream attributes, + -- which is the default in GNAT's persistent storage implementation. begin Validate_Non_Static_Attribute_Function_Call; @@ -2049,16 +2047,11 @@ package body Sem_Attr is -- some attributes for which we do not analyze the prefix, since the -- prefix is not a normal name, or else needs special handling. - if Aname /= Name_Elab_Body - and then - Aname /= Name_Elab_Spec - and then - Aname /= Name_Elab_Subp_Body - and then - Aname /= Name_UET_Address - and then - Aname /= Name_Enabled - and then + if Aname /= Name_Elab_Body and then + Aname /= Name_Elab_Spec and then + Aname /= Name_Elab_Subp_Body and then + Aname /= Name_UET_Address and then + Aname /= Name_Enabled and then Aname /= Name_Old then Analyze (P); @@ -2122,12 +2115,18 @@ package body Sem_Attr is else E1 := First (Exprs); - Analyze (E1); - -- Check for missing/bad expression (result of previous error) + -- Skip analysis for case of Restriction_Set, we do not expect + -- the argument to be analyzed in this case. - if No (E1) or else Etype (E1) = Any_Type then - raise Bad_Attribute; + if Aname /= Name_Restriction_Set then + Analyze (E1); + + -- Check for missing/bad expression (result of previous error) + + if No (E1) or else Etype (E1) = Any_Type then + raise Bad_Attribute; + end if; end if; E2 := Next (E1); @@ -4832,6 +4831,121 @@ package body Sem_Attr is Resolve (E1, P_Base_Type); Resolve (E2, P_Base_Type); + --------------------- + -- Restriction_Set -- + --------------------- + + when Attribute_Restriction_Set => Restriction_Set : declare + R : Restriction_Id; + U : Node_Id; + Unam : Unit_Name_Type; + + procedure Set_Result (B : Boolean); + -- Replace restriction node by static constant False or True, + -- depending on the value of B. + + ---------------- + -- Set_Result -- + ---------------- + + procedure Set_Result (B : Boolean) is + begin + if B then + Rewrite (N, New_Occurrence_Of (Standard_True, Loc)); + else + Rewrite (N, New_Occurrence_Of (Standard_False, Loc)); + end if; + + Set_Is_Static_Expression (N); + end Set_Result; + + -- Start of processing for Restriction_Set + + begin + Check_E1; + Analyze (P); + + if Nkind (P) /= N_Identifier or else Chars (P) /= Name_System then + Set_Result (False); + Error_Attr_P ("prefix of % attribute must be System"); + end if; + + -- No_Dependence case + + if Nkind (E1) = N_Parameter_Association then + pragma Assert (Chars (Selector_Name (E1)) = Name_No_Dependence); + U := Explicit_Actual_Parameter (E1); + + if not OK_No_Dependence_Unit_Name (U) then + Set_Result (False); + Error_Attr; + end if; + + -- See if there is an entry already in the table. That's the + -- case in which we can return True. + + for J in No_Dependences.First .. No_Dependences.Last loop + if Designate_Same_Unit (U, No_Dependences.Table (J).Unit) + and then No_Dependences.Table (J).Warn = False + then + Set_Result (True); + return; + end if; + end loop; + + -- If not in the No_Dependence table, result is False + + Set_Result (False); + + -- In this case, we must ensure that the binder will reject any + -- other unit in the partition that sets No_Dependence for this + -- unit. We do that by making an entry in the special table kept + -- for this purpose (if the entry is not there already). + + Unam := Get_Spec_Name (Get_Unit_Name (U)); + + for J in Restriction_Set_Dependences.First .. + Restriction_Set_Dependences.Last + loop + if Restriction_Set_Dependences.Table (J) = Unam then + return; + end if; + end loop; + + Restriction_Set_Dependences.Append (Unam); + + -- Normal restriction case + + else + if Nkind (E1) /= N_Identifier then + Set_Result (False); + Error_Attr ("attribute % requires restriction identifier", E1); + + else + R := Get_Restriction_Id (Process_Restriction_Synonyms (E1)); + + if R = Not_A_Restriction_Id then + Set_Result (False); + Error_Msg_Node_1 := E1; + Error_Attr ("invalid restriction identifier &", E1); + + elsif R not in Partition_Boolean_Restrictions then + Set_Result (False); + Error_Msg_Node_1 := E1; + Error_Attr + ("& is not a boolean partition-wide restriction", E1); + end if; + + if Restriction_Active (R) then + Set_Result (True); + else + Check_Restriction (R, N); + Set_Result (False); + end if; + end if; + end if; + end Restriction_Set; + ----------- -- Round -- ----------- @@ -5334,9 +5448,7 @@ package body Sem_Attr is Check_E1; Analyze (P); - if Nkind (P) /= N_Identifier - or else Chars (P) /= Name_System - then + if Nkind (P) /= N_Identifier or else Chars (P) /= Name_System then Error_Attr_P ("prefix of % attribute must be System"); end if; @@ -8072,6 +8184,16 @@ package body Sem_Attr is Fold_Ureal (N, Eval_Fat.Remainder (P_Base_Type, X, Y), Static); end Remainder; + ----------------- + -- Restriction -- + ----------------- + + when Attribute_Restriction_Set => Restriction_Set : declare + begin + Rewrite (N, New_Occurrence_Of (Standard_False, Loc)); + Set_Is_Static_Expression (N); + end Restriction_Set; + ----------- -- Round -- ----------- diff --git a/gcc/ada/sem_ch10.adb b/gcc/ada/sem_ch10.adb index 98b0d5795ae..87d2ab3c259 100644 --- a/gcc/ada/sem_ch10.adb +++ b/gcc/ada/sem_ch10.adb @@ -3000,7 +3000,7 @@ package body Sem_Ch10 is Set_First_Name (Withn, True); Set_Implicit_With (Withn, True); - -- If the unit is a package or generic package declaration, a private_ + -- If the unit is a package or generic package declaration, a private_ -- with_clause on a child unit implies that the implicit with on the -- parent is also private. diff --git a/gcc/ada/sem_ch12.adb b/gcc/ada/sem_ch12.adb index 98d45f83378..b93d3858335 100644 --- a/gcc/ada/sem_ch12.adb +++ b/gcc/ada/sem_ch12.adb @@ -4084,6 +4084,7 @@ package body Sem_Ch12 is Use_Clauses : array (1 .. Scope_Stack_Depth) of Node_Id; Instances : array (1 .. Scope_Stack_Depth) of Entity_Id; Inner_Scopes : array (1 .. Scope_Stack_Depth) of Entity_Id; + List : Elist_Id; Num_Inner : Int := 0; N_Instances : Int := 0; S : Entity_Id; @@ -4187,7 +4188,7 @@ package body Sem_Ch12 is -- Remove entities in current scopes from visibility, so that -- instance body is compiled in a clean environment. - Save_Scope_Stack (Handle_Use => False); + List := Save_Scope_Stack (Handle_Use => False); if Is_Child_Unit (S) then @@ -4261,7 +4262,7 @@ package body Sem_Ch12 is end loop; end if; - Restore_Scope_Stack (Handle_Use => False); + Restore_Scope_Stack (List, Handle_Use => False); if Present (Curr_Scope) and then @@ -4367,14 +4368,30 @@ package body Sem_Ch12 is Subp : Entity_Id) return Boolean is begin + -- Must be inlined (or inlined renaming) + if (Is_In_Main_Unit (N) or else Is_Inlined (Subp) or else Is_Inlined (Alias (Subp))) + + -- Must be generating code or analyzing code in ASIS mode + and then (Operating_Mode = Generate_Code or else (Operating_Mode = Check_Semantics and then ASIS_Mode)) - and then (Full_Expander_Active or else ASIS_Mode) + + -- The body is needed when generating code (full expansion), in ASIS + -- mode for other tools, and in SPARK mode (special expansion) for + -- formal verification of the body itself. + + and then (Expander_Active or ASIS_Mode) + + -- No point in inlining if ABE is inevitable + and then not ABE_Is_Certain (N) + + -- Or if subprogram is eliminated + and then not Is_Eliminated (Subp) then Pending_Instantiations.Append @@ -4387,6 +4404,8 @@ package body Sem_Ch12 is Version => Ada_Version)); return True; + -- Here if not inlined, or we ignore the inlining + else return False; end if; @@ -5220,7 +5239,15 @@ package body Sem_Ch12 is -- If the formal entity comes from a formal declaration, it was -- defaulted in the formal package, and no check is needed on it. - elsif Nkind (Parent (E2)) = N_Formal_Object_Declaration then + elsif Nkind (Parent (E2)) = N_Formal_Object_Declaration then + goto Next_E; + + -- Ditto for defaulted formal subprograms. + + elsif Is_Overloadable (E1) + and then Nkind (Unit_Declaration_Node (E2)) in + N_Formal_Subprogram_Declaration + then goto Next_E; elsif Is_Type (E1) then @@ -6577,7 +6604,13 @@ package body Sem_Ch12 is Set_Entity (New_N, Entity (Assoc)); Check_Private_View (N); - elsif Nkind (Assoc) = N_Function_Call then + -- The name in the call may be a selected component if the + -- call has not been analyzed yet, as may be the case for + -- pre/post conditions in a generic unit. + + elsif Nkind (Assoc) = N_Function_Call + and then Is_Entity_Name (Name (Assoc)) + then Set_Entity (New_N, Entity (Name (Assoc))); elsif Nkind_In (Assoc, N_Defining_Identifier, diff --git a/gcc/ada/sem_ch12.ads b/gcc/ada/sem_ch12.ads index 3fe88c96ae7..450237be243 100644 --- a/gcc/ada/sem_ch12.ads +++ b/gcc/ada/sem_ch12.ads @@ -6,7 +6,7 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 1992-2011, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- @@ -113,7 +113,6 @@ package Sem_Ch12 is function Need_Subprogram_Instance_Body (N : Node_Id; Subp : Entity_Id) return Boolean; - -- If a subprogram instance is inlined, indicate that the body of it -- must be created, to be used in inlined calls by the back-end. The -- subprogram may be inlined because the generic itself carries the diff --git a/gcc/ada/sem_ch13.adb b/gcc/ada/sem_ch13.adb index 1496912cdb4..37fd72253d6 100644 --- a/gcc/ada/sem_ch13.adb +++ b/gcc/ada/sem_ch13.adb @@ -1310,7 +1310,6 @@ package body Sem_Ch13 is Aspect_Small | Aspect_Simple_Storage_Pool | Aspect_Storage_Pool | - Aspect_Storage_Size | Aspect_Stream_Size | Aspect_Value_Size | Aspect_Variable_Indexing | @@ -1659,6 +1658,16 @@ package body Sem_Ch13 is Insert_Delayed_Pragma (Aitem); goto Continue; + -- SPARK_Mode + + when Aspect_SPARK_Mode => + Make_Aitem_Pragma + (Pragma_Argument_Associations => New_List ( + Make_Pragma_Argument_Association (Loc, + Expression => Relocate_Node (Expr))), + Pragma_Name => Name_SPARK_Mode); + Delay_Required := False; + -- Relative_Deadline when Aspect_Relative_Deadline => @@ -1741,7 +1750,7 @@ package body Sem_Ch13 is Analyze_Aspect_Dimension_System (N, Id, Expr); goto Continue; - -- Case 4: Special handling for aspects + -- Case 4: Aspects requiring special handling -- Pre/Post/Test_Case/Contract_Cases whose corresponding -- pragmas take care of the delay. @@ -1801,6 +1810,8 @@ package body Sem_Ch13 is -- Build the precondition/postcondition pragma + -- Add note about why we do NOT need Copy_Tree here ??? + Make_Aitem_Pragma (Pragma_Argument_Associations => New_List ( Make_Pragma_Argument_Association (Eloc, @@ -2016,6 +2027,62 @@ package body Sem_Ch13 is else Aitem := Empty; end if; + + -- Storage_Size + + -- This is special because for access types we need to generate + -- an attribute definition clause. This also works for single + -- task declarations, but it does not work for task type + -- declarations, because we have the case where the expression + -- references a discriminant of the task type. That can't use + -- an attribute definition clause because we would not have + -- visibility on the discriminant. For that case we must + -- generate a pragma in the task definition. + + when Aspect_Storage_Size => + + -- Task type case + + if Ekind (E) = E_Task_Type then + declare + Decl : constant Node_Id := Declaration_Node (E); + + begin + pragma Assert (Nkind (Decl) = N_Task_Type_Declaration); + + -- If no task definition, create one + + if No (Task_Definition (Decl)) then + Set_Task_Definition (Decl, + Make_Task_Definition (Loc, + Visible_Declarations => Empty_List, + End_Label => Empty)); + end if; + + -- Create a pragma and put it at the start of the + -- task definition for the task type declaration. + + Make_Aitem_Pragma + (Pragma_Argument_Associations => New_List ( + Make_Pragma_Argument_Association (Loc, + Expression => Relocate_Node (Expr))), + Pragma_Name => Name_Storage_Size); + + Prepend + (Aitem, + Visible_Declarations (Task_Definition (Decl))); + goto Continue; + end; + + -- All other cases, generate attribute definition + + else + Aitem := + Make_Attribute_Definition_Clause (Loc, + Name => Ent, + Chars => Chars (Id), + Expression => Relocate_Node (Expr)); + end if; end case; -- Attach the corresponding pragma/attribute definition clause to @@ -4055,13 +4122,18 @@ package body Sem_Ch13 is begin if Is_Task_Type (U_Ent) then - Check_Restriction (No_Obsolescent_Features, N); - if Warn_On_Obsolescent_Feature then - Error_Msg_N - ("?j?storage size clause for task is an " & - "obsolescent feature (RM J.9)", N); - Error_Msg_N ("\?j?use Storage_Size pragma instead", N); + -- Check obsolescent (but never obsolescent if from aspect!) + + if not From_Aspect_Specification (N) then + Check_Restriction (No_Obsolescent_Features, N); + + if Warn_On_Obsolescent_Feature then + Error_Msg_N + ("?j?storage size clause for task is an " & + "obsolescent feature (RM J.9)", N); + Error_Msg_N ("\?j?use Storage_Size pragma instead", N); + end if; end if; FOnly := True; @@ -7387,6 +7459,7 @@ package body Sem_Ch13 is Aspect_Postcondition | Aspect_Pre | Aspect_Precondition | + Aspect_SPARK_Mode | Aspect_Test_Case => raise Program_Error; diff --git a/gcc/ada/sem_ch3.adb b/gcc/ada/sem_ch3.adb index a3b2c4e3a3e..f07f083463a 100644 --- a/gcc/ada/sem_ch3.adb +++ b/gcc/ada/sem_ch3.adb @@ -1283,6 +1283,8 @@ package body Sem_Ch3 is Init_Size_Align (T_Name); Set_Directly_Designated_Type (T_Name, Desig_Type); + Generate_Reference_To_Formals (T_Name); + -- Ada 2005 (AI-231): Propagate the null-excluding attribute Set_Can_Never_Be_Null (T_Name, Null_Exclusion_Present (T_Def)); @@ -2075,7 +2077,7 @@ package body Sem_Ch3 is -- Start of processing for Analyze_Declarations begin - if Restriction_Check_Required (SPARK) then + if Restriction_Check_Required (SPARK_05) then Check_Later_Vs_Basic_Declarations (L, During_Parsing => False); end if; @@ -3240,7 +3242,7 @@ package body Sem_Ch3 is -- Only call test if needed - and then Restriction_Check_Required (SPARK) + and then Restriction_Check_Required (SPARK_05) and then not Is_SPARK_Initialization_Expr (E) then Check_SPARK_Restriction diff --git a/gcc/ada/sem_ch4.adb b/gcc/ada/sem_ch4.adb index 04db9b0d391..a03c46552be 100644 --- a/gcc/ada/sem_ch4.adb +++ b/gcc/ada/sem_ch4.adb @@ -881,12 +881,24 @@ package body Sem_Ch4 is S : Entity_Id; begin + -- Do not perform the check while preanalyzing the enclosing context + -- because the call is not in its final place. Premature attempts to + -- verify the placement lead to bogus errors. + + if In_Spec_Expression then + return; + -- The ghost subprogram appears inside an assertion expression + -- which is one of the allowed cases. - if In_Assertion_Expression (N) then + elsif In_Assertion_Expression (N) then return; + -- Otherwise see if it inside another ghost subprogram + else + -- Loop to climb scopes + S := Current_Scope; while Present (S) and then S /= Standard_Standard loop @@ -898,11 +910,14 @@ package body Sem_Ch4 is S := Scope (S); end loop; - end if; - Error_Msg_N - ("call to ghost subprogram must appear in assertion expression or " - & "another ghost subprogram", N); + -- If we fall through the loop it was not within another + -- ghost subprogram, so we have bad placement. + + Error_Msg_N + ("call to ghost subprogram must appear in assertion expression " + & "or another ghost subprogram", N); + end if; end Check_Ghost_Subprogram_Call; -------------------------------------------------- @@ -991,7 +1006,7 @@ package body Sem_Ch4 is -- Start of processing for Analyze_Call begin - if Restriction_Check_Required (SPARK) then + if Restriction_Check_Required (SPARK_05) then Check_Mixed_Parameter_And_Named_Associations; end if; @@ -2472,10 +2487,22 @@ package body Sem_Ch4 is Process_Function_Call; elsif Nkind (P) = N_Selected_Component + and then Present (Entity (Selector_Name (P))) and then Is_Overloadable (Entity (Selector_Name (P))) then Process_Function_Call; + -- In ASIS mode within a generic, a prefixed call is analyzed and + -- partially rewritten but the original indexed component has not + -- yet been rewritten as a call. Perform the replacement now. + + elsif Nkind (P) = N_Selected_Component + and then Nkind (Parent (P)) = N_Function_Call + and then ASIS_Mode + then + Rewrite (N, Parent (P)); + Analyze (N); + else -- Indexed component, slice, or a call to a member of a family -- entry, which will be converted to an entry call later. diff --git a/gcc/ada/sem_ch5.adb b/gcc/ada/sem_ch5.adb index 5b34ecc347b..2f8eced6fc9 100644 --- a/gcc/ada/sem_ch5.adb +++ b/gcc/ada/sem_ch5.adb @@ -2867,7 +2867,7 @@ package body Sem_Ch5 is -- we are in formal mode where goto statements are not allowed. if Nkind (Nxt) = N_Label - and then not Restriction_Check_Required (SPARK) + and then not Restriction_Check_Required (SPARK_05) then return; @@ -2924,7 +2924,7 @@ package body Sem_Ch5 is -- Now issue the warning (or error in formal mode) - if Restriction_Check_Required (SPARK) then + if Restriction_Check_Required (SPARK_05) then Check_SPARK_Restriction ("unreachable code is not allowed", Error_Node); else diff --git a/gcc/ada/sem_ch6.adb b/gcc/ada/sem_ch6.adb index 68edadfafd7..57712d83d9c 100644 --- a/gcc/ada/sem_ch6.adb +++ b/gcc/ada/sem_ch6.adb @@ -2789,11 +2789,11 @@ package body Sem_Ch6 is and then (Nkind (Original_Node (Spec_Decl)) = N_Subprogram_Renaming_Declaration - or else (Present (Corresponding_Body (Spec_Decl)) - and then - Nkind (Unit_Declaration_Node - (Corresponding_Body (Spec_Decl))) = - N_Subprogram_Renaming_Declaration)) + or else (Present (Corresponding_Body (Spec_Decl)) + and then + Nkind (Unit_Declaration_Node + (Corresponding_Body (Spec_Decl))) = + N_Subprogram_Renaming_Declaration)) then Conformant := True; @@ -7663,13 +7663,16 @@ package body Sem_Ch6 is end if; -- Ada 2005 (AI-254): Anonymous access-to-subprogram types must be - -- treated recursively because they carry a signature. + -- treated recursively because they carry a signature. As far as + -- conformance is concerned, convention plays no role, and either + -- or both could be access to protected subprograms. Are_Anonymous_Access_To_Subprogram_Types := - Ekind (Type_1) = Ekind (Type_2) + Ekind_In (Type_1, E_Anonymous_Access_Subprogram_Type, + E_Anonymous_Access_Protected_Subprogram_Type) and then - Ekind_In (Type_1, E_Anonymous_Access_Subprogram_Type, - E_Anonymous_Access_Protected_Subprogram_Type); + Ekind_In (Type_2, E_Anonymous_Access_Subprogram_Type, + E_Anonymous_Access_Protected_Subprogram_Type); -- Test anonymous access type case. For this case, static subtype -- matching is required for mode conformance (RM 6.3.1(15)). We check diff --git a/gcc/ada/sem_ch8.adb b/gcc/ada/sem_ch8.adb index 4fdef1cdac2..27ccc2d3d1e 100644 --- a/gcc/ada/sem_ch8.adb +++ b/gcc/ada/sem_ch8.adb @@ -2069,11 +2069,20 @@ package body Sem_Ch8 is if Is_Incomplete_Or_Private_Type (Etype (F)) and then No (Underlying_Type (Etype (F))) - and then not Is_Generic_Type (Etype (F)) then - Error_Msg_NE - ("type& must be frozen before this point", - Instantiation_Node, Etype (F)); + + -- Exclude generic types, or types derived from them. + -- They will be frozen in the enclosing instance. + + if Is_Generic_Type (Etype (F)) + or else Is_Generic_Type (Root_Type (Etype (F))) + then + null; + else + Error_Msg_NE + ("type& must be frozen before this point", + Instantiation_Node, Etype (F)); + end if; end if; F := Next_Formal (F); @@ -2816,7 +2825,7 @@ package body Sem_Ch8 is -- The following is illegal, because F hides whatever other F may -- be around: - -- function F (..) renames F; + -- function F (...) renames F; elsif Old_S = New_S or else (Nkind (Nam) /= N_Expanded_Name @@ -2824,6 +2833,10 @@ package body Sem_Ch8 is then Error_Msg_N ("subprogram cannot rename itself", N); + -- This is illegal even if we use a selector: + -- function F (...) renames Pkg.F; + -- because F is still hidden. + elsif Nkind (Nam) = N_Expanded_Name and then Entity (Prefix (Nam)) = Current_Scope and then Chars (Selector_Name (Nam)) = Chars (New_S) @@ -3287,14 +3300,14 @@ package body Sem_Ch8 is ------------------------ procedure Attribute_Renaming (N : Node_Id) is - Loc : constant Source_Ptr := Sloc (N); - Nam : constant Node_Id := Name (N); - Spec : constant Node_Id := Specification (N); - New_S : constant Entity_Id := Defining_Unit_Name (Spec); - Aname : constant Name_Id := Attribute_Name (Nam); + Loc : constant Source_Ptr := Sloc (N); + Nam : constant Node_Id := Name (N); + Spec : constant Node_Id := Specification (N); + New_S : constant Entity_Id := Defining_Unit_Name (Spec); + Aname : constant Name_Id := Attribute_Name (Nam); - Form_Num : Nat := 0; - Expr_List : List_Id := No_List; + Form_Num : Nat := 0; + Expr_List : List_Id := No_List; Attr_Node : Node_Id; Body_Node : Node_Id; @@ -3305,12 +3318,12 @@ package body Sem_Ch8 is -- This procedure is called in the context of subprogram renaming, and -- thus the attribute must be one that is a subprogram. All of those - -- have at least one formal parameter, with the singular exception of - -- AST_Entry (which is a real oddity, it is odd that this can be renamed - -- at all!) + -- have at least one formal parameter, with the exceptions of AST_Entry + -- (which is a real oddity, it is odd that this can be renamed at all!) + -- and the GNAT attribute 'Img, which GNAT treats as renameable. if not Is_Non_Empty_List (Parameter_Specifications (Spec)) then - if Aname /= Name_AST_Entry then + if Aname /= Name_AST_Entry and then Aname /= Name_Img then Error_Msg_N ("subprogram renaming an attribute must have formals", N); return; @@ -3329,8 +3342,8 @@ package body Sem_Ch8 is -- there are no subtypes involved. Rewrite (Parameter_Type (Param_Spec), - New_Reference_To - (Base_Type (Entity (Parameter_Type (Param_Spec))), Loc)); + New_Reference_To + (Base_Type (Entity (Parameter_Type (Param_Spec))), Loc)); end if; if No (Expr_List) then @@ -3480,10 +3493,20 @@ package body Sem_Ch8 is and then Etype (Nam) /= RTE (RE_AST_Handler) then declare - P : constant Entity_Id := Prefix (Nam); + P : constant Node_Id := Prefix (Nam); begin - Find_Type (P); + -- The prefix of 'Img is an object that is evaluated for each call + -- of the function that renames it. + + if Aname = Name_Img then + Preanalyze_And_Resolve (P); + + -- For all other attribute renamings, the prefix is a subtype + + else + Find_Type (P); + end if; if Is_Tagged_Type (Etype (P)) then Ensure_Freeze_Node (Etype (P)); @@ -5859,7 +5882,7 @@ package body Sem_Ch8 is -- Selector name cannot be a character literal or an operator symbol in -- SPARK, except for the operator symbol in a renaming. - if Restriction_Check_Required (SPARK) then + if Restriction_Check_Required (SPARK_05) then if Nkind (Selector_Name (N)) = N_Character_Literal then Check_SPARK_Restriction ("character literal cannot be prefixed", N); @@ -6199,7 +6222,7 @@ package body Sem_Ch8 is -- Selector name is restricted in SPARK if Nkind (N) = N_Expanded_Name - and then Restriction_Check_Required (SPARK) + and then Restriction_Check_Required (SPARK_05) then if Is_Subprogram (P_Name) then Check_SPARK_Restriction @@ -7641,121 +7664,26 @@ package body Sem_Ch8 is -- Restore_Scope_Stack -- ------------------------- - procedure Restore_Scope_Stack (Handle_Use : Boolean := True) is - E : Entity_Id; - S : Entity_Id; - Comp_Unit : Node_Id; - In_Child : Boolean := False; - Full_Vis : Boolean := True; - SS_Last : constant Int := Scope_Stack.Last; + procedure Restore_Scope_Stack + (List : Elist_Id; + Handle_Use : Boolean := True) + is + SS_Last : constant Int := Scope_Stack.Last; + Elmt : Elmt_Id; begin - -- Restore visibility of previous scope stack, if any - - for J in reverse 0 .. Scope_Stack.Last loop - exit when Scope_Stack.Table (J).Entity = Standard_Standard - or else No (Scope_Stack.Table (J).Entity); - - S := Scope_Stack.Table (J).Entity; - - if not Is_Hidden_Open_Scope (S) then - - -- If the parent scope is hidden, its entities are hidden as - -- well, unless the entity is the instantiation currently - -- being analyzed. - - if not Is_Hidden_Open_Scope (Scope (S)) - or else not Analyzed (Parent (S)) - or else Scope (S) = Standard_Standard - then - Set_Is_Immediately_Visible (S, True); - end if; - - E := First_Entity (S); - while Present (E) loop - if Is_Child_Unit (E) then - if not From_With_Type (E) then - Set_Is_Immediately_Visible (E, - Is_Visible_Lib_Unit (E) or else In_Open_Scopes (E)); - - else - pragma Assert - (Nkind (Parent (E)) = N_Defining_Program_Unit_Name - and then - Nkind (Parent (Parent (E))) = - N_Package_Specification); - Set_Is_Immediately_Visible (E, - Limited_View_Installed (Parent (Parent (E)))); - end if; - else - Set_Is_Immediately_Visible (E, True); - end if; - - Next_Entity (E); - - if not Full_Vis and then Is_Package_Or_Generic_Package (S) then - - -- We are in the visible part of the package scope - - exit when E = First_Private_Entity (S); - end if; - end loop; - - -- The visibility of child units (siblings of current compilation) - -- must be restored in any case. Their declarations may appear - -- after the private part of the parent. - - if not Full_Vis then - while Present (E) loop - if Is_Child_Unit (E) then - Set_Is_Immediately_Visible (E, - Is_Visible_Lib_Unit (E) or else In_Open_Scopes (E)); - end if; - - Next_Entity (E); - end loop; - end if; - end if; + -- Restore visibility of previous scope stack, if any, using the list + -- we saved (we use Remove, since this list will not be used again). - if Is_Child_Unit (S) - and not In_Child -- check only for current unit - then - In_Child := True; - - -- Restore visibility of parents according to whether the child - -- is private and whether we are in its visible part. - - Comp_Unit := Parent (Unit_Declaration_Node (S)); - - if Nkind (Comp_Unit) = N_Compilation_Unit - and then Private_Present (Comp_Unit) - then - Full_Vis := True; - - elsif Is_Package_Or_Generic_Package (S) - and then (In_Private_Part (S) or else In_Package_Body (S)) - then - Full_Vis := True; - - -- if S is the scope of some instance (which has already been - -- seen on the stack) it does not affect the visibility of - -- other scopes. - - elsif Is_Hidden_Open_Scope (S) then - null; - - elsif Ekind_In (S, E_Procedure, E_Function) - and then Has_Completion (S) - then - Full_Vis := True; - else - Full_Vis := False; - end if; - else - Full_Vis := True; - end if; + loop + Elmt := Last_Elmt (List); + exit when Elmt = No_Elmt; + Set_Is_Immediately_Visible (Node (Elmt)); + Remove_Last_Elmt (List); end loop; + -- Restore use clauses + if SS_Last >= Scope_Stack.First and then Scope_Stack.Table (SS_Last).Entity /= Standard_Standard and then Handle_Use @@ -7768,11 +7696,58 @@ package body Sem_Ch8 is -- Save_Scope_Stack -- ---------------------- - procedure Save_Scope_Stack (Handle_Use : Boolean := True) is + -- Save_Scope_Stack/Restore_Scope_Stack were originally designed to avoid + -- consuming any memory. That is, Save_Scope_Stack took care of removing + -- from immediate visibility entities and Restore_Scope_Stack took care + -- of restoring their visibility analyzing the context of each entity. The + -- problem of such approach is that it was fragile and caused unexpected + -- visibility problems, and indeed one test was found where there was a + -- real problem. + + -- Furthermore, the following experiment was carried out: + + -- - Save_Scope_Stack was modified to store in an Elist1 all those + -- entities whose attribute Is_Immediately_Visible is modified + -- from True to False. + + -- - Restore_Scope_Stack was modified to store in another Elist2 + -- all the entities whose attribute Is_Immediately_Visible is + -- modified from False to True. + + -- - Extra code was added to verify that all the elements of Elist1 + -- are found in Elist2 + + -- This test shows that there may be more occurrences of this problem which + -- have not yet been detected. As a result, we replaced that approach by + -- the current one in which Save_Scope_Stack returns the list of entities + -- whose visibility is changed, and that list is passed to Restore_Scope_ + -- Stack to undo that change. This approach is simpler and safer, although + -- it consumes more memory. + + function Save_Scope_Stack (Handle_Use : Boolean := True) return Elist_Id is + Result : constant Elist_Id := New_Elmt_List; E : Entity_Id; S : Entity_Id; SS_Last : constant Int := Scope_Stack.Last; + procedure Remove_From_Visibility (E : Entity_Id); + -- If E is immediately visible then append it to the result and remove + -- it temporarily from visibility. + + ---------------------------- + -- Remove_From_Visibility -- + ---------------------------- + + procedure Remove_From_Visibility (E : Entity_Id) is + begin + if Is_Immediately_Visible (E) then + Append_Elmt (E, Result); + Set_Is_Immediately_Visible (E, False); + end if; + end Remove_From_Visibility; + + -- Start of processing for Save_Scope_Stack + begin if SS_Last >= Scope_Stack.First and then Scope_Stack.Table (SS_Last).Entity /= Standard_Standard @@ -7790,16 +7765,19 @@ package body Sem_Ch8 is or else No (Scope_Stack.Table (J).Entity); S := Scope_Stack.Table (J).Entity; - Set_Is_Immediately_Visible (S, False); + + Remove_From_Visibility (S); E := First_Entity (S); while Present (E) loop - Set_Is_Immediately_Visible (E, False); + Remove_From_Visibility (E); Next_Entity (E); end loop; end loop; end if; + + return Result; end Save_Scope_Stack; ------------- diff --git a/gcc/ada/sem_ch8.ads b/gcc/ada/sem_ch8.ads index 195c03bd3a9..99d2b1485d4 100644 --- a/gcc/ada/sem_ch8.ads +++ b/gcc/ada/sem_ch8.ads @@ -6,7 +6,7 @@ -- -- -- S p e c -- -- -- --- Copyright (C) 1992-2012, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- @@ -148,18 +148,26 @@ package Sem_Ch8 is -- with-clause on system. N is absent when the function is called to find -- the visibility of implicit operators. - procedure Restore_Scope_Stack (Handle_Use : Boolean := True); - procedure Save_Scope_Stack (Handle_Use : Boolean := True); - -- These two procedures are called from Semantics, when a unit U1 is to + function Save_Scope_Stack + (Handle_Use : Boolean := True) return Elist_Id; + procedure Restore_Scope_Stack + (List : Elist_Id; + Handle_Use : Boolean := True); + -- These two subprograms are called from Semantics, when a unit U1 is to -- be compiled in the course of the compilation of another unit U2. This -- happens whenever Rtsfind is called. U1, the unit retrieved by Rtsfind, -- must be compiled in its own context, and the current scope stack - -- containing U2 and local scopes must be made unreachable. On return, the - -- contents of the scope stack must be made accessible again. The flag - -- Handle_Use indicates whether local use clauses must be removed or - -- installed. In the case of inlining of instance bodies, the visibility + -- containing U2 and local scopes must be made unreachable. This is + -- achieved using a call to Save_Scope_Stack. On return, the contents + -- of the scope stack must be made accessible again with a call to + -- Restore_Scope_Stack. + -- + -- The flag Handle_Use indicates whether local use clauses must be removed + -- or installed. In the case of inlining of instance bodies, the visibility -- handling is done fully in Inline_Instance_Body, and use clauses are - -- handled there. + -- handled there. Save_Scope_Stack returns the list of entities which have + -- been temporarily removed from visibility; that list must be passed to + -- Restore_Scope_Stack to restore their visibility. procedure Set_Use (L : List_Id); -- Find use clauses that are declarative items in a package declaration diff --git a/gcc/ada/sem_ch9.adb b/gcc/ada/sem_ch9.adb index 16c011c5ad8..41b4d9ccb2a 100644 --- a/gcc/ada/sem_ch9.adb +++ b/gcc/ada/sem_ch9.adb @@ -6,7 +6,7 @@ -- -- -- B o d y -- -- -- --- Copyright (C) 1992-2012, Free Software Foundation, Inc. -- +-- Copyright (C) 1992-2013, 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- -- @@ -3053,8 +3053,9 @@ package body Sem_Ch9 is and then not Is_Controlling_Limited_Procedure (Entity (Name (Trigger))) then - Error_Msg_N ("triggering statement must be delay, procedure " & - "or entry call", Trigger); + Error_Msg_N + ("triggering statement must be procedure_or_entry_call " & + "('R'M 9.7.2) or delay statement", Trigger); end if; end if; diff --git a/gcc/ada/sem_dim.adb b/gcc/ada/sem_dim.adb index 1f91d9612e0..79c1e15037a 100644 --- a/gcc/ada/sem_dim.adb +++ b/gcc/ada/sem_dim.adb @@ -1409,7 +1409,7 @@ package body Sem_Dim is if L_Has_Dimensions then if not Compile_Time_Known_Value (R) then Error_Msg_N ("exponent of dimensioned operand must be " & - "known at compile-time", N); + "known at compile time", N); end if; declare diff --git a/gcc/ada/sem_prag.adb b/gcc/ada/sem_prag.adb index e148d05bbf2..4fe6c57a5bd 100644 --- a/gcc/ada/sem_prag.adb +++ b/gcc/ada/sem_prag.adb @@ -213,6 +213,11 @@ package body Sem_Prag is -- original one, following the renaming chain) is returned. Otherwise the -- entity is returned unchanged. Should be in Einfo??? + function Get_SPARK_Mode_Id (N : Name_Id) return SPARK_Mode_Id; + -- Subsidiary to the analysis of pragma SPARK_Mode as well as subprogram + -- Get_SPARK_Mode_Id. Convert a name into a corresponding value of type + -- SPARK_Mode_Id. + function Original_Name (N : Node_Id) return Name_Id; -- N is a pragma node or aspect specification node. This function returns -- the name of the pragma or aspect in original source form, taking into @@ -1713,14 +1718,16 @@ package body Sem_Prag is -- Preanalyze the boolean expression, we treat this as a spec expression -- (i.e. similar to a default expression). - Preanalyze_Assert_Expression (Get_Pragma_Arg (Arg1), Standard_Boolean); - - -- In ASIS mode, for a pragma generated from a source aspect, also - -- analyze the original aspect expression. + -- In ASIS mode, for a pragma generated from a source aspect, analyze + -- directly the the original aspect expression, which is shared with + -- the generated pragma. if ASIS_Mode and then Present (Corresponding_Aspect (N)) then Preanalyze_Assert_Expression (Expression (Corresponding_Aspect (N)), Standard_Boolean); + else + Preanalyze_Assert_Expression + (Get_Pragma_Arg (Arg1), Standard_Boolean); end if; -- For a class-wide condition, a reference to a controlling formal must @@ -1749,6 +1756,9 @@ package body Sem_Prag is -- accessparameter of type access-to-T is interpreted as having -- type access-to-T'Class. This ensures the expression is well- -- defined for a primitive subprogram of a type descended from T. + -- Note that this replacement is not done for selector names in + -- parameter associations. These carry an entity for reference + -- purposes, but semantically they are just identifiers. ------------- -- Get_ACW -- @@ -1790,6 +1800,9 @@ package body Sem_Prag is and then Present (Entity (N)) and then Is_Formal (Entity (N)) and then Nkind (Parent (N)) /= N_Type_Conversion + and then + (Nkind (Parent (N)) /= N_Parameter_Association + or else N /= Selector_Name (Parent (N))) then if Etype (Entity (N)) = T then Typ := Class_Wide_Type (T); @@ -3552,12 +3565,13 @@ package body Sem_Prag is -- If we fall through loop, pragma is at start of list, so see if it -- is at the start of declarations of a subprogram body. - if Nkind (Parent (N)) = N_Subprogram_Body - and then List_Containing (N) = Declarations (Parent (N)) + PO := Parent (N); + + if Nkind (PO) = N_Subprogram_Body + and then List_Containing (N) = Declarations (PO) then - if Operating_Mode /= Generate_Code - or else Inside_A_Generic - then + if Operating_Mode /= Generate_Code or else Inside_A_Generic then + -- Analyze pragma expression for correctness and for ASIS use Preanalyze_Assert_Expression @@ -3572,22 +3586,56 @@ package body Sem_Prag is end if; end if; + -- Retain a copy of the pre- or postcondition pragma for formal + -- verification purposes. The copy is needed because the pragma is + -- expanded into other constructs which are not acceptable in the + -- N_Contract node. + + if Acts_As_Spec (PO) + and then (SPARK_Mode or else Formal_Extensions) + then + declare + Prag : constant Node_Id := New_Copy_Tree (N); + + begin + -- Preanalyze the pragma + + Preanalyze_Assert_Expression + (Get_Pragma_Arg + (First (Pragma_Argument_Associations (Prag))), + Standard_Boolean); + + -- Preanalyze the corresponding aspect (if any) + + if Present (Corresponding_Aspect (Prag)) then + Preanalyze_Assert_Expression + (Expression (Corresponding_Aspect (Prag)), + Standard_Boolean); + end if; + + -- Chain the copy on the contract of the body + + Add_Contract_Item + (Prag, Defining_Unit_Name (Specification (PO))); + end; + end if; + In_Body := True; return; -- See if it is in the pragmas after a library level subprogram - elsif Nkind (Parent (N)) = N_Compilation_Unit_Aux then + elsif Nkind (PO) = N_Compilation_Unit_Aux then -- In formal verification mode, analyze pragma expression for -- correctness, as it is not expanded later. if SPARK_Mode then Analyze_PPC_In_Decl_Part - (N, Defining_Entity (Unit (Parent (Parent (N))))); + (N, Defining_Entity (Unit (Parent (PO)))); end if; - Chain_PPC (Unit (Parent (Parent (N)))); + Chain_PPC (Unit (Parent (PO))); return; end if; @@ -3740,7 +3788,6 @@ package body Sem_Prag is begin -- First check pragma arguments - GNAT_Pragma; Check_At_Least_N_Arguments (2); Check_At_Most_N_Arguments (4); Check_Arg_Order @@ -4617,7 +4664,7 @@ package body Sem_Prag is and then Is_Spec_Name (Unit_Name (Current_Sem_Unit)) and then (Ekind (Cent) /= E_Package - or else not In_Private_Part (Cent)); + or else not In_Private_Part (Cent)); -- Set True if this is the warning case, and we are in the -- visible part of a package spec, or in a subprogram spec, -- in which case we want to force the client to see the @@ -5289,7 +5336,6 @@ package body Sem_Prag is procedure Process_Disable_Enable_Atomic_Sync (Nam : Name_Id) is begin - GNAT_Pragma; Check_No_Identifiers; Check_At_Most_N_Arguments (1); @@ -5993,6 +6039,8 @@ package body Sem_Prag is Check_No_Identifiers; Check_At_Least_N_Arguments (1); + -- Check all arguments are names of generic units or instances + Arg := Arg1; while Present (Arg) loop Exp := Get_Pragma_Arg (Arg); @@ -6977,33 +7025,8 @@ package body Sem_Prag is Expr : Node_Id; Val : Uint; - procedure Check_Unit_Name (N : Node_Id); - -- Checks unit name parameter for No_Dependence. Returns if it has - -- an appropriate form, otherwise raises pragma argument error. - - --------------------- - -- Check_Unit_Name -- - --------------------- - - procedure Check_Unit_Name (N : Node_Id) is - begin - if Nkind (N) = N_Selected_Component then - Check_Unit_Name (Prefix (N)); - Check_Unit_Name (Selector_Name (N)); - - elsif Nkind (N) = N_Identifier then - return; - - else - Error_Pragma_Arg - ("wrong form for unit name for No_Dependence", N); - end if; - end Check_Unit_Name; - - -- Start of processing for Process_Restrictions_Or_Restriction_Warnings - begin - -- Ignore all Restrictions pragma in CodePeer mode + -- Ignore all Restrictions pragmas in CodePeer mode if CodePeer_Mode then return; @@ -7161,7 +7184,9 @@ package body Sem_Prag is -- already made the necessary entry in the No_Dependence table. elsif Id = Name_No_Dependence then - Check_Unit_Name (Expr); + if not OK_No_Dependence_Unit_Name (Expr) then + raise Pragma_Exit; + end if; -- Case of No_Specification_Of_Aspect => Identifier. @@ -9650,8 +9675,8 @@ package body Sem_Prag is -- pragma Check_Name (check_IDENTIFIER); when Pragma_Check_Name => - Check_No_Identifiers; GNAT_Pragma; + Check_No_Identifiers; Check_Valid_Configuration_Pragma; Check_Arg_Count (1); Check_Arg_Is_Identifier (Arg1); @@ -10076,11 +10101,19 @@ package body Sem_Prag is if Nkind (Subp_Decl) = N_Subprogram_Body then Analyze_Contract_Cases_In_Decl_Part (N); - -- Chain the pragma on the contract for further processing + -- When Contract_Cases applies to a subprogram compilation unit, + -- the corresponding pragma is placed after the unit's declaration + -- node and needs to be analyzed immediately. - else - Add_Contract_Item (N, Subp_Id); + elsif Nkind (Subp_Decl) = N_Subprogram_Declaration + and then Nkind (Parent (Subp_Decl)) = N_Compilation_Unit + then + Analyze_Contract_Cases_In_Decl_Part (N); end if; + + -- Chain the pragma on the contract for further processing + + Add_Contract_Item (N, Subp_Id); end Contract_Cases; ---------------- @@ -10294,7 +10327,7 @@ package body Sem_Prag is if Warn_On_Obsolescent_Feature then Error_Msg_N - ("'G'N'A'T pragma cpp'_virtual is now obsolete and has no " + ("'G'N'A'T pragma Cpp'_Virtual is now obsolete and has no " & "effect?j?", N); end if; end CPP_Virtual; @@ -10309,7 +10342,7 @@ package body Sem_Prag is if Warn_On_Obsolescent_Feature then Error_Msg_N - ("'G'N'A'T pragma cpp'_vtable is now obsolete and has no " + ("'G'N'A'T pragma Cpp'_Vtable is now obsolete and has no " & "effect?j?", N); end if; end CPP_Vtable; @@ -10584,11 +10617,19 @@ package body Sem_Prag is if Nkind (Subp_Decl) = N_Subprogram_Body then Analyze_Depends_In_Decl_Part (N); - -- Chain the pragma on the contract for further processing + -- When Depends applies to a subprogram compilation unit, the + -- corresponding pragma is placed after the unit's declaration + -- node and needs to be analyzed immediately. - else - Add_Contract_Item (N, Subp_Id); + elsif Nkind (Subp_Decl) = N_Subprogram_Declaration + and then Nkind (Parent (Subp_Decl)) = N_Compilation_Unit + then + Analyze_Depends_In_Decl_Part (N); end if; + + -- Chain the pragma on the contract for further processing + + Add_Contract_Item (N, Subp_Id); end Depends; --------------------- @@ -10661,6 +10702,7 @@ package body Sem_Prag is -- pragma Disable_Atomic_Synchronization [(Entity)]; when Pragma_Disable_Atomic_Synchronization => + GNAT_Pragma; Process_Disable_Enable_Atomic_Sync (Name_Suppress); ------------------- @@ -11092,6 +11134,7 @@ package body Sem_Prag is -- pragma Enable_Atomic_Synchronization [(Entity)]; when Pragma_Enable_Atomic_Synchronization => + GNAT_Pragma; Process_Disable_Enable_Atomic_Sync (Name_Unsuppress); ------------ @@ -11592,6 +11635,18 @@ package body Sem_Prag is end case; end External_Name_Casing; + --------------- + -- Fast_Math -- + --------------- + + -- pragma Fast_Math; + + when Pragma_Fast_Math => + GNAT_Pragma; + Check_No_Identifiers; + Check_Valid_Configuration_Pragma; + Fast_Math := True; + -------------------------- -- Favor_Top_Level -- -------------------------- @@ -11623,18 +11678,6 @@ package body Sem_Prag is end if; end Favor_Top_Level; - --------------- - -- Fast_Math -- - --------------- - - -- pragma Fast_Math; - - when Pragma_Fast_Math => - GNAT_Pragma; - Check_No_Identifiers; - Check_Valid_Configuration_Pragma; - Fast_Math := True; - --------------------------- -- Finalize_Storage_Only -- --------------------------- @@ -11825,11 +11868,19 @@ package body Sem_Prag is if Nkind (Subp_Decl) = N_Subprogram_Body then Analyze_Global_In_Decl_Part (N); - -- Chain the pragma on the contract for further processing + -- When Global applies to a subprogram compilation unit, the + -- corresponding pragma is placed after the unit's declaration + -- node and needs to be analyzed immediately. - else - Add_Contract_Item (N, Subp_Id); + elsif Nkind (Subp_Decl) = N_Subprogram_Declaration + and then Nkind (Parent (Subp_Decl)) = N_Compilation_Unit + then + Analyze_Global_In_Decl_Part (N); end if; + + -- Chain the pragma on the contract for further processing + + Add_Contract_Item (N, Subp_Id); end Global; ----------- @@ -11959,6 +12010,7 @@ package body Sem_Prag is Ent : Entity_Id; begin + GNAT_Pragma; Check_No_Identifiers; -- Form with no arguments @@ -13339,8 +13391,8 @@ package body Sem_Prag is -- abstract. ??? if not Is_Tagged_Type (Typ) or else not Is_Abstract_Type (Typ) then - Error_Pragma_Arg ("pragma% requires an abstract " - & "tagged type", Arg1); + Error_Pragma_Arg + ("pragma% requires an abstract tagged type", Arg1); elsif not Has_Discriminants (Typ) or else Ekind (Etype (First_Discriminant (Typ))) @@ -14471,6 +14523,41 @@ package body Sem_Prag is Optimize_Alignment_Local := True; end Optimize_Alignment; + ------------- + -- Ordered -- + ------------- + + -- pragma Ordered (first_enumeration_subtype_LOCAL_NAME); + + when Pragma_Ordered => Ordered : declare + Assoc : constant Node_Id := Arg1; + Type_Id : Node_Id; + Typ : Entity_Id; + + begin + GNAT_Pragma; + Check_No_Identifiers; + Check_Arg_Count (1); + Check_Arg_Is_Local_Name (Arg1); + + Type_Id := Get_Pragma_Arg (Assoc); + Find_Type (Type_Id); + Typ := Entity (Type_Id); + + if Typ = Any_Type then + return; + else + Typ := Underlying_Type (Typ); + end if; + + if not Is_Enumeration_Type (Typ) then + Error_Pragma ("pragma% must specify enumeration type"); + end if; + + Check_First_Subtype (Arg1); + Set_Has_Pragma_Ordered (Base_Type (Typ)); + end Ordered; + ------------------- -- Overflow_Mode -- ------------------- @@ -14551,43 +14638,17 @@ package body Sem_Prag is end if; end Overflow_Mode; - when Pragma_Overriding_Renamings => - Overriding_Renamings := True; - - ------------- - -- Ordered -- - ------------- - - -- pragma Ordered (first_enumeration_subtype_LOCAL_NAME); + -------------------------- + -- Overriding Renamings -- + -------------------------- - when Pragma_Ordered => Ordered : declare - Assoc : constant Node_Id := Arg1; - Type_Id : Node_Id; - Typ : Entity_Id; + -- pragma Overriding_Renamings; - begin + when Pragma_Overriding_Renamings => GNAT_Pragma; - Check_No_Identifiers; - Check_Arg_Count (1); - Check_Arg_Is_Local_Name (Arg1); - - Type_Id := Get_Pragma_Arg (Assoc); - Find_Type (Type_Id); - Typ := Entity (Type_Id); - - if Typ = Any_Type then - return; - else - Typ := Underlying_Type (Typ); - end if; - - if not Is_Enumeration_Type (Typ) then - Error_Pragma ("pragma% must specify enumeration type"); - end if; - - Check_First_Subtype (Arg1); - Set_Has_Pragma_Ordered (Base_Type (Typ)); - end Ordered; + Check_Arg_Count (0); + Check_Valid_Configuration_Pragma; + Overriding_Renamings := True; ---------- -- Pack -- @@ -15022,7 +15083,7 @@ package body Sem_Prag is -- pragma Predicate -- ([Entity =>] type_LOCAL_NAME, - -- [Check =>] EXPRESSION); + -- [Check =>] boolean_EXPRESSION); when Pragma_Predicate => Predicate : declare Type_Id : Node_Id; @@ -15452,8 +15513,10 @@ package body Sem_Prag is GNAT_Pragma; Check_Arg_Count (0); - if In_Extended_Main_Source_Unit (N) then - Propagate_Exceptions := True; + if Warn_On_Obsolescent_Feature then + Error_Msg_N + ("'G'N'A'T pragma Propagate'_Exceptions is now obsolete " & + "and has no effect?j?", N); end if; ------------------ @@ -16042,6 +16105,8 @@ package body Sem_Prag is -- Short_Circuit_And_Or -- -------------------------- + -- pragma Short_Circuit_And_Or; + when Pragma_Short_Circuit_And_Or => GNAT_Pragma; Check_Arg_Count (0); @@ -16052,7 +16117,9 @@ package body Sem_Prag is -- Share_Generic -- ------------------- - -- pragma Share_Generic (NAME {, NAME}); + -- pragma Share_Generic (GNAME {, GNAME}); + + -- GNAME ::= generic_unit_NAME | generic_instance_NAME when Pragma_Share_Generic => GNAT_Pragma; @@ -16267,6 +16334,290 @@ package body Sem_Prag is when Pragma_Source_Reference => GNAT_Pragma; + ---------------- + -- SPARK_Mode -- + ---------------- + + -- pragma SPARK_Mode (On | Off | Auto); + + when Pragma_SPARK_Mode => SPARK_Mod : declare + procedure Chain_Pragma (Context : Entity_Id; Prag : Node_Id); + -- Associate a SPARK_Mode pragma with the context where it lives. + -- If the context is a package spec or a body, the routine checks + -- the consistency between modes of visible/private declarations + -- and body declarations/statements. + + procedure Check_Conformance + (Governing_Id : Entity_Id; + New_Id : Entity_Id); + -- Verify the "monotonicity" of SPARK modes between two entities. + -- The order of modes is Off < Auto < On. Governing_Id establishes + -- the mode of the context. New_Id attempts to redefine the known + -- mode. + + procedure Check_Pragma_Conformance + (Governing_Mode : Node_Id; + New_Mode : Node_Id); + -- Verify the "monotonicity" of two SPARK_Mode pragmas. The order + -- of modes is Off < Auto < On. Governing_Mode is the established + -- mode dictated by the context. New_Mode attempts to redefine the + -- governing mode. + + function Get_SPARK_Mode_Name (Id : SPARK_Mode_Id) return Name_Id; + -- Convert a value of type SPARK_Mode_Id into a corresponding name + + ------------------ + -- Chain_Pragma -- + ------------------ + + procedure Chain_Pragma (Context : Entity_Id; Prag : Node_Id) is + Existing_Prag : constant Node_Id := + SPARK_Mode_Pragmas (Context); + begin + -- The context does not have a prior mode defined + + if No (Existing_Prag) then + Set_SPARK_Mode_Pragmas (Context, Prag); + + -- Chain the new mode on the list of SPARK_Mode pragmas. Verify + -- the consistency between the existing mode and the new one. + + else + Set_Next_Pragma (Existing_Prag, Prag); + + Check_Pragma_Conformance + (Governing_Mode => Existing_Prag, + New_Mode => Prag); + end if; + end Chain_Pragma; + + ----------------------- + -- Check_Conformance -- + ----------------------- + + procedure Check_Conformance + (Governing_Id : Entity_Id; + New_Id : Entity_Id) + is + Gov_Prag : constant Node_Id := + SPARK_Mode_Pragmas (Governing_Id); + New_Prag : constant Node_Id := SPARK_Mode_Pragmas (New_Id); + + begin + -- Nothing to do when one or both entities lack a mode + + if No (Gov_Prag) or else No (New_Prag) then + return; + end if; + + -- Do not compare the modes of a package spec and body when the + -- spec mode appears in the private part. In this case the spec + -- mode does not affect the body. + + if Ekind_In (Governing_Id, E_Generic_Package, E_Package) + and then Ekind (New_Id) = E_Package_Body + and then Is_Private_SPARK_Mode (Gov_Prag) + then + null; + + -- Test the pragmas + + else + Check_Pragma_Conformance + (Governing_Mode => Gov_Prag, + New_Mode => New_Prag); + end if; + end Check_Conformance; + + ------------------------------ + -- Check_Pragma_Conformance -- + ------------------------------ + + procedure Check_Pragma_Conformance + (Governing_Mode : Node_Id; + New_Mode : Node_Id) + is + Gov_M : constant SPARK_Mode_Id := + Get_SPARK_Mode_Id (Governing_Mode); + New_M : constant SPARK_Mode_Id := Get_SPARK_Mode_Id (New_Mode); + + begin + -- The new mode is less restrictive than the established mode + + if Gov_M < New_M then + Error_Msg_Name_1 := Get_SPARK_Mode_Name (New_M); + Error_Msg_N ("cannot define 'S'P'A'R'K mode %", New_Mode); + + Error_Msg_Name_1 := Get_SPARK_Mode_Name (Gov_M); + Error_Msg_Sloc := Sloc (Governing_Mode); + Error_Msg_N + ("\mode is less restrictive than mode % defined #", + New_Mode); + end if; + end Check_Pragma_Conformance; + + ------------------------- + -- Get_SPARK_Mode_Name -- + ------------------------- + + function Get_SPARK_Mode_Name (Id : SPARK_Mode_Id) return Name_Id is + begin + if Id = SPARK_On then + return Name_On; + elsif Id = SPARK_Off then + return Name_Off; + elsif Id = SPARK_Auto then + return Name_Auto; + + -- Mode "None" should never be used in error message generation + + else + raise Program_Error; + end if; + end Get_SPARK_Mode_Name; + + -- Local variables + + Body_Id : Entity_Id; + Context : Node_Id; + Mode : Name_Id; + Mode_Id : SPARK_Mode_Id; + Spec_Id : Entity_Id; + Stmt : Node_Id; + + -- Start of processing for SPARK_Mode + + begin + GNAT_Pragma; + Check_No_Identifiers; + Check_At_Most_N_Arguments (1); + + -- Check the legality of the mode + + if Arg_Count = 1 then + Check_Arg_Is_One_Of (Arg1, Name_On, Name_Off, Name_Auto); + Mode := Chars (Get_Pragma_Arg (Arg1)); + + -- A SPARK_Mode without an argument defaults to "On" + + else + Mode := Name_On; + end if; + + Mode_Id := Get_SPARK_Mode_Id (Mode); + Context := Parent (N); + + -- The pragma appears in a configuration file + + if No (Context) then + Check_Valid_Configuration_Pragma; + Global_SPARK_Mode := Mode_Id; + + -- When the pragma is placed before the declaration of a unit, it + -- configures the whole unit. + + elsif Nkind (Context) = N_Compilation_Unit then + Check_Valid_Configuration_Pragma; + Set_SPARK_Mode_Pragma (Current_Sem_Unit, N); + + -- The pragma applies to a [library unit] subprogram or package + + else + -- Mode "Auto" cannot be used in nested subprograms or packages + + if Mode_Id = SPARK_Auto then + Error_Pragma_Arg + ("mode `Auto` can only apply to the configuration variant " + & "of pragma %", Arg1); + end if; + + -- Verify the placement of the pragma with respect to package + -- or subprogram declarations and detect duplicates. + + Stmt := Prev (N); + while Present (Stmt) loop + + -- Skip prior pragmas, but check for duplicates + + if Nkind (Stmt) = N_Pragma then + if Pragma_Name (Stmt) = Pname then + Error_Msg_Name_1 := Pname; + Error_Msg_Sloc := Sloc (Stmt); + Error_Msg_N + ("pragma % duplicates pragma declared #", N); + end if; + + -- Skip internally generated code + + elsif not Comes_From_Source (Stmt) then + null; + + -- The pragma applies to a package or subprogram declaration + + elsif Nkind_In (Stmt, N_Generic_Package_Declaration, + N_Generic_Subprogram_Declaration, + N_Package_Declaration, + N_Subprogram_Declaration) + then + Spec_Id := Defining_Unit_Name (Specification (Stmt)); + Chain_Pragma (Spec_Id, N); + return; + + -- The pragma does not apply to a legal construct, issue an + -- error and stop the analysis. + + else + Pragma_Misplaced; + exit; + end if; + + Stmt := Prev (Stmt); + end loop; + + -- If we get here, then we ran out of preceding statements. The + -- pragma is immediately within a body. + + if Nkind_In (Context, N_Package_Body, + N_Subprogram_Body) + then + Spec_Id := Corresponding_Spec (Context); + + if Nkind (Context) = N_Subprogram_Body then + Context := Specification (Context); + end if; + + Body_Id := Defining_Unit_Name (Context); + + Chain_Pragma (Body_Id, N); + Check_Conformance (Spec_Id, Body_Id); + + -- The pragma is at the top level of a package spec + + elsif Nkind (Context) = N_Package_Specification then + Spec_Id := Defining_Unit_Name (Context); + Chain_Pragma (Spec_Id, N); + + -- The pragma applies to the statements of a package body + + elsif Nkind (Context) = N_Handled_Sequence_Of_Statements + and then Nkind (Parent (Context)) = N_Package_Body + then + Context := Parent (Context); + Spec_Id := Corresponding_Spec (Context); + Body_Id := Defining_Unit_Name (Context); + + Chain_Pragma (Body_Id, N); + Check_Conformance (Spec_Id, Body_Id); + + -- The pragma does not apply to a legal construct, issue an + -- error. + + else + Pragma_Misplaced; + end if; + end if; + end SPARK_Mod; + -------------------------------- -- Static_Elaboration_Desired -- -------------------------------- @@ -16890,6 +17241,7 @@ package body Sem_Prag is -- MODE_TYPE ::= Nominal | Robustness when Pragma_Test_Case => + GNAT_Pragma; Check_Test_Case; -------------------------- @@ -18219,6 +18571,43 @@ package body Sem_Prag is return Result; end Get_Base_Subprogram; + ----------------------- + -- Get_SPARK_Mode_Id -- + ----------------------- + + function Get_SPARK_Mode_Id (N : Name_Id) return SPARK_Mode_Id is + begin + if N = Name_On then + return SPARK_On; + elsif N = Name_Off then + return SPARK_Off; + elsif N = Name_Auto then + return SPARK_Auto; + + -- Any other argument is erroneous + + else + raise Program_Error; + end if; + end Get_SPARK_Mode_Id; + + ----------------------- + -- Get_SPARK_Mode_Id -- + ----------------------- + + function Get_SPARK_Mode_Id (N : Node_Id) return SPARK_Mode_Id is + Mode : Node_Id; + + begin + pragma Assert + (Nkind (N) = N_Pragma + and then Present (Pragma_Argument_Associations (N))); + + Mode := First (Pragma_Argument_Associations (N)); + + return Get_SPARK_Mode_Id (Chars (Get_Pragma_Arg (Mode))); + end Get_SPARK_Mode_Id; + ---------------- -- Initialize -- ---------------- @@ -18283,11 +18672,33 @@ package body Sem_Prag is -- Start of processing for Is_Config_Static_String begin - Name_Len := 0; + return Add_Config_Static_String (Arg); end Is_Config_Static_String; + ------------------------------- + -- Is_Elaboration_SPARK_Mode -- + ------------------------------- + + function Is_Elaboration_SPARK_Mode (N : Node_Id) return Boolean is + begin + pragma Assert + (Nkind (N) = N_Pragma + and then Pragma_Name (N) = Name_SPARK_Mode + and then Is_List_Member (N)); + + -- Pragma SPARK_Mode affects the elaboration of a package body when it + -- appears in the statement part of the body. + + return + Present (Parent (N)) + and then Nkind (Parent (N)) = N_Handled_Sequence_Of_Statements + and then List_Containing (N) = Statements (Parent (N)) + and then Present (Parent (Parent (N))) + and then Nkind (Parent (Parent (N))) = N_Package_Body; + end Is_Elaboration_SPARK_Mode; + ----------------------------------------- -- Is_Non_Significant_Pragma_Reference -- ----------------------------------------- @@ -18475,6 +18886,7 @@ package body Sem_Prag is Pragma_Source_File_Name => -1, Pragma_Source_File_Name_Project => -1, Pragma_Source_Reference => -1, + Pragma_SPARK_Mode => 0, Pragma_Storage_Size => -1, Pragma_Storage_Unit => -1, Pragma_Static_Elaboration_Desired => -1, @@ -18633,6 +19045,26 @@ package body Sem_Prag is end if; end Is_Pragma_String_Literal; + --------------------------- + -- Is_Private_SPARK_Mode -- + --------------------------- + + function Is_Private_SPARK_Mode (N : Node_Id) return Boolean is + begin + pragma Assert + (Nkind (N) = N_Pragma + and then Pragma_Name (N) = Name_SPARK_Mode + and then Is_List_Member (N)); + + -- For pragma SPARK_Mode to be private, it has to appear in the private + -- declarations of a package. + + return + Present (Parent (N)) + and then Nkind (Parent (N)) = N_Package_Specification + and then List_Containing (N) = Private_Declarations (Parent (N)); + end Is_Private_SPARK_Mode; + ----------------------------- -- Is_Valid_Assertion_Kind -- ----------------------------- diff --git a/gcc/ada/sem_prag.ads b/gcc/ada/sem_prag.ads index 3b8a3bcbc89..fcbe9889861 100644 --- a/gcc/ada/sem_prag.ads +++ b/gcc/ada/sem_prag.ads @@ -113,6 +113,9 @@ package Sem_Prag is -- True have their analysis delayed until after the main program is parsed -- and analyzed. + function Get_SPARK_Mode_Id (N : Node_Id) return SPARK_Mode_Id; + -- Given a pragma SPARK_Mode node, return the corresponding mode id + procedure Initialize; -- Initializes data structures used for pragma processing. Must be called -- before analyzing each new main source program. @@ -127,6 +130,10 @@ package Sem_Prag is -- length, and then returns True. If it is not of the correct form, then an -- appropriate error message is posted, and False is returned. + function Is_Elaboration_SPARK_Mode (N : Node_Id) return Boolean; + -- Determine whether pragma SPARK_Mode appears in the statement part of a + -- package body. + function Is_Non_Significant_Pragma_Reference (N : Node_Id) return Boolean; -- The node N is a node for an entity and the issue is whether the -- occurrence is a reference for the purposes of giving warnings about @@ -143,6 +150,10 @@ package Sem_Prag is -- False is returned, then the argument is treated as an entity reference -- to the operator. + function Is_Private_SPARK_Mode (N : Node_Id) return Boolean; + -- Determine whether pragma SPARK_Mode appears in the private part of a + -- package. + function Is_Valid_Assertion_Kind (Nam : Name_Id) return Boolean; -- Returns True if Nam is one of the names recognized as a valid assertion -- kind by the Assertion_Policy pragma. Note that the 'Class cases are diff --git a/gcc/ada/sem_res.adb b/gcc/ada/sem_res.adb index b4a654a24cc..61f7712a090 100644 --- a/gcc/ada/sem_res.adb +++ b/gcc/ada/sem_res.adb @@ -1576,6 +1576,23 @@ package body Sem_Res is else Resolve (N, Typ); end if; + + -- If in ASIS_Mode, propagate operand types to original actuals of + -- function call, which would otherwise not be fully resolved. If + -- the call has already been constant-folded, nothing to do. + + if ASIS_Mode and then Nkind (N) in N_Op then + if Is_Binary then + Set_Parameter_Associations + (Original_Node (N), + New_List (New_Copy_Tree (Left_Opnd (N)), + New_Copy_Tree (Right_Opnd (N)))); + else + Set_Parameter_Associations + (Original_Node (N), + New_List (New_Copy_Tree (Right_Opnd (N)))); + end if; + end if; end Make_Call_Into_Operator; ------------------- @@ -7028,7 +7045,7 @@ package body Sem_Res is -- Protect call to Matching_Static_Array_Bounds to avoid costly -- operation if not needed. - if Restriction_Check_Required (SPARK) + if Restriction_Check_Required (SPARK_05) and then Base_Type (T) /= Standard_String and then Base_Type (Etype (L)) = Base_Type (Etype (R)) and then Etype (L) /= Any_Composite -- or else L in error @@ -7738,7 +7755,7 @@ package body Sem_Res is -- Protect call to Matching_Static_Array_Bounds to avoid costly -- operation if not needed. - if Restriction_Check_Required (SPARK) + if Restriction_Check_Required (SPARK_05) and then Base_Type (Left_Typ) = Base_Type (Right_Typ) and then Left_Typ /= Any_Composite -- or Left_Opnd in error and then Right_Typ /= Any_Composite -- or Right_Opnd in error @@ -8483,7 +8500,7 @@ package body Sem_Res is -- Protect call to Matching_Static_Array_Bounds to avoid costly -- operation if not needed. - if Restriction_Check_Required (SPARK) + if Restriction_Check_Required (SPARK_05) and then Is_Array_Type (Target_Typ) and then Is_Array_Type (Etype (Expr)) and then Etype (Expr) /= Any_Composite -- or else Expr in error @@ -9625,7 +9642,7 @@ package body Sem_Res is -- Protect call to Matching_Static_Array_Bounds to avoid costly -- operation if not needed. - if Restriction_Check_Required (SPARK) + if Restriction_Check_Required (SPARK_05) and then Is_Array_Type (Target_Typ) and then Is_Array_Type (Operand_Typ) and then Operand_Typ /= Any_Composite -- or else Operand in error diff --git a/gcc/ada/sem_util.adb b/gcc/ada/sem_util.adb index c914703f894..dcad44f1bba 100644 --- a/gcc/ada/sem_util.adb +++ b/gcc/ada/sem_util.adb @@ -4582,7 +4582,7 @@ package body Sem_Util is -- Declaring a homonym is not allowed in SPARK ... if Present (C) - and then Restriction_Check_Required (SPARK) + and then Restriction_Check_Required (SPARK_05) then declare Enclosing_Subp : constant Node_Id := Enclosing_Subprogram (Def_Id); @@ -12982,7 +12982,7 @@ package body Sem_Util is -- subprogram bodies. Detect those cases by testing whether -- Process_End_Label was called for a body (Typ = 't') or a package. - if Restriction_Check_Required (SPARK) + if Restriction_Check_Required (SPARK_05) and then (Typ = 't' or else Ekind (Ent) = E_Package) then Error_Msg_Node_1 := Endl; @@ -14144,9 +14144,8 @@ package body Sem_Util is if Known_Static_Esize (Typ) then Size := UI_To_Int (Esize (Typ)); - -- If the Esize (Object_Size) is unknown at compile-time, look at the - -- RM_Size (Value_Size) since it may have been set by an explicit rep - -- item. + -- If the Esize (Object_Size) is unknown at compile time, look at the + -- RM_Size (Value_Size) which may have been set by an explicit rep item. elsif Known_Static_RM_Size (Typ) then Size := UI_To_Int (RM_Size (Typ)); diff --git a/gcc/ada/sinfo.ads b/gcc/ada/sinfo.ads index 10b6e81062a..e8c9805cc31 100644 --- a/gcc/ada/sinfo.ads +++ b/gcc/ada/sinfo.ads @@ -1516,14 +1516,14 @@ package Sinfo is -- in rtsfind to indicate implicit dependencies on predefined units. Used -- to prevent multiple with_clauses for the same unit in a given context. -- A postorder traversal of the tree whose nodes are units and whose - -- links are with_clauses defines the order in which Inspector must + -- links are with_clauses defines the order in which CodePeer must -- examine a compiled unit and its full context. This ordering ensures -- that any subprogram call is examined after the subprogram declaration -- has been seen. -- Next_Named_Actual (Node4-Sem) - -- Present in parameter association node. Set during semantic analysis to - -- point to the next named parameter, where parameters are ordered by + -- Present in parameter association nodes. Set during semantic analysis + -- to point to the next named parameter, where parameters are ordered by -- declaration order (as opposed to the actual order in the call, which -- may be different due to named associations). Not that this field -- points to the explicit actual parameter itself, not to the @@ -1539,6 +1539,10 @@ package Sinfo is -- Used by processing for Pre/Postcondition pragmas to store a list of -- pragmas associated with the spec of a subprogram (see Sem_Prag for -- details). + -- + -- Used by processing for pragma SPARK_Mode to store multiple pragmas + -- the apply to the same construct. These are visible/private mode for + -- a package spec and declarative/statement mode for package body. -- Next_Rep_Item (Node5-Sem) -- Present in pragma nodes, attribute definition nodes, enumeration rep @@ -7225,7 +7229,8 @@ package Sinfo is -- Sprint syntax: labelname : label; -- N_Implicit_Label_Declaration - -- Sloc points to the << of the label + -- Sloc points to the << token for a statement identifier, or to the + -- LOOP, DECLARE, or BEGIN token for a loop or block identifier -- Defining_Identifier (Node1) -- Label_Construct (Node2-Sem) diff --git a/gcc/ada/snames.ads-tmpl b/gcc/ada/snames.ads-tmpl index ef983a7fbea..70afdb70110 100644 --- a/gcc/ada/snames.ads-tmpl +++ b/gcc/ada/snames.ads-tmpl @@ -436,6 +436,7 @@ package Snames is Name_Short_Descriptors : constant Name_Id := N + $; -- GNAT Name_Source_File_Name : constant Name_Id := N + $; -- GNAT Name_Source_File_Name_Project : constant Name_Id := N + $; -- GNAT + Name_SPARK_Mode : constant Name_Id := N + $; -- GNAT Name_Style_Checks : constant Name_Id := N + $; -- GNAT Name_Suppress : constant Name_Id := N + $; Name_Suppress_Exception_Locations : constant Name_Id := N + $; -- GNAT @@ -673,6 +674,7 @@ package Snames is Name_Assertion : constant Name_Id := N + $; Name_Assertions : constant Name_Id := N + $; Name_Attribute_Name : constant Name_Id := N + $; + Name_Auto : constant Name_Id := N + $; Name_Body_File_Name : constant Name_Id := N + $; Name_Boolean_Entry_Barriers : constant Name_Id := N + $; Name_By_Any : constant Name_Id := N + $; @@ -731,6 +733,7 @@ package Snames is Name_No_Dynamic_Attachment : constant Name_Id := N + $; Name_No_Dynamic_Interrupts : constant Name_Id := N + $; Name_No_Implementation_Extensions : constant Name_Id := N + $; + Name_No_Obsolescent_Features : constant Name_Id := N + $; Name_No_Requeue : constant Name_Id := N + $; Name_No_Requeue_Statements : constant Name_Id := N + $; Name_No_Specification_Of_Aspect : constant Name_Id := N + $; @@ -760,6 +763,8 @@ package Snames is Name_Semaphore : constant Name_Id := N + $; Name_Short_Descriptor : constant Name_Id := N + $; Name_Simple_Barriers : constant Name_Id := N + $; + Name_SPARK : constant Name_Id := N + $; + Name_SPARK_05 : constant Name_Id := N + $; Name_Spec_File_Name : constant Name_Id := N + $; Name_State : constant Name_Id := N + $; Name_Statement_Assertions : constant Name_Id := N + $; @@ -898,6 +903,7 @@ package Snames is Name_Range : constant Name_Id := N + $; Name_Range_Length : constant Name_Id := N + $; -- GNAT Name_Ref : constant Name_Id := N + $; -- GNAT + Name_Restriction_Set : constant Name_Id := N + $; -- GNAT Name_Result : constant Name_Id := N + $; -- GNAT Name_Round : constant Name_Id := N + $; Name_Safe_Emax : constant Name_Id := N + $; -- Ada 83 @@ -1514,6 +1520,7 @@ package Snames is Attribute_Range, Attribute_Range_Length, Attribute_Ref, + Attribute_Restriction_Set, Attribute_Result, Attribute_Round, Attribute_Safe_Emax, @@ -1748,6 +1755,7 @@ package Snames is Pragma_Short_Descriptors, Pragma_Source_File_Name, Pragma_Source_File_Name_Project, + Pragma_SPARK_Mode, Pragma_Style_Checks, Pragma_Suppress, Pragma_Suppress_Exception_Locations, diff --git a/gcc/ada/styleg.adb b/gcc/ada/styleg.adb index 04634d171a6..6e4a44207e6 100644 --- a/gcc/ada/styleg.adb +++ b/gcc/ada/styleg.adb @@ -351,7 +351,9 @@ package body Styleg is -- 6. In addition, the comment must be properly indented if comment -- indentation checking is active (Style_Check_Indentation non-zero). -- Either the start column must be a multiple of this indentation, - -- or the indentation must match that of the next non-blank line. + -- or the indentation must match that of the next non-blank line, + -- or must match the indentation of the immediately preciding line + -- if it is non-blank. procedure Check_Comment is S : Source_Ptr; @@ -369,6 +371,12 @@ package body Styleg is -- matches that of the next non-blank line in the source, then True is -- returned, otherwise False. + function Same_Column_As_Previous_Line return Boolean; + -- Called for a full line comment. If the previous line is blank, then + -- returns False. Otherwise, if the indentation of this comment matches + -- that of the previous line in the source, then True is returned, + -- otherwise False. + -------------------- -- Is_Box_Comment -- -------------------- @@ -429,6 +437,39 @@ package body Styleg is return Get_Column_Number (Scan_Ptr) = Get_Column_Number (P); end Same_Column_As_Next_Non_Blank_Line; + ---------------------------------- + -- Same_Column_As_Previous_Line -- + ---------------------------------- + + function Same_Column_As_Previous_Line return Boolean is + S, P : Source_Ptr; + + begin + -- Point S to start of this line, and P to start of previous line + + S := Line_Start (Scan_Ptr); + P := S; + Backup_Line (P); + + -- Step P to first non-blank character on line + + loop + -- If we get back to start of current line, then the previous line + -- was blank, and we always return False in that situation. + + if P = S then + return False; + end if; + + exit when Source (P) /= ' ' and then Source (P) /= ASCII.HT; + P := P + 1; + end loop; + + -- Compare columns + + return Get_Column_Number (Scan_Ptr) = Get_Column_Number (P); + end Same_Column_As_Previous_Line; + -- Start of processing for Check_Comment begin @@ -466,7 +507,9 @@ package body Styleg is if Style_Check_Indentation /= 0 then if Start_Column rem Style_Check_Indentation /= 0 then - if not Same_Column_As_Next_Non_Blank_Line then + if not Same_Column_As_Next_Non_Blank_Line + and then not Same_Column_As_Previous_Line + then Error_Msg_S -- CODEFIX ("(style) bad column"); end if; diff --git a/gcc/ada/switch-c.adb b/gcc/ada/switch-c.adb index 96416a5e546..0fc6bdb2188 100644 --- a/gcc/ada/switch-c.adb +++ b/gcc/ada/switch-c.adb @@ -394,6 +394,22 @@ package body Switch.C is when 'D' => Ptr := Ptr + 1; + -- Not allowed if previous -gnatR given + + -- The reason for this prohibition is that the rewriting of + -- Sloc values causes strange malfunctions in the tests of + -- whether units belong to the main source. This is really a + -- bug, but too hard to fix for a marginal capability ??? + + -- The proper fix is to completely redo -gnatD processing so + -- that the tree is not messed with, and instead a separate + -- table is built on the side for debug information generation. + + if List_Representation_Info /= 0 then + Osint.Fail + ("-gnatD not permitted since -gnatR given previously"); + end if; + -- Scan optional integer line limit value if Nat_Present (Switch_Chars, Max, Ptr) then @@ -988,9 +1004,22 @@ package body Switch.C is -- -gnatR (list rep. info) when 'R' => + + -- Not allowed if previous -gnatD given. See more extensive + -- comments in the 'D' section for the inverse test. + + if Debug_Generated_Code then + Osint.Fail + ("-gnatR not permitted since -gnatD given previously"); + end if; + + -- Set to annotate rep info, and set default -gnatR mode + Back_Annotate_Rep_Info := True; List_Representation_Info := 1; + -- Scan possible parameter + Ptr := Ptr + 1; while Ptr <= Max loop C := Switch_Chars (Ptr); diff --git a/gcc/ada/targparm.adb b/gcc/ada/targparm.adb index ce3da1cb737..37ac4cd25f9 100644 --- a/gcc/ada/targparm.adb +++ b/gcc/ada/targparm.adb @@ -388,6 +388,16 @@ package body Targparm is Opt.Init_Or_Norm_Scalars := True; goto Line_Loop_Continue; + -- Partition_Elaboration_Policy + + elsif System_Text (P .. P + 36) = + "pragma Partition_Elaboration_Policy (" + then + P := P + 37; + Opt.Partition_Elaboration_Policy := System_Text (P); + Opt.Partition_Elaboration_Policy_Sloc := System_Location; + goto Line_Loop_Continue; + -- Polling (On) elsif System_Text (P .. P + 19) = "pragma Polling (On);" then diff --git a/gcc/ada/types.ads b/gcc/ada/types.ads index 9ec2d5e5984..4bbaa6b43da 100644 --- a/gcc/ada/types.ads +++ b/gcc/ada/types.ads @@ -843,25 +843,26 @@ package Types is PE_Access_Before_Elaboration, -- 14 PE_Accessibility_Check_Failed, -- 15 PE_Address_Of_Intrinsic, -- 16 - PE_All_Guards_Closed, -- 17 - PE_Bad_Predicated_Generic_Type, -- 18 - PE_Current_Task_In_Entry_Body, -- 19 - PE_Duplicated_Entry_Address, -- 20 - PE_Explicit_Raise, -- 21 - PE_Finalize_Raised_Exception, -- 22 - PE_Implicit_Return, -- 23 - PE_Misaligned_Address_Value, -- 24 - PE_Missing_Return, -- 25 - PE_Overlaid_Controlled_Object, -- 26 - PE_Potentially_Blocking_Operation, -- 27 - PE_Stubbed_Subprogram_Called, -- 28 - PE_Unchecked_Union_Restriction, -- 29 - PE_Non_Transportable_Actual, -- 30 - - SE_Empty_Storage_Pool, -- 31 - SE_Explicit_Raise, -- 32 - SE_Infinite_Recursion, -- 33 - SE_Object_Too_Large); -- 34 + PE_Aliased_Parameters, -- 17 + PE_All_Guards_Closed, -- 18 + PE_Bad_Predicated_Generic_Type, -- 19 + PE_Current_Task_In_Entry_Body, -- 20 + PE_Duplicated_Entry_Address, -- 21 + PE_Explicit_Raise, -- 22 + PE_Finalize_Raised_Exception, -- 23 + PE_Implicit_Return, -- 24 + PE_Misaligned_Address_Value, -- 25 + PE_Missing_Return, -- 26 + PE_Overlaid_Controlled_Object, -- 27 + PE_Potentially_Blocking_Operation, -- 28 + PE_Stubbed_Subprogram_Called, -- 29 + PE_Unchecked_Union_Restriction, -- 30 + PE_Non_Transportable_Actual, -- 31 + + SE_Empty_Storage_Pool, -- 32 + SE_Explicit_Raise, -- 33 + SE_Infinite_Recursion, -- 34 + SE_Object_Too_Large); -- 35 subtype RT_CE_Exceptions is RT_Exception_Code range CE_Access_Check_Failed .. @@ -875,4 +876,12 @@ package Types is SE_Empty_Storage_Pool .. SE_Object_Too_Large; + ---------------------------------------- + -- Types Used for SPARK Mode Handling -- + ---------------------------------------- + + type SPARK_Mode_Id is (None, SPARK_Off, SPARK_Auto, SPARK_On); + -- Type used to represent all legal modes that can be set by aspect/pragma + -- SPARK_Mode. + end Types; diff --git a/gcc/ada/types.h b/gcc/ada/types.h index a0f28910d11..7d1e69624c5 100644 --- a/gcc/ada/types.h +++ b/gcc/ada/types.h @@ -6,7 +6,7 @@ * * * C Header File * * * - * Copyright (C) 1992-2012, Free Software Foundation, Inc. * + * Copyright (C) 1992-2013, 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- * @@ -363,24 +363,25 @@ typedef Int Mechanism_Type; #define PE_Access_Before_Elaboration 14 #define PE_Accessibility_Check_Failed 15 #define PE_Address_Of_Intrinsic 16 -#define PE_All_Guards_Closed 17 -#define PE_Bad_Attribute_For_Predicate 18 -#define PE_Current_Task_In_Entry_Body 19 -#define PE_Duplicated_Entry_Address 20 -#define PE_Explicit_Raise 21 -#define PE_Finalize_Raised_Exception 22 -#define PE_Implicit_Return 23 -#define PE_Misaligned_Address_Value 24 -#define PE_Missing_Return 25 -#define PE_Overlaid_Controlled_Object 26 -#define PE_Potentially_Blocking_Operation 27 -#define PE_Stubbed_Subprogram_Called 28 -#define PE_Unchecked_Union_Restriction 29 -#define PE_Non_Transportable_Actual 30 - -#define SE_Empty_Storage_Pool 31 -#define SE_Explicit_Raise 32 -#define SE_Infinite_Recursion 33 -#define SE_Object_Too_Large 34 - -#define LAST_REASON_CODE 34 +#define PE_Aliased_Parameters 17 +#define PE_All_Guards_Closed 18 +#define PE_Bad_Attribute_For_Predicate 19 +#define PE_Current_Task_In_Entry_Body 20 +#define PE_Duplicated_Entry_Address 21 +#define PE_Explicit_Raise 22 +#define PE_Finalize_Raised_Exception 23 +#define PE_Implicit_Return 24 +#define PE_Misaligned_Address_Value 25 +#define PE_Missing_Return 26 +#define PE_Overlaid_Controlled_Object 27 +#define PE_Potentially_Blocking_Operation 28 +#define PE_Stubbed_Subprogram_Called 29 +#define PE_Unchecked_Union_Restriction 30 +#define PE_Non_Transportable_Actual 31 + +#define SE_Empty_Storage_Pool 32 +#define SE_Explicit_Raise 33 +#define SE_Infinite_Recursion 34 +#define SE_Object_Too_Large 35 + +#define LAST_REASON_CODE 35 diff --git a/gcc/builtins.c b/gcc/builtins.c index 6bd045c1e7e..78b0d842cc0 100644 --- a/gcc/builtins.c +++ b/gcc/builtins.c @@ -6107,7 +6107,6 @@ expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode, break; CASE_INT_FN (BUILT_IN_FFS): - case BUILT_IN_FFSIMAX: target = expand_builtin_unop (target_mode, exp, target, subtarget, ffs_optab); if (target) @@ -6115,7 +6114,6 @@ expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode, break; CASE_INT_FN (BUILT_IN_CLZ): - case BUILT_IN_CLZIMAX: target = expand_builtin_unop (target_mode, exp, target, subtarget, clz_optab); if (target) @@ -6123,7 +6121,6 @@ expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode, break; CASE_INT_FN (BUILT_IN_CTZ): - case BUILT_IN_CTZIMAX: target = expand_builtin_unop (target_mode, exp, target, subtarget, ctz_optab); if (target) @@ -6131,7 +6128,6 @@ expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode, break; CASE_INT_FN (BUILT_IN_CLRSB): - case BUILT_IN_CLRSBIMAX: target = expand_builtin_unop (target_mode, exp, target, subtarget, clrsb_optab); if (target) @@ -6139,7 +6135,6 @@ expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode, break; CASE_INT_FN (BUILT_IN_POPCOUNT): - case BUILT_IN_POPCOUNTIMAX: target = expand_builtin_unop (target_mode, exp, target, subtarget, popcount_optab); if (target) @@ -6147,7 +6142,6 @@ expand_builtin (tree exp, rtx target, rtx subtarget, enum machine_mode mode, break; CASE_INT_FN (BUILT_IN_PARITY): - case BUILT_IN_PARITYIMAX: target = expand_builtin_unop (target_mode, exp, target, subtarget, parity_optab); if (target) @@ -8152,6 +8146,8 @@ fold_builtin_bitop (tree fndecl, tree arg) break; CASE_INT_FN (BUILT_IN_CLRSB): + if (width > 2 * HOST_BITS_PER_WIDE_INT) + return NULL_TREE; if (width > HOST_BITS_PER_WIDE_INT && (hi & ((unsigned HOST_WIDE_INT) 1 << (width - HOST_BITS_PER_WIDE_INT - 1))) != 0) diff --git a/gcc/c-family/ChangeLog b/gcc/c-family/ChangeLog index c9a4f70e8bc..5aeb338b4d5 100644 --- a/gcc/c-family/ChangeLog +++ b/gcc/c-family/ChangeLog @@ -1,3 +1,24 @@ +2013-07-10 Jakub Jelinek <jakub@redhat.com> + + * c-ppoutput.c (scan_translation_unit): Call account_for_newlines + for all CPP_TOKEN_FLD_STR tokens, not just CPP_COMMENT. + +2013-07-10 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/57869 + * c.opt: Add Wconditionally-supported. + +2013-07-08 Graham Stott <graham.stott@btinternet.com> + + * c-family/array-notation-common.c (length_mismatch_in_expr_p): Delete + unused variables l_length and l_node. + +2013-07-04 Joern Rennecke <joern.rennecke@embecosm.com> + + PR c/57821 + * c-common.c (complete_array_type): Delay folding first index + like other indices. When folding, check for index overflow. + 2013-06-27 Marc Glisse <marc.glisse@inria.fr> PR c++/57509 @@ -11,7 +32,7 @@ * c-cppbuiltin.c (c_cpp_builtins): Likewise. * c-opts.c (c_common_post_options): Likewise. -2013-06-21 Balaji V. Iyer <balaji.v.iyer@intel.com> +2013-06-21 Balaji V. Iyer <balaji.v.iyer@intel.com> * array-notation-common.c (length_mismatch_in_expr): Changed the parameter type's from a dynamic array to a vec_tree. Also removed @@ -64,7 +85,7 @@ (find_inv_trees): Likewise. (replace_inv_trees): Likewise. (find_correct_array_notation_type): Likewise. - + 2013-05-28 Balaji V. Iyer <balaji.v.iyer@intel.com> * c-common.c (c_define_builtins): When cilkplus is enabled, the diff --git a/gcc/c-family/array-notation-common.c b/gcc/c-family/array-notation-common.c index 5e17009ee87..c54f444f757 100644 --- a/gcc/c-family/array-notation-common.c +++ b/gcc/c-family/array-notation-common.c @@ -84,7 +84,6 @@ length_mismatch_in_expr_p (location_t loc, vec<vec<an_parts> >list) { size_t ii, jj; tree length = NULL_TREE; - HOST_WIDE_INT l_length, l_node; size_t x = list.length (); size_t y = list[0].length (); diff --git a/gcc/c-family/c-common.c b/gcc/c-family/c-common.c index 8f7f5e52b0a..61300cd05c7 100644 --- a/gcc/c-family/c-common.c +++ b/gcc/c-family/c-common.c @@ -9781,6 +9781,7 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default) tree maxindex, type, main_type, elt, unqual_elt; int failure = 0, quals; hashval_t hashcode = 0; + bool overflow_p = false; maxindex = size_zero_node; if (initial_value) @@ -9809,8 +9810,8 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default) bool fold_p = false; if ((*v)[0].index) - maxindex = fold_convert_loc (input_location, sizetype, - (*v)[0].index); + maxindex = (*v)[0].index, fold_p = true; + curindex = maxindex; for (cnt = 1; vec_safe_iterate (v, cnt, &ce); cnt++) @@ -9821,15 +9822,26 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default) else { if (fold_p) - curindex = fold_convert (sizetype, curindex); + { + /* Since we treat size types now as ordinary + unsigned types, we need an explicit overflow + check. */ + tree orig = curindex; + curindex = fold_convert (sizetype, curindex); + overflow_p |= tree_int_cst_lt (curindex, orig); + } curindex = size_binop (PLUS_EXPR, curindex, size_one_node); } if (tree_int_cst_lt (maxindex, curindex)) maxindex = curindex, fold_p = curfold_p; } - if (fold_p) - maxindex = fold_convert (sizetype, maxindex); + if (fold_p) + { + tree orig = maxindex; + maxindex = fold_convert (sizetype, maxindex); + overflow_p |= tree_int_cst_lt (maxindex, orig); + } } } else @@ -9890,7 +9902,7 @@ complete_array_type (tree *ptype, tree initial_value, bool do_default) if (COMPLETE_TYPE_P (type) && TREE_CODE (TYPE_SIZE_UNIT (type)) == INTEGER_CST - && TREE_OVERFLOW (TYPE_SIZE_UNIT (type))) + && (overflow_p || TREE_OVERFLOW (TYPE_SIZE_UNIT (type)))) { error ("size of array is too large"); /* If we proceed with the array type as it is, we'll eventually diff --git a/gcc/c-family/c-ppoutput.c b/gcc/c-family/c-ppoutput.c index 4a1534667f6..03b88170520 100644 --- a/gcc/c-family/c-ppoutput.c +++ b/gcc/c-family/c-ppoutput.c @@ -251,7 +251,11 @@ scan_translation_unit (cpp_reader *pfile) cpp_output_token (token, print.outf); } - if (token->type == CPP_COMMENT) + /* CPP_COMMENT tokens and raw-string literal tokens can + have embedded new-line characters. Rather than enumerating + all the possible token types just check if token uses + val.str union member. */ + if (cpp_token_val_index (token) == CPP_TOKEN_FLD_STR) account_for_newlines (token->val.str.text, token->val.str.len); } } diff --git a/gcc/c-family/c.opt b/gcc/c-family/c.opt index 857813474c9..9690a087fd3 100644 --- a/gcc/c-family/c.opt +++ b/gcc/c-family/c.opt @@ -319,6 +319,10 @@ Wcomments C ObjC C++ ObjC++ Warning Alias(Wcomment) Synonym for -Wcomment +Wconditionally-supported +C++ ObjC++ Var(warn_conditionally_supported) Warning +Warn for conditionally-supported constructs + Wconversion C ObjC C++ ObjC++ Var(warn_conversion) Warning Warn for implicit type conversions that may change a value diff --git a/gcc/c/ChangeLog b/gcc/c/ChangeLog index 71a1db12faf..43cc83902ef 100644 --- a/gcc/c/ChangeLog +++ b/gcc/c/ChangeLog @@ -1,3 +1,8 @@ +2013-07-04 Joern Rennecke <joern.rennecke@embecosm.com> + + PR c/57821 + * c-typeck.c (set_init_index): When folding, check for index overflow. + 2013-06-28 Balaji V. Iyer <balaji.v.iyer@intel.com> * c-parser.c (c_parser_array_notation): Removed rejection of array diff --git a/gcc/c/c-typeck.c b/gcc/c/c-typeck.c index 3a923111429..30871db3623 100644 --- a/gcc/c/c-typeck.c +++ b/gcc/c/c-typeck.c @@ -7217,6 +7217,11 @@ set_init_index (tree first, tree last, if (last) constant_expression_warning (last); constructor_index = convert (bitsizetype, first); + if (tree_int_cst_lt (constructor_index, first)) + { + constructor_index = copy_node (constructor_index); + TREE_OVERFLOW (constructor_index) = 1; + } if (last) { diff --git a/gcc/combine.c b/gcc/combine.c index b737bc5529f..fc94c68626c 100644 --- a/gcc/combine.c +++ b/gcc/combine.c @@ -7326,7 +7326,8 @@ make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos, if (pos_rtx != 0 && GET_MODE_SIZE (pos_mode) > GET_MODE_SIZE (GET_MODE (pos_rtx))) { - rtx temp = gen_rtx_ZERO_EXTEND (pos_mode, pos_rtx); + rtx temp = simplify_gen_unary (ZERO_EXTEND, pos_mode, pos_rtx, + GET_MODE (pos_rtx)); /* If we know that no extraneous bits are set, and that the high bit is not set, convert extraction to cheaper one - either @@ -7340,7 +7341,8 @@ make_extraction (enum machine_mode mode, rtx inner, HOST_WIDE_INT pos, >> 1)) == 0))) { - rtx temp1 = gen_rtx_SIGN_EXTEND (pos_mode, pos_rtx); + rtx temp1 = simplify_gen_unary (SIGN_EXTEND, pos_mode, pos_rtx, + GET_MODE (pos_rtx)); /* Prefer ZERO_EXTENSION, since it gives more information to backends. */ @@ -13578,14 +13580,17 @@ distribute_notes (rtx notes, rtx from_insn, rtx i3, rtx i2, rtx elim_i2, && hard_regno_nregs[regno][GET_MODE (XEXP (note, 0))] > 1) { unsigned int endregno = END_HARD_REGNO (XEXP (note, 0)); - int all_used = 1; + bool all_used = true; unsigned int i; for (i = regno; i < endregno; i++) if ((! refers_to_regno_p (i, i + 1, PATTERN (place), 0) && ! find_regno_fusage (place, USE, i)) || dead_or_set_regno_p (place, i)) - all_used = 0; + { + all_used = false; + break; + } if (! all_used) { @@ -13629,7 +13634,6 @@ distribute_notes (rtx notes, rtx from_insn, rtx i3, rtx i2, rtx elim_i2, break; } } - } place = 0; diff --git a/gcc/config/aarch64/aarch64-linux.h b/gcc/config/aarch64/aarch64-linux.h index e914ed27f1f..83efad447f1 100644 --- a/gcc/config/aarch64/aarch64-linux.h +++ b/gcc/config/aarch64/aarch64-linux.h @@ -23,6 +23,8 @@ #define GLIBC_DYNAMIC_LINKER "/lib/ld-linux-aarch64.so.1" +#define CPP_SPEC "%{pthread:-D_REENTRANT}" + #define LINUX_TARGET_LINK_SPEC "%{h*} \ %{static:-Bstatic} \ %{shared:-shared} \ diff --git a/gcc/config/avr/avr-mcus.def b/gcc/config/avr/avr-mcus.def index 2a730ac7a19..f277d3687b9 100644 --- a/gcc/config/avr/avr-mcus.def +++ b/gcc/config/avr/avr-mcus.def @@ -168,7 +168,6 @@ AVR_MCU ("atmega169", ARCH_AVR5, "__AVR_ATmega169__", 0, 0, 0 AVR_MCU ("atmega169a", ARCH_AVR5, "__AVR_ATmega169A__", 0, 0, 0x0100, 1, "m169a") AVR_MCU ("atmega169p", ARCH_AVR5, "__AVR_ATmega169P__", 0, 0, 0x0100, 1, "m169p") AVR_MCU ("atmega169pa", ARCH_AVR5, "__AVR_ATmega169PA__", 0, 0, 0x0100, 1, "m169pa") -AVR_MCU ("atmega16hva", ARCH_AVR5, "__AVR_ATmega16HVA__", 0, 0, 0x0100, 1, "m16hva") AVR_MCU ("atmega16hvb", ARCH_AVR5, "__AVR_ATmega16HVB__", 0, 0, 0x0100, 1, "m16hvb") AVR_MCU ("atmega16hvbrevb", ARCH_AVR5, "__AVR_ATmega16HVBREVB__", 0, 0, 0x0100, 1, "m16hvbrevb") AVR_MCU ("atmega16m1", ARCH_AVR5, "__AVR_ATmega16M1__", 0, 0, 0x0100, 1, "m16m1") @@ -176,7 +175,6 @@ AVR_MCU ("atmega16u4", ARCH_AVR5, "__AVR_ATmega16U4__", 0, 0, 0 AVR_MCU ("atmega26hvg", ARCH_AVR5, "__AVR_ATmega26HVG__", 0, 0, 0x0100, 1, "m26hvg") AVR_MCU ("atmega32a", ARCH_AVR5, "__AVR_ATmega32A__", 0, 0, 0x0060, 1, "m32a") AVR_MCU ("atmega32", ARCH_AVR5, "__AVR_ATmega32__", 0, 0, 0x0060, 1, "m32") -AVR_MCU ("atmega32a", ARCH_AVR5, "__AVR_ATmega32A__", 0, 0, 0x0060, 1, "m32a") AVR_MCU ("atmega323", ARCH_AVR5, "__AVR_ATmega323__", 0, 0, 0x0060, 1, "m323") AVR_MCU ("atmega324a", ARCH_AVR5, "__AVR_ATmega324A__", 0, 0, 0x0100, 1, "m324a") AVR_MCU ("atmega324p", ARCH_AVR5, "__AVR_ATmega324P__", 0, 0, 0x0100, 1, "m324p") @@ -222,7 +220,6 @@ AVR_MCU ("atmega649p", ARCH_AVR5, "__AVR_ATmega649P__", 0, 0, 0 AVR_MCU ("atmega6490", ARCH_AVR5, "__AVR_ATmega6490__", 0, 0, 0x0100, 1, "m6490") AVR_MCU ("atmega16hva", ARCH_AVR5, "__AVR_ATmega16HVA__", 0, 0, 0x0100, 1, "m16hva") AVR_MCU ("atmega16hva2", ARCH_AVR5, "__AVR_ATmega16HVA2__", 0, 0, 0x0100, 1, "m16hva2") -AVR_MCU ("atmega16hvb", ARCH_AVR5, "__AVR_ATmega16HVB__", 0, 0, 0x0100, 1, "m16hvb") AVR_MCU ("atmega32hvb", ARCH_AVR5, "__AVR_ATmega32HVB__", 0, 0, 0x0100, 1, "m32hvb") AVR_MCU ("atmega6490a", ARCH_AVR5, "__AVR_ATmega6490A__", 0, 0, 0x0100, 1, "m6490a") AVR_MCU ("atmega6490p", ARCH_AVR5, "__AVR_ATmega6490P__", 0, 0, 0x0100, 1, "m6490p") @@ -231,23 +228,13 @@ AVR_MCU ("atmega64m1", ARCH_AVR5, "__AVR_ATmega64M1__", 0, 0, 0 AVR_MCU ("atmega64hve", ARCH_AVR5, "__AVR_ATmega64HVE__", 0, 0, 0x0100, 1, "m64hve") AVR_MCU ("atmega64rfa2", ARCH_AVR5, "__AVR_ATmega64RFA2__", 0, 0, 0x0200, 1, "m64rfa2") AVR_MCU ("atmega64rfr2", ARCH_AVR5, "__AVR_ATmega64RFR2__", 0, 0, 0x0200, 1, "m64rfr2") -AVR_MCU ("atmega32hvb", ARCH_AVR5, "__AVR_ATmega32HVB__", 0, 0, 0x0100, 1, "m32hvb") AVR_MCU ("atmega32hvbrevb", ARCH_AVR5, "__AVR_ATmega32HVBREVB__", 0, 0, 0x0100, 1, "m32hvbrevb") -AVR_MCU ("atmega16hva2", ARCH_AVR5, "__AVR_ATmega16HVA2__", 0, 0, 0x0100, 1, "m16hva2") AVR_MCU ("atmega48hvf", ARCH_AVR5, "__AVR_ATmega48HVF__", 0, 0, 0x0100, 1, "m48hvf") AVR_MCU ("at90can32", ARCH_AVR5, "__AVR_AT90CAN32__", 0, 0, 0x0100, 1, "can32") AVR_MCU ("at90can64", ARCH_AVR5, "__AVR_AT90CAN64__", 0, 0, 0x0100, 1, "can64") AVR_MCU ("at90pwm161", ARCH_AVR5, "__AVR_AT90PWM161__", 0, 0, 0x0100, 1, "90pwm161") AVR_MCU ("at90pwm216", ARCH_AVR5, "__AVR_AT90PWM216__", 0, 0, 0x0100, 1, "90pwm216") AVR_MCU ("at90pwm316", ARCH_AVR5, "__AVR_AT90PWM316__", 0, 0, 0x0100, 1, "90pwm316") -AVR_MCU ("atmega32c1", ARCH_AVR5, "__AVR_ATmega32C1__", 0, 0, 0x0100, 1, "m32c1") -AVR_MCU ("atmega64c1", ARCH_AVR5, "__AVR_ATmega64C1__", 0, 0, 0x0100, 1, "m64c1") -AVR_MCU ("atmega16m1", ARCH_AVR5, "__AVR_ATmega16M1__", 0, 0, 0x0100, 1, "m16m1") -AVR_MCU ("atmega32m1", ARCH_AVR5, "__AVR_ATmega32M1__", 0, 0, 0x0100, 1, "m32m1") -AVR_MCU ("atmega64m1", ARCH_AVR5, "__AVR_ATmega64M1__", 0, 0, 0x0100, 1, "m64m1") -AVR_MCU ("atmega16u4", ARCH_AVR5, "__AVR_ATmega16U4__", 0, 0, 0x0100, 1, "m16u4") -AVR_MCU ("atmega32u4", ARCH_AVR5, "__AVR_ATmega32U4__", 0, 0, 0x0100, 1, "m32u4") -AVR_MCU ("atmega32u6", ARCH_AVR5, "__AVR_ATmega32U6__", 0, 0, 0x0100, 1, "m32u6") AVR_MCU ("at90scr100", ARCH_AVR5, "__AVR_AT90SCR100__", 0, 0, 0x0100, 1, "90scr100") AVR_MCU ("at90usb646", ARCH_AVR5, "__AVR_AT90USB646__", 0, 0, 0x0100, 1, "usb646") AVR_MCU ("at90usb647", ARCH_AVR5, "__AVR_AT90USB647__", 0, 0, 0x0100, 1, "usb647") diff --git a/gcc/config/avr/avr-tables.opt b/gcc/config/avr/avr-tables.opt index 1a451bda4b6..b101e00e7e9 100644 --- a/gcc/config/avr/avr-tables.opt +++ b/gcc/config/avr/avr-tables.opt @@ -330,479 +330,440 @@ EnumValue Enum(avr_mcu) String(atmega169pa) Value(101) EnumValue -Enum(avr_mcu) String(atmega16hva) Value(102) +Enum(avr_mcu) String(atmega16hvb) Value(102) EnumValue -Enum(avr_mcu) String(atmega16hvb) Value(103) +Enum(avr_mcu) String(atmega16hvbrevb) Value(103) EnumValue -Enum(avr_mcu) String(atmega16hvbrevb) Value(104) +Enum(avr_mcu) String(atmega16m1) Value(104) EnumValue -Enum(avr_mcu) String(atmega16m1) Value(105) +Enum(avr_mcu) String(atmega16u4) Value(105) EnumValue -Enum(avr_mcu) String(atmega16u4) Value(106) +Enum(avr_mcu) String(atmega26hvg) Value(106) EnumValue -Enum(avr_mcu) String(atmega26hvg) Value(107) +Enum(avr_mcu) String(atmega32a) Value(107) EnumValue -Enum(avr_mcu) String(atmega32a) Value(108) +Enum(avr_mcu) String(atmega32) Value(108) EnumValue -Enum(avr_mcu) String(atmega32) Value(109) +Enum(avr_mcu) String(atmega323) Value(109) EnumValue -Enum(avr_mcu) String(atmega32a) Value(110) +Enum(avr_mcu) String(atmega324a) Value(110) EnumValue -Enum(avr_mcu) String(atmega323) Value(111) +Enum(avr_mcu) String(atmega324p) Value(111) EnumValue -Enum(avr_mcu) String(atmega324a) Value(112) +Enum(avr_mcu) String(atmega324pa) Value(112) EnumValue -Enum(avr_mcu) String(atmega324p) Value(113) +Enum(avr_mcu) String(atmega325) Value(113) EnumValue -Enum(avr_mcu) String(atmega324pa) Value(114) +Enum(avr_mcu) String(atmega325a) Value(114) EnumValue -Enum(avr_mcu) String(atmega325) Value(115) +Enum(avr_mcu) String(atmega325p) Value(115) EnumValue -Enum(avr_mcu) String(atmega325a) Value(116) +Enum(avr_mcu) String(atmega3250) Value(116) EnumValue -Enum(avr_mcu) String(atmega325p) Value(117) +Enum(avr_mcu) String(atmega3250a) Value(117) EnumValue -Enum(avr_mcu) String(atmega3250) Value(118) +Enum(avr_mcu) String(atmega3250p) Value(118) EnumValue -Enum(avr_mcu) String(atmega3250a) Value(119) +Enum(avr_mcu) String(atmega3250pa) Value(119) EnumValue -Enum(avr_mcu) String(atmega3250p) Value(120) +Enum(avr_mcu) String(atmega328) Value(120) EnumValue -Enum(avr_mcu) String(atmega3250pa) Value(121) +Enum(avr_mcu) String(atmega328p) Value(121) EnumValue -Enum(avr_mcu) String(atmega328) Value(122) +Enum(avr_mcu) String(atmega329) Value(122) EnumValue -Enum(avr_mcu) String(atmega328p) Value(123) +Enum(avr_mcu) String(atmega329a) Value(123) EnumValue -Enum(avr_mcu) String(atmega329) Value(124) +Enum(avr_mcu) String(atmega329p) Value(124) EnumValue -Enum(avr_mcu) String(atmega329a) Value(125) +Enum(avr_mcu) String(atmega329pa) Value(125) EnumValue -Enum(avr_mcu) String(atmega329p) Value(126) +Enum(avr_mcu) String(atmega3290) Value(126) EnumValue -Enum(avr_mcu) String(atmega329pa) Value(127) +Enum(avr_mcu) String(atmega3290a) Value(127) EnumValue -Enum(avr_mcu) String(atmega3290) Value(128) +Enum(avr_mcu) String(atmega3290p) Value(128) EnumValue -Enum(avr_mcu) String(atmega3290a) Value(129) +Enum(avr_mcu) String(atmega3290pa) Value(129) EnumValue -Enum(avr_mcu) String(atmega3290p) Value(130) +Enum(avr_mcu) String(atmega32c1) Value(130) EnumValue -Enum(avr_mcu) String(atmega3290pa) Value(131) +Enum(avr_mcu) String(atmega32m1) Value(131) EnumValue -Enum(avr_mcu) String(atmega32c1) Value(132) +Enum(avr_mcu) String(atmega32u4) Value(132) EnumValue -Enum(avr_mcu) String(atmega32m1) Value(133) +Enum(avr_mcu) String(atmega32u6) Value(133) EnumValue -Enum(avr_mcu) String(atmega32u4) Value(134) +Enum(avr_mcu) String(atmega406) Value(134) EnumValue -Enum(avr_mcu) String(atmega32u6) Value(135) +Enum(avr_mcu) String(atmega64) Value(135) EnumValue -Enum(avr_mcu) String(atmega406) Value(136) +Enum(avr_mcu) String(atmega64a) Value(136) EnumValue -Enum(avr_mcu) String(atmega64) Value(137) +Enum(avr_mcu) String(atmega640) Value(137) EnumValue -Enum(avr_mcu) String(atmega64a) Value(138) +Enum(avr_mcu) String(atmega644) Value(138) EnumValue -Enum(avr_mcu) String(atmega640) Value(139) +Enum(avr_mcu) String(atmega644a) Value(139) EnumValue -Enum(avr_mcu) String(atmega644) Value(140) +Enum(avr_mcu) String(atmega644p) Value(140) EnumValue -Enum(avr_mcu) String(atmega644a) Value(141) +Enum(avr_mcu) String(atmega644pa) Value(141) EnumValue -Enum(avr_mcu) String(atmega644p) Value(142) +Enum(avr_mcu) String(atmega645) Value(142) EnumValue -Enum(avr_mcu) String(atmega644pa) Value(143) +Enum(avr_mcu) String(atmega645a) Value(143) EnumValue -Enum(avr_mcu) String(atmega645) Value(144) +Enum(avr_mcu) String(atmega645p) Value(144) EnumValue -Enum(avr_mcu) String(atmega645a) Value(145) +Enum(avr_mcu) String(atmega6450) Value(145) EnumValue -Enum(avr_mcu) String(atmega645p) Value(146) +Enum(avr_mcu) String(atmega6450a) Value(146) EnumValue -Enum(avr_mcu) String(atmega6450) Value(147) +Enum(avr_mcu) String(atmega6450p) Value(147) EnumValue -Enum(avr_mcu) String(atmega6450a) Value(148) +Enum(avr_mcu) String(atmega649) Value(148) EnumValue -Enum(avr_mcu) String(atmega6450p) Value(149) +Enum(avr_mcu) String(atmega649a) Value(149) EnumValue -Enum(avr_mcu) String(atmega649) Value(150) +Enum(avr_mcu) String(atmega649p) Value(150) EnumValue -Enum(avr_mcu) String(atmega649a) Value(151) +Enum(avr_mcu) String(atmega6490) Value(151) EnumValue -Enum(avr_mcu) String(atmega649p) Value(152) +Enum(avr_mcu) String(atmega16hva) Value(152) EnumValue -Enum(avr_mcu) String(atmega6490) Value(153) +Enum(avr_mcu) String(atmega16hva2) Value(153) EnumValue -Enum(avr_mcu) String(atmega16hva) Value(154) +Enum(avr_mcu) String(atmega32hvb) Value(154) EnumValue -Enum(avr_mcu) String(atmega16hva2) Value(155) +Enum(avr_mcu) String(atmega6490a) Value(155) EnumValue -Enum(avr_mcu) String(atmega16hvb) Value(156) +Enum(avr_mcu) String(atmega6490p) Value(156) EnumValue -Enum(avr_mcu) String(atmega32hvb) Value(157) +Enum(avr_mcu) String(atmega64c1) Value(157) EnumValue -Enum(avr_mcu) String(atmega6490a) Value(158) +Enum(avr_mcu) String(atmega64m1) Value(158) EnumValue -Enum(avr_mcu) String(atmega6490p) Value(159) +Enum(avr_mcu) String(atmega64hve) Value(159) EnumValue -Enum(avr_mcu) String(atmega64c1) Value(160) +Enum(avr_mcu) String(atmega64rfa2) Value(160) EnumValue -Enum(avr_mcu) String(atmega64m1) Value(161) +Enum(avr_mcu) String(atmega64rfr2) Value(161) EnumValue -Enum(avr_mcu) String(atmega64hve) Value(162) +Enum(avr_mcu) String(atmega32hvbrevb) Value(162) EnumValue -Enum(avr_mcu) String(atmega64rfa2) Value(163) +Enum(avr_mcu) String(atmega48hvf) Value(163) EnumValue -Enum(avr_mcu) String(atmega64rfr2) Value(164) +Enum(avr_mcu) String(at90can32) Value(164) EnumValue -Enum(avr_mcu) String(atmega32hvb) Value(165) +Enum(avr_mcu) String(at90can64) Value(165) EnumValue -Enum(avr_mcu) String(atmega32hvbrevb) Value(166) +Enum(avr_mcu) String(at90pwm161) Value(166) EnumValue -Enum(avr_mcu) String(atmega16hva2) Value(167) +Enum(avr_mcu) String(at90pwm216) Value(167) EnumValue -Enum(avr_mcu) String(atmega48hvf) Value(168) +Enum(avr_mcu) String(at90pwm316) Value(168) EnumValue -Enum(avr_mcu) String(at90can32) Value(169) +Enum(avr_mcu) String(at90scr100) Value(169) EnumValue -Enum(avr_mcu) String(at90can64) Value(170) +Enum(avr_mcu) String(at90usb646) Value(170) EnumValue -Enum(avr_mcu) String(at90pwm161) Value(171) +Enum(avr_mcu) String(at90usb647) Value(171) EnumValue -Enum(avr_mcu) String(at90pwm216) Value(172) +Enum(avr_mcu) String(at94k) Value(172) EnumValue -Enum(avr_mcu) String(at90pwm316) Value(173) +Enum(avr_mcu) String(m3000) Value(173) EnumValue -Enum(avr_mcu) String(atmega32c1) Value(174) +Enum(avr_mcu) String(avr51) Value(174) EnumValue -Enum(avr_mcu) String(atmega64c1) Value(175) +Enum(avr_mcu) String(atmega128) Value(175) EnumValue -Enum(avr_mcu) String(atmega16m1) Value(176) +Enum(avr_mcu) String(atmega128a) Value(176) EnumValue -Enum(avr_mcu) String(atmega32m1) Value(177) +Enum(avr_mcu) String(atmega1280) Value(177) EnumValue -Enum(avr_mcu) String(atmega64m1) Value(178) +Enum(avr_mcu) String(atmega1281) Value(178) EnumValue -Enum(avr_mcu) String(atmega16u4) Value(179) +Enum(avr_mcu) String(atmega1284) Value(179) EnumValue -Enum(avr_mcu) String(atmega32u4) Value(180) +Enum(avr_mcu) String(atmega1284p) Value(180) EnumValue -Enum(avr_mcu) String(atmega32u6) Value(181) +Enum(avr_mcu) String(atmega128rfa1) Value(181) EnumValue -Enum(avr_mcu) String(at90scr100) Value(182) +Enum(avr_mcu) String(at90can128) Value(182) EnumValue -Enum(avr_mcu) String(at90usb646) Value(183) +Enum(avr_mcu) String(at90usb1286) Value(183) EnumValue -Enum(avr_mcu) String(at90usb647) Value(184) +Enum(avr_mcu) String(at90usb1287) Value(184) EnumValue -Enum(avr_mcu) String(at94k) Value(185) +Enum(avr_mcu) String(avr6) Value(185) EnumValue -Enum(avr_mcu) String(m3000) Value(186) +Enum(avr_mcu) String(atmega2560) Value(186) EnumValue -Enum(avr_mcu) String(avr51) Value(187) +Enum(avr_mcu) String(atmega2561) Value(187) EnumValue -Enum(avr_mcu) String(atmega128) Value(188) +Enum(avr_mcu) String(avrxmega2) Value(188) EnumValue -Enum(avr_mcu) String(atmega128a) Value(189) +Enum(avr_mcu) String(atxmega16a4) Value(189) EnumValue -Enum(avr_mcu) String(atmega1280) Value(190) +Enum(avr_mcu) String(atxmega16d4) Value(190) EnumValue -Enum(avr_mcu) String(atmega1281) Value(191) +Enum(avr_mcu) String(atxmega16x1) Value(191) EnumValue -Enum(avr_mcu) String(atmega1284) Value(192) +Enum(avr_mcu) String(atxmega32a4) Value(192) EnumValue -Enum(avr_mcu) String(atmega1284p) Value(193) +Enum(avr_mcu) String(atxmega32d4) Value(193) EnumValue -Enum(avr_mcu) String(atmega128rfa1) Value(194) +Enum(avr_mcu) String(atxmega32x1) Value(194) EnumValue -Enum(avr_mcu) String(at90can128) Value(195) +Enum(avr_mcu) String(atmxt112sl) Value(195) EnumValue -Enum(avr_mcu) String(at90usb1286) Value(196) +Enum(avr_mcu) String(atmxt224) Value(196) EnumValue -Enum(avr_mcu) String(at90usb1287) Value(197) +Enum(avr_mcu) String(atmxt224e) Value(197) EnumValue -Enum(avr_mcu) String(avr6) Value(198) +Enum(avr_mcu) String(atmxt336s) Value(198) EnumValue -Enum(avr_mcu) String(atmega2560) Value(199) +Enum(avr_mcu) String(atxmega16a4u) Value(199) EnumValue -Enum(avr_mcu) String(atmega2561) Value(200) +Enum(avr_mcu) String(atxmega16c4) Value(200) EnumValue -Enum(avr_mcu) String(avrxmega2) Value(201) +Enum(avr_mcu) String(atxmega32a4u) Value(201) EnumValue -Enum(avr_mcu) String(atxmega16a4) Value(202) +Enum(avr_mcu) String(atxmega32c4) Value(202) EnumValue -Enum(avr_mcu) String(atxmega16d4) Value(203) +Enum(avr_mcu) String(atxmega32e5) Value(203) EnumValue -Enum(avr_mcu) String(atxmega16x1) Value(204) +Enum(avr_mcu) String(avrxmega4) Value(204) EnumValue -Enum(avr_mcu) String(atxmega32a4) Value(205) +Enum(avr_mcu) String(atxmega64a3) Value(205) EnumValue -Enum(avr_mcu) String(atxmega32d4) Value(206) +Enum(avr_mcu) String(atxmega64d3) Value(206) EnumValue -Enum(avr_mcu) String(atxmega32x1) Value(207) +Enum(avr_mcu) String(atxmega64a3u) Value(207) EnumValue -Enum(avr_mcu) String(atmxt112sl) Value(208) +Enum(avr_mcu) String(atxmega64a4u) Value(208) EnumValue -Enum(avr_mcu) String(atmxt224) Value(209) +Enum(avr_mcu) String(atxmega64b1) Value(209) EnumValue -Enum(avr_mcu) String(atmxt224e) Value(210) +Enum(avr_mcu) String(atxmega64b3) Value(210) EnumValue -Enum(avr_mcu) String(atmxt336s) Value(211) +Enum(avr_mcu) String(atxmega64c3) Value(211) EnumValue -Enum(avr_mcu) String(atxmega16a4u) Value(212) +Enum(avr_mcu) String(atxmega64d4) Value(212) EnumValue -Enum(avr_mcu) String(atxmega16c4) Value(213) +Enum(avr_mcu) String(avrxmega5) Value(213) EnumValue -Enum(avr_mcu) String(atxmega32a4u) Value(214) +Enum(avr_mcu) String(atxmega64a1) Value(214) EnumValue -Enum(avr_mcu) String(atxmega32c4) Value(215) +Enum(avr_mcu) String(atxmega64a1u) Value(215) EnumValue -Enum(avr_mcu) String(atxmega32e5) Value(216) +Enum(avr_mcu) String(avrxmega6) Value(216) EnumValue -Enum(avr_mcu) String(avrxmega4) Value(217) +Enum(avr_mcu) String(atxmega128a3) Value(217) EnumValue -Enum(avr_mcu) String(atxmega64a3) Value(218) +Enum(avr_mcu) String(atxmega128d3) Value(218) EnumValue -Enum(avr_mcu) String(atxmega64d3) Value(219) +Enum(avr_mcu) String(atxmega192a3) Value(219) EnumValue -Enum(avr_mcu) String(atxmega64a3u) Value(220) +Enum(avr_mcu) String(atxmega192d3) Value(220) EnumValue -Enum(avr_mcu) String(atxmega64a4u) Value(221) +Enum(avr_mcu) String(atxmega256a3) Value(221) EnumValue -Enum(avr_mcu) String(atxmega64b1) Value(222) +Enum(avr_mcu) String(atxmega256a3b) Value(222) EnumValue -Enum(avr_mcu) String(atxmega64b3) Value(223) +Enum(avr_mcu) String(atxmega256a3bu) Value(223) EnumValue -Enum(avr_mcu) String(atxmega64c3) Value(224) +Enum(avr_mcu) String(atxmega256d3) Value(224) EnumValue -Enum(avr_mcu) String(atxmega64d4) Value(225) +Enum(avr_mcu) String(atxmega128a3u) Value(225) EnumValue -Enum(avr_mcu) String(avrxmega5) Value(226) +Enum(avr_mcu) String(atxmega128b1) Value(226) EnumValue -Enum(avr_mcu) String(atxmega64a1) Value(227) +Enum(avr_mcu) String(atxmega128b3) Value(227) EnumValue -Enum(avr_mcu) String(atxmega64a1u) Value(228) +Enum(avr_mcu) String(atxmega128c3) Value(228) EnumValue -Enum(avr_mcu) String(avrxmega6) Value(229) +Enum(avr_mcu) String(atxmega128d4) Value(229) EnumValue -Enum(avr_mcu) String(atxmega128a3) Value(230) +Enum(avr_mcu) String(atmxt540s) Value(230) EnumValue -Enum(avr_mcu) String(atxmega128d3) Value(231) +Enum(avr_mcu) String(atmxt540sreva) Value(231) EnumValue -Enum(avr_mcu) String(atxmega192a3) Value(232) +Enum(avr_mcu) String(atxmega192a3u) Value(232) EnumValue -Enum(avr_mcu) String(atxmega192d3) Value(233) +Enum(avr_mcu) String(atxmega192c3) Value(233) EnumValue -Enum(avr_mcu) String(atxmega256a3) Value(234) +Enum(avr_mcu) String(atxmega256a3u) Value(234) EnumValue -Enum(avr_mcu) String(atxmega256a3b) Value(235) +Enum(avr_mcu) String(atxmega256c3) Value(235) EnumValue -Enum(avr_mcu) String(atxmega256a3bu) Value(236) +Enum(avr_mcu) String(atxmega384c3) Value(236) EnumValue -Enum(avr_mcu) String(atxmega256d3) Value(237) +Enum(avr_mcu) String(atxmega384d3) Value(237) EnumValue -Enum(avr_mcu) String(atxmega128a3u) Value(238) +Enum(avr_mcu) String(avrxmega7) Value(238) EnumValue -Enum(avr_mcu) String(atxmega128b1) Value(239) +Enum(avr_mcu) String(atxmega128a1) Value(239) EnumValue -Enum(avr_mcu) String(atxmega128b3) Value(240) +Enum(avr_mcu) String(atxmega128a1u) Value(240) EnumValue -Enum(avr_mcu) String(atxmega128c3) Value(241) +Enum(avr_mcu) String(atxmega128a4u) Value(241) EnumValue -Enum(avr_mcu) String(atxmega128d4) Value(242) +Enum(avr_mcu) String(avr1) Value(242) EnumValue -Enum(avr_mcu) String(atmxt540s) Value(243) +Enum(avr_mcu) String(at90s1200) Value(243) EnumValue -Enum(avr_mcu) String(atmxt540sreva) Value(244) +Enum(avr_mcu) String(attiny11) Value(244) EnumValue -Enum(avr_mcu) String(atxmega192a3u) Value(245) +Enum(avr_mcu) String(attiny12) Value(245) EnumValue -Enum(avr_mcu) String(atxmega192c3) Value(246) +Enum(avr_mcu) String(attiny15) Value(246) EnumValue -Enum(avr_mcu) String(atxmega256a3u) Value(247) - -EnumValue -Enum(avr_mcu) String(atxmega256c3) Value(248) - -EnumValue -Enum(avr_mcu) String(atxmega384c3) Value(249) - -EnumValue -Enum(avr_mcu) String(atxmega384d3) Value(250) - -EnumValue -Enum(avr_mcu) String(avrxmega7) Value(251) - -EnumValue -Enum(avr_mcu) String(atxmega128a1) Value(252) - -EnumValue -Enum(avr_mcu) String(atxmega128a1u) Value(253) - -EnumValue -Enum(avr_mcu) String(atxmega128a4u) Value(254) - -EnumValue -Enum(avr_mcu) String(avr1) Value(255) - -EnumValue -Enum(avr_mcu) String(at90s1200) Value(256) - -EnumValue -Enum(avr_mcu) String(attiny11) Value(257) - -EnumValue -Enum(avr_mcu) String(attiny12) Value(258) - -EnumValue -Enum(avr_mcu) String(attiny15) Value(259) - -EnumValue -Enum(avr_mcu) String(attiny28) Value(260) +Enum(avr_mcu) String(attiny28) Value(247) diff --git a/gcc/config/avr/avr.c b/gcc/config/avr/avr.c index e397186398e..f8a43e5715e 100644 --- a/gcc/config/avr/avr.c +++ b/gcc/config/avr/avr.c @@ -584,7 +584,12 @@ avr_set_current_function (tree decl) { tree args = TYPE_ARG_TYPES (TREE_TYPE (decl)); tree ret = TREE_TYPE (TREE_TYPE (decl)); - const char *name = IDENTIFIER_POINTER (DECL_NAME (decl)); + const char *name; + + name = DECL_ASSEMBLER_NAME_SET_P (decl) + /* Remove the leading '*' added in set_user_assembler_name. */ + ? 1 + IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)) + : IDENTIFIER_POINTER (DECL_NAME (decl)); /* Silently ignore 'signal' if 'interrupt' is present. AVR-LibC startet using this when it switched from SIGNAL and INTERRUPT to ISR. */ @@ -1112,7 +1117,7 @@ avr_prologue_setup_frame (HOST_WIDE_INT size, HARD_REG_SET set) leaf function and thus X has already been saved. */ int irq_state = -1; - HOST_WIDE_INT size_cfa = size; + HOST_WIDE_INT size_cfa = size, neg_size; rtx fp_plus_insns, fp, my_fp; gcc_assert (frame_pointer_needed @@ -1151,6 +1156,7 @@ avr_prologue_setup_frame (HOST_WIDE_INT size, HARD_REG_SET set) } size = trunc_int_for_mode (size, GET_MODE (my_fp)); + neg_size = trunc_int_for_mode (-size, GET_MODE (my_fp)); /************ Method 1: Adjust frame pointer ************/ @@ -1171,7 +1177,8 @@ avr_prologue_setup_frame (HOST_WIDE_INT size, HARD_REG_SET set) } insn = emit_move_insn (my_fp, plus_constant (GET_MODE (my_fp), - my_fp, -size)); + my_fp, neg_size)); + if (frame_pointer_needed) { RTX_FRAME_RELATED_P (insn) = 1; diff --git a/gcc/config/avr/avr.opt b/gcc/config/avr/avr.opt index 6b2e755eeb2..4b990775b7f 100644 --- a/gcc/config/avr/avr.opt +++ b/gcc/config/avr/avr.opt @@ -77,4 +77,4 @@ The device has no SPH special function register. This option will be overridden Waddr-space-convert Warning C Report Var(avr_warn_addr_space_convert) Init(0) -Warn if the address space of an address is change. +Warn if the address space of an address is changed. diff --git a/gcc/config/avr/gen-avr-mmcu-texi.c b/gcc/config/avr/gen-avr-mmcu-texi.c index 55335f98dd9..e69cd419e4e 100644 --- a/gcc/config/avr/gen-avr-mmcu-texi.c +++ b/gcc/config/avr/gen-avr-mmcu-texi.c @@ -68,6 +68,7 @@ comparator (const void *va, const void *vb) static void print_mcus (size_t n_mcus) { + int duplicate = 0; size_t i; if (!n_mcus) @@ -78,7 +79,20 @@ print_mcus (size_t n_mcus) printf ("@*@var{mcu}@tie{}="); for (i = 0; i < n_mcus; i++) - printf (" @code{%s}%s", mcu_name[i], i == n_mcus-1 ? ".\n\n" : ","); + { + printf (" @code{%s}%s", mcu_name[i], i == n_mcus-1 ? ".\n\n" : ","); + + if (i && !strcmp (mcu_name[i], mcu_name[i-1])) + { + /* Sanity-check: Fail on devices that are present more than once. */ + + duplicate = 1; + fprintf (stderr, "error: duplicate device: %s\n", mcu_name[i]); + } + } + + if (duplicate) + exit (1); } int main (void) diff --git a/gcc/config/avr/t-multilib b/gcc/config/avr/t-multilib index 6b1db609271..d3fb28cd6ab 100644 --- a/gcc/config/avr/t-multilib +++ b/gcc/config/avr/t-multilib @@ -135,7 +135,6 @@ MULTILIB_MATCHES = \ mmcu?avr5=mmcu?atmega169a \ mmcu?avr5=mmcu?atmega169p \ mmcu?avr5=mmcu?atmega169pa \ - mmcu?avr5=mmcu?atmega16hva \ mmcu?avr5=mmcu?atmega16hvb \ mmcu?avr5=mmcu?atmega16hvbrevb \ mmcu?avr5=mmcu?atmega16m1 \ @@ -143,7 +142,6 @@ MULTILIB_MATCHES = \ mmcu?avr5=mmcu?atmega26hvg \ mmcu?avr5=mmcu?atmega32a \ mmcu?avr5=mmcu?atmega32 \ - mmcu?avr5=mmcu?atmega32a \ mmcu?avr5=mmcu?atmega323 \ mmcu?avr5=mmcu?atmega324a \ mmcu?avr5=mmcu?atmega324p \ @@ -189,7 +187,6 @@ MULTILIB_MATCHES = \ mmcu?avr5=mmcu?atmega6490 \ mmcu?avr5=mmcu?atmega16hva \ mmcu?avr5=mmcu?atmega16hva2 \ - mmcu?avr5=mmcu?atmega16hvb \ mmcu?avr5=mmcu?atmega32hvb \ mmcu?avr5=mmcu?atmega6490a \ mmcu?avr5=mmcu?atmega6490p \ @@ -198,23 +195,13 @@ MULTILIB_MATCHES = \ mmcu?avr5=mmcu?atmega64hve \ mmcu?avr5=mmcu?atmega64rfa2 \ mmcu?avr5=mmcu?atmega64rfr2 \ - mmcu?avr5=mmcu?atmega32hvb \ mmcu?avr5=mmcu?atmega32hvbrevb \ - mmcu?avr5=mmcu?atmega16hva2 \ mmcu?avr5=mmcu?atmega48hvf \ mmcu?avr5=mmcu?at90can32 \ mmcu?avr5=mmcu?at90can64 \ mmcu?avr5=mmcu?at90pwm161 \ mmcu?avr5=mmcu?at90pwm216 \ mmcu?avr5=mmcu?at90pwm316 \ - mmcu?avr5=mmcu?atmega32c1 \ - mmcu?avr5=mmcu?atmega64c1 \ - mmcu?avr5=mmcu?atmega16m1 \ - mmcu?avr5=mmcu?atmega32m1 \ - mmcu?avr5=mmcu?atmega64m1 \ - mmcu?avr5=mmcu?atmega16u4 \ - mmcu?avr5=mmcu?atmega32u4 \ - mmcu?avr5=mmcu?atmega32u6 \ mmcu?avr5=mmcu?at90scr100 \ mmcu?avr5=mmcu?at90usb646 \ mmcu?avr5=mmcu?at90usb647 \ diff --git a/gcc/config/cr16/cr16-protos.h b/gcc/config/cr16/cr16-protos.h index a5213158dec..f6663c92869 100644 --- a/gcc/config/cr16/cr16-protos.h +++ b/gcc/config/cr16/cr16-protos.h @@ -21,8 +21,6 @@ #ifndef GCC_CR16_PROTOS_H #define GCC_CR16_PROTOS_H -#include "target.h" - /* Register usage. */ extern enum reg_class cr16_regno_reg_class (int); extern int cr16_hard_regno_mode_ok (int regno, enum machine_mode); diff --git a/gcc/config/i386/driver-i386.c b/gcc/config/i386/driver-i386.c index 249c4cd1d53..c8b71c8edf9 100644 --- a/gcc/config/i386/driver-i386.c +++ b/gcc/config/i386/driver-i386.c @@ -520,8 +520,7 @@ const char *host_detect_local_cpu (int argc, const char **argv) if (vendor == signature_AMD_ebx || vendor == signature_CENTAUR_ebx || vendor == signature_CYRIX_ebx - || vendor == signature_NSC_ebx - || vendor == signature_TM2_ebx) + || vendor == signature_NSC_ebx) cache = detect_caches_amd (ext_level); else if (vendor == signature_INTEL_ebx) { diff --git a/gcc/config/i386/i386-opts.h b/gcc/config/i386/i386-opts.h index 61f04ced53b..bea1c257830 100644 --- a/gcc/config/i386/i386-opts.h +++ b/gcc/config/i386/i386-opts.h @@ -35,7 +35,8 @@ enum stringop_alg rep_prefix_8_byte, loop_1_byte, loop, - unrolled_loop + unrolled_loop, + vector_loop }; /* Available call abi. */ diff --git a/gcc/config/i386/i386.c b/gcc/config/i386/i386.c index 6a431877231..5df6ab741da 100644 --- a/gcc/config/i386/i386.c +++ b/gcc/config/i386/i386.c @@ -14670,6 +14670,9 @@ ix86_print_operand (FILE *file, rtx x, int code) /* It doesn't actually matter what mode we use here, as we're only going to use this for printing. */ x = adjust_address_nv (x, DImode, 8); + /* Output 'qword ptr' for intel assembler dialect. */ + if (ASSEMBLER_DIALECT == ASM_INTEL) + code = 'q'; break; case 'K': @@ -21950,11 +21953,10 @@ expand_set_or_movmem_via_loop (rtx destmem, rtx srcmem, { rtx out_label, top_label, iter, tmp; enum machine_mode iter_mode = counter_mode (count); - rtx piece_size = GEN_INT (GET_MODE_SIZE (mode) * unroll); + int piece_size_n = GET_MODE_SIZE (mode) * unroll; + rtx piece_size = GEN_INT (piece_size_n); rtx piece_size_mask = GEN_INT (~((GET_MODE_SIZE (mode) * unroll) - 1)); rtx size; - rtx x_addr; - rtx y_addr; int i; top_label = gen_label_rtx (); @@ -21975,13 +21977,18 @@ expand_set_or_movmem_via_loop (rtx destmem, rtx srcmem, emit_label (top_label); tmp = convert_modes (Pmode, iter_mode, iter, true); - x_addr = gen_rtx_PLUS (Pmode, destptr, tmp); - destmem = change_address (destmem, mode, x_addr); + + /* This assert could be relaxed - in this case we'll need to compute + smallest power of two, containing in PIECE_SIZE_N and pass it to + offset_address. */ + gcc_assert ((piece_size_n & (piece_size_n - 1)) == 0); + destmem = offset_address (destmem, tmp, piece_size_n); + destmem = adjust_address (destmem, mode, 0); if (srcmem) { - y_addr = gen_rtx_PLUS (Pmode, srcptr, copy_rtx (tmp)); - srcmem = change_address (srcmem, mode, y_addr); + srcmem = offset_address (srcmem, copy_rtx (tmp), piece_size_n); + srcmem = adjust_address (srcmem, mode, 0); /* When unrolling for chips that reorder memory reads and writes, we can save registers by using single temporary. @@ -22160,13 +22167,76 @@ expand_setmem_via_rep_stos (rtx destmem, rtx destptr, rtx value, emit_insn (gen_rep_stos (destptr, countreg, destmem, value, destexp)); } -static void -emit_strmov (rtx destmem, rtx srcmem, - rtx destptr, rtx srcptr, enum machine_mode mode, int offset) +/* This function emits moves to copy SIZE_TO_MOVE bytes from SRCMEM to + DESTMEM. + SRC is passed by pointer to be updated on return. + Return value is updated DST. */ +static rtx +emit_memmov (rtx destmem, rtx *srcmem, rtx destptr, rtx srcptr, + HOST_WIDE_INT size_to_move) { - rtx src = adjust_automodify_address_nv (srcmem, mode, srcptr, offset); - rtx dest = adjust_automodify_address_nv (destmem, mode, destptr, offset); - emit_insn (gen_strmov (destptr, dest, srcptr, src)); + rtx dst = destmem, src = *srcmem, adjust, tempreg; + enum insn_code code; + enum machine_mode move_mode; + int piece_size, i; + + /* Find the widest mode in which we could perform moves. + Start with the biggest power of 2 less than SIZE_TO_MOVE and half + it until move of such size is supported. */ + piece_size = 1 << floor_log2 (size_to_move); + move_mode = mode_for_size (piece_size * BITS_PER_UNIT, MODE_INT, 0); + code = optab_handler (mov_optab, move_mode); + while (code == CODE_FOR_nothing && piece_size > 1) + { + piece_size >>= 1; + move_mode = mode_for_size (piece_size * BITS_PER_UNIT, MODE_INT, 0); + code = optab_handler (mov_optab, move_mode); + } + + /* Find the corresponding vector mode with the same size as MOVE_MODE. + MOVE_MODE is an integer mode at the moment (SI, DI, TI, etc.). */ + if (GET_MODE_SIZE (move_mode) > GET_MODE_SIZE (word_mode)) + { + int nunits = GET_MODE_SIZE (move_mode) / GET_MODE_SIZE (word_mode); + move_mode = mode_for_vector (word_mode, nunits); + code = optab_handler (mov_optab, move_mode); + if (code == CODE_FOR_nothing) + { + move_mode = word_mode; + piece_size = GET_MODE_SIZE (move_mode); + code = optab_handler (mov_optab, move_mode); + } + } + gcc_assert (code != CODE_FOR_nothing); + + dst = adjust_automodify_address_nv (dst, move_mode, destptr, 0); + src = adjust_automodify_address_nv (src, move_mode, srcptr, 0); + + /* Emit moves. We'll need SIZE_TO_MOVE/PIECE_SIZES moves. */ + gcc_assert (size_to_move % piece_size == 0); + adjust = GEN_INT (piece_size); + for (i = 0; i < size_to_move; i += piece_size) + { + /* We move from memory to memory, so we'll need to do it via + a temporary register. */ + tempreg = gen_reg_rtx (move_mode); + emit_insn (GEN_FCN (code) (tempreg, src)); + emit_insn (GEN_FCN (code) (dst, tempreg)); + + emit_move_insn (destptr, + gen_rtx_PLUS (Pmode, copy_rtx (destptr), adjust)); + emit_move_insn (srcptr, + gen_rtx_PLUS (Pmode, copy_rtx (srcptr), adjust)); + + dst = adjust_automodify_address_nv (dst, move_mode, destptr, + piece_size); + src = adjust_automodify_address_nv (src, move_mode, srcptr, + piece_size); + } + + /* Update DST and SRC rtx. */ + *srcmem = src; + return dst; } /* Output code to copy at most count & (max_size - 1) bytes from SRC to DEST. */ @@ -22178,44 +22248,17 @@ expand_movmem_epilogue (rtx destmem, rtx srcmem, if (CONST_INT_P (count)) { HOST_WIDE_INT countval = INTVAL (count); - int offset = 0; + HOST_WIDE_INT epilogue_size = countval % max_size; + int i; - if ((countval & 0x10) && max_size > 16) - { - if (TARGET_64BIT) - { - emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset); - emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset + 8); - } - else - gcc_unreachable (); - offset += 16; - } - if ((countval & 0x08) && max_size > 8) - { - if (TARGET_64BIT) - emit_strmov (destmem, srcmem, destptr, srcptr, DImode, offset); - else - { - emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset); - emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset + 4); - } - offset += 8; - } - if ((countval & 0x04) && max_size > 4) + /* For now MAX_SIZE should be a power of 2. This assert could be + relaxed, but it'll require a bit more complicated epilogue + expanding. */ + gcc_assert ((max_size & (max_size - 1)) == 0); + for (i = max_size; i >= 1; i >>= 1) { - emit_strmov (destmem, srcmem, destptr, srcptr, SImode, offset); - offset += 4; - } - if ((countval & 0x02) && max_size > 2) - { - emit_strmov (destmem, srcmem, destptr, srcptr, HImode, offset); - offset += 2; - } - if ((countval & 0x01) && max_size > 1) - { - emit_strmov (destmem, srcmem, destptr, srcptr, QImode, offset); - offset += 1; + if (epilogue_size & i) + destmem = emit_memmov (destmem, &srcmem, destptr, srcptr, i); } return; } @@ -22451,47 +22494,33 @@ expand_setmem_epilogue (rtx destmem, rtx destptr, rtx value, rtx count, int max_ } /* Copy enough from DEST to SRC to align DEST known to by aligned by ALIGN to - DESIRED_ALIGNMENT. */ -static void + DESIRED_ALIGNMENT. + Return value is updated DESTMEM. */ +static rtx expand_movmem_prologue (rtx destmem, rtx srcmem, rtx destptr, rtx srcptr, rtx count, int align, int desired_alignment) { - if (align <= 1 && desired_alignment > 1) - { - rtx label = ix86_expand_aligntest (destptr, 1, false); - srcmem = change_address (srcmem, QImode, srcptr); - destmem = change_address (destmem, QImode, destptr); - emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem)); - ix86_adjust_counter (count, 1); - emit_label (label); - LABEL_NUSES (label) = 1; - } - if (align <= 2 && desired_alignment > 2) - { - rtx label = ix86_expand_aligntest (destptr, 2, false); - srcmem = change_address (srcmem, HImode, srcptr); - destmem = change_address (destmem, HImode, destptr); - emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem)); - ix86_adjust_counter (count, 2); - emit_label (label); - LABEL_NUSES (label) = 1; - } - if (align <= 4 && desired_alignment > 4) + int i; + for (i = 1; i < desired_alignment; i <<= 1) { - rtx label = ix86_expand_aligntest (destptr, 4, false); - srcmem = change_address (srcmem, SImode, srcptr); - destmem = change_address (destmem, SImode, destptr); - emit_insn (gen_strmov (destptr, destmem, srcptr, srcmem)); - ix86_adjust_counter (count, 4); - emit_label (label); - LABEL_NUSES (label) = 1; + if (align <= i) + { + rtx label = ix86_expand_aligntest (destptr, i, false); + destmem = emit_memmov (destmem, &srcmem, destptr, srcptr, i); + ix86_adjust_counter (count, i); + emit_label (label); + LABEL_NUSES (label) = 1; + set_mem_align (destmem, i * 2 * BITS_PER_UNIT); + } } - gcc_assert (desired_alignment <= 8); + return destmem; } /* Copy enough from DST to SRC to align DST known to DESIRED_ALIGN. - ALIGN_BYTES is how many bytes need to be copied. */ + ALIGN_BYTES is how many bytes need to be copied. + The function updates DST and SRC, namely, it sets proper alignment. + DST is returned via return value, SRC is updated via pointer SRCP. */ static rtx expand_constant_movmem_prologue (rtx dst, rtx *srcp, rtx destreg, rtx srcreg, int desired_align, int align_bytes) @@ -22499,62 +22528,34 @@ expand_constant_movmem_prologue (rtx dst, rtx *srcp, rtx destreg, rtx srcreg, rtx src = *srcp; rtx orig_dst = dst; rtx orig_src = src; - int off = 0; + int piece_size = 1; + int copied_bytes = 0; int src_align_bytes = get_mem_align_offset (src, desired_align * BITS_PER_UNIT); if (src_align_bytes >= 0) src_align_bytes = desired_align - src_align_bytes; - if (align_bytes & 1) - { - dst = adjust_automodify_address_nv (dst, QImode, destreg, 0); - src = adjust_automodify_address_nv (src, QImode, srcreg, 0); - off = 1; - emit_insn (gen_strmov (destreg, dst, srcreg, src)); - } - if (align_bytes & 2) - { - dst = adjust_automodify_address_nv (dst, HImode, destreg, off); - src = adjust_automodify_address_nv (src, HImode, srcreg, off); - if (MEM_ALIGN (dst) < 2 * BITS_PER_UNIT) - set_mem_align (dst, 2 * BITS_PER_UNIT); - if (src_align_bytes >= 0 - && (src_align_bytes & 1) == (align_bytes & 1) - && MEM_ALIGN (src) < 2 * BITS_PER_UNIT) - set_mem_align (src, 2 * BITS_PER_UNIT); - off = 2; - emit_insn (gen_strmov (destreg, dst, srcreg, src)); - } - if (align_bytes & 4) + + for (piece_size = 1; + piece_size <= desired_align && copied_bytes < align_bytes; + piece_size <<= 1) { - dst = adjust_automodify_address_nv (dst, SImode, destreg, off); - src = adjust_automodify_address_nv (src, SImode, srcreg, off); - if (MEM_ALIGN (dst) < 4 * BITS_PER_UNIT) - set_mem_align (dst, 4 * BITS_PER_UNIT); - if (src_align_bytes >= 0) + if (align_bytes & piece_size) { - unsigned int src_align = 0; - if ((src_align_bytes & 3) == (align_bytes & 3)) - src_align = 4; - else if ((src_align_bytes & 1) == (align_bytes & 1)) - src_align = 2; - if (MEM_ALIGN (src) < src_align * BITS_PER_UNIT) - set_mem_align (src, src_align * BITS_PER_UNIT); + dst = emit_memmov (dst, &src, destreg, srcreg, piece_size); + copied_bytes += piece_size; } - off = 4; - emit_insn (gen_strmov (destreg, dst, srcreg, src)); } - dst = adjust_automodify_address_nv (dst, BLKmode, destreg, off); - src = adjust_automodify_address_nv (src, BLKmode, srcreg, off); + if (MEM_ALIGN (dst) < (unsigned int) desired_align * BITS_PER_UNIT) set_mem_align (dst, desired_align * BITS_PER_UNIT); if (src_align_bytes >= 0) { - unsigned int src_align = 0; - if ((src_align_bytes & 7) == (align_bytes & 7)) - src_align = 8; - else if ((src_align_bytes & 3) == (align_bytes & 3)) - src_align = 4; - else if ((src_align_bytes & 1) == (align_bytes & 1)) - src_align = 2; + unsigned int src_align; + for (src_align = desired_align; src_align >= 2; src_align >>= 1) + { + if ((src_align_bytes & (src_align - 1)) + == (align_bytes & (src_align - 1))) + break; + } if (src_align > (unsigned int) desired_align) src_align = desired_align; if (MEM_ALIGN (src) < src_align * BITS_PER_UNIT) @@ -22787,42 +22788,24 @@ decide_alg (HOST_WIDE_INT count, HOST_WIDE_INT expected_size, bool memset, static int decide_alignment (int align, enum stringop_alg alg, - int expected_size) + int expected_size, + enum machine_mode move_mode) { int desired_align = 0; - switch (alg) - { - case no_stringop: - gcc_unreachable (); - case loop: - case unrolled_loop: - desired_align = GET_MODE_SIZE (Pmode); - break; - case rep_prefix_8_byte: - desired_align = 8; - break; - case rep_prefix_4_byte: - /* PentiumPro has special logic triggering for 8 byte aligned blocks. - copying whole cacheline at once. */ - if (TARGET_PENTIUMPRO) - desired_align = 8; - else - desired_align = 4; - break; - case rep_prefix_1_byte: - /* PentiumPro has special logic triggering for 8 byte aligned blocks. - copying whole cacheline at once. */ - if (TARGET_PENTIUMPRO) - desired_align = 8; - else - desired_align = 1; - break; - case loop_1_byte: - desired_align = 1; - break; - case libcall: - return 0; - } + + gcc_assert (alg != no_stringop); + + if (alg == libcall) + return 0; + if (move_mode == VOIDmode) + return 0; + + desired_align = GET_MODE_SIZE (move_mode); + /* PentiumPro has special logic triggering for 8 byte aligned blocks. + copying whole cacheline at once. */ + if (TARGET_PENTIUMPRO + && (alg == rep_prefix_4_byte || alg == rep_prefix_1_byte)) + desired_align = 8; if (optimize_size) desired_align = 1; @@ -22830,17 +22813,8 @@ decide_alignment (int align, desired_align = align; if (expected_size != -1 && expected_size < 4) desired_align = align; - return desired_align; -} -/* Return the smallest power of 2 greater than VAL. */ -static int -smallest_pow2_greater_than (int val) -{ - int ret = 1; - while (ret <= val) - ret <<= 1; - return ret; + return desired_align; } /* Expand string move (memcpy) operation. Use i386 string operations @@ -22886,6 +22860,8 @@ ix86_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp, int dynamic_check; bool need_zero_guard = false; bool noalign; + enum machine_mode move_mode = VOIDmode; + int unroll_factor = 1; if (CONST_INT_P (align_exp)) align = INTVAL (align_exp); @@ -22909,50 +22885,71 @@ ix86_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp, /* Step 0: Decide on preferred algorithm, desired alignment and size of chunks to be copied by main loop. */ - alg = decide_alg (count, expected_size, false, &dynamic_check, &noalign); - desired_align = decide_alignment (align, alg, expected_size); - - if (!TARGET_ALIGN_STRINGOPS || noalign) - align = desired_align; - if (alg == libcall) return false; gcc_assert (alg != no_stringop); + if (!count) count_exp = copy_to_mode_reg (GET_MODE (count_exp), count_exp); destreg = copy_addr_to_reg (XEXP (dst, 0)); srcreg = copy_addr_to_reg (XEXP (src, 0)); + + unroll_factor = 1; + move_mode = word_mode; switch (alg) { case libcall: case no_stringop: gcc_unreachable (); + case loop_1_byte: + need_zero_guard = true; + move_mode = QImode; + break; case loop: need_zero_guard = true; - size_needed = GET_MODE_SIZE (word_mode); break; case unrolled_loop: need_zero_guard = true; - size_needed = GET_MODE_SIZE (word_mode) * (TARGET_64BIT ? 4 : 2); + unroll_factor = (TARGET_64BIT ? 4 : 2); + break; + case vector_loop: + need_zero_guard = true; + unroll_factor = 4; + /* Find the widest supported mode. */ + move_mode = word_mode; + while (optab_handler (mov_optab, GET_MODE_WIDER_MODE (move_mode)) + != CODE_FOR_nothing) + move_mode = GET_MODE_WIDER_MODE (move_mode); + + /* Find the corresponding vector mode with the same size as MOVE_MODE. + MOVE_MODE is an integer mode at the moment (SI, DI, TI, etc.). */ + if (GET_MODE_SIZE (move_mode) > GET_MODE_SIZE (word_mode)) + { + int nunits = GET_MODE_SIZE (move_mode) / GET_MODE_SIZE (word_mode); + move_mode = mode_for_vector (word_mode, nunits); + if (optab_handler (mov_optab, move_mode) == CODE_FOR_nothing) + move_mode = word_mode; + } + gcc_assert (optab_handler (mov_optab, move_mode) != CODE_FOR_nothing); break; case rep_prefix_8_byte: - size_needed = 8; + move_mode = DImode; break; case rep_prefix_4_byte: - size_needed = 4; + move_mode = SImode; break; case rep_prefix_1_byte: - size_needed = 1; - break; - case loop_1_byte: - need_zero_guard = true; - size_needed = 1; + move_mode = QImode; break; } - + size_needed = GET_MODE_SIZE (move_mode) * unroll_factor; epilogue_size_needed = size_needed; + desired_align = decide_alignment (align, alg, expected_size, move_mode); + if (!TARGET_ALIGN_STRINGOPS || noalign) + align = desired_align; + /* Step 1: Prologue guard. */ /* Alignment code needs count to be in register. */ @@ -22979,7 +22976,7 @@ ix86_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp, epilogue_size_needed = MAX (size_needed - 1, desired_align - align); /* Epilogue always copies COUNT_EXP & EPILOGUE_SIZE_NEEDED bytes. Make sure it is power of 2. */ - epilogue_size_needed = smallest_pow2_greater_than (epilogue_size_needed); + epilogue_size_needed = 1 << (floor_log2 (epilogue_size_needed) + 1); if (count) { @@ -23044,8 +23041,8 @@ ix86_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp, the info early. */ src = change_address (src, BLKmode, srcreg); dst = change_address (dst, BLKmode, destreg); - expand_movmem_prologue (dst, src, destreg, srcreg, count_exp, align, - desired_align); + dst = expand_movmem_prologue (dst, src, destreg, srcreg, count_exp, align, + desired_align); } else { @@ -23096,31 +23093,18 @@ ix86_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp, case no_stringop: gcc_unreachable (); case loop_1_byte: - expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL, - count_exp, QImode, 1, expected_size); - break; case loop: - expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL, - count_exp, word_mode, 1, expected_size); - break; case unrolled_loop: - /* Unroll only by factor of 2 in 32bit mode, since we don't have enough - registers for 4 temporaries anyway. */ + case vector_loop: expand_set_or_movmem_via_loop (dst, src, destreg, srcreg, NULL, - count_exp, word_mode, TARGET_64BIT ? 4 : 2, + count_exp, move_mode, unroll_factor, expected_size); break; case rep_prefix_8_byte: - expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp, - DImode); - break; case rep_prefix_4_byte: - expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp, - SImode); - break; case rep_prefix_1_byte: expand_movmem_via_rep_mov (dst, src, destreg, srcreg, count_exp, - QImode); + move_mode); break; } /* Adjust properly the offset of src and dest memory for aliasing. */ @@ -23161,7 +23145,7 @@ ix86_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp, if (count_exp != const0_rtx && epilogue_size_needed > 1) expand_movmem_epilogue (dst, src, destreg, srcreg, count_exp, - epilogue_size_needed); + size_needed); if (jump_around_label) emit_label (jump_around_label); return true; @@ -23282,6 +23266,8 @@ ix86_expand_setmem (rtx dst, rtx count_exp, rtx val_exp, rtx align_exp, int dynamic_check; bool need_zero_guard = false; bool noalign; + enum machine_mode move_mode = VOIDmode; + int unroll_factor; if (CONST_INT_P (align_exp)) align = INTVAL (align_exp); @@ -23302,17 +23288,16 @@ ix86_expand_setmem (rtx dst, rtx count_exp, rtx val_exp, rtx align_exp, size of chunks to be copied by main loop. */ alg = decide_alg (count, expected_size, true, &dynamic_check, &noalign); - desired_align = decide_alignment (align, alg, expected_size); - - if (!TARGET_ALIGN_STRINGOPS || noalign) - align = desired_align; - if (alg == libcall) return false; gcc_assert (alg != no_stringop); + if (!count) count_exp = copy_to_mode_reg (counter_mode (count_exp), count_exp); destreg = copy_addr_to_reg (XEXP (dst, 0)); + + move_mode = word_mode; + unroll_factor = 1; switch (alg) { case libcall: @@ -23320,28 +23305,33 @@ ix86_expand_setmem (rtx dst, rtx count_exp, rtx val_exp, rtx align_exp, gcc_unreachable (); case loop: need_zero_guard = true; - size_needed = GET_MODE_SIZE (word_mode); break; + case vector_loop: case unrolled_loop: need_zero_guard = true; - size_needed = GET_MODE_SIZE (word_mode) * 4; + unroll_factor = 4; break; case rep_prefix_8_byte: - size_needed = 8; + move_mode = DImode; break; case rep_prefix_4_byte: - size_needed = 4; + move_mode = SImode; break; case rep_prefix_1_byte: - size_needed = 1; + move_mode = QImode; break; case loop_1_byte: need_zero_guard = true; - size_needed = 1; + move_mode = QImode; break; } + size_needed = GET_MODE_SIZE (move_mode) * unroll_factor; epilogue_size_needed = size_needed; + desired_align = decide_alignment (align, alg, expected_size, move_mode); + if (!TARGET_ALIGN_STRINGOPS || noalign) + align = desired_align; + /* Step 1: Prologue guard. */ /* Alignment code needs count to be in register. */ @@ -23377,7 +23367,7 @@ ix86_expand_setmem (rtx dst, rtx count_exp, rtx val_exp, rtx align_exp, epilogue_size_needed = MAX (size_needed - 1, desired_align - align); /* Epilogue always copies COUNT_EXP & (EPILOGUE_SIZE_NEEDED - 1) bytes. Make sure it is power of 2. */ - epilogue_size_needed = smallest_pow2_greater_than (epilogue_size_needed); + epilogue_size_needed = 1 << (floor_log2 (epilogue_size_needed) + 1); /* To improve performance of small blocks, we jump around the VAL promoting mode. This mean that if the promoted VAL is not constant, @@ -23491,16 +23481,12 @@ ix86_expand_setmem (rtx dst, rtx count_exp, rtx val_exp, rtx align_exp, case no_stringop: gcc_unreachable (); case loop_1_byte: - expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val, - count_exp, QImode, 1, expected_size); - break; case loop: - expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val, - count_exp, word_mode, 1, expected_size); - break; + case vector_loop: case unrolled_loop: expand_set_or_movmem_via_loop (dst, NULL, destreg, NULL, promoted_val, - count_exp, word_mode, 4, expected_size); + count_exp, move_mode, unroll_factor, + expected_size); break; case rep_prefix_8_byte: expand_setmem_via_rep_stos (dst, destreg, promoted_val, count_exp, @@ -29356,10 +29342,11 @@ dispatch_function_versions (tree dispatch_decl, if (predicate_chain == NULL_TREE) continue; + function_version_info [actual_versions].version_decl = version_decl; + function_version_info [actual_versions].predicate_chain + = predicate_chain; + function_version_info [actual_versions].dispatch_priority = priority; actual_versions++; - function_version_info [ix - 1].version_decl = version_decl; - function_version_info [ix - 1].predicate_chain = predicate_chain; - function_version_info [ix - 1].dispatch_priority = priority; } /* Sort the versions according to descending order of dispatch priority. The @@ -42701,6 +42688,8 @@ ix86_memmodel_check (unsigned HOST_WIDE_INT val) #undef TARGET_ATTRIBUTE_TABLE #define TARGET_ATTRIBUTE_TABLE ix86_attribute_table +#undef TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P +#define TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P hook_bool_const_tree_true #if TARGET_DLLIMPORT_DECL_ATTRIBUTES # undef TARGET_MERGE_DECL_ATTRIBUTES # define TARGET_MERGE_DECL_ATTRIBUTES merge_dllimport_decl_attributes diff --git a/gcc/config/i386/i386.md b/gcc/config/i386/i386.md index a6e2946584b..2777e9c8617 100644 --- a/gcc/config/i386/i386.md +++ b/gcc/config/i386/i386.md @@ -10474,6 +10474,39 @@ PUT_CODE (operands[0], reverse_condition (GET_CODE (operands[0]))); }) +;; Like *jcc_bt<mode>, but expect a SImode operand 2 instead of QImode +;; zero extended to SImode. +(define_insn_and_split "*jcc_bt<mode>_1" + [(set (pc) + (if_then_else (match_operator 0 "bt_comparison_operator" + [(zero_extract:SWI48 + (match_operand:SWI48 1 "register_operand" "r") + (const_int 1) + (match_operand:SI 2 "register_operand" "r")) + (const_int 0)]) + (label_ref (match_operand 3)) + (pc))) + (clobber (reg:CC FLAGS_REG))] + "TARGET_USE_BT || optimize_function_for_size_p (cfun)" + "#" + "&& 1" + [(set (reg:CCC FLAGS_REG) + (compare:CCC + (zero_extract:SWI48 + (match_dup 1) + (const_int 1) + (match_dup 2)) + (const_int 0))) + (set (pc) + (if_then_else (match_op_dup 0 [(reg:CCC FLAGS_REG) (const_int 0)]) + (label_ref (match_dup 3)) + (pc)))] +{ + operands[2] = simplify_gen_subreg (<MODE>mode, operands[2], SImode, 0); + + PUT_CODE (operands[0], reverse_condition (GET_CODE (operands[0]))); +}) + ;; Avoid useless masking of bit offset operand. "and" in SImode is correct ;; also for DImode, this is what combine produces. (define_insn_and_split "*jcc_bt<mode>_mask" diff --git a/gcc/config/i386/i386.opt b/gcc/config/i386/i386.opt index f5ad69e26c2..9fbf5451e9c 100644 --- a/gcc/config/i386/i386.opt +++ b/gcc/config/i386/i386.opt @@ -345,6 +345,9 @@ Enum(stringop_alg) String(loop) Value(loop) EnumValue Enum(stringop_alg) String(unrolled_loop) Value(unrolled_loop) +EnumValue +Enum(stringop_alg) String(vector_loop) Value(vector_loop) + mtls-dialect= Target RejectNegative Joined Var(ix86_tls_dialect) Enum(tls_dialect) Init(TLS_DIALECT_GNU) Use given thread-local storage dialect diff --git a/gcc/config/i386/mmx.md b/gcc/config/i386/mmx.md index 782f0698025..12c062687c0 100644 --- a/gcc/config/i386/mmx.md +++ b/gcc/config/i386/mmx.md @@ -1078,7 +1078,7 @@ (const_int 2) (const_int 10) (const_int 3) (const_int 11)])))] "TARGET_MMX" - "punpcklbw\t{%2, %0|%0, %2}" + "punpcklbw\t{%2, %0|%0, %k2}" [(set_attr "type" "mmxcvt") (set_attr "mode" "DI")]) @@ -1104,7 +1104,7 @@ (parallel [(const_int 0) (const_int 4) (const_int 1) (const_int 5)])))] "TARGET_MMX" - "punpcklwd\t{%2, %0|%0, %2}" + "punpcklwd\t{%2, %0|%0, %k2}" [(set_attr "type" "mmxcvt") (set_attr "mode" "DI")]) @@ -1130,7 +1130,7 @@ (parallel [(const_int 0) (const_int 2)])))] "TARGET_MMX" - "punpckldq\t{%2, %0|%0, %2}" + "punpckldq\t{%2, %0|%0, %k2}" [(set_attr "type" "mmxcvt") (set_attr "mode" "DI")]) diff --git a/gcc/config/i386/sse.md b/gcc/config/i386/sse.md index 66da4afc08c..439749877f2 100644 --- a/gcc/config/i386/sse.md +++ b/gcc/config/i386/sse.md @@ -355,6 +355,14 @@ (V8SF "SF") (V4DF "DF") (V4SF "SF") (V2DF "DF")]) +;; Pointer size override for scalar modes (Intel asm dialect) +(define_mode_attr iptr + [(V32QI "b") (V16HI "w") (V8SI "k") (V4DI "q") + (V16QI "b") (V8HI "w") (V4SI "k") (V2DI "q") + (V8SF "k") (V4DF "q") + (V4SF "k") (V2DF "q") + (SF "k") (DF "q")]) + ;; Number of scalar elements in each vector type (define_mode_attr ssescalarnum [(V32QI "32") (V16HI "16") (V8SI "8") (V4DI "4") @@ -511,7 +519,7 @@ (parallel [(const_int 0)])) (const_int 0)))] "TARGET_SSE2" - "%vmovq\t{%1, %0|%0, %1}" + "%vmovq\t{%1, %0|%0, %q1}" [(set_attr "type" "ssemov") (set_attr "prefix" "maybe_vex") (set_attr "mode" "TI")]) @@ -878,8 +886,8 @@ (const_int 1)))] "TARGET_SSE" "@ - <plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %0|%0, %2} - v<plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}" + <plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2} + v<plusminus_mnemonic><ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %<iptr>2}" [(set_attr "isa" "noavx,avx") (set_attr "type" "sseadd") (set_attr "prefix" "orig,vex") @@ -918,8 +926,8 @@ (const_int 1)))] "TARGET_SSE" "@ - mul<ssescalarmodesuffix>\t{%2, %0|%0, %2} - vmul<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}" + mul<ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2} + vmul<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %<iptr>2}" [(set_attr "isa" "noavx,avx") (set_attr "type" "ssemul") (set_attr "prefix" "orig,vex") @@ -975,8 +983,8 @@ (const_int 1)))] "TARGET_SSE" "@ - div<ssescalarmodesuffix>\t{%2, %0|%0, %2} - vdiv<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}" + div<ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2} + vdiv<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %<iptr>2}" [(set_attr "isa" "noavx,avx") (set_attr "type" "ssediv") (set_attr "prefix" "orig,vex") @@ -1004,8 +1012,8 @@ (const_int 1)))] "TARGET_SSE" "@ - rcpss\t{%1, %0|%0, %1} - vrcpss\t{%1, %2, %0|%0, %2, %1}" + rcpss\t{%1, %0|%0, %k1} + vrcpss\t{%1, %2, %0|%0, %2, %k1}" [(set_attr "isa" "noavx,avx") (set_attr "type" "sse") (set_attr "atom_sse_attr" "rcp") @@ -1054,8 +1062,8 @@ (const_int 1)))] "TARGET_SSE" "@ - sqrt<ssescalarmodesuffix>\t{%1, %0|%0, %1} - vsqrt<ssescalarmodesuffix>\t{%1, %2, %0|%0, %2, %1}" + sqrt<ssescalarmodesuffix>\t{%1, %0|%0, %<iptr>1} + vsqrt<ssescalarmodesuffix>\t{%1, %2, %0|%0, %2, %<iptr>1}" [(set_attr "isa" "noavx,avx") (set_attr "type" "sse") (set_attr "atom_sse_attr" "sqrt") @@ -1092,8 +1100,8 @@ (const_int 1)))] "TARGET_SSE" "@ - rsqrtss\t{%1, %0|%0, %1} - vrsqrtss\t{%1, %2, %0|%0, %2, %1}" + rsqrtss\t{%1, %0|%0, %k1} + vrsqrtss\t{%1, %2, %0|%0, %2, %k1}" [(set_attr "isa" "noavx,avx") (set_attr "type" "sse") (set_attr "prefix" "orig,vex") @@ -1156,8 +1164,8 @@ (const_int 1)))] "TARGET_SSE" "@ - <maxmin_float><ssescalarmodesuffix>\t{%2, %0|%0, %2} - v<maxmin_float><ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}" + <maxmin_float><ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2} + v<maxmin_float><ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %<iptr>2}" [(set_attr "isa" "noavx,avx") (set_attr "type" "sse") (set_attr "btver2_sse_attr" "maxmin") @@ -1588,7 +1596,7 @@ (match_dup 1) (const_int 1)))] "TARGET_AVX" - "vcmp<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}" + "vcmp<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %3}" [(set_attr "type" "ssecmp") (set_attr "length_immediate" "1") (set_attr "prefix" "vex") @@ -1635,8 +1643,8 @@ (const_int 1)))] "TARGET_SSE" "@ - cmp%D3<ssescalarmodesuffix>\t{%2, %0|%0, %2} - vcmp%D3<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %2}" + cmp%D3<ssescalarmodesuffix>\t{%2, %0|%0, %<iptr>2} + vcmp%D3<ssescalarmodesuffix>\t{%2, %1, %0|%0, %1, %<iptr>2}" [(set_attr "isa" "noavx,avx") (set_attr "type" "ssecmp") (set_attr "length_immediate" "1,*") @@ -1653,7 +1661,7 @@ (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm") (parallel [(const_int 0)]))))] "SSE_FLOAT_MODE_P (<MODE>mode)" - "%vcomi<ssemodesuffix>\t{%1, %0|%0, %1}" + "%vcomi<ssemodesuffix>\t{%1, %0|%0, %<iptr>1}" [(set_attr "type" "ssecomi") (set_attr "prefix" "maybe_vex") (set_attr "prefix_rep" "0") @@ -1673,7 +1681,7 @@ (match_operand:<ssevecmode> 1 "nonimmediate_operand" "xm") (parallel [(const_int 0)]))))] "SSE_FLOAT_MODE_P (<MODE>mode)" - "%vucomi<ssemodesuffix>\t{%1, %0|%0, %1}" + "%vucomi<ssemodesuffix>\t{%1, %0|%0, %<iptr>1}" [(set_attr "type" "ssecomi") (set_attr "prefix" "maybe_vex") (set_attr "prefix_rep" "0") @@ -2246,8 +2254,8 @@ (const_int 1)))] "TARGET_FMA" "@ - vfmadd132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %3, %2} - vfmadd213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}" + vfmadd132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %<iptr>3, %<iptr>2} + vfmadd213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %<iptr>2, %<iptr>3}" [(set_attr "type" "ssemuladd") (set_attr "mode" "<MODE>")]) @@ -2263,8 +2271,8 @@ (const_int 1)))] "TARGET_FMA" "@ - vfmsub132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %3, %2} - vfmsub213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}" + vfmsub132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %<iptr>3, %<iptr>2} + vfmsub213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %<iptr>2, %<iptr>3}" [(set_attr "type" "ssemuladd") (set_attr "mode" "<MODE>")]) @@ -2280,8 +2288,8 @@ (const_int 1)))] "TARGET_FMA" "@ - vfnmadd132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %3, %2} - vfnmadd213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}" + vfnmadd132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %<iptr>3, %<iptr>2} + vfnmadd213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %<iptr>2, %<iptr>3}" [(set_attr "type" "ssemuladd") (set_attr "mode" "<MODE>")]) @@ -2298,8 +2306,8 @@ (const_int 1)))] "TARGET_FMA" "@ - vfnmsub132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %3, %2} - vfnmsub213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %2, %3}" + vfnmsub132<ssescalarmodesuffix>\t{%2, %3, %0|%0, %<iptr>3, %<iptr>2} + vfnmsub213<ssescalarmodesuffix>\t{%3, %2, %0|%0, %<iptr>2, %<iptr>3}" [(set_attr "type" "ssemuladd") (set_attr "mode" "<MODE>")]) @@ -2328,7 +2336,7 @@ (match_operand:VF_128 4 "const0_operand") (const_int 1)))] "TARGET_FMA4" - "vfmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}" + "vfmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}" [(set_attr "type" "ssemuladd") (set_attr "mode" "<MODE>")]) @@ -2343,7 +2351,7 @@ (match_operand:VF_128 4 "const0_operand") (const_int 1)))] "TARGET_FMA4" - "vfmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}" + "vfmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}" [(set_attr "type" "ssemuladd") (set_attr "mode" "<MODE>")]) @@ -2358,7 +2366,7 @@ (match_operand:VF_128 4 "const0_operand") (const_int 1)))] "TARGET_FMA4" - "vfnmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}" + "vfnmadd<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}" [(set_attr "type" "ssemuladd") (set_attr "mode" "<MODE>")]) @@ -2374,7 +2382,7 @@ (match_operand:VF_128 4 "const0_operand") (const_int 1)))] "TARGET_FMA4" - "vfnmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %2, %3}" + "vfnmsub<ssescalarmodesuffix>\t{%3, %2, %1, %0|%0, %1, %<iptr>2, %<iptr>3}" [(set_attr "type" "ssemuladd") (set_attr "mode" "<MODE>")]) @@ -2403,7 +2411,7 @@ UNSPEC_FIX_NOTRUNC) (parallel [(const_int 0) (const_int 1)])))] "TARGET_SSE" - "cvtps2pi\t{%1, %0|%0, %1}" + "cvtps2pi\t{%1, %0|%0, %q1}" [(set_attr "type" "ssecvt") (set_attr "unit" "mmx") (set_attr "mode" "DI")]) @@ -2414,7 +2422,7 @@ (fix:V4SI (match_operand:V4SF 1 "nonimmediate_operand" "xm")) (parallel [(const_int 0) (const_int 1)])))] "TARGET_SSE" - "cvttps2pi\t{%1, %0|%0, %1}" + "cvttps2pi\t{%1, %0|%0, %q1}" [(set_attr "type" "ssecvt") (set_attr "unit" "mmx") (set_attr "prefix_rep" "0") @@ -2472,7 +2480,7 @@ (parallel [(const_int 0)]))] UNSPEC_FIX_NOTRUNC))] "TARGET_SSE" - "%vcvtss2si\t{%1, %0|%0, %1}" + "%vcvtss2si\t{%1, %0|%0, %k1}" [(set_attr "type" "sseicvt") (set_attr "athlon_decode" "double,vector") (set_attr "bdver1_decode" "double,double") @@ -2485,7 +2493,7 @@ (unspec:SI [(match_operand:SF 1 "nonimmediate_operand" "x,m")] UNSPEC_FIX_NOTRUNC))] "TARGET_SSE" - "%vcvtss2si\t{%1, %0|%0, %1}" + "%vcvtss2si\t{%1, %0|%0, %k1}" [(set_attr "type" "sseicvt") (set_attr "athlon_decode" "double,vector") (set_attr "amdfam10_decode" "double,double") @@ -2502,7 +2510,7 @@ (parallel [(const_int 0)]))] UNSPEC_FIX_NOTRUNC))] "TARGET_SSE && TARGET_64BIT" - "%vcvtss2si{q}\t{%1, %0|%0, %1}" + "%vcvtss2si{q}\t{%1, %0|%0, %k1}" [(set_attr "type" "sseicvt") (set_attr "athlon_decode" "double,vector") (set_attr "bdver1_decode" "double,double") @@ -2515,7 +2523,7 @@ (unspec:DI [(match_operand:SF 1 "nonimmediate_operand" "x,m")] UNSPEC_FIX_NOTRUNC))] "TARGET_SSE && TARGET_64BIT" - "%vcvtss2si{q}\t{%1, %0|%0, %1}" + "%vcvtss2si{q}\t{%1, %0|%0, %k1}" [(set_attr "type" "sseicvt") (set_attr "athlon_decode" "double,vector") (set_attr "amdfam10_decode" "double,double") @@ -2531,7 +2539,7 @@ (match_operand:V4SF 1 "nonimmediate_operand" "x,m") (parallel [(const_int 0)]))))] "TARGET_SSE" - "%vcvttss2si\t{%1, %0|%0, %1}" + "%vcvttss2si\t{%1, %0|%0, %k1}" [(set_attr "type" "sseicvt") (set_attr "athlon_decode" "double,vector") (set_attr "amdfam10_decode" "double,double") @@ -2547,7 +2555,7 @@ (match_operand:V4SF 1 "nonimmediate_operand" "x,m") (parallel [(const_int 0)]))))] "TARGET_SSE && TARGET_64BIT" - "%vcvttss2si{q}\t{%1, %0|%0, %1}" + "%vcvttss2si{q}\t{%1, %0|%0, %k1}" [(set_attr "type" "sseicvt") (set_attr "athlon_decode" "double,vector") (set_attr "amdfam10_decode" "double,double") @@ -2733,7 +2741,7 @@ (parallel [(const_int 0)]))] UNSPEC_FIX_NOTRUNC))] "TARGET_SSE2" - "%vcvtsd2si\t{%1, %0|%0, %1}" + "%vcvtsd2si\t{%1, %0|%0, %q1}" [(set_attr "type" "sseicvt") (set_attr "athlon_decode" "double,vector") (set_attr "bdver1_decode" "double,double") @@ -2747,7 +2755,7 @@ (unspec:SI [(match_operand:DF 1 "nonimmediate_operand" "x,m")] UNSPEC_FIX_NOTRUNC))] "TARGET_SSE2" - "%vcvtsd2si\t{%1, %0|%0, %1}" + "%vcvtsd2si\t{%1, %0|%0, %q1}" [(set_attr "type" "sseicvt") (set_attr "athlon_decode" "double,vector") (set_attr "amdfam10_decode" "double,double") @@ -2764,7 +2772,7 @@ (parallel [(const_int 0)]))] UNSPEC_FIX_NOTRUNC))] "TARGET_SSE2 && TARGET_64BIT" - "%vcvtsd2si{q}\t{%1, %0|%0, %1}" + "%vcvtsd2si{q}\t{%1, %0|%0, %q1}" [(set_attr "type" "sseicvt") (set_attr "athlon_decode" "double,vector") (set_attr "bdver1_decode" "double,double") @@ -2777,7 +2785,7 @@ (unspec:DI [(match_operand:DF 1 "nonimmediate_operand" "x,m")] UNSPEC_FIX_NOTRUNC))] "TARGET_SSE2 && TARGET_64BIT" - "%vcvtsd2si{q}\t{%1, %0|%0, %1}" + "%vcvtsd2si{q}\t{%1, %0|%0, %q1}" [(set_attr "type" "sseicvt") (set_attr "athlon_decode" "double,vector") (set_attr "amdfam10_decode" "double,double") @@ -2793,7 +2801,7 @@ (match_operand:V2DF 1 "nonimmediate_operand" "x,m") (parallel [(const_int 0)]))))] "TARGET_SSE2" - "%vcvttsd2si\t{%1, %0|%0, %1}" + "%vcvttsd2si\t{%1, %0|%0, %q1}" [(set_attr "type" "sseicvt") (set_attr "athlon_decode" "double,vector") (set_attr "amdfam10_decode" "double,double") @@ -2810,7 +2818,7 @@ (match_operand:V2DF 1 "nonimmediate_operand" "x,m") (parallel [(const_int 0)]))))] "TARGET_SSE2 && TARGET_64BIT" - "%vcvttsd2si{q}\t{%1, %0|%0, %1}" + "%vcvttsd2si{q}\t{%1, %0|%0, %q1}" [(set_attr "type" "sseicvt") (set_attr "athlon_decode" "double,vector") (set_attr "amdfam10_decode" "double,double") @@ -2983,8 +2991,8 @@ "TARGET_SSE2" "@ cvtsd2ss\t{%2, %0|%0, %2} - cvtsd2ss\t{%2, %0|%0, %2} - vcvtsd2ss\t{%2, %1, %0|%0, %1, %2}" + cvtsd2ss\t{%2, %0|%0, %q2} + vcvtsd2ss\t{%2, %1, %0|%0, %1, %q2}" [(set_attr "isa" "noavx,noavx,avx") (set_attr "type" "ssecvt") (set_attr "athlon_decode" "vector,double,*") @@ -3006,8 +3014,8 @@ "TARGET_SSE2" "@ cvtss2sd\t{%2, %0|%0, %2} - cvtss2sd\t{%2, %0|%0, %2} - vcvtss2sd\t{%2, %1, %0|%0, %1, %2}" + cvtss2sd\t{%2, %0|%0, %k2} + vcvtss2sd\t{%2, %1, %0|%0, %1, %k2}" [(set_attr "isa" "noavx,noavx,avx") (set_attr "type" "ssecvt") (set_attr "amdfam10_decode" "vector,double,*") @@ -3576,7 +3584,7 @@ vmovhlps\t{%2, %1, %0|%0, %1, %2} movlps\t{%H2, %0|%0, %H2} vmovlps\t{%H2, %1, %0|%0, %1, %H2} - %vmovhps\t{%2, %0|%0, %2}" + %vmovhps\t{%2, %0|%q0, %2}" [(set_attr "isa" "noavx,avx,noavx,avx,*") (set_attr "type" "ssemov") (set_attr "prefix" "orig,vex,orig,vex,maybe_vex") @@ -3610,7 +3618,7 @@ (vec_select:V4SF (vec_concat:V8SF (match_operand:V4SF 1 "nonimmediate_operand" " 0,x,0,x,0") - (match_operand:V4SF 2 "nonimmediate_operand" " x,x,m,x,x")) + (match_operand:V4SF 2 "nonimmediate_operand" " x,x,m,m,x")) (parallel [(const_int 0) (const_int 1) (const_int 4) @@ -3619,8 +3627,8 @@ "@ movlhps\t{%2, %0|%0, %2} vmovlhps\t{%2, %1, %0|%0, %1, %2} - movhps\t{%2, %0|%0, %2} - vmovhps\t{%2, %1, %0|%0, %1, %2} + movhps\t{%2, %0|%0, %q2} + vmovhps\t{%2, %1, %0|%0, %1, %q2} %vmovlps\t{%2, %H0|%H0, %2}" [(set_attr "isa" "noavx,avx,noavx,avx,*") (set_attr "type" "ssemov") @@ -3944,7 +3952,7 @@ (parallel [(const_int 2) (const_int 3)])))] "TARGET_SSE" "@ - %vmovhps\t{%1, %0|%0, %1} + %vmovhps\t{%1, %0|%q0, %1} %vmovhlps\t{%1, %d0|%d0, %1} %vmovlps\t{%H1, %d0|%d0, %H1}" [(set_attr "type" "ssemov") @@ -3980,8 +3988,8 @@ (match_operand:V2SF 2 "nonimmediate_operand" " m,m,x,x,x")))] "TARGET_SSE" "@ - movhps\t{%2, %0|%0, %2} - vmovhps\t{%2, %1, %0|%0, %1, %2} + movhps\t{%2, %0|%0, %q2} + vmovhps\t{%2, %1, %0|%0, %1, %q2} movlhps\t{%2, %0|%0, %2} vmovlhps\t{%2, %1, %0|%0, %1, %2} %vmovlps\t{%2, %H0|%H0, %2}" @@ -3997,9 +4005,9 @@ (parallel [(const_int 0) (const_int 1)])))] "TARGET_SSE" "@ - %vmovlps\t{%1, %0|%0, %1} + %vmovlps\t{%1, %0|%q0, %1} %vmovaps\t{%1, %0|%0, %1} - %vmovlps\t{%1, %d0|%d0, %1}" + %vmovlps\t{%1, %d0|%d0, %q1}" [(set_attr "type" "ssemov") (set_attr "prefix" "maybe_vex") (set_attr "mode" "V2SF,V4SF,V2SF")]) @@ -4035,9 +4043,9 @@ "@ shufps\t{$0xe4, %1, %0|%0, %1, 0xe4} vshufps\t{$0xe4, %1, %2, %0|%0, %2, %1, 0xe4} - movlps\t{%2, %0|%0, %2} - vmovlps\t{%2, %1, %0|%0, %1, %2} - %vmovlps\t{%2, %0|%0, %2}" + movlps\t{%2, %0|%0, %q2} + vmovlps\t{%2, %1, %0|%0, %1, %q2} + %vmovlps\t{%2, %0|%q0, %2}" [(set_attr "isa" "noavx,avx,noavx,avx,*") (set_attr "type" "sseshuf,sseshuf,ssemov,ssemov,ssemov") (set_attr "length_immediate" "1,1,*,*,*") @@ -4149,8 +4157,8 @@ "@ movlhps\t{%2, %0|%0, %2} vmovlhps\t{%2, %1, %0|%0, %1, %2} - movhps\t{%2, %0|%0, %2} - vmovhps\t{%2, %1, %0|%0, %1, %2}" + movhps\t{%2, %0|%0, %q2} + vmovhps\t{%2, %1, %0|%0, %1, %q2}" [(set_attr "isa" "noavx,avx,noavx,avx") (set_attr "type" "ssemov") (set_attr "prefix" "orig,vex,orig,vex") @@ -4625,7 +4633,7 @@ %vmovddup\t{%H1, %0|%0, %H1} movlpd\t{%H1, %0|%0, %H1} vmovlpd\t{%H1, %2, %0|%0, %2, %H1} - %vmovhpd\t{%1, %0|%0, %1}" + %vmovhpd\t{%1, %0|%q0, %1}" [(set_attr "isa" "noavx,avx,sse3,noavx,avx,*") (set_attr "type" "sselog,sselog,sselog,ssemov,ssemov,ssemov") (set_attr "prefix_data16" "*,*,*,1,*,1") @@ -4723,9 +4731,9 @@ "@ unpcklpd\t{%2, %0|%0, %2} vunpcklpd\t{%2, %1, %0|%0, %1, %2} - %vmovddup\t{%1, %0|%0, %1} - movhpd\t{%2, %0|%0, %2} - vmovhpd\t{%2, %1, %0|%0, %1, %2} + %vmovddup\t{%1, %0|%0, %q1} + movhpd\t{%2, %0|%0, %q2} + vmovhpd\t{%2, %1, %0|%0, %1, %q2} %vmovlpd\t{%2, %H0|%H0, %2}" [(set_attr "isa" "noavx,avx,sse3,noavx,avx,*") (set_attr "type" "sselog,sselog,sselog,ssemov,ssemov,ssemov") @@ -4963,7 +4971,7 @@ "!TARGET_SSE2 && TARGET_SSE && !(MEM_P (operands[0]) && MEM_P (operands[1]))" "@ - movhps\t{%1, %0|%0, %1} + movhps\t{%1, %0|%q0, %1} movhlps\t{%1, %0|%0, %1} movlps\t{%H1, %0|%0, %H1}" [(set_attr "type" "ssemov") @@ -5012,7 +5020,7 @@ "@ movlps\t{%1, %0|%0, %1} movaps\t{%1, %0|%0, %1} - movlps\t{%1, %0|%0, %1}" + movlps\t{%1, %0|%0, %q1}" [(set_attr "type" "ssemov") (set_attr "mode" "V2SF,V4SF,V2SF")]) @@ -5151,9 +5159,9 @@ "@ movsd\t{%2, %0|%0, %2} vmovsd\t{%2, %1, %0|%0, %1, %2} - movlpd\t{%2, %0|%0, %2} - vmovlpd\t{%2, %1, %0|%0, %1, %2} - %vmovlpd\t{%2, %0|%0, %2} + movlpd\t{%2, %0|%0, %q2} + vmovlpd\t{%2, %1, %0|%0, %1, %q2} + %vmovlpd\t{%2, %0|%q0, %2} shufpd\t{$2, %1, %0|%0, %1, 2} movhps\t{%H1, %0|%0, %H1} vmovhps\t{%H1, %2, %0|%0, %2, %H1} @@ -7547,8 +7555,8 @@ punpcklqdq\t{%2, %0|%0, %2} vpunpcklqdq\t{%2, %1, %0|%0, %1, %2} movlhps\t{%2, %0|%0, %2} - movhps\t{%2, %0|%0, %2} - vmovhps\t{%2, %1, %0|%0, %1, %2}" + movhps\t{%2, %0|%0, %q2} + vmovhps\t{%2, %1, %0|%0, %1, %q2}" [(set_attr "isa" "sse2_noavx,avx,noavx,noavx,avx") (set_attr "type" "sselog,sselog,ssemov,ssemov,ssemov") (set_attr "prefix" "orig,vex,orig,orig,vex") @@ -10201,7 +10209,7 @@ (match_operand:VF_128 2 "const0_operand") (const_int 1)))] "TARGET_XOP" - "vfrcz<ssescalarmodesuffix>\t{%1, %0|%0, %1}" + "vfrcz<ssescalarmodesuffix>\t{%1, %0|%0, %<iptr>1}" [(set_attr "type" "ssecvt1") (set_attr "mode" "<MODE>")]) @@ -10451,20 +10459,22 @@ (match_operand:<AVXTOSSEMODE> 1 "nonimmediate_operand" "xm") (parallel [(const_int 0)]))))] "TARGET_AVX2" - "vpbroadcast<ssemodesuffix>\t{%1, %0|%0, %1}" + "vpbroadcast<ssemodesuffix>\t{%1, %0|%0, %<iptr>1}" [(set_attr "type" "ssemov") (set_attr "prefix_extra" "1") (set_attr "prefix" "vex") (set_attr "mode" "<sseinsnmode>")]) (define_insn "avx2_pbroadcast<mode>_1" - [(set (match_operand:VI_256 0 "register_operand" "=x") + [(set (match_operand:VI_256 0 "register_operand" "=x,x") (vec_duplicate:VI_256 (vec_select:<ssescalarmode> - (match_operand:VI_256 1 "nonimmediate_operand" "xm") + (match_operand:VI_256 1 "nonimmediate_operand" "m,x") (parallel [(const_int 0)]))))] "TARGET_AVX2" - "vpbroadcast<ssemodesuffix>\t{%x1, %0|%0, %x1}" + "@ + vpbroadcast<ssemodesuffix>\t{%1, %0|%0, %<iptr>1} + vpbroadcast<ssemodesuffix>\t{%x1, %0|%0, %x1}" [(set_attr "type" "ssemov") (set_attr "prefix_extra" "1") (set_attr "prefix" "vex") @@ -10619,7 +10629,7 @@ case 0: case 1: operands[1] = adjust_address_nv (operands[1], SFmode, elt * 4); - return "vbroadcastss\t{%1, %0|%0, %1}"; + return "vbroadcastss\t{%1, %0|%0, %k1}"; case 2: operands[2] = GEN_INT (elt * 0x55); return "vpermilps\t{%2, %1, %0|%0, %1, %2}"; diff --git a/gcc/config/mips/mips.c b/gcc/config/mips/mips.c index bd1d10b0e4e..3c7e4391014 100644 --- a/gcc/config/mips/mips.c +++ b/gcc/config/mips/mips.c @@ -3944,7 +3944,7 @@ mips_rtx_costs (rtx x, int code, int outer_code, int opno ATTRIBUTE_UNUSED, ? mips_cost->int_mult_si * 3 + 6 : COSTS_N_INSNS (ISA_HAS_MUL3 ? 7 : 9)); else if (!speed) - *total = COSTS_N_INSNS (ISA_HAS_MUL3 ? 1 : 2); + *total = COSTS_N_INSNS (ISA_HAS_MUL3 ? 1 : 2) + 1; else if (mode == DImode) *total = mips_cost->int_mult_di; else @@ -17199,10 +17199,17 @@ mips_conditional_register_usage (void) } if (TARGET_MIPS16) { - /* In MIPS16 mode, we permit the $t temporary registers to be used - for reload. We prohibit the unused $s registers, since they + /* In MIPS16 mode, we prohibit the unused $s registers, since they are call-saved, and saving them via a MIPS16 register would - probably waste more time than just reloading the value. */ + probably waste more time than just reloading the value. + + We permit the $t temporary registers when optimizing for speed + but not when optimizing for space because using them results in + code that is larger (but faster) then not using them. We do + allow $24 (t8) because it is used in CMP and CMPI instructions + and $25 (t9) because it is used as the function call address in + SVR4 PIC code. */ + fixed_regs[18] = call_used_regs[18] = 1; fixed_regs[19] = call_used_regs[19] = 1; fixed_regs[20] = call_used_regs[20] = 1; @@ -17212,6 +17219,17 @@ mips_conditional_register_usage (void) fixed_regs[26] = call_used_regs[26] = 1; fixed_regs[27] = call_used_regs[27] = 1; fixed_regs[30] = call_used_regs[30] = 1; + if (optimize_size) + { + fixed_regs[8] = call_used_regs[8] = 1; + fixed_regs[9] = call_used_regs[9] = 1; + fixed_regs[10] = call_used_regs[10] = 1; + fixed_regs[11] = call_used_regs[11] = 1; + fixed_regs[12] = call_used_regs[12] = 1; + fixed_regs[13] = call_used_regs[13] = 1; + fixed_regs[14] = call_used_regs[14] = 1; + fixed_regs[15] = call_used_regs[15] = 1; + } /* Do not allow HI and LO to be treated as register operands. There are no MTHI or MTLO instructions (or any real need diff --git a/gcc/config/rs6000/rs6000.c b/gcc/config/rs6000/rs6000.c index 2331c5029c2..aabef7f703c 100644 --- a/gcc/config/rs6000/rs6000.c +++ b/gcc/config/rs6000/rs6000.c @@ -2518,7 +2518,8 @@ rs6000_init_hard_regno_mode_ok (bool global_init_p) int reg_size2 = reg_size; /* TFmode/TDmode always takes 2 registers, even in VSX. */ - if (m == TDmode || m == TFmode) + if (TARGET_VSX && VSX_REG_CLASS_P (c) + && (m == TDmode || m == TFmode)) reg_size2 = UNITS_PER_FP_WORD; rs6000_class_max_nregs[m][c] diff --git a/gcc/config/rs6000/rs6000.md b/gcc/config/rs6000/rs6000.md index 010e21f7413..731cfae930a 100644 --- a/gcc/config/rs6000/rs6000.md +++ b/gcc/config/rs6000/rs6000.md @@ -10989,7 +10989,7 @@ (unspec:TLSmode [(match_dup 1) (match_dup 2)] UNSPEC_TLSGD))) (set (match_dup 0) (lo_sum:TLSmode (match_dup 3) - (unspec:TLSmode [(match_dup 2)] UNSPEC_TLSGD)))] + (unspec:TLSmode [(match_dup 1) (match_dup 2)] UNSPEC_TLSGD)))] " { operands[3] = gen_reg_rtx (TARGET_64BIT ? DImode : SImode); @@ -11012,7 +11012,8 @@ (define_insn "*tls_gd_low<TLSmode:tls_abi_suffix>" [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b") (lo_sum:TLSmode (match_operand:TLSmode 1 "gpc_reg_operand" "b") - (unspec:TLSmode [(match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")] + (unspec:TLSmode [(match_operand:TLSmode 3 "gpc_reg_operand" "b") + (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")] UNSPEC_TLSGD)))] "HAVE_AS_TLS && TARGET_TLS_MARKERS && TARGET_CMODEL != CMODEL_SMALL" "addi %0,%1,%2@got@tlsgd@l" @@ -11124,7 +11125,7 @@ (unspec:TLSmode [(const_int 0) (match_dup 1)] UNSPEC_TLSLD))) (set (match_dup 0) (lo_sum:TLSmode (match_dup 2) - (unspec:TLSmode [(const_int 0)] UNSPEC_TLSLD)))] + (unspec:TLSmode [(const_int 0) (match_dup 1)] UNSPEC_TLSLD)))] " { operands[2] = gen_reg_rtx (TARGET_64BIT ? DImode : SImode); @@ -11147,7 +11148,9 @@ (define_insn "*tls_ld_low<TLSmode:tls_abi_suffix>" [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=b") (lo_sum:TLSmode (match_operand:TLSmode 1 "gpc_reg_operand" "b") - (unspec:TLSmode [(const_int 0)] UNSPEC_TLSLD)))] + (unspec:TLSmode [(const_int 0) + (match_operand:TLSmode 2 "gpc_reg_operand" "b")] + UNSPEC_TLSLD)))] "HAVE_AS_TLS && TARGET_TLS_MARKERS && TARGET_CMODEL != CMODEL_SMALL" "addi %0,%1,%&@got@tlsld@l" [(set_attr "length" "4")]) @@ -11219,7 +11222,7 @@ (unspec:TLSmode [(match_dup 1) (match_dup 2)] UNSPEC_TLSGOTDTPREL))) (set (match_dup 0) (lo_sum:TLSmode (match_dup 3) - (unspec:TLSmode [(match_dup 2)] UNSPEC_TLSGOTDTPREL)))] + (unspec:TLSmode [(match_dup 1) (match_dup 2)] UNSPEC_TLSGOTDTPREL)))] " { operands[3] = gen_reg_rtx (TARGET_64BIT ? DImode : SImode); @@ -11242,7 +11245,8 @@ (define_insn "*tls_got_dtprel_low<TLSmode:tls_abi_suffix>" [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=r") (lo_sum:TLSmode (match_operand:TLSmode 1 "gpc_reg_operand" "b") - (unspec:TLSmode [(match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")] + (unspec:TLSmode [(match_operand:TLSmode 3 "gpc_reg_operand" "b") + (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")] UNSPEC_TLSGOTDTPREL)))] "HAVE_AS_TLS && TARGET_CMODEL != CMODEL_SMALL" "l<TLSmode:tls_insn_suffix> %0,%2@got@dtprel@l(%1)" @@ -11288,7 +11292,7 @@ (unspec:TLSmode [(match_dup 1) (match_dup 2)] UNSPEC_TLSGOTTPREL))) (set (match_dup 0) (lo_sum:TLSmode (match_dup 3) - (unspec:TLSmode [(match_dup 2)] UNSPEC_TLSGOTTPREL)))] + (unspec:TLSmode [(match_dup 1) (match_dup 2)] UNSPEC_TLSGOTTPREL)))] " { operands[3] = gen_reg_rtx (TARGET_64BIT ? DImode : SImode); @@ -11311,7 +11315,8 @@ (define_insn "*tls_got_tprel_low<TLSmode:tls_abi_suffix>" [(set (match_operand:TLSmode 0 "gpc_reg_operand" "=r") (lo_sum:TLSmode (match_operand:TLSmode 1 "gpc_reg_operand" "b") - (unspec:TLSmode [(match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")] + (unspec:TLSmode [(match_operand:TLSmode 3 "gpc_reg_operand" "b") + (match_operand:TLSmode 2 "rs6000_tls_symbol_ref" "")] UNSPEC_TLSGOTTPREL)))] "HAVE_AS_TLS && TARGET_CMODEL != CMODEL_SMALL" "l<TLSmode:tls_insn_suffix> %0,%2@got@tprel@l(%1)" diff --git a/gcc/config/s390/s390.c b/gcc/config/s390/s390.c index 2cacf6f52ad..7ce0c30c883 100644 --- a/gcc/config/s390/s390.c +++ b/gcc/config/s390/s390.c @@ -333,9 +333,9 @@ struct GTY (()) s390_frame_layout /* Bits standing for floating point registers. Set, if the respective register has to be saved. Starting with reg 16 (f0) at the rightmost bit. - Bit 15 - 8 7 6 5 4 3 2 1 0 - fpr 15 - 8 7 5 3 1 6 4 2 0 - reg 31 - 24 23 22 21 20 19 18 17 16 */ + Bit 15 14 13 12 11 10 9 8 7 6 5 4 3 2 1 0 + fpr 15 13 11 9 14 12 10 8 7 5 3 1 6 4 2 0 + reg 31 30 29 28 27 26 25 24 23 22 21 20 19 18 17 16 */ unsigned int fpr_bitmap; /* Number of floating point registers f8-f15 which must be saved. */ @@ -379,10 +379,10 @@ struct GTY(()) machine_function #define cfun_save_high_fprs_p (!!cfun_frame_layout.high_fprs) #define cfun_gprs_save_area_size ((cfun_frame_layout.last_save_gpr_slot - \ cfun_frame_layout.first_save_gpr_slot + 1) * UNITS_PER_LONG) -#define cfun_set_fpr_bit(BITNUM) (cfun->machine->frame_layout.fpr_bitmap |= \ - (1 << (BITNUM))) -#define cfun_fpr_bit_p(BITNUM) (!!(cfun->machine->frame_layout.fpr_bitmap & \ - (1 << (BITNUM)))) +#define cfun_set_fpr_save(REGNO) (cfun->machine->frame_layout.fpr_bitmap |= \ + (1 << (REGNO - FPR0_REGNUM))) +#define cfun_fpr_save_p(REGNO) (!!(cfun->machine->frame_layout.fpr_bitmap & \ + (1 << (REGNO - FPR0_REGNUM)))) /* Number of GPRs and FPRs used for argument passing. */ #define GP_ARG_NUM_REG 5 @@ -7451,7 +7451,6 @@ static void s390_frame_area (int *area_bottom, int *area_top) { int b, t; - int i; b = INT_MAX; t = INT_MIN; @@ -7472,13 +7471,18 @@ s390_frame_area (int *area_bottom, int *area_top) } if (!TARGET_64BIT) - for (i = 2; i < 4; i++) - if (cfun_fpr_bit_p (i)) + { + if (cfun_fpr_save_p (FPR4_REGNUM)) { - b = MIN (b, cfun_frame_layout.f4_offset + (i - 2) * 8); - t = MAX (t, cfun_frame_layout.f4_offset + (i - 1) * 8); + b = MIN (b, cfun_frame_layout.f4_offset); + t = MAX (t, cfun_frame_layout.f4_offset + 8); } - + if (cfun_fpr_save_p (FPR6_REGNUM)) + { + b = MIN (b, cfun_frame_layout.f4_offset + 8); + t = MAX (t, cfun_frame_layout.f4_offset + 16); + } + } *area_bottom = b; *area_top = t; } @@ -7505,7 +7509,7 @@ s390_register_info (int clobbered_regs[]) cfun_frame_layout.fpr_bitmap = 0; cfun_frame_layout.high_fprs = 0; if (TARGET_64BIT) - for (i = 24; i < 32; i++) + for (i = FPR8_REGNUM; i <= FPR15_REGNUM; i++) /* During reload we have to use the df_regs_ever_live infos since reload is marking FPRs used as spill slots there as live before actually making the code changes. Without @@ -7517,7 +7521,7 @@ s390_register_info (int clobbered_regs[]) || crtl->saves_all_registers))) && !global_regs[i]) { - cfun_set_fpr_bit (i - 16); + cfun_set_fpr_save (i); cfun_frame_layout.high_fprs++; } } @@ -7644,14 +7648,17 @@ s390_register_info (int clobbered_regs[]) min_fpr = 0; for (i = min_fpr; i < max_fpr; i++) - cfun_set_fpr_bit (i); + cfun_set_fpr_save (i + FPR0_REGNUM); } } if (!TARGET_64BIT) - for (i = 2; i < 4; i++) - if (df_regs_ever_live_p (i + 16) && !global_regs[i + 16]) - cfun_set_fpr_bit (i); + { + if (df_regs_ever_live_p (FPR4_REGNUM) && !global_regs[FPR4_REGNUM]) + cfun_set_fpr_save (FPR4_REGNUM); + if (df_regs_ever_live_p (FPR6_REGNUM) && !global_regs[FPR6_REGNUM]) + cfun_set_fpr_save (FPR6_REGNUM); + } } /* Fill cfun->machine with info about frame of current function. */ @@ -7687,11 +7694,13 @@ s390_frame_info (void) { cfun_frame_layout.f4_offset = (cfun_frame_layout.gprs_offset - - 8 * (cfun_fpr_bit_p (2) + cfun_fpr_bit_p (3))); + - 8 * (cfun_fpr_save_p (FPR4_REGNUM) + + cfun_fpr_save_p (FPR6_REGNUM))); cfun_frame_layout.f0_offset = (cfun_frame_layout.f4_offset - - 8 * (cfun_fpr_bit_p (0) + cfun_fpr_bit_p (1))); + - 8 * (cfun_fpr_save_p (FPR0_REGNUM) + + cfun_fpr_save_p (FPR2_REGNUM))); } else { @@ -7700,22 +7709,26 @@ s390_frame_info (void) cfun_frame_layout.f0_offset = ((cfun_frame_layout.gprs_offset & ~(STACK_BOUNDARY / BITS_PER_UNIT - 1)) - - 8 * (cfun_fpr_bit_p (0) + cfun_fpr_bit_p (1))); + - 8 * (cfun_fpr_save_p (FPR0_REGNUM) + + cfun_fpr_save_p (FPR2_REGNUM))); cfun_frame_layout.f4_offset = (cfun_frame_layout.f0_offset - - 8 * (cfun_fpr_bit_p (2) + cfun_fpr_bit_p (3))); + - 8 * (cfun_fpr_save_p (FPR4_REGNUM) + + cfun_fpr_save_p (FPR6_REGNUM))); } } else /* no backchain */ { cfun_frame_layout.f4_offset = (STACK_POINTER_OFFSET - - 8 * (cfun_fpr_bit_p (2) + cfun_fpr_bit_p (3))); + - 8 * (cfun_fpr_save_p (FPR4_REGNUM) + + cfun_fpr_save_p (FPR6_REGNUM))); cfun_frame_layout.f0_offset = (cfun_frame_layout.f4_offset - - 8 * (cfun_fpr_bit_p (0) + cfun_fpr_bit_p (1))); + - 8 * (cfun_fpr_save_p (FPR0_REGNUM) + + cfun_fpr_save_p (FPR2_REGNUM))); cfun_frame_layout.gprs_offset = cfun_frame_layout.f0_offset - cfun_gprs_save_area_size; @@ -7747,8 +7760,8 @@ s390_frame_info (void) cfun_frame_layout.frame_size += cfun_frame_layout.high_fprs * 8; - for (i = 0; i < 8; i++) - if (cfun_fpr_bit_p (i)) + for (i = FPR0_REGNUM; i <= FPR7_REGNUM; i++) + if (cfun_fpr_save_p (i)) cfun_frame_layout.frame_size += 8; cfun_frame_layout.frame_size += cfun_gprs_save_area_size; @@ -8453,11 +8466,11 @@ s390_emit_prologue (void) offset = cfun_frame_layout.f0_offset; /* Save f0 and f2. */ - for (i = 0; i < 2; i++) + for (i = FPR0_REGNUM; i <= FPR0_REGNUM + 1; i++) { - if (cfun_fpr_bit_p (i)) + if (cfun_fpr_save_p (i)) { - save_fpr (stack_pointer_rtx, offset, i + 16); + save_fpr (stack_pointer_rtx, offset, i); offset += 8; } else if (!TARGET_PACKED_STACK) @@ -8466,16 +8479,16 @@ s390_emit_prologue (void) /* Save f4 and f6. */ offset = cfun_frame_layout.f4_offset; - for (i = 2; i < 4; i++) + for (i = FPR4_REGNUM; i <= FPR4_REGNUM + 1; i++) { - if (cfun_fpr_bit_p (i)) + if (cfun_fpr_save_p (i)) { - insn = save_fpr (stack_pointer_rtx, offset, i + 16); + insn = save_fpr (stack_pointer_rtx, offset, i); offset += 8; /* If f4 and f6 are call clobbered they are saved due to stdargs and therefore are not frame related. */ - if (!call_really_used_regs[i + 16]) + if (!call_really_used_regs[i]) RTX_FRAME_RELATED_P (insn) = 1; } else if (!TARGET_PACKED_STACK) @@ -8489,20 +8502,20 @@ s390_emit_prologue (void) offset = (cfun_frame_layout.f8_offset + (cfun_frame_layout.high_fprs - 1) * 8); - for (i = 15; i > 7 && offset >= 0; i--) - if (cfun_fpr_bit_p (i)) + for (i = FPR15_REGNUM; i >= FPR8_REGNUM && offset >= 0; i--) + if (cfun_fpr_save_p (i)) { - insn = save_fpr (stack_pointer_rtx, offset, i + 16); + insn = save_fpr (stack_pointer_rtx, offset, i); RTX_FRAME_RELATED_P (insn) = 1; offset -= 8; } if (offset >= cfun_frame_layout.f8_offset) - next_fpr = i + 16; + next_fpr = i; } if (!TARGET_PACKED_STACK) - next_fpr = cfun_save_high_fprs_p ? 31 : 0; + next_fpr = cfun_save_high_fprs_p ? FPR15_REGNUM : 0; if (flag_stack_usage_info) current_function_static_stack_size = cfun_frame_layout.frame_size; @@ -8647,8 +8660,8 @@ s390_emit_prologue (void) offset = 0; - for (i = 24; i <= next_fpr; i++) - if (cfun_fpr_bit_p (i - 16)) + for (i = FPR8_REGNUM; i <= next_fpr; i++) + if (cfun_fpr_save_p (i)) { rtx addr = plus_constant (Pmode, stack_pointer_rtx, cfun_frame_layout.frame_size @@ -8777,9 +8790,9 @@ s390_emit_epilogue (bool sibcall) if (cfun_save_high_fprs_p) { next_offset = cfun_frame_layout.f8_offset; - for (i = 24; i < 32; i++) + for (i = FPR8_REGNUM; i <= FPR15_REGNUM; i++) { - if (cfun_fpr_bit_p (i - 16)) + if (cfun_fpr_save_p (i)) { restore_fpr (frame_pointer, offset + next_offset, i); @@ -8795,9 +8808,10 @@ s390_emit_epilogue (bool sibcall) else { next_offset = cfun_frame_layout.f4_offset; - for (i = 18; i < 20; i++) + /* f4, f6 */ + for (i = FPR4_REGNUM; i <= FPR4_REGNUM + 1; i++) { - if (cfun_fpr_bit_p (i - 16)) + if (cfun_fpr_save_p (i)) { restore_fpr (frame_pointer, offset + next_offset, i); @@ -10504,18 +10518,18 @@ s390_conditional_register_usage (void) } if (TARGET_64BIT) { - for (i = 24; i < 32; i++) + for (i = FPR8_REGNUM; i <= FPR15_REGNUM; i++) call_used_regs[i] = call_really_used_regs[i] = 0; } else { - for (i = 18; i < 20; i++) - call_used_regs[i] = call_really_used_regs[i] = 0; + call_used_regs[FPR4_REGNUM] = call_really_used_regs[FPR4_REGNUM] = 0; + call_used_regs[FPR6_REGNUM] = call_really_used_regs[FPR6_REGNUM] = 0; } if (TARGET_SOFT_FLOAT) { - for (i = 16; i < 32; i++) + for (i = FPR0_REGNUM; i <= FPR15_REGNUM; i++) call_used_regs[i] = fixed_regs[i] = 1; } } diff --git a/gcc/config/s390/s390.md b/gcc/config/s390/s390.md index e12d1538a50..95ded7c78e6 100644 --- a/gcc/config/s390/s390.md +++ b/gcc/config/s390/s390.md @@ -183,7 +183,21 @@ (GPR0_REGNUM 0) ; Floating point registers. (FPR0_REGNUM 16) - (FPR2_REGNUM 18) + (FPR1_REGNUM 20) + (FPR2_REGNUM 17) + (FPR3_REGNUM 21) + (FPR4_REGNUM 18) + (FPR5_REGNUM 22) + (FPR6_REGNUM 19) + (FPR7_REGNUM 23) + (FPR8_REGNUM 24) + (FPR9_REGNUM 28) + (FPR10_REGNUM 25) + (FPR11_REGNUM 29) + (FPR12_REGNUM 26) + (FPR13_REGNUM 30) + (FPR14_REGNUM 27) + (FPR15_REGNUM 31) ]) ;; @@ -4405,7 +4419,7 @@ (define_insn "*trunc<BFP:mode><DFP_ALL:mode>2" [(set (reg:DFP_ALL FPR0_REGNUM) - (float_truncate:DFP_ALL (reg:BFP FPR2_REGNUM))) + (float_truncate:DFP_ALL (reg:BFP FPR4_REGNUM))) (use (reg:SI GPR0_REGNUM)) (clobber (reg:CC CC_REGNUM))] "TARGET_HARD_DFP" @@ -4413,18 +4427,18 @@ (define_insn "*trunc<DFP_ALL:mode><BFP:mode>2" [(set (reg:BFP FPR0_REGNUM) - (float_truncate:BFP (reg:DFP_ALL FPR2_REGNUM))) + (float_truncate:BFP (reg:DFP_ALL FPR4_REGNUM))) (use (reg:SI GPR0_REGNUM)) (clobber (reg:CC CC_REGNUM))] "TARGET_HARD_DFP" "pfpo") (define_expand "trunc<BFP:mode><DFP_ALL:mode>2" - [(set (reg:BFP FPR2_REGNUM) (match_operand:BFP 1 "nonimmediate_operand" "")) + [(set (reg:BFP FPR4_REGNUM) (match_operand:BFP 1 "nonimmediate_operand" "")) (set (reg:SI GPR0_REGNUM) (match_dup 2)) (parallel [(set (reg:DFP_ALL FPR0_REGNUM) - (float_truncate:DFP_ALL (reg:BFP FPR2_REGNUM))) + (float_truncate:DFP_ALL (reg:BFP FPR4_REGNUM))) (use (reg:SI GPR0_REGNUM)) (clobber (reg:CC CC_REGNUM))]) (set (match_operand:DFP_ALL 0 "nonimmediate_operand" "") @@ -4442,11 +4456,11 @@ }) (define_expand "trunc<DFP_ALL:mode><BFP:mode>2" - [(set (reg:DFP_ALL FPR2_REGNUM) + [(set (reg:DFP_ALL FPR4_REGNUM) (match_operand:DFP_ALL 1 "nonimmediate_operand" "")) (set (reg:SI GPR0_REGNUM) (match_dup 2)) (parallel - [(set (reg:BFP FPR0_REGNUM) (float_truncate:BFP (reg:DFP_ALL FPR2_REGNUM))) + [(set (reg:BFP FPR0_REGNUM) (float_truncate:BFP (reg:DFP_ALL FPR4_REGNUM))) (use (reg:SI GPR0_REGNUM)) (clobber (reg:CC CC_REGNUM))]) (set (match_operand:BFP 0 "nonimmediate_operand" "") (reg:BFP FPR0_REGNUM))] @@ -4467,25 +4481,25 @@ ; (define_insn "*extend<BFP:mode><DFP_ALL:mode>2" - [(set (reg:DFP_ALL FPR0_REGNUM) (float_extend:DFP_ALL (reg:BFP FPR2_REGNUM))) + [(set (reg:DFP_ALL FPR0_REGNUM) (float_extend:DFP_ALL (reg:BFP FPR4_REGNUM))) (use (reg:SI GPR0_REGNUM)) (clobber (reg:CC CC_REGNUM))] "TARGET_HARD_DFP" "pfpo") (define_insn "*extend<DFP_ALL:mode><BFP:mode>2" - [(set (reg:BFP FPR0_REGNUM) (float_extend:BFP (reg:DFP_ALL FPR2_REGNUM))) + [(set (reg:BFP FPR0_REGNUM) (float_extend:BFP (reg:DFP_ALL FPR4_REGNUM))) (use (reg:SI GPR0_REGNUM)) (clobber (reg:CC CC_REGNUM))] "TARGET_HARD_DFP" "pfpo") (define_expand "extend<BFP:mode><DFP_ALL:mode>2" - [(set (reg:BFP FPR2_REGNUM) (match_operand:BFP 1 "nonimmediate_operand" "")) + [(set (reg:BFP FPR4_REGNUM) (match_operand:BFP 1 "nonimmediate_operand" "")) (set (reg:SI GPR0_REGNUM) (match_dup 2)) (parallel [(set (reg:DFP_ALL FPR0_REGNUM) - (float_extend:DFP_ALL (reg:BFP FPR2_REGNUM))) + (float_extend:DFP_ALL (reg:BFP FPR4_REGNUM))) (use (reg:SI GPR0_REGNUM)) (clobber (reg:CC CC_REGNUM))]) (set (match_operand:DFP_ALL 0 "nonimmediate_operand" "") @@ -4503,11 +4517,11 @@ }) (define_expand "extend<DFP_ALL:mode><BFP:mode>2" - [(set (reg:DFP_ALL FPR2_REGNUM) + [(set (reg:DFP_ALL FPR4_REGNUM) (match_operand:DFP_ALL 1 "nonimmediate_operand" "")) (set (reg:SI GPR0_REGNUM) (match_dup 2)) (parallel - [(set (reg:BFP FPR0_REGNUM) (float_extend:BFP (reg:DFP_ALL FPR2_REGNUM))) + [(set (reg:BFP FPR0_REGNUM) (float_extend:BFP (reg:DFP_ALL FPR4_REGNUM))) (use (reg:SI GPR0_REGNUM)) (clobber (reg:CC CC_REGNUM))]) (set (match_operand:BFP 0 "nonimmediate_operand" "") (reg:BFP FPR0_REGNUM))] diff --git a/gcc/cp/ChangeLog b/gcc/cp/ChangeLog index 92fefea845c..3dede369473 100644 --- a/gcc/cp/ChangeLog +++ b/gcc/cp/ChangeLog @@ -1,3 +1,90 @@ +2013-07-10 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/57869 + * typeck.c (build_reinterpret_cast_1): With -Wconditionally-supported + warn about casting between pointer-to-function and pointer-to-object. + +2013-07-09 Jason Merrill <jason@redhat.com> + + PR c++/57402 + * init.c (build_vec_init): Don't take shortcuts when initializing + a VLA. + + PR c++/57471 + * parser.c (cp_parser_sizeof_pack): Clear parser scopes. + + PR c++/57658 + * semantics.c (finish_id_expression): Return the id for an + unevaluated outer variable. + + PR c++/57526 + * semantics.c (lambda_capture_field_type): Build a DECLTYPE_TYPE + if the variable type uses 'auto'. + + PR c++/57437 + * typeck.c (check_return_expr): Lambda proxies aren't eligible + for nrv or return by move. + + PR c++/57532 + * parser.c (cp_parser_ref_qualifier_opt): Don't tentatively parse + a ref-qualifier in C++98 mode. + + PR c++/57545 + * pt.c (convert_nontype_argument) [INTEGER_CST]: Force the + argument to have the exact type of the parameter. + + PR c++/57551 + * semantics.c (cxx_eval_indirect_ref): Don't try to look through + a POINTER_PLUS_EXPR for type punning diagnostic. + + PR c++/57831 + * pt.c (tsubst_copy): Handle USING_DECL. + +2013-07-09 Marc Glisse <marc.glisse@inria.fr> + + PR c++/53094 + * semantics.c (cxx_eval_bit_field_ref): Handle VECTOR_CST. + +2013-07-09 Marc Glisse <marc.glisse@inria.fr> + + PR c++/53000 + * call.c (build_conditional_expr_1): Preserve xvalues. + +2013-07-09 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/51786 + * parser.c (cp_parser_simple_declaration): Before calling shadow_tag + also check declares_class_or_enum. + +2013-07-08 Jason Merrill <jason@redhat.com> + + PR c++/57550 + * pt.c (fn_type_unification): Only defer during substitution. + (type_unification_real): Defer during defarg substitution, + add checks parm to pass back deferred checks. + (unify, do_auto_deduction): Adjust. + * semantics.c (reopen_deferring_access_checks): New. + * cp-tree.h: Declare it. + +2013-07-06 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/28262 + * parser.c (cp_parser_init_declarator): If we are parsing a typedef + set parser->default_arg_ok_p to false before cp_parser_declarator. + +2013-07-05 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/14263 + * class.c (build_base_path): Improve diagnostic. + +2013-07-04 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/38634 + * decl.c (start_preparsed_function): Return a bool, false if + push_template_decl fails. + (start_function): Adjust. + * cp-tree.h: Update. + 2013-07-03 Jakub Jelinek <jakub@redhat.com> PR c++/57771 diff --git a/gcc/cp/call.c b/gcc/cp/call.c index 425ef9bcd95..78899aba1a6 100644 --- a/gcc/cp/call.c +++ b/gcc/cp/call.c @@ -4641,10 +4641,11 @@ build_conditional_expr_1 (location_t loc, tree arg1, tree arg2, tree arg3, /* [expr.cond] - If the second and third operands are lvalues and have the same - type, the result is of that type and is an lvalue. */ - if (real_lvalue_p (arg2) - && real_lvalue_p (arg3) + If the second and third operands are glvalues of the same value + category and have the same type, the result is of that type and + value category. */ + if (((real_lvalue_p (arg2) && real_lvalue_p (arg3)) + || (xvalue_p (arg2) && xvalue_p (arg3))) && same_type_p (arg2_type, arg3_type)) { result_type = arg2_type; diff --git a/gcc/cp/class.c b/gcc/cp/class.c index bb2c3fe80e4..e5166324e4c 100644 --- a/gcc/cp/class.c +++ b/gcc/cp/class.c @@ -291,9 +291,31 @@ build_base_path (enum tree_code code, if (code == MINUS_EXPR && v_binfo) { if (complain & tf_error) - error ("cannot convert from base %qT to derived type %qT via " - "virtual base %qT", BINFO_TYPE (binfo), BINFO_TYPE (d_binfo), - BINFO_TYPE (v_binfo)); + { + if (SAME_BINFO_TYPE_P (BINFO_TYPE (binfo), BINFO_TYPE (v_binfo))) + { + if (want_pointer) + error ("cannot convert from pointer to base class %qT to " + "pointer to derived class %qT because the base is " + "virtual", BINFO_TYPE (binfo), BINFO_TYPE (d_binfo)); + else + error ("cannot convert from base class %qT to derived " + "class %qT because the base is virtual", + BINFO_TYPE (binfo), BINFO_TYPE (d_binfo)); + } + else + { + if (want_pointer) + error ("cannot convert from pointer to base class %qT to " + "pointer to derived class %qT via virtual base %qT", + BINFO_TYPE (binfo), BINFO_TYPE (d_binfo), + BINFO_TYPE (v_binfo)); + else + error ("cannot convert from base class %qT to derived " + "class %qT via virtual base %qT", BINFO_TYPE (binfo), + BINFO_TYPE (d_binfo), BINFO_TYPE (v_binfo)); + } + } return error_mark_node; } diff --git a/gcc/cp/cp-tree.h b/gcc/cp/cp-tree.h index 3e8043a4162..1971bc5386c 100644 --- a/gcc/cp/cp-tree.h +++ b/gcc/cp/cp-tree.h @@ -5206,8 +5206,9 @@ extern void finish_enum_value_list (tree); extern void finish_enum (tree); extern void build_enumerator (tree, tree, tree, location_t); extern tree lookup_enumerator (tree, tree); -extern void start_preparsed_function (tree, tree, int); -extern int start_function (cp_decl_specifier_seq *, const cp_declarator *, tree); +extern bool start_preparsed_function (tree, tree, int); +extern bool start_function (cp_decl_specifier_seq *, + const cp_declarator *, tree); extern tree begin_function_body (void); extern void finish_function_body (tree); extern tree outer_curly_brace_block (tree); @@ -5636,6 +5637,7 @@ extern void resume_deferring_access_checks (void); extern void stop_deferring_access_checks (void); extern void pop_deferring_access_checks (void); extern vec<deferred_access_check, va_gc> *get_deferred_access_checks (void); +extern void reopen_deferring_access_checks (vec<deferred_access_check, va_gc> *); extern void pop_to_parent_deferring_access_checks (void); extern bool perform_access_checks (vec<deferred_access_check, va_gc> *, tsubst_flags_t); diff --git a/gcc/cp/decl.c b/gcc/cp/decl.c index 047fd77fd74..54bede00bb1 100644 --- a/gcc/cp/decl.c +++ b/gcc/cp/decl.c @@ -12993,7 +12993,7 @@ check_function_type (tree decl, tree current_function_parms) error_mark_node if the function has never been defined, or a BLOCK if the function has been defined somewhere. */ -void +bool start_preparsed_function (tree decl1, tree attrs, int flags) { tree ctype = NULL_TREE; @@ -13090,10 +13090,14 @@ start_preparsed_function (tree decl1, tree attrs, int flags) by push_nested_class.) */ if (processing_template_decl) { - /* FIXME: Handle error_mark_node more gracefully. */ tree newdecl1 = push_template_decl (decl1); - if (newdecl1 != error_mark_node) - decl1 = newdecl1; + if (newdecl1 == error_mark_node) + { + if (ctype || DECL_STATIC_FUNCTION_P (decl1)) + pop_nested_class (); + return false; + } + decl1 = newdecl1; } /* We are now in the scope of the function being defined. */ @@ -13204,7 +13208,7 @@ start_preparsed_function (tree decl1, tree attrs, int flags) /* This function may already have been parsed, in which case just return; our caller will skip over the body without parsing. */ if (DECL_INITIAL (decl1) != error_mark_node) - return; + return true; /* Initialize RTL machinery. We cannot do this until CURRENT_FUNCTION_DECL and DECL_RESULT are set up. We do this @@ -13366,17 +13370,19 @@ start_preparsed_function (tree decl1, tree attrs, int flags) start_fname_decls (); store_parm_decls (current_function_parms); + + return true; } /* Like start_preparsed_function, except that instead of a FUNCTION_DECL, this function takes DECLSPECS and DECLARATOR. - Returns 1 on success. If the DECLARATOR is not suitable for a function - (it defines a datum instead), we return 0, which tells - yyparse to report a parse error. */ + Returns true on success. If the DECLARATOR is not suitable + for a function, we return false, which tells the parser to + skip the entire function. */ -int +bool start_function (cp_decl_specifier_seq *declspecs, const cp_declarator *declarator, tree attrs) @@ -13385,13 +13391,13 @@ start_function (cp_decl_specifier_seq *declspecs, decl1 = grokdeclarator (declarator, declspecs, FUNCDEF, 1, &attrs); if (decl1 == error_mark_node) - return 0; + return false; /* If the declarator is not suitable for a function definition, cause a syntax error. */ if (decl1 == NULL_TREE || TREE_CODE (decl1) != FUNCTION_DECL) { error ("invalid function declaration"); - return 0; + return false; } if (DECL_MAIN_P (decl1)) @@ -13400,9 +13406,7 @@ start_function (cp_decl_specifier_seq *declspecs, gcc_assert (same_type_p (TREE_TYPE (TREE_TYPE (decl1)), integer_type_node)); - start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT); - - return 1; + return start_preparsed_function (decl1, attrs, /*flags=*/SF_DEFAULT); } /* Returns true iff an EH_SPEC_BLOCK should be created in the body of diff --git a/gcc/cp/init.c b/gcc/cp/init.c index 4edd150d913..7acc7b582fe 100644 --- a/gcc/cp/init.c +++ b/gcc/cp/init.c @@ -3332,6 +3332,7 @@ build_vec_init (tree base, tree maxindex, tree init, if (init && TREE_CODE (atype) == ARRAY_TYPE + && TREE_CONSTANT (maxindex) && (from_array == 2 ? (!CLASS_TYPE_P (inner_elt_type) || !TYPE_HAS_COMPLEX_COPY_ASSIGN (inner_elt_type)) @@ -3452,6 +3453,7 @@ build_vec_init (tree base, tree maxindex, tree init, tree field, elt; /* Should we try to create a constant initializer? */ bool try_const = (TREE_CODE (atype) == ARRAY_TYPE + && TREE_CONSTANT (maxindex) && (literal_type_p (inner_elt_type) || TYPE_HAS_CONSTEXPR_CTOR (inner_elt_type))); /* If the constructor already has the array type, it's been through @@ -3561,6 +3563,8 @@ build_vec_init (tree base, tree maxindex, tree init, /* Clear out INIT so that we don't get confused below. */ init = NULL_TREE; + /* Any elements without explicit initializers get {}. */ + explicit_value_init_p = true; } else if (from_array) { diff --git a/gcc/cp/parser.c b/gcc/cp/parser.c index 46a8deb588f..4b683bfbace 100644 --- a/gcc/cp/parser.c +++ b/gcc/cp/parser.c @@ -11009,11 +11009,20 @@ cp_parser_simple_declaration (cp_parser* parser, /* Issue an error message if no declarators are present, and the decl-specifier-seq does not itself declare a class or - enumeration. */ + enumeration: [dcl.dcl]/3. */ if (!saw_declarator) { if (cp_parser_declares_only_class_p (parser)) - shadow_tag (&decl_specifiers); + { + if (!declares_class_or_enum + && decl_specifiers.type + && OVERLOAD_TYPE_P (decl_specifiers.type)) + /* Ensure an error is issued anyway when finish_decltype_type, + called via cp_parser_decl_specifier_seq, returns a class or + an enumeration (c++/51786). */ + decl_specifiers.type = NULL_TREE; + shadow_tag (&decl_specifiers); + } /* Perform any deferred access checks. */ perform_deferred_access_checks (tf_warning_or_error); } @@ -16182,6 +16191,7 @@ cp_parser_init_declarator (cp_parser* parser, bool friend_p; tree pushed_scope = NULL_TREE; bool range_for_decl_p = false; + bool saved_default_arg_ok_p = parser->default_arg_ok_p; /* Gather the attributes that were provided with the decl-specifiers. */ @@ -16192,6 +16202,10 @@ cp_parser_init_declarator (cp_parser* parser, if (function_definition_p) *function_definition_p = false; + /* Default arguments are only permitted for function parameters. */ + if (decl_spec_seq_has_spec_p (decl_specifiers, ds_typedef)) + parser->default_arg_ok_p = false; + /* Defer access checks while parsing the declarator; we cannot know what names are accessible until we know what is being declared. */ @@ -16207,6 +16221,8 @@ cp_parser_init_declarator (cp_parser* parser, /* Gather up the deferred checks. */ stop_deferring_access_checks (); + parser->default_arg_ok_p = saved_default_arg_ok_p; + /* If the DECLARATOR was erroneous, there's no need to go further. */ if (declarator == cp_error_declarator) @@ -17358,6 +17374,10 @@ cp_parser_ref_qualifier_opt (cp_parser* parser) { cp_ref_qualifier ref_qual = REF_QUAL_NONE; + /* Don't try to parse bitwise '&' as a ref-qualifier (c++/57532). */ + if (cxx_dialect < cxx11 && cp_parser_parsing_tentatively (parser)) + return ref_qual; + while (true) { cp_ref_qualifier curr_ref_qual = REF_QUAL_NONE; @@ -23116,6 +23136,10 @@ cp_parser_sizeof_pack (cp_parser *parser) cp_token *token = cp_lexer_peek_token (parser->lexer); tree name = cp_parser_identifier (parser); + /* The name is not qualified. */ + parser->scope = NULL_TREE; + parser->qualifying_scope = NULL_TREE; + parser->object_scope = NULL_TREE; tree expr = cp_parser_lookup_name_simple (parser, name, token->location); if (expr == error_mark_node) cp_parser_name_lookup_error (parser, name, expr, NLE_NULL, diff --git a/gcc/cp/pt.c b/gcc/cp/pt.c index 3847a1d6154..877d3b72979 100644 --- a/gcc/cp/pt.c +++ b/gcc/cp/pt.c @@ -138,6 +138,7 @@ static int maybe_adjust_types_for_deduction (unification_kind_t, tree*, tree*, tree); static int type_unification_real (tree, tree, tree, const tree *, unsigned int, int, unification_kind_t, int, + vec<deferred_access_check, va_gc> **, bool); static void note_template_header (int); static tree convert_nontype_argument_function (tree, tree); @@ -5619,6 +5620,10 @@ convert_nontype_argument (tree type, tree expr, tsubst_flags_t complain) else return NULL_TREE; } + + /* Avoid typedef problems. */ + if (TREE_TYPE (expr) != type) + expr = fold_convert (type, expr); } /* [temp.arg.nontype]/5, bullet 2 @@ -12551,6 +12556,9 @@ tsubst_copy (tree t, tree args, tsubst_flags_t complain, tree in_decl) case TYPE_DECL: return tsubst (t, args, complain, in_decl); + case USING_DECL: + t = DECL_NAME (t); + /* Fall through. */ case IDENTIFIER_NODE: if (IDENTIFIER_TYPENAME_P (t)) { @@ -15052,7 +15060,6 @@ fn_type_unification (tree fn, return error_mark_node; tinst = build_tree_list (fn, NULL_TREE); ++deduction_depth; - push_deferring_access_checks (dk_deferred); gcc_assert (TREE_CODE (fn) == TEMPLATE_DECL); @@ -15144,8 +15151,13 @@ fn_type_unification (tree fn, } processing_template_decl += incomplete; input_location = DECL_SOURCE_LOCATION (fn); + /* Ignore any access checks; we'll see them again in + instantiate_template and they might have the wrong + access path at this point. */ + push_deferring_access_checks (dk_deferred); fntype = tsubst (TREE_TYPE (fn), explicit_targs, complain | tf_partial, NULL_TREE); + pop_deferring_access_checks (); input_location = loc; processing_template_decl -= incomplete; pop_tinst_level (); @@ -15153,12 +15165,6 @@ fn_type_unification (tree fn, if (fntype == error_mark_node) goto fail; - /* Throw away these access checks; we'll see them again in - instantiate_template and they might have the wrong - access path at this point. */ - pop_deferring_access_checks (); - push_deferring_access_checks (dk_deferred); - /* Place the explicitly specified arguments in TARGS. */ for (i = NUM_TMPL_ARGS (explicit_targs); i--;) TREE_VEC_ELT (targs, i) = TREE_VEC_ELT (explicit_targs, i); @@ -15194,9 +15200,15 @@ fn_type_unification (tree fn, excessive_deduction_depth = true; goto fail; } + + /* type_unification_real will pass back any access checks from default + template argument substitution. */ + vec<deferred_access_check, va_gc> *checks; + checks = NULL; + ok = !type_unification_real (DECL_INNERMOST_TEMPLATE_PARMS (fn), targs, parms, args, nargs, /*subr=*/0, - strict, flags, explain_p); + strict, flags, &checks, explain_p); if (!explain_p) pop_tinst_level (); if (!ok) @@ -15245,16 +15257,23 @@ fn_type_unification (tree fn, excessive_deduction_depth = true; goto fail; } + + /* Also collect access checks from the instantiation. */ + reopen_deferring_access_checks (checks); + decl = instantiate_template (fn, targs, complain); + + checks = get_deferred_access_checks (); + pop_deferring_access_checks (); + pop_tinst_level (); if (decl == error_mark_node) goto fail; - /* Now perform any access checks encountered during deduction, such as - for default template arguments. */ + /* Now perform any access checks encountered during substitution. */ push_access_scope (decl); - ok = perform_deferred_access_checks (complain); + ok = perform_access_checks (checks, complain); pop_access_scope (decl); if (!ok) goto fail; @@ -15283,7 +15302,6 @@ fn_type_unification (tree fn, r = decl; fail: - pop_deferring_access_checks (); --deduction_depth; if (excessive_deduction_depth) { @@ -15684,7 +15702,10 @@ unify_one_argument (tree tparms, tree targs, tree parm, tree arg, If SUBR is 1, we're being called recursively (to unify the arguments of a function or method parameter of a function - template). */ + template). + + CHECKS is a pointer to a vector of access checks encountered while + substituting default template arguments. */ static int type_unification_real (tree tparms, @@ -15695,6 +15716,7 @@ type_unification_real (tree tparms, int subr, unification_kind_t strict, int flags, + vec<deferred_access_check, va_gc> **checks, bool explain_p) { tree parm, arg; @@ -15834,6 +15856,7 @@ type_unification_real (tree tparms, { tree parm = TREE_VALUE (TREE_VEC_ELT (tparms, i)); tree arg = TREE_PURPOSE (TREE_VEC_ELT (tparms, i)); + reopen_deferring_access_checks (*checks); location_t save_loc = input_location; if (DECL_P (parm)) input_location = DECL_SOURCE_LOCATION (parm); @@ -15841,6 +15864,8 @@ type_unification_real (tree tparms, arg = convert_template_argument (parm, arg, targs, complain, i, NULL_TREE); input_location = save_loc; + *checks = get_deferred_access_checks (); + pop_deferring_access_checks (); if (arg == error_mark_node) return 1; else @@ -17307,7 +17332,7 @@ unify (tree tparms, tree targs, tree parm, tree arg, int strict, return type_unification_real (tparms, targs, TYPE_ARG_TYPES (parm), args, nargs, 1, DEDUCE_EXACT, - LOOKUP_NORMAL, explain_p); + LOOKUP_NORMAL, NULL, explain_p); } case OFFSET_TYPE: @@ -20914,7 +20939,7 @@ do_auto_deduction (tree type, tree init, tree auto_node) = build_tree_list (NULL_TREE, TYPE_NAME (auto_node)); val = type_unification_real (tparms, targs, parms, &init, 1, 0, DEDUCE_CALL, LOOKUP_NORMAL, - /*explain_p=*/false); + NULL, /*explain_p=*/false); if (val > 0) { if (processing_template_decl) diff --git a/gcc/cp/semantics.c b/gcc/cp/semantics.c index f8217546b6b..74a6a53dc44 100644 --- a/gcc/cp/semantics.c +++ b/gcc/cp/semantics.c @@ -155,6 +155,17 @@ push_deferring_access_checks (deferring_kind deferring) } } +/* Save the current deferred access states and start deferred access + checking, continuing the set of deferred checks in CHECKS. */ + +void +reopen_deferring_access_checks (vec<deferred_access_check, va_gc> * checks) +{ + push_deferring_access_checks (dk_deferred); + if (!deferred_access_no_check) + deferred_access_stack->last().deferred_access_checks = checks; +} + /* Resume deferring access checks again after we stopped doing this previously. */ @@ -3045,15 +3056,15 @@ finish_id_expression (tree id_expression, /* Disallow uses of local variables from containing functions, except within lambda-expressions. */ - if (!outer_var_p (decl) - /* It's not a use (3.2) if we're in an unevaluated context. */ - || cp_unevaluated_operand) - /* OK. */; - else if (TREE_STATIC (decl)) + if (!outer_var_p (decl)) + /* OK */; + else if (TREE_STATIC (decl) + /* It's not a use (3.2) if we're in an unevaluated context. */ + || cp_unevaluated_operand) { if (processing_template_decl) - /* For a use of an outer static var, return the identifier so - that we'll look it up again in the instantiation. */ + /* For a use of an outer static/unevaluated var, return the id + so that we'll look it up again in the instantiation. */ return id_expression; } else @@ -7186,7 +7197,9 @@ cxx_eval_bit_field_ref (const constexpr_call *call, tree t, return t; /* Don't VERIFY_CONSTANT here; we only want to check that we got a CONSTRUCTOR. */ - if (!*non_constant_p && TREE_CODE (whole) != CONSTRUCTOR) + if (!*non_constant_p + && TREE_CODE (whole) != VECTOR_CST + && TREE_CODE (whole) != CONSTRUCTOR) { if (!allow_non_constant) error ("%qE is not a constant expression", orig_whole); @@ -7195,6 +7208,10 @@ cxx_eval_bit_field_ref (const constexpr_call *call, tree t, if (*non_constant_p) return t; + if (TREE_CODE (whole) == VECTOR_CST) + return fold_ternary (BIT_FIELD_REF, TREE_TYPE (t), whole, + TREE_OPERAND (t, 1), TREE_OPERAND (t, 2)); + start = TREE_OPERAND (t, 2); istart = tree_low_cst (start, 0); isize = tree_low_cst (TREE_OPERAND (t, 1), 0); @@ -7698,11 +7715,6 @@ cxx_eval_indirect_ref (const constexpr_call *call, tree t, { tree sub = op0; STRIP_NOPS (sub); - if (TREE_CODE (sub) == POINTER_PLUS_EXPR) - { - sub = TREE_OPERAND (sub, 0); - STRIP_NOPS (sub); - } if (TREE_CODE (sub) == ADDR_EXPR) { /* We couldn't fold to a constant value. Make sure it's not @@ -9165,7 +9177,7 @@ lambda_capture_field_type (tree expr, bool explicit_init_p) } else type = non_reference (unlowered_expr_type (expr)); - if (!type || WILDCARD_TYPE_P (type)) + if (!type || WILDCARD_TYPE_P (type) || type_uses_auto (type)) { type = cxx_make_type (DECLTYPE_TYPE); DECLTYPE_TYPE_EXPR (type) = expr; diff --git a/gcc/cp/typeck.c b/gcc/cp/typeck.c index 462abdd5039..1d504ad96d6 100644 --- a/gcc/cp/typeck.c +++ b/gcc/cp/typeck.c @@ -6722,12 +6722,12 @@ build_reinterpret_cast_1 (tree type, tree expr, bool c_cast_p, else if ((TYPE_PTRFN_P (type) && TYPE_PTROBV_P (intype)) || (TYPE_PTRFN_P (intype) && TYPE_PTROBV_P (type))) { - if (pedantic && (complain & tf_warning)) - /* Only issue a warning, as we have always supported this - where possible, and it is necessary in some cases. DR 195 - addresses this issue, but as of 2004/10/26 is still in - drafting. */ - warning (0, "ISO C++ forbids casting between pointer-to-function and pointer-to-object"); + if (complain & tf_warning) + /* C++11 5.2.10 p8 says that "Converting a function pointer to an + object pointer type or vice versa is conditionally-supported." */ + warning (OPT_Wconditionally_supported, + "casting between pointer-to-function and pointer-to-object " + "is conditionally-supported"); return fold_if_not_in_template (build_nop (type, expr)); } else if (TREE_CODE (type) == VECTOR_TYPE) @@ -8399,7 +8399,8 @@ check_return_expr (tree retval, bool *no_warning) && VAR_P (retval) && DECL_CONTEXT (retval) == current_function_decl && ! TREE_STATIC (retval) - && ! DECL_ANON_UNION_VAR_P (retval) + /* And not a lambda or anonymous union proxy. */ + && !DECL_HAS_VALUE_EXPR_P (retval) && (DECL_ALIGN (retval) <= DECL_ALIGN (result)) /* The cv-unqualified type of the returned value must be the same as the cv-unqualified return type of the @@ -8444,7 +8445,7 @@ check_return_expr (tree retval, bool *no_warning) Note that these conditions are similar to, but not as strict as, the conditions for the named return value optimization. */ if ((cxx_dialect != cxx98) - && (VAR_P (retval) + && ((VAR_P (retval) && !DECL_HAS_VALUE_EXPR_P (retval)) || TREE_CODE (retval) == PARM_DECL) && DECL_CONTEXT (retval) == current_function_decl && !TREE_STATIC (retval) diff --git a/gcc/doc/avr-mmcu.texi b/gcc/doc/avr-mmcu.texi index b1313c45e9e..838394d2bab 100644 --- a/gcc/doc/avr-mmcu.texi +++ b/gcc/doc/avr-mmcu.texi @@ -38,7 +38,7 @@ @item avr5 ``Enhanced'' devices with 16@tie{}KiB up to 64@tie{}KiB of program memory. -@*@var{mcu}@tie{}= @code{ata5790}, @code{ata5790n}, @code{ata5795}, @code{atmega16}, @code{atmega16a}, @code{atmega16hva}, @code{atmega16hva}, @code{atmega16hva2}, @code{atmega16hva2}, @code{atmega16hvb}, @code{atmega16hvb}, @code{atmega16hvbrevb}, @code{atmega16m1}, @code{atmega16m1}, @code{atmega16u4}, @code{atmega16u4}, @code{atmega161}, @code{atmega162}, @code{atmega163}, @code{atmega164a}, @code{atmega164p}, @code{atmega164pa}, @code{atmega165}, @code{atmega165a}, @code{atmega165p}, @code{atmega165pa}, @code{atmega168}, @code{atmega168a}, @code{atmega168p}, @code{atmega168pa}, @code{atmega169}, @code{atmega169a}, @code{atmega169p}, @code{atmega169pa}, @code{atmega26hvg}, @code{atmega32}, @code{atmega32a}, @code{atmega32a}, @code{atmega32c1}, @code{atmega32c1}, @code{atmega32hvb}, @code{atmega32hvb}, @code{atmega32hvbrevb}, @code{atmega32m1}, @code{atmega32m1}, @code{atmega32u4}, @code{atmega32u4}, @code{atmega32u6}, @code{atmega32u6}, @code{atmega323}, @code{atmega324a}, @code{atmega324p}, @code{atmega324pa}, @code{atmega325}, @code{atmega325a}, @code{atmega325p}, @code{atmega3250}, @code{atmega3250a}, @code{atmega3250p}, @code{atmega3250pa}, @code{atmega328}, @code{atmega328p}, @code{atmega329}, @code{atmega329a}, @code{atmega329p}, @code{atmega329pa}, @code{atmega3290}, @code{atmega3290a}, @code{atmega3290p}, @code{atmega3290pa}, @code{atmega406}, @code{atmega48hvf}, @code{atmega64}, @code{atmega64a}, @code{atmega64c1}, @code{atmega64c1}, @code{atmega64hve}, @code{atmega64m1}, @code{atmega64m1}, @code{atmega64rfa2}, @code{atmega64rfr2}, @code{atmega640}, @code{atmega644}, @code{atmega644a}, @code{atmega644p}, @code{atmega644pa}, @code{atmega645}, @code{atmega645a}, @code{atmega645p}, @code{atmega6450}, @code{atmega6450a}, @code{atmega6450p}, @code{atmega649}, @code{atmega649a}, @code{atmega649p}, @code{atmega6490}, @code{atmega6490a}, @code{atmega6490p}, @code{at90can32}, @code{at90can64}, @code{at90pwm161}, @code{at90pwm216}, @code{at90pwm316}, @code{at90scr100}, @code{at90usb646}, @code{at90usb647}, @code{at94k}, @code{m3000}. +@*@var{mcu}@tie{}= @code{ata5790}, @code{ata5790n}, @code{ata5795}, @code{atmega16}, @code{atmega16a}, @code{atmega16hva}, @code{atmega16hva2}, @code{atmega16hvb}, @code{atmega16hvbrevb}, @code{atmega16m1}, @code{atmega16u4}, @code{atmega161}, @code{atmega162}, @code{atmega163}, @code{atmega164a}, @code{atmega164p}, @code{atmega164pa}, @code{atmega165}, @code{atmega165a}, @code{atmega165p}, @code{atmega165pa}, @code{atmega168}, @code{atmega168a}, @code{atmega168p}, @code{atmega168pa}, @code{atmega169}, @code{atmega169a}, @code{atmega169p}, @code{atmega169pa}, @code{atmega26hvg}, @code{atmega32}, @code{atmega32a}, @code{atmega32c1}, @code{atmega32hvb}, @code{atmega32hvbrevb}, @code{atmega32m1}, @code{atmega32u4}, @code{atmega32u6}, @code{atmega323}, @code{atmega324a}, @code{atmega324p}, @code{atmega324pa}, @code{atmega325}, @code{atmega325a}, @code{atmega325p}, @code{atmega3250}, @code{atmega3250a}, @code{atmega3250p}, @code{atmega3250pa}, @code{atmega328}, @code{atmega328p}, @code{atmega329}, @code{atmega329a}, @code{atmega329p}, @code{atmega329pa}, @code{atmega3290}, @code{atmega3290a}, @code{atmega3290p}, @code{atmega3290pa}, @code{atmega406}, @code{atmega48hvf}, @code{atmega64}, @code{atmega64a}, @code{atmega64c1}, @code{atmega64hve}, @code{atmega64m1}, @code{atmega64rfa2}, @code{atmega64rfr2}, @code{atmega640}, @code{atmega644}, @code{atmega644a}, @code{atmega644p}, @code{atmega644pa}, @code{atmega645}, @code{atmega645a}, @code{atmega645p}, @code{atmega6450}, @code{atmega6450a}, @code{atmega6450p}, @code{atmega649}, @code{atmega649a}, @code{atmega649p}, @code{atmega6490}, @code{atmega6490a}, @code{atmega6490p}, @code{at90can32}, @code{at90can64}, @code{at90pwm161}, @code{at90pwm216}, @code{at90pwm316}, @code{at90scr100}, @code{at90usb646}, @code{at90usb647}, @code{at94k}, @code{m3000}. @item avr51 ``Enhanced'' devices with 128@tie{}KiB of program memory. diff --git a/gcc/doc/invoke.texi b/gcc/doc/invoke.texi index 05f626c130d..9f66cfba2b8 100644 --- a/gcc/doc/invoke.texi +++ b/gcc/doc/invoke.texi @@ -237,7 +237,7 @@ Objective-C and Objective-C++ Dialects}. -Waggressive-loop-optimizations -Warray-bounds @gol -Wno-attributes -Wno-builtin-macro-redefined @gol -Wc++-compat -Wc++11-compat -Wcast-align -Wcast-qual @gol --Wchar-subscripts -Wclobbered -Wcomment @gol +-Wchar-subscripts -Wclobbered -Wcomment -Wconditionally-supported @gol -Wconversion -Wcoverage-mismatch -Wno-cpp -Wno-deprecated @gol -Wno-deprecated-declarations -Wdisabled-optimization @gol -Wno-div-by-zero -Wdouble-promotion -Wempty-body -Wenum-compare @gol @@ -4397,6 +4397,11 @@ programs. Warn for variables that might be changed by @samp{longjmp} or @samp{vfork}. This warning is also enabled by @option{-Wextra}. +@item -Wconditionally-supported @r{(C++ and Objective-C++ only)} +@opindex Wconditionally-supported +@opindex Wno-conditionally-supported +Warn for conditionally-supported (C++11 [intro.defs]) constructs. + @item -Wconversion @opindex Wconversion @opindex Wno-conversion diff --git a/gcc/doc/tm.texi b/gcc/doc/tm.texi index f030b56ef6d..a1010b7c2da 100644 --- a/gcc/doc/tm.texi +++ b/gcc/doc/tm.texi @@ -6040,7 +6040,7 @@ You should define this macro if and only if you define extra CC modes in @file{@var{machine}-modes.def}. @end defmac -@deftypefn {Target Hook} void TARGET_CANONICALIZE_COMPARISON (int *@var{code}, rtx *@var{op0}, rtx *@var{op1}, bool @var{op0_preserve_value}) (@var{code}, @var{op0}, @var{op1}, @var{op0_preserve_value}) +@deftypefn {Target Hook} void TARGET_CANONICALIZE_COMPARISON (int *@var{code}, rtx *@var{op0}, rtx *@var{op1}, bool @var{op0_preserve_value}) On some machines not all possible comparisons are defined, but you can convert an invalid comparison into a valid one. For example, the Alpha does not have a @code{GT} comparison, but you can use an @code{LT} diff --git a/gcc/doc/tm.texi.in b/gcc/doc/tm.texi.in index cc25fec495e..fad6d1044ea 100644 --- a/gcc/doc/tm.texi.in +++ b/gcc/doc/tm.texi.in @@ -698,14 +698,6 @@ should use @code{TARGET_HANDLE_C_OPTION} instead. @hook TARGET_CHECK_STRING_OBJECT_FORMAT_ARG @hook TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE -This target function is similar to the hook @code{TARGET_OPTION_OVERRIDE} -but is called when the optimize level is changed via an attribute or -pragma or when it is reset at the end of the code affected by the -attribute or pragma. It is not called at the beginning of compilation -when @code{TARGET_OPTION_OVERRIDE} is called so if you want to perform these -actions then, you should have @code{TARGET_OPTION_OVERRIDE} call -@code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE}. -@end deftypefn @defmac C_COMMON_OVERRIDE_OPTIONS This is similar to the @code{TARGET_OPTION_OVERRIDE} hook @@ -929,26 +921,6 @@ Do not define this macro if it would never modify @var{m}. @end defmac @hook TARGET_PROMOTE_FUNCTION_MODE -Like @code{PROMOTE_MODE}, but it is applied to outgoing function arguments or -function return values. The target hook should return the new mode -and possibly change @code{*@var{punsignedp}} if the promotion should -change signedness. This function is called only for scalar @emph{or -pointer} types. - -@var{for_return} allows to distinguish the promotion of arguments and -return values. If it is @code{1}, a return value is being promoted and -@code{TARGET_FUNCTION_VALUE} must perform the same promotions done here. -If it is @code{2}, the returned mode should be that of the register in -which an incoming parameter is copied, or the outgoing result is computed; -then the hook should return the same mode as @code{promote_mode}, though -the signedness may be different. - -@var{type} can be NULL when promoting function arguments of libcalls. - -The default is to not promote arguments and return values. You can -also define the hook to @code{default_promote_function_mode_always_promote} -if you would like to apply the same rules given by @code{PROMOTE_MODE}. -@end deftypefn @defmac PARM_BOUNDARY Normal alignment required for function parameters on the stack, in @@ -1234,31 +1206,10 @@ to aligning a bit-field within the structure. @end defmac @hook TARGET_ALIGN_ANON_BITFIELD -When @code{PCC_BITFIELD_TYPE_MATTERS} is true this hook will determine -whether unnamed bitfields affect the alignment of the containing -structure. The hook should return true if the structure should inherit -the alignment requirements of an unnamed bitfield's type. -@end deftypefn @hook TARGET_NARROW_VOLATILE_BITFIELD -This target hook should return @code{true} if accesses to volatile bitfields -should use the narrowest mode possible. It should return @code{false} if -these accesses should use the bitfield container type. - -The default is @code{!TARGET_STRICT_ALIGN}. -@end deftypefn @hook TARGET_MEMBER_TYPE_FORCES_BLK -Return true if a structure, union or array containing @var{field} should -be accessed using @code{BLKMODE}. - -If @var{field} is the only field in the structure, @var{mode} is its -mode, otherwise @var{mode} is VOIDmode. @var{mode} is provided in the -case where structures of one field would require the structure's mode to -retain the field's mode. - -Normally, this is not needed. -@end deftypefn @defmac ROUND_TYPE_ALIGN (@var{type}, @var{computed}, @var{specified}) Define this macro as an expression for the alignment of a type (given @@ -1303,23 +1254,10 @@ pattern needs to support both a 32- and a 64-bit mode. @end defmac @hook TARGET_LIBGCC_CMP_RETURN_MODE -This target hook should return the mode to be used for the return value -of compare instructions expanded to libgcc calls. If not defined -@code{word_mode} is returned which is the right choice for a majority of -targets. -@end deftypefn @hook TARGET_LIBGCC_SHIFT_COUNT_MODE -This target hook should return the mode to be used for the shift count operand -of shift instructions expanded to libgcc calls. If not defined -@code{word_mode} is returned which is the right choice for a majority of -targets. -@end deftypefn @hook TARGET_UNWIND_WORD_MODE -Return machine mode to be used for @code{_Unwind_Word} type. -The default is to use @code{word_mode}. -@end deftypefn @defmac ROUND_TOWARDS_ZERO If defined, this macro should be true if the prevailing rounding @@ -1343,88 +1281,16 @@ The default definition of this macro returns false for all sizes. @end defmac @hook TARGET_MS_BITFIELD_LAYOUT_P -This target hook returns @code{true} if bit-fields in the given -@var{record_type} are to be laid out following the rules of Microsoft -Visual C/C++, namely: (i) a bit-field won't share the same storage -unit with the previous bit-field if their underlying types have -different sizes, and the bit-field will be aligned to the highest -alignment of the underlying types of itself and of the previous -bit-field; (ii) a zero-sized bit-field will affect the alignment of -the whole enclosing structure, even if it is unnamed; except that -(iii) a zero-sized bit-field will be disregarded unless it follows -another bit-field of nonzero size. If this hook returns @code{true}, -other macros that control bit-field layout are ignored. - -When a bit-field is inserted into a packed record, the whole size -of the underlying type is used by one or more same-size adjacent -bit-fields (that is, if its long:3, 32 bits is used in the record, -and any additional adjacent long bit-fields are packed into the same -chunk of 32 bits. However, if the size changes, a new field of that -size is allocated). In an unpacked record, this is the same as using -alignment, but not equivalent when packing. - -If both MS bit-fields and @samp{__attribute__((packed))} are used, -the latter will take precedence. If @samp{__attribute__((packed))} is -used on a single field when MS bit-fields are in use, it will take -precedence for that field, but the alignment of the rest of the structure -may affect its placement. -@end deftypefn @hook TARGET_DECIMAL_FLOAT_SUPPORTED_P -Returns true if the target supports decimal floating point. -@end deftypefn @hook TARGET_FIXED_POINT_SUPPORTED_P -Returns true if the target supports fixed-point arithmetic. -@end deftypefn @hook TARGET_EXPAND_TO_RTL_HOOK -This hook is called just before expansion into rtl, allowing the target -to perform additional initializations or analysis before the expansion. -For example, the rs6000 port uses it to allocate a scratch stack slot -for use in copying SDmode values between memory and floating point -registers whenever the function being expanded has any SDmode -usage. -@end deftypefn @hook TARGET_INSTANTIATE_DECLS -This hook allows the backend to perform additional instantiations on rtl -that are not actually in any insns yet, but will be later. -@end deftypefn @hook TARGET_MANGLE_TYPE -If your target defines any fundamental types, or any types your target -uses should be mangled differently from the default, define this hook -to return the appropriate encoding for these types as part of a C++ -mangled name. The @var{type} argument is the tree structure representing -the type to be mangled. The hook may be applied to trees which are -not target-specific fundamental types; it should return @code{NULL} -for all such types, as well as arguments it does not recognize. If the -return value is not @code{NULL}, it must point to a statically-allocated -string constant. - -Target-specific fundamental types might be new fundamental types or -qualified versions of ordinary fundamental types. Encode new -fundamental types as @samp{@w{u @var{n} @var{name}}}, where @var{name} -is the name used for the type in source code, and @var{n} is the -length of @var{name} in decimal. Encode qualified versions of -ordinary types as @samp{@w{U @var{n} @var{name} @var{code}}}, where -@var{name} is the name used for the type qualifier in source code, -@var{n} is the length of @var{name} as above, and @var{code} is the -code used to represent the unqualified version of this type. (See -@code{write_builtin_type} in @file{cp/mangle.c} for the list of -codes.) In both cases the spaces are for clarity; do not include any -spaces in your string. - -This hook is applied to types prior to typedef resolution. If the mangled -name for a particular type depends only on that type's main variant, you -can perform typedef resolution yourself using @code{TYPE_MAIN_VARIANT} -before mangling. - -The default version of this hook always returns @code{NULL}, which is -appropriate for a target that does not define any new fundamental -types. -@end deftypefn @node Type Layout @section Layout of Source Language Data Types @@ -1619,13 +1485,6 @@ and @option{-funsigned-char}. @end defmac @hook TARGET_DEFAULT_SHORT_ENUMS -This target hook should return true if the compiler should give an -@code{enum} type only as many bytes as it takes to represent the range -of possible values of that type. It should return false if all -@code{enum} types should be allocated like @code{int}. - -The default is to return false. -@end deftypefn @defmac SIZE_TYPE A C expression for a string describing the name of the data type to use @@ -1921,36 +1780,6 @@ preserve the entire contents of a register across a call. @findex reg_names @findex reg_class_contents @hook TARGET_CONDITIONAL_REGISTER_USAGE -This hook may conditionally modify five variables -@code{fixed_regs}, @code{call_used_regs}, @code{global_regs}, -@code{reg_names}, and @code{reg_class_contents}, to take into account -any dependence of these register sets on target flags. The first three -of these are of type @code{char []} (interpreted as Boolean vectors). -@code{global_regs} is a @code{const char *[]}, and -@code{reg_class_contents} is a @code{HARD_REG_SET}. Before the macro is -called, @code{fixed_regs}, @code{call_used_regs}, -@code{reg_class_contents}, and @code{reg_names} have been initialized -from @code{FIXED_REGISTERS}, @code{CALL_USED_REGISTERS}, -@code{REG_CLASS_CONTENTS}, and @code{REGISTER_NAMES}, respectively. -@code{global_regs} has been cleared, and any @option{-ffixed-@var{reg}}, -@option{-fcall-used-@var{reg}} and @option{-fcall-saved-@var{reg}} -command options have been applied. - -@cindex disabling certain registers -@cindex controlling register usage -If the usage of an entire class of registers depends on the target -flags, you may indicate this to GCC by using this macro to modify -@code{fixed_regs} and @code{call_used_regs} to 1 for each of the -registers in the classes which should not be used by GCC@. Also define -the macro @code{REG_CLASS_FROM_LETTER} / @code{REG_CLASS_FROM_CONSTRAINT} -to return @code{NO_REGS} if it -is called with a letter for a class that shouldn't be used. - -(However, if this class is not included in @code{GENERAL_REGS} and all -of the insn patterns whose constraints permit this class are -controlled by target switches, then GCC will automatically avoid using -these registers when the target switches are opposed to them.) -@end deftypefn @defmac INCOMING_REGNO (@var{out}) Define this macro if the target machine has register windows. This C @@ -2188,14 +2017,6 @@ allocation. @end defmac @hook TARGET_HARD_REGNO_SCRATCH_OK -This target hook should return @code{true} if it is OK to use a hard register -@var{regno} as scratch reg in peephole2. - -One common use of this macro is to prevent using of a register that -is not saved by a prologue in an interrupt handler. - -The default version of this hook always returns @code{true}. -@end deftypefn @defmac AVOID_CCMODE_COPIES Define this macro if the compiler should avoid copies to/from @code{CCmode} @@ -2523,38 +2344,6 @@ only if neither labeling works. @hook TARGET_PREFERRED_RENAME_CLASS @hook TARGET_PREFERRED_RELOAD_CLASS -A target hook that places additional restrictions on the register class -to use when it is necessary to copy value @var{x} into a register in class -@var{rclass}. The value is a register class; perhaps @var{rclass}, or perhaps -another, smaller class. - -The default version of this hook always returns value of @code{rclass} argument. - -Sometimes returning a more restrictive class makes better code. For -example, on the 68000, when @var{x} is an integer constant that is in range -for a @samp{moveq} instruction, the value of this macro is always -@code{DATA_REGS} as long as @var{rclass} includes the data registers. -Requiring a data register guarantees that a @samp{moveq} will be used. - -One case where @code{TARGET_PREFERRED_RELOAD_CLASS} must not return -@var{rclass} is if @var{x} is a legitimate constant which cannot be -loaded into some register class. By returning @code{NO_REGS} you can -force @var{x} into a memory location. For example, rs6000 can load -immediate values into general-purpose registers, but does not have an -instruction for loading an immediate value into a floating-point -register, so @code{TARGET_PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when -@var{x} is a floating-point constant. If the constant can't be loaded -into any kind of register, code generation will be better if -@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead -of using @code{TARGET_PREFERRED_RELOAD_CLASS}. - -If an insn has pseudos in it after register allocation, reload will go -through the alternatives and call repeatedly @code{TARGET_PREFERRED_RELOAD_CLASS} -to find the best one. Returning @code{NO_REGS}, in this case, makes -reload add a @code{!} in front of the constraint: the x86 back-end uses -this feature to discourage usage of 387 registers when math is done in -the SSE registers (and vice versa). -@end deftypefn @defmac PREFERRED_RELOAD_CLASS (@var{x}, @var{class}) A C expression that places additional restrictions on the register class @@ -2594,15 +2383,6 @@ the SSE registers (and vice versa). @end defmac @hook TARGET_PREFERRED_OUTPUT_RELOAD_CLASS -Like @code{TARGET_PREFERRED_RELOAD_CLASS}, but for output reloads instead of -input reloads. - -The default version of this hook always returns value of @code{rclass} -argument. - -You can also use @code{TARGET_PREFERRED_OUTPUT_RELOAD_CLASS} to discourage -reload from using some alternatives, like @code{TARGET_PREFERRED_RELOAD_CLASS}. -@end deftypefn @defmac LIMIT_RELOAD_CLASS (@var{mode}, @var{class}) A C expression that places additional restrictions on the register class @@ -2621,90 +2401,6 @@ require the macro to do something nontrivial. @end defmac @hook TARGET_SECONDARY_RELOAD -Many machines have some registers that cannot be copied directly to or -from memory or even from other types of registers. An example is the -@samp{MQ} register, which on most machines, can only be copied to or -from general registers, but not memory. Below, we shall be using the -term 'intermediate register' when a move operation cannot be performed -directly, but has to be done by copying the source into the intermediate -register first, and then copying the intermediate register to the -destination. An intermediate register always has the same mode as -source and destination. Since it holds the actual value being copied, -reload might apply optimizations to re-use an intermediate register -and eliding the copy from the source when it can determine that the -intermediate register still holds the required value. - -Another kind of secondary reload is required on some machines which -allow copying all registers to and from memory, but require a scratch -register for stores to some memory locations (e.g., those with symbolic -address on the RT, and those with certain symbolic address on the SPARC -when compiling PIC)@. Scratch registers need not have the same mode -as the value being copied, and usually hold a different value than -that being copied. Special patterns in the md file are needed to -describe how the copy is performed with the help of the scratch register; -these patterns also describe the number, register class(es) and mode(s) -of the scratch register(s). - -In some cases, both an intermediate and a scratch register are required. - -For input reloads, this target hook is called with nonzero @var{in_p}, -and @var{x} is an rtx that needs to be copied to a register of class -@var{reload_class} in @var{reload_mode}. For output reloads, this target -hook is called with zero @var{in_p}, and a register of class @var{reload_class} -needs to be copied to rtx @var{x} in @var{reload_mode}. - -If copying a register of @var{reload_class} from/to @var{x} requires -an intermediate register, the hook @code{secondary_reload} should -return the register class required for this intermediate register. -If no intermediate register is required, it should return NO_REGS. -If more than one intermediate register is required, describe the one -that is closest in the copy chain to the reload register. - -If scratch registers are needed, you also have to describe how to -perform the copy from/to the reload register to/from this -closest intermediate register. Or if no intermediate register is -required, but still a scratch register is needed, describe the -copy from/to the reload register to/from the reload operand @var{x}. - -You do this by setting @code{sri->icode} to the instruction code of a pattern -in the md file which performs the move. Operands 0 and 1 are the output -and input of this copy, respectively. Operands from operand 2 onward are -for scratch operands. These scratch operands must have a mode, and a -single-register-class -@c [later: or memory] -output constraint. - -When an intermediate register is used, the @code{secondary_reload} -hook will be called again to determine how to copy the intermediate -register to/from the reload operand @var{x}, so your hook must also -have code to handle the register class of the intermediate operand. - -@c [For later: maybe we'll allow multi-alternative reload patterns - -@c the port maintainer could name a mov<mode> pattern that has clobbers - -@c and match the constraints of input and output to determine the required -@c alternative. A restriction would be that constraints used to match -@c against reloads registers would have to be written as register class -@c constraints, or we need a new target macro / hook that tells us if an -@c arbitrary constraint can match an unknown register of a given class. -@c Such a macro / hook would also be useful in other places.] - - -@var{x} might be a pseudo-register or a @code{subreg} of a -pseudo-register, which could either be in a hard register or in memory. -Use @code{true_regnum} to find out; it will return @minus{}1 if the pseudo is -in memory and the hard register number if it is in a register. - -Scratch operands in memory (constraint @code{"=m"} / @code{"=&m"}) are -currently not supported. For the time being, you will have to continue -to use @code{SECONDARY_MEMORY_NEEDED} for that purpose. - -@code{copy_cost} also uses this target hook to find out how values are -copied. If you want it to include some extra cost for the need to allocate -(a) scratch register(s), set @code{sri->extra_cost} to the additional cost. -Or if two dependent moves are supposed to have a lower cost than the sum -of the individual moves due to expected fortuitous scheduling and/or special -forwarding logic, you can set @code{sri->extra_cost} to a negative amount. -@end deftypefn @defmac SECONDARY_RELOAD_CLASS (@var{class}, @var{mode}, @var{x}) @defmacx SECONDARY_INPUT_RELOAD_CLASS (@var{class}, @var{mode}, @var{x}) @@ -2812,37 +2508,8 @@ is @code{BITS_PER_WORD} bits wide is correct for your machine. @end defmac @hook TARGET_CLASS_LIKELY_SPILLED_P -A target hook which returns @code{true} if pseudos that have been assigned -to registers of class @var{rclass} would likely be spilled because -registers of @var{rclass} are needed for spill registers. - -The default version of this target hook returns @code{true} if @var{rclass} -has exactly one register and @code{false} otherwise. On most machines, this -default should be used. For generally register-starved machines, such as -i386, or machines with right register constraints, such as SH, this hook -can be used to avoid excessive spilling. - -This hook is also used by some of the global intra-procedural code -transformations to throtle code motion, to avoid increasing register -pressure. -@end deftypefn @hook TARGET_CLASS_MAX_NREGS -A target hook returns the maximum number of consecutive registers -of class @var{rclass} needed to hold a value of mode @var{mode}. - -This is closely related to the macro @code{HARD_REGNO_NREGS}. In fact, -the value returned by @code{TARGET_CLASS_MAX_NREGS (@var{rclass}, -@var{mode})} target hook should be the maximum value of -@code{HARD_REGNO_NREGS (@var{regno}, @var{mode})} for all @var{regno} -values in the class @var{rclass}. - -This target hook helps control the handling of multiple-word values -in the reload pass. - -The default version of this target hook returns the size of @var{mode} -in words. -@end deftypefn @defmac CLASS_MAX_NREGS (@var{class}, @var{mode}) A C expression for the maximum number of consecutive registers @@ -3178,12 +2845,6 @@ define this macro. @end defmac @hook TARGET_BUILTIN_SETJMP_FRAME_VALUE -This target hook should return an rtx that is used to store -the address of the current frame into the built in @code{setjmp} buffer. -The default value, @code{virtual_stack_vars_rtx}, is correct for most -machines. One reason you may need to define this target hook is if -@code{hard_frame_pointer_rtx} is the appropriate value on your machine. -@end deftypefn @defmac FRAME_ADDR_RTX (@var{frameaddr}) A C expression whose value is RTL representing the value of the frame @@ -3245,20 +2906,6 @@ terminate the stack backtrace. New ports should avoid this. @end defmac @hook TARGET_DWARF_HANDLE_FRAME_UNSPEC -This target hook allows the backend to emit frame-related insns that -contain UNSPECs or UNSPEC_VOLATILEs. The DWARF 2 call frame debugging -info engine will invoke it on insns of the form -@smallexample -(set (reg) (unspec [@dots{}] UNSPEC_INDEX)) -@end smallexample -and -@smallexample -(set (reg) (unspec_volatile [@dots{}] UNSPECV_INDEX)). -@end smallexample -to let the backend emit the call frame instructions. @var{label} is -the CFI label attached to the insn, @var{pattern} is the pattern of -the insn and @var{index} is @code{UNSPEC_INDEX} or @code{UNSPECV_INDEX}. -@end deftypefn @defmac INCOMING_FRAME_SP_OFFSET A C expression whose value is an integer giving the offset, in bytes, @@ -3641,26 +3288,6 @@ defined; instead, the @code{TARGET_STATIC_CHAIN} hook should be used. @end defmac @hook TARGET_STATIC_CHAIN -This hook replaces the use of @code{STATIC_CHAIN_REGNUM} et al for -targets that may use different static chain locations for different -nested functions. This may be required if the target has function -attributes that affect the calling conventions of the function and -those calling conventions use different static chain locations. - -The default version of this hook uses @code{STATIC_CHAIN_REGNUM} et al. - -If the static chain is passed in memory, this hook should be used to -provide rtx giving @code{mem} expressions that denote where they are stored. -Often the @code{mem} expression as seen by the caller will be at an offset -from the stack pointer and the @code{mem} expression as seen by the callee -will be at an offset from the frame pointer. -@findex stack_pointer_rtx -@findex frame_pointer_rtx -@findex arg_pointer_rtx -The variables @code{stack_pointer_rtx}, @code{frame_pointer_rtx}, and -@code{arg_pointer_rtx} will have been initialized and should be used -to refer to those items. -@end deftypefn @defmac DWARF_FRAME_REGISTERS This macro specifies the maximum number of hard registers that can be @@ -3743,29 +3370,6 @@ defined and 0 otherwise. This is about eliminating the frame pointer and arg pointer. @hook TARGET_FRAME_POINTER_REQUIRED -This target hook should return @code{true} if a function must have and use -a frame pointer. This target hook is called in the reload pass. If its return -value is @code{true} the function will have a frame pointer. - -This target hook can in principle examine the current function and decide -according to the facts, but on most machines the constant @code{false} or the -constant @code{true} suffices. Use @code{false} when the machine allows code -to be generated with no frame pointer, and doing so saves some time or space. -Use @code{true} when there is no possible advantage to avoiding a frame -pointer. - -In certain cases, the compiler does not know how to produce valid code -without a frame pointer. The compiler recognizes those cases and -automatically gives the function a frame pointer regardless of what -@code{TARGET_FRAME_POINTER_REQUIRED} returns. You don't need to worry about -them. - -In a function that does not require a frame pointer, the frame pointer -register can be allocated for ordinary usage, unless you mark it as a -fixed register. See @code{FIXED_REGISTERS} for more information. - -Default return value is @code{false}. -@end deftypefn @findex get_frame_size @defmac INITIAL_FRAME_POINTER_OFFSET (@var{depth-var}) @@ -3809,15 +3413,6 @@ specified first since that is the preferred elimination. @end defmac @hook TARGET_CAN_ELIMINATE -This target hook should returns @code{true} if the compiler is allowed to -try to replace register number @var{from_reg} with register number -@var{to_reg}. This target hook need only be defined if @code{ELIMINABLE_REGS} -is defined, and will usually be @code{true}, since most of the cases -preventing register elimination are things that the compiler already -knows about. - -Default return value is @code{true}. -@end deftypefn @defmac INITIAL_ELIMINATION_OFFSET (@var{from-reg}, @var{to-reg}, @var{offset-var}) This macro is similar to @code{INITIAL_FRAME_POINTER_OFFSET}. It @@ -3836,12 +3431,6 @@ on the stack. See the following section for other macros that control passing certain arguments in registers. @hook TARGET_PROMOTE_PROTOTYPES -This target hook returns @code{true} if an argument declared in a -prototype as an integral type smaller than @code{int} should actually be -passed as an @code{int}. In addition to avoiding errors in certain -cases of mismatch, it also makes for better code on certain machines. -The default is to not promote prototypes. -@end deftypefn @defmac PUSH_ARGS A C expression. If nonzero, push insns will be used to pass @@ -3936,42 +3525,6 @@ stack in its natural location. @end defmac @hook TARGET_RETURN_POPS_ARGS -This target hook returns the number of bytes of its own arguments that -a function pops on returning, or 0 if the function pops no arguments -and the caller must therefore pop them all after the function returns. - -@var{fundecl} is a C variable whose value is a tree node that describes -the function in question. Normally it is a node of type -@code{FUNCTION_DECL} that describes the declaration of the function. -From this you can obtain the @code{DECL_ATTRIBUTES} of the function. - -@var{funtype} is a C variable whose value is a tree node that -describes the function in question. Normally it is a node of type -@code{FUNCTION_TYPE} that describes the data type of the function. -From this it is possible to obtain the data types of the value and -arguments (if known). - -When a call to a library function is being considered, @var{fundecl} -will contain an identifier node for the library function. Thus, if -you need to distinguish among various library functions, you can do so -by their names. Note that ``library function'' in this context means -a function used to perform arithmetic, whose name is known specially -in the compiler and was not mentioned in the C code being compiled. - -@var{size} is the number of bytes of arguments passed on the -stack. If a variable number of bytes is passed, it is zero, and -argument popping will always be the responsibility of the calling function. - -On the VAX, all functions always pop their arguments, so the definition -of this macro is @var{size}. On the 68000, using the standard -calling convention, no functions pop their arguments, so the value of -the macro is always 0 in this case. But an alternative calling -convention is available in which functions that take a fixed number of -arguments pop them but other functions (such as @code{printf}) pop -nothing (the caller pops all). When this convention is in use, -@var{funtype} is examined to determine whether a function takes a fixed -number of arguments. -@end deftypefn @defmac CALL_POPS_ARGS (@var{cum}) A C expression that should indicate the number of bytes a call sequence @@ -3998,124 +3551,16 @@ types of arguments are passed in registers or how they are arranged in the stack. @hook TARGET_FUNCTION_ARG -Return an RTX indicating whether a function argument is passed in a -register and if so, which register. - -The arguments are @var{ca}, which summarizes all the previous -arguments; @var{mode}, the machine mode of the argument; @var{type}, -the data type of the argument as a tree node or 0 if that is not known -(which happens for C support library functions); and @var{named}, -which is @code{true} for an ordinary argument and @code{false} for -nameless arguments that correspond to @samp{@dots{}} in the called -function's prototype. @var{type} can be an incomplete type if a -syntax error has previously occurred. - -The return value is usually either a @code{reg} RTX for the hard -register in which to pass the argument, or zero to pass the argument -on the stack. - -The value of the expression can also be a @code{parallel} RTX@. This is -used when an argument is passed in multiple locations. The mode of the -@code{parallel} should be the mode of the entire argument. The -@code{parallel} holds any number of @code{expr_list} pairs; each one -describes where part of the argument is passed. In each -@code{expr_list} the first operand must be a @code{reg} RTX for the hard -register in which to pass this part of the argument, and the mode of the -register RTX indicates how large this part of the argument is. The -second operand of the @code{expr_list} is a @code{const_int} which gives -the offset in bytes into the entire argument of where this part starts. -As a special exception the first @code{expr_list} in the @code{parallel} -RTX may have a first operand of zero. This indicates that the entire -argument is also stored on the stack. - -The last time this hook is called, it is called with @code{MODE == -VOIDmode}, and its result is passed to the @code{call} or @code{call_value} -pattern as operands 2 and 3 respectively. - -@cindex @file{stdarg.h} and register arguments -The usual way to make the ISO library @file{stdarg.h} work on a -machine where some arguments are usually passed in registers, is to -cause nameless arguments to be passed on the stack instead. This is -done by making @code{TARGET_FUNCTION_ARG} return 0 whenever -@var{named} is @code{false}. - -@cindex @code{TARGET_MUST_PASS_IN_STACK}, and @code{TARGET_FUNCTION_ARG} -@cindex @code{REG_PARM_STACK_SPACE}, and @code{TARGET_FUNCTION_ARG} -You may use the hook @code{targetm.calls.must_pass_in_stack} -in the definition of this macro to determine if this argument is of a -type that must be passed in the stack. If @code{REG_PARM_STACK_SPACE} -is not defined and @code{TARGET_FUNCTION_ARG} returns nonzero for such an -argument, the compiler will abort. If @code{REG_PARM_STACK_SPACE} is -defined, the argument will be computed in the stack and then loaded into -a register. -@end deftypefn @hook TARGET_MUST_PASS_IN_STACK -This target hook should return @code{true} if we should not pass @var{type} -solely in registers. The file @file{expr.h} defines a -definition that is usually appropriate, refer to @file{expr.h} for additional -documentation. -@end deftypefn @hook TARGET_FUNCTION_INCOMING_ARG -Define this hook if the target machine has ``register windows'', so -that the register in which a function sees an arguments is not -necessarily the same as the one in which the caller passed the -argument. - -For such machines, @code{TARGET_FUNCTION_ARG} computes the register in -which the caller passes the value, and -@code{TARGET_FUNCTION_INCOMING_ARG} should be defined in a similar -fashion to tell the function being called where the arguments will -arrive. - -If @code{TARGET_FUNCTION_INCOMING_ARG} is not defined, -@code{TARGET_FUNCTION_ARG} serves both purposes. -@end deftypefn @hook TARGET_ARG_PARTIAL_BYTES -This target hook returns the number of bytes at the beginning of an -argument that must be put in registers. The value must be zero for -arguments that are passed entirely in registers or that are entirely -pushed on the stack. - -On some machines, certain arguments must be passed partially in -registers and partially in memory. On these machines, typically the -first few words of arguments are passed in registers, and the rest -on the stack. If a multi-word argument (a @code{double} or a -structure) crosses that boundary, its first few words must be passed -in registers and the rest must be pushed. This macro tells the -compiler when this occurs, and how many bytes should go in registers. - -@code{TARGET_FUNCTION_ARG} for these arguments should return the first -register to be used by the caller for this argument; likewise -@code{TARGET_FUNCTION_INCOMING_ARG}, for the called function. -@end deftypefn @hook TARGET_PASS_BY_REFERENCE -This target hook should return @code{true} if an argument at the -position indicated by @var{cum} should be passed by reference. This -predicate is queried after target independent reasons for being -passed by reference, such as @code{TREE_ADDRESSABLE (type)}. - -If the hook returns true, a copy of that argument is made in memory and a -pointer to the argument is passed instead of the argument itself. -The pointer is passed in whatever way is appropriate for passing a pointer -to that type. -@end deftypefn @hook TARGET_CALLEE_COPIES -The function argument described by the parameters to this hook is -known to be passed by reference. The hook should return true if the -function argument should be copied by the callee instead of copied -by the caller. - -For any argument for which the hook returns true, if it can be -determined that the argument is not modified, then a copy need -not be generated. - -The default version of this hook always returns false. -@end deftypefn @defmac CUMULATIVE_ARGS A C type for declaring a variable that is used as the first argument @@ -4184,16 +3629,6 @@ argument @var{libname} exists for symmetry with @end defmac @hook TARGET_FUNCTION_ARG_ADVANCE -This hook updates the summarizer variable pointed to by @var{ca} to -advance past an argument in the argument list. The values @var{mode}, -@var{type} and @var{named} describe that argument. Once this is done, -the variable @var{cum} is suitable for analyzing the @emph{following} -argument with @code{TARGET_FUNCTION_ARG}, etc. - -This hook need not do anything if the argument in question was passed -on the stack. The compiler knows how to track the amount of stack space -used for arguments without any special help. -@end deftypefn @defmac FUNCTION_ARG_OFFSET (@var{mode}, @var{type}) If defined, a C expression that is the number of bytes to add to the @@ -4239,10 +3674,6 @@ required. @end defmac @hook TARGET_FUNCTION_ARG_BOUNDARY -This hook returns the alignment boundary, in bits, of an argument -with the specified mode and type. The default hook returns -@code{PARM_BOUNDARY} for all arguments. -@end deftypefn @hook TARGET_FUNCTION_ARG_ROUND_BOUNDARY @@ -4256,115 +3687,28 @@ stack. @end defmac @hook TARGET_SPLIT_COMPLEX_ARG -This hook should return true if parameter of type @var{type} are passed -as two scalar parameters. By default, GCC will attempt to pack complex -arguments into the target's word size. Some ABIs require complex arguments -to be split and treated as their individual components. For example, on -AIX64, complex floats should be passed in a pair of floating point -registers, even though a complex float would fit in one 64-bit floating -point register. - -The default value of this hook is @code{NULL}, which is treated as always -false. -@end deftypefn @hook TARGET_BUILD_BUILTIN_VA_LIST -This hook returns a type node for @code{va_list} for the target. -The default version of the hook returns @code{void*}. -@end deftypefn @hook TARGET_ENUM_VA_LIST_P -This target hook is used in function @code{c_common_nodes_and_builtins} -to iterate through the target specific builtin types for va_list. The -variable @var{idx} is used as iterator. @var{pname} has to be a pointer -to a @code{const char *} and @var{ptree} a pointer to a @code{tree} typed -variable. -The arguments @var{pname} and @var{ptree} are used to store the result of -this macro and are set to the name of the va_list builtin type and its -internal type. -If the return value of this macro is zero, then there is no more element. -Otherwise the @var{IDX} should be increased for the next call of this -macro to iterate through all types. -@end deftypefn @hook TARGET_FN_ABI_VA_LIST -This hook returns the va_list type of the calling convention specified by -@var{fndecl}. -The default version of this hook returns @code{va_list_type_node}. -@end deftypefn @hook TARGET_CANONICAL_VA_LIST_TYPE -This hook returns the va_list type of the calling convention specified by the -type of @var{type}. If @var{type} is not a valid va_list type, it returns -@code{NULL_TREE}. -@end deftypefn @hook TARGET_GIMPLIFY_VA_ARG_EXPR -This hook performs target-specific gimplification of -@code{VA_ARG_EXPR}. The first two parameters correspond to the -arguments to @code{va_arg}; the latter two are as in -@code{gimplify.c:gimplify_expr}. -@end deftypefn @hook TARGET_VALID_POINTER_MODE -Define this to return nonzero if the port can handle pointers -with machine mode @var{mode}. The default version of this -hook returns true for both @code{ptr_mode} and @code{Pmode}. -@end deftypefn @hook TARGET_REF_MAY_ALIAS_ERRNO @hook TARGET_SCALAR_MODE_SUPPORTED_P -Define this to return nonzero if the port is prepared to handle -insns involving scalar mode @var{mode}. For a scalar mode to be -considered supported, all the basic arithmetic and comparisons -must work. - -The default version of this hook returns true for any mode -required to handle the basic C types (as defined by the port). -Included here are the double-word arithmetic supported by the -code in @file{optabs.c}. -@end deftypefn @hook TARGET_VECTOR_MODE_SUPPORTED_P -Define this to return nonzero if the port is prepared to handle -insns involving vector mode @var{mode}. At the very least, it -must have move patterns for this mode. -@end deftypefn @hook TARGET_ARRAY_MODE_SUPPORTED_P @hook TARGET_SMALL_REGISTER_CLASSES_FOR_MODE_P -Define this to return nonzero for machine modes for which the port has -small register classes. If this target hook returns nonzero for a given -@var{mode}, the compiler will try to minimize the lifetime of registers -in @var{mode}. The hook may be called with @code{VOIDmode} as argument. -In this case, the hook is expected to return nonzero if it returns nonzero -for any mode. - -On some machines, it is risky to let hard registers live across arbitrary -insns. Typically, these machines have instructions that require values -to be in specific registers (like an accumulator), and reload will fail -if the required hard register is used for another purpose across such an -insn. - -Passes before reload do not know which hard registers will be used -in an instruction, but the machine modes of the registers set or used in -the instruction are already known. And for some machines, register -classes are small for, say, integer registers but not for floating point -registers. For example, the AMD x86-64 architecture requires specific -registers for the legacy x86 integer instructions, but there are many -SSE registers for floating point operations. On such targets, a good -strategy may be to return nonzero from this hook for @code{INTEGRAL_MODE_P} -machine modes but zero for the SSE register classes. - -The default version of this hook returns false for any mode. It is always -safe to redefine this hook to return with a nonzero value. But if you -unnecessarily define it, you will reduce the amount of optimizations -that can be performed in some cases. If you do not define this hook -to return a nonzero value when it is required, the compiler will run out -of spill registers and print a fatal error message. -@end deftypefn @hook TARGET_FLAGS_REGNUM @@ -4379,48 +3723,6 @@ values---values that can fit in registers. @hook TARGET_FUNCTION_VALUE -Define this to return an RTX representing the place where a function -returns or receives a value of data type @var{ret_type}, a tree node -representing a data type. @var{fn_decl_or_type} is a tree node -representing @code{FUNCTION_DECL} or @code{FUNCTION_TYPE} of a -function being called. If @var{outgoing} is false, the hook should -compute the register in which the caller will see the return value. -Otherwise, the hook should return an RTX representing the place where -a function returns a value. - -On many machines, only @code{TYPE_MODE (@var{ret_type})} is relevant. -(Actually, on most machines, scalar values are returned in the same -place regardless of mode.) The value of the expression is usually a -@code{reg} RTX for the hard register where the return value is stored. -The value can also be a @code{parallel} RTX, if the return value is in -multiple places. See @code{TARGET_FUNCTION_ARG} for an explanation of the -@code{parallel} form. Note that the callee will populate every -location specified in the @code{parallel}, but if the first element of -the @code{parallel} contains the whole return value, callers will use -that element as the canonical location and ignore the others. The m68k -port uses this type of @code{parallel} to return pointers in both -@samp{%a0} (the canonical location) and @samp{%d0}. - -If @code{TARGET_PROMOTE_FUNCTION_RETURN} returns true, you must apply -the same promotion rules specified in @code{PROMOTE_MODE} if -@var{valtype} is a scalar type. - -If the precise function being called is known, @var{func} is a tree -node (@code{FUNCTION_DECL}) for it; otherwise, @var{func} is a null -pointer. This makes it possible to use a different value-returning -convention for specific functions when all their calls are -known. - -Some target machines have ``register windows'' so that the register in -which a function returns its value is not the same as the one in which -the caller sees the value. For such machines, you should return -different RTX depending on @var{outgoing}. - -@code{TARGET_FUNCTION_VALUE} is not used for return values with -aggregate data types, because these are returned in another way. See -@code{TARGET_STRUCT_VALUE_RTX} and related macros, below. -@end deftypefn - @defmac FUNCTION_VALUE (@var{valtype}, @var{func}) This macro has been deprecated. Use @code{TARGET_FUNCTION_VALUE} for a new target instead. @@ -4437,15 +3739,6 @@ compiled. @end defmac @hook TARGET_LIBCALL_VALUE -Define this hook if the back-end needs to know the name of the libcall -function in order to determine where the result should be returned. - -The mode of the result is given by @var{mode} and the name of the called -library function is given by @var{fun}. The hook should return an RTX -representing the place where the library function result will be returned. - -If this hook is not defined, then LIBCALL_VALUE will be used. -@end deftypefn @defmac FUNCTION_VALUE_REGNO_P (@var{regno}) A C expression that is nonzero if @var{regno} is the number of a hard @@ -4469,19 +3762,6 @@ for a new target instead. @end defmac @hook TARGET_FUNCTION_VALUE_REGNO_P -A target hook that return @code{true} if @var{regno} is the number of a hard -register in which the values of called function may come back. - -A register whose use for returning values is limited to serving as the -second of a pair (for a value of type @code{double}, say) need not be -recognized by this target hook. - -If the machine has register windows, so that the caller and the called -function use different registers for the return value, this target hook -should recognize only the caller's register numbers. - -If this hook is not defined, then FUNCTION_VALUE_REGNO_P will be used. -@end deftypefn @defmac APPLY_RESULT_SIZE Define this macro if @samp{untyped_call} and @samp{untyped_return} @@ -4490,17 +3770,6 @@ saving and restoring an arbitrary return value. @end defmac @hook TARGET_RETURN_IN_MSB -This hook should return true if values of type @var{type} are returned -at the most significant end of a register (in other words, if they are -padded at the least significant end). You can assume that @var{type} -is returned in a register; the caller is required to check this. - -Note that the register provided by @code{TARGET_FUNCTION_VALUE} must -be able to hold the complete return value. For example, if a 1-, 2- -or 3-byte structure is returned at the most significant end of a -4-byte register, @code{TARGET_FUNCTION_VALUE} should provide an -@code{SImode} rtx. -@end deftypefn @node Aggregate Return @subsection How Large Values Are Returned @@ -4520,23 +3789,6 @@ This section describes how to control returning structure values in memory. @hook TARGET_RETURN_IN_MEMORY -This target hook should return a nonzero value to say to return the -function value in memory, just as large structures are always returned. -Here @var{type} will be the data type of the value, and @var{fntype} -will be the type of the function doing the returning, or @code{NULL} for -libcalls. - -Note that values of mode @code{BLKmode} must be explicitly handled -by this function. Also, the option @option{-fpcc-struct-return} -takes effect regardless of this macro. On most systems, it is -possible to leave the hook undefined; this causes a default -definition to be used, whose value is the constant 1 for @code{BLKmode} -values, and 0 otherwise. - -Do not use this hook to indicate that structures and unions should always -be returned in memory. You should instead use @code{DEFAULT_PCC_STRUCT_RETURN} -to indicate this. -@end deftypefn @defmac DEFAULT_PCC_STRUCT_RETURN Define this macro to be 1 if all structure and union return values must be @@ -4550,27 +3802,6 @@ If not defined, this defaults to the value 1. @end defmac @hook TARGET_STRUCT_VALUE_RTX -This target hook should return the location of the structure value -address (normally a @code{mem} or @code{reg}), or 0 if the address is -passed as an ``invisible'' first argument. Note that @var{fndecl} may -be @code{NULL}, for libcalls. You do not need to define this target -hook if the address is always passed as an ``invisible'' first -argument. - -On some architectures the place where the structure value address -is found by the called function is not the same place that the -caller put it. This can be due to register windows, or it could -be because the function prologue moves it to a different place. -@var{incoming} is @code{1} or @code{2} when the location is needed in -the context of the called function, and @code{0} in the context of -the caller. - -If @var{incoming} is nonzero and the address is to be found on the -stack, return a @code{mem} which refers to the frame pointer. If -@var{incoming} is @code{2}, the result is being used to fetch the -structure value address at the beginning of a function. If you need -to emit adjusting code, you should do it at this point. -@end deftypefn @defmac PCC_STATIC_STRUCT_RETURN Define this macro if the usual system convention on the target machine @@ -4623,110 +3854,12 @@ This section describes the macros that output function entry (@dfn{prologue}) and exit (@dfn{epilogue}) code. @hook TARGET_ASM_FUNCTION_PROLOGUE -If defined, a function that outputs the assembler code for entry to a -function. The prologue is responsible for setting up the stack frame, -initializing the frame pointer register, saving registers that must be -saved, and allocating @var{size} additional bytes of storage for the -local variables. @var{size} is an integer. @var{file} is a stdio -stream to which the assembler code should be output. - -The label for the beginning of the function need not be output by this -macro. That has already been done when the macro is run. - -@findex regs_ever_live -To determine which registers to save, the macro can refer to the array -@code{regs_ever_live}: element @var{r} is nonzero if hard register -@var{r} is used anywhere within the function. This implies the function -prologue should save register @var{r}, provided it is not one of the -call-used registers. (@code{TARGET_ASM_FUNCTION_EPILOGUE} must likewise use -@code{regs_ever_live}.) - -On machines that have ``register windows'', the function entry code does -not save on the stack the registers that are in the windows, even if -they are supposed to be preserved by function calls; instead it takes -appropriate steps to ``push'' the register stack, if any non-call-used -registers are used in the function. - -@findex frame_pointer_needed -On machines where functions may or may not have frame-pointers, the -function entry code must vary accordingly; it must set up the frame -pointer if one is wanted, and not otherwise. To determine whether a -frame pointer is in wanted, the macro can refer to the variable -@code{frame_pointer_needed}. The variable's value will be 1 at run -time in a function that needs a frame pointer. @xref{Elimination}. - -The function entry code is responsible for allocating any stack space -required for the function. This stack space consists of the regions -listed below. In most cases, these regions are allocated in the -order listed, with the last listed region closest to the top of the -stack (the lowest address if @code{STACK_GROWS_DOWNWARD} is defined, and -the highest address if it is not defined). You can use a different order -for a machine if doing so is more convenient or required for -compatibility reasons. Except in cases where required by standard -or by a debugger, there is no reason why the stack layout used by GCC -need agree with that used by other compilers for a machine. -@end deftypefn @hook TARGET_ASM_FUNCTION_END_PROLOGUE -If defined, a function that outputs assembler code at the end of a -prologue. This should be used when the function prologue is being -emitted as RTL, and you have some extra assembler that needs to be -emitted. @xref{prologue instruction pattern}. -@end deftypefn @hook TARGET_ASM_FUNCTION_BEGIN_EPILOGUE -If defined, a function that outputs assembler code at the start of an -epilogue. This should be used when the function epilogue is being -emitted as RTL, and you have some extra assembler that needs to be -emitted. @xref{epilogue instruction pattern}. -@end deftypefn @hook TARGET_ASM_FUNCTION_EPILOGUE -If defined, a function that outputs the assembler code for exit from a -function. The epilogue is responsible for restoring the saved -registers and stack pointer to their values when the function was -called, and returning control to the caller. This macro takes the -same arguments as the macro @code{TARGET_ASM_FUNCTION_PROLOGUE}, and the -registers to restore are determined from @code{regs_ever_live} and -@code{CALL_USED_REGISTERS} in the same way. - -On some machines, there is a single instruction that does all the work -of returning from the function. On these machines, give that -instruction the name @samp{return} and do not define the macro -@code{TARGET_ASM_FUNCTION_EPILOGUE} at all. - -Do not define a pattern named @samp{return} if you want the -@code{TARGET_ASM_FUNCTION_EPILOGUE} to be used. If you want the target -switches to control whether return instructions or epilogues are used, -define a @samp{return} pattern with a validity condition that tests the -target switches appropriately. If the @samp{return} pattern's validity -condition is false, epilogues will be used. - -On machines where functions may or may not have frame-pointers, the -function exit code must vary accordingly. Sometimes the code for these -two cases is completely different. To determine whether a frame pointer -is wanted, the macro can refer to the variable -@code{frame_pointer_needed}. The variable's value will be 1 when compiling -a function that needs a frame pointer. - -Normally, @code{TARGET_ASM_FUNCTION_PROLOGUE} and -@code{TARGET_ASM_FUNCTION_EPILOGUE} must treat leaf functions specially. -The C variable @code{current_function_is_leaf} is nonzero for such a -function. @xref{Leaf Functions}. - -On some machines, some functions pop their arguments on exit while -others leave that for the caller to do. For example, the 68020 when -given @option{-mrtd} pops arguments in functions that take a fixed -number of arguments. - -@findex pops_args -@findex crtl->args.pops_args -Your definition of the macro @code{RETURN_POPS_ARGS} decides which -functions pop their own arguments. @code{TARGET_ASM_FUNCTION_EPILOGUE} -needs to know what was decided. The number of bytes of the current -function's arguments that this function should pop is available in -@code{crtl->args.pops_args}. @xref{Scalar Return}. -@end deftypefn @itemize @bullet @item @@ -4789,54 +3922,8 @@ on entry to an exception edge. @end defmac @hook TARGET_ASM_OUTPUT_MI_THUNK -A function that outputs the assembler code for a thunk -function, used to implement C++ virtual function calls with multiple -inheritance. The thunk acts as a wrapper around a virtual function, -adjusting the implicit object parameter before handing control off to -the real function. - -First, emit code to add the integer @var{delta} to the location that -contains the incoming first argument. Assume that this argument -contains a pointer, and is the one used to pass the @code{this} pointer -in C++. This is the incoming argument @emph{before} the function prologue, -e.g.@: @samp{%o0} on a sparc. The addition must preserve the values of -all other incoming arguments. - -Then, if @var{vcall_offset} is nonzero, an additional adjustment should be -made after adding @code{delta}. In particular, if @var{p} is the -adjusted pointer, the following adjustment should be made: - -@smallexample -p += (*((ptrdiff_t **)p))[vcall_offset/sizeof(ptrdiff_t)] -@end smallexample - -After the additions, emit code to jump to @var{function}, which is a -@code{FUNCTION_DECL}. This is a direct pure jump, not a call, and does -not touch the return address. Hence returning from @var{FUNCTION} will -return to whoever called the current @samp{thunk}. - -The effect must be as if @var{function} had been called directly with -the adjusted first argument. This macro is responsible for emitting all -of the code for a thunk function; @code{TARGET_ASM_FUNCTION_PROLOGUE} -and @code{TARGET_ASM_FUNCTION_EPILOGUE} are not invoked. - -The @var{thunk_fndecl} is redundant. (@var{delta} and @var{function} -have already been extracted from it.) It might possibly be useful on -some targets, but probably not. - -If you do not define this macro, the target-independent code in the C++ -front end will generate a less efficient heavyweight thunk that calls -@var{function} instead of jumping to it. The generic approach does -not support varargs. -@end deftypefn @hook TARGET_ASM_CAN_OUTPUT_MI_THUNK -A function that returns true if TARGET_ASM_OUTPUT_MI_THUNK would be able -to output the assembler code for the thunk function specified by the -arguments it is passed, and false otherwise. In the latter case, the -generic approach will be used by the C++ front end, with the limitations -previously exposed. -@end deftypefn @node Profiling @subsection Generating Code for Profiling @@ -4884,26 +3971,8 @@ the function prologue. Normally, the profiling code comes after. @cindex tail calls @hook TARGET_FUNCTION_OK_FOR_SIBCALL -True if it is ok to do sibling call optimization for the specified -call expression @var{exp}. @var{decl} will be the called function, -or @code{NULL} if this is an indirect call. - -It is not uncommon for limitations of calling conventions to prevent -tail calls to functions outside the current unit of translation, or -during PIC compilation. The hook is used to enforce these restrictions, -as the @code{sibcall} md pattern can not fail, or fall over to a -``normal'' call. The criteria for successful sibling call optimization -may vary greatly between different architectures. -@end deftypefn @hook TARGET_EXTRA_LIVE_ON_ENTRY -Add any hard registers to @var{regs} that are live on entry to the -function. This hook only needs to be defined to provide registers that -cannot be found by examination of FUNCTION_ARG_REGNO_P, the callee saved -registers, STATIC_CHAIN_INCOMING_REGNUM, STATIC_CHAIN_REGNUM, -TARGET_STRUCT_VALUE_RTX, FRAME_POINTER_REGNUM, EH_USES, -FRAME_POINTER_REGNUM, ARG_POINTER_REGNUM, and the PIC_OFFSET_TABLE_REGNUM. -@end deftypefn @hook TARGET_SET_UP_BY_PROLOGUE @@ -4914,25 +3983,8 @@ FRAME_POINTER_REGNUM, ARG_POINTER_REGNUM, and the PIC_OFFSET_TABLE_REGNUM. @cindex stack smashing protection @hook TARGET_STACK_PROTECT_GUARD -This hook returns a @code{DECL} node for the external variable to use -for the stack protection guard. This variable is initialized by the -runtime to some random value and is used to initialize the guard value -that is placed at the top of the local stack frame. The type of this -variable must be @code{ptr_type_node}. - -The default version of this hook creates a variable called -@samp{__stack_chk_guard}, which is normally defined in @file{libgcc2.c}. -@end deftypefn @hook TARGET_STACK_PROTECT_FAIL -This hook returns a @code{CALL_EXPR} that alerts the runtime that the -stack protect guard variable has been modified. This expression should -involve a call to a @code{noreturn} function. - -The default version of this hook invokes a function called -@samp{__stack_chk_fail}, taking no arguments. This function is -normally defined in @file{libgcc2.c}. -@end deftypefn @hook TARGET_SUPPORTS_SPLIT_STACK @@ -5005,70 +4057,12 @@ interpret the values of @code{__builtin_classify_type}. These machine description macros help implement varargs: @hook TARGET_EXPAND_BUILTIN_SAVEREGS -If defined, this hook produces the machine-specific code for a call to -@code{__builtin_saveregs}. This code will be moved to the very -beginning of the function, before any parameter access are made. The -return value of this function should be an RTX that contains the value -to use as the return of @code{__builtin_saveregs}. -@end deftypefn @hook TARGET_SETUP_INCOMING_VARARGS -This target hook offers an alternative to using -@code{__builtin_saveregs} and defining the hook -@code{TARGET_EXPAND_BUILTIN_SAVEREGS}. Use it to store the anonymous -register arguments into the stack so that all the arguments appear to -have been passed consecutively on the stack. Once this is done, you can -use the standard implementation of varargs that works for machines that -pass all their arguments on the stack. - -The argument @var{args_so_far} points to the @code{CUMULATIVE_ARGS} data -structure, containing the values that are obtained after processing the -named arguments. The arguments @var{mode} and @var{type} describe the -last named argument---its machine mode and its data type as a tree node. - -The target hook should do two things: first, push onto the stack all the -argument registers @emph{not} used for the named arguments, and second, -store the size of the data thus pushed into the @code{int}-valued -variable pointed to by @var{pretend_args_size}. The value that you -store here will serve as additional offset for setting up the stack -frame. - -Because you must generate code to push the anonymous arguments at -compile time without knowing their data types, -@code{TARGET_SETUP_INCOMING_VARARGS} is only useful on machines that -have just a single category of argument register and use it uniformly -for all data types. - -If the argument @var{second_time} is nonzero, it means that the -arguments of the function are being analyzed for the second time. This -happens for an inline function, which is not actually compiled until the -end of the source file. The hook @code{TARGET_SETUP_INCOMING_VARARGS} should -not generate any instructions in this case. -@end deftypefn @hook TARGET_STRICT_ARGUMENT_NAMING -Define this hook to return @code{true} if the location where a function -argument is passed depends on whether or not it is a named argument. - -This hook controls how the @var{named} argument to @code{TARGET_FUNCTION_ARG} -is set for varargs and stdarg functions. If this hook returns -@code{true}, the @var{named} argument is always true for named -arguments, and false for unnamed arguments. If it returns @code{false}, -but @code{TARGET_PRETEND_OUTGOING_VARARGS_NAMED} returns @code{true}, -then all arguments are treated as named. Otherwise, all named arguments -except the last are treated as named. - -You need not define this hook if it always returns @code{false}. -@end deftypefn @hook TARGET_PRETEND_OUTGOING_VARARGS_NAMED -If you need to conditionally change ABIs so that one works with -@code{TARGET_SETUP_INCOMING_VARARGS}, but the other works like neither -@code{TARGET_SETUP_INCOMING_VARARGS} nor @code{TARGET_STRICT_ARGUMENT_NAMING} was -defined, then define this hook to return @code{true} if -@code{TARGET_SETUP_INCOMING_VARARGS} is used, @code{false} otherwise. -Otherwise, you should not define this hook. -@end deftypefn @node Trampolines @section Trampolines for Nested Functions @@ -5099,16 +4093,6 @@ may be necessary to take out pieces of the address and store them separately. @hook TARGET_ASM_TRAMPOLINE_TEMPLATE -This hook is called by @code{assemble_trampoline_template} to output, -on the stream @var{f}, assembler code for a block of data that contains -the constant parts of a trampoline. This code should not include a -label---the label is taken care of automatically. - -If you do not define this hook, it means no template is needed -for the target. Do not define this hook on systems where the block move -code to copy the trampoline into place would be larger than the code -to generate it on the spot. -@end deftypefn @defmac TRAMPOLINE_SECTION Return the section into which the trampoline template is to be placed @@ -5127,33 +4111,8 @@ is used for aligning trampolines. @end defmac @hook TARGET_TRAMPOLINE_INIT -This hook is called to initialize a trampoline. -@var{m_tramp} is an RTX for the memory block for the trampoline; @var{fndecl} -is the @code{FUNCTION_DECL} for the nested function; @var{static_chain} is an -RTX for the static chain value that should be passed to the function -when it is called. - -If the target defines @code{TARGET_ASM_TRAMPOLINE_TEMPLATE}, then the -first thing this hook should do is emit a block move into @var{m_tramp} -from the memory block returned by @code{assemble_trampoline_template}. -Note that the block move need only cover the constant parts of the -trampoline. If the target isolates the variable parts of the trampoline -to the end, not all @code{TRAMPOLINE_SIZE} bytes need be copied. - -If the target requires any other actions, such as flushing caches or -enabling stack execution, these actions should be performed after -initializing the trampoline proper. -@end deftypefn @hook TARGET_TRAMPOLINE_ADJUST_ADDRESS -This hook should perform any machine-specific adjustment in -the address of the trampoline. Its argument contains the address of the -memory block that was passed to @code{TARGET_TRAMPOLINE_INIT}. In case -the address to be used for a function call should be different from the -address at which the template was stored, the different address should -be returned; otherwise @var{addr} should be returned unchanged. -If this hook is not defined, @var{addr} will be used for function calls. -@end deftypefn Implementing trampolines is difficult on many machines because they have separate instruction and data caches. Writing into a stack location @@ -5214,14 +4173,6 @@ are ABI-mandated names that the compiler should provide. @findex set_optab_libfunc @findex init_one_libfunc @hook TARGET_INIT_LIBFUNCS -This hook should declare additional library routines or rename -existing ones, using the functions @code{set_optab_libfunc} and -@code{init_one_libfunc} defined in @file{optabs.c}. -@code{init_optabs} calls this macro after initializing all the normal -library routines. - -The default is to do nothing. Most ports don't need to define this hook. -@end deftypefn @hook TARGET_LIBFUNC_GNU_PREFIX @@ -5358,69 +4309,6 @@ accept. @end defmac @hook TARGET_LEGITIMATE_ADDRESS_P -A function that returns whether @var{x} (an RTX) is a legitimate memory -address on the target machine for a memory operand of mode @var{mode}. - -Legitimate addresses are defined in two variants: a strict variant and a -non-strict one. The @var{strict} parameter chooses which variant is -desired by the caller. - -The strict variant is used in the reload pass. It must be defined so -that any pseudo-register that has not been allocated a hard register is -considered a memory reference. This is because in contexts where some -kind of register is required, a pseudo-register with no hard register -must be rejected. For non-hard registers, the strict variant should look -up the @code{reg_renumber} array; it should then proceed using the hard -register number in the array, or treat the pseudo as a memory reference -if the array holds @code{-1}. - -The non-strict variant is used in other passes. It must be defined to -accept all pseudo-registers in every context where some kind of -register is required. - -Normally, constant addresses which are the sum of a @code{symbol_ref} -and an integer are stored inside a @code{const} RTX to mark them as -constant. Therefore, there is no need to recognize such sums -specifically as legitimate addresses. Normally you would simply -recognize any @code{const} as legitimate. - -Usually @code{PRINT_OPERAND_ADDRESS} is not prepared to handle constant -sums that are not marked with @code{const}. It assumes that a naked -@code{plus} indicates indexing. If so, then you @emph{must} reject such -naked constant sums as illegitimate addresses, so that none of them will -be given to @code{PRINT_OPERAND_ADDRESS}. - -@cindex @code{TARGET_ENCODE_SECTION_INFO} and address validation -On some machines, whether a symbolic address is legitimate depends on -the section that the address refers to. On these machines, define the -target hook @code{TARGET_ENCODE_SECTION_INFO} to store the information -into the @code{symbol_ref}, and then check for it here. When you see a -@code{const}, you will have to look inside it to find the -@code{symbol_ref} in order to determine the section. @xref{Assembler -Format}. - -@cindex @code{GO_IF_LEGITIMATE_ADDRESS} -Some ports are still using a deprecated legacy substitute for -this hook, the @code{GO_IF_LEGITIMATE_ADDRESS} macro. This macro -has this syntax: - -@example -#define GO_IF_LEGITIMATE_ADDRESS (@var{mode}, @var{x}, @var{label}) -@end example - -@noindent -and should @code{goto @var{label}} if the address @var{x} is a valid -address on the target machine for a memory operand of mode @var{mode}. - -@findex REG_OK_STRICT -Compiler source files that want to use the strict variant of this -macro define the macro @code{REG_OK_STRICT}. You should use an -@code{#ifdef REG_OK_STRICT} conditional to define the strict variant in -that case and the non-strict variant otherwise. - -Using the hook is usually simpler because it limits the number of -files that are recompiled when changes are made. -@end deftypefn @defmac TARGET_MEM_CONSTRAINT A single character to be used instead of the default @code{'m'} @@ -5447,27 +4335,6 @@ a label_ref or symbol_ref within an UNSPEC@. @end defmac @hook TARGET_LEGITIMIZE_ADDRESS -This hook is given an invalid memory address @var{x} for an -operand of mode @var{mode} and should try to return a valid memory -address. - -@findex break_out_memory_refs -@var{x} will always be the result of a call to @code{break_out_memory_refs}, -and @var{oldx} will be the operand that was given to that function to produce -@var{x}. - -The code of the hook should not alter the substructure of -@var{x}. If it transforms @var{x} into a more legitimate form, it -should return the new @var{x}. - -It is not necessary for this hook to come up with a legitimate address, -with the exception of native TLS addresses (@pxref{Emulated TLS}). -The compiler has standard ways of doing so in all cases. In fact, if -the target supports only emulated TLS, it -is safe to omit this hook or make it return @var{x} if it cannot find -a valid way to legitimize the address. But often a machine-dependent -strategy can generate better code. -@end deftypefn @defmac LEGITIMIZE_RELOAD_ADDRESS (@var{x}, @var{mode}, @var{opnum}, @var{type}, @var{ind_levels}, @var{win}) A C compound statement that attempts to replace @var{x}, which is an address @@ -5519,169 +4386,38 @@ address; but often a machine-dependent strategy can generate better code. @end defmac @hook TARGET_MODE_DEPENDENT_ADDRESS_P -This hook returns @code{true} if memory address @var{addr} in address -space @var{addrspace} can have -different meanings depending on the machine mode of the memory -reference it is used for or if the address is valid for some modes -but not others. - -Autoincrement and autodecrement addresses typically have mode-dependent -effects because the amount of the increment or decrement is the size -of the operand being addressed. Some machines have other mode-dependent -addresses. Many RISC machines have no mode-dependent addresses. - -You may assume that @var{addr} is a valid address for the machine. - -The default version of this hook returns @code{false}. -@end deftypefn @hook TARGET_LEGITIMATE_CONSTANT_P -This hook returns true if @var{x} is a legitimate constant for a -@var{mode}-mode immediate operand on the target machine. You can assume that -@var{x} satisfies @code{CONSTANT_P}, so you need not check this. - -The default definition returns true. -@end deftypefn @hook TARGET_DELEGITIMIZE_ADDRESS -This hook is used to undo the possibly obfuscating effects of the -@code{LEGITIMIZE_ADDRESS} and @code{LEGITIMIZE_RELOAD_ADDRESS} target -macros. Some backend implementations of these macros wrap symbol -references inside an @code{UNSPEC} rtx to represent PIC or similar -addressing modes. This target hook allows GCC's optimizers to understand -the semantics of these opaque @code{UNSPEC}s by converting them back -into their original form. -@end deftypefn @hook TARGET_CONST_NOT_OK_FOR_DEBUG_P -This hook should return true if @var{x} should not be emitted into -debug sections. -@end deftypefn @hook TARGET_CANNOT_FORCE_CONST_MEM -This hook should return true if @var{x} is of a form that cannot (or -should not) be spilled to the constant pool. @var{mode} is the mode -of @var{x}. - -The default version of this hook returns false. - -The primary reason to define this hook is to prevent reload from -deciding that a non-legitimate constant would be better reloaded -from the constant pool instead of spilling and reloading a register -holding the constant. This restriction is often true of addresses -of TLS symbols for various targets. -@end deftypefn @hook TARGET_USE_BLOCKS_FOR_CONSTANT_P -This hook should return true if pool entries for constant @var{x} can -be placed in an @code{object_block} structure. @var{mode} is the mode -of @var{x}. - -The default version returns false for all constants. -@end deftypefn @hook TARGET_USE_BLOCKS_FOR_DECL_P -This hook should return true if pool entries for @var{decl} should -be placed in an @code{object_block} structure. - -The default version returns true for all decls. -@end deftypefn @hook TARGET_BUILTIN_RECIPROCAL -This hook should return the DECL of a function that implements reciprocal of -the builtin function with builtin function code @var{fn}, or -@code{NULL_TREE} if such a function is not available. @var{md_fn} is true -when @var{fn} is a code of a machine-dependent builtin function. When -@var{sqrt} is true, additional optimizations that apply only to the reciprocal -of a square root function are performed, and only reciprocals of @code{sqrt} -function are valid. -@end deftypefn @hook TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD -This hook should return the DECL of a function @var{f} that given an -address @var{addr} as an argument returns a mask @var{m} that can be -used to extract from two vectors the relevant data that resides in -@var{addr} in case @var{addr} is not properly aligned. - -The autovectorizer, when vectorizing a load operation from an address -@var{addr} that may be unaligned, will generate two vector loads from -the two aligned addresses around @var{addr}. It then generates a -@code{REALIGN_LOAD} operation to extract the relevant data from the -two loaded vectors. The first two arguments to @code{REALIGN_LOAD}, -@var{v1} and @var{v2}, are the two vectors, each of size @var{VS}, and -the third argument, @var{OFF}, defines how the data will be extracted -from these two vectors: if @var{OFF} is 0, then the returned vector is -@var{v2}; otherwise, the returned vector is composed from the last -@var{VS}-@var{OFF} elements of @var{v1} concatenated to the first -@var{OFF} elements of @var{v2}. - -If this hook is defined, the autovectorizer will generate a call -to @var{f} (using the DECL tree that this hook returns) and will -use the return value of @var{f} as the argument @var{OFF} to -@code{REALIGN_LOAD}. Therefore, the mask @var{m} returned by @var{f} -should comply with the semantics expected by @code{REALIGN_LOAD} -described above. -If this hook is not defined, then @var{addr} will be used as -the argument @var{OFF} to @code{REALIGN_LOAD}, in which case the low -log2(@var{VS}) @minus{} 1 bits of @var{addr} will be considered. -@end deftypefn @hook TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST -Returns cost of different scalar or vector statements for vectorization cost model. -For vector memory operations the cost may depend on type (@var{vectype}) and -misalignment value (@var{misalign}). -@end deftypefn @hook TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE -Return true if vector alignment is reachable (by peeling N iterations) for the given type. -@end deftypefn @hook TARGET_VECTORIZE_VEC_PERM_CONST_OK -Return true if a vector created for @code{vec_perm_const} is valid. -@end deftypefn @hook TARGET_VECTORIZE_BUILTIN_CONVERSION -This hook should return the DECL of a function that implements conversion of the -input vector of type @var{src_type} to type @var{dest_type}. -The value of @var{code} is one of the enumerators in @code{enum tree_code} and -specifies how the conversion is to be applied -(truncation, rounding, etc.). - -If this hook is defined, the autovectorizer will use the -@code{TARGET_VECTORIZE_BUILTIN_CONVERSION} target hook when vectorizing -conversion. Otherwise, it will return @code{NULL_TREE}. -@end deftypefn @hook TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION -This hook should return the decl of a function that implements the -vectorized variant of the builtin function with builtin function code -@var{code} or @code{NULL_TREE} if such a function is not available. -The value of @var{fndecl} is the builtin function declaration. The -return type of the vectorized function shall be of vector type -@var{vec_type_out} and the argument types should be @var{vec_type_in}. -@end deftypefn @hook TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT -This hook should return true if the target supports misaligned vector -store/load of a specific factor denoted in the @var{misalignment} -parameter. The vector store/load should be of machine mode @var{mode} and -the elements in the vectors should be of type @var{type}. @var{is_packed} -parameter is true if the memory access is defined in a packed struct. -@end deftypefn @hook TARGET_VECTORIZE_PREFERRED_SIMD_MODE -This hook should return the preferred mode for vectorizing scalar -mode @var{mode}. The default is -equal to @code{word_mode}, because the vectorizer can do some -transformations even in absence of specialized @acronym{SIMD} hardware. -@end deftypefn @hook TARGET_VECTORIZE_AUTOVECTORIZE_VECTOR_SIZES -This hook should return a mask of sizes that should be iterated over -after trying to autovectorize using the vector size derived from the -mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE}. -The default is zero which means to not iterate over other vector sizes. -@end deftypefn @hook TARGET_VECTORIZE_INIT_COST @@ -5696,12 +4432,6 @@ The default is zero which means to not iterate over other vector sizes. @hook TARGET_VECTORIZE_BUILTIN_TM_STORE @hook TARGET_VECTORIZE_BUILTIN_GATHER -Target builtin that implements vector gather operation. @var{mem_vectype} -is the vector type of the load and @var{index_type} is scalar type of -the index, scaled by @var{scale}. -The default is @code{NULL_TREE} which means to not vectorize gather -loads. -@end deftypefn @node Anchored Addresses @section Anchored Addresses @@ -5739,39 +4469,12 @@ section anchors at all unless either @code{TARGET_MIN_ANCHOR_OFFSET} or @code{TARGET_MAX_ANCHOR_OFFSET} is set to a nonzero value. @hook TARGET_MIN_ANCHOR_OFFSET -The minimum offset that should be applied to a section anchor. -On most targets, it should be the smallest offset that can be -applied to a base register while still giving a legitimate address -for every mode. The default value is 0. -@end deftypevr @hook TARGET_MAX_ANCHOR_OFFSET -Like @code{TARGET_MIN_ANCHOR_OFFSET}, but the maximum (inclusive) -offset that should be applied to section anchors. The default -value is 0. -@end deftypevr @hook TARGET_ASM_OUTPUT_ANCHOR -Write the assembly code to define section anchor @var{x}, which is a -@code{SYMBOL_REF} for which @samp{SYMBOL_REF_ANCHOR_P (@var{x})} is true. -The hook is called with the assembly output position set to the beginning -of @code{SYMBOL_REF_BLOCK (@var{x})}. - -If @code{ASM_OUTPUT_DEF} is available, the hook's default definition uses -it to define the symbol as @samp{. + SYMBOL_REF_BLOCK_OFFSET (@var{x})}. -If @code{ASM_OUTPUT_DEF} is not available, the hook's default definition -is @code{NULL}, which disables the use of section anchors altogether. -@end deftypefn @hook TARGET_USE_ANCHORS_FOR_SYMBOL_P -Return true if GCC should attempt to use anchors to access @code{SYMBOL_REF} -@var{x}. You can assume @samp{SYMBOL_REF_HAS_BLOCK_INFO_P (@var{x})} and -@samp{!SYMBOL_REF_ANCHOR_P (@var{x})}. - -The default version is correct for most targets, but you might need to -intercept this hook to handle things like target-specific attributes -or target-specific sections. -@end deftypefn @node Condition Code @section Condition Code Status @@ -5940,27 +4643,7 @@ You should define this macro if and only if you define extra CC modes in @file{@var{machine}-modes.def}. @end defmac -@hook TARGET_CANONICALIZE_COMPARISON (@var{code}, @var{op0}, @var{op1}, @var{op0_preserve_value}) -On some machines not all possible comparisons are defined, but you can -convert an invalid comparison into a valid one. For example, the Alpha -does not have a @code{GT} comparison, but you can use an @code{LT} -comparison instead and swap the order of the operands. - -On such machines, implement this hook to do any required conversions. -@var{code} is the initial comparison code and @var{op0} and @var{op1} -are the left and right operands of the comparison, respectively. If -@var{op0_preserve_value} is @code{true} the implementation is not -allowed to change the value of @var{op0} since the value might be used -in RTXs which aren't comparisons. E.g. the implementation is not -allowed to swap operands in that case. - -GCC will not assume that the comparison resulting from this macro is -valid but will see if the resulting insn matches a pattern in the -@file{md} file. - -You need not to implement this hook if it would never change the -comparison code or operands. -@end deftypefn +@hook TARGET_CANONICALIZE_COMPARISON @defmac REVERSIBLE_CC_MODE (@var{mode}) A C expression whose value is one if it is always safe to reverse a @@ -5995,32 +4678,8 @@ like: @end defmac @hook TARGET_FIXED_CONDITION_CODE_REGS -On targets which do not use @code{(cc0)}, and which use a hard -register rather than a pseudo-register to hold condition codes, the -regular CSE passes are often not able to identify cases in which the -hard register is set to a common value. Use this hook to enable a -small pass which optimizes such cases. This hook should return true -to enable this pass, and it should set the integers to which its -arguments point to the hard register numbers used for condition codes. -When there is only one such register, as is true on most systems, the -integer pointed to by @var{p2} should be set to -@code{INVALID_REGNUM}. - -The default version of this hook returns false. -@end deftypefn @hook TARGET_CC_MODES_COMPATIBLE -On targets which use multiple condition code modes in class -@code{MODE_CC}, it is sometimes the case that a comparison can be -validly done in more than one mode. On such a system, define this -target hook to take two mode arguments and to return a mode in which -both comparisons may be validly done. If there is no such mode, -return @code{VOIDmode}. - -The default version of this hook checks whether the modes are the -same. If they are, it returns that mode. If they are different, it -returns @code{VOIDmode}. -@end deftypefn @node Cond Exec Macros @subsection Macros to control conditional execution @@ -6063,25 +4722,6 @@ These macros are obsolete, new ports should use the target hook @end defmac @hook TARGET_REGISTER_MOVE_COST -This target hook should return the cost of moving data of mode @var{mode} -from a register in class @var{from} to one in class @var{to}. The classes -are expressed using the enumeration values such as @code{GENERAL_REGS}. -A value of 2 is the default; other values are interpreted relative to -that. - -It is not required that the cost always equal 2 when @var{from} is the -same as @var{to}; on some machines it is expensive to move between -registers if they are not general registers. - -If reload sees an insn consisting of a single @code{set} between two -hard registers, and if @code{TARGET_REGISTER_MOVE_COST} applied to their -classes returns a value of 2, reload does not check to ensure that the -constraints of the insn are met. Setting a cost of other than 2 will -allow reload to verify that the constraints are met. You should do this -if the @samp{mov@var{m}} pattern's constraints do not allow such copying. - -The default version of this function returns 2. -@end deftypefn @defmac MEMORY_MOVE_COST (@var{mode}, @var{class}, @var{in}) A C expression for the cost of moving data of mode @var{mode} between a @@ -6111,28 +4751,6 @@ These macros are obsolete, new ports should use the target hook @end defmac @hook TARGET_MEMORY_MOVE_COST -This target hook should return the cost of moving data of mode @var{mode} -between a register of class @var{rclass} and memory; @var{in} is @code{false} -if the value is to be written to memory, @code{true} if it is to be read in. -This cost is relative to those in @code{TARGET_REGISTER_MOVE_COST}. -If moving between registers and memory is more expensive than between two -registers, you should add this target hook to express the relative cost. - -If you do not add this target hook, GCC uses a default cost of 4 plus -the cost of copying via a secondary reload register, if one is -needed. If your machine requires a secondary reload register to copy -between memory and a register of @var{rclass} but the reload mechanism is -more complex than copying via an intermediate, use this target hook to -reflect the actual cost of the move. - -GCC defines the function @code{memory_move_secondary_cost} if -secondary reloads are needed. It computes the costs due to copying via -a secondary register. If your machine copies from memory using a -secondary register in the conventional way but the default base value of -4 is not correct for your machine, use this target hook to add some other -value to the result of that function. The arguments to that function -are the same as to this target hook. -@end deftypefn @defmac BRANCH_COST (@var{speed_p}, @var{predictable_p}) A C expression for the cost of a branch instruction. A value of 1 is @@ -6318,71 +4936,8 @@ Define this macro if a non-short-circuit operation produced by @end defmac @hook TARGET_RTX_COSTS -This target hook describes the relative costs of RTL expressions. - -The cost may depend on the precise form of the expression, which is -available for examination in @var{x}, and the fact that @var{x} appears -as operand @var{opno} of an expression with rtx code @var{outer_code}. -That is, the hook can assume that there is some rtx @var{y} such -that @samp{GET_CODE (@var{y}) == @var{outer_code}} and such that -either (a) @samp{XEXP (@var{y}, @var{opno}) == @var{x}} or -(b) @samp{XVEC (@var{y}, @var{opno})} contains @var{x}. - -@var{code} is @var{x}'s expression code---redundant, since it can be -obtained with @code{GET_CODE (@var{x})}. - -In implementing this hook, you can use the construct -@code{COSTS_N_INSNS (@var{n})} to specify a cost equal to @var{n} fast -instructions. - -On entry to the hook, @code{*@var{total}} contains a default estimate -for the cost of the expression. The hook should modify this value as -necessary. Traditionally, the default costs are @code{COSTS_N_INSNS (5)} -for multiplications, @code{COSTS_N_INSNS (7)} for division and modulus -operations, and @code{COSTS_N_INSNS (1)} for all other operations. - -When optimizing for code size, i.e.@: when @code{speed} is -false, this target hook should be used to estimate the relative -size cost of an expression, again relative to @code{COSTS_N_INSNS}. - -The hook returns true when all subexpressions of @var{x} have been -processed, and false when @code{rtx_cost} should recurse. -@end deftypefn @hook TARGET_ADDRESS_COST -This hook computes the cost of an addressing mode that contains -@var{address}. If not defined, the cost is computed from -the @var{address} expression and the @code{TARGET_RTX_COST} hook. - -For most CISC machines, the default cost is a good approximation of the -true cost of the addressing mode. However, on RISC machines, all -instructions normally have the same length and execution time. Hence -all addresses will have equal costs. - -In cases where more than one form of an address is known, the form with -the lowest cost will be used. If multiple forms have the same, lowest, -cost, the one that is the most complex will be used. - -For example, suppose an address that is equal to the sum of a register -and a constant is used twice in the same basic block. When this macro -is not defined, the address will be computed in a register and memory -references will be indirect through that register. On machines where -the cost of the addressing mode containing the sum is no higher than -that of a simple indirect reference, this will produce an additional -instruction and possibly require an additional register. Proper -specification of this macro eliminates this overhead for such machines. - -This hook is never called with an invalid address. - -On machines where an address involving more than one register is as -cheap as an address computation involving only one register, defining -@code{TARGET_ADDRESS_COST} to reflect this can cause two registers to -be live over a region of code where only one would have been if -@code{TARGET_ADDRESS_COST} were not defined in that manner. This effect -should be considered in the definition of this macro. Equivalent costs -should probably only be given to addresses with different numbers of -registers on machines with lots of registers. -@end deftypefn @node Scheduling @section Adjusting the Instruction Scheduler @@ -6393,357 +4948,86 @@ hooks for this purpose. It is usually enough to define just a few of them: try the first ones in this list first. @hook TARGET_SCHED_ISSUE_RATE -This hook returns the maximum number of instructions that can ever -issue at the same time on the target machine. The default is one. -Although the insn scheduler can define itself the possibility of issue -an insn on the same cycle, the value can serve as an additional -constraint to issue insns on the same simulated processor cycle (see -hooks @samp{TARGET_SCHED_REORDER} and @samp{TARGET_SCHED_REORDER2}). -This value must be constant over the entire compilation. If you need -it to vary depending on what the instructions are, you must use -@samp{TARGET_SCHED_VARIABLE_ISSUE}. -@end deftypefn @hook TARGET_SCHED_VARIABLE_ISSUE -This hook is executed by the scheduler after it has scheduled an insn -from the ready list. It should return the number of insns which can -still be issued in the current cycle. The default is -@samp{@w{@var{more} - 1}} for insns other than @code{CLOBBER} and -@code{USE}, which normally are not counted against the issue rate. -You should define this hook if some insns take more machine resources -than others, so that fewer insns can follow them in the same cycle. -@var{file} is either a null pointer, or a stdio stream to write any -debug output to. @var{verbose} is the verbose level provided by -@option{-fsched-verbose-@var{n}}. @var{insn} is the instruction that -was scheduled. -@end deftypefn @hook TARGET_SCHED_ADJUST_COST -This function corrects the value of @var{cost} based on the -relationship between @var{insn} and @var{dep_insn} through the -dependence @var{link}. It should return the new value. The default -is to make no adjustment to @var{cost}. This can be used for example -to specify to the scheduler using the traditional pipeline description -that an output- or anti-dependence does not incur the same cost as a -data-dependence. If the scheduler using the automaton based pipeline -description, the cost of anti-dependence is zero and the cost of -output-dependence is maximum of one and the difference of latency -times of the first and the second insns. If these values are not -acceptable, you could use the hook to modify them too. See also -@pxref{Processor pipeline description}. -@end deftypefn @hook TARGET_SCHED_ADJUST_PRIORITY -This hook adjusts the integer scheduling priority @var{priority} of -@var{insn}. It should return the new priority. Increase the priority to -execute @var{insn} earlier, reduce the priority to execute @var{insn} -later. Do not define this hook if you do not need to adjust the -scheduling priorities of insns. -@end deftypefn @hook TARGET_SCHED_REORDER -This hook is executed by the scheduler after it has scheduled the ready -list, to allow the machine description to reorder it (for example to -combine two small instructions together on @samp{VLIW} machines). -@var{file} is either a null pointer, or a stdio stream to write any -debug output to. @var{verbose} is the verbose level provided by -@option{-fsched-verbose-@var{n}}. @var{ready} is a pointer to the ready -list of instructions that are ready to be scheduled. @var{n_readyp} is -a pointer to the number of elements in the ready list. The scheduler -reads the ready list in reverse order, starting with -@var{ready}[@var{*n_readyp} @minus{} 1] and going to @var{ready}[0]. @var{clock} -is the timer tick of the scheduler. You may modify the ready list and -the number of ready insns. The return value is the number of insns that -can issue this cycle; normally this is just @code{issue_rate}. See also -@samp{TARGET_SCHED_REORDER2}. -@end deftypefn @hook TARGET_SCHED_REORDER2 -Like @samp{TARGET_SCHED_REORDER}, but called at a different time. That -function is called whenever the scheduler starts a new cycle. This one -is called once per iteration over a cycle, immediately after -@samp{TARGET_SCHED_VARIABLE_ISSUE}; it can reorder the ready list and -return the number of insns to be scheduled in the same cycle. Defining -this hook can be useful if there are frequent situations where -scheduling one insn causes other insns to become ready in the same -cycle. These other insns can then be taken into account properly. -@end deftypefn @hook TARGET_SCHED_DEPENDENCIES_EVALUATION_HOOK -This hook is called after evaluation forward dependencies of insns in -chain given by two parameter values (@var{head} and @var{tail} -correspondingly) but before insns scheduling of the insn chain. For -example, it can be used for better insn classification if it requires -analysis of dependencies. This hook can use backward and forward -dependencies of the insn scheduler because they are already -calculated. -@end deftypefn @hook TARGET_SCHED_INIT -This hook is executed by the scheduler at the beginning of each block of -instructions that are to be scheduled. @var{file} is either a null -pointer, or a stdio stream to write any debug output to. @var{verbose} -is the verbose level provided by @option{-fsched-verbose-@var{n}}. -@var{max_ready} is the maximum number of insns in the current scheduling -region that can be live at the same time. This can be used to allocate -scratch space if it is needed, e.g.@: by @samp{TARGET_SCHED_REORDER}. -@end deftypefn @hook TARGET_SCHED_FINISH -This hook is executed by the scheduler at the end of each block of -instructions that are to be scheduled. It can be used to perform -cleanup of any actions done by the other scheduling hooks. @var{file} -is either a null pointer, or a stdio stream to write any debug output -to. @var{verbose} is the verbose level provided by -@option{-fsched-verbose-@var{n}}. -@end deftypefn @hook TARGET_SCHED_INIT_GLOBAL -This hook is executed by the scheduler after function level initializations. -@var{file} is either a null pointer, or a stdio stream to write any debug output to. -@var{verbose} is the verbose level provided by @option{-fsched-verbose-@var{n}}. -@var{old_max_uid} is the maximum insn uid when scheduling begins. -@end deftypefn @hook TARGET_SCHED_FINISH_GLOBAL -This is the cleanup hook corresponding to @code{TARGET_SCHED_INIT_GLOBAL}. -@var{file} is either a null pointer, or a stdio stream to write any debug output to. -@var{verbose} is the verbose level provided by @option{-fsched-verbose-@var{n}}. -@end deftypefn @hook TARGET_SCHED_DFA_PRE_CYCLE_INSN -The hook returns an RTL insn. The automaton state used in the -pipeline hazard recognizer is changed as if the insn were scheduled -when the new simulated processor cycle starts. Usage of the hook may -simplify the automaton pipeline description for some @acronym{VLIW} -processors. If the hook is defined, it is used only for the automaton -based pipeline description. The default is not to change the state -when the new simulated processor cycle starts. -@end deftypefn @hook TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN -The hook can be used to initialize data used by the previous hook. -@end deftypefn @hook TARGET_SCHED_DFA_POST_CYCLE_INSN -The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used -to changed the state as if the insn were scheduled when the new -simulated processor cycle finishes. -@end deftypefn @hook TARGET_SCHED_INIT_DFA_POST_CYCLE_INSN -The hook is analogous to @samp{TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN} but -used to initialize data used by the previous hook. -@end deftypefn @hook TARGET_SCHED_DFA_PRE_ADVANCE_CYCLE -The hook to notify target that the current simulated cycle is about to finish. -The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used -to change the state in more complicated situations - e.g., when advancing -state on a single insn is not enough. -@end deftypefn @hook TARGET_SCHED_DFA_POST_ADVANCE_CYCLE -The hook to notify target that new simulated cycle has just started. -The hook is analogous to @samp{TARGET_SCHED_DFA_POST_CYCLE_INSN} but used -to change the state in more complicated situations - e.g., when advancing -state on a single insn is not enough. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD -This hook controls better choosing an insn from the ready insn queue -for the @acronym{DFA}-based insn scheduler. Usually the scheduler -chooses the first insn from the queue. If the hook returns a positive -value, an additional scheduler code tries all permutations of -@samp{TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD ()} -subsequent ready insns to choose an insn whose issue will result in -maximal number of issued insns on the same cycle. For the -@acronym{VLIW} processor, the code could actually solve the problem of -packing simple insns into the @acronym{VLIW} insn. Of course, if the -rules of @acronym{VLIW} packing are described in the automaton. - -This code also could be used for superscalar @acronym{RISC} -processors. Let us consider a superscalar @acronym{RISC} processor -with 3 pipelines. Some insns can be executed in pipelines @var{A} or -@var{B}, some insns can be executed only in pipelines @var{B} or -@var{C}, and one insn can be executed in pipeline @var{B}. The -processor may issue the 1st insn into @var{A} and the 2nd one into -@var{B}. In this case, the 3rd insn will wait for freeing @var{B} -until the next cycle. If the scheduler issues the 3rd insn the first, -the processor could issue all 3 insns per cycle. - -Actually this code demonstrates advantages of the automaton based -pipeline hazard recognizer. We try quickly and easy many insn -schedules to choose the best one. - -The default is no multipass scheduling. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD -This hook controls what insns from the ready insn queue will be -considered for the multipass insn scheduling. If the hook returns -zero for @var{insn}, the insn will be not chosen to -be issued. - -The default is that any ready insns can be chosen to be issued. -@end deftypefn - @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BEGIN -This hook prepares the target backend for a new round of multipass -scheduling. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_ISSUE -This hook is called when multipass scheduling evaluates instruction INSN. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_BACKTRACK -This is called when multipass scheduling backtracks from evaluation of -an instruction. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_END -This hook notifies the target about the result of the concluded current -round of multipass scheduling. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_INIT -This hook initializes target-specific data used in multipass scheduling. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_FINI -This hook finalizes target-specific data used in multipass scheduling. -@end deftypefn @hook TARGET_SCHED_DFA_NEW_CYCLE -This hook is called by the insn scheduler before issuing @var{insn} -on cycle @var{clock}. If the hook returns nonzero, -@var{insn} is not issued on this processor cycle. Instead, -the processor cycle is advanced. If *@var{sort_p} -is zero, the insn ready queue is not sorted on the new cycle -start as usually. @var{dump} and @var{verbose} specify the file and -verbosity level to use for debugging output. -@var{last_clock} and @var{clock} are, respectively, the -processor cycle on which the previous insn has been issued, -and the current processor cycle. -@end deftypefn @hook TARGET_SCHED_IS_COSTLY_DEPENDENCE -This hook is used to define which dependences are considered costly by -the target, so costly that it is not advisable to schedule the insns that -are involved in the dependence too close to one another. The parameters -to this hook are as follows: The first parameter @var{_dep} is the dependence -being evaluated. The second parameter @var{cost} is the cost of the -dependence as estimated by the scheduler, and the third -parameter @var{distance} is the distance in cycles between the two insns. -The hook returns @code{true} if considering the distance between the two -insns the dependence between them is considered costly by the target, -and @code{false} otherwise. - -Defining this hook can be useful in multiple-issue out-of-order machines, -where (a) it's practically hopeless to predict the actual data/resource -delays, however: (b) there's a better chance to predict the actual grouping -that will be formed, and (c) correctly emulating the grouping can be very -important. In such targets one may want to allow issuing dependent insns -closer to one another---i.e., closer than the dependence distance; however, -not in cases of ``costly dependences'', which this hooks allows to define. -@end deftypefn @hook TARGET_SCHED_H_I_D_EXTENDED -This hook is called by the insn scheduler after emitting a new instruction to -the instruction stream. The hook notifies a target backend to extend its -per instruction data structures. -@end deftypefn @hook TARGET_SCHED_ALLOC_SCHED_CONTEXT -Return a pointer to a store large enough to hold target scheduling context. -@end deftypefn @hook TARGET_SCHED_INIT_SCHED_CONTEXT -Initialize store pointed to by @var{tc} to hold target scheduling context. -It @var{clean_p} is true then initialize @var{tc} as if scheduler is at the -beginning of the block. Otherwise, copy the current context into @var{tc}. -@end deftypefn @hook TARGET_SCHED_SET_SCHED_CONTEXT -Copy target scheduling context pointed to by @var{tc} to the current context. -@end deftypefn @hook TARGET_SCHED_CLEAR_SCHED_CONTEXT -Deallocate internal data in target scheduling context pointed to by @var{tc}. -@end deftypefn @hook TARGET_SCHED_FREE_SCHED_CONTEXT -Deallocate a store for target scheduling context pointed to by @var{tc}. -@end deftypefn @hook TARGET_SCHED_SPECULATE_INSN -This hook is called by the insn scheduler when @var{insn} has only -speculative dependencies and therefore can be scheduled speculatively. -The hook is used to check if the pattern of @var{insn} has a speculative -version and, in case of successful check, to generate that speculative -pattern. The hook should return 1, if the instruction has a speculative form, -or @minus{}1, if it doesn't. @var{request} describes the type of requested -speculation. If the return value equals 1 then @var{new_pat} is assigned -the generated speculative pattern. -@end deftypefn @hook TARGET_SCHED_NEEDS_BLOCK_P -This hook is called by the insn scheduler during generation of recovery code -for @var{insn}. It should return @code{true}, if the corresponding check -instruction should branch to recovery code, or @code{false} otherwise. -@end deftypefn @hook TARGET_SCHED_GEN_SPEC_CHECK -This hook is called by the insn scheduler to generate a pattern for recovery -check instruction. If @var{mutate_p} is zero, then @var{insn} is a -speculative instruction for which the check should be generated. -@var{label} is either a label of a basic block, where recovery code should -be emitted, or a null pointer, when requested check doesn't branch to -recovery code (a simple check). If @var{mutate_p} is nonzero, then -a pattern for a branchy check corresponding to a simple check denoted by -@var{insn} should be generated. In this case @var{label} can't be null. -@end deftypefn @hook TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD_SPEC -This hook is used as a workaround for -@samp{TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD} not being -called on the first instruction of the ready list. The hook is used to -discard speculative instructions that stand first in the ready list from -being scheduled on the current cycle. If the hook returns @code{false}, -@var{insn} will not be chosen to be issued. -For non-speculative instructions, -the hook should always return @code{true}. For example, in the ia64 backend -the hook is used to cancel data speculative insns when the ALAT table -is nearly full. -@end deftypefn @hook TARGET_SCHED_SET_SCHED_FLAGS -This hook is used by the insn scheduler to find out what features should be -enabled/used. -The structure *@var{spec_info} should be filled in by the target. -The structure describes speculation types that can be used in the scheduler. -@end deftypefn @hook TARGET_SCHED_SMS_RES_MII -This hook is called by the swing modulo scheduler to calculate a -resource-based lower bound which is based on the resources available in -the machine and the resources required by each instruction. The target -backend can use @var{g} to calculate such bound. A very simple lower -bound will be used in case this hook is not implemented: the total number -of instructions divided by the issue rate. -@end deftypefn @hook TARGET_SCHED_DISPATCH -This hook is called by Haifa Scheduler. It returns true if dispatch scheduling -is supported in hardware and the condition specified in the parameter is true. -@end deftypefn @hook TARGET_SCHED_DISPATCH_DO -This hook is called by Haifa Scheduler. It performs the operation specified -in its second parameter. -@end deftypefn @hook TARGET_SCHED_EXPOSED_PIPELINE @@ -6925,40 +5209,10 @@ This macro is irrelevant if there is no separate readonly data section. @end defmac @hook TARGET_ASM_INIT_SECTIONS -Define this hook if you need to do something special to set up the -@file{varasm.c} sections, or if your target has some special sections -of its own that you need to create. - -GCC calls this hook after processing the command line, but before writing -any assembly code, and before calling any of the section-returning hooks -described below. -@end deftypefn @hook TARGET_ASM_RELOC_RW_MASK -Return a mask describing how relocations should be treated when -selecting sections. Bit 1 should be set if global relocations -should be placed in a read-write section; bit 0 should be set if -local relocations should be placed in a read-write section. - -The default version of this function returns 3 when @option{-fpic} -is in effect, and 0 otherwise. The hook is typically redefined -when the target cannot support (some kinds of) dynamic relocations -in read-only sections even in executables. -@end deftypefn @hook TARGET_ASM_SELECT_SECTION -Return the section into which @var{exp} should be placed. You can -assume that @var{exp} is either a @code{VAR_DECL} node or a constant of -some sort. @var{reloc} indicates whether the initial value of @var{exp} -requires link-time relocations. Bit 0 is set when variable contains -local relocations only, while bit 1 is set for global relocations. -@var{align} is the constant alignment in bits. - -The default version of this function takes care of putting read-only -variables in @code{readonly_data_section}. - -See also @var{USE_SELECT_SECTION_FOR_FUNCTIONS}. -@end deftypefn @defmac USE_SELECT_SECTION_FOR_FUNCTIONS Define this macro if you wish TARGET_ASM_SELECT_SECTION to be called @@ -6970,122 +5224,30 @@ it is unlikely to be called. @end defmac @hook TARGET_ASM_UNIQUE_SECTION -Build up a unique section name, expressed as a @code{STRING_CST} node, -and assign it to @samp{DECL_SECTION_NAME (@var{decl})}. -As with @code{TARGET_ASM_SELECT_SECTION}, @var{reloc} indicates whether -the initial value of @var{exp} requires link-time relocations. - -The default version of this function appends the symbol name to the -ELF section name that would normally be used for the symbol. For -example, the function @code{foo} would be placed in @code{.text.foo}. -Whatever the actual target object format, this is often good enough. -@end deftypefn @hook TARGET_ASM_FUNCTION_RODATA_SECTION -Return the readonly data section associated with -@samp{DECL_SECTION_NAME (@var{decl})}. -The default version of this function selects @code{.gnu.linkonce.r.name} if -the function's section is @code{.gnu.linkonce.t.name}, @code{.rodata.name} -if function is in @code{.text.name}, and the normal readonly-data section -otherwise. -@end deftypefn @hook TARGET_ASM_MERGEABLE_RODATA_PREFIX @hook TARGET_ASM_TM_CLONE_TABLE_SECTION @hook TARGET_ASM_SELECT_RTX_SECTION -Return the section into which a constant @var{x}, of mode @var{mode}, -should be placed. You can assume that @var{x} is some kind of -constant in RTL@. The argument @var{mode} is redundant except in the -case of a @code{const_int} rtx. @var{align} is the constant alignment -in bits. - -The default version of this function takes care of putting symbolic -constants in @code{flag_pic} mode in @code{data_section} and everything -else in @code{readonly_data_section}. -@end deftypefn @hook TARGET_MANGLE_DECL_ASSEMBLER_NAME -Define this hook if you need to postprocess the assembler name generated -by target-independent code. The @var{id} provided to this hook will be -the computed name (e.g., the macro @code{DECL_NAME} of the @var{decl} in C, -or the mangled name of the @var{decl} in C++). The return value of the -hook is an @code{IDENTIFIER_NODE} for the appropriate mangled name on -your target system. The default implementation of this hook just -returns the @var{id} provided. -@end deftypefn @hook TARGET_ENCODE_SECTION_INFO -Define this hook if references to a symbol or a constant must be -treated differently depending on something about the variable or -function named by the symbol (such as what section it is in). - -The hook is executed immediately after rtl has been created for -@var{decl}, which may be a variable or function declaration or -an entry in the constant pool. In either case, @var{rtl} is the -rtl in question. Do @emph{not} use @code{DECL_RTL (@var{decl})} -in this hook; that field may not have been initialized yet. - -In the case of a constant, it is safe to assume that the rtl is -a @code{mem} whose address is a @code{symbol_ref}. Most decls -will also have this form, but that is not guaranteed. Global -register variables, for instance, will have a @code{reg} for their -rtl. (Normally the right thing to do with such unusual rtl is -leave it alone.) - -The @var{new_decl_p} argument will be true if this is the first time -that @code{TARGET_ENCODE_SECTION_INFO} has been invoked on this decl. It will -be false for subsequent invocations, which will happen for duplicate -declarations. Whether or not anything must be done for the duplicate -declaration depends on whether the hook examines @code{DECL_ATTRIBUTES}. -@var{new_decl_p} is always true when the hook is called for a constant. - -@cindex @code{SYMBOL_REF_FLAG}, in @code{TARGET_ENCODE_SECTION_INFO} -The usual thing for this hook to do is to record flags in the -@code{symbol_ref}, using @code{SYMBOL_REF_FLAG} or @code{SYMBOL_REF_FLAGS}. -Historically, the name string was modified if it was necessary to -encode more than one bit of information, but this practice is now -discouraged; use @code{SYMBOL_REF_FLAGS}. - -The default definition of this hook, @code{default_encode_section_info} -in @file{varasm.c}, sets a number of commonly-useful bits in -@code{SYMBOL_REF_FLAGS}. Check whether the default does what you need -before overriding it. -@end deftypefn @hook TARGET_STRIP_NAME_ENCODING -Decode @var{name} and return the real name part, sans -the characters that @code{TARGET_ENCODE_SECTION_INFO} -may have added. -@end deftypefn @hook TARGET_IN_SMALL_DATA_P -Returns true if @var{exp} should be placed into a ``small data'' section. -The default version of this hook always returns false. -@end deftypefn @hook TARGET_HAVE_SRODATA_SECTION -Contains the value true if the target places read-only -``small data'' into a separate section. The default value is false. -@end deftypevr @hook TARGET_PROFILE_BEFORE_PROLOGUE @hook TARGET_BINDS_LOCAL_P -Returns true if @var{exp} names an object for which name resolution -rules must resolve to the current ``module'' (dynamic shared library -or executable image). - -The default version of this hook implements the name resolution rules -for ELF, which has a looser model of global name binding than other -currently supported object file formats. -@end deftypefn @hook TARGET_HAVE_TLS -Contains the value true if the target supports thread-local storage. -The default value is false. -@end deftypevr @node PIC @@ -7166,39 +5328,12 @@ This describes the overall framework of an assembly file. @findex default_file_start @hook TARGET_ASM_FILE_START -Output to @code{asm_out_file} any text which the assembler expects to -find at the beginning of a file. The default behavior is controlled -by two flags, documented below. Unless your target's assembler is -quite unusual, if you override the default, you should call -@code{default_file_start} at some point in your target hook. This -lets other target files rely on these variables. -@end deftypefn @hook TARGET_ASM_FILE_START_APP_OFF -If this flag is true, the text of the macro @code{ASM_APP_OFF} will be -printed as the very first line in the assembly file, unless -@option{-fverbose-asm} is in effect. (If that macro has been defined -to the empty string, this variable has no effect.) With the normal -definition of @code{ASM_APP_OFF}, the effect is to notify the GNU -assembler that it need not bother stripping comments or extra -whitespace from its input. This allows it to work a bit faster. - -The default is false. You should not set it to true unless you have -verified that your port does not generate any extra whitespace or -comments that will cause GAS to issue errors in NO_APP mode. -@end deftypevr @hook TARGET_ASM_FILE_START_FILE_DIRECTIVE -If this flag is true, @code{output_file_directive} will be called -for the primary source file, immediately after printing -@code{ASM_APP_OFF} (if that is enabled). Most ELF assemblers expect -this to be done. The default is false. -@end deftypevr @hook TARGET_ASM_FILE_END -Output to @code{asm_out_file} any text which the assembler expects -to find at the end of a file. The default is to output nothing. -@end deftypefn @deftypefun void file_end_indicate_exec_stack () Some systems use a common convention, the @samp{.note.GNU-stack} @@ -7210,24 +5345,10 @@ this function. @end deftypefun @hook TARGET_ASM_LTO_START -Output to @code{asm_out_file} any text which the assembler expects -to find at the start of an LTO section. The default is to output -nothing. -@end deftypefn @hook TARGET_ASM_LTO_END -Output to @code{asm_out_file} any text which the assembler expects -to find at the end of an LTO section. The default is to output -nothing. -@end deftypefn @hook TARGET_ASM_CODE_END -Output to @code{asm_out_file} any text which is needed before emitting -unwind info and debug info at the end of a file. Some targets emit -here PIC setup thunks that cannot be emitted at the end of file, -because they couldn't have unwind info then. The default is to output -nothing. -@end deftypefn @defmac ASM_COMMENT_START A C string constant describing how to begin a comment in the target @@ -7272,22 +5393,8 @@ of the filename using this macro. @end defmac @hook TARGET_ASM_NAMED_SECTION -Output assembly directives to switch to section @var{name}. The section -should have attributes as specified by @var{flags}, which is a bit mask -of the @code{SECTION_*} flags defined in @file{output.h}. If @var{decl} -is non-NULL, it is the @code{VAR_DECL} or @code{FUNCTION_DECL} with which -this section is associated. -@end deftypefn @hook TARGET_ASM_FUNCTION_SECTION -Return preferred text (sub)section for function @var{decl}. -Main purpose of this function is to separate cold, normal and hot -functions. @var{startup} is true when function is known to be used only -at startup (from static constructors or it is @code{main()}). -@var{exit} is true when function is known to be used only at exit -(from static destructors). -Return NULL if function should go to default text section. -@end deftypefn @hook TARGET_ASM_FUNCTION_SWITCHED_TEXT_SECTIONS @@ -7298,74 +5405,12 @@ It must not be modified by command-line option processing. @anchor{TARGET_HAVE_SWITCHABLE_BSS_SECTIONS} @hook TARGET_HAVE_SWITCHABLE_BSS_SECTIONS -This flag is true if we can create zeroed data by switching to a BSS -section and then using @code{ASM_OUTPUT_SKIP} to allocate the space. -This is true on most ELF targets. -@end deftypevr @hook TARGET_SECTION_TYPE_FLAGS -Choose a set of section attributes for use by @code{TARGET_ASM_NAMED_SECTION} -based on a variable or function decl, a section name, and whether or not the -declaration's initializer may contain runtime relocations. @var{decl} may be -null, in which case read-write data should be assumed. - -The default version of this function handles choosing code vs data, -read-only vs read-write data, and @code{flag_pic}. You should only -need to override this if your target has special flags that might be -set via @code{__attribute__}. -@end deftypefn @hook TARGET_ASM_RECORD_GCC_SWITCHES -Provides the target with the ability to record the gcc command line -switches that have been passed to the compiler, and options that are -enabled. The @var{type} argument specifies what is being recorded. -It can take the following values: - -@table @gcctabopt -@item SWITCH_TYPE_PASSED -@var{text} is a command line switch that has been set by the user. - -@item SWITCH_TYPE_ENABLED -@var{text} is an option which has been enabled. This might be as a -direct result of a command line switch, or because it is enabled by -default or because it has been enabled as a side effect of a different -command line switch. For example, the @option{-O2} switch enables -various different individual optimization passes. - -@item SWITCH_TYPE_DESCRIPTIVE -@var{text} is either NULL or some descriptive text which should be -ignored. If @var{text} is NULL then it is being used to warn the -target hook that either recording is starting or ending. The first -time @var{type} is SWITCH_TYPE_DESCRIPTIVE and @var{text} is NULL, the -warning is for start up and the second time the warning is for -wind down. This feature is to allow the target hook to make any -necessary preparations before it starts to record switches and to -perform any necessary tidying up after it has finished recording -switches. - -@item SWITCH_TYPE_LINE_START -This option can be ignored by this target hook. - -@item SWITCH_TYPE_LINE_END -This option can be ignored by this target hook. -@end table - -The hook's return value must be zero. Other return values may be -supported in the future. - -By default this hook is set to NULL, but an example implementation is -provided for ELF based targets. Called @var{elf_record_gcc_switches}, -it records the switches as ASCII text inside a new, string mergeable -section in the assembler output file. The name of the new section is -provided by the @code{TARGET_ASM_RECORD_GCC_SWITCHES_SECTION} target -hook. -@end deftypefn @hook TARGET_ASM_RECORD_GCC_SWITCHES_SECTION -This is the name of the section that will be created by the example -ELF implementation of the @code{TARGET_ASM_RECORD_GCC_SWITCHES} target -hook. -@end deftypevr @need 2000 @node Data Output @@ -7373,49 +5418,10 @@ hook. @hook TARGET_ASM_BYTE_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_HI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_SI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_DI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_TI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_HI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_SI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_DI_OP -@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_TI_OP -These hooks specify assembly directives for creating certain kinds -of integer object. The @code{TARGET_ASM_BYTE_OP} directive creates a -byte-sized object, the @code{TARGET_ASM_ALIGNED_HI_OP} one creates an -aligned two-byte object, and so on. Any of the hooks may be -@code{NULL}, indicating that no suitable directive is available. - -The compiler will print these strings at the start of a new line, -followed immediately by the object's initial value. In most cases, -the string should contain a tab, a pseudo-op, and then another tab. -@end deftypevr @hook TARGET_ASM_INTEGER -The @code{assemble_integer} function uses this hook to output an -integer object. @var{x} is the object's value, @var{size} is its size -in bytes and @var{aligned_p} indicates whether it is aligned. The -function should return @code{true} if it was able to output the -object. If it returns false, @code{assemble_integer} will try to -split the object into smaller parts. - -The default implementation of this hook will use the -@code{TARGET_ASM_BYTE_OP} family of strings, returning @code{false} -when the relevant string is @code{NULL}. -@end deftypefn @hook TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA -A target hook to recognize @var{rtx} patterns that @code{output_addr_const} -can't deal with, and output assembly code to @var{file} corresponding to -the pattern @var{x}. This may be used to allow machine-dependent -@code{UNSPEC}s to appear within constants. - -If target hook fails to recognize a pattern, it must return @code{false}, -so that a standard error message is printed. If it prints an error message -itself, by calling, for example, @code{output_operand_lossage}, it may just -return @code{true}. -@end deftypefn @defmac ASM_OUTPUT_ASCII (@var{stream}, @var{ptr}, @var{len}) A C statement to output to the stdio stream @var{stream} an assembler @@ -7505,10 +5511,6 @@ the character @samp{;} is treated as a logical line separator. @end defmac @hook TARGET_ASM_OPEN_PAREN -These target hooks are C string constants, describing the syntax in the -assembler for grouping arithmetic expressions. If not overridden, they -default to normal parentheses, which is correct for most assemblers. -@end deftypevr These macros are provided by @file{real.h} for writing the definitions of @code{ASM_OUTPUT_DOUBLE} and the like: @@ -7798,18 +5800,6 @@ You may wish to use @code{ASM_OUTPUT_TYPE_DIRECTIVE} and/or @end defmac @hook TARGET_ASM_DECLARE_CONSTANT_NAME -A target hook to output to the stdio stream @var{file} any text necessary -for declaring the name @var{name} of a constant which is being defined. This -target hook is responsible for outputting the label definition (perhaps using -@code{assemble_label}). The argument @var{exp} is the value of the constant, -and @var{size} is the size of the constant in bytes. The @var{name} -will be an internal label. - -The default version of this target hook, define the @var{name} in the -usual manner as a label (by means of @code{assemble_label}). - -You may wish to use @code{ASM_OUTPUT_TYPE_DIRECTIVE} in this target hook. -@end deftypefn @defmac ASM_DECLARE_REGISTER_GLOBAL (@var{stream}, @var{decl}, @var{regno}, @var{name}) A C statement (sans semicolon) to output to the stdio stream @@ -7835,21 +5825,8 @@ You may wish to use @code{ASM_OUTPUT_SIZE_DIRECTIVE} and/or @end defmac @hook TARGET_ASM_GLOBALIZE_LABEL -This target hook is a function to output to the stdio stream -@var{stream} some commands that will make the label @var{name} global; -that is, available for reference from other files. - -The default implementation relies on a proper definition of -@code{GLOBAL_ASM_OP}. -@end deftypefn @hook TARGET_ASM_GLOBALIZE_DECL_NAME -This target hook is a function to output to the stdio stream -@var{stream} some commands that will make the name associated with @var{decl} -global; that is, available for reference from other files. - -The default implementation uses the TARGET_ASM_GLOBALIZE_LABEL target hook. -@end deftypefn @defmac ASM_WEAKEN_LABEL (@var{stream}, @var{name}) A C statement (sans semicolon) to output to the stdio stream @@ -7921,10 +5898,6 @@ be emitted as one-only. @end defmac @hook TARGET_ASM_ASSEMBLE_VISIBILITY -This target hook is a function to output to @var{asm_out_file} some -commands that will make the symbol(s) associated with @var{decl} have -hidden, protected or internal visibility as specified by @var{visibility}. -@end deftypefn @defmac TARGET_WEAK_NOT_IN_ARCHIVE_TOC A C expression that evaluates to true if the target's linker expects @@ -7957,16 +5930,8 @@ The GNU assembler and most Unix assemblers don't require anything. @end defmac @hook TARGET_ASM_EXTERNAL_LIBCALL -This target hook is a function to output to @var{asm_out_file} an assembler -pseudo-op to declare a library function name external. The name of the -library function is given by @var{symref}, which is a @code{symbol_ref}. -@end deftypefn @hook TARGET_ASM_MARK_DECL_PRESERVED -This target hook is a function to output to @var{asm_out_file} an assembler -directive to annotate @var{symbol} as used. The Darwin target uses the -.no_dead_code_strip directive. -@end deftypefn @defmac ASM_OUTPUT_LABELREF (@var{stream}, @var{name}) A C statement (sans semicolon) to output to the stdio stream @@ -7997,21 +5962,6 @@ being taken. @end defmac @hook TARGET_ASM_INTERNAL_LABEL -A function to output to the stdio stream @var{stream} a label whose -name is made from the string @var{prefix} and the number @var{labelno}. - -It is absolutely essential that these labels be distinct from the labels -used for user-level functions and variables. Otherwise, certain programs -will have name conflicts with internal labels. - -It is desirable to exclude internal labels from the symbol table of the -object file. Most assemblers have a naming convention for labels that -should be excluded; on many systems, the letter @samp{L} at the -beginning of a label has this effect. You should find out what -convention your system uses, and follow it. - -The default version of this function utilizes @code{ASM_GENERATE_INTERNAL_LABEL}. -@end deftypefn @defmac ASM_OUTPUT_DEBUG_LABEL (@var{stream}, @var{prefix}, @var{num}) A C statement to output to the stdio stream @var{stream} a debug info @@ -8322,30 +6272,10 @@ encountering an @code{init_priority} attribute. @end defmac @hook TARGET_HAVE_CTORS_DTORS -This value is true if the target supports some ``native'' method of -collecting constructors and destructors to be run at startup and exit. -It is false if we must use @command{collect2}. -@end deftypevr @hook TARGET_ASM_CONSTRUCTOR -If defined, a function that outputs assembler code to arrange to call -the function referenced by @var{symbol} at initialization time. - -Assume that @var{symbol} is a @code{SYMBOL_REF} for a function taking -no arguments and with no return value. If the target supports initialization -priorities, @var{priority} is a value between 0 and @code{MAX_INIT_PRIORITY}; -otherwise it must be @code{DEFAULT_INIT_PRIORITY}. - -If this macro is not defined by the target, a suitable default will -be chosen if (1) the target supports arbitrary section names, (2) the -target defines @code{CTORS_SECTION_ASM_OP}, or (3) @code{USE_COLLECT2} -is not defined. -@end deftypefn @hook TARGET_ASM_DESTRUCTOR -This is like @code{TARGET_ASM_CONSTRUCTOR} but used for termination -functions rather than initialization functions. -@end deftypefn If @code{TARGET_HAVE_CTORS_DTORS} is true, the initialization routine generated for the generated object file will have static linkage. @@ -8492,17 +6422,6 @@ If this macro is not defined, it is equivalent to a null statement. @end defmac @hook TARGET_ASM_FINAL_POSTSCAN_INSN -If defined, this target hook is a function which is executed just after the -output of assembler code for @var{insn}, to change the mode of the assembler -if necessary. - -Here the argument @var{opvec} is the vector containing the operands -extracted from @var{insn}, and @var{noperands} is the number of -elements of the vector which contain meaningful data for this insn. -The contents of this vector are what was used to convert the insn -template into assembler code, so you can change the assembler mode -by checking the contents of the vector. -@end deftypefn @defmac PRINT_OPERAND (@var{stream}, @var{x}, @var{code}) A C compound statement to output to stdio stream @var{stream} the @@ -8712,32 +6631,12 @@ the jump-table. @end defmac @hook TARGET_ASM_EMIT_UNWIND_LABEL -This target hook emits a label at the beginning of each FDE@. It -should be defined on targets where FDEs need special labels, and it -should write the appropriate label, for the FDE associated with the -function declaration @var{decl}, to the stdio stream @var{stream}. -The third argument, @var{for_eh}, is a boolean: true if this is for an -exception table. The fourth argument, @var{empty}, is a boolean: -true if this is a placeholder label for an omitted FDE@. - -The default is that FDEs are not given nonlocal labels. -@end deftypefn @hook TARGET_ASM_EMIT_EXCEPT_TABLE_LABEL -This target hook emits a label at the beginning of the exception table. -It should be defined on targets where it is desirable for the table -to be broken up according to function. - -The default is that no label is emitted. -@end deftypefn @hook TARGET_ASM_EMIT_EXCEPT_PERSONALITY @hook TARGET_ASM_UNWIND_EMIT -This target hook emits assembly directives required to unwind the -given instruction. This is only used when @code{TARGET_EXCEPT_UNWIND_INFO} -returns @code{UI_TARGET}. -@end deftypefn @hook TARGET_ASM_UNWIND_EMIT_BEFORE_INSN @@ -8845,43 +6744,14 @@ the target supports DWARF 2 frame unwind information. @end defmac @hook TARGET_TERMINATE_DW2_EH_FRAME_INFO -Contains the value true if the target should add a zero word onto the -end of a Dwarf-2 frame info section when used for exception handling. -Default value is false if @code{EH_FRAME_SECTION_NAME} is defined, and -true otherwise. -@end deftypevr @hook TARGET_DWARF_REGISTER_SPAN -Given a register, this hook should return a parallel of registers to -represent where to find the register pieces. Define this hook if the -register and its mode are represented in Dwarf in non-contiguous -locations, or if the register should be represented in more than one -register in Dwarf. Otherwise, this hook should return @code{NULL_RTX}. -If not defined, the default is to return @code{NULL_RTX}. -@end deftypefn @hook TARGET_INIT_DWARF_REG_SIZES_EXTRA -If some registers are represented in Dwarf-2 unwind information in -multiple pieces, define this hook to fill in information about the -sizes of those pieces in the table used by the unwinder at runtime. -It will be called by @code{expand_builtin_init_dwarf_reg_sizes} after -filling in a single size corresponding to each hard register; -@var{address} is the address of the table. -@end deftypefn @hook TARGET_ASM_TTYPE -This hook is used to output a reference from a frame unwinding table to -the type_info object identified by @var{sym}. It should return @code{true} -if the reference was output. Returning @code{false} will cause the -reference to be output using the normal Dwarf2 routines. -@end deftypefn @hook TARGET_ARM_EABI_UNWINDER -This flag should be set to @code{true} on targets that use an ARM EABI -based unwinding library, and @code{false} on other targets. This effects -the format of unwinding tables, and how the unwinder in entered after -running a cleanup. The default is @code{false}. -@end deftypevr @node Alignment Output @subsection Assembler Commands for Alignment @@ -8904,10 +6774,6 @@ selection in @var{align_jumps} in a @code{JUMP_ALIGN} implementation. @end defmac @hook TARGET_ASM_JUMP_ALIGN_MAX_SKIP -The maximum number of bytes to skip before @var{label} when applying -@code{JUMP_ALIGN}. This works only if -@code{ASM_OUTPUT_MAX_SKIP_ALIGN} is defined. -@end deftypefn @defmac LABEL_ALIGN_AFTER_BARRIER (@var{label}) The alignment (log base 2) to put in front of @var{label}, which follows @@ -8919,10 +6785,6 @@ define the macro. @end defmac @hook TARGET_ASM_LABEL_ALIGN_AFTER_BARRIER_MAX_SKIP -The maximum number of bytes to skip before @var{label} when applying -@code{LABEL_ALIGN_AFTER_BARRIER}. This works only if -@code{ASM_OUTPUT_MAX_SKIP_ALIGN} is defined. -@end deftypefn @defmac LOOP_ALIGN (@var{label}) The alignment (log base 2) to put in front of @var{label} that heads @@ -8939,10 +6801,6 @@ selection in @code{align_loops} in a @code{LOOP_ALIGN} implementation. @end defmac @hook TARGET_ASM_LOOP_ALIGN_MAX_SKIP -The maximum number of bytes to skip when applying @code{LOOP_ALIGN} to -@var{label}. This works only if @code{ASM_OUTPUT_MAX_SKIP_ALIGN} is -defined. -@end deftypefn @defmac LABEL_ALIGN (@var{label}) The alignment (log base 2) to put in front of @var{label}. @@ -8956,10 +6814,6 @@ selection in @code{align_labels} in a @code{LABEL_ALIGN} implementation. @end defmac @hook TARGET_ASM_LABEL_ALIGN_MAX_SKIP -The maximum number of bytes to skip when applying @code{LABEL_ALIGN} -to @var{label}. This works only if @code{ASM_OUTPUT_MAX_SKIP_ALIGN} -is defined. -@end deftypefn @defmac ASM_OUTPUT_SKIP (@var{stream}, @var{nbytes}) A C statement to output to the stdio stream @var{stream} an assembler @@ -9302,10 +7156,6 @@ Define this macro if GCC should produce dwarf version 2 format debugging output in response to the @option{-g} option. @hook TARGET_DWARF_CALLING_CONVENTION -Define this to enable the dwarf attribute @code{DW_AT_calling_convention} to -be emitted for each function. Instead of an integer return the enum -value for the @code{DW_CC_} tag. -@end deftypefn To support optional call frame debugging information, you must also define @code{INCOMING_RETURN_ADDR_RTX} and either set @@ -9323,17 +7173,6 @@ how you define @code{DWARF2_FRAME_INFO}. @end defmac @hook TARGET_DEBUG_UNWIND_INFO -This hook defines the mechanism that will be used for describing frame -unwind information to the debugger. Normally the hook will return -@code{UI_DWARF2} if DWARF 2 debug information is enabled, and -return @code{UI_NONE} otherwise. - -A target may return @code{UI_DWARF2} even when DWARF 2 debug information -is disabled in order to always output DWARF 2 frame information. - -A target may return @code{UI_TARGET} if it has ABI specified unwind tables. -This will suppress generation of the normal debug frame unwind information. -@end deftypefn @defmac DWARF2_ASM_LINE_DEBUG_INFO Define this macro to be a nonzero value if the assembler can generate Dwarf 2 @@ -9379,9 +7218,6 @@ is referenced by a function. @end defmac @hook TARGET_ASM_OUTPUT_DWARF_DTPREL -If defined, this target hook is a function which outputs a DTP-relative -reference to the given TLS symbol of the specified size. -@end deftypefn @defmac PUT_SDB_@dots{} Define these macros to override the assembler syntax for the special @@ -9633,64 +7469,16 @@ These are described using the following target hooks; they also need to be documented in @file{extend.texi}. @hook TARGET_ATTRIBUTE_TABLE -If defined, this target hook points to an array of @samp{struct -attribute_spec} (defined in @file{tree.h}) specifying the machine -specific attributes for this target and some of the restrictions on the -entities to which these attributes are applied and the arguments they -take. -@end deftypevr @hook TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P -If defined, this target hook is a function which returns true if the -machine-specific attribute named @var{name} expects an identifier -given as its first argument to be passed on as a plain identifier, not -subjected to name lookup. If this is not defined, the default is -false for all machine-specific attributes. -@end deftypefn @hook TARGET_COMP_TYPE_ATTRIBUTES -If defined, this target hook is a function which returns zero if the attributes on -@var{type1} and @var{type2} are incompatible, one if they are compatible, -and two if they are nearly compatible (which causes a warning to be -generated). If this is not defined, machine-specific attributes are -supposed always to be compatible. -@end deftypefn @hook TARGET_SET_DEFAULT_TYPE_ATTRIBUTES -If defined, this target hook is a function which assigns default attributes to -the newly defined @var{type}. -@end deftypefn @hook TARGET_MERGE_TYPE_ATTRIBUTES -Define this target hook if the merging of type attributes needs special -handling. If defined, the result is a list of the combined -@code{TYPE_ATTRIBUTES} of @var{type1} and @var{type2}. It is assumed -that @code{comptypes} has already been called and returned 1. This -function may call @code{merge_attributes} to handle machine-independent -merging. -@end deftypefn @hook TARGET_MERGE_DECL_ATTRIBUTES -Define this target hook if the merging of decl attributes needs special -handling. If defined, the result is a list of the combined -@code{DECL_ATTRIBUTES} of @var{olddecl} and @var{newdecl}. -@var{newdecl} is a duplicate declaration of @var{olddecl}. Examples of -when this is needed are when one attribute overrides another, or when an -attribute is nullified by a subsequent definition. This function may -call @code{merge_attributes} to handle machine-independent merging. - -@findex TARGET_DLLIMPORT_DECL_ATTRIBUTES -If the only target-specific handling you require is @samp{dllimport} -for Microsoft Windows targets, you should define the macro -@code{TARGET_DLLIMPORT_DECL_ATTRIBUTES} to @code{1}. The compiler -will then define a function called -@code{merge_dllimport_decl_attributes} which can then be defined as -the expansion of @code{TARGET_MERGE_DECL_ATTRIBUTES}. You can also -add @code{handle_dll_attribute} in the attribute table for your port -to perform initial processing of the @samp{dllimport} and -@samp{dllexport} attributes. This is done in @file{i386/cygwin.h} and -@file{i386/i386.c}, for example. -@end deftypefn @hook TARGET_VALID_DLLIMPORT_ATTRIBUTE_P @@ -9704,92 +7492,24 @@ on this implementation detail. @end defmac @hook TARGET_INSERT_ATTRIBUTES -Define this target hook if you want to be able to add attributes to a decl -when it is being created. This is normally useful for back ends which -wish to implement a pragma by using the attributes which correspond to -the pragma's effect. The @var{node} argument is the decl which is being -created. The @var{attr_ptr} argument is a pointer to the attribute list -for this decl. The list itself should not be modified, since it may be -shared with other decls, but attributes may be chained on the head of -the list and @code{*@var{attr_ptr}} modified to point to the new -attributes, or a copy of the list may be made if further changes are -needed. -@end deftypefn @hook TARGET_FUNCTION_ATTRIBUTE_INLINABLE_P -@cindex inlining -This target hook returns @code{true} if it is ok to inline @var{fndecl} -into the current function, despite its having target-specific -attributes, @code{false} otherwise. By default, if a function has a -target specific attribute attached to it, it will not be inlined. -@end deftypefn @hook TARGET_OPTION_VALID_ATTRIBUTE_P -This hook is called to parse @code{attribute(target("..."))}, which -allows setting target-specific options on individual functions. -These function-specific options may differ -from the options specified on the command line. The hook should return -@code{true} if the options are valid. - -The hook should set the @code{DECL_FUNCTION_SPECIFIC_TARGET} field in -the function declaration to hold a pointer to a target-specific -@code{struct cl_target_option} structure. -@end deftypefn @hook TARGET_OPTION_SAVE -This hook is called to save any additional target-specific information -in the @code{struct cl_target_option} structure for function-specific -options. -@xref{Option file format}. -@end deftypefn @hook TARGET_OPTION_RESTORE -This hook is called to restore any additional target-specific -information in the @code{struct cl_target_option} structure for -function-specific options. -@end deftypefn @hook TARGET_OPTION_PRINT -This hook is called to print any additional target-specific -information in the @code{struct cl_target_option} structure for -function-specific options. -@end deftypefn @hook TARGET_OPTION_PRAGMA_PARSE -This target hook parses the options for @code{#pragma GCC target}, which -sets the target-specific options for functions that occur later in the -input stream. The options accepted should be the same as those handled by the -@code{TARGET_OPTION_VALID_ATTRIBUTE_P} hook. -@end deftypefn @hook TARGET_OPTION_OVERRIDE -Sometimes certain combinations of command options do not make sense on -a particular target machine. You can override the hook -@code{TARGET_OPTION_OVERRIDE} to take account of this. This hooks is called -once just after all the command options have been parsed. - -Don't use this hook to turn on various extra optimizations for -@option{-O}. That is what @code{TARGET_OPTION_OPTIMIZATION} is for. - -If you need to do something whenever the optimization level is -changed via the optimize attribute or pragma, see -@code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE} -@end deftypefn @hook TARGET_OPTION_FUNCTION_VERSIONS -This target hook returns @code{true} if @var{DECL1} and @var{DECL2} are -versions of the same function. @var{DECL1} and @var{DECL2} are function -versions if and only if they have the same function signature and -different target specific attributes, that is, they are compiled for -different target machines. -@end deftypefn @hook TARGET_CAN_INLINE_P -This target hook returns @code{false} if the @var{caller} function -cannot inline @var{callee}, based on target specific information. By -default, inlining is not allowed if the callee function has function -specific target options and the caller does not use the same options. -@end deftypefn @node Emulated TLS @section Emulating TLS @@ -9808,66 +7528,24 @@ which, when given the address of the control object, will return the address of the current thread's instance of the TLS object. @hook TARGET_EMUTLS_GET_ADDRESS -Contains the name of the helper function that uses a TLS control -object to locate a TLS instance. The default causes libgcc's -emulated TLS helper function to be used. -@end deftypevr @hook TARGET_EMUTLS_REGISTER_COMMON -Contains the name of the helper function that should be used at -program startup to register TLS objects that are implicitly -initialized to zero. If this is @code{NULL}, all TLS objects will -have explicit initializers. The default causes libgcc's emulated TLS -registration function to be used. -@end deftypevr @hook TARGET_EMUTLS_VAR_SECTION -Contains the name of the section in which TLS control variables should -be placed. The default of @code{NULL} allows these to be placed in -any section. -@end deftypevr @hook TARGET_EMUTLS_TMPL_SECTION -Contains the name of the section in which TLS initializers should be -placed. The default of @code{NULL} allows these to be placed in any -section. -@end deftypevr @hook TARGET_EMUTLS_VAR_PREFIX -Contains the prefix to be prepended to TLS control variable names. -The default of @code{NULL} uses a target-specific prefix. -@end deftypevr @hook TARGET_EMUTLS_TMPL_PREFIX -Contains the prefix to be prepended to TLS initializer objects. The -default of @code{NULL} uses a target-specific prefix. -@end deftypevr @hook TARGET_EMUTLS_VAR_FIELDS -Specifies a function that generates the FIELD_DECLs for a TLS control -object type. @var{type} is the RECORD_TYPE the fields are for and -@var{name} should be filled with the structure tag, if the default of -@code{__emutls_object} is unsuitable. The default creates a type suitable -for libgcc's emulated TLS function. -@end deftypefn @hook TARGET_EMUTLS_VAR_INIT -Specifies a function that generates the CONSTRUCTOR to initialize a -TLS control object. @var{var} is the TLS control object, @var{decl} -is the TLS object and @var{tmpl_addr} is the address of the -initializer. The default initializes libgcc's emulated TLS control object. -@end deftypefn @hook TARGET_EMUTLS_VAR_ALIGN_FIXED -Specifies whether the alignment of TLS control variable objects is -fixed and should not be increased as some backends may do to optimize -single objects. The default is false. -@end deftypevr @hook TARGET_EMUTLS_DEBUG_FORM_TLS_ADDRESS -Specifies whether a DWARF @code{DW_OP_form_tls_address} location descriptor -may be used to describe emulated TLS control objects. -@end deftypevr @node MIPS Coprocessors @section Defining coprocessor specifics for MIPS targets. @@ -9905,33 +7583,10 @@ you may want to override in subtargets; it is described below. @cindex parameters, precompiled headers @hook TARGET_GET_PCH_VALIDITY -This hook returns a pointer to the data needed by -@code{TARGET_PCH_VALID_P} and sets -@samp{*@var{sz}} to the size of the data in bytes. -@end deftypefn @hook TARGET_PCH_VALID_P -This hook checks whether the options used to create a PCH file are -compatible with the current settings. It returns @code{NULL} -if so and a suitable error message if not. Error messages will -be presented to the user and must be localized using @samp{_(@var{msg})}. - -@var{data} is the data that was returned by @code{TARGET_GET_PCH_VALIDITY} -when the PCH file was created and @var{sz} is the size of that data in bytes. -It's safe to assume that the data was created by the same version of the -compiler, so no format checking is needed. - -The default definition of @code{default_pch_valid_p} should be -suitable for most targets. -@end deftypefn @hook TARGET_CHECK_PCH_TARGET_FLAGS -If this hook is nonnull, the default implementation of -@code{TARGET_PCH_VALID_P} will use it to check for compatible values -of @code{target_flags}. @var{pch_flags} specifies the value that -@code{target_flags} had when the PCH file was created. The return -value is the same as for @code{TARGET_PCH_VALID_P}. -@end deftypefn @hook TARGET_PREPARE_PCH_SAVE @@ -9940,84 +7595,28 @@ value is the same as for @code{TARGET_PCH_VALID_P}. @cindex parameters, c++ abi @hook TARGET_CXX_GUARD_TYPE -Define this hook to override the integer type used for guard variables. -These are used to implement one-time construction of static objects. The -default is long_long_integer_type_node. -@end deftypefn @hook TARGET_CXX_GUARD_MASK_BIT -This hook determines how guard variables are used. It should return -@code{false} (the default) if the first byte should be used. A return value of -@code{true} indicates that only the least significant bit should be used. -@end deftypefn @hook TARGET_CXX_GET_COOKIE_SIZE -This hook returns the size of the cookie to use when allocating an array -whose elements have the indicated @var{type}. Assumes that it is already -known that a cookie is needed. The default is -@code{max(sizeof (size_t), alignof(type))}, as defined in section 2.7 of the -IA64/Generic C++ ABI@. -@end deftypefn @hook TARGET_CXX_COOKIE_HAS_SIZE -This hook should return @code{true} if the element size should be stored in -array cookies. The default is to return @code{false}. -@end deftypefn @hook TARGET_CXX_IMPORT_EXPORT_CLASS -If defined by a backend this hook allows the decision made to export -class @var{type} to be overruled. Upon entry @var{import_export} -will contain 1 if the class is going to be exported, @minus{}1 if it is going -to be imported and 0 otherwise. This function should return the -modified value and perform any other actions necessary to support the -backend's targeted operating system. -@end deftypefn @hook TARGET_CXX_CDTOR_RETURNS_THIS -This hook should return @code{true} if constructors and destructors return -the address of the object created/destroyed. The default is to return -@code{false}. -@end deftypefn @hook TARGET_CXX_KEY_METHOD_MAY_BE_INLINE -This hook returns true if the key method for a class (i.e., the method -which, if defined in the current translation unit, causes the virtual -table to be emitted) may be an inline function. Under the standard -Itanium C++ ABI the key method may be an inline function so long as -the function is not declared inline in the class definition. Under -some variants of the ABI, an inline function can never be the key -method. The default is to return @code{true}. -@end deftypefn @hook TARGET_CXX_DETERMINE_CLASS_DATA_VISIBILITY @hook TARGET_CXX_CLASS_DATA_ALWAYS_COMDAT -This hook returns true (the default) if virtual tables and other -similar implicit class data objects are always COMDAT if they have -external linkage. If this hook returns false, then class data for -classes whose virtual table will be emitted in only one translation -unit will not be COMDAT. -@end deftypefn @hook TARGET_CXX_LIBRARY_RTTI_COMDAT -This hook returns true (the default) if the RTTI information for -the basic types which is defined in the C++ runtime should always -be COMDAT, false if it should not be COMDAT. -@end deftypefn @hook TARGET_CXX_USE_AEABI_ATEXIT -This hook returns true if @code{__aeabi_atexit} (as defined by the ARM EABI) -should be used to register static destructors when @option{-fuse-cxa-atexit} -is in effect. The default is to return false to use @code{__cxa_atexit}. -@end deftypefn @hook TARGET_CXX_USE_ATEXIT_FOR_CXA_ATEXIT -This hook returns true if the target @code{atexit} function can be used -in the same manner as @code{__cxa_atexit} to register C++ static -destructors. This requires that @code{atexit}-registered functions in -shared libraries are run in the correct order when the libraries are -unloaded. The default is to return false. -@end deftypefn @hook TARGET_CXX_ADJUST_CLASS_AT_DEFINITION @@ -10062,62 +7661,18 @@ c_register_addr_space ("__ea", ADDR_SPACE_EA); @end smallexample @hook TARGET_ADDR_SPACE_POINTER_MODE -Define this to return the machine mode to use for pointers to -@var{address_space} if the target supports named address spaces. -The default version of this hook returns @code{ptr_mode} for the -generic address space only. -@end deftypefn @hook TARGET_ADDR_SPACE_ADDRESS_MODE -Define this to return the machine mode to use for addresses in -@var{address_space} if the target supports named address spaces. -The default version of this hook returns @code{Pmode} for the -generic address space only. -@end deftypefn @hook TARGET_ADDR_SPACE_VALID_POINTER_MODE -Define this to return nonzero if the port can handle pointers -with machine mode @var{mode} to address space @var{as}. This target -hook is the same as the @code{TARGET_VALID_POINTER_MODE} target hook, -except that it includes explicit named address space support. The default -version of this hook returns true for the modes returned by either the -@code{TARGET_ADDR_SPACE_POINTER_MODE} or @code{TARGET_ADDR_SPACE_ADDRESS_MODE} -target hooks for the given address space. -@end deftypefn @hook TARGET_ADDR_SPACE_LEGITIMATE_ADDRESS_P -Define this to return true if @var{exp} is a valid address for mode -@var{mode} in the named address space @var{as}. The @var{strict} -parameter says whether strict addressing is in effect after reload has -finished. This target hook is the same as the -@code{TARGET_LEGITIMATE_ADDRESS_P} target hook, except that it includes -explicit named address space support. -@end deftypefn @hook TARGET_ADDR_SPACE_LEGITIMIZE_ADDRESS -Define this to modify an invalid address @var{x} to be a valid address -with mode @var{mode} in the named address space @var{as}. This target -hook is the same as the @code{TARGET_LEGITIMIZE_ADDRESS} target hook, -except that it includes explicit named address space support. -@end deftypefn @hook TARGET_ADDR_SPACE_SUBSET_P -Define this to return whether the @var{subset} named address space is -contained within the @var{superset} named address space. Pointers to -a named address space that is a subset of another named address space -will be converted automatically without a cast if used together in -arithmetic operations. Pointers to a superset address space can be -converted to pointers to a subset address space via explicit casts. -@end deftypefn @hook TARGET_ADDR_SPACE_CONVERT -Define this to convert the pointer expression represented by the RTL -@var{op} with type @var{from_type} that points to a named address -space to a new pointer expression with type @var{to_type} that points -to a different named address space. When this hook it called, it is -guaranteed that one of the two address spaces is a subset of the other, -as determined by the @code{TARGET_ADDR_SPACE_SUBSET_P} target hook. -@end deftypefn @node Misc @section Miscellaneous Parameters @@ -10168,11 +7723,6 @@ is in effect. @end defmac @hook TARGET_CASE_VALUES_THRESHOLD -This function return the smallest number of different values for which it -is best to use a jump-table instead of a tree of conditional branches. -The default is four for machines with a @code{casesi} instruction and -five otherwise. This is best for most machines. -@end deftypefn @defmac WORD_REGISTER_OPERATIONS Define this macro if operations between registers with integral mode @@ -10213,13 +7763,6 @@ extends. @end defmac @hook TARGET_MIN_DIVISIONS_FOR_RECIP_MUL -When @option{-ffast-math} is in effect, GCC tries to optimize -divisions by the same divisor, by turning them into multiplications by -the reciprocal. This target hook specifies the minimum number of divisions -that should be there for GCC to perform the optimization for a variable -of mode @var{mode}. The default implementation returns 3 if the machine -has an instruction for the division, and 2 if it does not. -@end deftypefn @defmac MOVE_MAX The maximum number of bytes that a single instruction can move quickly @@ -10261,28 +7804,6 @@ You need not define this macro if it would always have the value of zero. @anchor{TARGET_SHIFT_TRUNCATION_MASK} @hook TARGET_SHIFT_TRUNCATION_MASK -This function describes how the standard shift patterns for @var{mode} -deal with shifts by negative amounts or by more than the width of the mode. -@xref{shift patterns}. - -On many machines, the shift patterns will apply a mask @var{m} to the -shift count, meaning that a fixed-width shift of @var{x} by @var{y} is -equivalent to an arbitrary-width shift of @var{x} by @var{y & m}. If -this is true for mode @var{mode}, the function should return @var{m}, -otherwise it should return 0. A return value of 0 indicates that no -particular behavior is guaranteed. - -Note that, unlike @code{SHIFT_COUNT_TRUNCATED}, this function does -@emph{not} apply to general shift rtxes; it applies only to instructions -that are generated by the named shift patterns. - -The default implementation of this function returns -@code{GET_MODE_BITSIZE (@var{mode}) - 1} if @code{SHIFT_COUNT_TRUNCATED} -and 0 otherwise. This definition is always safe, but if -@code{SHIFT_COUNT_TRUNCATED} is false, and some shift patterns -nevertheless truncate the shift count, you may get better code -by overriding it. -@end deftypefn @defmac TRULY_NOOP_TRUNCATION (@var{outprec}, @var{inprec}) A C expression which is nonzero if on this machine it is safe to @@ -10301,32 +7822,6 @@ such cases may improve things. @end defmac @hook TARGET_MODE_REP_EXTENDED -The representation of an integral mode can be such that the values -are always extended to a wider integral mode. Return -@code{SIGN_EXTEND} if values of @var{mode} are represented in -sign-extended form to @var{rep_mode}. Return @code{UNKNOWN} -otherwise. (Currently, none of the targets use zero-extended -representation this way so unlike @code{LOAD_EXTEND_OP}, -@code{TARGET_MODE_REP_EXTENDED} is expected to return either -@code{SIGN_EXTEND} or @code{UNKNOWN}. Also no target extends -@var{mode} to @var{rep_mode} so that @var{rep_mode} is not the next -widest integral mode and currently we take advantage of this fact.) - -Similarly to @code{LOAD_EXTEND_OP} you may return a non-@code{UNKNOWN} -value even if the extension is not performed on certain hard registers -as long as for the @code{REGNO_REG_CLASS} of these hard registers -@code{CANNOT_CHANGE_MODE_CLASS} returns nonzero. - -Note that @code{TARGET_MODE_REP_EXTENDED} and @code{LOAD_EXTEND_OP} -describe two related properties. If you define -@code{TARGET_MODE_REP_EXTENDED (mode, word_mode)} you probably also want -to define @code{LOAD_EXTEND_OP (mode)} to return the same type of -extension. - -In order to enforce the representation of @code{mode}, -@code{TRULY_NOOP_TRUNCATION} should return false when truncating to -@code{mode}. -@end deftypefn @defmac STORE_FLAG_VALUE A C expression describing the value returned by a comparison operator @@ -10629,15 +8124,6 @@ You need not define this macro if it would always evaluate to zero. @end defmac @hook TARGET_MD_ASM_CLOBBERS -This target hook should add to @var{clobbers} @code{STRING_CST} trees for -any hard regs the port wishes to automatically clobber for an asm. -It should return the result of the last @code{tree_cons} used to add a -clobber. The @var{outputs}, @var{inputs} and @var{clobber} lists are the -corresponding parameters to the asm and may be inspected to avoid -clobbering a register that is an input or output of the asm. You can use -@code{tree_overlaps_hard_reg_set}, declared in @file{tree.h}, to test -for overlap with regards to asm-declared registers. -@end deftypefn @defmac MATH_LIBRARY Define this macro as a C string constant for the linker argument to link @@ -10718,119 +8204,27 @@ to by @var{ce_info}. @end defmac @hook TARGET_MACHINE_DEPENDENT_REORG -If non-null, this hook performs a target-specific pass over the -instruction stream. The compiler will run it at all optimization levels, -just before the point at which it normally does delayed-branch scheduling. - -The exact purpose of the hook varies from target to target. Some use -it to do transformations that are necessary for correctness, such as -laying out in-function constant pools or avoiding hardware hazards. -Others use it as an opportunity to do some machine-dependent optimizations. - -You need not implement the hook if it has nothing to do. The default -definition is null. -@end deftypefn @hook TARGET_INIT_BUILTINS -Define this hook if you have any machine-specific built-in functions -that need to be defined. It should be a function that performs the -necessary setup. - -Machine specific built-in functions can be useful to expand special machine -instructions that would otherwise not normally be generated because -they have no equivalent in the source language (for example, SIMD vector -instructions or prefetch instructions). - -To create a built-in function, call the function -@code{lang_hooks.builtin_function} -which is defined by the language front end. You can use any type nodes set -up by @code{build_common_tree_nodes}; -only language front ends that use those two functions will call -@samp{TARGET_INIT_BUILTINS}. -@end deftypefn @hook TARGET_BUILTIN_DECL -Define this hook if you have any machine-specific built-in functions -that need to be defined. It should be a function that returns the -builtin function declaration for the builtin function code @var{code}. -If there is no such builtin and it cannot be initialized at this time -if @var{initialize_p} is true the function should return @code{NULL_TREE}. -If @var{code} is out of range the function should return -@code{error_mark_node}. -@end deftypefn @hook TARGET_EXPAND_BUILTIN -Expand a call to a machine specific built-in function that was set up by -@samp{TARGET_INIT_BUILTINS}. @var{exp} is the expression for the -function call; the result should go to @var{target} if that is -convenient, and have mode @var{mode} if that is convenient. -@var{subtarget} may be used as the target for computing one of -@var{exp}'s operands. @var{ignore} is nonzero if the value is to be -ignored. This function should return the result of the call to the -built-in function. -@end deftypefn - @hook TARGET_RESOLVE_OVERLOADED_BUILTIN -Select a replacement for a machine specific built-in function that -was set up by @samp{TARGET_INIT_BUILTINS}. This is done -@emph{before} regular type checking, and so allows the target to -implement a crude form of function overloading. @var{fndecl} is the -declaration of the built-in function. @var{arglist} is the list of -arguments passed to the built-in function. The result is a -complete expression that implements the operation, usually -another @code{CALL_EXPR}. -@var{arglist} really has type @samp{VEC(tree,gc)*} -@end deftypefn @hook TARGET_FOLD_BUILTIN -Fold a call to a machine specific built-in function that was set up by -@samp{TARGET_INIT_BUILTINS}. @var{fndecl} is the declaration of the -built-in function. @var{n_args} is the number of arguments passed to -the function; the arguments themselves are pointed to by @var{argp}. -The result is another tree, valid for both GIMPLE and GENERIC, -containing a simplified expression for the call's result. If -@var{ignore} is true the value will be ignored. -@end deftypefn @hook TARGET_GIMPLE_FOLD_BUILTIN @hook TARGET_COMPARE_VERSION_PRIORITY -This hook is used to compare the target attributes in two functions to -determine which function's features get higher priority. This is used -during function multi-versioning to figure out the order in which two -versions must be dispatched. A function version with a higher priority -is checked for dispatching earlier. @var{decl1} and @var{decl2} are - the two function decls that will be compared. -@end deftypefn @hook TARGET_GET_FUNCTION_VERSIONS_DISPATCHER -This hook is used to get the dispatcher function for a set of function -versions. The dispatcher function is called to invoke the right function -version at run-time. @var{decl} is one version from a set of semantically -identical versions. -@end deftypefn @hook TARGET_GENERATE_VERSION_DISPATCHER_BODY -This hook is used to generate the dispatcher logic to invoke the right -function version at run-time for a given set of function versions. -@var{arg} points to the callgraph node of the dispatcher function whose -body must be generated. -@end deftypefn @hook TARGET_INVALID_WITHIN_DOLOOP -Take an instruction in @var{insn} and return NULL if it is valid within a -low-overhead loop, otherwise return a string explaining why doloop -could not be applied. - -Many targets use special registers for low-overhead looping. For any -instruction that clobbers these this function should return a string indicating -the reason why the doloop could not be applied. -By default, the RTL loop optimizer does not use a present doloop pattern for -loops containing function calls or branch on table instructions. -@end deftypefn - @hook TARGET_LEGITIMATE_COMBINED_INSN @defmac MD_CAN_REDIRECT_BRANCH (@var{branch1}, @var{branch2}) @@ -10847,61 +8241,12 @@ may in turn cause a branch offset to overflow. @hook TARGET_CAN_FOLLOW_JUMP @hook TARGET_COMMUTATIVE_P -This target hook returns @code{true} if @var{x} is considered to be commutative. -Usually, this is just COMMUTATIVE_P (@var{x}), but the HP PA doesn't consider -PLUS to be commutative inside a MEM@. @var{outer_code} is the rtx code -of the enclosing rtl, if known, otherwise it is UNKNOWN. -@end deftypefn @hook TARGET_ALLOCATE_INITIAL_VALUE -When the initial value of a hard register has been copied in a pseudo -register, it is often not necessary to actually allocate another register -to this pseudo register, because the original hard register or a stack slot -it has been saved into can be used. @code{TARGET_ALLOCATE_INITIAL_VALUE} -is called at the start of register allocation once for each hard register -that had its initial value copied by using -@code{get_func_hard_reg_initial_val} or @code{get_hard_reg_initial_val}. -Possible values are @code{NULL_RTX}, if you don't want -to do any special allocation, a @code{REG} rtx---that would typically be -the hard register itself, if it is known not to be clobbered---or a -@code{MEM}. -If you are returning a @code{MEM}, this is only a hint for the allocator; -it might decide to use another register anyways. -You may use @code{current_function_is_leaf} or -@code{REG_N_SETS} in the hook to determine if the hard -register in question will not be clobbered. -The default value of this hook is @code{NULL}, which disables any special -allocation. -@end deftypefn - @hook TARGET_UNSPEC_MAY_TRAP_P -This target hook returns nonzero if @var{x}, an @code{unspec} or -@code{unspec_volatile} operation, might cause a trap. Targets can use -this hook to enhance precision of analysis for @code{unspec} and -@code{unspec_volatile} operations. You may call @code{may_trap_p_1} -to analyze inner elements of @var{x} in which case @var{flags} should be -passed along. -@end deftypefn @hook TARGET_SET_CURRENT_FUNCTION -The compiler invokes this hook whenever it changes its current function -context (@code{cfun}). You can define this function if -the back end needs to perform any initialization or reset actions on a -per-function basis. For example, it may be used to implement function -attributes that affect register usage or code generation patterns. -The argument @var{decl} is the declaration for the new function context, -and may be null to indicate that the compiler has left a function context -and is returning to processing at the top level. -The default hook function does nothing. - -GCC sets @code{cfun} to a dummy function context during initialization of -some parts of the back end. The hook function is not invoked in this -situation; you need not worry about the hook being invoked recursively, -or when the back end is in a partially-initialized state. -@code{cfun} might be @code{NULL} to indicate processing at top level, -outside of any function scope. -@end deftypefn @defmac TARGET_OBJECT_SUFFIX Define this macro to be a C string representing the suffix for object @@ -10941,56 +8286,14 @@ build_type_attribute_variant (@var{mdecl}, @end defmac @hook TARGET_CANNOT_MODIFY_JUMPS_P -This target hook returns @code{true} past the point in which new jump -instructions could be created. On machines that require a register for -every jump such as the SHmedia ISA of SH5, this point would typically be -reload, so this target hook should be defined to a function such as: - -@smallexample -static bool -cannot_modify_jumps_past_reload_p () -@{ - return (reload_completed || reload_in_progress); -@} -@end smallexample -@end deftypefn @hook TARGET_BRANCH_TARGET_REGISTER_CLASS -This target hook returns a register class for which branch target register -optimizations should be applied. All registers in this class should be -usable interchangeably. After reload, registers in this class will be -re-allocated and loads will be hoisted out of loops and be subjected -to inter-block scheduling. -@end deftypefn @hook TARGET_BRANCH_TARGET_REGISTER_CALLEE_SAVED -Branch target register optimization will by default exclude callee-saved -registers -that are not already live during the current function; if this target hook -returns true, they will be included. The target code must than make sure -that all target registers in the class returned by -@samp{TARGET_BRANCH_TARGET_REGISTER_CLASS} that might need saving are -saved. @var{after_prologue_epilogue_gen} indicates if prologues and -epilogues have already been generated. Note, even if you only return -true when @var{after_prologue_epilogue_gen} is false, you still are likely -to have to make special provisions in @code{INITIAL_ELIMINATION_OFFSET} -to reserve space for caller-saved target registers. -@end deftypefn @hook TARGET_HAVE_CONDITIONAL_EXECUTION -This target hook returns true if the target supports conditional execution. -This target hook is required only when the target has several different -modes and they have different conditional execution capability, such as ARM. -@end deftypefn @hook TARGET_LOOP_UNROLL_ADJUST -This target hook returns a new value for the number of times @var{loop} -should be unrolled. The parameter @var{nunroll} is the number of times -the loop is to be unrolled. The parameter @var{loop} is a pointer to -the loop, which is going to be checked for unrolling. This target hook -is required only when the target has special constraints like maximum -number of memory accesses. -@end deftypefn @defmac POWI_MAX_MULTS If defined, this macro is interpreted as a signed integer C expression @@ -11062,72 +8365,22 @@ and scanf formatter settings. @end defmac @hook TARGET_RELAXED_ORDERING -If set to @code{true}, means that the target's memory model does not -guarantee that loads which do not depend on one another will access -main memory in the order of the instruction stream; if ordering is -important, an explicit memory barrier must be used. This is true of -many recent processors which implement a policy of ``relaxed,'' -``weak,'' or ``release'' memory consistency, such as Alpha, PowerPC, -and ia64. The default is @code{false}. -@end deftypevr @hook TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN -If defined, this macro returns the diagnostic message when it is -illegal to pass argument @var{val} to function @var{funcdecl} -with prototype @var{typelist}. -@end deftypefn @hook TARGET_INVALID_CONVERSION -If defined, this macro returns the diagnostic message when it is -invalid to convert from @var{fromtype} to @var{totype}, or @code{NULL} -if validity should be determined by the front end. -@end deftypefn @hook TARGET_INVALID_UNARY_OP -If defined, this macro returns the diagnostic message when it is -invalid to apply operation @var{op} (where unary plus is denoted by -@code{CONVERT_EXPR}) to an operand of type @var{type}, or @code{NULL} -if validity should be determined by the front end. -@end deftypefn @hook TARGET_INVALID_BINARY_OP -If defined, this macro returns the diagnostic message when it is -invalid to apply operation @var{op} to operands of types @var{type1} -and @var{type2}, or @code{NULL} if validity should be determined by -the front end. -@end deftypefn @hook TARGET_INVALID_PARAMETER_TYPE -If defined, this macro returns the diagnostic message when it is -invalid for functions to include parameters of type @var{type}, -or @code{NULL} if validity should be determined by -the front end. This is currently used only by the C and C++ front ends. -@end deftypefn @hook TARGET_INVALID_RETURN_TYPE -If defined, this macro returns the diagnostic message when it is -invalid for functions to have return type @var{type}, -or @code{NULL} if validity should be determined by -the front end. This is currently used only by the C and C++ front ends. -@end deftypefn @hook TARGET_PROMOTED_TYPE -If defined, this target hook returns the type to which values of -@var{type} should be promoted when they appear in expressions, -analogous to the integer promotions, or @code{NULL_TREE} to use the -front end's normal promotion rules. This hook is useful when there are -target-specific types with special promotion rules. -This is currently used only by the C and C++ front ends. -@end deftypefn @hook TARGET_CONVERT_TO_TYPE -If defined, this hook returns the result of converting @var{expr} to -@var{type}. It should return the converted expression, -or @code{NULL_TREE} to apply the front end's normal conversion rules. -This hook is useful when there are target-specific types with special -conversion rules. -This is currently used only by the C and C++ front ends. -@end deftypefn @defmac TARGET_USE_JCR_SECTION This macro determines whether to use the JCR section to register Java @@ -11148,52 +8401,16 @@ and the associated definitions of those functions. @end defmac @hook TARGET_UPDATE_STACK_BOUNDARY -Define this macro to update the current function stack boundary if -necessary. -@end deftypefn @hook TARGET_GET_DRAP_RTX -This hook should return an rtx for Dynamic Realign Argument Pointer (DRAP) if a -different argument pointer register is needed to access the function's -argument list due to stack realignment. Return @code{NULL} if no DRAP -is needed. -@end deftypefn @hook TARGET_ALLOCATE_STACK_SLOTS_FOR_ARGS -When optimization is disabled, this hook indicates whether or not -arguments should be allocated to stack slots. Normally, GCC allocates -stacks slots for arguments when not optimizing in order to make -debugging easier. However, when a function is declared with -@code{__attribute__((naked))}, there is no stack frame, and the compiler -cannot safely move arguments from the registers in which they are passed -to the stack. Therefore, this hook should return true in general, but -false for naked functions. The default implementation always returns true. -@end deftypefn @hook TARGET_CONST_ANCHOR -On some architectures it can take multiple instructions to synthesize -a constant. If there is another constant already in a register that -is close enough in value then it is preferable that the new constant -is computed from this register using immediate addition or -subtraction. We accomplish this through CSE. Besides the value of -the constant we also add a lower and an upper constant anchor to the -available expressions. These are then queried when encountering new -constants. The anchors are computed by rounding the constant up and -down to a multiple of the value of @code{TARGET_CONST_ANCHOR}. -@code{TARGET_CONST_ANCHOR} should be the maximum positive value -accepted by immediate-add plus one. We currently assume that the -value of @code{TARGET_CONST_ANCHOR} is a power of 2. For example, on -MIPS, where add-immediate takes a 16-bit signed value, -@code{TARGET_CONST_ANCHOR} is set to @samp{0x8000}. The default value -is zero, which disables this optimization. -@end deftypevr @hook TARGET_ASAN_SHADOW_OFFSET @hook TARGET_MEMMODEL_CHECK -Validate target specific memory model mask bits. When NULL no target specific -memory model bits are allowed. -@end deftypefn @hook TARGET_ATOMIC_TEST_AND_SET_TRUEVAL diff --git a/gcc/fold-const.c b/gcc/fold-const.c index a8e5f43faf4..6506ae7bbfb 100644 --- a/gcc/fold-const.c +++ b/gcc/fold-const.c @@ -15606,6 +15606,8 @@ tree_call_nonnegative_warnv_p (tree type, tree fndecl, CASE_INT_FN (BUILT_IN_FFS): CASE_INT_FN (BUILT_IN_PARITY): CASE_INT_FN (BUILT_IN_POPCOUNT): + CASE_INT_FN (BUILT_IN_CLZ): + CASE_INT_FN (BUILT_IN_CLRSB): case BUILT_IN_BSWAP32: case BUILT_IN_BSWAP64: /* Always true. */ diff --git a/gcc/fortran/ChangeLog b/gcc/fortran/ChangeLog index f85e2ebfa6b..283521a22ce 100644 --- a/gcc/fortran/ChangeLog +++ b/gcc/fortran/ChangeLog @@ -1,3 +1,28 @@ +2013-07-08 Tobias Burnus <burnus@net-b.de> + + PR fortran/57834 + * check.c (is_c_interoperable): Add special case for c_f_pointer. + (explicit-size, gfc_check_c_f_pointer, gfc_check_c_loc): Update + call. + +2013-07-08 Tobias Burnus <burnus@net-b.de> + + PR fortran/50554 + * io.c (match_inquire_element): Add missing do-var check. + +2013-07-08 Tobias Burnus <burnus@net-b.de> + + PR fortran/57785 + * simplify.c (compute_dot_product): Complex conjugate for + dot_product. + (gfc_simplify_dot_product, gfc_simplify_matmul): Update call. + +2013-07-08 Tobias Burnus <burnus@net-b.de> + + PR fortran/57469 + * trans-decl.c (generate_local_decl): Don't warn that + a dummy is unused, when it is in a namelist. + 2013-07-01 Dominique d'Humieres <dominiq@lps.ens.fr> PR fortran/54788 @@ -628,7 +653,7 @@ * class.c (finalization_scalarizer, finalizer_insert_packed_call, generate_finalization_wrapper): Avoid segfault with absent SIZE= - argment to TRANSFER and use correct result kind for SIZE. + argument to TRANSFER and use correct result kind for SIZE. * intrinsic.c (gfc_isym_id_by_intmod): Also handle ids of nonmodules. * trans.c (gfc_build_final_call): Handle coarrays. diff --git a/gcc/fortran/check.c b/gcc/fortran/check.c index e531deb147a..4024cd45652 100644 --- a/gcc/fortran/check.c +++ b/gcc/fortran/check.c @@ -3650,10 +3650,11 @@ gfc_check_sizeof (gfc_expr *arg) otherwise, it is set to NULL. The msg string can be used in diagnostics. If c_loc is true, character with len > 1 are allowed (cf. Fortran 2003corr5); additionally, assumed-shape/assumed-rank/deferred-shape - arrays are permitted. */ + arrays are permitted. And if c_f_ptr is true, deferred-shape arrays + are permitted. */ static bool -is_c_interoperable (gfc_expr *expr, const char **msg, bool c_loc) +is_c_interoperable (gfc_expr *expr, const char **msg, bool c_loc, bool c_f_ptr) { *msg = NULL; @@ -3734,7 +3735,8 @@ is_c_interoperable (gfc_expr *expr, const char **msg, bool c_loc) *msg = "Only whole-arrays are interoperable"; return false; } - if (ar->as->type != AS_EXPLICIT && ar->as->type != AS_ASSUMED_SIZE) + if (!c_f_ptr && ar->as->type != AS_EXPLICIT + && ar->as->type != AS_ASSUMED_SIZE) { *msg = "Only explicit-size and assumed-size arrays are interoperable"; return false; @@ -3750,7 +3752,7 @@ gfc_check_c_sizeof (gfc_expr *arg) { const char *msg; - if (!is_c_interoperable (arg, &msg, false)) + if (!is_c_interoperable (arg, &msg, false, false)) { gfc_error ("'%s' argument of '%s' intrinsic at %L must be an " "interoperable data entity: %s", @@ -3900,7 +3902,7 @@ gfc_check_c_f_pointer (gfc_expr *cptr, gfc_expr *fptr, gfc_expr *shape) return false; } - if (!is_c_interoperable (fptr, &msg, false) && fptr->rank) + if (!is_c_interoperable (fptr, &msg, false, true)) return gfc_notify_std (GFC_STD_F2008_TS, "Noninteroperable array FPTR " "at %L to C_F_POINTER: %s", &fptr->where, msg); @@ -4029,7 +4031,7 @@ gfc_check_c_loc (gfc_expr *x) return false; } - if (!is_c_interoperable (x, &msg, true)) + if (!is_c_interoperable (x, &msg, true, false)) { if (x->ts.type == BT_CLASS) { diff --git a/gcc/fortran/io.c b/gcc/fortran/io.c index c5120dd78b1..678bc5d844e 100644 --- a/gcc/fortran/io.c +++ b/gcc/fortran/io.c @@ -3890,12 +3890,12 @@ match_inquire_element (gfc_inquire *inquire) RETM m = match_vtag (&tag_s_async, &inquire->asynchronous); RETM m = match_vtag (&tag_s_delim, &inquire->delim); RETM m = match_vtag (&tag_s_decimal, &inquire->decimal); - RETM m = match_vtag (&tag_size, &inquire->size); + RETM m = match_out_tag (&tag_size, &inquire->size); RETM m = match_vtag (&tag_s_encoding, &inquire->encoding); RETM m = match_vtag (&tag_s_round, &inquire->round); RETM m = match_vtag (&tag_s_sign, &inquire->sign); RETM m = match_vtag (&tag_s_pad, &inquire->pad); - RETM m = match_vtag (&tag_iolength, &inquire->iolength); + RETM m = match_out_tag (&tag_iolength, &inquire->iolength); RETM m = match_vtag (&tag_convert, &inquire->convert); RETM m = match_out_tag (&tag_strm_out, &inquire->strm_pos); RETM m = match_vtag (&tag_pending, &inquire->pending); diff --git a/gcc/fortran/simplify.c b/gcc/fortran/simplify.c index 41e1dfbe87f..32b8332fa9e 100644 --- a/gcc/fortran/simplify.c +++ b/gcc/fortran/simplify.c @@ -333,13 +333,15 @@ init_result_expr (gfc_expr *e, int init, gfc_expr *array) } -/* Helper function for gfc_simplify_dot_product() and gfc_simplify_matmul. */ +/* Helper function for gfc_simplify_dot_product() and gfc_simplify_matmul; + if conj_a is true, the matrix_a is complex conjugated. */ static gfc_expr * compute_dot_product (gfc_expr *matrix_a, int stride_a, int offset_a, - gfc_expr *matrix_b, int stride_b, int offset_b) + gfc_expr *matrix_b, int stride_b, int offset_b, + bool conj_a) { - gfc_expr *result, *a, *b; + gfc_expr *result, *a, *b, *c; result = gfc_get_constant_expr (matrix_a->ts.type, matrix_a->ts.kind, &matrix_a->where); @@ -362,9 +364,11 @@ compute_dot_product (gfc_expr *matrix_a, int stride_a, int offset_a, case BT_INTEGER: case BT_REAL: case BT_COMPLEX: - result = gfc_add (result, - gfc_multiply (gfc_copy_expr (a), - gfc_copy_expr (b))); + if (conj_a && a->ts.type == BT_COMPLEX) + c = gfc_simplify_conjg (a); + else + c = gfc_copy_expr (a); + result = gfc_add (result, gfc_multiply (c, gfc_copy_expr (b))); break; default: @@ -1882,7 +1886,7 @@ gfc_simplify_dot_product (gfc_expr *vector_a, gfc_expr *vector_b) gcc_assert (vector_b->rank == 1); gcc_assert (gfc_compare_types (&vector_a->ts, &vector_b->ts)); - return compute_dot_product (vector_a, 1, 0, vector_b, 1, 0); + return compute_dot_product (vector_a, 1, 0, vector_b, 1, 0, true); } @@ -3910,7 +3914,7 @@ gfc_simplify_matmul (gfc_expr *matrix_a, gfc_expr *matrix_b) for (row = 0; row < result_rows; ++row) { gfc_expr *e = compute_dot_product (matrix_a, stride_a, offset_a, - matrix_b, 1, offset_b); + matrix_b, 1, offset_b, false); gfc_constructor_append_expr (&result->value.constructor, e, NULL); diff --git a/gcc/fortran/trans-decl.c b/gcc/fortran/trans-decl.c index fc3a725aa3d..6a8d98c9d60 100644 --- a/gcc/fortran/trans-decl.c +++ b/gcc/fortran/trans-decl.c @@ -4726,7 +4726,7 @@ generate_local_decl (gfc_symbol * sym) gfc_get_symbol_decl (sym); /* Warnings for unused dummy arguments. */ - else if (sym->attr.dummy) + else if (sym->attr.dummy && !sym->attr.in_namelist) { /* INTENT(out) dummy arguments are likely meant to be set. */ if (gfc_option.warn_unused_dummy_argument diff --git a/gcc/lra-assigns.c b/gcc/lra-assigns.c index 9719f0dc9e7..b5736268e69 100644 --- a/gcc/lra-assigns.c +++ b/gcc/lra-assigns.c @@ -672,6 +672,19 @@ update_hard_regno_preference (int regno, int hard_regno, int div) } } +/* Return prefix title for pseudo REGNO. */ +static const char * +pseudo_prefix_title (int regno) +{ + return + (regno < lra_constraint_new_regno_start ? "" + : bitmap_bit_p (&lra_inheritance_pseudos, regno) ? "inheritance " + : bitmap_bit_p (&lra_split_regs, regno) ? "split " + : bitmap_bit_p (&lra_optional_reload_pseudos, regno) ? "optional reload " + : bitmap_bit_p (&lra_subreg_reload_pseudos, regno) ? "subreg reload " + : "reload "); +} + /* Update REG_RENUMBER and other pseudo preferences by assignment of HARD_REGNO to pseudo REGNO and print about it if PRINT_P. */ void @@ -692,13 +705,7 @@ lra_setup_reg_renumber (int regno, int hard_regno, bool print_p) lra_hard_reg_usage[hr + i] += lra_reg_info[regno].freq; if (print_p && lra_dump_file != NULL) fprintf (lra_dump_file, " Assign %d to %sr%d (freq=%d)\n", - reg_renumber[regno], - regno < lra_constraint_new_regno_start - ? "" - : bitmap_bit_p (&lra_inheritance_pseudos, regno) ? "inheritance " - : bitmap_bit_p (&lra_split_regs, regno) ? "split " - : bitmap_bit_p (&lra_optional_reload_pseudos, regno) - ? "optional reload ": "reload ", + reg_renumber[regno], pseudo_prefix_title (regno), regno, lra_reg_info[regno].freq); if (hard_regno >= 0) { @@ -844,6 +851,7 @@ spill_for (int regno, bitmap spilled_pseudo_bitmap) if ((int) spill_regno >= lra_constraint_new_regno_start && ! bitmap_bit_p (&lra_inheritance_pseudos, spill_regno) && ! bitmap_bit_p (&lra_split_regs, spill_regno) + && ! bitmap_bit_p (&lra_subreg_reload_pseudos, spill_regno) && ! bitmap_bit_p (&lra_optional_reload_pseudos, spill_regno)) goto fail; insn_pseudos_num = 0; @@ -953,14 +961,7 @@ spill_for (int regno, bitmap spilled_pseudo_bitmap) { if (lra_dump_file != NULL) fprintf (lra_dump_file, " Spill %sr%d(hr=%d, freq=%d) for r%d\n", - ((int) spill_regno < lra_constraint_new_regno_start - ? "" - : bitmap_bit_p (&lra_inheritance_pseudos, spill_regno) - ? "inheritance " - : bitmap_bit_p (&lra_split_regs, spill_regno) - ? "split " - : bitmap_bit_p (&lra_optional_reload_pseudos, spill_regno) - ? "optional reload " : "reload "), + pseudo_prefix_title (spill_regno), spill_regno, reg_renumber[spill_regno], lra_reg_info[spill_regno].freq, regno); update_lives (spill_regno, true); @@ -1176,6 +1177,7 @@ assign_by_spills (void) bitmap_initialize (&changed_insns, ®_obstack); bitmap_initialize (&non_reload_pseudos, ®_obstack); bitmap_ior (&non_reload_pseudos, &lra_inheritance_pseudos, &lra_split_regs); + bitmap_ior_into (&non_reload_pseudos, &lra_subreg_reload_pseudos); bitmap_ior_into (&non_reload_pseudos, &lra_optional_reload_pseudos); for (iter = 0; iter <= 1; iter++) { @@ -1350,6 +1352,7 @@ assign_by_spills (void) && lra_reg_info[i].restore_regno >= 0) || (bitmap_bit_p (&lra_split_regs, i) && lra_reg_info[i].restore_regno >= 0) + || bitmap_bit_p (&lra_subreg_reload_pseudos, i) || bitmap_bit_p (&lra_optional_reload_pseudos, i)) && reg_renumber[i] < 0 && lra_reg_info[i].nrefs != 0 && regno_allocno_class_array[i] != NO_REGS) diff --git a/gcc/lra-constraints.c b/gcc/lra-constraints.c index f667512337f..e9cb1adeff4 100644 --- a/gcc/lra-constraints.c +++ b/gcc/lra-constraints.c @@ -1228,7 +1228,7 @@ simplify_operand_subreg (int nop, enum machine_mode reg_mode) if (get_reload_reg (curr_static_id->operand[nop].type, reg_mode, reg, rclass, "subreg reg", &new_reg)) { - bitmap_set_bit (&lra_optional_reload_pseudos, REGNO (new_reg)); + bitmap_set_bit (&lra_subreg_reload_pseudos, REGNO (new_reg)); if (type != OP_OUT || GET_MODE_SIZE (GET_MODE (reg)) > GET_MODE_SIZE (mode)) { @@ -3183,6 +3183,8 @@ curr_insn_transform (void) for (i = 0; i < n_operands; i++) { + int regno; + bool optional_p = false; rtx old, new_reg; rtx op = *curr_id->operand_loc[i]; @@ -3205,7 +3207,22 @@ curr_insn_transform (void) current one. */ reg_renumber[regno] = -1; } - continue; + /* We can do an optional reload. If the pseudo got a hard + reg, we might improve the code through inheritance. If + it does not get a hard register we coalesce memory/memory + moves later. Ignore move insns to avoid cycling. */ + if (0 && ! lra_simple_p + && lra_undo_inheritance_iter < LRA_MAX_INHERITANCE_PASSES + && goal_alt[i] != NO_REGS && REG_P (op) + && (regno = REGNO (op)) >= FIRST_PSEUDO_REGISTER + && reg_renumber[regno] < 0 + && (curr_insn_set == NULL_RTX + || !(REG_P (SET_SRC (curr_insn_set)) + || MEM_P (SET_SRC (curr_insn_set)) + || GET_CODE (SET_SRC (curr_insn_set)) == SUBREG))) + optional_p = true; + else + continue; } /* Operands that match previous ones have already been handled. */ @@ -3328,6 +3345,21 @@ curr_insn_transform (void) /* We must generate code in any case when function process_alt_operands decides that it is possible. */ gcc_unreachable (); + if (optional_p) + { + lra_assert (REG_P (op)); + regno = REGNO (op); + op = *curr_id->operand_loc[i]; /* Substitution. */ + if (GET_CODE (op) == SUBREG) + op = SUBREG_REG (op); + gcc_assert (REG_P (op) && (int) REGNO (op) >= new_regno_start); + bitmap_set_bit (&lra_optional_reload_pseudos, REGNO (op)); + lra_reg_info[REGNO (op)].restore_regno = regno; + if (lra_dump_file != NULL) + fprintf (lra_dump_file, + " Making reload reg %d for reg %d optional\n", + REGNO (op), regno); + } } if (before != NULL_RTX || after != NULL_RTX || max_regno_before != max_reg_num ()) @@ -5273,6 +5305,100 @@ remove_inheritance_pseudos (bitmap remove_pseudos) return change_p; } +/* If optional reload pseudos failed to get a hard register or was not + inherited, it is better to remove optional reloads. We do this + transformation after undoing inheritance to figure out necessity to + remove optional reloads easier. Return true if we do any + change. */ +static bool +undo_optional_reloads (void) +{ + bool change_p; + unsigned int regno, uid; + bitmap_iterator bi, bi2; + rtx insn, set, src, dest; + bitmap_head removed_optional_reload_pseudos, insn_bitmap; + + bitmap_initialize (&removed_optional_reload_pseudos, ®_obstack); + bitmap_copy (&removed_optional_reload_pseudos, &lra_optional_reload_pseudos); + EXECUTE_IF_SET_IN_BITMAP (&lra_optional_reload_pseudos, 0, regno, bi) + if (reg_renumber[regno] >= 0) + EXECUTE_IF_SET_IN_BITMAP (&lra_reg_info[regno].insn_bitmap, 0, uid, bi2) + { + insn = lra_insn_recog_data[uid]->insn; + if ((set = single_set (insn)) == NULL_RTX) + continue; + src = SET_SRC (set); + dest = SET_DEST (set); + if (! REG_P (src) || ! REG_P (dest)) + continue; + if ((REGNO (src) == regno + && lra_reg_info[regno].restore_regno != (int) REGNO (dest)) + || (REGNO (dest) == regno + && lra_reg_info[regno].restore_regno != (int) REGNO (src))) + { + /* Optional reload was inherited. Keep it. */ + bitmap_clear_bit (&removed_optional_reload_pseudos, regno); + if (lra_dump_file != NULL) + fprintf (lra_dump_file, "Keep optional reload reg %d\n", regno); + } + } + change_p = ! bitmap_empty_p (&removed_optional_reload_pseudos); + bitmap_initialize (&insn_bitmap, ®_obstack); + EXECUTE_IF_SET_IN_BITMAP (&removed_optional_reload_pseudos, 0, regno, bi) + { + if (lra_dump_file != NULL) + fprintf (lra_dump_file, "Remove optional reload reg %d\n", regno); + bitmap_copy (&insn_bitmap, &lra_reg_info[regno].insn_bitmap); + EXECUTE_IF_SET_IN_BITMAP (&insn_bitmap, 0, uid, bi2) + { + insn = lra_insn_recog_data[uid]->insn; + if ((set = single_set (insn)) != NULL_RTX) + { + src = SET_SRC (set); + dest = SET_DEST (set); + if (REG_P (src) && REG_P (dest) + && ((REGNO (src) == regno + && (lra_reg_info[regno].restore_regno + == (int) REGNO (dest))) + || (REGNO (dest) == regno + && (lra_reg_info[regno].restore_regno + == (int) REGNO (src))))) + { + if (lra_dump_file != NULL) + { + fprintf (lra_dump_file, " Deleting move %u\n", + INSN_UID (insn)); + dump_insn_slim (lra_dump_file, insn); + } + lra_set_insn_deleted (insn); + continue; + } + /* We should not worry about generation memory-memory + moves here as if the corresponding inheritance did + not work (inheritance pseudo did not get a hard reg), + we remove the inheritance pseudo and the optional + reload. */ + } + substitute_pseudo (&insn, regno, + regno_reg_rtx[lra_reg_info[regno].restore_regno]); + lra_update_insn_regno_info (insn); + if (lra_dump_file != NULL) + { + fprintf (lra_dump_file, + " Restoring original insn:\n"); + dump_insn_slim (lra_dump_file, insn); + } + } + } + /* Clear restore_regnos. */ + EXECUTE_IF_SET_IN_BITMAP (&lra_optional_reload_pseudos, 0, regno, bi) + lra_reg_info[regno].restore_regno = -1; + bitmap_clear (&insn_bitmap); + bitmap_clear (&removed_optional_reload_pseudos); + return change_p; +} + /* Entry function for undoing inheritance/split transformation. Return true if we did any RTL change in this pass. */ bool @@ -5335,5 +5461,6 @@ lra_undo_inheritance (void) lra_reg_info[regno].restore_regno = -1; EXECUTE_IF_SET_IN_BITMAP (&lra_split_regs, 0, regno, bi) lra_reg_info[regno].restore_regno = -1; + change_p = undo_optional_reloads () || change_p; return change_p; } diff --git a/gcc/lra-int.h b/gcc/lra-int.h index 3d7ecb35e09..cb45c65d13a 100644 --- a/gcc/lra-int.h +++ b/gcc/lra-int.h @@ -321,6 +321,7 @@ extern int lra_new_regno_start; extern int lra_constraint_new_regno_start; extern bitmap_head lra_inheritance_pseudos; extern bitmap_head lra_split_regs; +extern bitmap_head lra_subreg_reload_pseudos; extern bitmap_head lra_optional_reload_pseudos; extern int lra_constraint_new_insn_uid_start; diff --git a/gcc/lra.c b/gcc/lra.c index 6b505c508c3..30b7c0a3dd5 100644 --- a/gcc/lra.c +++ b/gcc/lra.c @@ -43,13 +43,13 @@ along with GCC; see the file COPYING3. If not see Here is block diagram of LRA passes: - --------------------- - --------------- | Undo inheritance | --------------- - | Memory-memory | | for spilled pseudos)| | New (and old) | - | move coalesce |<---| and splits (for |<-- | pseudos | - --------------- | pseudos got the | | assignment | - Start | | same hard regs) | --------------- - | | --------------------- ^ + ------------------------ + --------------- | Undo inheritance for | --------------- + | Memory-memory | | spilled pseudos, | | New (and old) | + | move coalesce |<---| splits for pseudos got |<-- | pseudos | + --------------- | the same hard regs, | | assignment | + Start | | and optional reloads | --------------- + | | ------------------------ ^ V | ---------------- | ----------- V | Update virtual | | | Remove |----> ------------>| register | | @@ -2187,10 +2187,16 @@ bitmap_head lra_inheritance_pseudos; /* Split regnos before the new spill pass. */ bitmap_head lra_split_regs; -/* Reload pseudo regnos before the new assign pass which still can be - spilled after the assinment pass. */ +/* Reload pseudo regnos before the new assignmnet pass which still can + be spilled after the assinment pass as memory is also accepted in + insns for the reload pseudos. */ bitmap_head lra_optional_reload_pseudos; +/* Pseudo regnos used for subreg reloads before the new assignment + pass. Such pseudos still can be spilled after the assinment + pass. */ +bitmap_head lra_subreg_reload_pseudos; + /* First UID of insns generated before a new spill pass. */ int lra_constraint_new_insn_uid_start; @@ -2296,6 +2302,7 @@ lra (FILE *f) bitmap_initialize (&lra_inheritance_pseudos, ®_obstack); bitmap_initialize (&lra_split_regs, ®_obstack); bitmap_initialize (&lra_optional_reload_pseudos, ®_obstack); + bitmap_initialize (&lra_subreg_reload_pseudos, ®_obstack); live_p = false; if (get_frame_size () != 0 && crtl->stack_alignment_needed) /* If we have a stack frame, we must align it now. The stack size @@ -2356,8 +2363,9 @@ lra (FILE *f) if (! live_p) lra_clear_live_ranges (); } + bitmap_clear (&lra_optional_reload_pseudos); } - bitmap_clear (&lra_optional_reload_pseudos); + bitmap_clear (&lra_subreg_reload_pseudos); bitmap_clear (&lra_inheritance_pseudos); bitmap_clear (&lra_split_regs); if (! lra_need_for_spills_p ()) diff --git a/gcc/po/ChangeLog b/gcc/po/ChangeLog index 902e5e00ac9..d1c37c47c9b 100644 --- a/gcc/po/ChangeLog +++ b/gcc/po/ChangeLog @@ -1,3 +1,7 @@ +2013-07-11 Joseph Myers <joseph@codesourcery.com> + + * fi.po: Update. + 2013-07-02 Joseph Myers <joseph@codesourcery.com> * ru.po: Update. diff --git a/gcc/po/fi.po b/gcc/po/fi.po index 60202fc9b8f..34b208fe4c2 100644 --- a/gcc/po/fi.po +++ b/gcc/po/fi.po @@ -1,9 +1,9 @@ # Finnish translation of GNU Compiler Collection -# Copyright © 2010 Free Software Foundation, Inc. +# Copyright © 2013 Free Software Foundation, Inc. # This file is distributed under the same license as the GCC package. # Ville Koskinen <ville.koskinen@iki.fi>, 2005. # Jorma Karvonen <karvonen.jorma@gmail.com>, 2009. -# Lauri Nurmi <lanurmi@iki.fi>, 2007-2010. +# Lauri Nurmi <lanurmi@iki.fi>, 2007-2010, 2013. # # Joitakin termejä, joille voi miettiä (parempaa) suomennosta: # @@ -21,64 +21,68 @@ # Uusia: # pass -> välittää vai antaa # incomplete -# +# frame table -> kehystaulu +# immediate +# soveltuu/pätee +# brace group +# qualifi* +# tässä/täällä +# duplicate msgid "" msgstr "" -"Project-Id-Version: gcc 4.5-b20091203\n" +"Project-Id-Version: gcc 4.8.0\n" "Report-Msgid-Bugs-To: http://gcc.gnu.org/bugs.html\n" -"POT-Creation-Date: 2013-02-24 01:09+0000\n" -"PO-Revision-Date: 2010-01-11 22:13+0200\n" +"POT-Creation-Date: 2013-03-15 17:42+0000\n" +"PO-Revision-Date: 2013-07-11 20:50+0300\n" "Last-Translator: Lauri Nurmi <lanurmi@iki.fi>\n" "Language-Team: Finnish <translation-team-fi@lists.sourceforge.net>\n" "Language: fi\n" "MIME-Version: 1.0\n" "Content-Type: text/plain; charset=UTF-8\n" "Content-Transfer-Encoding: 8bit\n" +"Plural-Forms: nplurals=2; plural=(n != 1);\n" -#: cfgrtl.c:2320 +#: cfgrtl.c:2318 msgid "flow control insn inside a basic block" -msgstr "" +msgstr "vuonohjauskäsky peruslohkon sisällä" -#: cfgrtl.c:2448 +#: cfgrtl.c:2446 msgid "wrong insn in the fallthru edge" msgstr "" -#: cfgrtl.c:2502 +#: cfgrtl.c:2500 msgid "insn outside basic block" -msgstr "" +msgstr "käsky peruslohkon ulkopuolella" -#: cfgrtl.c:2509 +#: cfgrtl.c:2507 msgid "return not followed by barrier" msgstr "" #: collect2.c:1531 #, fuzzy, c-format -#| msgid "collect2 version %s" msgid "collect2 version %s\n" msgstr "collect2-versio %s" #: collect2.c:1638 -#, fuzzy, c-format -#| msgid "%d constructor(s) found\n" +#, c-format msgid "%d constructor found\n" msgid_plural "%d constructors found\n" -msgstr[0] "löytyi %d muodostin(ta)\n" -msgstr[1] "löytyi %d muodostin(ta)\n" +msgstr[0] "löytyi %d muodostin\n" +msgstr[1] "löytyi %d muodostinta\n" #: collect2.c:1642 -#, fuzzy, c-format -#| msgid "%d destructor(s) found\n" +#, c-format msgid "%d destructor found\n" msgid_plural "%d destructors found\n" -msgstr[0] "löytyi %d hajotin(ta)\n" -msgstr[1] "löytyi %d hajotin(ta)\n" +msgstr[0] "löytyi %d hajotin\n" +msgstr[1] "löytyi %d hajotinta\n" #: collect2.c:1646 #, c-format msgid "%d frame table found\n" msgid_plural "%d frame tables found\n" -msgstr[0] "" -msgstr[1] "" +msgstr[0] "löytyi %d kehystaulu\n" +msgstr[1] "löytyi %d kehystaulua\n" #: collect2.c:1902 #, c-format @@ -112,20 +116,18 @@ msgstr "" #: diagnostic.c:169 #, fuzzy, c-format -#| msgid "Treat all warnings as errors" msgid "%s: all warnings being treated as errors" msgstr "Käsittele kaikki varoitukset virheinä" #: diagnostic.c:174 #, fuzzy, c-format -#| msgid "%s: warning: no read access for file '%s'\n" msgid "%s: some warnings being treated as errors" -msgstr "%s: varoitus: ei lukuoikeuksia tiedostoon \"%s\"\n" +msgstr "%s: varoitus: ei lukuoikeuksia tiedostoon ”%s”\n" #: diagnostic.c:413 #, c-format msgid "compilation terminated due to -Wfatal-errors.\n" -msgstr "" +msgstr "käännös keskeytyi -Wfatal-errors-valitsimen vuoksi.\n" #: diagnostic.c:423 #, c-format @@ -138,6 +140,8 @@ msgid "" "Please submit a full bug report,\n" "with preprocessed source if appropriate.\n" msgstr "" +"Lähetä kokonainen vikaraportti, sisältäen\n" +"sisältäen esiprosessoidun lähdekoodin, jos tarpeellista.\n" #: diagnostic.c:448 #, fuzzy, c-format @@ -147,59 +151,59 @@ msgstr "Käytä AltiVec-käskyjä" #: diagnostic.c:457 #, c-format msgid "compilation terminated.\n" -msgstr "" +msgstr "käännös keskeytyi.\n" #: diagnostic.c:722 #, c-format msgid "%s:%d: confused by earlier errors, bailing out\n" -msgstr "" +msgstr "%s:%d: hämmentynyt aikaisemmista virheistä, poistutaan\n" -#: diagnostic.c:1126 +#: diagnostic.c:1129 #, c-format msgid "Internal compiler error: Error reporting routines re-entered.\n" msgstr "" #: final.c:1161 msgid "negative insn length" -msgstr "" +msgstr "negatiivinen käskyn pituus" #: final.c:2897 msgid "could not split insn" -msgstr "" +msgstr "ei voitu jakaa käskyä osiin" #: final.c:3306 msgid "invalid 'asm': " -msgstr "" +msgstr "virheellinen ”asm”: " #: final.c:3435 #, c-format msgid "nested assembly dialect alternatives" -msgstr "" +msgstr "sisäkkäiset assembly-murrevaihtoehdot" #: final.c:3450 final.c:3462 #, c-format msgid "unterminated assembly dialect alternative" -msgstr "" +msgstr "päättämättömät assembly-murrevaihtoehdot" #: final.c:3587 -#, c-format +#, fuzzy, c-format msgid "operand number missing after %%-letter" -msgstr "" +msgstr "kohdemuuttujanumero puuttuu %%-kirjaimen jäljestä" #: final.c:3590 final.c:3631 -#, c-format +#, fuzzy, c-format msgid "operand number out of range" -msgstr "" +msgstr "kohdemuuttujanumero lukualueen ulkopuolella" #: final.c:3648 #, c-format msgid "invalid %%-code" -msgstr "" +msgstr "virheellinen %%-koodi" #: final.c:3678 -#, c-format +#, fuzzy, c-format msgid "'%%l' operand isn't a label" -msgstr "" +msgstr "”%%l”-kohdemuuttuja ei ole nimiö" #. We can't handle floating point constants; #. PRINT_OPERAND must handle them. @@ -215,48 +219,48 @@ msgstr "liukulukuvakiota käytetty väärin" #: final.c:3877 config/i386/i386.c:13468 config/pdp11/pdp11.c:1729 #, c-format msgid "invalid expression as operand" -msgstr "" +msgstr "virheellinen lauseke kohdemuuttujana" -#: gcc.c:1402 +#: gcc.c:1403 #, c-format msgid "Using built-in specs.\n" msgstr "" -#: gcc.c:1599 +#: gcc.c:1600 #, c-format msgid "" "Setting spec %s to '%s'\n" "\n" msgstr "" -#: gcc.c:1708 +#: gcc.c:1709 #, c-format msgid "Reading specs from %s\n" msgstr "" -#: gcc.c:1833 +#: gcc.c:1834 #, c-format msgid "could not find specs file %s\n" msgstr "" -#: gcc.c:1902 +#: gcc.c:1903 #, c-format msgid "rename spec %s to %s\n" msgstr "" -#: gcc.c:1904 +#: gcc.c:1905 #, c-format msgid "" "spec is '%s'\n" "\n" msgstr "" -#: gcc.c:2337 +#: gcc.c:2338 #, c-format msgid "%s\n" msgstr "%s\n" -#: gcc.c:2704 +#: gcc.c:2705 #, c-format msgid "" "\n" @@ -265,209 +269,208 @@ msgstr "" "\n" "Jatketaanko? (y tai n) " -#: gcc.c:2844 +#: gcc.c:2845 #, c-format msgid "# %s %.2f %.2f\n" msgstr "# %s %.2f %.2f\n" -#: gcc.c:3047 +#: gcc.c:3048 #, c-format msgid "Usage: %s [options] file...\n" msgstr "Käyttö: %s [valitsimet] tiedosto...\n" -#: gcc.c:3048 +#: gcc.c:3049 msgid "Options:\n" msgstr "Valitsimet:\n" -#: gcc.c:3050 +#: gcc.c:3051 msgid " -pass-exit-codes Exit with highest error code from a phase\n" msgstr " -pass-exit-codes Palauta korkein käännösvaiheen virhekoodi\n" -#: gcc.c:3051 +#: gcc.c:3052 msgid " --help Display this information\n" msgstr " --help Näytä tämä ohje\n" -#: gcc.c:3052 +#: gcc.c:3053 #, fuzzy msgid " --target-help Display target specific command line options\n" -msgstr " --target-help Näytä " +msgstr " --target-help Näytä kohdekohtaiset komentorivivalitsimet\n" -#: gcc.c:3053 -#, fuzzy +#: gcc.c:3054 msgid " --help={common|optimizers|params|target|warnings|[^]{joined|separate|undocumented}}[,...]\n" msgstr " --help={target|optimizers|warnings|undocumented|params}[,{[^]joined|[^]separate}]\n" -#: gcc.c:3054 +#: gcc.c:3055 msgid " Display specific types of command line options\n" -msgstr " Näytä tietyn tyyppiset valitsimet\n" +msgstr " Näytä tietyn tyyppiset komentorivivalitsimet\n" -#: gcc.c:3056 +#: gcc.c:3057 msgid " (Use '-v --help' to display command line options of sub-processes)\n" -msgstr " (Komennolla ”-v --help” aliprosessien valitsimet)\n" +msgstr " (Komennolla ”-v --help” aliprosessien komentorivivalitsimet)\n" -#: gcc.c:3057 +#: gcc.c:3058 msgid " --version Display compiler version information\n" msgstr " --version Näytä kääntäjän versiotiedot\n" -#: gcc.c:3058 +#: gcc.c:3059 msgid " -dumpspecs Display all of the built in spec strings\n" msgstr " -dumpspecs Näytä kaikki sisäiset määrittelyrivit\n" -#: gcc.c:3059 +#: gcc.c:3060 msgid " -dumpversion Display the version of the compiler\n" msgstr " -dumpversion Näytä kääntäjän versio\n" -#: gcc.c:3060 +#: gcc.c:3061 +#, fuzzy msgid " -dumpmachine Display the compiler's target processor\n" -msgstr "" +msgstr " -dumpmachine Näytä kääntäjän kohdesuoritin\n" -#: gcc.c:3061 +#: gcc.c:3062 msgid " -print-search-dirs Display the directories in the compiler's search path\n" msgstr " -print-search-dirs Näytä kääntäjän hakupolussa olevat hakemistot\n" -#: gcc.c:3062 +#: gcc.c:3063 +#, fuzzy msgid " -print-libgcc-file-name Display the name of the compiler's companion library\n" -msgstr "" +msgstr " -print-libgcc-file-name Näytä kääntäjän kumppanikirjaston nimi\n" -#: gcc.c:3063 +#: gcc.c:3064 msgid " -print-file-name=<lib> Display the full path to library <lib>\n" msgstr " -print-file-name=<lib> Näytä täysi polku kirjastoon <lib>\n" -#: gcc.c:3064 +#: gcc.c:3065 msgid " -print-prog-name=<prog> Display the full path to compiler component <prog>\n" msgstr " -print-prog-name=<prog> Näytä täysi polku kääntäjän komponenttiin <prog>\n" -#: gcc.c:3065 +#: gcc.c:3066 msgid "" " -print-multiarch Display the target's normalized GNU triplet, used as\n" " a component in the library path\n" msgstr "" -#: gcc.c:3068 +#: gcc.c:3069 msgid " -print-multi-directory Display the root directory for versions of libgcc\n" msgstr " -print-multi-directory Näytä libgcc:n versioiden juurihakemisto\n" -#: gcc.c:3069 +#: gcc.c:3070 msgid "" " -print-multi-lib Display the mapping between command line options and\n" " multiple library search directories\n" msgstr "" -#: gcc.c:3072 +#: gcc.c:3073 msgid " -print-multi-os-directory Display the relative path to OS libraries\n" msgstr "" -#: gcc.c:3073 +#: gcc.c:3074 #, fuzzy msgid " -print-sysroot Display the target libraries directory\n" msgstr " -dumpversion Näytä kääntäjän versio\n" -#: gcc.c:3074 +#: gcc.c:3075 msgid " -print-sysroot-headers-suffix Display the sysroot suffix used to find headers\n" -msgstr "" +msgstr " -print-sysroot-headers-suffix Näytä sysroot-loppuliite, jota käytetään otsakkeiden löytämiseen\n" -#: gcc.c:3075 +#: gcc.c:3076 msgid " -Wa,<options> Pass comma-separated <options> on to the assembler\n" -msgstr "" +msgstr " -Wa,<valitsimet> Välitä pilkulla erotetut <valitsimet> assemblerille\n" -#: gcc.c:3076 +#: gcc.c:3077 msgid " -Wp,<options> Pass comma-separated <options> on to the preprocessor\n" msgstr " -Wp,<valitsimet> Välitä pilkulla erotetut <valitsimet> esikääntäjälle\n" -#: gcc.c:3077 +#: gcc.c:3078 msgid " -Wl,<options> Pass comma-separated <options> on to the linker\n" msgstr " -Wl,<valitsimet> Välitä pilkulla erotetut <valitsimet> linkittimelle\n" -#: gcc.c:3078 +#: gcc.c:3079 msgid " -Xassembler <arg> Pass <arg> on to the assembler\n" -msgstr "" +msgstr " -Xassembler <arg> Välitä <arg> assemblerille\n" -#: gcc.c:3079 +#: gcc.c:3080 msgid " -Xpreprocessor <arg> Pass <arg> on to the preprocessor\n" msgstr " -Xpreprocessor <arg> Välitä <arg> esikääntäjälle\n" -#: gcc.c:3080 +#: gcc.c:3081 msgid " -Xlinker <arg> Pass <arg> on to the linker\n" msgstr " -Xlinker <arg> Välitä <arg> linkittimelle\n" -#: gcc.c:3081 +#: gcc.c:3082 msgid " -save-temps Do not delete intermediate files\n" msgstr " -save-temps Älä poista väliaikaistiedostoja\n" -#: gcc.c:3082 +#: gcc.c:3083 msgid " -save-temps=<arg> Do not delete intermediate files\n" msgstr " -save-temps=<arg> Älä poista väliaikaistiedostoja\n" -#: gcc.c:3083 +#: gcc.c:3084 msgid "" " -no-canonical-prefixes Do not canonicalize paths when building relative\n" " prefixes to other gcc components\n" msgstr "" -#: gcc.c:3086 +#: gcc.c:3087 msgid " -pipe Use pipes rather than intermediate files\n" msgstr " -pipe Käytä putkia väliaikaistiedostojen sijaan\n" -#: gcc.c:3087 +#: gcc.c:3088 msgid " -time Time the execution of each subprocess\n" msgstr " -time Mittaa kunkin aliprosessin suoritusaika\n" -#: gcc.c:3088 +#: gcc.c:3089 msgid " -specs=<file> Override built-in specs with the contents of <file>\n" msgstr "" -#: gcc.c:3089 +#: gcc.c:3090 msgid " -std=<standard> Assume that the input sources are for <standard>\n" msgstr " -std=<standardi> Oleta syötetiedostojen olevan <standardi>n mukaisia\n" -#: gcc.c:3090 +#: gcc.c:3091 msgid "" " --sysroot=<directory> Use <directory> as the root directory for headers\n" " and libraries\n" msgstr "" +" --sysroot=<hakemisto> Käytä <hakemistoa> otsakkeiden ja kirjastojen\n" +" juurihakemistona\n" -#: gcc.c:3093 +#: gcc.c:3094 msgid " -B <directory> Add <directory> to the compiler's search paths\n" msgstr " -B <hakemisto> Lisää <hakemisto> kääntäjän hakupolkuihin\n" -#: gcc.c:3094 +#: gcc.c:3095 msgid " -v Display the programs invoked by the compiler\n" -msgstr "" +msgstr " -v Näytä kääntäjän käynnistämät ohjelmat\n" -#: gcc.c:3095 +#: gcc.c:3096 msgid " -### Like -v but options quoted and commands not executed\n" msgstr "" -#: gcc.c:3096 +#: gcc.c:3097 #, fuzzy msgid " -E Preprocess only; do not compile, assemble or link\n" -msgstr " -E Vain esikäsittely, älä käännä, xxxx tai linkitä\n" +msgstr " -E Suorita vain esikäsittely, älä käännä, assembloi tai linkitä\n" -#: gcc.c:3097 +#: gcc.c:3098 msgid " -S Compile only; do not assemble or link\n" msgstr "" -#: gcc.c:3098 +#: gcc.c:3099 msgid " -c Compile and assemble, but do not link\n" msgstr "" -#: gcc.c:3099 +#: gcc.c:3100 msgid " -o <file> Place the output into <file>\n" msgstr " -o <tiedosto> Ohjaa tuloste <tiedostoon>\n" -#: gcc.c:3100 -#, fuzzy -#| msgid " -pipe Use pipes rather than intermediate files\n" +#: gcc.c:3101 msgid " -pie Create a position independent executable\n" -msgstr " -pipe Käytä putkia väliaikaistiedostojen sijaan\n" +msgstr " -pie Luo paikkariippumaton suoritettava tiedosto\n" -#: gcc.c:3101 -#, fuzzy -#| msgid "Create a shared library" +#: gcc.c:3102 msgid " -shared Create a shared library\n" -msgstr "Luo jaettu kirjasto" +msgstr " -shared Luo jaettu kirjasto\n" -#: gcc.c:3102 +#: gcc.c:3103 msgid "" " -x <language> Specify the language of the following input files\n" " Permissible languages include: c c++ assembler none\n" @@ -479,7 +482,7 @@ msgstr "" " ”none” palauttaa käyttöön oletustoiminnan,\n" " eli kielen päättelyn tiedostopäätteestä\n" -#: gcc.c:3109 +#: gcc.c:3110 #, c-format msgid "" "\n" @@ -493,27 +496,27 @@ msgstr "" " valitsimien välittämiseen näille prosesseille on käytettävä -W<kirjain>-\n" " valitsimia.\n" -#: gcc.c:5364 +#: gcc.c:5365 #, c-format msgid "Processing spec (%s), which is '%s'\n" msgstr "" -#: gcc.c:6649 +#: gcc.c:6651 #, c-format msgid "install: %s%s\n" msgstr "asennus: %s%s\n" -#: gcc.c:6652 +#: gcc.c:6654 #, c-format msgid "programs: %s\n" msgstr "ohjelmat: %s\n" -#: gcc.c:6654 +#: gcc.c:6656 #, c-format msgid "libraries: %s\n" msgstr "kirjastot: %s\n" -#: gcc.c:6738 +#: gcc.c:6740 #, c-format msgid "" "\n" @@ -522,16 +525,16 @@ msgstr "" "\n" "Ohjeet vikailmoitusten tekoon ovat osoitteessa:\n" -#: gcc.c:6754 +#: gcc.c:6756 #, c-format msgid "%s %s%s\n" msgstr "%s %s%s\n" -#: gcc.c:6757 gcov.c:491 fortran/gfortranspec.c:303 java/jcf-dump.c:1230 +#: gcc.c:6759 gcov.c:491 fortran/gfortranspec.c:303 java/jcf-dump.c:1230 msgid "(C)" msgstr "©" -#: gcc.c:6758 java/jcf-dump.c:1231 +#: gcc.c:6760 java/jcf-dump.c:1231 #, c-format msgid "" "This is free software; see the source for copying conditions. There is NO\n" @@ -542,32 +545,32 @@ msgstr "" "Tällä ohjelmistolla EI OLE TAKUUTA; ei edes KAUPALLISESTI HYVÄKSYTTÄVÄSTÄ\n" "LAADUSTA tai SOPIVUUDESTA TIETTYYN TARKOITUKSEEN.\n" -#: gcc.c:6775 +#: gcc.c:6777 #, c-format msgid "Target: %s\n" msgstr "" -#: gcc.c:6776 +#: gcc.c:6778 #, c-format msgid "Configured with: %s\n" msgstr "" -#: gcc.c:6790 +#: gcc.c:6792 #, c-format msgid "Thread model: %s\n" msgstr "Säiemalli: %s\n" -#: gcc.c:6801 +#: gcc.c:6803 #, c-format msgid "gcc version %s %s\n" msgstr "gcc-versio %s %s\n" -#: gcc.c:6804 +#: gcc.c:6806 #, c-format msgid "gcc driver version %s %sexecuting gcc version %s\n" msgstr "" -#: gcc.c:7058 +#: gcc.c:7061 #, c-format msgid "" "\n" @@ -580,33 +583,37 @@ msgstr "" "======================\n" "\n" -#: gcc.c:7059 +#: gcc.c:7062 #, c-format msgid "" "Use \"-Wl,OPTION\" to pass \"OPTION\" to the linker.\n" "\n" msgstr "" +"Käytä ”-Wl,VALITSIN” välittämään ”VALITSIN” linkittimelle.\n" +"\n" -#: gcc.c:8276 +#: gcc.c:8279 #, c-format msgid "" "Assembler options\n" "=================\n" "\n" msgstr "" +"Assembler-valitsimet\n" +"====================\n" +"\n" -#: gcc.c:8277 +#: gcc.c:8280 #, c-format msgid "" "Use \"-Wa,OPTION\" to pass \"OPTION\" to the assembler.\n" "\n" msgstr "" +"Käytä ”-Wa,VALITSIN” välittämään ”VALITSIN” assemblerille.\n" +"\n" #: gcov.c:461 #, fuzzy, c-format -#| msgid "" -#| "Usage: gcov [OPTION]... SOURCEFILE...\n" -#| "\n" msgid "" "Usage: gcov [OPTION]... SOURCE|OBJ...\n" "\n" @@ -634,12 +641,12 @@ msgstr " -v, --version Näytä versionumero ja poistu\n" #: gcov.c:465 #, c-format msgid " -a, --all-blocks Show information for every basic block\n" -msgstr "" +msgstr " -a, --all-blocks Näytä tietoja jokaisesta peruslohkosta\n" #: gcov.c:466 #, c-format msgid " -b, --branch-probabilities Include branch probabilities in output\n" -msgstr "" +msgstr " -b, --branch-probabilities Sisällytä haarojen todennäköisyydet tulosteeseen\n" #: gcov.c:467 #, c-format @@ -647,11 +654,13 @@ msgid "" " -c, --branch-counts Given counts of branches taken\n" " rather than percentages\n" msgstr "" +" -c, --branch-counts Toteutuneiden haarojen lukumäärät,\n" +" ei prosenttilukuja\n" #: gcov.c:469 #, c-format msgid " -n, --no-output Do not create an output file\n" -msgstr "" +msgstr " -n, --no-output Älä luo tulostiedostoa\n" #: gcov.c:470 #, c-format @@ -659,11 +668,13 @@ msgid "" " -l, --long-file-names Use long output file names for included\n" " source files\n" msgstr "" +" -l, --long-file-names Käytä pitkiä tulostiedostojen nimiä sisällytetyille\n" +" lähdetiedostoille\n" #: gcov.c:472 #, c-format msgid " -f, --function-summaries Output summaries for each function\n" -msgstr "" +msgstr " -f, --function-summaries Tulosta yhteenvedot jokaisesta funktiosta\n" #: gcov.c:473 #, c-format @@ -692,7 +703,6 @@ msgstr "" #: gcov.c:478 #, fuzzy, c-format -#| msgid " --help Display this information\n" msgid " -d, --display-progress Display progress information\n" msgstr " --help Näytä tämä ohje\n" @@ -733,31 +743,26 @@ msgstr "\n" #: gcov.c:723 #, fuzzy, c-format -#| msgid "%s:creating '%s'\n" msgid "Creating '%s'\n" msgstr "%s:luodaan ”%s”\n" #: gcov.c:726 #, fuzzy, c-format -#| msgid "%s:error writing output file '%s'\n" msgid "Error writing output file '%s'\n" msgstr "%s:virhe kirjoitettaessa tulostetiedostoa ”%s”\n" #: gcov.c:731 #, fuzzy, c-format -#| msgid "%s:could not open output file '%s'\n" msgid "Could not open output file '%s'\n" msgstr "%s: ei voitu avata tulostetiedostoa ”%s”\n" #: gcov.c:737 #, fuzzy, c-format -#| msgid "%s:creating '%s'\n" msgid "Removing '%s'\n" -msgstr "%s:luodaan ”%s”\n" +msgstr "Poistetaan ”%s”\n" #: gcov.c:979 #, fuzzy, c-format -#| msgid "%s:error writing output file '%s'\n" msgid "%s:source file is newer than notes file '%s'\n" msgstr "%s:virhe kirjoitettaessa tulostetiedostoa ”%s”\n" @@ -768,13 +773,11 @@ msgstr "" #: gcov.c:1009 #, fuzzy, c-format -#| msgid "%s: cannot open as COFF file" msgid "%s:cannot open notes file\n" msgstr "%s: ei voida avata COFF-tiedostona" #: gcov.c:1015 #, fuzzy, c-format -#| msgid "%s: not a COFF file" msgid "%s:not a gcov notes file\n" msgstr "%s: ei ole COFF-tiedosto" @@ -806,7 +809,7 @@ msgstr "" #: gcov.c:1232 #, c-format msgid "%s:not a gcov data file\n" -msgstr "" +msgstr "%s:ei ole gcov-datatiedosto\n" #: gcov.c:1245 #, c-format @@ -821,7 +824,7 @@ msgstr "ehtolausekkeessa on tyyppiristiriita" #: gcov.c:1286 #, c-format msgid "%s:unknown function '%u'\n" -msgstr "" +msgstr "%s:tuntematon funktio ”%u”\n" #: gcov.c:1300 #, c-format @@ -901,12 +904,12 @@ msgstr "" #: gcov.c:2170 #, c-format msgid "call %2d returned %s\n" -msgstr "" +msgstr "kutsu %2d palautti %s\n" #: gcov.c:2175 #, c-format msgid "call %2d never executed\n" -msgstr "" +msgstr "kutsu %2d ei suoritettu koskaan\n" #: gcov.c:2180 #, c-format @@ -930,9 +933,8 @@ msgstr "" #: gcov.c:2258 #, fuzzy, c-format -#| msgid "%s: Cannot open output file: %s\n" msgid "Cannot open source file %s\n" -msgstr "%s: Ei voi avata tulostetiedostoa: %s\n" +msgstr "Lähdetiedostoa %s ei voi avata\n" #: gcse.c:2647 msgid "PRE disabled" @@ -944,13 +946,11 @@ msgstr "" #: gengtype-state.c:156 #, fuzzy, c-format -#| msgid "%s: invalid file name: %s\n" msgid "%s:%d:%d: Invalid state file; %s" msgstr "%s: virheellinen tiedoston nimi: %s\n" #: gengtype-state.c:160 #, fuzzy, c-format -#| msgid "%s: invalid file name: %s\n" msgid "%s:%d: Invalid state file; %s" msgstr "%s: virheellinen tiedoston nimi: %s\n" @@ -964,7 +964,6 @@ msgstr "" #: gengtype-state.c:176 #, fuzzy, c-format -#| msgid "%s: invalid file name: %s\n" msgid "%s:%d: Invalid state file; " msgstr "%s: virheellinen tiedoston nimi: %s\n" @@ -975,13 +974,11 @@ msgstr "" #: gengtype-state.c:756 #, fuzzy, c-format -#| msgid "Unexpected type in truthvalue_conversion" msgid "Unexpected type in write_state_scalar_type" msgstr "Odottamaton tyyppi kohteessa truthvalue_conversion" #: gengtype-state.c:771 #, fuzzy, c-format -#| msgid "Unexpected type in truthvalue_conversion" msgid "Unexpected type in write_state_string_type" msgstr "Odottamaton tyyppi kohteessa truthvalue_conversion" @@ -997,13 +994,11 @@ msgstr "%s: virhe kirjoitettaessa tiedostoa ”%s”: %s\n" #: gengtype-state.c:1249 #, fuzzy, c-format -#| msgid "%s: error writing file '%s': %s\n" msgid "output error when writing state file %s [%s]" msgstr "%s: virhe kirjoitettaessa tiedostoa ”%s”: %s\n" #: gengtype-state.c:1252 #, fuzzy, c-format -#| msgid "%s: Failed to close output file %s\n" msgid "failed to close state file %s [%s]" msgstr "%s: Tulostetiedoston %s sulkeminen epäonnistui\n" @@ -1019,7 +1014,6 @@ msgstr "" #: gengtype-state.c:2565 #, fuzzy, c-format -#| msgid "%s: Failed to close output file %s\n" msgid "failed to close read state file %s [%s]" msgstr "%s: Tulostetiedoston %s sulkeminen epäonnistui\n" @@ -1039,17 +1033,17 @@ msgid "ignoring nonexistent directory \"%s\"\n" msgstr "jätetään puuttuva hakemisto ”%s” huomiotta\n" # Tähän kuuluu ASCII-lainausmerkit. -#: incpath.c:363 +#: incpath.c:374 #, c-format msgid "#include \"...\" search starts here:\n" msgstr "#include \"...\" -haku alkaa täältä:\n" -#: incpath.c:367 +#: incpath.c:378 #, c-format msgid "#include <...> search starts here:\n" msgstr "#include <...> -haku alkaa täältä:\n" -#: incpath.c:372 +#: incpath.c:383 #, c-format msgid "End of search list.\n" msgstr "Hakulistan loppu.\n" @@ -1069,57 +1063,55 @@ msgid "'" msgstr "”" #: ipa-pure-const.c:151 -#, fuzzy msgid "function might be candidate for attribute %<%s%>" -msgstr "funktio on ehkä mahdollinen ehdokas %qs-muotoiluattribuutille" +msgstr "funktio voi olla ehdokas %<%s%>-attribuutille" #: ipa-pure-const.c:152 -#, fuzzy msgid "function might be candidate for attribute %<%s%> if it is known to return normally" -msgstr "funktio on ehkä mahdollinen ehdokas %qs-muotoiluattribuutille" +msgstr "funktio voi olla ehdokas %<%s%>-attribuutille jos sen tiedetään palaavan normaalisti" #: langhooks.c:380 msgid "At top level:" msgstr "" -#: langhooks.c:400 cp/error.c:3038 +#: langhooks.c:400 cp/error.c:3042 #, c-format msgid "In member function %qs" msgstr "Jäsenfunktio %qs" -#: langhooks.c:404 cp/error.c:3041 +#: langhooks.c:404 cp/error.c:3045 #, c-format msgid "In function %qs" msgstr "Funktio %qs" -#: langhooks.c:455 cp/error.c:2991 +#: langhooks.c:455 cp/error.c:2995 #, c-format msgid " inlined from %qs at %s:%d:%d" msgstr "" -#: langhooks.c:460 cp/error.c:2996 +#: langhooks.c:460 cp/error.c:3000 #, c-format msgid " inlined from %qs at %s:%d" msgstr "" -#: langhooks.c:466 cp/error.c:3002 +#: langhooks.c:466 cp/error.c:3006 #, c-format msgid " inlined from %qs" msgstr "" -#: loop-iv.c:3029 tree-ssa-loop-niter.c:1924 +#: loop-iv.c:3029 tree-ssa-loop-niter.c:1925 msgid "assuming that the loop is not infinite" msgstr "" -#: loop-iv.c:3030 tree-ssa-loop-niter.c:1925 +#: loop-iv.c:3030 tree-ssa-loop-niter.c:1926 msgid "cannot optimize possibly infinite loops" msgstr "mahdollisia ikisilmukoita ei voi optimoida" -#: loop-iv.c:3038 tree-ssa-loop-niter.c:1929 +#: loop-iv.c:3038 tree-ssa-loop-niter.c:1930 msgid "assuming that the loop counter does not overflow" msgstr "" -#: loop-iv.c:3039 tree-ssa-loop-niter.c:1930 +#: loop-iv.c:3039 tree-ssa-loop-niter.c:1931 msgid "cannot optimize loop, the loop counter may overflow" msgstr "" @@ -1130,12 +1122,12 @@ msgstr "" #: lto-wrapper.c:183 #, c-format msgid "pex_init failed" -msgstr "" +msgstr "pex_init epäonnistui" #: lto-wrapper.c:214 #, c-format msgid "can't get program status" -msgstr "" +msgstr "ohjelman tilaa ei saada" #: lto-wrapper.c:223 #, c-format @@ -1155,7 +1147,7 @@ msgstr "" #: lto-wrapper.c:247 #, c-format msgid "deleting LTRANS file %s" -msgstr "" +msgstr "poistetaan LTRANS-tiedosto %s" #: lto-wrapper.c:269 #, fuzzy, c-format @@ -1170,7 +1162,7 @@ msgstr "%s: ei voida avata PCH-tiedostoa: %m\n" #: lto-wrapper.c:321 #, c-format msgid "malformed COLLECT_GCC_OPTIONS" -msgstr "" +msgstr "vääränmuotoinen COLLECT_GCC_OPTIONS" #: lto-wrapper.c:430 #, c-format @@ -1178,14 +1170,14 @@ msgid "Option %s not used consistently in all LTO input files" msgstr "" #: lto-wrapper.c:461 -#, fuzzy, c-format +#, c-format msgid "environment variable COLLECT_GCC must be set" -msgstr "DJGPP-ympäristömuuttujaa ei ole määritelty" +msgstr "COLLECT_GCC-ympäristömuuttujan on oltava asetettuna" #: lto-wrapper.c:464 -#, fuzzy, c-format +#, c-format msgid "environment variable COLLECT_GCC_OPTIONS must be set" -msgstr "DJGPP-ympäristömuuttujaa ei ole määritelty" +msgstr "COLLECT_GCC_OPTIONS-ympäristömuuttujan on oltava asetettuna" #: lto-wrapper.c:758 #, c-format @@ -1197,82 +1189,80 @@ msgstr "fopen: %s" msgid "This switch lacks documentation" msgstr "Tältä valitsimelta puuttuu dokumentaatio" -#: opts.c:1015 +#: opts.c:1018 msgid "[default]" msgstr "" -#: opts.c:1026 +#: opts.c:1029 msgid "[enabled]" msgstr "[käytössä]" -#: opts.c:1026 +#: opts.c:1029 msgid "[disabled]" msgstr "[ei käytössä]" -#: opts.c:1045 +#: opts.c:1048 #, c-format msgid " No options with the desired characteristics were found\n" -msgstr "" +msgstr " Yhtään valitsinta halutuilla ominaisuuksilla ei löytynyt\n" -#: opts.c:1054 -#, c-format +#: opts.c:1057 +#, fuzzy, c-format msgid " None found. Use --help=%s to show *all* the options supported by the %s front-end\n" -msgstr "" +msgstr " Mitään ei löytynyt. Käytä --help=%s näyttämään *kaikki* valitsimet, joita %s-edusta tukee\n" -#: opts.c:1060 +#: opts.c:1063 #, c-format msgid " All options with the desired characteristics have already been displayed\n" -msgstr "" +msgstr " Kaikki valitsimet halutuilla ominaisuuksilla on jo näytetty\n" -#: opts.c:1155 +#: opts.c:1158 msgid "The following options are target specific" msgstr "" -#: opts.c:1158 +#: opts.c:1161 msgid "The following options control compiler warning messages" msgstr "" -#: opts.c:1161 +#: opts.c:1164 msgid "The following options control optimizations" msgstr "" -#: opts.c:1164 opts.c:1203 +#: opts.c:1167 opts.c:1206 msgid "The following options are language-independent" msgstr "" -#: opts.c:1167 +#: opts.c:1170 msgid "The --param option recognizes the following as parameters" msgstr "" -#: opts.c:1173 +#: opts.c:1176 msgid "The following options are specific to just the language " msgstr "" -#: opts.c:1175 +#: opts.c:1178 msgid "The following options are supported by the language " msgstr "" -#: opts.c:1186 +#: opts.c:1189 msgid "The following options are not documented" msgstr "" -#: opts.c:1188 +#: opts.c:1191 msgid "The following options take separate arguments" msgstr "" -#: opts.c:1190 +#: opts.c:1193 msgid "The following options take joined arguments" msgstr "" -#: opts.c:1201 +#: opts.c:1204 msgid "The following options are language-related" msgstr "" -#: opts.c:2078 -#, fuzzy -#| msgid "Make \"char\" signed by default" +#: opts.c:2081 msgid "enabled by default" -msgstr "Tee ”char”-tyypistä oletuksena etumerkillinen" +msgstr "oletusarvoisesti käytössä" #: plugin.c:781 msgid "Event" @@ -1289,7 +1279,7 @@ msgstr "" #: reload1.c:2123 msgid "this is the insn:" -msgstr "" +msgstr "tämä on käsky:" #. It's the compiler's fault. #: reload1.c:6095 @@ -1377,12 +1367,12 @@ msgstr "GMP-versio %s, MPFR-versio %s, MPC-versio %s\n" #: toplev.c:690 #, c-format msgid "%s%swarning: %s header version %s differs from library version %s.\n" -msgstr "" +msgstr "%s%swarning: %s-otsakeversio %s eroaa kirjastoversiosta %s.\n" #: toplev.c:692 -#, c-format +#, fuzzy, c-format msgid "%s%sGGC heuristics: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n" -msgstr "" +msgstr "%s%sGGC heuristinen/heuristiikka??: --param ggc-min-expand=%d --param ggc-min-heapsize=%d\n" #: toplev.c:852 msgid "options passed: " @@ -1390,7 +1380,7 @@ msgstr "annetut valitsimet: " #: toplev.c:880 msgid "options enabled: " -msgstr "" +msgstr "käyttöön otetut valitsimet: " #: tree-diagnostic.c:295 c-family/c-pretty-print.c:423 c/c-decl.c:4730 #: c/c-typeck.c:5873 cp/error.c:654 cp/error.c:938 @@ -1468,7 +1458,7 @@ msgstr "" #. Caller and callee disagree on the arguments. #: cif-code.def:84 msgid "mismatched arguments" -msgstr "" +msgstr "täsmäämättömät argumentit" #: cif-code.def:88 msgid "originally indirect function call not considered for inlining" @@ -1487,7 +1477,6 @@ msgstr "" #. caller cannot. #: cif-code.def:99 #, fuzzy -#| msgid "Enable exception handling" msgid "non-call exception handling mismatch" msgstr "Käytä poikkeustenkäsittelyä" @@ -1499,7 +1488,6 @@ msgstr "" #. We can't inline because of mismatched optimization levels. #: cif-code.def:105 #, fuzzy -#| msgid "Set optimization level to <number>" msgid "optimization level attribute mismatch" msgstr "Aseta optimointitasoksi <luku>" @@ -2162,13 +2150,11 @@ msgstr "" #: c-family/c-format.c:346 #, fuzzy -#| msgid "field width" msgid "field width specifier" msgstr "kentän leveys" #: c-family/c-format.c:347 #, fuzzy -#| msgid "field precision" msgid "field precision specifier" msgstr "kentän tarkkuus" @@ -2443,7 +2429,7 @@ msgstr "<nimetön-etumerkitön:" #: c-family/c-pretty-print.c:384 msgid "<unnamed-signed:" -msgstr "<nimetön etumerkillinen:" +msgstr "<nimetön-etumerkillinen:" #: c-family/c-pretty-print.c:387 msgid "<unnamed-float:" @@ -2451,7 +2437,7 @@ msgstr "<nimetön-liukuluku:" #: c-family/c-pretty-print.c:390 msgid "<unnamed-fixed:" -msgstr "" +msgstr "<nimetön-kiinteä:" #: c-family/c-pretty-print.c:405 msgid "<typedef-error>" @@ -2469,7 +2455,7 @@ msgstr "<virheellinen-lauseke>" msgid "<return-value>" msgstr "<paluuarvo>" -#: c-family/c-pretty-print.c:2147 cp/error.c:1818 cp/error.c:2764 +#: c-family/c-pretty-print.c:2147 cp/error.c:1818 cp/error.c:2768 msgid "<unknown>" msgstr "<tuntematon>" @@ -2487,14 +2473,13 @@ msgstr "epäkelvot operandit binääriselle %s-operaatiolle" msgid "incompatible floating point / vector register operand for '%%%c'" msgstr "" -#: config/aarch64/aarch64.c:3399 config/arm/arm.c:18223 +#: config/aarch64/aarch64.c:3399 config/arm/arm.c:18233 #, c-format msgid "missing operand" msgstr "puuttuva operandi" #: config/aarch64/aarch64.c:3462 #, fuzzy, c-format -#| msgid "invalid rotate insn" msgid "invalid constant" msgstr "virheellinen rotate-käsky" @@ -2592,33 +2577,34 @@ msgstr "" msgid "invalid %%xn code" msgstr "virheellinen %%xn-koodi" -#: config/arm/arm.c:17560 config/arm/arm.c:17578 +#: config/arm/arm.c:15438 config/arm/arm.c:15463 config/arm/arm.c:15473 +#: config/arm/arm.c:15482 config/arm/arm.c:15490 +#, fuzzy, c-format +msgid "invalid shift operand" +msgstr "epäkelvot operandit binääriselle %s-operaatiolle" + +#: config/arm/arm.c:17576 config/arm/arm.c:17594 #, c-format msgid "predicated Thumb instruction" msgstr "" -#: config/arm/arm.c:17566 +#: config/arm/arm.c:17582 #, c-format msgid "predicated instruction in conditional sequence" msgstr "" -#: config/arm/arm.c:17697 config/arm/arm.c:17710 +#: config/arm/arm.c:17713 config/arm/arm.c:17726 #, fuzzy, c-format msgid "Unsupported operand for code '%c'" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/arm/arm.c:17748 -#, fuzzy, c-format -msgid "invalid shift operand" -msgstr "epäkelvot operandit binääriselle %s-operaatiolle" - -#: config/arm/arm.c:17805 config/arm/arm.c:17827 config/arm/arm.c:17837 -#: config/arm/arm.c:17847 config/arm/arm.c:17857 config/arm/arm.c:17896 -#: config/arm/arm.c:17914 config/arm/arm.c:17939 config/arm/arm.c:17954 -#: config/arm/arm.c:17981 config/arm/arm.c:17988 config/arm/arm.c:18006 -#: config/arm/arm.c:18013 config/arm/arm.c:18021 config/arm/arm.c:18042 -#: config/arm/arm.c:18049 config/arm/arm.c:18174 config/arm/arm.c:18181 -#: config/arm/arm.c:18204 config/arm/arm.c:18211 config/bfin/bfin.c:1439 +#: config/arm/arm.c:17815 config/arm/arm.c:17837 config/arm/arm.c:17847 +#: config/arm/arm.c:17857 config/arm/arm.c:17867 config/arm/arm.c:17906 +#: config/arm/arm.c:17924 config/arm/arm.c:17949 config/arm/arm.c:17964 +#: config/arm/arm.c:17991 config/arm/arm.c:17998 config/arm/arm.c:18016 +#: config/arm/arm.c:18023 config/arm/arm.c:18031 config/arm/arm.c:18052 +#: config/arm/arm.c:18059 config/arm/arm.c:18184 config/arm/arm.c:18191 +#: config/arm/arm.c:18214 config/arm/arm.c:18221 config/bfin/bfin.c:1439 #: config/bfin/bfin.c:1446 config/bfin/bfin.c:1453 config/bfin/bfin.c:1460 #: config/bfin/bfin.c:1469 config/bfin/bfin.c:1476 config/bfin/bfin.c:1483 #: config/bfin/bfin.c:1490 @@ -2626,23 +2612,23 @@ msgstr "epäkelvot operandit binääriselle %s-operaatiolle" msgid "invalid operand for code '%c'" msgstr "" -#: config/arm/arm.c:17909 +#: config/arm/arm.c:17919 #, c-format msgid "instruction never executed" msgstr "" #. Former Maverick support, removed after GCC-4.7. -#: config/arm/arm.c:17930 +#: config/arm/arm.c:17940 #, c-format msgid "obsolete Maverick format code '%c'" msgstr "" -#: config/arm/arm.c:20988 +#: config/arm/arm.c:20998 #, fuzzy msgid "function parameters cannot have __fp16 type" msgstr "funktion paluuarvon tyyppi ei voi olla funktio" -#: config/arm/arm.c:20998 +#: config/arm/arm.c:21008 #, fuzzy msgid "functions cannot return __fp16 type" msgstr "funktio ei palauta merkkijonotyyppiä" @@ -2662,9 +2648,8 @@ msgstr "" #: config/avr/avr.c:2169 #, fuzzy -#| msgid "requested alignment is not a constant" msgid "bad address, not a constant:" -msgstr "pyydetty tasaus ei ole vakio" +msgstr "pyydetty kohdistus ei ole vakio" #: config/avr/avr.c:2187 msgid "bad address, not (reg+disp):" @@ -2676,12 +2661,12 @@ msgstr "" #: config/avr/avr.c:2205 msgid "internal compiler error. Bad address:" -msgstr "" +msgstr "kääntäjän sisäinen virhe. Virheellinen osoite:" #: config/avr/avr.c:2234 -#, c-format -msgid "Unsupported code '%c'for fixed-point:" -msgstr "" +#, fuzzy, c-format +msgid "Unsupported code '%c' for fixed-point:" +msgstr "void-lausekkeen epäkelpo käyttö" #: config/avr/avr.c:2243 msgid "internal compiler error. Unknown mode:" @@ -2689,7 +2674,7 @@ msgstr "" #: config/avr/avr.c:3213 config/avr/avr.c:3787 config/avr/avr.c:4073 msgid "invalid insn:" -msgstr "" +msgstr "virheellinen käsky:" #: config/avr/avr.c:3242 config/avr/avr.c:3317 config/avr/avr.c:3360 #: config/avr/avr.c:3379 config/avr/avr.c:3470 config/avr/avr.c:3639 @@ -2702,11 +2687,11 @@ msgstr "" #: config/avr/avr.c:3919 config/avr/avr.c:4012 config/avr/avr.c:4249 #: config/avr/avr.c:4370 msgid "unknown move insn:" -msgstr "" +msgstr "tuntematon move-käsky:" #: config/avr/avr.c:4795 msgid "bad shift insn:" -msgstr "" +msgstr "virheellinen shift-käsky:" #: config/avr/avr.c:4903 config/avr/avr.c:5384 config/avr/avr.c:5799 msgid "internal compiler error. Incorrect shift:" @@ -2725,11 +2710,11 @@ msgstr "virheellinen %%j-arvo" #: config/bfin/bfin.c:1581 config/c6x/c6x.c:2290 #, c-format msgid "invalid const_double operand" -msgstr "" +msgstr "virheellinen const_double-operandi" #: config/cris/cris.c:580 config/moxie/moxie.c:111 final.c:3311 final.c:3313 -#: fold-const.c:270 gcc.c:4712 gcc.c:4726 loop-iv.c:3031 loop-iv.c:3040 -#: rtl-error.c:102 toplev.c:332 tree-ssa-loop-niter.c:1933 tree-vrp.c:6783 +#: fold-const.c:270 gcc.c:4713 gcc.c:4727 loop-iv.c:3031 loop-iv.c:3040 +#: rtl-error.c:102 toplev.c:332 tree-ssa-loop-niter.c:1934 tree-vrp.c:6783 #: cp/typeck.c:5618 java/expr.c:389 lto/lto-object.c:189 lto/lto-object.c:287 #: lto/lto-object.c:344 lto/lto-object.c:368 #, gcc-internal-format, gfc-internal-format @@ -2840,22 +2825,22 @@ msgstr "" #: config/fr30/fr30.c:502 #, c-format msgid "fr30_print_operand_address: unhandled address" -msgstr "" +msgstr "fr30_print_operand_address: käsittelemätön osoite" #: config/fr30/fr30.c:526 #, c-format msgid "fr30_print_operand: unrecognized %%p code" -msgstr "" +msgstr "fr30_print_operand: tunnistamaton %%p-koodi" #: config/fr30/fr30.c:546 #, c-format msgid "fr30_print_operand: unrecognized %%b code" -msgstr "" +msgstr "fr30_print_operand: tunnistamaton %%b-koodi" #: config/fr30/fr30.c:567 #, c-format msgid "fr30_print_operand: unrecognized %%B code" -msgstr "" +msgstr "fr30_print_operand: tunnistamaton %%B-koodi" #: config/fr30/fr30.c:575 #, c-format @@ -2865,17 +2850,17 @@ msgstr "" #: config/fr30/fr30.c:592 #, c-format msgid "fr30_print_operand: invalid %%x code" -msgstr "" +msgstr "fr30_print_operand: virheellinen %%x-koodi" #: config/fr30/fr30.c:599 #, c-format msgid "fr30_print_operand: invalid %%F code" -msgstr "" +msgstr "fr30_print_operand: virheellinen %%F-koodi" #: config/fr30/fr30.c:616 #, c-format msgid "fr30_print_operand: unknown code" -msgstr "" +msgstr "fr30_print_operand: tuntematon koodi" #: config/fr30/fr30.c:644 config/fr30/fr30.c:653 config/fr30/fr30.c:664 #: config/fr30/fr30.c:677 @@ -3074,8 +3059,8 @@ msgstr "epäkelpo %<restrict%>-avainsanan käyttö" msgid "invalid operation on %<__fpreg%>" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/iq2000/iq2000.c:3132 config/tilegx/tilegx.c:5205 -#: config/tilepro/tilepro.c:4695 +#: config/iq2000/iq2000.c:3132 config/tilegx/tilegx.c:5203 +#: config/tilepro/tilepro.c:4693 #, c-format msgid "invalid %%P operand" msgstr "" @@ -3090,21 +3075,21 @@ msgstr "virheellinen %%p-arvo" msgid "invalid use of %%d, %%x, or %%X" msgstr "" -#: config/lm32/lm32.c:521 +#: config/lm32/lm32.c:518 #, c-format msgid "only 0.0 can be loaded as an immediate" msgstr "" -#: config/lm32/lm32.c:591 +#: config/lm32/lm32.c:588 #, fuzzy msgid "bad operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/lm32/lm32.c:603 +#: config/lm32/lm32.c:600 msgid "can't use non gp relative absolute address" msgstr "" -#: config/lm32/lm32.c:607 +#: config/lm32/lm32.c:604 #, fuzzy msgid "invalid addressing mode" msgstr "epäkelpo lvalue sijoituksessa" @@ -3174,36 +3159,36 @@ msgstr "" msgid "invalid %%L code" msgstr "virheellinen %%L-koodi" -#: config/microblaze/microblaze.c:1760 +#: config/microblaze/microblaze.c:2156 #, c-format msgid "unknown punctuation '%c'" msgstr "" -#: config/microblaze/microblaze.c:1769 +#: config/microblaze/microblaze.c:2165 #, c-format msgid "null pointer" msgstr "" -#: config/microblaze/microblaze.c:1804 +#: config/microblaze/microblaze.c:2200 #, c-format msgid "PRINT_OPERAND, invalid insn for %%C" msgstr "" -#: config/microblaze/microblaze.c:1833 +#: config/microblaze/microblaze.c:2229 #, c-format msgid "PRINT_OPERAND, invalid insn for %%N" msgstr "" -#: config/microblaze/microblaze.c:1853 config/microblaze/microblaze.c:2014 +#: config/microblaze/microblaze.c:2249 config/microblaze/microblaze.c:2420 msgid "insn contains an invalid address !" msgstr "" -#: config/microblaze/microblaze.c:1867 config/microblaze/microblaze.c:2054 +#: config/microblaze/microblaze.c:2264 config/microblaze/microblaze.c:2479 #: config/xtensa/xtensa.c:2443 msgid "invalid address" msgstr "" -#: config/microblaze/microblaze.c:1966 +#: config/microblaze/microblaze.c:2363 #, c-format msgid "letter %c was found & insn was not CONST_INT" msgstr "" @@ -3285,7 +3270,7 @@ msgstr "" #: config/rs6000/host-darwin.c:94 #, c-format msgid "Out of stack space.\n" -msgstr "" +msgstr "Pinotila loppui.\n" #: config/rs6000/host-darwin.c:115 #, c-format @@ -3298,21 +3283,19 @@ msgstr "" #: config/rs6000/rs6000.c:2619 msgid "-mvsx and -mpaired are incompatible" -msgstr "" +msgstr "-mvsx ja -mpaired ovat yhteensopimattomat" #: config/rs6000/rs6000.c:2624 msgid "-mvsx used with little endian code" -msgstr "" +msgstr "-mvsx:ää käytetty little-endian-koodissa" #: config/rs6000/rs6000.c:2626 msgid "-mvsx needs indexed addressing" msgstr "" #: config/rs6000/rs6000.c:2631 -#, fuzzy -#| msgid "-fpic and -mapcs-reent are incompatible" msgid "-mvsx and -mno-altivec are incompatible" -msgstr "-fpic ja -mapcs-reent ovat yhteensopimattomat" +msgstr "-mvsx ja -mno-altivec ovat yhteensopimattomat" #: config/rs6000/rs6000.c:2633 msgid "-mno-altivec disables vsx" @@ -3486,25 +3469,25 @@ msgstr "epäkelvot operandit binääriselle %s-operaatiolle" msgid "invalid operand for code: '%c'" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/sh/sh.c:1204 +#: config/sh/sh.c:1201 #, fuzzy, c-format msgid "invalid operand to %%R" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/sh/sh.c:1231 +#: config/sh/sh.c:1228 #, fuzzy, c-format msgid "invalid operand to %%S" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/sh/sh.c:9775 +#: config/sh/sh.c:9772 msgid "created and used with different architectures / ABIs" msgstr "" -#: config/sh/sh.c:9777 +#: config/sh/sh.c:9774 msgid "created and used with different ABIs" msgstr "" -#: config/sh/sh.c:9779 +#: config/sh/sh.c:9776 msgid "created and used with different endianness" msgstr "" @@ -3523,13 +3506,13 @@ msgstr "" msgid "invalid %%B operand" msgstr "" -#: config/sparc/sparc.c:8508 config/tilegx/tilegx.c:4988 -#: config/tilepro/tilepro.c:4498 +#: config/sparc/sparc.c:8508 config/tilegx/tilegx.c:4986 +#: config/tilepro/tilepro.c:4496 #, fuzzy, c-format msgid "invalid %%C operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/sparc/sparc.c:8525 config/tilegx/tilegx.c:5021 +#: config/sparc/sparc.c:8525 config/tilegx/tilegx.c:5019 #, fuzzy, c-format msgid "invalid %%D operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" @@ -3574,88 +3557,87 @@ msgstr "" msgid "xstormy16_print_operand: unknown code" msgstr "xstormy16_print_operand: tuntematon koodi" -#: config/tilegx/tilegx.c:4973 config/tilepro/tilepro.c:4483 +#: config/tilegx/tilegx.c:4971 config/tilepro/tilepro.c:4481 #, c-format msgid "invalid %%c operand" msgstr "" -#: config/tilegx/tilegx.c:5004 +#: config/tilegx/tilegx.c:5002 #, c-format msgid "invalid %%d operand" msgstr "" -#: config/tilegx/tilegx.c:5101 +#: config/tilegx/tilegx.c:5099 #, fuzzy, c-format -#| msgid "invalid %%L code" msgid "invalid %%H specifier" msgstr "virheellinen %%L-koodi" -#: config/tilegx/tilegx.c:5143 config/tilepro/tilepro.c:4512 +#: config/tilegx/tilegx.c:5141 config/tilepro/tilepro.c:4510 #, fuzzy, c-format msgid "invalid %%h operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/tilegx/tilegx.c:5155 config/tilepro/tilepro.c:4576 +#: config/tilegx/tilegx.c:5153 config/tilepro/tilepro.c:4574 #, fuzzy, c-format msgid "invalid %%I operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/tilegx/tilegx.c:5169 config/tilepro/tilepro.c:4590 +#: config/tilegx/tilegx.c:5167 config/tilepro/tilepro.c:4588 #, fuzzy, c-format msgid "invalid %%i operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/tilegx/tilegx.c:5192 config/tilepro/tilepro.c:4613 +#: config/tilegx/tilegx.c:5190 config/tilepro/tilepro.c:4611 #, fuzzy, c-format msgid "invalid %%j operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/tilegx/tilegx.c:5223 +#: config/tilegx/tilegx.c:5221 #, fuzzy, c-format msgid "invalid %%%c operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/tilegx/tilegx.c:5238 config/tilepro/tilepro.c:4727 +#: config/tilegx/tilegx.c:5236 config/tilepro/tilepro.c:4725 #, fuzzy, c-format msgid "invalid %%N operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/tilegx/tilegx.c:5282 +#: config/tilegx/tilegx.c:5280 #, fuzzy, c-format msgid "invalid operand for 'r' specifier" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/tilegx/tilegx.c:5307 config/tilepro/tilepro.c:4809 +#: config/tilegx/tilegx.c:5305 config/tilepro/tilepro.c:4807 #, c-format msgid "unable to print out operand yet; code == %d (%c)" msgstr "" -#: config/tilepro/tilepro.c:4548 +#: config/tilepro/tilepro.c:4546 #, fuzzy, c-format msgid "invalid %%H operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/tilepro/tilepro.c:4652 +#: config/tilepro/tilepro.c:4650 #, fuzzy, c-format msgid "invalid %%L operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/tilepro/tilepro.c:4712 +#: config/tilepro/tilepro.c:4710 #, fuzzy, c-format msgid "invalid %%M operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/tilepro/tilepro.c:4755 +#: config/tilepro/tilepro.c:4753 #, fuzzy, c-format msgid "invalid %%t operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/tilepro/tilepro.c:4762 +#: config/tilepro/tilepro.c:4760 #, fuzzy, c-format msgid "invalid %%t operand '" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: config/tilepro/tilepro.c:4783 +#: config/tilepro/tilepro.c:4781 #, fuzzy, c-format msgid "invalid %%r operand" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" @@ -3723,7 +3705,7 @@ msgstr "" msgid "({anonymous})" msgstr "({nimetön})" -#: c/c-parser.c:943 cp/parser.c:23010 +#: c/c-parser.c:943 cp/parser.c:23014 #, fuzzy, gcc-internal-format msgid "expected end of line" msgstr "päättämätön muotoilumerkkijono" @@ -3733,8 +3715,8 @@ msgstr "päättämätön muotoilumerkkijono" #: c/c-parser.c:7357 c/c-parser.c:7392 c/c-parser.c:7423 c/c-parser.c:7470 #: c/c-parser.c:7651 c/c-parser.c:8419 c/c-parser.c:8489 c/c-parser.c:8532 #: c/c-parser.c:9810 c/c-parser.c:9825 c/c-parser.c:9834 c/c-parser.c:9979 -#: c/c-parser.c:10018 c/c-parser.c:2500 c/c-parser.c:7644 cp/parser.c:22423 -#: cp/parser.c:22956 +#: c/c-parser.c:10018 c/c-parser.c:2500 c/c-parser.c:7644 cp/parser.c:22427 +#: cp/parser.c:22960 #, gcc-internal-format msgid "expected %<;%>" msgstr "" @@ -3746,13 +3728,13 @@ msgstr "" #: c/c-parser.c:6703 c/c-parser.c:6727 c/c-parser.c:7942 c/c-parser.c:8014 #: c/c-parser.c:8841 c/c-parser.c:8862 c/c-parser.c:8912 c/c-parser.c:9065 #: c/c-parser.c:9144 c/c-parser.c:9228 c/c-parser.c:9942 c/c-parser.c:10766 -#: c/c-parser.c:8985 c/c-parser.c:9010 cp/parser.c:20794 cp/parser.c:22959 +#: c/c-parser.c:8985 c/c-parser.c:9010 cp/parser.c:20798 cp/parser.c:22963 #, gcc-internal-format msgid "expected %<(%>" msgstr "" #: c/c-parser.c:1843 c/c-parser.c:6389 c/c-parser.c:6427 c/c-parser.c:6555 -#: cp/parser.c:22421 cp/parser.c:22974 +#: cp/parser.c:22425 cp/parser.c:22978 #, fuzzy, gcc-internal-format msgid "expected %<,%>" msgstr "taulukon indeksin tyyppi on %<char%>" @@ -3768,15 +3750,15 @@ msgstr "taulukon indeksin tyyppi on %<char%>" #: c/c-parser.c:7736 c/c-parser.c:7757 c/c-parser.c:7965 c/c-parser.c:8018 #: c/c-parser.c:8391 c/c-parser.c:8844 c/c-parser.c:8865 c/c-parser.c:8943 #: c/c-parser.c:9072 c/c-parser.c:9209 c/c-parser.c:9292 c/c-parser.c:9870 -#: c/c-parser.c:9987 c/c-parser.c:10029 c/c-parser.c:10775 cp/parser.c:20816 -#: cp/parser.c:23004 +#: c/c-parser.c:9987 c/c-parser.c:10029 c/c-parser.c:10775 cp/parser.c:20820 +#: cp/parser.c:23008 #, fuzzy, gcc-internal-format msgid "expected %<)%>" msgstr "taulukon indeksin tyyppi on %<char%>" #: c/c-parser.c:3095 c/c-parser.c:3911 c/c-parser.c:3945 c/c-parser.c:5228 #: c/c-parser.c:6491 c/c-parser.c:6760 c/c-parser.c:6878 c/c-parser.c:10678 -#: c/c-parser.c:10680 cp/parser.c:22968 +#: c/c-parser.c:10680 cp/parser.c:22972 #, fuzzy, gcc-internal-format msgid "expected %<]%>" msgstr "taulukon indeksin tyyppi on %<char%>" @@ -3786,25 +3768,25 @@ msgstr "taulukon indeksin tyyppi on %<char%>" msgid "expected %<;%>, %<,%> or %<)%>" msgstr "käytetty %<__thread%> ennen %<extern%>:a" -#: c/c-parser.c:3774 c/c-parser.c:9826 cp/parser.c:22962 cp/parser.c:24780 +#: c/c-parser.c:3774 c/c-parser.c:9826 cp/parser.c:22966 cp/parser.c:24784 #, fuzzy, gcc-internal-format msgid "expected %<}%>" msgstr "käytetty %<__thread%> ennen %<extern%>:a" #: c/c-parser.c:4064 c/c-parser.c:7985 c/c-parser.c:10272 c/c-parser.c:2318 -#: c/c-parser.c:2521 c/c-parser.c:7539 cp/parser.c:14644 cp/parser.c:22965 +#: c/c-parser.c:2521 c/c-parser.c:7539 cp/parser.c:14646 cp/parser.c:22969 #, gcc-internal-format msgid "expected %<{%>" msgstr "" #: c/c-parser.c:4283 c/c-parser.c:4292 c/c-parser.c:5135 c/c-parser.c:5469 #: c/c-parser.c:7750 c/c-parser.c:8125 c/c-parser.c:8182 c/c-parser.c:9198 -#: cp/parser.c:22998 cp/parser.c:24001 +#: cp/parser.c:23002 cp/parser.c:24005 #, fuzzy, gcc-internal-format msgid "expected %<:%>" msgstr "taulukon indeksin tyyppi on %<char%>" -#: c/c-parser.c:4831 cp/parser.c:22892 +#: c/c-parser.c:4831 cp/parser.c:22896 #, fuzzy, gcc-internal-format msgid "expected %<while%>" msgstr "käytetty %<__thread%> ennen %<extern%>:a" @@ -3814,34 +3796,34 @@ msgstr "käytetty %<__thread%> ennen %<extern%>:a" msgid "expected %<.%>" msgstr "taulukon indeksin tyyppi on %<char%>" -#: c/c-parser.c:7210 c/c-parser.c:7242 c/c-parser.c:7482 cp/parser.c:24564 -#: cp/parser.c:24638 +#: c/c-parser.c:7210 c/c-parser.c:7242 c/c-parser.c:7482 cp/parser.c:24568 +#: cp/parser.c:24642 #, fuzzy, gcc-internal-format msgid "expected %<@end%>" msgstr "vektoriylivuoto lausekkeessa" -#: c/c-parser.c:7899 cp/parser.c:22983 +#: c/c-parser.c:7899 cp/parser.c:22987 #, fuzzy, gcc-internal-format msgid "expected %<>%>" msgstr "käytetty %<__thread%> ennen %<extern%>:a" -#: c/c-parser.c:9296 cp/parser.c:23007 +#: c/c-parser.c:9296 cp/parser.c:23011 #, fuzzy, gcc-internal-format msgid "expected %<,%> or %<)%>" msgstr "käytetty %<__thread%> ennen %<extern%>:a" #: c/c-parser.c:9549 c/c-parser.c:9580 c/c-parser.c:9816 c/c-parser.c:9968 -#: c/c-parser.c:3968 cp/parser.c:22986 +#: c/c-parser.c:3968 cp/parser.c:22990 #, gcc-internal-format msgid "expected %<=%>" msgstr "" -#: c/c-parser.c:10329 c/c-parser.c:10319 cp/parser.c:27421 +#: c/c-parser.c:10329 c/c-parser.c:10319 cp/parser.c:27425 #, fuzzy, gcc-internal-format msgid "expected %<#pragma omp section%> or %<}%>" msgstr "%qs määrittää %<auto%>:n tiedostoalue-esittelyssä" -#: c/c-parser.c:10666 cp/parser.c:22971 +#: c/c-parser.c:10666 cp/parser.c:22975 #, fuzzy, gcc-internal-format msgid "expected %<[%>" msgstr "taulukon indeksin tyyppi on %<char%>" @@ -3850,11 +3832,11 @@ msgstr "taulukon indeksin tyyppi on %<char%>" msgid "(anonymous)" msgstr "(nimetön)" -#: cp/call.c:8680 +#: cp/call.c:8698 msgid "candidate 1:" msgstr "ehdokas 1:" -#: cp/call.c:8681 +#: cp/call.c:8699 msgid "candidate 2:" msgstr "ehdokas 2:" @@ -3862,7 +3844,7 @@ msgstr "ehdokas 2:" msgid "<unnamed>" msgstr "<nimetön>" -#: cp/cxx-pretty-print.c:2149 +#: cp/cxx-pretty-print.c:2153 msgid "template-parameter-" msgstr "" @@ -3893,9 +3875,9 @@ msgid "<type error>" msgstr "<tyyppivirhe>" #: cp/error.c:656 -#, fuzzy, c-format +#, c-format msgid "<anonymous %s>" -msgstr "<nimetön>" +msgstr "<nimetön %s>" #. A lambda's "type" is essentially its signature. #: cp/error.c:661 @@ -3914,11 +3896,11 @@ msgstr "(%qs:n alustuksen lähistöllä)" #: cp/error.c:907 #, c-format msgid "(static destructors for %s)" -msgstr "" +msgstr "(staattiset hajottimet kohteelle %s)" #: cp/error.c:1006 msgid "vtable for " -msgstr "" +msgstr "vtable kohteelle " #: cp/error.c:1018 msgid "<return value> " @@ -3926,13 +3908,11 @@ msgstr "<paluuarvo> " #: cp/error.c:1033 #, fuzzy -#| msgid "({anonymous})" msgid "{anonymous}" msgstr "({nimetön})" #: cp/error.c:1035 #, fuzzy -#| msgid "(anonymous)" msgid "(anonymous namespace)" msgstr "(nimetön)" @@ -3949,7 +3929,7 @@ msgstr "" msgid "<declaration error>" msgstr "<esittelyvirhe>" -#: cp/error.c:1445 cp/error.c:2855 +#: cp/error.c:1445 cp/error.c:2859 msgid "with" msgstr "" @@ -3972,113 +3952,115 @@ msgstr "<throw-lauseke>" msgid "<unparsed>" msgstr "<jäsentämätön>" -#: cp/error.c:2504 +#: cp/error.c:2498 +#, fuzzy +msgid "<lambda>" +msgstr "<lambda" + +#: cp/error.c:2508 msgid "<expression error>" msgstr "<lausekevirhe>" -#: cp/error.c:2518 +#: cp/error.c:2522 msgid "<unknown operator>" msgstr "<tuntematon operaattori>" -#: cp/error.c:2807 +#: cp/error.c:2811 msgid "{unknown}" msgstr "{tuntematon}" -#: cp/error.c:2922 +#: cp/error.c:2926 msgid "At global scope:" msgstr "" -#: cp/error.c:3028 -#, fuzzy, c-format +#: cp/error.c:3032 +#, c-format msgid "In static member function %qs" -msgstr "Jäsenfunktio %qs" +msgstr "Staattinen jäsenfunktio %qs" -#: cp/error.c:3030 -#, fuzzy, c-format +#: cp/error.c:3034 +#, c-format msgid "In copy constructor %qs" -msgstr "Muodostin %qs" +msgstr "Kopiomuodostin %qs" -#: cp/error.c:3032 +#: cp/error.c:3036 #, c-format msgid "In constructor %qs" msgstr "Muodostin %qs" -#: cp/error.c:3034 -#, fuzzy, c-format +#: cp/error.c:3038 +#, c-format msgid "In destructor %qs" -msgstr "Muodostin %qs" +msgstr "Hajotin %qs" -#: cp/error.c:3036 -#, fuzzy +#: cp/error.c:3040 msgid "In lambda function" -msgstr "Jäsenfunktio %qs" +msgstr "Lambda-funktio" -#: cp/error.c:3056 +#: cp/error.c:3060 #, fuzzy, c-format msgid "%s: In substitution of %qS:\n" msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" -#: cp/error.c:3057 +#: cp/error.c:3061 #, fuzzy msgid "%s: In instantiation of %q#D:\n" msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" -#: cp/error.c:3080 +#: cp/error.c:3084 #, c-format msgid "%s:%d:%d: " msgstr "" -#: cp/error.c:3083 +#: cp/error.c:3087 #, c-format msgid "%s:%d: " msgstr "" -#: cp/error.c:3091 +#: cp/error.c:3095 #, c-format msgid "recursively required by substitution of %qS\n" msgstr "" -#: cp/error.c:3092 +#: cp/error.c:3096 #, c-format msgid "required by substitution of %qS\n" msgstr "" -#: cp/error.c:3097 +#: cp/error.c:3101 msgid "recursively required from %q#D\n" msgstr "" -#: cp/error.c:3098 +#: cp/error.c:3102 msgid "required from %q#D\n" msgstr "" -#: cp/error.c:3105 +#: cp/error.c:3109 #, fuzzy -#| msgid "previously defined here" msgid "recursively required from here" msgstr "määritelty aiemmin täällä" -#: cp/error.c:3106 +#: cp/error.c:3110 #, fuzzy -#| msgid " from here" msgid "required from here" msgstr " täältä" -#: cp/error.c:3158 +#: cp/error.c:3162 #, c-format msgid "%s:%d:%d: [ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n" msgstr "" -#: cp/error.c:3163 +#: cp/error.c:3167 #, c-format msgid "%s:%d: [ skipping %d instantiation contexts, use -ftemplate-backtrace-limit=0 to disable ]\n" msgstr "" -#: cp/error.c:3227 +#: cp/error.c:3231 #, fuzzy, c-format msgid "%s:%d:%d: in constexpr expansion of %qs" msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" -#: cp/error.c:3231 +#: cp/error.c:3235 #, fuzzy, c-format msgid "%s:%d: in constexpr expansion of %qs" msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" @@ -4087,13 +4069,12 @@ msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" msgid "candidates are:" msgstr "ehdokkaat ovat:" -#: cp/pt.c:17926 cp/call.c:3290 -#, fuzzy, gcc-internal-format -#| msgid "candidate 1:" +#: cp/pt.c:17922 cp/call.c:3290 +#, gcc-internal-format msgid "candidate is:" msgid_plural "candidates are:" -msgstr[0] "ehdokas 1:" -msgstr[1] "ehdokas 1:" +msgstr[0] "ehdokas on:" +msgstr[1] "ehdokkaat ovat:" #: cp/rtti.c:537 #, fuzzy @@ -4522,9 +4503,8 @@ msgid "module procedure" msgstr "tyhjä esittely" #: fortran/resolve.c:592 -#, fuzzy msgid "internal function" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "sisäinen funktio" #: fortran/resolve.c:2051 msgid "elemental procedure" @@ -4600,7 +4580,6 @@ msgstr "" #: fortran/resolve.c:6682 #, fuzzy -#| msgid "%qD is not a variable" msgid "iterator variable" msgstr "%qD ei ole muuttuja" @@ -4651,12 +4630,12 @@ msgstr "" msgid "Integer overflow when calculating the amount of memory to allocate" msgstr "" -#: fortran/trans-decl.c:4842 +#: fortran/trans-decl.c:4844 #, c-format msgid "Actual string length does not match the declared one for dummy argument '%s' (%ld/%ld)" msgstr "" -#: fortran/trans-decl.c:4850 +#: fortran/trans-decl.c:4852 #, c-format msgid "Actual string length is shorter than the declared one for dummy argument '%s' (%ld/%ld)" msgstr "" @@ -4671,12 +4650,12 @@ msgstr "" msgid "Unequal character lengths (%ld/%ld) in %s" msgstr "" -#: fortran/trans-intrinsic.c:6157 +#: fortran/trans-intrinsic.c:6156 #, fuzzy, c-format msgid "Argument NCOPIES of REPEAT intrinsic is negative (its value is %ld)" msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" -#: fortran/trans-intrinsic.c:6189 +#: fortran/trans-intrinsic.c:6188 msgid "Argument NCOPIES of REPEAT intrinsic is too large" msgstr "" @@ -4707,7 +4686,7 @@ msgstr "" #: fortran/trans.c:46 msgid "Array reference out of bounds" -msgstr "" +msgstr "Taulukkoviite rajojen ulkopuolella" #: fortran/trans.c:47 msgid "Incorrect function return value" @@ -4715,7 +4694,7 @@ msgstr "Virheellinen funktion paluuarvo" #: fortran/trans.c:573 msgid "Memory allocation failed" -msgstr "" +msgstr "Muistinvaraus epäonnistui" #: fortran/trans.c:649 fortran/trans.c:1270 msgid "Allocation would exceed memory limit" @@ -4896,7 +4875,7 @@ msgstr "%s: Ei voi avata tulostetiedostoa: %s\n" #: java/jvgenmain.c:165 #, c-format msgid "%s: Failed to close output file %s\n" -msgstr "%s: Tulostetiedoston %s sulkeminen epäonnistui\n" +msgstr "%s: Tulostiedoston %s sulkeminen epäonnistui\n" #: objc/lang-specs.h:30 objc/lang-specs.h:41 msgid "GNU Objective C no longer supports traditional compilation" @@ -4906,7 +4885,7 @@ msgstr "" msgid "objc-cpp-output is deprecated; please use objective-c-cpp-output instead" msgstr "" -#: java/jvspec.c:79 ada/gcc-interface/lang-specs.h:33 gcc.c:844 +#: java/jvspec.c:79 ada/gcc-interface/lang-specs.h:33 gcc.c:845 msgid "-pg and -fomit-frame-pointer are incompatible" msgstr "" @@ -4967,7 +4946,7 @@ msgstr "" msgid "consider using '-pg' instead of '-p' with gprof(1)" msgstr "" -#: config/sh/sh.h:360 config/sh/sh.h:363 +#: config/sh/sh.h:363 config/sh/sh.h:366 msgid "SH2a does not support little-endian" msgstr "" @@ -5032,7 +5011,7 @@ msgid "the -shared option is not currently supported for VAX ELF" msgstr "" #: config/i386/mingw-w64.h:82 config/i386/mingw32.h:115 -#: config/i386/cygwin.h:113 +#: config/i386/cygwin.h:109 msgid "shared and mdll are not compatible" msgstr "" @@ -5058,7 +5037,6 @@ msgstr "" #: config/arm/arm.h:206 #, fuzzy -#| msgid "-mbig-endian and -mlittle-endian may not be used together" msgid "-mfloat-abi=soft and -mfloat-abi=hard may not be used together" msgstr "valitsimia -mbig-endian ja -mlittle-endian ei voi käyttää yhdessä" @@ -5067,35 +5045,32 @@ msgid "-mbig-endian and -mlittle-endian may not be used together" msgstr "valitsimia -mbig-endian ja -mlittle-endian ei voi käyttää yhdessä" #: config/bfin/elf.h:55 -#, fuzzy msgid "no processor type specified for linking" -msgstr "%J ristiriitaiset tyyppimääreet %qD:lle" +msgstr "linkitystä varten ei ole määritelty suoritinta" #: config/vax/vax.h:46 config/vax/vax.h:47 #, fuzzy -#| msgid "profiling not supported with -mg\n" msgid "profiling not supported with -mg" msgstr "profilointia ei tueta valitsimen -mg kanssa\n" -#: gcc.c:704 +#: gcc.c:705 #, fuzzy -#| msgid "weakref is not supported in this configuration" msgid "-fuse-linker-plugin is not supported in this configuration" msgstr "weakref ei ole tuettu tässä konfiguraatiossa" -#: gcc.c:718 +#: gcc.c:719 msgid "cannot specify -static with -fsanitize=address" msgstr "" -#: gcc.c:720 +#: gcc.c:721 msgid "-fsanitize=thread linking must be done with -pie or -shared" msgstr "" -#: gcc.c:1012 +#: gcc.c:1013 msgid "GNU C no longer supports -traditional without -E" -msgstr "" +msgstr "GCC ei enää tue valitsinta -traditional ilman valitsinta -E" -#: gcc.c:1021 +#: gcc.c:1022 msgid "-E or -x required when input is from standard input" msgstr "" @@ -5148,17 +5123,15 @@ msgstr "" #: fortran/lang.opt:230 #, fuzzy -#| msgid "Warn about implicit conversion" msgid "Warn about most implicit conversions" msgstr "Varoita implisiittisistä muunnoksista" -#: fortran/lang.opt:234 common.opt:542 +#: fortran/lang.opt:234 common.opt:546 msgid "Print extra (possibly unwanted) warnings" msgstr "Näytä ylimääräisiä (mahdollisesti ei-toivottuja) varoituksia" #: fortran/lang.opt:238 #, fuzzy -#| msgid "Warn about implicit function declarations" msgid "Warn about function call elimination" msgstr "Varoita implisiittisistä funktioesittelyistä" @@ -5215,7 +5188,6 @@ msgstr "" #: fortran/lang.opt:294 #, fuzzy -#| msgid "Warn about misuses of pragmas" msgid "Warn about unused dummy arguments." msgstr "Varoita pragmain väärästä käytöstä" @@ -5262,11 +5234,11 @@ msgstr "" #: fortran/lang.opt:350 msgid "Use big-endian format for unformatted files" -msgstr "" +msgstr "Käytä big-endian-muotoa muotoilemattomille tiedostoille" #: fortran/lang.opt:354 msgid "Use little-endian format for unformatted files" -msgstr "" +msgstr "Käytä little-endian-muotoa muotoilemattomille tiedostoille" #: fortran/lang.opt:358 msgid "Use native format for unformatted files" @@ -5304,9 +5276,9 @@ msgstr "" msgid "Allow dollar signs in entity names" msgstr "" -#: fortran/lang.opt:394 config/alpha/alpha.opt:31 common.opt:656 -#: common.opt:830 common.opt:834 common.opt:838 common.opt:842 common.opt:1227 -#: common.opt:1360 common.opt:1364 +#: fortran/lang.opt:394 config/alpha/alpha.opt:31 common.opt:660 +#: common.opt:834 common.opt:838 common.opt:842 common.opt:846 common.opt:1231 +#: common.opt:1364 common.opt:1368 msgid "Does nothing. Preserved for backward compatibility." msgstr "" @@ -5498,7 +5470,7 @@ msgstr "" #: fortran/lang.opt:598 msgid "Compile all program units at once and check all interfaces" -msgstr "" +msgstr "Käännä kaikki ohjelmayksiköt kerralla ja tarkasta kaikki rajapinnat" #: fortran/lang.opt:638 msgid "Statically link the GNU Fortran helper library (libgfortran)" @@ -5514,7 +5486,6 @@ msgstr "Noudata ISO Fortran 2009 -standardia" #: fortran/lang.opt:650 #, fuzzy -#| msgid "Conform to the ISO Fortran 2008 standard" msgid "Conform to the ISO Fortran 2008 standard including TS 29113" msgstr "Noudata ISO Fortran 2009 -standardia" @@ -5544,7 +5515,7 @@ msgstr "makron nimi puuttuu %qs:n jälkeen" #: c-family/c.opt:70 c-family/c.opt:73 c-family/c.opt:76 c-family/c.opt:79 #: c-family/c.opt:175 c-family/c.opt:178 c-family/c.opt:216 c-family/c.opt:220 #: c-family/c.opt:232 c-family/c.opt:1253 c-family/c.opt:1261 -#: config/darwin.opt:53 common.opt:300 common.opt:303 common.opt:2399 +#: config/darwin.opt:53 common.opt:300 common.opt:303 common.opt:2403 #, c-format msgid "missing filename after %qs" msgstr "tiedostonimi puuttuu %qs:n jälkeen" @@ -5562,11 +5533,11 @@ msgstr "" #: c-family/c.opt:186 msgid "Do not discard comments" -msgstr "" +msgstr "Älä hylkää kommentteja" #: c-family/c.opt:190 msgid "Do not discard comments in macro expansions" -msgstr "" +msgstr "Älä hylkää kommentteja makroja laajennettaessa" #: c-family/c.opt:194 msgid "-D<macro>[=<val>]\tDefine a <macro> with <val> as its value. If just <macro> is given, <val> is taken to be 1" @@ -5594,7 +5565,6 @@ msgstr "Luo make-riippuvuudet ja käännä" #: c-family/c.opt:221 #, fuzzy -#| msgid "Write dependency output to the given file" msgid "-MF <file>\tWrite dependency output to the given file" msgstr "Kirjoita riippuvuustuloste annettuun tiedostoon" @@ -5629,7 +5599,7 @@ msgstr "" #: c-family/c.opt:249 msgid "Do not generate #line directives" -msgstr "" +msgstr "Älä luo #line-direktiivejä" #: c-family/c.opt:253 msgid "-U<macro>\tUndefine <macro>" @@ -5670,19 +5640,17 @@ msgstr "Varoita C:n rakenteista, jotka eivät ole C:n ja C++:n yhteisessä osajo #: c-family/c.opt:296 #, fuzzy -#| msgid "Deprecated in favor of -std=c99" msgid "Deprecated in favor of -Wc++11-compat" msgstr "Vanhentunut, ks. -std=c99" #: c-family/c.opt:300 #, fuzzy -#| msgid "Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 201x" msgid "Warn about C++ constructs whose meaning differs between ISO C++ 1998 and ISO C++ 2011" msgstr "Varoita C++:n rakenteista, joilla on eri merkitys ISO C++ 1998- ja ISO C++ 201x -standardeissa" #: c-family/c.opt:304 msgid "Warn about casts which discard qualifiers" -msgstr "" +msgstr "Varoita tyyppimuunnoksista, jotka hylkäävät määreet" #: c-family/c.opt:308 msgid "Warn about subscripts whose type is \"char\"" @@ -5690,11 +5658,11 @@ msgstr "Varoita ”char”-tyypillä indeksoinnista" #: c-family/c.opt:312 msgid "Warn about variables that might be changed by \"longjmp\" or \"vfork\"" -msgstr "" +msgstr "Varoita muuttujista, jotka ”longjmp” tai ”vfork” saattavat muuttaa" #: c-family/c.opt:316 msgid "Warn about possibly nested block comments, and C++ comments spanning more than one physical line" -msgstr "" +msgstr "Varoita mahdollisista sisäkkäisistä lohkokommenteista ja C++-kommenteista, jotka ulottuvat useammalle kuin yhdelle fyysiselle riville" #: c-family/c.opt:320 msgid "Synonym for -Wcomment" @@ -5706,7 +5674,6 @@ msgstr "" #: c-family/c.opt:328 #, fuzzy -#| msgid "converting NULL to non-pointer type" msgid "Warn for converting NULL from/to a non-pointer type" msgstr "NULLin muunnos epäosoitintyypiksi" @@ -5720,7 +5687,6 @@ msgstr "" #: c-family/c.opt:340 #, fuzzy -#| msgid "Warn about non-virtual destructors" msgid "Warn about deleting polymorphic objects with non-virtual destructors" msgstr "Varoita epävirtuaalisista hajottimista" @@ -5738,11 +5704,11 @@ msgstr "Varoita Effective C++ -tyylisääntöjen rikkomuksista" #: c-family/c.opt:360 msgid "Warn about an empty body in an if or else statement" -msgstr "Varoita tyhjästä rungosta if-tai else-lauseissa" +msgstr "Varoita tyhjästä rungosta if- ja else-lauseissa" #: c-family/c.opt:364 msgid "Warn about stray tokens after #elif and #endif" -msgstr "" +msgstr "Varoita ylimääräisistä merkeistä #elif- ja #endif-direktiivien perässä" #: c-family/c.opt:368 msgid "Warn about comparison of different enum types" @@ -5754,7 +5720,7 @@ msgstr "" #: c-family/c.opt:384 msgid "Warn if testing floating point numbers for equality" -msgstr "" +msgstr "Varoita liukulukujen yhtäsuuruusvertailuista" #: c-family/c.opt:388 c-family/c.opt:416 msgid "Warn about printf/scanf/strftime/strfmon format string anomalies" @@ -5794,13 +5760,11 @@ msgstr "Varoita muuttujista, jotka alustetaan omalla arvollaan" #: c-family/c.opt:428 #, fuzzy -#| msgid "Warn about implicit function declarations" msgid "Warn about implicit declarations" msgstr "Varoita implisiittisistä funktioesittelyistä" #: c-family/c.opt:432 #, fuzzy -#| msgid "Warn about implicit conversion" msgid "Warn about implicit conversions from \"float\" to \"double\"" msgstr "Varoita implisiittisistä muunnoksista" @@ -5817,9 +5781,8 @@ msgid "Warn about C++11 inheriting constructors when the base has a variadic con msgstr "" #: c-family/c.opt:451 -#, fuzzy msgid "Warn when there is a cast to a pointer from an integer of a different size" -msgstr "tyyppimuunnos erisuuruisesta kokonaisluvusta osoittimeksi" +msgstr "Varoita osoittimien tyyppimuunnoksista erikokoisiksi kokonaisluvuiksi" #: c-family/c.opt:455 msgid "Warn about invalid uses of the \"offsetof\" macro" @@ -5852,7 +5815,7 @@ msgstr "Varoita epäilyttävistä ”main”-funktion esittelyistä" #: c-family/c.opt:487 msgid "Warn about possibly missing braces around initializers" -msgstr "" +msgstr "Varoita mahdollisesti puuttuvista aaltosuluista alustimissa" #: c-family/c.opt:491 msgid "Warn about global functions without previous declarations" @@ -5860,7 +5823,7 @@ msgstr "" #: c-family/c.opt:495 msgid "Warn about missing fields in struct initializers" -msgstr "" +msgstr "Varoita puuttuvista kentistä struct-alustimissa" #: c-family/c.opt:502 msgid "Warn about functions which might be candidates for format attributes" @@ -5884,7 +5847,7 @@ msgstr "Varoita annetuista include-hakemistoista, jotka eivät ole olemassa" #: c-family/c.opt:526 msgid "Warn about function parameters declared without a type specifier in K&R-style functions" -msgstr "" +msgstr "Varoita funktioparametreistä, jotka on esitelty ilman tyyppimäärittelyjä K&R-tyylisissä funktioissa" #: c-family/c.opt:530 msgid "Warn about global functions without prototypes" @@ -5923,10 +5886,8 @@ msgid "Warn about NULL being passed to argument slots marked as requiring non-NU msgstr "" #: c-family/c.opt:574 -#, fuzzy -#| msgid "Warn about non-normalised Unicode strings" msgid "-Wnormalized=<id|nfc|nfkc>\tWarn about non-normalised Unicode strings" -msgstr "Varoita normalisoimattomista Unicode-merkkijonoista" +msgstr "-Wnormalized=<id|nfc|nfkc>\tVaroita normalisoimattomista Unicode-merkkijonoista" #: c-family/c.opt:578 msgid "Warn if a C-style cast is used in a program" @@ -5977,6 +5938,7 @@ msgstr "" msgid "Warn when a pointer is cast to an integer of a different size" msgstr "tyyppimuunnos osoittimesta erisuuruiseen kokonaislukuun" +# vähän fuzzy #: c-family/c.opt:634 msgid "Warn about misuses of pragmas" msgstr "Varoita pragmain väärästä käytöstä" @@ -5999,7 +5961,7 @@ msgstr "Varoita kun kääntäjä järjestää koodia uudelleen" #: c-family/c.opt:654 msgid "Warn about returning a pointer/reference to a local or temporary variable." -msgstr "" +msgstr "Varoita osoittimen/viittauksen palauttamisesta paikalliseen tai väliaikiseen muuttujaan." #: c-family/c.opt:658 msgid "Warn whenever a function's return type defaults to \"int\" (C), or about inconsistent return types (C++)" @@ -6082,13 +6044,11 @@ msgid "Warn about macros defined in the main file that are not used" msgstr "" #: c-family/c.opt:766 -#, fuzzy msgid "Warn if a caller of a function, marked with attribute warn_unused_result, does not use its return value" -msgstr "%Hattribuutilla warn_unused_result esitellyn funktion paluuarvoa ei huomioida" +msgstr "Varoita, jos attribuutilla warn_unused_result merkitty funktion kutsuja ei käytä paluuarvoa" #: c-family/c.opt:770 #, fuzzy -#| msgid "Warn about unrecognized pragmas" msgid "Warn about using variadic macros" msgstr "Varoita tuntemattomista pragmoista" @@ -6116,21 +6076,17 @@ msgstr "" # puhuta, miksi tässä? #: c-family/c.opt:790 #, fuzzy -#| 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." 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 "C++:ssa varoitetaan vanhentuneesta merkkijonoliteraalien tyyppimuunnoksesta ”char *”:een. C:ssä annetaan vastaava varoitus, vaikkei muunnos ISO C -standardin mukaan tietenkään ole vanhentunut." #: c-family/c.opt:794 #, fuzzy -#| msgid "Warn when a label is unused" msgid "Warn when a literal '0' is used as null pointer" msgstr "Varoita kun nimiö on käyttämätön" #: c-family/c.opt:798 -#, fuzzy -#| msgid "Warn about misuses of pragmas" msgid "Warn about useless casts" -msgstr "Varoita pragmain väärästä käytöstä" +msgstr "Varoita tarpeettomista tyyppimuunnoksista" #: c-family/c.opt:802 msgid "A synonym for -std=c89 (for C) or -std=c++98 (for C++)" @@ -6161,7 +6117,6 @@ msgstr "" #: c-family/c.opt:825 c-family/c.opt:958 c-family/c.opt:1201 #: c-family/c.opt:1205 c-family/c.opt:1221 #, fuzzy -#| msgid "switch %qs is no longer supported" msgid "No longer supported" msgstr "valitsin %qs ei ole enää tuettu" @@ -6186,9 +6141,9 @@ msgid "Allow the arguments of the '?' operator to have different types" msgstr "Salli ”?”-operaattorin argumenttien olla eri tyyppiä" #: c-family/c.opt:856 c-family/c.opt:876 c-family/c.opt:1074 -#: config/sh/sh.opt:209 common.opt:949 common.opt:1135 common.opt:1439 -#: common.opt:1713 common.opt:1749 common.opt:1834 common.opt:1838 -#: common.opt:1914 common.opt:1996 common.opt:2020 common.opt:2108 +#: config/sh/sh.opt:213 common.opt:953 common.opt:1139 common.opt:1443 +#: common.opt:1717 common.opt:1753 common.opt:1838 common.opt:1842 +#: common.opt:1918 common.opt:2000 common.opt:2024 common.opt:2112 msgid "Does nothing. Preserved for backward compatibility." msgstr "" @@ -6260,11 +6215,11 @@ msgstr "" #: c-family/c.opt:933 msgid "Recognize GNU-defined keywords" -msgstr "" +msgstr "Tunnista GNU-määritellyt avainsanat" #: c-family/c.opt:937 msgid "Generate code for GNU runtime environment" -msgstr "" +msgstr "Tuota koodi GNU-suoritusympäristölle" #: c-family/c.opt:941 msgid "Use traditional GNU semantics for inline functions" @@ -6361,7 +6316,6 @@ msgstr "" #: c-family/c.opt:1062 #, fuzzy -#| msgid "Conform to the ISO 1990 C standard as amended in 1994" msgid "Conform to the Objective-C 1.0 language as implemented in GCC 4.0" msgstr "Noudata ISO 1990 C -standardia vuoden 1994 korjauksineen" @@ -6452,7 +6406,6 @@ msgstr "" #: c-family/c.opt:1173 #, fuzzy -#| msgid "Do not generate thread-safe code for initializing local statics" msgid "-fno-threadsafe-statics\tDo not generate thread-safe code for initializing local statics" msgstr "Älä luo säieturvallista koodia paikallisten staattisten muuttujien alustamiseksi" @@ -6534,17 +6487,16 @@ msgstr "" #: c-family/c.opt:1266 #, fuzzy -#| msgid "Specify <path> as a prefix for next two options" msgid "-iprefix <path>\tSpecify <path> as a prefix for next two options" msgstr "Määrittele <polku> etuliitteeksi seuraaville kahdelle valitsimelle" #: c-family/c.opt:1270 msgid "-isysroot <dir>\tSet <dir> to be the system root directory" -msgstr "" +msgstr "-isysroot <hakemisto>\tAseta <hakemisto> järjestelmän juurihakemistoksi" #: c-family/c.opt:1274 msgid "-isystem <dir>\tAdd <dir> to the start of the system include path" -msgstr "" +msgstr "-isystem <hakemisto>\tLisää <hakemisto> järjestelmän include-polun alkuun" #: c-family/c.opt:1278 msgid "-iquote <dir>\tAdd <dir> to the end of the quote include path" @@ -6576,38 +6528,29 @@ msgstr "" #: c-family/c.opt:1320 c-family/c.opt:1324 #, fuzzy -#| msgid "Conform to the ISO 1998 C++ standard with GNU extensions" msgid "Conform to the ISO 1998 C++ standard revised by the 2003 technical corrigendum" msgstr "Noudata ISO 1998 C++ -standardia GNU-laajennoksineen" #: c-family/c.opt:1328 -#, fuzzy -#| msgid "Conform to the ISO 1998 C++ standard with GNU extensions" msgid "Conform to the ISO 2011 C++ standard (experimental and incomplete support)" -msgstr "Noudata ISO 1998 C++ -standardia GNU-laajennoksineen" +msgstr "Noudata ISO 2011 C++ -standardia (kokeellinen ja epätäydellinen tuki)" #: c-family/c.opt:1332 #, fuzzy -#| msgid "Deprecated in favor of -std=c99" msgid "Deprecated in favor of -std=c++11" msgstr "Vanhentunut, ks. -std=c99" -# Viesti ei jatku englanniksikaan pidemmälle. #: c-family/c.opt:1336 -#, fuzzy -#| msgid "Conform to the ISO 1998 C++ standard, with extensions that are likely to" msgid "Conform to the ISO 201y(7?) C++ draft standard (experimental and incomplete support)" -msgstr "Noudata ISO 1998 C++ -standardia laajennoksineen, jotka todennäköisesti" +msgstr "Noudata ISO 201y(7?) C++ -standardiluonnosta (kokeellinen ja epätäydellinen tuki)" #: c-family/c.opt:1340 c-family/c.opt:1426 #, fuzzy -#| msgid "Conform to the ISO 1990 C standard as amended in 1994" msgid "Conform to the ISO 2011 C standard (experimental and incomplete support)" msgstr "Noudata ISO 1990 C -standardia vuoden 1994 korjauksineen" #: c-family/c.opt:1344 #, fuzzy -#| msgid "Deprecated in favor of -std=c99" msgid "Deprecated in favor of -std=c11" msgstr "Vanhentunut, ks. -std=c99" @@ -6625,37 +6568,31 @@ msgstr "Vanhentunut, ks. -std=c99" #: c-family/c.opt:1364 c-family/c.opt:1369 #, fuzzy -#| msgid "Conform to the ISO 1998 C++ standard with GNU extensions" msgid "Conform to the ISO 1998 C++ standard revised by the 2003 technical" msgstr "Noudata ISO 1998 C++ -standardia GNU-laajennoksineen" #: c-family/c.opt:1374 #, fuzzy -#| msgid "Conform to the ISO 1998 C++ standard, with GNU extensions and" msgid "Conform to the ISO 2011 C++ standard with GNU extensions (experimental and incomplete support)" msgstr "Noudata ISO 1998 C++ -standardia GNU-laajennoksineen ja" #: c-family/c.opt:1378 #, fuzzy -#| msgid "Deprecated in favor of -std=c99" msgid "Deprecated in favor of -std=gnu++11" msgstr "Vanhentunut, ks. -std=c99" #: c-family/c.opt:1382 #, fuzzy -#| msgid "Conform to the ISO 1998 C++ standard, with GNU extensions and" msgid "Conform to the ISO 201y(7?) C++ draft standard with GNU extensions (experimental and incomplete support)" msgstr "Noudata ISO 1998 C++ -standardia GNU-laajennoksineen ja" #: c-family/c.opt:1386 #, fuzzy -#| msgid "Conform to the ISO 1998 C++ standard, with GNU extensions and" msgid "Conform to the ISO 2011 C standard with GNU extensions (experimental and incomplete support)" msgstr "Noudata ISO 1998 C++ -standardia GNU-laajennoksineen ja" #: c-family/c.opt:1390 #, fuzzy -#| msgid "Deprecated in favor of -std=c99" msgid "Deprecated in favor of -std=gnu11" msgstr "Vanhentunut, ks. -std=c99" @@ -6693,7 +6630,6 @@ msgstr "" #: ada/gcc-interface/lang.opt:63 #, fuzzy -#| msgid "Synonym for -Wcomment" msgid "Synonym of -gnatk8" msgstr "Sama kuin -Wcomment" @@ -6747,7 +6683,6 @@ msgstr "" #: go/lang.opt:70 #, fuzzy -#| msgid "function declared %<noreturn%> has a %<return%> statement" msgid "Functions which return values must end with return statements" msgstr "%<noreturn%>-esitellyllä funktiolla on %<return%>-lause" @@ -6787,7 +6722,7 @@ msgstr "" #: config/mcore/mcore.opt:35 config/score/score.opt:23 #: config/moxie/moxie.opt:23 msgid "Generate big-endian code" -msgstr "" +msgstr "Tuota big-endian-koodia" #: config/mcore/mcore.opt:39 msgid "Emit call graph information" @@ -6804,7 +6739,7 @@ msgstr "" #: config/mcore/mcore.opt:51 config/score/score.opt:27 #: config/moxie/moxie.opt:27 msgid "Generate little-endian code" -msgstr "" +msgstr "Tuota little-endian-koodia" #: config/mcore/mcore.opt:56 config/fr30/fr30.opt:27 msgid "Assume that run-time support has been provided, so omit -lsim from the linker command line" @@ -6824,12 +6759,11 @@ msgstr "" #: config/mcore/mcore.opt:75 msgid "Always treat bitfields as int-sized" -msgstr "" +msgstr "Käsittele bittikenttiä aina int-kokoisina" #: config/linux-android.opt:23 -#, fuzzy msgid "Generate code for the Android platform." -msgstr "Käytä AltiVec-käskyjä" +msgstr "Tuota koodia Android-alustalle." #: config/mmix/mmix.opt:24 msgid "For intrinsics library: pass all parameters in registers" @@ -6893,11 +6827,11 @@ msgstr "" #: config/mmix/mmix.opt:95 msgid "Set start-address of the program" -msgstr "" +msgstr "Aseta ohjelman alkuosoite" #: config/mmix/mmix.opt:99 msgid "Set start-address of data" -msgstr "" +msgstr "Aseta datan alkuosoite" #: config/darwin.opt:114 msgid "Generate compile-time CFString objects" @@ -6913,7 +6847,7 @@ msgstr "" #: config/darwin.opt:217 msgid "Generate code suitable for executables (NOT shared libs)" -msgstr "" +msgstr "Tuota suoritettaville tiedostoille sopivaa koodia (EI jaetuille kirjastoille)" #: config/darwin.opt:221 msgid "Generate code suitable for fast turn around debugging" @@ -7002,9 +6936,8 @@ msgid "Do stack checking using bounds in L1 scratch memory" msgstr "" #: config/bfin/bfin.opt:102 -#, fuzzy msgid "Enable multicore support" -msgstr "säiekohtaista muistia ei tueta tälle kohteelle" +msgstr "Ota käyttöön moniydintuki" #: config/bfin/bfin.opt:106 msgid "Build for Core A" @@ -7040,75 +6973,75 @@ msgstr "" #: config/m68k/m68k.opt:30 msgid "Generate code for a 520X" -msgstr "" +msgstr "Tuota 520X-koodia" #: config/m68k/m68k.opt:34 msgid "Generate code for a 5206e" -msgstr "" +msgstr "Tuota 5206e-koodia" #: config/m68k/m68k.opt:38 msgid "Generate code for a 528x" -msgstr "" +msgstr "Tuota 528x-koodia" #: config/m68k/m68k.opt:42 msgid "Generate code for a 5307" -msgstr "" +msgstr "Tuota 5307-koodia" #: config/m68k/m68k.opt:46 msgid "Generate code for a 5407" -msgstr "" +msgstr "Tuota 5407-koodia" #: config/m68k/m68k.opt:50 config/m68k/m68k.opt:111 msgid "Generate code for a 68000" -msgstr "" +msgstr "Tuota 68000-koodia" #: config/m68k/m68k.opt:54 msgid "Generate code for a 68010" -msgstr "" +msgstr "Tuota 68010-koodia" #: config/m68k/m68k.opt:58 config/m68k/m68k.opt:115 msgid "Generate code for a 68020" -msgstr "" +msgstr "Tuota 68020-koodia" #: config/m68k/m68k.opt:62 msgid "Generate code for a 68040, without any new instructions" -msgstr "" +msgstr "Tuota 68040-koodia, ilman uusia käskyjä" #: config/m68k/m68k.opt:66 msgid "Generate code for a 68060, without any new instructions" -msgstr "" +msgstr "Tuota 68060-koodia, ilman uusia käskyjä" #: config/m68k/m68k.opt:70 msgid "Generate code for a 68030" -msgstr "" +msgstr "Tuota 68030-koodia" #: config/m68k/m68k.opt:74 msgid "Generate code for a 68040" -msgstr "" +msgstr "Tuota 68040-koodia" #: config/m68k/m68k.opt:78 msgid "Generate code for a 68060" -msgstr "" +msgstr "Tuota 68060-koodia" #: config/m68k/m68k.opt:82 msgid "Generate code for a 68302" -msgstr "" +msgstr "Tuota 68302-koodia" #: config/m68k/m68k.opt:86 msgid "Generate code for a 68332" -msgstr "" +msgstr "Tuota 68332-koodia" #: config/m68k/m68k.opt:91 msgid "Generate code for a 68851" -msgstr "" +msgstr "Tuota 68851-koodia" #: config/m68k/m68k.opt:95 msgid "Generate code that uses 68881 floating-point instructions" -msgstr "" +msgstr "Tuota koodia, joka käyttää 68881-liukulukukäskyjä" #: config/m68k/m68k.opt:99 msgid "Align variables on a 32-bit boundary" -msgstr "" +msgstr "Kohdista muuttujat 32 bitin rajoille" #: config/m68k/m68k.opt:103 config/score/score.opt:47 config/arm/arm.opt:81 #: config/c6x/c6x.opt:67 @@ -7117,7 +7050,7 @@ msgstr "" #: config/m68k/m68k.opt:107 msgid "Use the bit-field instructions" -msgstr "" +msgstr "Käytä bittikenttäkäskyjä" #: config/m68k/m68k.opt:119 msgid "Generate code for a ColdFire v4e" @@ -7192,28 +7125,34 @@ msgid "Support TLS segment larger than 64K" msgstr "" #: config/m32c/m32c.opt:23 +#, fuzzy msgid "-msim\tUse simulator runtime" -msgstr "" +msgstr "Käytä simulaattorin ajoaikaista ympäristöä." #: config/m32c/m32c.opt:27 +#, fuzzy msgid "-mcpu=r8c\tCompile code for R8C variants" -msgstr "" +msgstr "Käännä koodi R8C-varianteille" #: config/m32c/m32c.opt:31 +#, fuzzy msgid "-mcpu=m16c\tCompile code for M16C variants" -msgstr "" +msgstr "Käännä koodi M16C-varianteille" #: config/m32c/m32c.opt:35 +#, fuzzy msgid "-mcpu=m32cm\tCompile code for M32CM variants" -msgstr "" +msgstr "Käännä koodi M32CM-varianteille" #: config/m32c/m32c.opt:39 +#, fuzzy msgid "-mcpu=m32c\tCompile code for M32C variants" -msgstr "" +msgstr "Käännä koodi M32C-varianteille" #: config/m32c/m32c.opt:43 +#, fuzzy msgid "-memregs=\tNumber of memreg bytes (default: 16, range: 0..16)" -msgstr "" +msgstr "Memreg-tavujen lukumäärä (oletus: 16, lukualue: 0..16)" #: config/picochip/picochip.opt:23 msgid "Specify which type of AE to target. This option sets the mul-type and byte-access." @@ -7263,7 +7202,6 @@ msgstr "" #: config/aarch64/aarch64.opt:76 #, fuzzy -#| msgid "Specify ABI to use" msgid "Specify the code model" msgstr "Määrittele käytettävä ABI" @@ -7305,27 +7243,27 @@ msgstr "" #: config/ia64/ilp32.opt:3 msgid "Generate ILP32 code" -msgstr "" +msgstr "Tuota ILP32-koodia" #: config/ia64/ilp32.opt:7 msgid "Generate LP64 code" -msgstr "" +msgstr "Tuota LP64-koodia" #: config/ia64/ia64.opt:28 msgid "Generate big endian code" -msgstr "" +msgstr "Tuota big endian -koodia" #: config/ia64/ia64.opt:32 msgid "Generate little endian code" -msgstr "" +msgstr "Tuota little endian -koodia" #: config/ia64/ia64.opt:36 msgid "Generate code for GNU as" -msgstr "" +msgstr "Tuota koodia GNU as:lle" #: config/ia64/ia64.opt:40 msgid "Generate code for GNU ld" -msgstr "" +msgstr "Tuota koodia GNU ld:lle" #: config/ia64/ia64.opt:44 msgid "Emit stop bits before and after volatile extended asms" @@ -7392,7 +7330,7 @@ msgid "Enable earlier placing stop bits for better scheduling" msgstr "" #: config/ia64/ia64.opt:114 config/spu/spu.opt:72 config/pa/pa.opt:58 -#: config/sh/sh.opt:261 +#: config/sh/sh.opt:265 msgid "Specify range of registers to make fixed" msgstr "" @@ -7573,7 +7511,6 @@ msgstr "" #: config/epiphany/epiphany.opt:52 #, fuzzy -#| msgid "Use software floating point" msgid "Use software floating point comparisons" msgstr "Käytä ohjelmistoliukulukuja" @@ -7604,7 +7541,6 @@ msgstr "virheellinen versionumero ”%s”" #: config/epiphany/epiphany.opt:80 #, fuzzy -#| msgid "Use indirect calls" msgid "Generate call insns as direct calls" msgstr "Käytä epäsuoria kutsuja" @@ -7655,23 +7591,23 @@ msgstr "" #: config/h8300/h8300.opt:23 msgid "Generate H8S code" -msgstr "" +msgstr "Tuota H8S-koodia" #: config/h8300/h8300.opt:27 msgid "Generate H8SX code" -msgstr "" +msgstr "Tuota H8SX-koodia" #: config/h8300/h8300.opt:31 msgid "Generate H8S/2600 code" -msgstr "" +msgstr "Tuota H8S/2600-koodia" #: config/h8300/h8300.opt:35 msgid "Make integers 32 bits wide" -msgstr "" +msgstr "Tee kokonaisluvista 32 bitin levyisiä" #: config/h8300/h8300.opt:42 msgid "Use registers for argument passing" -msgstr "" +msgstr "Käytä rekistereitä argumenttien välittämiseen" #: config/h8300/h8300.opt:46 msgid "Consider access to byte sized memory slow" @@ -7683,15 +7619,15 @@ msgstr "" #: config/h8300/h8300.opt:54 msgid "Generate H8/300H code" -msgstr "" +msgstr "Tuota H8/300H-koodia" #: config/h8300/h8300.opt:58 msgid "Enable the normal mode" -msgstr "" +msgstr "Ota käyttöön normaalitila" #: config/h8300/h8300.opt:62 msgid "Use H8/300 alignment rules" -msgstr "" +msgstr "Käytä H8/300-kohdistussääntöjä" #: config/h8300/h8300.opt:66 msgid "Push extended registers on stack in monitor functions" @@ -7760,7 +7696,7 @@ msgstr "Käytä 32-bittistä int-tyyppiä" #: config/pdp11/pdp11.opt:79 config/rs6000/rs6000.opt:162 msgid "Do not use hardware floating point" -msgstr "" +msgstr "Älä käytä laitteistoliukulukuja" #: config/pdp11/pdp11.opt:83 msgid "Target has split I&D" @@ -7796,11 +7732,11 @@ msgstr "" #: config/i386/cygming.opt:23 msgid "Create console application" -msgstr "" +msgstr "Luo konsolisovellus" #: config/i386/cygming.opt:27 msgid "Generate code for a DLL" -msgstr "" +msgstr "Tuota koodia DLL:lle" #: config/i386/cygming.opt:31 msgid "Ignore dllimport for functions" @@ -7816,7 +7752,7 @@ msgstr "" #: config/i386/cygming.opt:43 msgid "Create GUI application" -msgstr "" +msgstr "Luo graafinen käyttöliittymäsovellus" #: config/i386/cygming.opt:47 config/i386/interix.opt:32 msgid "Use the GNU extension to the PE format for aligned common data" @@ -7853,7 +7789,7 @@ msgstr "sizeof(long double) on 16" #: config/i386/i386.opt:82 config/i386/i386.opt:229 msgid "Use hardware fp" -msgstr "" +msgstr "Käytä laitteistoliukulukuja" #: config/i386/i386.opt:86 msgid "sizeof(long double) is 12" @@ -7861,7 +7797,6 @@ msgstr "sizeof(long double) on 12" #: config/i386/i386.opt:90 #, fuzzy -#| msgid "Use 128-bit long double" msgid "Use 80-bit long double" msgstr "Käytä 128-bittistä long double -tyyppiä" @@ -7870,7 +7805,7 @@ msgstr "Käytä 128-bittistä long double -tyyppiä" msgid "Use 64-bit long double" msgstr "Käytä 64-bittistä long double -tyyppiä" -#: config/i386/i386.opt:98 config/sh/sh.opt:205 +#: config/i386/i386.opt:98 config/sh/sh.opt:209 msgid "Reserve space for outgoing arguments in the function prologue" msgstr "" @@ -7967,19 +7902,16 @@ msgstr "" #: config/i386/i386.opt:269 #, fuzzy -#| msgid "Use 32-bit floating-point registers" msgid "Set 80387 floating-point precision to 32-bit" msgstr "Käytä 32-bittisiä liukulukurekistereitä" #: config/i386/i386.opt:273 #, fuzzy -#| msgid "Use 32-bit floating-point registers" msgid "Set 80387 floating-point precision to 64-bit" msgstr "Käytä 32-bittisiä liukulukurekistereitä" #: config/i386/i386.opt:277 #, fuzzy -#| msgid "Use 32-bit floating-point registers" msgid "Set 80387 floating-point precision to 80-bit" msgstr "Käytä 32-bittisiä liukulukurekistereitä" @@ -8029,7 +7961,6 @@ msgstr "" #: config/i386/i386.opt:325 #, fuzzy -#| msgid "alias argument not a string" msgid "Valid arguments to -mstringop-strategy=:" msgstr "aliaksen argumentti ei ole merkkijono" @@ -8101,7 +8032,6 @@ msgstr "Tuota 64-bittistä x86-64-koodia" #: config/i386/i386.opt:440 #, fuzzy -#| msgid "Generate 64bit x86-64 code" msgid "Generate 32bit x86-64 code" msgstr "Tuota 64-bittistä x86-64-koodia" @@ -8327,15 +8257,15 @@ msgstr "" #: config/pa/pa.opt:30 config/pa/pa.opt:83 config/pa/pa.opt:91 msgid "Generate PA1.0 code" -msgstr "" +msgstr "Tuota PA1.0-koodia" #: config/pa/pa.opt:34 config/pa/pa.opt:95 config/pa/pa.opt:136 msgid "Generate PA1.1 code" -msgstr "" +msgstr "Tuota PA1.0-koodia" #: config/pa/pa.opt:38 config/pa/pa.opt:99 msgid "Generate PA2.0 code (requires binutils 2.10 or later)" -msgstr "" +msgstr "Tuota PA2.0-koodia (vaatii binutils 2.10:n tai uudemman)" #: config/pa/pa.opt:42 msgid "Generate code for huge switch statements" @@ -8395,7 +8325,7 @@ msgstr "" #: config/v850/v850.opt:29 msgid "Use registers r2 and r5" -msgstr "" +msgstr "Käytä rekistereitä r2 ja r5" #: config/v850/v850.opt:33 msgid "Use 4 byte entries in switch tables" @@ -8522,11 +8452,11 @@ msgstr "" #: config/lynx.opt:27 msgid "Use shared libraries" -msgstr "" +msgstr "Käytä jaettuja kirjastoja" #: config/lynx.opt:31 msgid "Support multi-threading" -msgstr "" +msgstr "Tue monisäikeisyyttä" #: config/vxworks.opt:36 msgid "Assume the VxWorks RTP environment" @@ -8613,6 +8543,10 @@ msgstr "" 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 "" +#: config/avr/avr.opt:80 +msgid "Warn if the address space of an address is change." +msgstr "" + #: config/m32r/m32r.opt:34 msgid "Compile for the m32rx" msgstr "" @@ -8659,7 +8593,7 @@ msgstr "" #: config/m32r/m32r.opt:78 msgid "Code size: small, medium or large" -msgstr "" +msgstr "Koodin koko: small, medium tai large" #: config/m32r/m32r.opt:94 msgid "Don't call any cache flush functions" @@ -8699,7 +8633,7 @@ msgstr "" #: config/s390/s390.opt:89 msgid "ESA/390 architecture" -msgstr "" +msgstr "ESA/390-arkkitehtuuri" #: config/s390/s390.opt:93 #, fuzzy @@ -8924,11 +8858,11 @@ msgstr "" #: config/sparc/sparc.opt:30 config/sparc/sparc.opt:34 msgid "Use hardware FP" -msgstr "" +msgstr "Käytä laitteistoliukulukuja" #: config/sparc/sparc.opt:38 msgid "Do not use hardware FP" -msgstr "" +msgstr "Älä käytä laitteistoliukulukuja" #: config/sparc/sparc.opt:42 msgid "Use flat register window model" @@ -8981,19 +8915,19 @@ msgstr "säiekohtaista muistia ei tueta tälle kohteelle" #: config/sparc/sparc.opt:90 msgid "Pointers are 64-bit" -msgstr "" +msgstr "Osoittimet ovat 64-bittisiä" #: config/sparc/sparc.opt:94 msgid "Pointers are 32-bit" -msgstr "" +msgstr "Osoittimet ovat 32-bittisiä" #: config/sparc/sparc.opt:98 msgid "Use 64-bit ABI" -msgstr "" +msgstr "Käytä 64-bittistä ABIa" #: config/sparc/sparc.opt:102 msgid "Use 32-bit ABI" -msgstr "" +msgstr "Käytä 32-bittistä ABIa" #: config/sparc/sparc.opt:106 msgid "Use stack bias" @@ -9017,7 +8951,7 @@ msgstr "" #: config/sparc/sparc.opt:193 msgid "Enable debug output" -msgstr "" +msgstr "Ota käyttöön vianjäljitystuloste" #: config/sparc/sparc.opt:197 msgid "Enable strict 32-bit psABI struct return checking." @@ -9033,11 +8967,11 @@ msgstr "" #: config/rs6000/darwin.opt:38 config/rs6000/sysv4.opt:141 msgid "Generate 64-bit code" -msgstr "" +msgstr "Tuota 64-bittistä koodia" #: config/rs6000/darwin.opt:42 config/rs6000/sysv4.opt:145 msgid "Generate 32-bit code" -msgstr "" +msgstr "Tuota 32-bittistä koodia" #: config/rs6000/rs6000-tables.opt:24 msgid "Known CPUs (for use with the -mcpu= and -mtune= options):" @@ -9069,7 +9003,7 @@ msgstr "" #: config/rs6000/rs6000.opt:106 msgid "Use PowerPC-64 instruction set" -msgstr "" +msgstr "Käytä PowerPC-64 -käskykantaa" #: config/rs6000/rs6000.opt:110 msgid "Use PowerPC General Purpose group optional instructions" @@ -9221,7 +9155,7 @@ msgstr "" #: config/rs6000/rs6000.opt:320 msgid "Generate isel instructions" -msgstr "" +msgstr "Tuota isel-käskyjä" #: config/rs6000/rs6000.opt:324 msgid "Deprecated option. Use -mno-isel instead" @@ -9253,13 +9187,11 @@ msgstr "" #: config/rs6000/rs6000.opt:352 #, fuzzy -#| msgid "Use AltiVec instructions" msgid "Use the AltiVec ABI extensions" msgstr "Käytä AltiVec-käskyjä" #: config/rs6000/rs6000.opt:356 #, fuzzy -#| msgid "Don't warn about uses of Microsoft extensions" msgid "Do not use the AltiVec ABI extensions" msgstr "Älä varoita Microsoft-laajennosten käytöstä" @@ -9273,13 +9205,11 @@ msgstr "" #: config/rs6000/rs6000.opt:371 #, fuzzy -#| msgid "Using darwin64 ABI" msgid "using darwin64 ABI" msgstr "Käytetään darwin64-ABIa" #: config/rs6000/rs6000.opt:374 #, fuzzy -#| msgid "Using old darwin ABI" msgid "using old darwin ABI" msgstr "Käytetään vanhaa darwin-ABIa" @@ -9308,14 +9238,13 @@ msgid "Avoid all range limits on call instructions" msgstr "" #: config/rs6000/rs6000.opt:412 -#, fuzzy msgid "Generate Cell microcode" -msgstr "Tuota 32-bittistä i386-koodia" +msgstr "Tuota Cell-mikrokoodia" #: config/rs6000/rs6000.opt:416 #, fuzzy msgid "Warn when a Cell microcoded instruction is emitted" -msgstr "Varoita kun kaikki muodostimet ja hajottimet ovat yksityisiä" +msgstr "Varoita kun Cell-mikrokoodattu käsky lähetetään" #: config/rs6000/rs6000.opt:420 msgid "Warn about deprecated 'vector long ...' AltiVec type usage" @@ -9348,7 +9277,6 @@ msgstr "" #: config/rs6000/rs6000.opt:460 #, fuzzy -#| msgid "alias argument not a string" msgid "Valid arguments to -malign-:" msgstr "aliaksen argumentti ei ole merkkijono" @@ -9467,7 +9395,7 @@ msgstr "" #: config/alpha/alpha.opt:27 msgid "Use fp registers" -msgstr "" +msgstr "Käytä liukulukurekistereitä" #: config/alpha/alpha.opt:35 msgid "Request IEEE-conformant math library routines (OSF/1)" @@ -9483,7 +9411,7 @@ msgstr "" #: config/alpha/alpha.opt:50 msgid "Use VAX fp" -msgstr "" +msgstr "Käytä VAX-liukulukuja" #: config/alpha/alpha.opt:54 msgid "Do not use VAX fp" @@ -9566,14 +9494,12 @@ msgid "Known TILEPro CPUs (for use with the -mcpu= option):" msgstr "" #: config/lm32/lm32.opt:24 -#, fuzzy msgid "Enable multiply instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Ota käyttöön kertolaskukäskyt" #: config/lm32/lm32.opt:28 -#, fuzzy msgid "Enable divide and modulus instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Ota käyttöö divide- ja modulus-käskyt" #: config/lm32/lm32.opt:32 #, fuzzy @@ -9581,14 +9507,12 @@ msgid "Enable barrel shift instructions" msgstr "Käytä AltiVec-käskyjä" #: config/lm32/lm32.opt:36 -#, fuzzy msgid "Enable sign extend instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Ota käyttöön etumerkilliset laajennetut käskyt" #: config/lm32/lm32.opt:40 -#, fuzzy msgid "Enable user-defined instructions" -msgstr "säiekohtaista muistia ei tueta tälle kohteelle" +msgstr "Ota käyttöön käyttäjän määrittelemät käskyt" #: config/rx/rx.opt:29 msgid "Store doubles in 64 bits." @@ -9606,7 +9530,7 @@ msgstr "Tasaa funktioiden alut" #: config/rx/rx.opt:44 #, fuzzy msgid "Enable the use of RX FPU instructions. This is the default." -msgstr "Tasaa funktioiden alut" +msgstr "Ota käyttöön RX FPU-käskyjen käyttö." #: config/rx/rx.opt:50 msgid "Specify the target RX cpu type." @@ -9614,11 +9538,11 @@ msgstr "" #: config/rx/rx.opt:68 msgid "Data is stored in big-endian format." -msgstr "" +msgstr "Data tallennetaan big-endian-muodossa." #: config/rx/rx.opt:72 msgid "Data is stored in little-endian format. (Default)." -msgstr "" +msgstr "Data tallennetaan little-endian-muodossa. (Oletus)." #: config/rx/rx.opt:78 msgid "Maximum size of global and static variables which can be placed into the small data area." @@ -9671,7 +9595,6 @@ msgstr "" #: config/microblaze/microblaze.opt:40 #, fuzzy -#| msgid "Use software floating point" msgid "Use software emulation for floating point (default)" msgstr "Käytä ohjelmistoliukulukuja" @@ -9697,70 +9620,72 @@ msgid "Use the soft multiply emulation (default)" msgstr "" #: config/microblaze/microblaze.opt:72 -msgid "Use the software emulation for divides (default)" +msgid "Use reorder instructions (swap and byte reversed load/store) (default)" msgstr "" #: config/microblaze/microblaze.opt:76 -msgid "Use the hardware barrel shifter instead of emulation" +msgid "Use the software emulation for divides (default)" msgstr "" #: config/microblaze/microblaze.opt:80 +msgid "Use the hardware barrel shifter instead of emulation" +msgstr "" + +#: config/microblaze/microblaze.opt:84 #, fuzzy -#| msgid "Use AltiVec instructions" msgid "Use pattern compare instructions" msgstr "Käytä AltiVec-käskyjä" -#: config/microblaze/microblaze.opt:83 +#: config/microblaze/microblaze.opt:87 #, fuzzy, c-format msgid "%qs is deprecated; use -fstack-check" msgstr "%J%qD on tavallisesti ei-staattinen funktio" -#: config/microblaze/microblaze.opt:84 +#: config/microblaze/microblaze.opt:88 #, fuzzy -#| msgid "parser stack overflow" msgid "Check for stack overflow at runtime" msgstr "jäsentimen pinon ylivuoto" -#: config/microblaze/microblaze.opt:88 config/iq2000/iq2000.opt:65 +#: config/microblaze/microblaze.opt:92 config/iq2000/iq2000.opt:65 msgid "Use GP relative sdata/sbss sections" msgstr "" -#: config/microblaze/microblaze.opt:91 +#: config/microblaze/microblaze.opt:95 #, c-format msgid "%qs is deprecated; use -fno-zero-initialized-in-bss" msgstr "" -#: config/microblaze/microblaze.opt:92 +#: config/microblaze/microblaze.opt:96 msgid "Clear the BSS to zero and place zero initialized in BSS" msgstr "" -#: config/microblaze/microblaze.opt:96 +#: config/microblaze/microblaze.opt:100 msgid "Use multiply high instructions for high part of 32x32 multiply" msgstr "" -#: config/microblaze/microblaze.opt:100 +#: config/microblaze/microblaze.opt:104 #, fuzzy msgid "Use hardware floating point conversion instructions" msgstr "säiekohtaista muistia ei tueta tälle kohteelle" -#: config/microblaze/microblaze.opt:104 +#: config/microblaze/microblaze.opt:108 #, fuzzy msgid "Use hardware floating point square root instruction" msgstr "säiekohtaista muistia ei tueta tälle kohteelle" -#: config/microblaze/microblaze.opt:108 +#: config/microblaze/microblaze.opt:112 msgid "Description for mxl-mode-executable" msgstr "" -#: config/microblaze/microblaze.opt:112 +#: config/microblaze/microblaze.opt:116 msgid "Description for mxl-mode-xmdstub" msgstr "" -#: config/microblaze/microblaze.opt:116 +#: config/microblaze/microblaze.opt:120 msgid "Description for mxl-mode-bootstrap" msgstr "" -#: config/microblaze/microblaze.opt:120 +#: config/microblaze/microblaze.opt:124 msgid "Description for mxl-mode-novectors" msgstr "" @@ -9774,7 +9699,7 @@ msgstr "" #: config/vax/vax.opt:39 msgid "Generate code for GNU assembler (gas)" -msgstr "" +msgstr "Tuota koodia GNU-assemblerille (gas)" #: config/vax/vax.opt:43 msgid "Generate code for UNIX assembler" @@ -9822,7 +9747,7 @@ msgstr "" #: config/frv/frv.opt:65 msgid "Enable conditional moves" -msgstr "" +msgstr "Ota käyttöön ehdolliset siirrot" #: config/frv/frv.opt:69 msgid "Set the target CPU type" @@ -9846,19 +9771,19 @@ msgstr "" #: config/frv/frv.opt:138 msgid "Only use 32 FPRs" -msgstr "" +msgstr "Käytä vain 32 liukulukurekisteriä" #: config/frv/frv.opt:142 msgid "Use 64 FPRs" -msgstr "" +msgstr "Käytä 64 liukulukurekisteriä" #: config/frv/frv.opt:146 msgid "Only use 32 GPRs" -msgstr "" +msgstr "Käytä vain 32 yleiskäyttörekisteriä" #: config/frv/frv.opt:150 msgid "Use 64 GPRs" -msgstr "" +msgstr "Käytä 64 yleiskäyttörekisteriä" #: config/frv/frv.opt:154 msgid "Enable use of GPREL for read-only data in FDPIC" @@ -9878,7 +9803,7 @@ msgstr "" #: config/frv/frv.opt:178 msgid "Use media instructions" -msgstr "" +msgstr "Käytä media-käskyjä" #: config/frv/frv.opt:182 msgid "Use multiply add/subtract instructions" @@ -9887,7 +9812,7 @@ msgstr "" #: config/frv/frv.opt:186 #, fuzzy msgid "Enable optimizing &&/|| in conditional execution" -msgstr "ehtolausekkeessa ei-lvalue-taulukko" +msgstr "Ota käyttöön optimointi &&/|| ehdollisessa suorituksessa" #: config/frv/frv.opt:190 msgid "Enable nested conditional execution optimizations" @@ -9997,21 +9922,19 @@ msgstr "" #: config/c6x/c6x.opt:30 config/mep/mep.opt:82 config/mips/mips.opt:130 msgid "Use big-endian byte order" -msgstr "" +msgstr "Käytä big-endian-tavujärjestystä" #: config/c6x/c6x.opt:34 config/mep/mep.opt:86 config/mips/mips.opt:134 msgid "Use little-endian byte order" -msgstr "" +msgstr "Käytä little-endian-tavujärjestystä" #: config/c6x/c6x.opt:46 #, fuzzy -#| msgid "alias argument not a string" msgid "Valid arguments for the -msdata= option" msgstr "aliaksen argumentti ei ole merkkijono" #: config/c6x/c6x.opt:59 #, fuzzy -#| msgid "Create a shared library" msgid "Compile for the DSBT shared library ABI" msgstr "Luo jaettu kirjasto" @@ -10057,7 +9980,7 @@ msgstr "" #: config/cris/cris.opt:116 msgid "Align code and data to 32 bits" -msgstr "" +msgstr "Kohdista koodi ja data 32 bittiin" #: config/cris/cris.opt:133 msgid "Don't align items in code or data" @@ -10107,302 +10030,298 @@ msgstr "" msgid "Runtime name." msgstr "" -#: config/sh/sh.opt:44 +#: config/sh/sh.opt:48 msgid "Generate SH1 code" -msgstr "" +msgstr "Tuota SH1-koodia" -#: config/sh/sh.opt:48 +#: config/sh/sh.opt:52 msgid "Generate SH2 code" -msgstr "" +msgstr "Tuota SH2-koodia" -#: config/sh/sh.opt:52 +#: config/sh/sh.opt:56 msgid "Generate default double-precision SH2a-FPU code" msgstr "" -#: config/sh/sh.opt:56 +#: config/sh/sh.opt:60 msgid "Generate SH2a FPU-less code" msgstr "" -#: config/sh/sh.opt:60 +#: config/sh/sh.opt:64 msgid "Generate default single-precision SH2a-FPU code" msgstr "" -#: config/sh/sh.opt:64 +#: config/sh/sh.opt:68 msgid "Generate only single-precision SH2a-FPU code" msgstr "" -#: config/sh/sh.opt:68 +#: config/sh/sh.opt:72 msgid "Generate SH2e code" -msgstr "" +msgstr "Tuota SH2e-koodia" -#: config/sh/sh.opt:72 +#: config/sh/sh.opt:76 msgid "Generate SH3 code" -msgstr "" +msgstr "Tuota SH3-koodia" -#: config/sh/sh.opt:76 +#: config/sh/sh.opt:80 msgid "Generate SH3e code" -msgstr "" +msgstr "Tuota SH3e-koodia" -#: config/sh/sh.opt:80 +#: config/sh/sh.opt:84 msgid "Generate SH4 code" -msgstr "" +msgstr "Tuota SH4-koodia" -#: config/sh/sh.opt:84 +#: config/sh/sh.opt:88 msgid "Generate SH4-100 code" -msgstr "" +msgstr "Tuota SH3-100-koodia" -#: config/sh/sh.opt:88 +#: config/sh/sh.opt:92 msgid "Generate SH4-200 code" -msgstr "" +msgstr "Tuota SH4-200-koodia" -#: config/sh/sh.opt:94 -#, fuzzy +#: config/sh/sh.opt:98 msgid "Generate SH4-300 code" -msgstr "Tuota 64-bittistä x86-64-koodia" +msgstr "Tuota SH4-300-koodia" -#: config/sh/sh.opt:98 +#: config/sh/sh.opt:102 msgid "Generate SH4 FPU-less code" msgstr "" -#: config/sh/sh.opt:102 -#, fuzzy +# fuzzy: pitäisikö FPU-less kääntää? +#: config/sh/sh.opt:106 msgid "Generate SH4-100 FPU-less code" -msgstr "Tuota 64-bittistä x86-64-koodia" +msgstr "Tuota SH4-100 FPU-less-koodia" -#: config/sh/sh.opt:106 -#, fuzzy +#: config/sh/sh.opt:110 msgid "Generate SH4-200 FPU-less code" -msgstr "Tuota 64-bittistä x86-64-koodia" +msgstr "Tuota SH4-200 FPU-less-koodia" -#: config/sh/sh.opt:110 -#, fuzzy +#: config/sh/sh.opt:114 msgid "Generate SH4-300 FPU-less code" -msgstr "Tuota 64-bittistä x86-64-koodia" +msgstr "Tuota SH4-300 FPU-less-koodia" -#: config/sh/sh.opt:114 +#: config/sh/sh.opt:118 msgid "Generate code for SH4 340 series (MMU/FPU-less)" msgstr "" -#: config/sh/sh.opt:119 +#: config/sh/sh.opt:123 msgid "Generate code for SH4 400 series (MMU/FPU-less)" msgstr "" -#: config/sh/sh.opt:124 +#: config/sh/sh.opt:128 msgid "Generate code for SH4 500 series (FPU-less)." msgstr "" -#: config/sh/sh.opt:129 +#: config/sh/sh.opt:133 msgid "Generate default single-precision SH4 code" msgstr "" -#: config/sh/sh.opt:133 +#: config/sh/sh.opt:137 msgid "Generate default single-precision SH4-100 code" msgstr "" -#: config/sh/sh.opt:137 +#: config/sh/sh.opt:141 msgid "Generate default single-precision SH4-200 code" msgstr "" -#: config/sh/sh.opt:141 +#: config/sh/sh.opt:145 msgid "Generate default single-precision SH4-300 code" msgstr "" -#: config/sh/sh.opt:145 +#: config/sh/sh.opt:149 msgid "Generate only single-precision SH4 code" msgstr "" -#: config/sh/sh.opt:149 +#: config/sh/sh.opt:153 msgid "Generate only single-precision SH4-100 code" msgstr "" -#: config/sh/sh.opt:153 +#: config/sh/sh.opt:157 msgid "Generate only single-precision SH4-200 code" msgstr "" -#: config/sh/sh.opt:157 +#: config/sh/sh.opt:161 msgid "Generate only single-precision SH4-300 code" msgstr "" -#: config/sh/sh.opt:161 +#: config/sh/sh.opt:165 msgid "Generate SH4a code" -msgstr "" +msgstr "Tuota SH4a-koodia" -#: config/sh/sh.opt:165 +#: config/sh/sh.opt:169 msgid "Generate SH4a FPU-less code" msgstr "" -#: config/sh/sh.opt:169 +#: config/sh/sh.opt:173 msgid "Generate default single-precision SH4a code" msgstr "" -#: config/sh/sh.opt:173 +#: config/sh/sh.opt:177 msgid "Generate only single-precision SH4a code" msgstr "" -#: config/sh/sh.opt:177 +#: config/sh/sh.opt:181 msgid "Generate SH4al-dsp code" -msgstr "" +msgstr "Tuota SH4al-dsp-koodia" -#: config/sh/sh.opt:181 +#: config/sh/sh.opt:185 msgid "Generate 32-bit SHmedia code" msgstr "" -#: config/sh/sh.opt:185 +#: config/sh/sh.opt:189 msgid "Generate 32-bit FPU-less SHmedia code" msgstr "" -#: config/sh/sh.opt:189 +#: config/sh/sh.opt:193 msgid "Generate 64-bit SHmedia code" msgstr "" -#: config/sh/sh.opt:193 +#: config/sh/sh.opt:197 msgid "Generate 64-bit FPU-less SHmedia code" msgstr "" -#: config/sh/sh.opt:197 +#: config/sh/sh.opt:201 msgid "Generate SHcompact code" -msgstr "" +msgstr "Tuota SHcompact-koodia" -#: config/sh/sh.opt:201 +#: config/sh/sh.opt:205 msgid "Generate FPU-less SHcompact code" msgstr "" -#: config/sh/sh.opt:213 +#: config/sh/sh.opt:217 msgid "Generate code in big endian mode" -msgstr "" +msgstr "Tuota koodia big-endian-tilassa" -#: config/sh/sh.opt:217 +#: config/sh/sh.opt:221 msgid "Generate 32-bit offsets in switch tables" msgstr "" -#: config/sh/sh.opt:221 -#, fuzzy +#: config/sh/sh.opt:225 msgid "Generate bit instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Tuota bittikäskyjä" -#: config/sh/sh.opt:225 +#: config/sh/sh.opt:229 msgid "Cost to assume for a branch insn" msgstr "" -#: config/sh/sh.opt:229 +#: config/sh/sh.opt:233 msgid "Assume that zero displacement conditional branches are fast" msgstr "" -#: config/sh/sh.opt:233 +#: config/sh/sh.opt:237 msgid "Enable cbranchdi4 pattern" msgstr "" -#: config/sh/sh.opt:237 +#: config/sh/sh.opt:241 msgid "Emit cmpeqdi_t pattern even when -mcbranchdi is in effect." msgstr "" -#: config/sh/sh.opt:241 +#: config/sh/sh.opt:245 msgid "Enable SH5 cut2 workaround" msgstr "" -#: config/sh/sh.opt:245 +#: config/sh/sh.opt:249 msgid "Align doubles at 64-bit boundaries" msgstr "" -#: config/sh/sh.opt:249 +#: config/sh/sh.opt:253 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 "" -#: config/sh/sh.opt:253 +#: config/sh/sh.opt:257 msgid "Specify name for 32 bit signed division function" msgstr "" -#: config/sh/sh.opt:257 +#: config/sh/sh.opt:261 msgid "Enable the use of 64-bit floating point registers in fmov instructions. See -mdalign if 64-bit alignment is required." msgstr "" -#: config/sh/sh.opt:265 +#: config/sh/sh.opt:269 msgid "Cost to assume for gettr insn" msgstr "" -#: config/sh/sh.opt:269 config/sh/sh.opt:319 +#: config/sh/sh.opt:273 config/sh/sh.opt:323 msgid "Follow Renesas (formerly Hitachi) / SuperH calling conventions" msgstr "" -#: config/sh/sh.opt:273 +#: config/sh/sh.opt:277 msgid "Increase the IEEE compliance for floating-point comparisons" msgstr "" -#: config/sh/sh.opt:277 +#: config/sh/sh.opt:281 msgid "Enable the use of the indexed addressing mode for SHmedia32/SHcompact" msgstr "" -#: config/sh/sh.opt:281 +#: config/sh/sh.opt:285 msgid "inline code to invalidate instruction cache entries after setting up nested function trampolines" msgstr "" -#: config/sh/sh.opt:285 +#: config/sh/sh.opt:289 msgid "Assume symbols might be invalid" msgstr "" -#: config/sh/sh.opt:289 +#: config/sh/sh.opt:293 msgid "Annotate assembler instructions with estimated addresses" msgstr "" -#: config/sh/sh.opt:293 +#: config/sh/sh.opt:297 msgid "Generate code in little endian mode" msgstr "" -#: config/sh/sh.opt:297 +#: config/sh/sh.opt:301 msgid "Mark MAC register as call-clobbered" msgstr "" -#: config/sh/sh.opt:303 +#: config/sh/sh.opt:307 msgid "Make structs a multiple of 4 bytes (warning: ABI altered)" msgstr "" -#: config/sh/sh.opt:307 +#: config/sh/sh.opt:311 msgid "Emit function-calls using global offset table when generating PIC" msgstr "" -#: config/sh/sh.opt:311 +#: config/sh/sh.opt:315 msgid "Assume pt* instructions won't trap" msgstr "" -#: config/sh/sh.opt:315 +#: config/sh/sh.opt:319 msgid "Shorten address references during linking" msgstr "" -#: config/sh/sh.opt:323 +#: config/sh/sh.opt:327 msgid "Deprecated. Use -matomic= instead to select the atomic model" msgstr "" -#: config/sh/sh.opt:327 +#: config/sh/sh.opt:331 #, fuzzy msgid "Specify the model for atomic operations" msgstr "Käytä AltiVec-käskyjä" -#: config/sh/sh.opt:331 +#: config/sh/sh.opt:335 msgid "Use tas.b instruction for __atomic_test_and_set" msgstr "" -#: config/sh/sh.opt:335 +#: config/sh/sh.opt:339 msgid "Deprecated. Use -Os instead" msgstr "" -#: config/sh/sh.opt:339 +#: config/sh/sh.opt:343 msgid "Cost to assume for a multiply insn" msgstr "" -#: config/sh/sh.opt:343 +#: config/sh/sh.opt:347 msgid "Don't generate privileged-mode only code; implies -mno-inline-ic_invalidate if the inline code would not work in user mode." msgstr "" -#: config/sh/sh.opt:349 +#: config/sh/sh.opt:353 msgid "Pretend a branch-around-a-move is a conditional move." msgstr "" -#: config/sh/sh.opt:353 +#: config/sh/sh.opt:357 #, fuzzy msgid "Enable the use of the fsca instruction" msgstr "Tasaa funktioiden alut" -#: config/sh/sh.opt:357 +#: config/sh/sh.opt:361 #, fuzzy msgid "Enable the use of the fsrra instruction" msgstr "Tasaa funktioiden alut" @@ -10422,27 +10341,24 @@ msgid "Enable all optional instructions" msgstr "säiekohtaista muistia ei tueta tälle kohteelle" #: config/mep/mep.opt:31 -#, fuzzy msgid "Enable average instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Ota käyttöön average-käskyt" #: config/mep/mep.opt:35 msgid "Variables this size and smaller go in the based section. (default 0)" msgstr "" #: config/mep/mep.opt:39 -#, fuzzy msgid "Enable bit manipulation instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Ota käyttöön bittimanipulointikäskyt" #: config/mep/mep.opt:43 msgid "Section to put all const variables in (tiny, near, far) (no default)" msgstr "" #: config/mep/mep.opt:47 -#, fuzzy msgid "Enable clip instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Ota käyttöön clip-käskyt" #: config/mep/mep.opt:51 msgid "Configuration name" @@ -10471,9 +10387,8 @@ msgid "Const variables default to the near section" msgstr "ei tarpeeksi argumentteja lopetusalkion mahduttamiseksi" #: config/mep/mep.opt:78 -#, fuzzy msgid "Enable 32-bit divide instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Ota käyttöön 32-bittiset divide-käskyt" #: config/mep/mep.opt:93 msgid "__io vars are volatile by default" @@ -10493,14 +10408,12 @@ msgid "All variables default to the near section" msgstr "" #: config/mep/mep.opt:112 -#, fuzzy msgid "Enable min/max instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Ota käyttöön min/max-käskyt" #: config/mep/mep.opt:116 -#, fuzzy msgid "Enable 32-bit multiply instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Ota käyttöön 32-bittiset kertolaskukäskyt" #: config/mep/mep.opt:120 #, fuzzy @@ -10508,18 +10421,16 @@ msgid "Disable all optional instructions" msgstr "Käytä AltiVec-käskyjä" #: config/mep/mep.opt:127 -#, fuzzy msgid "Allow gcc to use the repeat/erepeat instructions" -msgstr "Tasaa funktioiden alut" +msgstr "Salli gcc:n käyttää repeat/erepeat-käskyjä" #: config/mep/mep.opt:131 msgid "All variables default to the tiny section" msgstr "" #: config/mep/mep.opt:135 -#, fuzzy msgid "Enable saturation instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Ota käyttöön saturation-käskyt" #: config/mep/mep.opt:139 msgid "Use sdram version of runtime" @@ -10604,9 +10515,8 @@ msgid "Use MIPS-DSP instructions" msgstr "" #: config/mips/mips.opt:120 -#, fuzzy msgid "Use MIPS-DSP REV 2 instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Käytä MIPS-DSP REV 2 -käskyjä" #: config/mips/mips.opt:142 msgid "Use NewABI-style %reloc() assembly operators" @@ -10646,11 +10556,11 @@ msgstr "" #: config/mips/mips.opt:178 msgid "Work around an early 4300 hardware bug" -msgstr "" +msgstr "Kierrä vanha 4300-laitteistovika" #: config/mips/mips.opt:182 msgid "FP exceptions are enabled" -msgstr "" +msgstr "Liukulukupoikkeukset otettu käyttöön" #: config/mips/mips.opt:186 msgid "Use 32-bit floating-point registers" @@ -10670,11 +10580,11 @@ msgstr "" #: config/mips/mips.opt:202 msgid "Use 32-bit general registers" -msgstr "" +msgstr "Käytä 32-bittisiä yleisrekistereitä" #: config/mips/mips.opt:206 msgid "Use 64-bit general registers" -msgstr "" +msgstr "Käytä 64-bittisiä yleisrekistereitä" #: config/mips/mips.opt:210 msgid "Use GP-relative addressing to access small data" @@ -10686,7 +10596,7 @@ msgstr "" #: config/mips/mips.opt:218 msgid "Allow the use of hardware floating-point ABI and instructions" -msgstr "" +msgstr "Salli laitteistöliukuluku-ABIn ja -käskyjen käyttö" #: config/mips/mips.opt:222 msgid "Generate code that can be safely linked with MIPS16 code." @@ -10697,18 +10607,16 @@ msgid "-mipsN\tGenerate code for ISA level N" msgstr "" #: config/mips/mips.opt:230 -#, fuzzy msgid "Generate MIPS16 code" -msgstr "Tuota 32-bittistä i386-koodia" +msgstr "Tuota MIPS16-koodia" #: config/mips/mips.opt:234 msgid "Use MIPS-3D instructions" -msgstr "" +msgstr "Käytä MIPS-3D-käskyjä" #: config/mips/mips.opt:238 -#, fuzzy msgid "Use ll, sc and sync instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Käytä ll-, sc- ja sync-käskyjä" #: config/mips/mips.opt:242 msgid "Use -G for object-local data" @@ -10735,35 +10643,32 @@ msgid "Don't optimize block moves" msgstr "" #: config/mips/mips.opt:266 -#, fuzzy msgid "Allow the use of MT instructions" -msgstr "Tasaa funktioiden alut" +msgstr "Salli MT-käskyjen käyttö" #: config/mips/mips.opt:270 msgid "Prevent the use of all floating-point operations" msgstr "" #: config/mips/mips.opt:274 -#, fuzzy msgid "Use MCU instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Käytä MCU-käskyjä" #: config/mips/mips.opt:278 msgid "Do not use a cache-flushing function before calling stack trampolines" msgstr "" #: config/mips/mips.opt:282 -#, fuzzy msgid "Do not use MDMX instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Älä käytä MDMX-käskyjä" #: config/mips/mips.opt:286 msgid "Generate normal-mode code" -msgstr "" +msgstr "Tuota normaalitilan koodia" #: config/mips/mips.opt:290 msgid "Do not use MIPS-3D instructions" -msgstr "" +msgstr "Älä käytä MIPS-3D-käskyjä" #: config/mips/mips.opt:294 msgid "Use paired-single floating-point instructions" @@ -10787,16 +10692,16 @@ msgstr "" #: config/mips/mips.opt:323 msgid "Restrict the use of hardware floating-point instructions to 32-bit operations" -msgstr "" +msgstr "Rajoita laitteistöliukulukukäskyjen käyttö 32-bittisiin operaatioihin" #: config/mips/mips.opt:327 #, fuzzy msgid "Use SmartMIPS instructions" -msgstr "Käytä AltiVec-käskyjä" +msgstr "Käytä SmartMIPS-käskyjä" #: config/mips/mips.opt:331 msgid "Prevent the use of all hardware floating-point instructions" -msgstr "" +msgstr "Estä kaikkien laitteistoliukulukukäskyjen käyttö" #: config/mips/mips.opt:335 msgid "Optimize lui/addiu address loads" @@ -10989,7 +10894,6 @@ msgstr "" #: common.opt:441 #, fuzzy -#| msgid "Set optimization level to <number>" msgid "-O<number>\tSet optimization level to <number>" msgstr "Aseta optimointitasoksi <luku>" @@ -11014,1567 +10918,1564 @@ msgid "Warn about returning structures, unions or arrays" msgstr "Varoita tietueiden, unionien ja taulukoiden palauttamisesta" #: common.opt:510 -msgid "Warn if an array is accessed out of bounds" +msgid "Warn if a loop with constant number of iterations triggers undefined behavior" msgstr "" #: common.opt:514 -msgid "Warn about inappropriate attribute usage" +msgid "Warn if an array is accessed out of bounds" msgstr "" #: common.opt:518 -msgid "Warn about pointer casts which increase alignment" +msgid "Warn about inappropriate attribute usage" msgstr "" #: common.opt:522 +msgid "Warn about pointer casts which increase alignment" +msgstr "" + +#: common.opt:526 #, fuzzy -#| msgid "Warn when a function parameter is unused" msgid "Warn when a #warning directive is encountered" msgstr "Varoita käyttämättömistä funktion parametreista" -#: common.opt:526 +#: common.opt:530 msgid "Warn about uses of __attribute__((deprecated)) declarations" -msgstr "" +msgstr "Varoita __attribute__((deprecated)) -esittelyjen käytöstä" -#: common.opt:530 +#: common.opt:534 msgid "Warn when an optimization pass is disabled" msgstr "" -#: common.opt:534 +#: common.opt:538 msgid "Treat all warnings as errors" msgstr "Käsittele kaikki varoitukset virheinä" -#: common.opt:538 +#: common.opt:542 msgid "Treat specified warning as error" msgstr "Käsittele annettu varoitus virheenä" -#: common.opt:546 +#: common.opt:550 msgid "Exit on the first error occurred" msgstr "" -#: common.opt:550 +#: common.opt:554 msgid "-Wframe-larger-than=<number>\tWarn if a function's stack frame requires more than <number> bytes" msgstr "" -#: common.opt:554 +#: common.opt:558 msgid "Warn when attempting to free a non-heap object" msgstr "" -#: common.opt:558 +#: common.opt:562 msgid "Warn when an inlined function cannot be inlined" msgstr "" -#: common.opt:562 +#: common.opt:566 msgid "Warn when an atomic memory model parameter is known to be outside the valid range." msgstr "" -#: common.opt:569 +#: common.opt:573 msgid "-Wlarger-than=<number>\tWarn if an object is larger than <number> bytes" msgstr "" -#: common.opt:573 +#: common.opt:577 msgid "Warn if the loop cannot be optimized due to nontrivial assumptions." msgstr "" -#: common.opt:580 +#: common.opt:584 msgid "Warn about overflow in arithmetic expressions" msgstr "Varoita ylivuodosta aritmeettisissa lausekkeissa" -#: common.opt:584 +#: common.opt:588 msgid "Warn when the packed attribute has no effect on struct layout" msgstr "" -#: common.opt:588 +#: common.opt:592 msgid "Warn when padding is required to align structure members" msgstr "" -#: common.opt:592 +#: common.opt:596 msgid "Issue warnings needed for strict compliance to the standard" msgstr "" -#: common.opt:596 +#: common.opt:600 msgid "Warn when one local variable shadows another" msgstr "" -#: common.opt:600 +#: common.opt:604 msgid "Warn when not issuing stack smashing protection for some reason" msgstr "" -#: common.opt:604 +#: common.opt:608 msgid "Warn if stack usage might be larger than specified amount" msgstr "" -#: common.opt:608 common.opt:612 +#: common.opt:612 common.opt:616 msgid "Warn about code which might break strict aliasing rules" msgstr "" -#: common.opt:616 common.opt:620 +#: common.opt:620 common.opt:624 msgid "Warn about optimizations that assume that signed overflow is undefined" msgstr "" -#: common.opt:624 +#: common.opt:628 #, fuzzy msgid "Warn about functions which might be candidates for __attribute__((const))" msgstr "funktio on ehkä mahdollinen ehdokas %qs-muotoiluattribuutille" -#: common.opt:628 +#: common.opt:632 #, fuzzy msgid "Warn about functions which might be candidates for __attribute__((pure))" msgstr "funktio on ehkä mahdollinen ehdokas %qs-muotoiluattribuutille" -#: common.opt:632 +#: common.opt:636 msgid "Warn about functions which might be candidates for __attribute__((noreturn))" msgstr "" -#: common.opt:636 +#: common.opt:640 msgid "Do not suppress warnings from system headers" msgstr "Älä vaienna järjestelmän otsakkeista aiheutuvia varoituksia" -#: common.opt:640 +#: common.opt:644 #, fuzzy -#| msgid "Warn when a variable is unused" msgid "Warn whenever a trampoline is generated" msgstr "Varoita käyttämättömistä muuttujista" -#: common.opt:644 +#: common.opt:648 msgid "Warn if a comparison is always true or always false due to the limited range of the data type" msgstr "Varoita vertailusta, joka on aina tosi tai aina epätosi johtuen tietotyypin rajallisesta arvoalueesta" -#: common.opt:648 +#: common.opt:652 msgid "Warn about uninitialized automatic variables" msgstr "" -#: common.opt:652 +#: common.opt:656 #, fuzzy -#| msgid "Warn about variables which are initialized to themselves" msgid "Warn about maybe uninitialized automatic variables" msgstr "Varoita muuttujista, jotka alustetaan omalla arvollaan" -#: common.opt:660 +#: common.opt:664 msgid "Enable all -Wunused- warnings" -msgstr "" +msgstr "Ota käyttöön kaikki -Wunused-varoitukset" -#: common.opt:664 +#: common.opt:668 #, fuzzy -#| msgid "Warn when a function parameter is unused" msgid "Warn when a function parameter is only set, otherwise unused" msgstr "Varoita käyttämättömistä funktion parametreista" -#: common.opt:668 +#: common.opt:672 #, fuzzy -#| msgid "Warn when a variable is unused" msgid "Warn when a variable is only set, otherwise unused" msgstr "Varoita käyttämättömistä muuttujista" -#: common.opt:672 +#: common.opt:676 msgid "Warn when a function is unused" msgstr "Varoita käyttämättömistä funktioista" -#: common.opt:676 +#: common.opt:680 msgid "Warn when a label is unused" msgstr "Varoita kun nimiö on käyttämätön" -#: common.opt:680 +#: common.opt:684 msgid "Warn when a function parameter is unused" msgstr "Varoita käyttämättömistä funktion parametreista" -#: common.opt:684 +#: common.opt:688 msgid "Warn when an expression value is unused" msgstr "" -#: common.opt:688 +#: common.opt:692 msgid "Warn when a variable is unused" msgstr "Varoita käyttämättömistä muuttujista" -#: common.opt:692 +#: common.opt:696 msgid "Warn in case profiles in -fprofile-use do not match" msgstr "" -#: common.opt:696 +#: common.opt:700 msgid "Warn when a vector operation is compiled outside the SIMD" msgstr "" -#: common.opt:712 +#: common.opt:716 msgid "-aux-info <file>\tEmit declaration information into <file>" msgstr "" -#: common.opt:731 +#: common.opt:735 msgid "-d<letters>\tEnable dumps from specific passes of the compiler" msgstr "" -#: common.opt:735 +#: common.opt:739 msgid "-dumpbase <file>\tSet the file basename to be used for dumps" msgstr "" -#: common.opt:739 +#: common.opt:743 msgid "-dumpdir <dir>\tSet the directory name to be used for dumps" msgstr "" -#: common.opt:798 +#: common.opt:802 msgid "Aggressively optimize loops using language constraints" msgstr "" -#: common.opt:802 +#: common.opt:806 msgid "Align the start of functions" msgstr "Tasaa funktioiden alut" -#: common.opt:809 +#: common.opt:813 msgid "Align labels which are only reached by jumping" msgstr "" -#: common.opt:816 +#: common.opt:820 msgid "Align all labels" msgstr "" -#: common.opt:823 +#: common.opt:827 msgid "Align the start of loops" msgstr "Tasaa silmukoiden alut" -#: common.opt:846 +#: common.opt:850 msgid "Enable AddressSanitizer, a memory error detector" msgstr "" -#: common.opt:850 +#: common.opt:854 msgid "Enable ThreadSanitizer, a data race detector" msgstr "" -#: common.opt:854 +#: common.opt:858 msgid "Generate unwind tables that are exact at each instruction boundary" msgstr "" -#: common.opt:858 +#: common.opt:862 #, fuzzy msgid "Generate auto-inc/dec instructions" msgstr "Käytä AltiVec-käskyjä" -#: common.opt:866 +#: common.opt:870 msgid "Generate code to check bounds before indexing arrays" msgstr "" -#: common.opt:870 +#: common.opt:874 msgid "Replace add, compare, branch with branch on count register" msgstr "" -#: common.opt:874 +#: common.opt:878 msgid "Use profiling information for branch probabilities" msgstr "" -#: common.opt:878 +#: common.opt:882 msgid "Perform branch target load optimization before prologue / epilogue threading" msgstr "" -#: common.opt:882 +#: common.opt:886 msgid "Perform branch target load optimization after prologue / epilogue threading" msgstr "" -#: common.opt:886 +#: common.opt:890 msgid "Restrict target load migration not to re-use registers in any basic block" msgstr "" -#: common.opt:890 +#: common.opt:894 msgid "-fcall-saved-<register>\tMark <register> as being preserved across functions" msgstr "" -#: common.opt:894 +#: common.opt:898 msgid "-fcall-used-<register>\tMark <register> as being corrupted by function calls" msgstr "" -#: common.opt:901 +#: common.opt:905 msgid "Save registers around function calls" msgstr "" -#: common.opt:905 +#: common.opt:909 msgid "Compare the results of several data dependence analyzers." msgstr "" -#: common.opt:909 +#: common.opt:913 msgid "Looks for opportunities to reduce stack adjustments and stack references." msgstr "" -#: common.opt:913 +#: common.opt:917 msgid "Do not put uninitialized globals in the common section" msgstr "" -#: common.opt:921 +#: common.opt:925 msgid "-fcompare-debug[=<opts>]\tCompile with and without e.g. -gtoggle, and compare the final-insns dump" msgstr "" -#: common.opt:925 +#: common.opt:929 msgid "Run only the second compilation of -fcompare-debug" msgstr "" -#: common.opt:929 +#: common.opt:933 msgid "Perform comparison elimination after register allocation has finished" msgstr "" -#: common.opt:933 +#: common.opt:937 msgid "Do not perform optimizations increasing noticeably stack usage" msgstr "" -#: common.opt:937 +#: common.opt:941 msgid "Perform a register copy-propagation optimization pass" msgstr "" -#: common.opt:941 +#: common.opt:945 msgid "Perform cross-jumping optimization" msgstr "" -#: common.opt:945 +#: common.opt:949 msgid "When running CSE, follow jumps to their targets" msgstr "" -#: common.opt:953 +#: common.opt:957 msgid "Omit range reduction step when performing complex division" msgstr "" -#: common.opt:957 +#: common.opt:961 msgid "Complex multiplication and division follow Fortran rules" msgstr "" -#: common.opt:961 +#: common.opt:965 msgid "Place data items into their own section" msgstr "" -#: common.opt:965 +#: common.opt:969 msgid "List all available debugging counters with their limits and counts." msgstr "" -#: common.opt:969 +#: common.opt:973 msgid "-fdbg-cnt=<counter>:<limit>[,<counter>:<limit>,...]\tSet the debug counter limit. " msgstr "" -#: common.opt:973 +#: common.opt:977 msgid "Map one directory name to another in debug information" msgstr "" -#: common.opt:977 +#: common.opt:981 msgid "Output .debug_types section when using DWARF v4 debuginfo." msgstr "" -#: common.opt:983 +#: common.opt:987 msgid "Defer popping functions args from stack until later" msgstr "" -#: common.opt:987 +#: common.opt:991 msgid "Attempt to fill delay slots of branch instructions" msgstr "" -#: common.opt:991 +#: common.opt:995 msgid "Delete dead instructions that may throw exceptions" msgstr "" -#: common.opt:995 +#: common.opt:999 msgid "Delete useless null pointer checks" msgstr "" -#: common.opt:999 +#: common.opt:1003 msgid "Try to convert virtual calls to direct ones." msgstr "" -#: common.opt:1003 +#: common.opt:1007 msgid "-fdiagnostics-show-location=[once|every-line]\tHow often to emit source location at the beginning of line-wrapped diagnostics" msgstr "" -#: common.opt:1020 +#: common.opt:1024 msgid "Show the source line with a caret indicating the column" msgstr "" -#: common.opt:1024 +#: common.opt:1028 msgid "Amend appropriate diagnostic messages with the command line option that controls them" msgstr "" -#: common.opt:1028 +#: common.opt:1032 msgid "-fdisable-[tree|rtl|ipa]-<pass>=range1+range2 disables an optimization pass" msgstr "" -#: common.opt:1032 +#: common.opt:1036 msgid "-fenable-[tree|rtl|ipa]-<pass>=range1+range2 enables an optimization pass" msgstr "" -#: common.opt:1036 +#: common.opt:1040 msgid "-fdump-<type>\tDump various compiler internals to a file" msgstr "" -#: common.opt:1043 +#: common.opt:1047 msgid "-fdump-final-insns=filename\tDump to filename the insns at the end of translation" msgstr "" -#: common.opt:1047 +#: common.opt:1051 msgid "-fdump-go-spec=filename\tWrite all declarations to file as Go code" msgstr "" -#: common.opt:1051 +#: common.opt:1055 msgid "Suppress output of addresses in debugging dumps" msgstr "" -#: common.opt:1055 +#: common.opt:1059 #, fuzzy -#| msgid "options passed: " msgid "Dump optimization passes" msgstr "annetut valitsimet: " -#: common.opt:1059 +#: common.opt:1063 msgid "Suppress output of instruction numbers, line number notes and addresses in debugging dumps" msgstr "" -#: common.opt:1063 +#: common.opt:1067 msgid "Suppress output of previous and next insn numbers in debugging dumps" msgstr "" -#: common.opt:1067 +#: common.opt:1071 msgid "Enable CFI tables via GAS assembler directives." -msgstr "" +msgstr "Ota käyttöön CFI-taulut GAS-assembler-direktiivien kautta" -#: common.opt:1071 +#: common.opt:1075 msgid "Perform early inlining" msgstr "" -#: common.opt:1075 +#: common.opt:1079 msgid "Perform DWARF2 duplicate elimination" msgstr "" -#: common.opt:1079 +#: common.opt:1083 msgid "Perform interprocedural reduction of aggregates" msgstr "" -#: common.opt:1083 common.opt:1087 +#: common.opt:1087 common.opt:1091 msgid "Perform unused type elimination in debug info" msgstr "" -#: common.opt:1091 +#: common.opt:1095 msgid "Do not suppress C++ class debug information." msgstr "" -#: common.opt:1095 +#: common.opt:1099 msgid "Enable exception handling" msgstr "Käytä poikkeustenkäsittelyä" -#: common.opt:1099 +#: common.opt:1103 msgid "Perform a number of minor, expensive optimizations" msgstr "" -#: common.opt:1103 +#: common.opt:1107 msgid "-fexcess-precision=[fast|standard]\tSpecify handling of excess floating-point precision" msgstr "" -#: common.opt:1106 +#: common.opt:1110 #, fuzzy, c-format msgid "unknown excess precision style %qs" msgstr "tuntematon konetila %qs" -#: common.opt:1119 +#: common.opt:1123 msgid "Output lto objects containing both the intermediate language and binary output." msgstr "" -#: common.opt:1123 +#: common.opt:1127 msgid "Assume no NaNs or infinities are generated" msgstr "" -#: common.opt:1127 +#: common.opt:1131 msgid "-ffixed-<register>\tMark <register> as being unavailable to the compiler" msgstr "" -#: common.opt:1131 +#: common.opt:1135 msgid "Don't allocate floats and doubles in extended-precision registers" msgstr "" -#: common.opt:1139 +#: common.opt:1143 msgid "Perform a forward propagation pass on RTL" msgstr "" -#: common.opt:1143 +#: common.opt:1147 msgid "-ffp-contract=[off|on|fast] Perform floating-point expression contraction." msgstr "" -#: common.opt:1146 +#: common.opt:1150 #, fuzzy, c-format msgid "unknown floating point contraction style %qs" msgstr "tuntematon konetila %qs" -#: common.opt:1163 +#: common.opt:1167 msgid "Allow function addresses to be held in registers" msgstr "" -#: common.opt:1167 +#: common.opt:1171 msgid "Place each function into its own section" msgstr "" -#: common.opt:1171 +#: common.opt:1175 msgid "Perform global common subexpression elimination" msgstr "" -#: common.opt:1175 +#: common.opt:1179 msgid "Perform enhanced load motion during global common subexpression elimination" msgstr "" -#: common.opt:1179 +#: common.opt:1183 msgid "Perform store motion after global common subexpression elimination" msgstr "" -#: common.opt:1183 +#: common.opt:1187 msgid "Perform redundant load after store elimination in global common subexpression" msgstr "" -#: common.opt:1188 +#: common.opt:1192 msgid "Perform global common subexpression elimination after register allocation" msgstr "" -#: common.opt:1194 +#: common.opt:1198 msgid "Enable in and out of Graphite representation" msgstr "" -#: common.opt:1198 +#: common.opt:1202 msgid "Enable Graphite Identity transformation" msgstr "" -#: common.opt:1202 +#: common.opt:1206 #, fuzzy msgid "Enable hoisting adjacent loads to encourage generating conditional move" msgstr "ehtolausekkeessa ei-lvalue-taulukko" -#: common.opt:1207 +#: common.opt:1211 msgid "Mark all loops as parallel" msgstr "" -#: common.opt:1211 +#: common.opt:1215 msgid "Enable Loop Strip Mining transformation" msgstr "" -#: common.opt:1215 +#: common.opt:1219 msgid "Enable Loop Interchange transformation" msgstr "" -#: common.opt:1219 +#: common.opt:1223 msgid "Enable Loop Blocking transformation" msgstr "" -#: common.opt:1223 +#: common.opt:1227 msgid "Enable support for GNU transactional memory" msgstr "" -#: common.opt:1231 +#: common.opt:1235 msgid "Enable the ISL based loop nest optimizer" msgstr "" -#: common.opt:1235 +#: common.opt:1239 msgid "Force bitfield accesses to match their type width" msgstr "" -#: common.opt:1239 +#: common.opt:1243 msgid "Enable guessing of branch probabilities" msgstr "" -#: common.opt:1247 +#: common.opt:1251 msgid "Process #ident directives" msgstr "" -#: common.opt:1251 +#: common.opt:1255 msgid "Perform conversion of conditional jumps to branchless equivalents" msgstr "" -#: common.opt:1255 +#: common.opt:1259 msgid "Perform conversion of conditional jumps to conditional execution" msgstr "" -#: common.opt:1259 +#: common.opt:1263 msgid "-fstack-reuse=[all|named_vars|none] Set stack reuse level for local variables." msgstr "" -#: common.opt:1262 +#: common.opt:1266 #, fuzzy, c-format msgid "unknown Stack Reuse Level %qs" msgstr "tuntematon konetila %qs" -#: common.opt:1275 +#: common.opt:1279 msgid "Convert conditional jumps in innermost loops to branchless equivalents" msgstr "" -#: common.opt:1279 +#: common.opt:1283 msgid "Also if-convert conditional jumps containing memory writes" msgstr "" -#: common.opt:1287 +#: common.opt:1291 msgid "Do not generate .size directives" msgstr "" -#: common.opt:1291 +#: common.opt:1295 msgid "Perform indirect inlining" msgstr "" -#: common.opt:1297 +#: common.opt:1301 msgid "Enable inlining of function declared \"inline\", disabling disables all inlining" msgstr "" -#: common.opt:1301 +#: common.opt:1305 #, fuzzy msgid "Integrate functions into their callers when code size is known not to grow" msgstr "jäsenfunktio-osoitinta käytetty laskutoimituksessa" -#: common.opt:1305 +#: common.opt:1309 #, fuzzy msgid "Integrate functions not declared \"inline\" into their callers when profitable" msgstr "jäsenfunktio-osoitinta käytetty laskutoimituksessa" -#: common.opt:1309 +#: common.opt:1313 #, fuzzy msgid "Integrate functions only required by their single caller" msgstr "jäsenfunktio-osoitinta käytetty laskutoimituksessa" -#: common.opt:1316 +#: common.opt:1320 msgid "-finline-limit=<number>\tLimit the size of inlined functions to <number>" msgstr "" -#: common.opt:1320 +#: common.opt:1324 msgid "Inline __atomic operations when a lock free instruction sequence is available." msgstr "" -#: common.opt:1324 +#: common.opt:1328 msgid "Instrument function entry and exit with profiling calls" msgstr "" -#: common.opt:1328 +#: common.opt:1332 msgid "-finstrument-functions-exclude-function-list=name,... Do not instrument listed functions" msgstr "" -#: common.opt:1332 +#: common.opt:1336 msgid "-finstrument-functions-exclude-file-list=filename,... Do not instrument functions listed in files" msgstr "" -#: common.opt:1336 +#: common.opt:1340 msgid "Perform Interprocedural constant propagation" msgstr "" -#: common.opt:1340 +#: common.opt:1344 msgid "Perform cloning to make Interprocedural constant propagation stronger" msgstr "" -#: common.opt:1344 +#: common.opt:1348 msgid "Perform interprocedural profile propagation" msgstr "" -#: common.opt:1348 +#: common.opt:1352 msgid "Perform interprocedural points-to analysis" msgstr "" -#: common.opt:1352 +#: common.opt:1356 msgid "Discover pure and const functions" msgstr "" -#: common.opt:1356 +#: common.opt:1360 msgid "Discover readonly and non addressable static variables" msgstr "" -#: common.opt:1368 +#: common.opt:1372 msgid "-fira-algorithm=[CB|priority] Set the used IRA algorithm" msgstr "" -#: common.opt:1371 +#: common.opt:1375 #, c-format msgid "unknown IRA algorithm %qs" msgstr "" -#: common.opt:1381 +#: common.opt:1385 msgid "-fira-region=[one|all|mixed] Set regions for IRA" msgstr "" -#: common.opt:1384 +#: common.opt:1388 #, c-format msgid "unknown IRA region %qs" msgstr "" -#: common.opt:1397 common.opt:1402 +#: common.opt:1401 common.opt:1406 msgid "Use IRA based register pressure calculation" msgstr "" -#: common.opt:1407 +#: common.opt:1411 msgid "Share slots for saving different hard registers." msgstr "" -#: common.opt:1411 +#: common.opt:1415 msgid "Share stack slots for spilled pseudo-registers." msgstr "" -#: common.opt:1415 +#: common.opt:1419 msgid "-fira-verbose=<number>\tControl IRA's level of diagnostic messages." msgstr "" -#: common.opt:1419 +#: common.opt:1423 msgid "Optimize induction variables on trees" msgstr "" -#: common.opt:1423 +#: common.opt:1427 msgid "Use jump tables for sufficiently large switch statements" msgstr "" -#: common.opt:1427 +#: common.opt:1431 msgid "Generate code for functions even if they are fully inlined" msgstr "" -#: common.opt:1431 +#: common.opt:1435 msgid "Emit static const variables even if they are not used" msgstr "" -#: common.opt:1435 +#: common.opt:1439 msgid "Give external symbols a leading underscore" msgstr "" -#: common.opt:1443 +#: common.opt:1447 msgid "Enable link-time optimization." msgstr "" -#: common.opt:1447 +#: common.opt:1451 msgid "Link-time optimization with number of parallel jobs or jobserver." msgstr "" -#: common.opt:1451 +#: common.opt:1455 msgid "Partition symbols and vars at linktime based on object files they originate from" msgstr "" -#: common.opt:1455 +#: common.opt:1459 msgid "Partition functions and vars at linktime into approximately same sized buckets" msgstr "" -#: common.opt:1459 +#: common.opt:1463 msgid "Put every symbol into separate partition" msgstr "" -#: common.opt:1463 +#: common.opt:1467 #, fuzzy msgid "Disable partioning and streaming" msgstr "Käytä AltiVec-käskyjä" -#: common.opt:1468 +#: common.opt:1472 msgid "-flto-compression-level=<number>\tUse zlib compression level <number> for IL" msgstr "" -#: common.opt:1472 +#: common.opt:1476 msgid "Report various link-time optimization statistics" msgstr "" -#: common.opt:1476 +#: common.opt:1480 msgid "Set errno after built-in math functions" msgstr "" -#: common.opt:1480 +#: common.opt:1484 msgid "-fmax-errors=<number>\tMaximum number of errors to report" msgstr "" -#: common.opt:1484 +#: common.opt:1488 msgid "Report on permanent memory allocation" msgstr "" -#: common.opt:1488 +#: common.opt:1492 msgid "Report on permanent memory allocation in WPA only" msgstr "" -#: common.opt:1495 +#: common.opt:1499 msgid "Attempt to merge identical constants and constant variables" msgstr "" -#: common.opt:1499 +#: common.opt:1503 msgid "Attempt to merge identical constants across compilation units" msgstr "" -#: common.opt:1503 +#: common.opt:1507 msgid "Attempt to merge identical debug strings across compilation units" msgstr "" -#: common.opt:1507 +#: common.opt:1511 msgid "-fmessage-length=<number>\tLimit diagnostics to <number> characters per line. 0 suppresses line-wrapping" msgstr "" -#: common.opt:1511 +#: common.opt:1515 msgid "Perform SMS based modulo scheduling before the first scheduling pass" msgstr "" -#: common.opt:1515 +#: common.opt:1519 msgid "Perform SMS based modulo scheduling with register moves allowed" msgstr "" -#: common.opt:1519 +#: common.opt:1523 msgid "Move loop invariant computations out of loops" msgstr "" -#: common.opt:1523 +#: common.opt:1527 msgid "Use the RTL dead code elimination pass" msgstr "" -#: common.opt:1527 +#: common.opt:1531 msgid "Use the RTL dead store elimination pass" msgstr "" -#: common.opt:1531 +#: common.opt:1535 msgid "Enable/Disable the traditional scheduling in loops that already passed modulo scheduling" msgstr "" -#: common.opt:1535 +#: common.opt:1539 msgid "Support synchronous non-call exceptions" msgstr "" -#: common.opt:1539 +#: common.opt:1543 msgid "When possible do not generate stack frames" msgstr "" -#: common.opt:1543 +#: common.opt:1547 #, fuzzy msgid "Enable all optimization info dumps on stderr" msgstr "säiekohtaista muistia ei tueta tälle kohteelle" -#: common.opt:1547 +#: common.opt:1551 msgid "-fopt-info[-<type>=filename]\tDump compiler optimization details" msgstr "" -#: common.opt:1551 +#: common.opt:1555 msgid "Do the full register move optimization pass" msgstr "" -#: common.opt:1555 +#: common.opt:1559 msgid "Optimize sibling and tail recursive calls" msgstr "" -#: common.opt:1559 +#: common.opt:1563 msgid "Perform partial inlining" msgstr "" -#: common.opt:1563 common.opt:1567 +#: common.opt:1567 common.opt:1571 msgid "Report on memory allocation before interprocedural optimization" msgstr "" -#: common.opt:1571 +#: common.opt:1575 msgid "Pack structure members together without holes" msgstr "" -#: common.opt:1575 +#: common.opt:1579 msgid "-fpack-struct=<number>\tSet initial maximum structure member alignment" msgstr "" -#: common.opt:1579 +#: common.opt:1583 msgid "Return small aggregates in memory, not registers" msgstr "" -#: common.opt:1583 +#: common.opt:1587 msgid "Perform loop peeling" msgstr "" -#: common.opt:1587 +#: common.opt:1591 msgid "Enable machine specific peephole optimizations" msgstr "" -#: common.opt:1591 +#: common.opt:1595 msgid "Enable an RTL peephole pass before sched2" msgstr "" -#: common.opt:1595 +#: common.opt:1599 msgid "Generate position-independent code if possible (large mode)" msgstr "" -#: common.opt:1599 +#: common.opt:1603 msgid "Generate position-independent code for executables if possible (large mode)" msgstr "" -#: common.opt:1603 +#: common.opt:1607 msgid "Generate position-independent code if possible (small mode)" msgstr "" -#: common.opt:1607 +#: common.opt:1611 msgid "Generate position-independent code for executables if possible (small mode)" msgstr "" -#: common.opt:1611 +#: common.opt:1615 msgid "Specify a plugin to load" msgstr "" -#: common.opt:1615 +#: common.opt:1619 msgid "-fplugin-arg-<name>-<key>[=<value>]\tSpecify argument <key>=<value> for plugin <name>" msgstr "" -#: common.opt:1619 +#: common.opt:1623 msgid "Run predictive commoning optimization." msgstr "" -#: common.opt:1623 +#: common.opt:1627 msgid "Generate prefetch instructions, if available, for arrays in loops" msgstr "" -#: common.opt:1627 +#: common.opt:1631 msgid "Enable basic program profiling code" msgstr "" -#: common.opt:1631 +#: common.opt:1635 msgid "Insert arc-based program profiling code" msgstr "" -#: common.opt:1635 +#: common.opt:1639 msgid "Set the top-level directory for storing the profile data." msgstr "" -#: common.opt:1640 +#: common.opt:1644 msgid "Enable correction of flow inconsistent profile data input" msgstr "" -#: common.opt:1644 +#: common.opt:1648 msgid "Enable common options for generating profile info for profile feedback directed optimizations" msgstr "" -#: common.opt:1648 +#: common.opt:1652 msgid "Enable common options for generating profile info for profile feedback directed optimizations, and set -fprofile-dir=" msgstr "" -#: common.opt:1652 +#: common.opt:1656 msgid "Enable common options for performing profile feedback directed optimizations" msgstr "" -#: common.opt:1656 +#: common.opt:1660 msgid "Enable common options for performing profile feedback directed optimizations, and set -fprofile-dir=" msgstr "" -#: common.opt:1660 +#: common.opt:1664 msgid "Insert code to profile values of expressions" msgstr "" -#: common.opt:1664 +#: common.opt:1668 msgid "Report on consistency of profile" msgstr "" -#: common.opt:1671 +#: common.opt:1675 msgid "-frandom-seed=<string>\tMake compile reproducible using <string>" msgstr "" -#: common.opt:1681 +#: common.opt:1685 msgid "Record gcc command line switches in the object file." msgstr "" -#: common.opt:1685 +#: common.opt:1689 msgid "Return small aggregates in registers" msgstr "" -#: common.opt:1689 +#: common.opt:1693 msgid "Enables a register move optimization" msgstr "" -#: common.opt:1693 +#: common.opt:1697 msgid "Perform a register renaming optimization pass" msgstr "" -#: common.opt:1697 +#: common.opt:1701 msgid "Reorder basic blocks to improve code placement" msgstr "" -#: common.opt:1701 +#: common.opt:1705 msgid "Reorder basic blocks and partition into hot and cold sections" msgstr "" -#: common.opt:1705 +#: common.opt:1709 msgid "Reorder functions to improve code placement" msgstr "" -#: common.opt:1709 +#: common.opt:1713 msgid "Add a common subexpression elimination pass after loop optimizations" msgstr "" -#: common.opt:1717 +#: common.opt:1721 msgid "Disable optimizations that assume default FP rounding behavior" msgstr "" -#: common.opt:1721 +#: common.opt:1725 msgid "Enable scheduling across basic blocks" msgstr "" -#: common.opt:1725 +#: common.opt:1729 msgid "Enable register pressure sensitive insn scheduling" msgstr "" -#: common.opt:1729 +#: common.opt:1733 msgid "Allow speculative motion of non-loads" msgstr "" -#: common.opt:1733 +#: common.opt:1737 msgid "Allow speculative motion of some loads" msgstr "" -#: common.opt:1737 +#: common.opt:1741 msgid "Allow speculative motion of more loads" msgstr "" -#: common.opt:1741 +#: common.opt:1745 msgid "-fsched-verbose=<number>\tSet the verbosity level of the scheduler" msgstr "" -#: common.opt:1745 +#: common.opt:1749 msgid "If scheduling post reload, do superblock scheduling" msgstr "" -#: common.opt:1753 +#: common.opt:1757 msgid "Reschedule instructions before register allocation" msgstr "" -#: common.opt:1757 +#: common.opt:1761 msgid "Reschedule instructions after register allocation" msgstr "" -#: common.opt:1764 +#: common.opt:1768 msgid "Schedule instructions using selective scheduling algorithm" msgstr "" -#: common.opt:1768 +#: common.opt:1772 msgid "Run selective scheduling after reload" msgstr "" -#: common.opt:1772 +#: common.opt:1776 msgid "Perform software pipelining of inner loops during selective scheduling" msgstr "" -#: common.opt:1776 +#: common.opt:1780 msgid "Perform software pipelining of outer loops during selective scheduling" msgstr "" -#: common.opt:1780 +#: common.opt:1784 msgid "Reschedule pipelined regions without pipelining" msgstr "" -#: common.opt:1786 +#: common.opt:1790 msgid "Allow premature scheduling of queued insns" msgstr "" -#: common.opt:1790 +#: common.opt:1794 msgid "-fsched-stalled-insns=<number>\tSet number of queued insns that can be prematurely scheduled" msgstr "" -#: common.opt:1798 +#: common.opt:1802 msgid "Set dependence distance checking in premature scheduling of queued insns" msgstr "" -#: common.opt:1802 +#: common.opt:1806 msgid "-fsched-stalled-insns-dep=<number>\tSet dependence distance checking in premature scheduling of queued insns" msgstr "" -#: common.opt:1806 +#: common.opt:1810 msgid "Enable the group heuristic in the scheduler" msgstr "" -#: common.opt:1810 +#: common.opt:1814 msgid "Enable the critical path heuristic in the scheduler" msgstr "" -#: common.opt:1814 +#: common.opt:1818 msgid "Enable the speculative instruction heuristic in the scheduler" msgstr "" -#: common.opt:1818 +#: common.opt:1822 msgid "Enable the rank heuristic in the scheduler" msgstr "" -#: common.opt:1822 +#: common.opt:1826 msgid "Enable the last instruction heuristic in the scheduler" msgstr "" -#: common.opt:1826 +#: common.opt:1830 msgid "Enable the dependent count heuristic in the scheduler" msgstr "" -#: common.opt:1830 +#: common.opt:1834 msgid "Access data in the same section from shared anchor points" msgstr "" -#: common.opt:1842 +#: common.opt:1846 msgid "Turn on Redundant Extensions Elimination pass." msgstr "" -#: common.opt:1846 +#: common.opt:1850 msgid "Show column numbers in diagnostics, when available. Default on" msgstr "" -#: common.opt:1850 +#: common.opt:1854 msgid "Emit function prologues only before parts of the function that need it," msgstr "" -#: common.opt:1855 +#: common.opt:1859 msgid "Disable optimizations observable by IEEE signaling NaNs" msgstr "" -#: common.opt:1859 +#: common.opt:1863 msgid "Disable floating point optimizations that ignore the IEEE signedness of zero" msgstr "" -#: common.opt:1863 +#: common.opt:1867 msgid "Convert floating point constants to single precision constants" msgstr "" -#: common.opt:1867 +#: common.opt:1871 msgid "Split lifetimes of induction variables when loops are unrolled" msgstr "" -#: common.opt:1871 +#: common.opt:1875 msgid "Generate discontiguous stack frames" msgstr "" -#: common.opt:1875 +#: common.opt:1879 msgid "Split wide types into independent registers" msgstr "" -#: common.opt:1879 +#: common.opt:1883 msgid "Apply variable expansion when loops are unrolled" msgstr "" -#: common.opt:1883 +#: common.opt:1887 msgid "-fstack-check=[no|generic|specific]\tInsert stack checking code into the program" msgstr "" -#: common.opt:1887 +#: common.opt:1891 msgid "Insert stack checking code into the program. Same as -fstack-check=specific" msgstr "" -#: common.opt:1894 +#: common.opt:1898 msgid "-fstack-limit-register=<register>\tTrap if the stack goes past <register>" msgstr "" -#: common.opt:1898 +#: common.opt:1902 msgid "-fstack-limit-symbol=<name>\tTrap if the stack goes past symbol <name>" msgstr "" -#: common.opt:1902 +#: common.opt:1906 msgid "Use propolice as a stack protection method" msgstr "" -#: common.opt:1906 +#: common.opt:1910 msgid "Use a stack protection method for every function" msgstr "" -#: common.opt:1910 +#: common.opt:1914 msgid "Output stack usage information on a per-function basis" msgstr "" -#: common.opt:1922 +#: common.opt:1926 msgid "Assume strict aliasing rules apply" msgstr "" -#: common.opt:1926 +#: common.opt:1930 msgid "Treat signed overflow as undefined" msgstr "" -#: common.opt:1930 +#: common.opt:1934 msgid "Implement __atomic operations via libcalls to legacy __sync functions" msgstr "" -#: common.opt:1934 +#: common.opt:1938 msgid "Check for syntax errors, then stop" msgstr "" -#: common.opt:1938 +#: common.opt:1942 msgid "Create data files needed by \"gcov\"" msgstr "" -#: common.opt:1942 +#: common.opt:1946 msgid "Perform jump threading optimizations" msgstr "" -#: common.opt:1946 +#: common.opt:1950 msgid "Report the time taken by each compiler pass" msgstr "" -#: common.opt:1950 +#: common.opt:1954 msgid "-ftls-model=[global-dynamic|local-dynamic|initial-exec|local-exec]\tSet the default thread-local storage code generation model" msgstr "" -#: common.opt:1953 +#: common.opt:1957 #, fuzzy, c-format msgid "unknown TLS model %qs" msgstr "tuntematon konetila %qs" -#: common.opt:1969 +#: common.opt:1973 msgid "Reorder top level functions, variables, and asms" msgstr "" -#: common.opt:1973 +#: common.opt:1977 msgid "Perform superblock formation via tail duplication" msgstr "" -#: common.opt:1980 +#: common.opt:1984 msgid "Assume floating-point operations can trap" msgstr "" -#: common.opt:1984 +#: common.opt:1988 msgid "Trap for signed overflow in addition, subtraction and multiplication" msgstr "" -#: common.opt:1988 +#: common.opt:1992 msgid "Enable SSA-CCP optimization on trees" msgstr "" -#: common.opt:1992 +#: common.opt:1996 msgid "Enable SSA-BIT-CCP optimization on trees" msgstr "" -#: common.opt:2000 +#: common.opt:2004 msgid "Enable loop header copying on trees" msgstr "" -#: common.opt:2004 +#: common.opt:2008 msgid "Enable coalescing of copy-related user variables that are inlined" msgstr "" -#: common.opt:2008 +#: common.opt:2012 msgid "Enable coalescing of all copy-related user variables" msgstr "" -#: common.opt:2012 +#: common.opt:2016 msgid "Replace SSA temporaries with better names in copies" msgstr "" -#: common.opt:2016 +#: common.opt:2020 msgid "Enable copy propagation on trees" msgstr "" -#: common.opt:2024 +#: common.opt:2028 msgid "Transform condition stores into unconditional ones" msgstr "" -#: common.opt:2028 +#: common.opt:2032 msgid "Perform conversions of switch initializations." msgstr "" -#: common.opt:2032 +#: common.opt:2036 msgid "Enable SSA dead code elimination optimization on trees" msgstr "" -#: common.opt:2036 +#: common.opt:2040 msgid "Enable dominator optimizations" msgstr "" -#: common.opt:2040 +#: common.opt:2044 #, fuzzy msgid "Enable tail merging on trees" msgstr "säiekohtaista muistia ei tueta tälle kohteelle" -#: common.opt:2044 +#: common.opt:2048 msgid "Enable dead store elimination" msgstr "" -#: common.opt:2048 +#: common.opt:2052 msgid "Enable forward propagation on trees" msgstr "" -#: common.opt:2052 +#: common.opt:2056 msgid "Enable Full Redundancy Elimination (FRE) on trees" msgstr "" -#: common.opt:2056 +#: common.opt:2060 #, fuzzy msgid "Enable string length optimizations on trees" msgstr "ehtolausekkeessa ei-lvalue-taulukko" -#: common.opt:2060 +#: common.opt:2064 msgid "Enable loop distribution on trees" msgstr "" -#: common.opt:2064 +#: common.opt:2068 msgid "Enable loop distribution for patterns transformed into a library call" msgstr "" -#: common.opt:2068 +#: common.opt:2072 msgid "Enable loop invariant motion on trees" msgstr "" -#: common.opt:2072 +#: common.opt:2076 msgid "Enable loop interchange transforms. Same as -floop-interchange" msgstr "" -#: common.opt:2076 +#: common.opt:2080 msgid "Create canonical induction variables in loops" msgstr "" -#: common.opt:2080 +#: common.opt:2084 msgid "Enable loop optimizations on tree level" msgstr "" -#: common.opt:2084 +#: common.opt:2088 msgid "Enable automatic parallelization of loops" msgstr "" -#: common.opt:2088 +#: common.opt:2092 #, fuzzy msgid "Enable hoisting loads from conditional pointers." msgstr "ehtolausekkeessa ei-lvalue-taulukko" -#: common.opt:2092 +#: common.opt:2096 msgid "Enable SSA-PRE optimization on trees" msgstr "" -#: common.opt:2096 +#: common.opt:2100 msgid "In SSA-PRE optimization on trees, enable partial-partial redundancy elimination" msgstr "" -#: common.opt:2100 +#: common.opt:2104 msgid "Perform function-local points-to analysis on trees." msgstr "" -#: common.opt:2104 +#: common.opt:2108 msgid "Enable reassociation on tree level" msgstr "" -#: common.opt:2112 +#: common.opt:2116 msgid "Enable SSA code sinking on trees" msgstr "" -#: common.opt:2116 +#: common.opt:2120 msgid "Perform straight-line strength reduction" msgstr "" -#: common.opt:2120 +#: common.opt:2124 msgid "Perform scalar replacement of aggregates" msgstr "" -#: common.opt:2124 +#: common.opt:2128 msgid "Replace temporary expressions in the SSA->normal pass" msgstr "" -#: common.opt:2128 +#: common.opt:2132 msgid "Perform live range splitting during the SSA->normal pass" msgstr "" -#: common.opt:2132 +#: common.opt:2136 msgid "Perform Value Range Propagation on trees" msgstr "" -#: common.opt:2136 +#: common.opt:2140 msgid "Compile whole compilation unit at a time" msgstr "" -#: common.opt:2140 +#: common.opt:2144 msgid "Perform loop unrolling when iteration count is known" msgstr "" -#: common.opt:2144 +#: common.opt:2148 msgid "Perform loop unrolling for all loops" msgstr "" -#: common.opt:2151 +#: common.opt:2155 msgid "Allow loop optimizations to assume that the loops behave in normal way" msgstr "" -#: common.opt:2155 +#: common.opt:2159 msgid "Allow optimization for floating-point arithmetic which may change the" msgstr "" -#: common.opt:2160 +#: common.opt:2164 msgid "Same as -fassociative-math for expressions which include division." msgstr "" -#: common.opt:2168 +#: common.opt:2172 msgid "Allow math optimizations that may violate IEEE or ISO standards" msgstr "" -#: common.opt:2172 +#: common.opt:2176 msgid "Perform loop unswitching" msgstr "" -#: common.opt:2176 +#: common.opt:2180 msgid "Just generate unwind tables for exception handling" msgstr "" -#: common.opt:2180 +#: common.opt:2184 msgid "Use the bfd linker instead of the default linker" msgstr "" -#: common.opt:2184 +#: common.opt:2188 msgid "Use the gold linker instead of the default linker" msgstr "" -#: common.opt:2196 +#: common.opt:2200 msgid "Perform variable tracking" msgstr "" -#: common.opt:2204 +#: common.opt:2208 msgid "Perform variable tracking by annotating assignments" msgstr "" -#: common.opt:2210 +#: common.opt:2214 msgid "Toggle -fvar-tracking-assignments" msgstr "" -#: common.opt:2218 +#: common.opt:2222 msgid "Perform variable tracking and also tag variables that are uninitialized" msgstr "" -#: common.opt:2222 +#: common.opt:2226 msgid "Enable loop vectorization on trees" msgstr "" -#: common.opt:2226 +#: common.opt:2230 msgid "-ftree-vectorizer-verbose=<number>\tThis switch is deprecated. Use -fopt-info instead." msgstr "" -#: common.opt:2230 +#: common.opt:2234 msgid "Enable basic block vectorization (SLP) on trees" msgstr "" -#: common.opt:2234 +#: common.opt:2238 msgid "Enable use of cost model in vectorization" msgstr "" -#: common.opt:2238 +#: common.opt:2242 msgid "Enable loop versioning when doing loop vectorization on trees" msgstr "" -#: common.opt:2242 +#: common.opt:2246 msgid "Enable copy propagation of scalar-evolution information." msgstr "" -#: common.opt:2252 +#: common.opt:2256 msgid "Add extra commentary to assembler output" msgstr "" -#: common.opt:2256 +#: common.opt:2260 msgid "-fvisibility=[default|internal|hidden|protected]\tSet the default symbol visibility" msgstr "" -#: common.opt:2259 +#: common.opt:2263 #, fuzzy, c-format msgid "unrecognized visibility value %qs" msgstr "tunnistamaton muotomäärite" -#: common.opt:2275 +#: common.opt:2279 msgid "Use expression value profiles in optimizations" msgstr "" -#: common.opt:2279 +#: common.opt:2283 msgid "Construct webs and split unrelated uses of single variable" msgstr "" -#: common.opt:2283 +#: common.opt:2287 msgid "Enable conditional dead code elimination for builtin calls" msgstr "" -#: common.opt:2287 +#: common.opt:2291 msgid "Perform whole program optimizations" msgstr "" -#: common.opt:2291 +#: common.opt:2295 msgid "Assume signed arithmetic overflow wraps around" msgstr "" -#: common.opt:2295 +#: common.opt:2299 msgid "Put zero initialized data in the bss section" msgstr "" -#: common.opt:2299 +#: common.opt:2303 msgid "Generate debug information in default format" msgstr "" -#: common.opt:2303 +#: common.opt:2307 msgid "Generate debug information in COFF format" msgstr "" -#: common.opt:2307 +#: common.opt:2311 msgid "Generate debug information in DWARF v2 (or later) format" msgstr "" -#: common.opt:2311 +#: common.opt:2315 msgid "Generate debug information in default extended format" msgstr "" -#: common.opt:2315 +#: common.opt:2319 msgid "Don't generate DWARF pubnames and pubtypes sections." msgstr "" -#: common.opt:2319 +#: common.opt:2323 msgid "Generate DWARF pubnames and pubtypes sections." msgstr "" -#: common.opt:2323 +#: common.opt:2327 msgid "Don't record gcc command line switches in DWARF DW_AT_producer." msgstr "" -#: common.opt:2327 +#: common.opt:2331 msgid "Record gcc command line switches in DWARF DW_AT_producer." msgstr "" -#: common.opt:2331 +#: common.opt:2335 msgid "Don't generate debug information in separate .dwo files" msgstr "" -#: common.opt:2335 +#: common.opt:2339 msgid "Generate debug information in separate .dwo files" msgstr "" -#: common.opt:2339 +#: common.opt:2343 msgid "Generate debug information in STABS format" msgstr "" -#: common.opt:2343 +#: common.opt:2347 msgid "Generate debug information in extended STABS format" -msgstr "" +msgstr "Tuota vianjäljitystietoja laajennetussa STABS-muodossa" -#: common.opt:2347 +#: common.opt:2351 msgid "Emit DWARF additions beyond selected version" msgstr "" -#: common.opt:2351 +#: common.opt:2355 msgid "Don't emit DWARF additions beyond selected version" msgstr "" -#: common.opt:2355 +#: common.opt:2359 msgid "Toggle debug information generation" msgstr "" -#: common.opt:2359 +#: common.opt:2363 msgid "Generate debug information in VMS format" -msgstr "" +msgstr "Tuota vianjäljitystietoja VMS-muodossa" -#: common.opt:2363 +#: common.opt:2367 msgid "Generate debug information in XCOFF format" -msgstr "" +msgstr "Tuota vianjäljitystietoja XCOFF-muodossa" -#: common.opt:2367 +#: common.opt:2371 msgid "Generate debug information in extended XCOFF format" msgstr "" -#: common.opt:2374 +#: common.opt:2378 msgid "-iplugindir=<dir>\tSet <dir> to be the default plugin directory" msgstr "" -#: common.opt:2378 +#: common.opt:2382 msgid "-imultiarch <dir>\tSet <dir> to be the multiarch include subdirectory" msgstr "" -#: common.opt:2400 +#: common.opt:2404 #, fuzzy -#| msgid " -o <file> Place the output into <file>\n" msgid "-o <file>\tPlace output into <file>" msgstr " -o <tiedosto> Ohjaa tuloste <tiedostoon>\n" -#: common.opt:2404 +#: common.opt:2408 msgid "Enable function profiling" -msgstr "" +msgstr "Ota käyttöön funktioprofilointi" -#: common.opt:2414 +#: common.opt:2418 msgid "Like -pedantic but issue them as errors" msgstr "" -#: common.opt:2454 +#: common.opt:2458 msgid "Do not display functions compiled or elapsed time" msgstr "" -#: common.opt:2486 +#: common.opt:2490 msgid "Enable verbose output" msgstr "" -#: common.opt:2490 +#: common.opt:2494 msgid "Display the compiler's version" -msgstr "" +msgstr "Näytä kääntäjän versio" -#: common.opt:2494 +#: common.opt:2498 msgid "Suppress warnings" -msgstr "" +msgstr "Vaimenna varoitukset" -#: common.opt:2504 +#: common.opt:2508 msgid "Create a shared library" msgstr "Luo jaettu kirjasto" -#: common.opt:2543 +#: common.opt:2547 msgid "Create a position independent executable" -msgstr "" +msgstr "Luo paikkariippumaton suoritettava tiedosto" -#: go/gofrontend/expressions.cc:102 c-family/c-common.c:1777 cp/cvt.c:1149 +#: go/gofrontend/expressions.cc:102 c-family/c-common.c:1782 cp/cvt.c:1149 #: cp/cvt.c:1395 #, gcc-internal-format msgid "value computed is not used" @@ -12622,13 +12523,11 @@ msgstr "epäkelvot operandit binääriselle %s-operaatiolle" #: go/gofrontend/expressions.cc:5616 go/gofrontend/expressions.cc:5634 #, fuzzy -#| msgid "incompatible types in return" msgid "incompatible types in binary expression" msgstr "yhteensopimattomat tyypin palautuksessa" #: go/gofrontend/expressions.cc:5648 #, fuzzy -#| msgid "size of array %qE has non-integer type" msgid "shift of non-integer operand" msgstr "taulukon %qE koko ei ole kokonaislukutyyppiä" @@ -12642,13 +12541,11 @@ msgstr "" #: go/gofrontend/expressions.cc:6470 #, fuzzy -#| msgid "called object %qE is not a function" msgid "object is not a method" msgstr "kutsuttu objekti %qE ei ole funktio" #: go/gofrontend/expressions.cc:6479 #, fuzzy -#| msgid "argument %qD doesn%'t match prototype" msgid "method type does not match object type" msgstr "argumentti %qD ei sovi prototyyppiin" @@ -12663,7 +12560,6 @@ msgstr "epäkelpo argumentti funktiolle %<__builtin_return_address%>" #: go/gofrontend/expressions.cc:7848 go/gofrontend/expressions.cc:9036 #: go/gofrontend/expressions.cc:9055 #, fuzzy -#| msgid "no arguments" msgid "not enough arguments" msgstr "ei argumentteja" @@ -12758,7 +12654,6 @@ msgstr "%Jparametrilla %u in vaillinainen tyyppi" #: go/gofrontend/expressions.cc:7858 #, fuzzy -#| msgid "cleanup argument not an identifier" msgid "complex arguments must have identical types" msgstr "puhdistusargumentti ei ole tunniste" @@ -12779,19 +12674,16 @@ msgstr "epäkelpo %<restrict%>-avainsanan käyttö" #: go/gofrontend/expressions.cc:9008 #, fuzzy -#| msgid "incompatible types in return" msgid "incompatible type for receiver" msgstr "yhteensopimattomat tyypin palautuksessa" #: go/gofrontend/expressions.cc:9026 #, fuzzy -#| msgid "invalid use of non-static member function" msgid "invalid use of %<...%> calling non-variadic function" msgstr "virheellinen ei-staattisen jäsenfunktion käyttö" #: go/gofrontend/expressions.cc:9460 go/gofrontend/expressions.cc:9474 #, fuzzy -#| msgid "number of arguments doesn%'t match prototype" msgid "number of results does not match number of values" msgstr "argumenttien määrä ei vastaa prototyyppiä" @@ -12813,7 +12705,6 @@ msgstr "" #: go/gofrontend/expressions.cc:10448 #, fuzzy -#| msgid "incompatible types in return" msgid "incompatible type for map index" msgstr "yhteensopimattomat tyypin palautuksessa" @@ -12823,13 +12714,11 @@ msgstr "" #: go/gofrontend/expressions.cc:11461 #, fuzzy -#| msgid "too many arguments for format" msgid "too many expressions for struct" msgstr "liian monta argumenttia muotoilulle" #: go/gofrontend/expressions.cc:11474 #, fuzzy -#| msgid "too few arguments for format" msgid "too few expressions for struct" msgstr "liian vähän argumentteja muotoilulle" @@ -12843,7 +12732,6 @@ msgstr "" #: go/gofrontend/expressions.cc:13318 go/gofrontend/statements.cc:1385 #, fuzzy -#| msgid "expected class name" msgid "expected channel" msgstr "odotettiin luokan nimeä" @@ -12858,7 +12746,6 @@ msgstr "" # XXX #: go/gofrontend/statements.cc:588 #, fuzzy -#| msgid "lvalue required as left operand of assignment" msgid "invalid left hand side of assignment" msgstr "sijoituksen vasemman operandin on oltava lvalue" @@ -12877,7 +12764,6 @@ msgstr "liian vähän argumentteja funktiolle %qE" #: go/gofrontend/statements.cc:2644 #, fuzzy -#| msgid "%<return%> with a value, in function returning void" msgid "return with value in function with no return type" msgstr "%<return%> arvon kanssa voidin palauttavassa funktiossa" @@ -12897,7 +12783,6 @@ msgstr "" #: go/gofrontend/statements.cc:4325 #, fuzzy -#| msgid "incompatible types in return" msgid "incompatible types in send" msgstr "yhteensopimattomat tyypin palautuksessa" @@ -12916,7 +12801,6 @@ msgstr "" #: go/gofrontend/types.cc:515 #, fuzzy -#| msgid "invalid application of %qs to a void type" msgid "invalid comparison of non-ordered type" msgstr "epäkelpo %qs:n soveltaminen tyhjään tyyppiin" @@ -12939,7 +12823,6 @@ msgstr "epäkelvot operandit binääriselle %s-operaatiolle" #: go/gofrontend/types.cc:564 #, fuzzy -#| msgid "invalid application of %qs to incomplete type %qT " msgid "invalid comparison of non-comparable type" msgstr "epäkelpo %qs:n soveltaminen vaillinaiseen tyyppiin %qT " @@ -12957,13 +12840,11 @@ msgstr "" #: go/gofrontend/types.cc:714 #, fuzzy -#| msgid "Warn about implicit conversion" msgid "need explicit conversion" msgstr "Varoita implisiittisistä muunnoksista" #: go/gofrontend/types.cc:721 #, fuzzy, c-format -#| msgid "cannot convert type %qT to type %qT" msgid "cannot use type %s as type %s" msgstr "ei voi muuntaa tyyppiä %qT tyypiksi %qT" @@ -12975,13 +12856,11 @@ msgstr "epäkelpo osoitintila %qs" #: go/gofrontend/types.cc:3293 go/gofrontend/types.cc:3306 #: go/gofrontend/types.cc:3321 #, fuzzy -#| msgid "redefinition of parameter %q+D" msgid "different number of parameters" msgstr "parametri %q+D määritelty uudelleen" #: go/gofrontend/types.cc:3314 #, fuzzy -#| msgid "invalid parameter type %qT" msgid "different parameter types" msgstr "virheellinen parametrityyppi %qT" @@ -13010,13 +12889,11 @@ msgstr "" #: go/gofrontend/types.cc:6803 go/gofrontend/types.cc:6945 #, fuzzy, c-format -#| msgid "incompatible type for argument %d of %qE" msgid "incompatible type for method %s%s%s" msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton" #: go/gofrontend/types.cc:6807 go/gofrontend/types.cc:6949 #, fuzzy, c-format -#| msgid "incompatible type for argument %d of %qE" msgid "incompatible type for method %s%s%s (%s)" msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton" @@ -13026,7 +12903,6 @@ msgstr "" #: go/gofrontend/types.cc:6888 go/gofrontend/types.cc:6901 #, fuzzy -#| msgid "struct has no members" msgid "type has no methods" msgstr "structilla ei ole jäseniä" @@ -13051,7 +12927,7 @@ msgid "method %s%s%s is marked go:nointerface" msgstr "" #. Warn about and ignore all others for now, but store them. -#: attribs.c:426 c-family/c-common.c:8019 objc/objc-act.c:4952 +#: attribs.c:426 c-family/c-common.c:8041 objc/objc-act.c:4952 #: objc/objc-act.c:6922 objc/objc-act.c:8109 objc/objc-act.c:8160 #, fuzzy, gcc-internal-format msgid "%qE attribute directive ignored" @@ -13072,7 +12948,6 @@ msgstr "attribuutille %qs annettu väärä määrä argumentteja" #. type. Ignore it. #: attribs.c:452 #, fuzzy, gcc-internal-format -#| msgid "%qE attribute ignored" msgid "attribute ignored" msgstr "%qE-attribuuttia ei huomioida" @@ -13082,14 +12957,14 @@ msgid "an attribute that appertains to a type-specifier is ignored" msgstr "" #: attribs.c:471 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE attribute does not apply to types" -msgstr "attribuutti %qs ei päde tyyppeihin" +msgstr "%qE-attribuutti ei päde tyyppeihin" #: attribs.c:523 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE attribute only applies to function types" -msgstr "attribuutti %qs pätee vain funktiotyyppeihin" +msgstr "%qE-attribuutti pätee vain funktiotyyppeihin" #: attribs.c:533 #, fuzzy, gcc-internal-format @@ -13250,7 +13125,7 @@ msgstr "%Jlohkoattribuutteja ei tueta tälle kohteelle" #. All valid uses of __builtin_va_arg_pack () are removed during #. inlining. -#: builtins.c:6025 expr.c:10184 +#: builtins.c:6025 expr.c:10185 #, fuzzy, gcc-internal-format msgid "%Kinvalid use of %<__builtin_va_arg_pack ()%>" msgstr "epäkelpo argumentti funktiolle %<__builtin_frame_address%>" @@ -13337,17 +13212,17 @@ msgstr "" msgid "function call has aggregate value" msgstr "" -#: cfgexpand.c:1238 function.c:971 varasm.c:1966 -#, fuzzy, gcc-internal-format +#: cfgexpand.c:1238 function.c:971 varasm.c:1964 +#, gcc-internal-format msgid "size of variable %q+D is too large" -msgstr "taulukon %qs koko on liian suuri" +msgstr "muuttujan %q+D koko on liian suuri" -#: cfgexpand.c:4487 +#: cfgexpand.c:4542 #, gcc-internal-format msgid "stack protector not protecting local variables: variable length buffer" msgstr "" -#: cfgexpand.c:4491 +#: cfgexpand.c:4546 #, gcc-internal-format, gfc-internal-format msgid "stack protector not protecting function: all local arrays are less than %d bytes long" msgstr "" @@ -13647,162 +13522,162 @@ msgstr "liikaa syötetiedostoja" msgid "%d exits recorded for loop %d (having %d exits)" msgstr "" -#: cfgrtl.c:2092 +#: cfgrtl.c:2090 #, gcc-internal-format, gfc-internal-format msgid "BB_RTL flag not set for block %d" msgstr "" -#: cfgrtl.c:2099 +#: cfgrtl.c:2097 #, gcc-internal-format, gfc-internal-format msgid "insn %d basic block pointer is %d, should be %d" msgstr "" -#: cfgrtl.c:2110 +#: cfgrtl.c:2108 #, gcc-internal-format, gfc-internal-format msgid "insn %d in header of bb %d has non-NULL basic block" msgstr "" -#: cfgrtl.c:2118 +#: cfgrtl.c:2116 #, gcc-internal-format, gfc-internal-format msgid "insn %d in footer of bb %d has non-NULL basic block" msgstr "" -#: cfgrtl.c:2141 +#: cfgrtl.c:2139 #, gcc-internal-format msgid "verify_flow_info: REG_BR_PROB does not match cfg %wi %i" msgstr "" -#: cfgrtl.c:2160 +#: cfgrtl.c:2158 #, gcc-internal-format msgid "EDGE_CROSSING incorrectly set across same section" msgstr "" -#: cfgrtl.c:2165 +#: cfgrtl.c:2163 #, gcc-internal-format, gfc-internal-format msgid "fallthru edge crosses section boundary in bb %i" msgstr "" -#: cfgrtl.c:2171 +#: cfgrtl.c:2169 #, gcc-internal-format, gfc-internal-format msgid "EH edge crosses section boundary in bb %i" msgstr "" -#: cfgrtl.c:2178 +#: cfgrtl.c:2176 #, gcc-internal-format msgid "EDGE_CROSSING missing across section boundary" msgstr "" -#: cfgrtl.c:2205 +#: cfgrtl.c:2203 #, gcc-internal-format, gfc-internal-format msgid "missing REG_EH_REGION note at the end of bb %i" msgstr "" -#: cfgrtl.c:2210 +#: cfgrtl.c:2208 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "too many exception handling edges in bb %i" msgstr "liikaa syötetiedostoja" -#: cfgrtl.c:2218 +#: cfgrtl.c:2216 #, gcc-internal-format, gfc-internal-format msgid "too many outgoing branch edges from bb %i" msgstr "" -#: cfgrtl.c:2223 +#: cfgrtl.c:2221 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "fallthru edge after unconditional jump in bb %i" msgstr "väärä määrä argumentteja funktiolle %<va_start%>" -#: cfgrtl.c:2228 +#: cfgrtl.c:2226 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "wrong number of branch edges after unconditional jump in bb %i" msgstr "väärä määrä argumentteja funktiolle %<va_start%>" -#: cfgrtl.c:2235 +#: cfgrtl.c:2233 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "wrong amount of branch edges after conditional jump in bb %i" msgstr "väärä määrä argumentteja funktiolle %<va_start%>" -#: cfgrtl.c:2241 +#: cfgrtl.c:2239 #, gcc-internal-format, gfc-internal-format msgid "abnormal call edges for non-call insn in bb %i" msgstr "" -#: cfgrtl.c:2246 +#: cfgrtl.c:2244 #, gcc-internal-format, gfc-internal-format msgid "sibcall edges for non-call insn in bb %i" msgstr "" -#: cfgrtl.c:2256 +#: cfgrtl.c:2254 #, gcc-internal-format, gfc-internal-format msgid "abnormal edges for no purpose in bb %i" msgstr "" -#: cfgrtl.c:2268 +#: cfgrtl.c:2266 #, gcc-internal-format, gfc-internal-format msgid "insn %d inside basic block %d but block_for_insn is NULL" msgstr "" -#: cfgrtl.c:2272 +#: cfgrtl.c:2270 #, gcc-internal-format, gfc-internal-format msgid "insn %d inside basic block %d but block_for_insn is %i" msgstr "" -#: cfgrtl.c:2286 cfgrtl.c:2296 +#: cfgrtl.c:2284 cfgrtl.c:2294 #, gcc-internal-format, gfc-internal-format msgid "NOTE_INSN_BASIC_BLOCK is missing for block %d" msgstr "" -#: cfgrtl.c:2309 +#: cfgrtl.c:2307 #, gcc-internal-format, gfc-internal-format msgid "NOTE_INSN_BASIC_BLOCK %d in middle of basic block %d" msgstr "" -#: cfgrtl.c:2319 +#: cfgrtl.c:2317 #, gcc-internal-format, gfc-internal-format msgid "in basic block %d:" msgstr "" -#: cfgrtl.c:2371 cfgrtl.c:2461 +#: cfgrtl.c:2369 cfgrtl.c:2459 #, gcc-internal-format, gfc-internal-format msgid "insn %d outside of basic blocks has non-NULL bb field" msgstr "" -#: cfgrtl.c:2379 +#: cfgrtl.c:2377 #, gcc-internal-format, gfc-internal-format msgid "end insn %d for block %d not found in the insn stream" msgstr "" -#: cfgrtl.c:2392 +#: cfgrtl.c:2390 #, gcc-internal-format, gfc-internal-format msgid "insn %d is in multiple basic blocks (%d and %d)" msgstr "" -#: cfgrtl.c:2404 +#: cfgrtl.c:2402 #, gcc-internal-format, gfc-internal-format msgid "head insn %d for block %d not found in the insn stream" msgstr "" -#: cfgrtl.c:2421 +#: cfgrtl.c:2419 #, gcc-internal-format, gfc-internal-format msgid "missing barrier after block %i" msgstr "" -#: cfgrtl.c:2437 +#: cfgrtl.c:2435 #, gcc-internal-format, gfc-internal-format msgid "verify_flow_info: Incorrect blocks for fallthru %i->%i" msgstr "" -#: cfgrtl.c:2446 +#: cfgrtl.c:2444 #, gcc-internal-format, gfc-internal-format msgid "verify_flow_info: Incorrect fallthru %i->%i" msgstr "" -#: cfgrtl.c:2479 +#: cfgrtl.c:2477 #, gcc-internal-format msgid "basic blocks not laid down consecutively" msgstr "" -#: cfgrtl.c:2516 +#: cfgrtl.c:2514 #, gcc-internal-format, gfc-internal-format msgid "number of bb notes in insn chain (%d) != n_basic_blocks (%d)" msgstr "" @@ -14072,7 +13947,7 @@ msgstr "" msgid "no arguments" msgstr "ei argumentteja" -#: collect2.c:1284 opts.c:794 +#: collect2.c:1284 opts.c:797 #, fuzzy, gcc-internal-format msgid "LTO support has not been enabled in this configuration" msgstr "#pragma redefine_extname ei ole tuettu tällä kohteella" @@ -14089,19 +13964,16 @@ msgstr "" #: collect2.c:1520 collect2.c:1703 collect2.c:1738 #, fuzzy, gcc-internal-format -#| msgid "fopen %s" msgid "fopen %s: %m" msgstr "fopen %s" #: collect2.c:1523 collect2.c:1708 collect2.c:1741 #, fuzzy, gcc-internal-format -#| msgid "fclose %s" msgid "fclose %s: %m" msgstr "fclose %s" #: collect2.c:1805 #, fuzzy, gcc-internal-format -#| msgid "can%'t read %s: %m" msgid "can't get program status: %m" msgstr "ei voi lukea tiedostoa %s: %m" @@ -14130,15 +14002,13 @@ msgstr "" msgid "cannot find '%s'" msgstr "" -#: collect2.c:1921 collect2.c:2448 collect2.c:2644 gcc.c:2749 +#: collect2.c:1921 collect2.c:2448 collect2.c:2644 gcc.c:2750 #, fuzzy, gcc-internal-format -#| msgid "pex_init failed: %s" msgid "pex_init failed: %m" msgstr "pex_init epäonnistui: %s" -#: collect2.c:1930 collect2.c:2457 collect2.c:2652 gcc.c:7188 +#: collect2.c:1930 collect2.c:2457 collect2.c:2652 gcc.c:7191 #, fuzzy, gcc-internal-format -#| msgid "%s: %s" msgid "%s: %m" msgstr "%s: %s" @@ -14149,7 +14019,6 @@ msgstr "" #: collect2.c:2470 #, fuzzy, gcc-internal-format -#| msgid "can't open ldd output" msgid "can't open nm output: %m" msgstr "ei voida avata ldd-tulostetta" @@ -14170,7 +14039,6 @@ msgstr "" #: collect2.c:2665 #, fuzzy, gcc-internal-format -#| msgid "can't open ldd output" msgid "can't open ldd output: %m" msgstr "ei voida avata ldd-tulostetta" @@ -14221,7 +14089,6 @@ msgstr "" #: convert.c:823 convert.c:899 #, fuzzy, gcc-internal-format -#| msgid "cast from pointer to integer of different size" msgid "can%'t convert between vector values of different size" msgstr "tyyppimuunnos osoittimesta erikokoiseen kokonaislukuun" @@ -14380,7 +14247,7 @@ msgstr "" msgid "global constructors not supported on this target" msgstr "" -#: diagnostic.c:1145 +#: diagnostic.c:1148 #, gcc-internal-format, gfc-internal-format msgid "in %s, at %s:%d" msgstr "" @@ -14425,22 +14292,22 @@ msgstr "" msgid "non-delegitimized UNSPEC %s (%d) found in variable location" msgstr "" -#: emit-rtl.c:2612 +#: emit-rtl.c:2616 #, gcc-internal-format msgid "invalid rtl sharing found in the insn" msgstr "" -#: emit-rtl.c:2614 +#: emit-rtl.c:2618 #, gcc-internal-format msgid "shared rtx" msgstr "" -#: emit-rtl.c:2616 +#: emit-rtl.c:2620 #, gcc-internal-format msgid "internal consistency failure" msgstr "" -#: emit-rtl.c:3741 +#: emit-rtl.c:3749 #, gcc-internal-format msgid "ICE: emit_insn used where emit_jump_insn needed:\n" msgstr "" @@ -14450,57 +14317,57 @@ msgstr "" msgid "abort in %s, at %s:%d" msgstr "" -#: except.c:2026 +#: except.c:2075 #, gcc-internal-format msgid "argument of %<__builtin_eh_return_regno%> must be constant" msgstr "" -#: except.c:2163 +#: except.c:2212 #, gcc-internal-format msgid "__builtin_eh_return not supported on this target" msgstr "" -#: except.c:3222 except.c:3247 +#: except.c:3271 except.c:3296 #, gcc-internal-format, gfc-internal-format msgid "region_array is corrupted for region %i" msgstr "" -#: except.c:3235 except.c:3266 +#: except.c:3284 except.c:3315 #, gcc-internal-format, gfc-internal-format msgid "lp_array is corrupted for lp %i" msgstr "" -#: except.c:3252 +#: except.c:3301 #, gcc-internal-format, gfc-internal-format msgid "outer block of region %i is wrong" msgstr "" -#: except.c:3257 +#: except.c:3306 #, gcc-internal-format, gfc-internal-format msgid "negative nesting depth of region %i" msgstr "" -#: except.c:3271 +#: except.c:3320 #, gcc-internal-format, gfc-internal-format msgid "region of lp %i is wrong" msgstr "" -#: except.c:3298 +#: except.c:3347 #, gcc-internal-format, gfc-internal-format msgid "tree list ends on depth %i" msgstr "" -#: except.c:3303 +#: except.c:3352 #, gcc-internal-format msgid "region_array does not match region_tree" msgstr "" -#: except.c:3308 +#: except.c:3357 #, gcc-internal-format msgid "lp_array does not match region_tree" msgstr "" -#: except.c:3315 +#: except.c:3364 #, gcc-internal-format msgid "verify_eh_tree failed" msgstr "" @@ -14537,19 +14404,18 @@ msgstr "" #: expr.c:7590 #, fuzzy, gcc-internal-format -#| msgid "global register variable %qD used in nested function" msgid "local frame unavailable (naked function?)" msgstr "sisäkkäisessä funktiossa käytetty globaalia rekisterimuuttujaa %qD" -#: expr.c:10191 -#, fuzzy, gcc-internal-format +#: expr.c:10192 +#, gcc-internal-format msgid "%Kcall to %qs declared with attribute error: %s" -msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline" +msgstr "%Kkutsu kohteeseen %qs esitelty attribuuttivirheellä: %s" -#: expr.c:10198 -#, fuzzy, gcc-internal-format +#: expr.c:10199 +#, gcc-internal-format msgid "%Kcall to %qs declared with attribute warning: %s" -msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline" +msgstr "%Kkutsu kohteeseen %qs esitelty attribuuttivaroituksella: %s" #: final.c:1499 #, fuzzy, gcc-internal-format @@ -14581,55 +14447,55 @@ msgstr "suuri kokonaisluku implisiittisesti katkaistu etumerkittömäksi tyypiks msgid "assuming signed overflow does not occur when negating a division" msgstr "" -#: fold-const.c:3437 fold-const.c:3449 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: fold-const.c:3450 fold-const.c:3462 +#, gcc-internal-format, gfc-internal-format msgid "comparison is always %d due to width of bit-field" -msgstr "vertailu on aina tosi johtuen tietotyypin rajallisesta arvoalueesta" +msgstr "vertailu on aina %d johtuen bittikentän leveydestä" -#: fold-const.c:4849 tree-ssa-reassoc.c:1943 +#: fold-const.c:4862 tree-ssa-reassoc.c:1944 #, gcc-internal-format msgid "assuming signed overflow does not occur when simplifying range test" msgstr "" -#: fold-const.c:5285 fold-const.c:5299 +#: fold-const.c:5298 fold-const.c:5312 #, gcc-internal-format, gfc-internal-format msgid "comparison is always %d" msgstr "" -#: fold-const.c:5432 +#: fold-const.c:5445 #, gcc-internal-format msgid "%<or%> of unmatched not-equal tests is always 1" msgstr "" -#: fold-const.c:5437 +#: fold-const.c:5450 #, gcc-internal-format msgid "%<and%> of mutually exclusive equal-tests is always 0" msgstr "" -#: fold-const.c:8729 +#: fold-const.c:8742 #, gcc-internal-format msgid "assuming signed overflow does not occur when reducing constant in comparison" msgstr "" -#: fold-const.c:8887 +#: fold-const.c:8900 #, gcc-internal-format msgid "assuming signed overflow does not occur when changing X +- C1 cmp C2 to X cmp C1 +- C2" msgstr "" -#: fold-const.c:9150 +#: fold-const.c:9163 #, gcc-internal-format msgid "assuming signed overflow does not occur when combining constants around a comparison" msgstr "" -#: fold-const.c:14564 +#: fold-const.c:14577 #, gcc-internal-format msgid "fold check: original tree changed by fold" msgstr "" #: function.c:227 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "total size of local objects too large" -msgstr "taulukon %qs koko on liian suuri" +msgstr "paikallisten objektien kokonaiskoko on liian suuri" #: function.c:1738 gimplify.c:5409 #, gcc-internal-format @@ -14646,381 +14512,364 @@ msgstr "" msgid "argument %q+D might be clobbered by %<longjmp%> or %<vfork%>" msgstr "" -#: function.c:4631 +#: function.c:4620 #, gcc-internal-format msgid "function returns an aggregate" msgstr "" -#: function.c:4993 +#: function.c:4982 #, gcc-internal-format msgid "unused parameter %q+D" msgstr "käyttämätön muuttuja %q+D" -#: gcc.c:1804 gcc.c:1824 +#: gcc.c:1805 gcc.c:1825 #, gcc-internal-format, gfc-internal-format msgid "specs %%include syntax malformed after %ld characters" msgstr "" -#: gcc.c:1850 gcc.c:1859 gcc.c:1869 gcc.c:1879 +#: gcc.c:1851 gcc.c:1860 gcc.c:1870 gcc.c:1880 #, gcc-internal-format, gfc-internal-format msgid "specs %%rename syntax malformed after %ld characters" msgstr "" -#: gcc.c:1889 +#: gcc.c:1890 #, gcc-internal-format, gfc-internal-format msgid "specs %s spec was not found to be renamed" msgstr "" -#: gcc.c:1896 +#: gcc.c:1897 #, fuzzy, gcc-internal-format msgid "%s: attempt to rename spec %qs to already defined spec %qs" msgstr "%qs-attribuuttia ei huomioida %qs:lle" -#: gcc.c:1917 +#: gcc.c:1918 #, gcc-internal-format, gfc-internal-format msgid "specs unknown %% command after %ld characters" msgstr "" -#: gcc.c:1928 gcc.c:1941 +#: gcc.c:1929 gcc.c:1942 #, gcc-internal-format, gfc-internal-format msgid "specs file malformed after %ld characters" msgstr "" -#: gcc.c:1993 +#: gcc.c:1994 #, gcc-internal-format msgid "spec file has no spec for linking" msgstr "" -#: gcc.c:2538 +#: gcc.c:2539 #, fuzzy, gcc-internal-format -#| msgid "system path '%s' is not absolute" msgid "system path %qs is not absolute" msgstr "järjestelmäpolku ”%s” ei ole absoluuttinen" -#: gcc.c:2626 +#: gcc.c:2627 #, gcc-internal-format msgid "-pipe not supported" msgstr "-pipe ei ole tuettu" -#: gcc.c:2788 +#: gcc.c:2789 #, fuzzy, gcc-internal-format -#| msgid "ld returned %d exit status" msgid "failed to get exit status: %m" msgstr "ld:n paluuarvo oli %d" -#: gcc.c:2794 +#: gcc.c:2795 #, gcc-internal-format msgid "failed to get process times: %m" msgstr "" -#: gcc.c:2820 +#: gcc.c:2821 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "programs: %s\n" msgid "%s (program %s)" msgstr "ohjelmat: %s\n" -#: gcc.c:3251 opts-common.c:986 opts-common.c:1058 +#: gcc.c:3252 opts-common.c:1019 opts-common.c:1091 #, fuzzy, gcc-internal-format -#| msgid "unrecognized command line option \"%s\"" msgid "unrecognized command line option %qs" msgstr "tuntematon komentorivivalitsin ”%s”" -#: gcc.c:3506 +#: gcc.c:3507 #, gcc-internal-format msgid "%qs is an unknown -save-temps option" msgstr "" -#: gcc.c:3967 +#: gcc.c:3968 #, gcc-internal-format msgid "-pipe ignored because -save-temps specified" msgstr "" -#: gcc.c:4055 +#: gcc.c:4056 #, gcc-internal-format msgid "%<-x %s%> after last input file has no effect" msgstr "" -#: gcc.c:4217 +#: gcc.c:4218 #, gcc-internal-format msgid "unable to locate default linker script %qs in the library search paths" msgstr "" -#: gcc.c:4421 +#: gcc.c:4422 #, gcc-internal-format msgid "switch %qs does not start with %<-%>" msgstr "" -#: gcc.c:4424 +#: gcc.c:4425 #, gcc-internal-format msgid "spec-generated switch is just %<-%>" msgstr "" -#: gcc.c:4515 +#: gcc.c:4516 #, gcc-internal-format, gfc-internal-format msgid "could not open temporary response file %s" msgstr "" -#: gcc.c:4521 +#: gcc.c:4522 #, gcc-internal-format, gfc-internal-format msgid "could not write to temporary response file %s" msgstr "" -#: gcc.c:4527 +#: gcc.c:4528 #, gcc-internal-format, gfc-internal-format msgid "could not close temporary response file %s" msgstr "" -#: gcc.c:4650 +#: gcc.c:4651 #, fuzzy, gcc-internal-format -#| msgid "%s: PCH file was invalid" msgid "spec %qs invalid" msgstr "%s: PCH-tiedosto oli epäkelpo" -#: gcc.c:4799 +#: gcc.c:4800 #, fuzzy, gcc-internal-format -#| msgid "bit-field %qs has invalid type" msgid "spec %qs has invalid %<%%0%c%>" msgstr "bittikentällä %qs on epäkelpo tyyppi" -#: gcc.c:5118 +#: gcc.c:5119 #, fuzzy, gcc-internal-format -#| msgid "bit-field %qs has invalid type" msgid "spec %qs has invalid %<%%W%c%>" msgstr "bittikentällä %qs on epäkelpo tyyppi" -#: gcc.c:5140 +#: gcc.c:5141 #, fuzzy, gcc-internal-format -#| msgid "bit-field %qs has invalid type" msgid "spec %qs has invalid %<%%x%c%>" msgstr "bittikentällä %qs on epäkelpo tyyppi" #. 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:5341 +#: gcc.c:5342 #, gcc-internal-format msgid "spec failure: %<%%*%> has not been initialized by pattern match" msgstr "" -#: gcc.c:5384 +#: gcc.c:5385 #, fuzzy, gcc-internal-format msgid "spec failure: unrecognized spec option %qc" msgstr "tunnistamaton muotomäärite" -#: gcc.c:5446 +#: gcc.c:5447 #, fuzzy, gcc-internal-format -#| msgid "In function %qs" msgid "unknown spec function %qs" msgstr "Funktio %qs" -#: gcc.c:5476 +#: gcc.c:5477 #, fuzzy, gcc-internal-format -#| msgid "too many arguments to function %qs" msgid "error in args to spec function %qs" msgstr "liian monta argumenttia funktiolle %qs" -#: gcc.c:5527 +#: gcc.c:5528 #, gcc-internal-format msgid "malformed spec function name" msgstr "" #. ) -#: gcc.c:5530 +#: gcc.c:5531 #, gcc-internal-format msgid "no arguments for spec function" msgstr "" -#: gcc.c:5549 +#: gcc.c:5550 #, gcc-internal-format msgid "malformed spec function arguments" msgstr "" -#: gcc.c:5810 +#: gcc.c:5811 #, fuzzy, gcc-internal-format -#| msgid "bit-field %qs has invalid type" msgid "braced spec %qs is invalid at %qc" msgstr "bittikentällä %qs on epäkelpo tyyppi" -#: gcc.c:5898 +#: gcc.c:5899 #, gcc-internal-format msgid "braced spec body %qs is invalid" msgstr "" -#: gcc.c:6151 +#: gcc.c:6152 #, gcc-internal-format, gfc-internal-format msgid "%s: could not determine length of compare-debug file %s" msgstr "" -#: gcc.c:6162 +#: gcc.c:6163 #, gcc-internal-format, gfc-internal-format msgid "%s: -fcompare-debug failure (length)" msgstr "" -#: gcc.c:6172 gcc.c:6213 +#: gcc.c:6173 gcc.c:6214 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "%s: could not open compare-debug file %s" msgstr "%s: ei voida avata PCH-tiedostoa: %m\n" -#: gcc.c:6192 gcc.c:6229 +#: gcc.c:6193 gcc.c:6230 #, gcc-internal-format, gfc-internal-format msgid "%s: -fcompare-debug failure" msgstr "" -#: gcc.c:6304 +#: gcc.c:6305 #, fuzzy, gcc-internal-format -#| msgid "pex_init failed: %s" msgid "atexit failed" msgstr "pex_init epäonnistui: %s" -#: gcc.c:6453 +#: gcc.c:6454 #, gcc-internal-format msgid "spec failure: more than one arg to SYSROOT_SUFFIX_SPEC" msgstr "" -#: gcc.c:6477 +#: gcc.c:6478 #, gcc-internal-format msgid "spec failure: more than one arg to SYSROOT_HEADERS_SUFFIX_SPEC" msgstr "" -#: gcc.c:6643 +#: gcc.c:6645 #, fuzzy, gcc-internal-format -#| msgid "unrecognized command line option \"%s\"" msgid "unrecognized command line option %<-%s%>" msgstr "tuntematon komentorivivalitsin ”%s”" #. The error status indicates that only one set of fixed #. headers should be built. -#: gcc.c:6729 +#: gcc.c:6731 #, gcc-internal-format msgid "not configured with sysroot headers suffix" msgstr "ei konfiguroitu sysroot-otsakkeiden loppuliitteellä" -#: gcc.c:6812 +#: gcc.c:6814 #, gcc-internal-format msgid "no input files" msgstr "ei syötetiedostoja" -#: gcc.c:6861 +#: gcc.c:6863 #, gcc-internal-format msgid "cannot specify -o with -c, -S or -E with multiple files" msgstr "" -#: gcc.c:6891 +#: gcc.c:6893 #, gcc-internal-format, gfc-internal-format msgid "%s: %s compiler not installed on this system" msgstr "" -#: gcc.c:6913 +#: gcc.c:6915 #, gcc-internal-format msgid "recompiling with -fcompare-debug" msgstr "" -#: gcc.c:6929 +#: gcc.c:6931 #, gcc-internal-format msgid "during -fcompare-debug recompilation" msgstr "" -#: gcc.c:6938 +#: gcc.c:6940 #, fuzzy, gcc-internal-format msgid "comparing final insns dumps" msgstr "%s: ei voida avata PCH-tiedostoa: %m\n" -#: gcc.c:7044 +#: gcc.c:7046 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "library lib%s not found" msgid "-fuse-linker-plugin, but %s not found" msgstr "kirjastoa lib%s ei löytynyt" -#: gcc.c:7076 +#: gcc.c:7079 #, gcc-internal-format, gfc-internal-format msgid "%s: linker input file unused because linking not done" msgstr "" -#: gcc.c:7117 +#: gcc.c:7120 #, gcc-internal-format, gfc-internal-format msgid "language %s not recognized" msgstr "" -#: gcc.c:7344 +#: gcc.c:7347 #, fuzzy, gcc-internal-format msgid "multilib spec %qs is invalid" msgstr "alustamaton const %qD" -#: gcc.c:7538 +#: gcc.c:7541 #, fuzzy, gcc-internal-format msgid "multilib exclusions %qs is invalid" msgstr "alustamaton const %qD" -#: gcc.c:7602 +#: gcc.c:7605 #, gcc-internal-format msgid "multilib select %qs %qs is invalid" msgstr "" -#: gcc.c:7758 +#: gcc.c:7761 #, fuzzy, gcc-internal-format msgid "multilib select %qs is invalid" msgstr "alustamaton const %qD" -#: gcc.c:7797 +#: gcc.c:7800 #, fuzzy, gcc-internal-format msgid "multilib exclusion %qs is invalid" msgstr "alustamaton const %qD" -#: gcc.c:8003 +#: gcc.c:8006 #, fuzzy, gcc-internal-format -#| msgid "environment variable \"%s\" not defined" msgid "environment variable %qs not defined" msgstr "ympäristömuuttujaa ”%s” ei ole määritelty" -#: gcc.c:8115 gcc.c:8120 +#: gcc.c:8118 gcc.c:8123 #, fuzzy, gcc-internal-format -#| msgid "invalid version number `%s'" msgid "invalid version number %qs" msgstr "virheellinen versionumero ”%s”" -#: gcc.c:8163 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: gcc.c:8166 +#, gcc-internal-format, gfc-internal-format msgid "too few arguments to %%:version-compare" -msgstr "liian vähän argumentteja muotoilulle" +msgstr "liian vähän argumentteja kohteelle %%:version-compare" -#: gcc.c:8169 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: gcc.c:8172 +#, gcc-internal-format, gfc-internal-format msgid "too many arguments to %%:version-compare" -msgstr "liian monta argumenttia muotoilulle" +msgstr "liian monta argumenttia kohteelle %%:version-compare" -#: gcc.c:8210 +#: gcc.c:8213 #, fuzzy, gcc-internal-format msgid "unknown operator %qs in %%:version-compare" -msgstr "liian vähän argumentteja muotoilulle" +msgstr "liian vähän argumentteja kohteelle %%:version-compare" -#: gcc.c:8333 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: gcc.c:8336 +#, gcc-internal-format, gfc-internal-format msgid "too many arguments to %%:compare-debug-dump-opt" -msgstr "liian monta argumenttia muotoilulle" +msgstr "liian monta argumenttia kohteelle %%:compare-debug-dump-opt" -#: gcc.c:8405 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: gcc.c:8408 +#, gcc-internal-format, gfc-internal-format msgid "too many arguments to %%:compare-debug-self-opt" -msgstr "liian monta argumenttia muotoilulle" +msgstr "liian monta argumenttia kohteelle %%:compare-debug-self-opt" -#: gcc.c:8440 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: gcc.c:8443 +#, gcc-internal-format, gfc-internal-format msgid "too few arguments to %%:compare-debug-auxbase-opt" -msgstr "liian vähän argumentteja muotoilulle" +msgstr "liian vähän argumentteja kohteelle %%:compare-debug-auxbase-opt" -#: gcc.c:8443 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: gcc.c:8446 +#, gcc-internal-format, gfc-internal-format msgid "too many arguments to %%:compare-debug-auxbase-opt" -msgstr "liian monta argumenttia muotoilulle" +msgstr "liian monta argumenttia kohteelle %%:compare-debug-auxbase-opt" -#: gcc.c:8450 +#: gcc.c:8453 #, gcc-internal-format, gfc-internal-format msgid "argument to %%:compare-debug-auxbase-opt does not end in .gk" msgstr "" -#: gcc.c:8524 +#: gcc.c:8527 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "too few arguments to function" msgid "too few arguments to %%:replace-extension" msgstr "liian vähän argumentteja funktiolle" @@ -15040,13 +14889,13 @@ msgstr "%s: ei voida avata PCH-tiedostoa: %m\n" msgid "can%'t write padding to PCH file: %m" msgstr "%s: ei voida avata PCH-tiedostoa: %m\n" -#: ggc-common.c:615 ggc-common.c:623 ggc-common.c:630 ggc-common.c:633 -#: ggc-common.c:643 ggc-common.c:646 ggc-page.c:2439 +#: ggc-common.c:681 ggc-common.c:689 ggc-common.c:696 ggc-common.c:699 +#: ggc-common.c:709 ggc-common.c:712 ggc-page.c:2439 #, fuzzy, gcc-internal-format msgid "can%'t read PCH file: %m" msgstr "%s: ei voida avata PCH-tiedostoa: %m\n" -#: ggc-common.c:638 +#: ggc-common.c:704 #, gcc-internal-format msgid "had to relocate PCH" msgstr "" @@ -15058,7 +14907,6 @@ msgstr "" #: ggc-page.c:2327 ggc-page.c:2333 #, fuzzy, gcc-internal-format -#| msgid "can't write PCH file" msgid "can%'t write PCH file" msgstr "PCH-tiedostoa ei voida kirjoittaa" @@ -15105,7 +14953,7 @@ msgstr "ei palautuslausetta funktiossa, joka palauttaa ei-tyhjän" #: gimplify.c:5294 #, gcc-internal-format, gfc-internal-format msgid "invalid lvalue in asm output %d" -msgstr "" +msgstr "virheellinen lvalue asm-tulosteessa %d" #: gimplify.c:5410 #, gcc-internal-format, gfc-internal-format @@ -15119,7 +14967,6 @@ msgstr "" #: gimplify.c:5926 #, fuzzy, gcc-internal-format -#| msgid "register variable %qD used in nested function" msgid "threadprivate variable %qE used in untied task" msgstr "sisäkkäisessä funktiossa käytetty rekisterimuuttujaa %qD" @@ -15200,7 +15047,7 @@ msgstr "" #. Fatal error here. We do not want to support compiling ltrans units with #. different version of compiler or different flags than the WPA unit, so #. this should never happen. -#: ipa-reference.c:1148 +#: ipa-reference.c:1146 #, gcc-internal-format msgid "ipa reference summary is missing in ltrans unit" msgstr "" @@ -15332,19 +15179,19 @@ msgid "alignment of %qD is bigger than original declaration" msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa" #: lto-symtab.c:396 lto-symtab.c:489 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "previously declared here" -msgstr "%Jviimeksi käytetty täällä" +msgstr "esitelty aiemmin täällä" #: lto-symtab.c:470 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "variable %qD redeclared as function" -msgstr "kenttä %qs esitelty funktiona" +msgstr "muuttuja %qD esitelty uudelleen funktiona" #: lto-symtab.c:477 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "function %qD redeclared as variable" -msgstr "%Jsisäänrakennettu funktio %qD esitelty ei-funktiona" +msgstr "funktio %qD esitelty uudelleen muuttujana" #: omp-low.c:1849 #, gcc-internal-format @@ -15392,29 +15239,27 @@ msgstr "" msgid "invalid branch to/from an OpenMP structured block" msgstr "" -#: opts-common.c:997 +#: opts-common.c:1030 #, fuzzy, gcc-internal-format msgid "command line option %qs is not supported by this configuration" msgstr "#pragma redefine_extname ei ole tuettu tällä kohteella" -#: opts-common.c:1007 +#: opts-common.c:1040 #, fuzzy, gcc-internal-format msgid "missing argument to %qs" msgstr "liikaa argumentteja funktiolle %s %q+#D" -#: opts-common.c:1013 +#: opts-common.c:1046 #, fuzzy, gcc-internal-format -#| msgid "first argument of %q+D should be %<int%>" msgid "argument to %qs should be a non-negative integer" msgstr "%q+D:n ensimmäisen argumentin pitäisi olla %<int%>" -#: opts-common.c:1028 +#: opts-common.c:1061 #, fuzzy, gcc-internal-format -#| msgid "unrecognized command line option \"%s\"" msgid "unrecognized argument in option %qs" msgstr "tuntematon komentorivivalitsin ”%s”" -#: opts-common.c:1044 +#: opts-common.c:1077 #, fuzzy, gcc-internal-format msgid "valid arguments to %qs are: %s" msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton" @@ -15426,26 +15271,24 @@ msgstr "#pragma redefine_extname ei ole tuettu tällä kohteella" #. 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 "#pragma redefine_extname ei ole tuettu tällä kohteella" +msgstr "komentorivivalitsin %qs on kelvollinen kohteelle %s, mutta ei kohteelle %s" #: opts-global.c:136 #, gcc-internal-format, gfc-internal-format msgid "unrecognized command line option \"%s\"" -msgstr "tuntematon komentorivivalitsin ”%s”" +msgstr "tunnistamaton komentorivivalitsin ”%s”" #: opts-global.c:389 -#, fuzzy, gcc-internal-format -#| msgid "unrecognized command line option \"%s\"" +#, gcc-internal-format msgid "unrecognized command line option %<-fdump-%s%>" -msgstr "tuntematon komentorivivalitsin ”%s”" +msgstr "tunnistamaton komentorivivalitsin %<-fdump-%s%>" #: opts-global.c:394 -#, fuzzy, gcc-internal-format -#| msgid "unrecognized command line option \"%s\"" +#, gcc-internal-format msgid "unrecognized command line option %<-fopt-info-%s%>" -msgstr "tuntematon komentorivivalitsin ”%s”" +msgstr "tunnistamaton komentorivivalitsin %<-fopt-info-%s%>" #: opts-global.c:415 opts-global.c:423 #, gcc-internal-format @@ -15453,9 +15296,9 @@ msgid "plugin support is disabled; configure with --enable-plugin" msgstr "" #: opts-global.c:447 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "unrecognized register name %qs" -msgstr "tunnistamaton muotomäärite" +msgstr "tunnistamaton rekisterinimi %qs" #: opts.c:92 #, gcc-internal-format @@ -15472,139 +15315,137 @@ msgstr "" msgid "%<-femit-struct-debug-detailed=dir:...%> must allow at least as much as %<-femit-struct-debug-detailed=ind:...%>" msgstr "" -#: opts.c:542 +#: opts.c:544 #, gcc-internal-format msgid "argument to %<-O%> should be a non-negative integer, %<g%>, %<s%> or %<fast%>" msgstr "" -#: opts.c:669 +#: opts.c:672 #, gcc-internal-format msgid "section anchors must be disabled when unit-at-a-time is disabled" msgstr "" -#: opts.c:673 +#: opts.c:676 #, gcc-internal-format msgid "toplevel reorder must be disabled when unit-at-a-time is disabled" msgstr "" -#: opts.c:679 +#: opts.c:682 #, fuzzy, gcc-internal-format msgid "transactional memory is not supported with non-call exceptions" msgstr "#pragma redefine_extname ei ole tuettu tällä kohteella" -#: opts.c:694 +#: opts.c:697 #, gcc-internal-format msgid "section anchors must be disabled when toplevel reorder is disabled" msgstr "" -#: opts.c:729 config/darwin.c:3061 config/sh/sh.c:936 +#: opts.c:732 config/darwin.c:3061 config/sh/sh.c:933 #, gcc-internal-format msgid "-freorder-blocks-and-partition does not work with exceptions on this architecture" msgstr "" -#: opts.c:744 config/sh/sh.c:944 +#: opts.c:747 config/sh/sh.c:941 #, gcc-internal-format msgid "-freorder-blocks-and-partition does not support unwind info on this architecture" msgstr "" -#: opts.c:761 config/pa/pa.c:526 +#: opts.c:764 config/pa/pa.c:526 #, gcc-internal-format msgid "-freorder-blocks-and-partition does not work on this architecture" msgstr "" -#: opts.c:797 +#: opts.c:800 #, gcc-internal-format msgid "-fno-fat-lto-objects are supported only with linker plugin." msgstr "" -#: opts.c:805 +#: opts.c:808 #, gcc-internal-format msgid "only one -flto-partition value can be specified" msgstr "" -#: opts.c:816 +#: opts.c:819 #, fuzzy, gcc-internal-format -#| msgid "weakref is not supported in this configuration" msgid "%<-fsplit-stack%> is not supported by this compiler configuration" msgstr "weakref ei ole tuettu tässä konfiguraatiossa" -#: opts.c:1193 +#: opts.c:1196 #, gcc-internal-format msgid "unrecognized include_flags 0x%x passed to print_specific_help" msgstr "" -#: opts.c:1373 +#: opts.c:1376 #, gcc-internal-format msgid "--help argument %q.*s is ambiguous, please be more specific" msgstr "" -#: opts.c:1382 +#: opts.c:1385 #, fuzzy, gcc-internal-format -#| msgid "unrecognized command line option \"%s\"" msgid "unrecognized argument to --help= option: %q.*s" msgstr "tuntematon komentorivivalitsin ”%s”" -#: opts.c:1547 +#: opts.c:1550 #, gcc-internal-format, gfc-internal-format msgid "structure alignment must be a small power of two, not %d" msgstr "" -#: opts.c:1664 +#: opts.c:1667 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "unknown stack check parameter \"%s\"" msgstr "tuntematon konetila %qs" -#: opts.c:1701 +#: opts.c:1704 #, gcc-internal-format, gfc-internal-format msgid "dwarf version %d is not supported" msgstr "dwarfin versio %d ei ole tuettu" -#: opts.c:1791 +#: opts.c:1794 #, gcc-internal-format, gfc-internal-format msgid "%s: --param arguments should be of the form NAME=VALUE" -msgstr "" +msgstr "%s: --param-argumenttien tulee olla muotoa NIMI=ARVO" -#: opts.c:1797 +#: opts.c:1800 #, gcc-internal-format msgid "invalid --param value %qs" -msgstr "" +msgstr "virheellinen --param-arvo %qs" -#: opts.c:1915 +#: opts.c:1918 #, gcc-internal-format msgid "target system does not support debug output" msgstr "" -#: opts.c:1924 +#: opts.c:1927 #, gcc-internal-format, gfc-internal-format msgid "debug format \"%s\" conflicts with prior selection" msgstr "" -#: opts.c:1940 +#: opts.c:1943 #, gcc-internal-format, gfc-internal-format msgid "unrecognised debug output level \"%s\"" msgstr "" -#: opts.c:1942 +#: opts.c:1945 #, gcc-internal-format, gfc-internal-format msgid "debug output level %s is too high" msgstr "" -#: opts.c:1962 +#: opts.c:1965 #, gcc-internal-format msgid "getting core file size maximum limit: %m" msgstr "" -#: opts.c:1965 +#: opts.c:1968 #, gcc-internal-format msgid "setting core file size limit to maximum: %m" msgstr "" -#: opts.c:2010 +#: opts.c:2013 #, gcc-internal-format, gfc-internal-format msgid "unrecognized gcc debugging option: %c" -msgstr "" +msgstr "tunnistamaton gcc:n vianjäljitysvalitsin: %c" -#: opts.c:2036 +#: opts.c:2039 #, gcc-internal-format, gfc-internal-format msgid "-Werror=%s: no option -%s" msgstr "" @@ -15612,18 +15453,18 @@ msgstr "" #: params.c:120 #, gcc-internal-format msgid "minimum value of parameter %qs is %u" -msgstr "" +msgstr "parametrin %qs minimiarvo on %u" #: params.c:125 #, gcc-internal-format msgid "maximum value of parameter %qs is %u" -msgstr "" +msgstr "parametrin %qs maksimiarvo on %u" #. If we didn't find this parameter, issue an error message. #: params.c:135 #, gcc-internal-format msgid "invalid parameter %qs" -msgstr "" +msgstr "virheellinen parametri %qs" #: passes.c:804 #, fuzzy, gcc-internal-format @@ -15642,7 +15483,6 @@ msgstr "" #: passes.c:816 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "no class name specified with %qs" msgid "unknown pass %s specified in -fdisable" msgstr "luokkanimeä ei ole annettu %qs:n kanssa" @@ -15866,15 +15706,14 @@ msgid "can%'t use %qs as a fixed register" msgstr "" #: reginfo.c:750 config/ia64/ia64.c:5897 config/ia64/ia64.c:5904 -#: config/pa/pa.c:428 config/pa/pa.c:435 config/sh/sh.c:9362 -#: config/sh/sh.c:9369 config/spu/spu.c:4908 config/spu/spu.c:4915 +#: config/pa/pa.c:428 config/pa/pa.c:435 config/sh/sh.c:9359 +#: config/sh/sh.c:9366 config/spu/spu.c:4908 config/spu/spu.c:4915 #, gcc-internal-format, gfc-internal-format msgid "unknown register name: %s" msgstr "" #: reginfo.c:763 #, fuzzy, gcc-internal-format -#| msgid "address of global register variable %qD requested" msgid "stack register used for global register variable" msgstr "halutaan globaalin rekisterimuuttujan %qD osoite" @@ -15890,7 +15729,6 @@ msgstr "" #: reginfo.c:777 #, fuzzy, gcc-internal-format -#| msgid "conflicting types for %q+D" msgid "conflicts with %qD" msgstr "ristiriitaiset tyypit %qD:lle" @@ -15949,42 +15787,42 @@ msgstr "" msgid "output operand is constant in %<asm%>" msgstr "" -#: rtl.c:738 +#: rtl.c:742 #, gcc-internal-format, gfc-internal-format msgid "RTL check: access of elt %d of '%s' with last elt %d in %s, at %s:%d" msgstr "" -#: rtl.c:748 +#: rtl.c:752 #, gcc-internal-format, gfc-internal-format msgid "RTL check: expected elt %d type '%c', have '%c' (rtx %s) in %s, at %s:%d" msgstr "" -#: rtl.c:758 +#: rtl.c:762 #, gcc-internal-format, gfc-internal-format msgid "RTL check: expected elt %d type '%c' or '%c', have '%c' (rtx %s) in %s, at %s:%d" msgstr "" -#: rtl.c:767 +#: rtl.c:771 #, gcc-internal-format, gfc-internal-format msgid "RTL check: expected code '%s', have '%s' in %s, at %s:%d" msgstr "" -#: rtl.c:777 +#: rtl.c:781 #, gcc-internal-format, gfc-internal-format msgid "RTL check: expected code '%s' or '%s', have '%s' in %s, at %s:%d" msgstr "" -#: rtl.c:804 +#: rtl.c:808 #, 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.c:814 +#: rtl.c:818 #, gcc-internal-format, gfc-internal-format msgid "RTL check: access of elt %d of vector with last elt %d in %s, at %s:%d" msgstr "" -#: rtl.c:825 +#: rtl.c:829 #, gcc-internal-format, gfc-internal-format msgid "RTL flag check: %s used with unexpected rtx code '%s' in %s, at %s:%d" msgstr "" @@ -16115,9 +15953,9 @@ msgid "packed attribute causes inefficient alignment for %q+D" msgstr "" #: stor-layout.c:1156 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "packed attribute is unnecessary for %q+D" -msgstr "%qs-attribuuttia ei huomioida %qs:lle" +msgstr "pakattu attribuutti on tarpeeton %q+D:lle" #: stor-layout.c:1173 #, gcc-internal-format @@ -16126,7 +15964,6 @@ msgstr "" #: stor-layout.c:1235 #, fuzzy, gcc-internal-format -#| msgid "Warn about packed bit-fields whose offset changed in GCC 4.4" msgid "offset of packed bit-field %qD has changed in GCC 4.4" msgstr "Varoita pakatuista bittikentistä, joiden siirrososoite vaihtui GCC 4.4:ssä" @@ -16136,24 +15973,24 @@ msgid "padding struct size to alignment boundary" msgstr "" #: stor-layout.c:1569 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "packed attribute causes inefficient alignment for %qE" -msgstr "%qs-attribuuttia ei huomioida %qs:lle" +msgstr "pakattu attribuutti aiheuttaa tehottoman kohdistuksen %qE:lle" #: stor-layout.c:1573 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "packed attribute is unnecessary for %qE" -msgstr "%qs-attribuuttia ei huomioida %qs:lle" +msgstr "pakattu attribuutti on tarpeeton %qE:lle" #: stor-layout.c:1579 #, gcc-internal-format msgid "packed attribute causes inefficient alignment" -msgstr "" +msgstr "pakattu attribuutti aiheuttaa tehottoman kohdistuksen" #: stor-layout.c:1581 #, gcc-internal-format msgid "packed attribute is unnecessary" -msgstr "" +msgstr "pakattu attribuutti on tarpeeton" #: stor-layout.c:2293 #, gcc-internal-format @@ -16167,7 +16004,6 @@ msgstr "" #: symtab.c:586 #, fuzzy, gcc-internal-format -#| msgid "function return type cannot be function" msgid "function symbol is not function" msgstr "funktion paluuarvon tyyppi ei voi olla funktio" @@ -16253,13 +16089,11 @@ msgstr "#pragma extern_prefix ei ole tuettu tällä kohteella" #: tlink.c:489 #, fuzzy, gcc-internal-format -#| msgid "removing .rpo file" msgid "removing .rpo file: %m" msgstr "poistetaan .rpo-tiedosto" #: tlink.c:491 #, fuzzy, gcc-internal-format -#| msgid "renaming .rpo file" msgid "renaming .rpo file: %m" msgstr "nimetään uudelleen .rpo-tiedosto" @@ -16443,7 +16277,7 @@ msgstr "rajat määrittelemättömän taulukon epäkelpo käyttö" msgid "%<transaction_may_cancel_outer%> function call not within outer transaction or %<transaction_may_cancel_outer%>" msgstr "" -#: trans-mem.c:676 trans-mem.c:4569 +#: trans-mem.c:676 trans-mem.c:4570 #, gcc-internal-format msgid "unsafe function call %qD within atomic transaction" msgstr "" @@ -16458,7 +16292,7 @@ msgstr "" msgid "unsafe indirect function call within atomic transaction" msgstr "" -#: trans-mem.c:694 trans-mem.c:4502 +#: trans-mem.c:694 trans-mem.c:4503 #, gcc-internal-format msgid "unsafe function call %qD within %<transaction_safe%> function" msgstr "" @@ -16473,7 +16307,7 @@ msgstr "" msgid "unsafe indirect function call within %<transaction_safe%> function" msgstr "" -#: trans-mem.c:719 trans-mem.c:4541 +#: trans-mem.c:719 trans-mem.c:4542 #, gcc-internal-format msgid "asm not allowed in atomic transaction" msgstr "" @@ -16495,7 +16329,6 @@ msgstr "" #: trans-mem.c:743 #, fuzzy, gcc-internal-format -#| msgid "pointer to a function used in subtraction" msgid "outer transaction in transaction" msgstr "vähennyslaskussa käytetty osoitinta funktioon" @@ -16509,7 +16342,7 @@ msgstr "" msgid "outer transaction in %<transaction_safe%> function" msgstr "" -#: trans-mem.c:4169 +#: trans-mem.c:4170 #, fuzzy, gcc-internal-format msgid "%Kasm not allowed in %<transaction_safe%> function" msgstr "%Jvanhanmallinen funktiomäärittely" @@ -16559,7 +16392,7 @@ msgstr "" msgid "MODIFY_EXPR not expected while having tuples" msgstr "" -#: tree-cfg.c:2613 tree-ssa.c:879 +#: tree-cfg.c:2613 tree-ssa.c:876 #, gcc-internal-format msgid "address taken, but ADDRESSABLE bit not set" msgstr "" @@ -16630,24 +16463,24 @@ msgid "invalid operands to array reference" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" #: tree-cfg.c:2862 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type mismatch in array reference" -msgstr "ehtolausekkeessa on tyyppiristiriita" +msgstr "tyyppitäsmäämättömyys taulukkoviitteessä" #: tree-cfg.c:2871 #, gcc-internal-format msgid "type mismatch in array range reference" -msgstr "" +msgstr "tyyppitäsmäämättömyys taulukkoalueviitteessä" #: tree-cfg.c:2882 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type mismatch in real/imagpart reference" -msgstr "ehtolausekkeessa on tyyppiristiriita" +msgstr "tyyppitäsmäämättömyys real/imagpart-viitteessä" #: tree-cfg.c:2892 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type mismatch in component reference" -msgstr "ehtolausekkeessa on tyyppiristiriita" +msgstr "tyyppitäsmäämättömyys komponenttiviitteessä" #: tree-cfg.c:2909 #, gcc-internal-format @@ -16656,7 +16489,6 @@ msgstr "" #: tree-cfg.c:2916 #, fuzzy, gcc-internal-format -#| msgid "cast from pointer to integer of different size" msgid "conversion of register to a different size" msgstr "tyyppimuunnos osoittimesta erikokoiseen kokonaislukuun" @@ -16716,9 +16548,9 @@ msgid "LHS in noreturn call" msgstr "" #: tree-cfg.c:3077 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid conversion in gimple call" -msgstr "virheellinen versionumero ”%s”" +msgstr "virheellinen muunnos gimple-kutsussa" #: tree-cfg.c:3086 #, fuzzy, gcc-internal-format @@ -16767,7 +16599,6 @@ msgstr "epäkelpo totuusarvolauseke" #: tree-cfg.c:3203 #, fuzzy, gcc-internal-format -#| msgid "Warn about comparison of different enum types" msgid "bogus comparison result type" msgstr "Varoita eri enum-tyyppien vertailusta" @@ -16782,9 +16613,9 @@ msgid "invalid operand in unary operation" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" #: tree-cfg.c:3263 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid types in nop conversion" -msgstr "void-lausekkeen epäkelpo käyttö" +msgstr "virheelliset tyypit nop-muunnokselle" #: tree-cfg.c:3278 #, fuzzy, gcc-internal-format @@ -16797,14 +16628,14 @@ msgid "invalid types in fixed-point conversion" msgstr "void-lausekkeen epäkelpo käyttö" #: tree-cfg.c:3307 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid types in conversion to floating point" -msgstr "epäkelpo %<restrict%>-avainsanan käyttö" +msgstr "virheellisiä tyyppejä muunnoksessa liukuluvuksi" #: tree-cfg.c:3322 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid types in conversion to integer" -msgstr "epäkelpo %<restrict%>-avainsanan käyttö" +msgstr "virheellisiä tyyppejä muunnoksessa kokonaisluvuksi" #: tree-cfg.c:3356 #, fuzzy, gcc-internal-format @@ -16878,7 +16709,6 @@ msgstr "epäkelvot operandit binääriselle %s-operaatiolle" #: tree-cfg.c:3693 #, fuzzy, gcc-internal-format -#| msgid "type mismatch in conditional expression" msgid "type mismatch in widening multiply-accumulate expression" msgstr "ehtolausekkeessa on tyyppiristiriita" @@ -16963,9 +16793,9 @@ msgid "invalid conversion in return statement" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" #: tree-cfg.c:4074 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "goto destination is neither a label nor a pointer" -msgstr "indeksoitu arvo ei ole taulukko eikä osoitin" +msgstr "goto-kohde ei ole nimiö eikä osoitin" #: tree-cfg.c:4093 #, fuzzy, gcc-internal-format @@ -17047,10 +16877,10 @@ msgstr "virheellinen %%H-arvo" msgid "incompatible types in PHI argument %u" msgstr "yhteensopimattomat tyypit sijoituksessa" -#: tree-cfg.c:4433 tree-cfg.c:4727 -#, fuzzy, gcc-internal-format +#: tree-cfg.c:4433 tree-cfg.c:4738 +#, gcc-internal-format msgid "verify_gimple failed" -msgstr "verify_flow_info epäonnistui" +msgstr "verify_gimple epäonnistui" #: tree-cfg.c:4495 #, gcc-internal-format @@ -17062,150 +16892,148 @@ msgstr "" msgid "location references block not in block tree" msgstr "" -#: tree-cfg.c:4594 +#: tree-cfg.c:4605 #, gcc-internal-format msgid "gimple_bb (phi) is set to a wrong basic block" msgstr "" -#: tree-cfg.c:4603 +#: tree-cfg.c:4614 #, fuzzy, gcc-internal-format -#| msgid "from this location" msgid "PHI node with location" msgstr "tästä kohdasta" -#: tree-cfg.c:4614 tree-cfg.c:4663 +#: tree-cfg.c:4625 tree-cfg.c:4674 #, gcc-internal-format msgid "incorrect sharing of tree nodes" msgstr "" -#: tree-cfg.c:4622 +#: tree-cfg.c:4633 #, gcc-internal-format msgid "virtual PHI with argument locations" msgstr "" -#: tree-cfg.c:4651 +#: tree-cfg.c:4662 #, gcc-internal-format msgid "gimple_bb (stmt) is set to a wrong basic block" -msgstr "" +msgstr "gimple_bb (stmt) on asetettu väärään peruslohkoon" -#: tree-cfg.c:4687 +#: tree-cfg.c:4698 #, gcc-internal-format msgid "in statement" msgstr "" -#: tree-cfg.c:4702 +#: tree-cfg.c:4713 #, gcc-internal-format msgid "statement marked for throw, but doesn%'t" msgstr "" -#: tree-cfg.c:4709 +#: tree-cfg.c:4720 #, gcc-internal-format msgid "statement marked for throw in middle of block" msgstr "" -#: tree-cfg.c:4751 +#: tree-cfg.c:4762 #, gcc-internal-format msgid "ENTRY_BLOCK has IL associated with it" msgstr "" -#: tree-cfg.c:4757 +#: tree-cfg.c:4768 #, gcc-internal-format msgid "EXIT_BLOCK has IL associated with it" msgstr "" -#: tree-cfg.c:4764 +#: tree-cfg.c:4775 #, gcc-internal-format, gfc-internal-format msgid "fallthru to exit from bb %d" msgstr "" -#: tree-cfg.c:4788 +#: tree-cfg.c:4799 #, gcc-internal-format msgid "nonlocal label " msgstr "ei-paikallinen nimiö " -#: tree-cfg.c:4797 +#: tree-cfg.c:4808 #, gcc-internal-format msgid "EH landing pad label " msgstr "" -#: tree-cfg.c:4806 tree-cfg.c:4815 tree-cfg.c:4840 +#: tree-cfg.c:4817 tree-cfg.c:4826 tree-cfg.c:4851 #, gcc-internal-format msgid "label " msgstr "nimiö " -#: tree-cfg.c:4830 +#: tree-cfg.c:4841 #, gcc-internal-format, gfc-internal-format msgid "control flow in the middle of basic block %d" msgstr "" -#: tree-cfg.c:4863 +#: tree-cfg.c:4874 #, gcc-internal-format, gfc-internal-format msgid "fallthru edge after a control statement in bb %d" msgstr "" -#: tree-cfg.c:4876 +#: tree-cfg.c:4887 #, gcc-internal-format, gfc-internal-format msgid "true/false edge after a non-GIMPLE_COND in bb %d" msgstr "" -#: tree-cfg.c:4899 tree-cfg.c:4921 tree-cfg.c:4938 tree-cfg.c:5007 +#: tree-cfg.c:4910 tree-cfg.c:4932 tree-cfg.c:4949 tree-cfg.c:5018 #, gcc-internal-format, gfc-internal-format msgid "wrong outgoing edge flags at end of bb %d" msgstr "" -#: tree-cfg.c:4909 +#: tree-cfg.c:4920 #, gcc-internal-format, gfc-internal-format msgid "explicit goto at end of bb %d" msgstr "" -#: tree-cfg.c:4943 +#: tree-cfg.c:4954 #, gcc-internal-format, gfc-internal-format msgid "return edge does not point to exit in bb %d" msgstr "" -#: tree-cfg.c:4973 +#: tree-cfg.c:4984 #, gcc-internal-format msgid "found default case not at the start of case vector" msgstr "" -#: tree-cfg.c:4981 +#: tree-cfg.c:4992 #, gcc-internal-format msgid "case labels not sorted: " msgstr "" -#: tree-cfg.c:4998 +#: tree-cfg.c:5009 #, gcc-internal-format, gfc-internal-format msgid "extra outgoing edge %d->%d" msgstr "" -#: tree-cfg.c:5021 +#: tree-cfg.c:5032 #, gcc-internal-format, gfc-internal-format msgid "missing edge %i->%i" msgstr "" -#: tree-cfg.c:7803 -#, fuzzy, gcc-internal-format +#: tree-cfg.c:7814 +#, gcc-internal-format msgid "%<noreturn%> function does return" -msgstr "%<noreturn%>-funktio palauttaa ei-void-arvon" +msgstr "%<noreturn%>-funktio palaa" -#: tree-cfg.c:7823 +#: tree-cfg.c:7834 #, gcc-internal-format msgid "control reaches end of non-void function" msgstr "ei-void-tyyppisen funktion loppu saavutettu" -#: tree-cfg.c:7963 +#: tree-cfg.c:7974 #, gcc-internal-format msgid "ignoring return value of %qD, declared with attribute warn_unused_result" msgstr "%qD:n paluuarvoa ei huomioida, esitelty attribuutilla warn_unused_result" -#: tree-cfg.c:7968 +#: tree-cfg.c:7979 #, gcc-internal-format msgid "ignoring return value of function declared with attribute warn_unused_result" msgstr "attribuutilla warn_unused_result esitellyn funktion paluuarvoa ei huomioida" #: tree-diagnostic.c:202 #, fuzzy, gcc-internal-format -#| msgid "redefinition of %q+D" msgid "in definition of macro %qs" msgstr "%q+D määritelty uudelleen" @@ -17214,122 +17042,122 @@ msgstr "%q+D määritelty uudelleen" msgid "in expansion of macro %qs" msgstr "" -#: tree-eh.c:4368 +#: tree-eh.c:4396 #, gcc-internal-format, gfc-internal-format msgid "BB %i has multiple EH edges" msgstr "" -#: tree-eh.c:4380 +#: tree-eh.c:4408 #, gcc-internal-format, gfc-internal-format msgid "BB %i can not throw but has an EH edge" msgstr "" -#: tree-eh.c:4388 +#: tree-eh.c:4416 #, gcc-internal-format, gfc-internal-format msgid "BB %i last statement has incorrectly set lp" msgstr "" -#: tree-eh.c:4394 +#: tree-eh.c:4422 #, gcc-internal-format, gfc-internal-format msgid "BB %i is missing an EH edge" msgstr "" -#: tree-eh.c:4400 +#: tree-eh.c:4428 #, gcc-internal-format, gfc-internal-format msgid "Incorrect EH edge %i->%i" msgstr "" -#: tree-eh.c:4434 tree-eh.c:4453 +#: tree-eh.c:4462 tree-eh.c:4481 #, gcc-internal-format, gfc-internal-format msgid "BB %i is missing an edge" msgstr "" -#: tree-eh.c:4470 +#: tree-eh.c:4498 #, gcc-internal-format, gfc-internal-format msgid "BB %i too many fallthru edges" msgstr "" -#: tree-eh.c:4479 +#: tree-eh.c:4507 #, gcc-internal-format, gfc-internal-format msgid "BB %i has incorrect edge" msgstr "" -#: tree-eh.c:4485 +#: tree-eh.c:4513 #, gcc-internal-format, gfc-internal-format msgid "BB %i has incorrect fallthru edge" msgstr "" -#: tree-inline.c:3012 +#: tree-inline.c:3022 #, gcc-internal-format msgid "function %q+F can never be copied because it receives a non-local goto" -msgstr "funktiota %q+F ei voi koskaan kopioida, koska se vastaanottaa ei-paikallisen goton" +msgstr "funktiota %q+F ei voi koskaan kopioida, koska se vastaanottaa ei-paikallisen goto-käskyn" -#: tree-inline.c:3026 +#: tree-inline.c:3036 #, gcc-internal-format msgid "function %q+F can never be copied because it saves address of local label in a static variable" msgstr "funktiota %q+F ei voi koskaan kopioida, koska se tallentaa paikallisen nimiön osoitteen staattiseen muuttujaan" -#: tree-inline.c:3066 +#: tree-inline.c:3076 #, fuzzy, gcc-internal-format msgid "function %q+F can never be inlined because it uses alloca (override using the always_inline attribute)" msgstr "%Jfunktio %qF ei voi koskaan olla avoin, koska se käyttää avoimille funktioille sopimattomia attribuutteja" -#: tree-inline.c:3080 +#: tree-inline.c:3090 #, fuzzy, gcc-internal-format msgid "function %q+F can never be inlined because it uses setjmp" msgstr "%Jfunktio %qF ei voi koskaan olla avoin, koska ne on poistettu käytöstä -fno-inline:lla" -#: tree-inline.c:3094 +#: tree-inline.c:3104 #, fuzzy, gcc-internal-format msgid "function %q+F can never be inlined because it uses variable argument lists" msgstr "%Jfunktio %qF ei voi koskaan olla avoin, koska se käyttää avoimille funktioille sopimattomia attribuutteja" -#: tree-inline.c:3106 +#: tree-inline.c:3116 #, fuzzy, gcc-internal-format msgid "function %q+F can never be inlined because it uses setjmp-longjmp exception handling" msgstr "%Jfunktio %qF ei voi koskaan olla avoin, koska se käyttää avoimille funktioille sopimattomia attribuutteja" -#: tree-inline.c:3114 +#: tree-inline.c:3124 #, fuzzy, gcc-internal-format msgid "function %q+F can never be inlined because it uses non-local goto" msgstr "%Jfunktio %qF ei voi koskaan olla avoin, koska ne on poistettu käytöstä -fno-inline:lla" -#: tree-inline.c:3126 +#: tree-inline.c:3136 #, fuzzy, gcc-internal-format msgid "function %q+F can never be inlined because it uses __builtin_return or __builtin_apply_args" msgstr "%Jfunktio %qF ei voi koskaan olla avoin, koska se käyttää avoimille funktioille sopimattomia attribuutteja" -#: tree-inline.c:3146 +#: tree-inline.c:3156 #, fuzzy, gcc-internal-format msgid "function %q+F can never be inlined because it contains a computed goto" msgstr "%Jfunktio %qF ei voi koskaan olla avoin, koska ne on poistettu käytöstä -fno-inline:lla" -#: tree-inline.c:3249 +#: tree-inline.c:3259 #, fuzzy, gcc-internal-format msgid "function %q+F can never be inlined because it is suppressed using -fno-inline" msgstr "%Jfunktio %qF ei voi koskaan olla avoin, koska ne on poistettu käytöstä -fno-inline:lla" -#: tree-inline.c:3257 +#: tree-inline.c:3267 #, fuzzy, gcc-internal-format msgid "function %q+F can never be inlined because it uses attributes conflicting with inlining" msgstr "%Jfunktio %qF ei voi koskaan olla avoin, koska se käyttää avoimille funktioille sopimattomia attribuutteja" -#: tree-inline.c:3842 +#: tree-inline.c:3852 #, gcc-internal-format msgid "inlining failed in call to always_inline %q+F: %s" msgstr "" -#: tree-inline.c:3844 tree-inline.c:3859 +#: tree-inline.c:3854 tree-inline.c:3869 #, gcc-internal-format msgid "called from here" -msgstr "" +msgstr "kutsuttu täältä" -#: tree-inline.c:3857 +#: tree-inline.c:3867 #, gcc-internal-format msgid "inlining failed in call to %q+F: %s" msgstr "" -#: tree-into-ssa.c:3209 tree-outof-ssa.c:774 tree-outof-ssa.c:831 +#: tree-into-ssa.c:3226 tree-outof-ssa.c:774 tree-outof-ssa.c:831 #: tree-ssa-coalesce.c:934 tree-ssa-live.c:1282 #, gcc-internal-format msgid "SSA corruption" @@ -17360,6 +17188,16 @@ msgstr "" msgid "unimplemented functionality" msgstr "" +#: tree-ssa-loop-niter.c:2557 +#, fuzzy, gcc-internal-format +msgid "iteration %E invokes undefined behavior" +msgstr "operaatio %qE:lle voi olla määrittelemätön" + +#: tree-ssa-loop-niter.c:2559 +#, gcc-internal-format +msgid "containing loop" +msgstr "" + #: tree-ssa-operands.c:975 #, gcc-internal-format msgid "virtual definition of statement not up-to-date" @@ -17387,7 +17225,6 @@ msgstr "" #: tree-ssa-operands.c:1023 #, fuzzy, gcc-internal-format -#| msgid "assertion missing after %qs" msgid "use operand missing for stmt" msgstr "väittämä puuttuu %qs:n jälkeen" @@ -17396,145 +17233,145 @@ msgstr "väittämä puuttuu %qs:n jälkeen" msgid "stmt volatile flag not up-to-date" msgstr "" -#: tree-ssa-uninit.c:1943 tree-ssa.c:1668 +#: tree-ssa-uninit.c:1946 tree-ssa.c:1665 #, gcc-internal-format msgid "%qD may be used uninitialized in this function" msgstr "" -#: tree-ssa.c:625 +#: tree-ssa.c:622 #, gcc-internal-format msgid "expected an SSA_NAME object" msgstr "" -#: tree-ssa.c:631 +#: tree-ssa.c:628 #, gcc-internal-format msgid "found an SSA_NAME that had been released into the free pool" msgstr "" -#: tree-ssa.c:638 +#: tree-ssa.c:635 #, gcc-internal-format msgid "type mismatch between an SSA_NAME and its symbol" msgstr "" -#: tree-ssa.c:644 +#: tree-ssa.c:641 #, gcc-internal-format msgid "found a virtual definition for a GIMPLE register" msgstr "löytyi virtuaalimäärittely GIMPLE-rekisterille" -#: tree-ssa.c:650 +#: tree-ssa.c:647 #, gcc-internal-format msgid "virtual SSA name for non-VOP decl" msgstr "" -#: tree-ssa.c:656 +#: tree-ssa.c:653 #, fuzzy, gcc-internal-format msgid "found a real definition for a non-register" msgstr "funktion määrittely esitelty %<register%>:ksi" -#: tree-ssa.c:663 +#: tree-ssa.c:660 #, gcc-internal-format msgid "found a default name with a non-empty defining statement" msgstr "" -#: tree-ssa.c:693 +#: tree-ssa.c:690 #, gcc-internal-format msgid "RESULT_DECL should be read only when DECL_BY_REFERENCE is set" msgstr "" -#: tree-ssa.c:699 +#: tree-ssa.c:696 #, gcc-internal-format, gfc-internal-format msgid "SSA_NAME created in two different blocks %i and %i" msgstr "" -#: tree-ssa.c:708 tree-ssa.c:1020 +#: tree-ssa.c:705 tree-ssa.c:1017 #, gcc-internal-format msgid "SSA_NAME_DEF_STMT is wrong" msgstr "" -#: tree-ssa.c:760 +#: tree-ssa.c:757 #, gcc-internal-format msgid "missing definition" msgstr "puuttuva määrittely" -#: tree-ssa.c:766 +#: tree-ssa.c:763 #, gcc-internal-format, gfc-internal-format msgid "definition in block %i does not dominate use in block %i" msgstr "" -#: tree-ssa.c:774 +#: tree-ssa.c:771 #, gcc-internal-format, gfc-internal-format msgid "definition in block %i follows the use" msgstr "" -#: tree-ssa.c:781 +#: tree-ssa.c:778 #, gcc-internal-format msgid "SSA_NAME_OCCURS_IN_ABNORMAL_PHI should be set" msgstr "" -#: tree-ssa.c:789 +#: tree-ssa.c:786 #, gcc-internal-format msgid "no immediate_use list" msgstr "" -#: tree-ssa.c:801 +#: tree-ssa.c:798 #, gcc-internal-format msgid "wrong immediate use list" msgstr "" -#: tree-ssa.c:835 +#: tree-ssa.c:832 #, gcc-internal-format msgid "incoming edge count does not match number of PHI arguments" msgstr "" -#: tree-ssa.c:849 +#: tree-ssa.c:846 #, gcc-internal-format, gfc-internal-format msgid "PHI argument is missing for edge %d->%d" msgstr "" -#: tree-ssa.c:858 +#: tree-ssa.c:855 #, gcc-internal-format msgid "PHI argument is not SSA_NAME, or invariant" msgstr "" -#: tree-ssa.c:886 +#: tree-ssa.c:883 #, gcc-internal-format, gfc-internal-format msgid "wrong edge %d->%d for PHI argument" msgstr "" -#: tree-ssa.c:967 +#: tree-ssa.c:964 #, gcc-internal-format, gfc-internal-format msgid "AUX pointer initialized for edge %d->%d" msgstr "" -#: tree-ssa.c:992 +#: tree-ssa.c:989 #, gcc-internal-format msgid "stmt (%p) marked modified after optimization pass: " msgstr "" -#: tree-ssa.c:1049 +#: tree-ssa.c:1046 #, gcc-internal-format msgid "verify_ssa failed" msgstr "" -#: tree-ssa.c:1631 varasm.c:322 +#: tree-ssa.c:1628 varasm.c:321 #, gcc-internal-format msgid "%qD was declared here" msgstr "%qD esiteltiin täällä" -#: tree-ssa.c:1663 -#, fuzzy, gcc-internal-format +#: tree-ssa.c:1660 +#, gcc-internal-format msgid "%qD is used uninitialized in this function" -msgstr "%q+D on yleensä funktio" +msgstr "%qD:a käytetään alustamattomana tässä funktiossa" -#: tree-ssa.c:1700 -#, fuzzy, gcc-internal-format +#: tree-ssa.c:1697 +#, gcc-internal-format msgid "%qE is used uninitialized in this function" -msgstr "%q+D on yleensä funktio" +msgstr "%qE:a käytetään alustamattomana tässä funktiossa" -#: tree-ssa.c:1705 -#, fuzzy, gcc-internal-format +#: tree-ssa.c:1702 +#, gcc-internal-format msgid "%qE may be used uninitialized in this function" -msgstr "%q+D on yleensä funktio" +msgstr "%qE:a saatetaan käyttää alustamattomana tässä funktiossa" #: tree-streamer-in.c:316 tree-streamer-in.c:1075 #, gcc-internal-format @@ -17587,19 +17424,19 @@ msgid "vector shuffling operation will be expanded piecewise" msgstr "" #: tree-vrp.c:6015 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "array subscript is outside array bounds" -msgstr "taulukon indeksi ei ole kokonaisluku" +msgstr "taulukon indeksi on taulukkorajojen ulkopuolella" #: tree-vrp.c:6033 tree-vrp.c:6134 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "array subscript is above array bounds" -msgstr "taulukon indeksi ei ole kokonaisluku" +msgstr "taulukon indeksi on taulukkorajojen yläpuolella" #: tree-vrp.c:6046 tree-vrp.c:6120 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "array subscript is below array bounds" -msgstr "taulukon indeksi ei ole kokonaisluku" +msgstr "taulukon indeksi on taulukkorajojen alapuolella" #: tree-vrp.c:6765 #, gcc-internal-format @@ -17651,24 +17488,24 @@ msgstr "" msgid "%q+D redeclared without dllimport attribute: previous dllimport ignored" msgstr "" -#: tree.c:5610 tree.c:5622 tree.c:5632 c-family/c-common.c:6380 -#: c-family/c-common.c:6399 c-family/c-common.c:6417 c-family/c-common.c:6445 -#: c-family/c-common.c:6473 c-family/c-common.c:6501 c-family/c-common.c:6517 -#: c-family/c-common.c:6536 c-family/c-common.c:6553 c-family/c-common.c:6577 -#: c-family/c-common.c:6600 c-family/c-common.c:6617 c-family/c-common.c:6645 -#: c-family/c-common.c:6666 c-family/c-common.c:6687 c-family/c-common.c:6714 -#: c-family/c-common.c:6745 c-family/c-common.c:6782 c-family/c-common.c:6809 -#: c-family/c-common.c:6869 c-family/c-common.c:6954 c-family/c-common.c:6984 -#: c-family/c-common.c:7038 c-family/c-common.c:7496 c-family/c-common.c:7514 -#: c-family/c-common.c:7576 c-family/c-common.c:7619 c-family/c-common.c:7690 -#: c-family/c-common.c:7818 c-family/c-common.c:7886 c-family/c-common.c:7944 -#: c-family/c-common.c:7992 c-family/c-common.c:8155 c-family/c-common.c:8176 -#: c-family/c-common.c:8288 c-family/c-common.c:8312 c-family/c-common.c:8619 -#: c-family/c-common.c:8642 c-family/c-common.c:8681 c-family/c-common.c:8759 -#: c-family/c-common.c:8906 config/darwin.c:1997 config/arm/arm.c:5119 -#: config/arm/arm.c:5147 config/arm/arm.c:5164 config/avr/avr.c:7789 -#: config/h8300/h8300.c:5463 config/h8300/h8300.c:5487 config/i386/i386.c:4965 -#: config/i386/i386.c:34737 config/ia64/ia64.c:737 +#: tree.c:5610 tree.c:5622 tree.c:5632 c-family/c-common.c:6385 +#: c-family/c-common.c:6404 c-family/c-common.c:6422 c-family/c-common.c:6450 +#: c-family/c-common.c:6478 c-family/c-common.c:6506 c-family/c-common.c:6522 +#: c-family/c-common.c:6537 c-family/c-common.c:6558 c-family/c-common.c:6575 +#: c-family/c-common.c:6599 c-family/c-common.c:6622 c-family/c-common.c:6639 +#: c-family/c-common.c:6667 c-family/c-common.c:6688 c-family/c-common.c:6709 +#: c-family/c-common.c:6736 c-family/c-common.c:6767 c-family/c-common.c:6804 +#: c-family/c-common.c:6831 c-family/c-common.c:6891 c-family/c-common.c:6976 +#: c-family/c-common.c:7006 c-family/c-common.c:7060 c-family/c-common.c:7518 +#: c-family/c-common.c:7536 c-family/c-common.c:7598 c-family/c-common.c:7641 +#: c-family/c-common.c:7712 c-family/c-common.c:7840 c-family/c-common.c:7908 +#: c-family/c-common.c:7966 c-family/c-common.c:8014 c-family/c-common.c:8177 +#: c-family/c-common.c:8198 c-family/c-common.c:8310 c-family/c-common.c:8334 +#: c-family/c-common.c:8641 c-family/c-common.c:8664 c-family/c-common.c:8703 +#: c-family/c-common.c:8781 c-family/c-common.c:8928 config/darwin.c:1997 +#: config/arm/arm.c:5119 config/arm/arm.c:5147 config/arm/arm.c:5164 +#: config/avr/avr.c:7789 config/h8300/h8300.c:5463 config/h8300/h8300.c:5487 +#: config/i386/i386.c:4965 config/i386/i386.c:34737 config/ia64/ia64.c:737 #: config/rs6000/rs6000.c:24907 config/spu/spu.c:3743 #: ada/gcc-interface/utils.c:6189 lto/lto-lang.c:222 #, gcc-internal-format @@ -17681,9 +17518,9 @@ msgid "inline function %q+D declared as dllimport: attribute ignored" msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline" #: tree.c:5658 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "function %q+D definition is marked dllimport" -msgstr "funktion määrittely esitelty %<auto%>:ksi" +msgstr "funktion %q+D määrittely on merkitty dllimport-tyyppiseksi" #: tree.c:5666 #, gcc-internal-format @@ -17696,9 +17533,9 @@ msgid "external linkage required for symbol %q+D because of %qE attribute" msgstr "" #: tree.c:5708 -#, 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 esitelty uudelleen erityyppisenä symbolina" +msgstr "%qE edellyttää oletusnäkyvyyttä, mutta %qD on jo esitelty eri näkyvyydellä" #: tree.c:7482 #, gcc-internal-format @@ -17756,54 +17593,54 @@ msgid "tree check: accessed operand %d of omp_clause %s with %d operands in %s, msgstr "" #: tree.c:11557 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qD is deprecated (declared at %s:%d): %s" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qD on vanhentunut (esitelty kohdassa %s:%d): %s" #: tree.c:11561 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qD is deprecated (declared at %s:%d)" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qD on vanhentunut (esitelty kohdassa %s:%d)" #: tree.c:11586 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE is deprecated (declared at %s:%d): %s" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qE on vanhentunut (esitelty kohdassa %s:%d): %s" #: tree.c:11590 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE is deprecated (declared at %s:%d)" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qE on vanhentunut (esitelty kohdassa %s:%d)" #: tree.c:11597 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "type is deprecated (declared at %s:%d): %s" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "tyyppi on vanhentunut (esitelty kohdassa %s:%d): %s" #: tree.c:11601 #, gcc-internal-format, gfc-internal-format msgid "type is deprecated (declared at %s:%d)" -msgstr "" +msgstr "tyyppi on vanhentunut (esitelty kohdassa %s:%d)" #: tree.c:11610 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE is deprecated: %s" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qE on vanhentunut: %s" #: tree.c:11613 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE is deprecated" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qE on vanhentunut" #: tree.c:11618 #, gcc-internal-format, gfc-internal-format msgid "type is deprecated: %s" -msgstr "" +msgstr "tyyppi on vanhentunut: %s" #: tree.c:11621 #, gcc-internal-format msgid "type is deprecated" -msgstr "" +msgstr "tyyppi on vanhentunut" #: value-prof.c:408 #, gcc-internal-format @@ -17850,145 +17687,143 @@ msgstr "" msgid "variable tracking size limit exceeded" msgstr "" -#: varasm.c:315 +#: varasm.c:314 #, gcc-internal-format msgid "%+D causes a section type conflict" msgstr "" -#: varasm.c:318 +#: varasm.c:317 #, gcc-internal-format msgid "%+D causes a section type conflict with %D" msgstr "" -#: varasm.c:960 +#: varasm.c:959 #, gcc-internal-format msgid "alignment of %q+D is greater than maximum object file alignment. Using %d" msgstr "" -#: varasm.c:1200 varasm.c:1209 +#: varasm.c:1198 varasm.c:1207 #, fuzzy, gcc-internal-format msgid "register name not specified for %q+D" -msgstr "%Jtasausta ei voi määrittää %qD:lle" +msgstr "%Jkohdistusta ei voi määrittää %qD:lle" -#: varasm.c:1211 +#: varasm.c:1209 #, fuzzy, gcc-internal-format msgid "invalid register name for %q+D" msgstr "epäkelpo osoitintila %qs" -#: varasm.c:1213 +#: varasm.c:1211 #, gcc-internal-format msgid "data type of %q+D isn%'t suitable for a register" msgstr "" -#: varasm.c:1216 +#: varasm.c:1214 #, gcc-internal-format msgid "the register specified for %q+D cannot be accessed by the current target" msgstr "" -#: varasm.c:1219 +#: varasm.c:1217 #, gcc-internal-format msgid "the register specified for %q+D is not general enough to be used as a register variable" msgstr "" -#: varasm.c:1222 +#: varasm.c:1220 #, gcc-internal-format msgid "register specified for %q+D isn%'t suitable for data type" msgstr "" -#: varasm.c:1232 +#: varasm.c:1230 #, gcc-internal-format msgid "global register variable has initial value" msgstr "" -#: varasm.c:1236 +#: varasm.c:1234 #, gcc-internal-format msgid "optimization may eliminate reads and/or writes to register variables" msgstr "" -#: varasm.c:1274 +#: varasm.c:1272 #, gcc-internal-format msgid "register name given for non-register variable %q+D" msgstr "" -#: varasm.c:1820 +#: varasm.c:1818 #, gcc-internal-format msgid "thread-local COMMON data not implemented" msgstr "" -#: varasm.c:1852 +#: varasm.c:1850 #, gcc-internal-format msgid "requested alignment for %q+D is greater than implemented alignment of %wu" msgstr "" -#: varasm.c:1940 c/c-decl.c:4353 -#, fuzzy, gcc-internal-format +#: varasm.c:1938 c/c-decl.c:4353 +#, gcc-internal-format msgid "storage size of %q+D isn%'t known" -msgstr "%Jmuuttujan %qD koko muistissa ei ole tunnettu" +msgstr "muuttujan %q+D koko muistissa ei ole tunnettu" -#: varasm.c:4605 +#: varasm.c:4590 #, gcc-internal-format msgid "initializer for integer/fixed-point value is too complicated" msgstr "" -#: varasm.c:4610 +#: varasm.c:4595 #, gcc-internal-format msgid "initializer for floating value is not a floating constant" -msgstr "" +msgstr "alustin liukulukuarvolle ei ole liukulukuvakio" -#: varasm.c:4918 -#, fuzzy, gcc-internal-format +#: varasm.c:4903 +#, gcc-internal-format msgid "invalid initial value for member %qE" -msgstr "alustamaton const-jäsen %qD" +msgstr "virheellinen alkuarvo jäsenelle %qE" -#: varasm.c:5270 +#: varasm.c:5255 #, fuzzy, gcc-internal-format msgid "weak declaration of %q+D must be public" msgstr "%J%qD esitelty uudelleen ilman linkitystä" -#: varasm.c:5272 +#: varasm.c:5257 #, fuzzy, gcc-internal-format msgid "weak declaration of %q+D not supported" msgstr "%J%qD:n esittely varjostaa parametria" -#: varasm.c:5301 varasm.c:5598 +#: varasm.c:5286 varasm.c:5583 #, gcc-internal-format msgid "only weak aliases are supported in this configuration" msgstr "" -#: varasm.c:5490 +#: varasm.c:5475 #, gcc-internal-format msgid "weakref is not supported in this configuration" msgstr "weakref ei ole tuettu tässä konfiguraatiossa" -#: varasm.c:5513 varasm.c:5595 +#: varasm.c:5498 varasm.c:5580 #, fuzzy, gcc-internal-format -#| msgid "weakref is not supported in this configuration" msgid "ifunc is not supported in this configuration" msgstr "weakref ei ole tuettu tässä konfiguraatiossa" -#: varasm.c:5572 +#: varasm.c:5557 #, gcc-internal-format msgid "weakref %q+D ultimately targets itself" msgstr "" -#: varasm.c:5581 +#: varasm.c:5566 #, gcc-internal-format msgid "weakref %q+D must have static linkage" msgstr "" -#: varasm.c:5588 +#: varasm.c:5573 #, fuzzy, gcc-internal-format msgid "alias definitions not supported in this configuration" msgstr "#pragma redefine_extname ei ole tuettu tällä kohteella" -#: varasm.c:5807 config/sol2.c:155 config/i386/winnt.c:254 +#: varasm.c:5792 config/sol2.c:155 config/i386/winnt.c:254 #, gcc-internal-format msgid "visibility attribute not supported in this configuration; ignored" msgstr "" #: varpool.c:240 #, fuzzy, gcc-internal-format -#| msgid "variable %qD has function type" msgid "variable %q+D part of alias cycle" msgstr "muuttujalla %qD on funktiotyyppi" @@ -18008,1341 +17843,1316 @@ msgstr "" msgid "bytecode stream: tag %s is not in the expected range [%s, %s]" msgstr "" -#: c-family/c-common.c:911 +#: c-family/c-common.c:916 #, gcc-internal-format msgid "%qD is not defined outside of function scope" msgstr "%qD ei ole määritelty funktion näkyvyysalueen ulkopuolella" -#: c-family/c-common.c:961 +#: c-family/c-common.c:966 #, gcc-internal-format msgid "string length %qd is greater than the length %qd ISO C%d compilers are required to support" msgstr "merkkijonon pituudeksi annettu %1$qd merkkiä on suurempi kuin ISO C%3$d -kääntäjiltä vaadittu %2$qd merkkiä" -#: c-family/c-common.c:1280 c/c-typeck.c:9864 cp/typeck.c:4158 +#: c-family/c-common.c:1285 c/c-typeck.c:9864 cp/typeck.c:4158 #, gcc-internal-format msgid "left shift count is negative" -msgstr "" +msgstr "vasemmalle siirron lukumäärä on negatiivinen" -#: c-family/c-common.c:1281 c/c-typeck.c:9812 cp/typeck.c:4112 +#: c-family/c-common.c:1286 c/c-typeck.c:9812 cp/typeck.c:4112 #, gcc-internal-format msgid "right shift count is negative" -msgstr "" +msgstr "oikealle siirron lukumäärä on negatiivinen" -#: c-family/c-common.c:1286 c/c-typeck.c:9871 cp/typeck.c:4165 +#: c-family/c-common.c:1291 c/c-typeck.c:9871 cp/typeck.c:4165 #, gcc-internal-format msgid "left shift count >= width of type" -msgstr "" +msgstr "vasemmalle siirron lukumäärä >= tyypin leveys" -#: c-family/c-common.c:1287 c/c-typeck.c:9823 cp/typeck.c:4119 +#: c-family/c-common.c:1292 c/c-typeck.c:9823 cp/typeck.c:4119 #, gcc-internal-format msgid "right shift count >= width of type" -msgstr "" +msgstr "oikealle siirron lukumäärä >= tyypin leveys" -#: c-family/c-common.c:1508 c-family/c-common.c:1520 cp/semantics.c:6865 +#: c-family/c-common.c:1513 c-family/c-common.c:1525 cp/semantics.c:6867 #, gcc-internal-format msgid "overflow in constant expression" msgstr "ylivuoto vakiolausekkeessa" -#: c-family/c-common.c:1543 +#: c-family/c-common.c:1548 #, gcc-internal-format msgid "integer overflow in expression" msgstr "kokonaislukuylivuoto lausekkeessa" -#: c-family/c-common.c:1548 +#: c-family/c-common.c:1553 #, gcc-internal-format msgid "floating point overflow in expression" msgstr "liukulukuylivuoto lausekkeessa" -#: c-family/c-common.c:1552 +#: c-family/c-common.c:1557 #, fuzzy, gcc-internal-format msgid "fixed-point overflow in expression" msgstr "liukulukuylivuoto lausekkeessa" -#: c-family/c-common.c:1556 +#: c-family/c-common.c:1561 #, gcc-internal-format msgid "vector overflow in expression" msgstr "vektoriylivuoto lausekkeessa" -#: c-family/c-common.c:1562 +#: c-family/c-common.c:1567 #, gcc-internal-format msgid "complex integer overflow in expression" msgstr "kompleksikokonaislukuylivuoto lausekkeessa" -#: c-family/c-common.c:1565 +#: c-family/c-common.c:1570 #, gcc-internal-format msgid "complex floating point overflow in expression" msgstr "kompleksiliukulukuylivuoto lausekkeessa" -#: c-family/c-common.c:1608 +#: c-family/c-common.c:1613 #, gcc-internal-format msgid "logical %<or%> applied to non-boolean constant" msgstr "" -#: c-family/c-common.c:1611 +#: c-family/c-common.c:1616 #, gcc-internal-format msgid "logical %<and%> applied to non-boolean constant" msgstr "" -#: c-family/c-common.c:1675 +#: c-family/c-common.c:1680 #, gcc-internal-format msgid "logical %<or%> of collectively exhaustive tests is always true" msgstr "" -#: c-family/c-common.c:1679 +#: c-family/c-common.c:1684 #, gcc-internal-format msgid "logical %<and%> of mutually exclusive tests is always false" msgstr "" -#: c-family/c-common.c:1811 +#: c-family/c-common.c:1816 #, gcc-internal-format msgid "type-punning to incomplete type might break strict-aliasing rules" msgstr "" -#: c-family/c-common.c:1826 +#: c-family/c-common.c:1831 #, gcc-internal-format msgid "dereferencing type-punned pointer will break strict-aliasing rules" msgstr "" -#: c-family/c-common.c:1833 c-family/c-common.c:1851 +#: c-family/c-common.c:1838 c-family/c-common.c:1856 #, gcc-internal-format msgid "dereferencing type-punned pointer might break strict-aliasing rules" msgstr "" -#: c-family/c-common.c:1985 +#: c-family/c-common.c:1990 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same expression as the destination; did you mean to remove the addressof?" msgstr "" -#: c-family/c-common.c:1992 +#: c-family/c-common.c:1997 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same expression as the destination; did you mean to provide an explicit length?" msgstr "" -#: c-family/c-common.c:1997 +#: c-family/c-common.c:2002 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same expression as the destination; did you mean to dereference it?" msgstr "" -#: c-family/c-common.c:2009 +#: c-family/c-common.c:2014 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same pointer type %qT as the destination; expected %qT or an explicit length" msgstr "" -#: c-family/c-common.c:2025 +#: c-family/c-common.c:2030 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same expression as the source; did you mean to remove the addressof?" msgstr "" -#: c-family/c-common.c:2032 +#: c-family/c-common.c:2037 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same expression as the source; did you mean to provide an explicit length?" msgstr "" -#: c-family/c-common.c:2037 +#: c-family/c-common.c:2042 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same expression as the source; did you mean to dereference it?" msgstr "" -#: c-family/c-common.c:2049 +#: c-family/c-common.c:2054 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same pointer type %qT as the source; expected %qT or an explicit length" msgstr "" -#: c-family/c-common.c:2065 +#: c-family/c-common.c:2070 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same expression as the first source; did you mean to remove the addressof?" msgstr "" -#: c-family/c-common.c:2072 +#: c-family/c-common.c:2077 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same expression as the first source; did you mean to provide an explicit length?" msgstr "" -#: c-family/c-common.c:2077 +#: c-family/c-common.c:2082 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same expression as the first source; did you mean to dereference it?" msgstr "" -#: c-family/c-common.c:2089 +#: c-family/c-common.c:2094 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same pointer type %qT as the first source; expected %qT or an explicit length" msgstr "" -#: c-family/c-common.c:2105 +#: c-family/c-common.c:2110 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same expression as the second source; did you mean to remove the addressof?" msgstr "" -#: c-family/c-common.c:2112 +#: c-family/c-common.c:2117 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same expression as the second source; did you mean to provide an explicit length?" msgstr "" -#: c-family/c-common.c:2117 +#: c-family/c-common.c:2122 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same expression as the second source; did you mean to dereference it?" msgstr "" -#: c-family/c-common.c:2129 +#: c-family/c-common.c:2134 #, gcc-internal-format msgid "argument to %<sizeof%> in %qD call is the same pointer type %qT as the second source; expected %qT or an explicit length" msgstr "" -#: c-family/c-common.c:2161 +#: c-family/c-common.c:2166 #, gcc-internal-format msgid "first argument of %q+D should be %<int%>" msgstr "%q+D:n ensimmäisen argumentin pitäisi olla %<int%>" -#: c-family/c-common.c:2170 +#: c-family/c-common.c:2175 #, gcc-internal-format msgid "second argument of %q+D should be %<char **%>" msgstr "%q+D:n toisen argumentin pitäisi olla %<char **%>" -#: c-family/c-common.c:2179 +#: c-family/c-common.c:2184 #, gcc-internal-format msgid "third argument of %q+D should probably be %<char **%>" msgstr "%q+D:n kolmannen argumentin pitäisi todennäköisesti olla %<char **%>" -#: c-family/c-common.c:2190 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:2195 +#, gcc-internal-format msgid "%q+D takes only zero or two arguments" -msgstr "%J%qD sallii vain nolla tai kaksi argumenttia" +msgstr "%q+D sallii vain nolla tai kaksi argumenttia" -#: c-family/c-common.c:2239 +#: c-family/c-common.c:2244 #, gcc-internal-format msgid "use -flax-vector-conversions to permit conversions between vectors with differing element types or numbers of subparts" msgstr "" -#: c-family/c-common.c:2278 +#: c-family/c-common.c:2283 #, fuzzy, gcc-internal-format msgid "__builtin_shuffle last argument must be an integer vector" msgstr "puhdistusargumentti ei ole tunniste" -#: c-family/c-common.c:2286 +#: c-family/c-common.c:2291 #, fuzzy, gcc-internal-format -#| msgid "%<__builtin_longjmp%> second argument must be 1" msgid "__builtin_shuffle arguments must be vectors" msgstr "%<__builtin_longjmp%>-fuktion toisen argumentin pitää olla 1" -#: c-family/c-common.c:2292 +#: c-family/c-common.c:2297 #, gcc-internal-format msgid "__builtin_shuffle argument vectors must be of the same type" msgstr "" -#: c-family/c-common.c:2302 +#: c-family/c-common.c:2307 #, gcc-internal-format msgid "__builtin_shuffle number of elements of the argument vector(s) and the mask vector should be the same" msgstr "" -#: c-family/c-common.c:2311 +#: c-family/c-common.c:2316 #, gcc-internal-format msgid "__builtin_shuffle argument vector(s) inner type must have the same size as inner type of the mask" msgstr "" -#: c-family/c-common.c:2505 +#: c-family/c-common.c:2510 #, gcc-internal-format msgid "negative integer implicitly converted to unsigned type" msgstr "negatiivinen kokonaisluku muunnettu implisiittisesti etumerkittömään tyyppiin" -#: c-family/c-common.c:2511 +#: c-family/c-common.c:2516 #, gcc-internal-format msgid "conversion of unsigned constant value to negative integer" msgstr "etumerkittömän vakion muunnos negatiiviseksi kokonaisluvuksi" -#: c-family/c-common.c:2605 +#: c-family/c-common.c:2610 #, gcc-internal-format msgid "conversion to %qT from %qT may change the sign of the result" msgstr "" -#: c-family/c-common.c:2674 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:2679 +#, gcc-internal-format msgid "conversion to %qT from boolean expression" -msgstr "muunnos tyypistä %2$qT tyypiksi %1$qT" +msgstr "muunnos tyyppiin %qT loogisesta lausekkeesta" -#: c-family/c-common.c:2681 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:2686 +#, gcc-internal-format msgid "conversion to %qT alters %qT constant value" -msgstr "muunnos tyypistä %2$qT tyypiksi %1$qT" +msgstr "muunnos tyyppiin %qT muuttaa %qT:n vakioarvoa" -#: c-family/c-common.c:2700 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:2705 +#, gcc-internal-format msgid "conversion to %qT from %qT may alter its value" -msgstr "muunnos tyypistä %2$qT tyypiksi %1$qT" +msgstr "muunnos tyyppiin %qT tyypistä %qT saattaa muuttaa sen arvoa" -#: c-family/c-common.c:2730 +#: c-family/c-common.c:2735 #, gcc-internal-format msgid "large integer implicitly truncated to unsigned type" msgstr "suuri kokonaisluku implisiittisesti katkaistu etumerkittömäksi tyypiksi" -#: c-family/c-common.c:2736 c-family/c-common.c:2743 c-family/c-common.c:2751 +#: c-family/c-common.c:2741 c-family/c-common.c:2748 c-family/c-common.c:2756 #, gcc-internal-format msgid "overflow in implicit constant conversion" msgstr "ylivuoto implisiittisessä vakiomuunnoksessa" -#: c-family/c-common.c:2923 +#: c-family/c-common.c:2928 #, gcc-internal-format msgid "operation on %qE may be undefined" msgstr "operaatio %qE:lle voi olla määrittelemätön" -#: c-family/c-common.c:3234 +#: c-family/c-common.c:3239 #, gcc-internal-format msgid "case label does not reduce to an integer constant" msgstr "case-nimike ei pelkisty kokonaislukuvakioksi" -#: c-family/c-common.c:3274 +#: c-family/c-common.c:3279 #, gcc-internal-format msgid "case label value is less than minimum value for type" msgstr "case-nimikkeen arvo on pienempi kuin tyypin minimiarvo" -#: c-family/c-common.c:3282 +#: c-family/c-common.c:3287 #, gcc-internal-format msgid "case label value exceeds maximum value for type" msgstr "case-nimikkeen arvo ylittää tyypin maksimiarvon" -#: c-family/c-common.c:3290 +#: c-family/c-common.c:3295 #, gcc-internal-format msgid "lower value in case label range less than minimum value for type" msgstr "case-nimikkeen alarajan arvo on pienempi kuin tyypin minimiarvo" -#: c-family/c-common.c:3299 +#: c-family/c-common.c:3304 #, gcc-internal-format msgid "upper value in case label range exceeds maximum value for type" msgstr "case-nimikkeen ylärajan arvo ylittää tyypin maksimiarvon" -#: c-family/c-common.c:3378 +#: c-family/c-common.c:3383 #, 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 "" -#: c-family/c-common.c:3881 +#: c-family/c-common.c:3886 #, fuzzy, gcc-internal-format msgid "invalid operands to binary %s (have %qT and %qT)" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: c-family/c-common.c:4142 +#: c-family/c-common.c:4147 #, gcc-internal-format msgid "comparison is always false due to limited range of data type" msgstr "vertailu on aina epätosi johtuen tietotyypin rajallisesta arvoalueesta" -#: c-family/c-common.c:4145 +#: c-family/c-common.c:4150 #, gcc-internal-format msgid "comparison is always true due to limited range of data type" msgstr "vertailu on aina tosi johtuen tietotyypin rajallisesta arvoalueesta" -#: c-family/c-common.c:4230 +#: c-family/c-common.c:4235 #, gcc-internal-format msgid "comparison of unsigned expression >= 0 is always true" msgstr "vertailu ”etumerkitön lauseke >= 0” on aina tosi" -#: c-family/c-common.c:4237 +#: c-family/c-common.c:4242 #, gcc-internal-format msgid "comparison of unsigned expression < 0 is always false" msgstr "vertailu ”etumerkitön lauseke < 0” on aina epätosi" -#: c-family/c-common.c:4279 +#: c-family/c-common.c:4284 #, gcc-internal-format msgid "pointer of type %<void *%> used in arithmetic" msgstr "%<void *%>-tyyppistä osoitinta käytetty laskutoimituksessa" -#: c-family/c-common.c:4285 +#: c-family/c-common.c:4290 #, gcc-internal-format msgid "pointer to a function used in arithmetic" msgstr "funktio-osoitinta käytetty laskutoimituksessa" -#: c-family/c-common.c:4291 +#: c-family/c-common.c:4296 #, gcc-internal-format msgid "pointer to member function used in arithmetic" msgstr "jäsenfunktio-osoitinta käytetty laskutoimituksessa" -#: c-family/c-common.c:4503 +#: c-family/c-common.c:4508 #, gcc-internal-format msgid "the address of %qD will always evaluate as %<true%>" msgstr "%qD:n osoite tulee aina olemaan %<true%>" -#: c-family/c-common.c:4598 cp/semantics.c:592 cp/typeck.c:7906 +#: c-family/c-common.c:4603 cp/semantics.c:592 cp/typeck.c:7906 #, gcc-internal-format msgid "suggest parentheses around assignment used as truth value" msgstr "ehdotetaan sulkeita totuusarvona käytetyn sijoituksen ympärille" -#: c-family/c-common.c:4677 c/c-decl.c:3686 c/c-typeck.c:10883 +#: c-family/c-common.c:4682 c/c-decl.c:3686 c/c-typeck.c:10883 #, gcc-internal-format msgid "invalid use of %<restrict%>" msgstr "epäkelpo %<restrict%>-avainsanan käyttö" -#: c-family/c-common.c:4870 +#: c-family/c-common.c:4875 #, gcc-internal-format msgid "invalid application of %<sizeof%> to a function type" msgstr "epäkelpo %<sizeof%>-avainsanan soveltaminen funktiotyyppiin" -#: c-family/c-common.c:4880 +#: c-family/c-common.c:4885 #, fuzzy, gcc-internal-format -#| msgid "ISO C does not allow extra %<;%> outside of a function" msgid "ISO C++ does not permit %<alignof%> applied to a function type" msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktioiden ulkopuolella" -#: c-family/c-common.c:4883 +#: c-family/c-common.c:4888 #, fuzzy, gcc-internal-format -#| msgid "ISO C does not allow extra %<;%> outside of a function" msgid "ISO C does not permit %<_Alignof%> applied to a function type" msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktioiden ulkopuolella" -#: c-family/c-common.c:4894 +#: c-family/c-common.c:4899 #, gcc-internal-format msgid "invalid application of %qs to a void type" msgstr "epäkelpo %qs:n soveltaminen tyhjään tyyppiin" -#: c-family/c-common.c:4903 +#: c-family/c-common.c:4908 #, fuzzy, gcc-internal-format -#| msgid "invalid application of %qs to incomplete type %qT " msgid "invalid application of %qs to incomplete type %qT" msgstr "epäkelpo %qs:n soveltaminen vaillinaiseen tyyppiin %qT " -#: c-family/c-common.c:4911 +#: c-family/c-common.c:4916 #, fuzzy, gcc-internal-format -#| msgid "invalid application of %qs to incomplete type %qT " msgid "invalid application of %qs to array type %qT of incomplete element type" msgstr "epäkelpo %qs:n soveltaminen vaillinaiseen tyyppiin %qT " -#: c-family/c-common.c:4951 +#: c-family/c-common.c:4956 #, gcc-internal-format msgid "%<__alignof%> applied to a bit-field" msgstr "%<__alignof%>-avainsanaa sovellettu bittikenttään" -#: c-family/c-common.c:5664 +#: c-family/c-common.c:5669 #, gcc-internal-format msgid "cannot disable built-in function %qs" msgstr "sisäistä funktiota %qs ei voi ottaa pois käytöstä" -#: c-family/c-common.c:5855 +#: c-family/c-common.c:5860 #, gcc-internal-format msgid "pointers are not permitted as case values" msgstr "osoittimet eivät ole sallittuja case-arvoja" -#: c-family/c-common.c:5862 +#: c-family/c-common.c:5867 #, gcc-internal-format msgid "range expressions in switch statements are non-standard" msgstr "arvoaluelausekkeet switch-lauseessa eivät ole standardin mukaisia" -#: c-family/c-common.c:5888 +#: c-family/c-common.c:5893 #, gcc-internal-format msgid "empty range specified" msgstr "tyhjä arvoalue annettu" -#: c-family/c-common.c:5948 +#: c-family/c-common.c:5953 #, gcc-internal-format msgid "duplicate (or overlapping) case value" msgstr "case-arvon kaksoiskappale (tai limitys)" -#: c-family/c-common.c:5950 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:5955 +#, gcc-internal-format msgid "this is the first entry overlapping that value" -msgstr "%Jtämä on ensimmäinen arvoa limittävä kenttä" +msgstr "tämä on ensimmäinen arvoa limittävä kenttä" -#: c-family/c-common.c:5954 +#: c-family/c-common.c:5959 #, gcc-internal-format msgid "duplicate case value" msgstr "case-arvon kaksoiskappale" -#: c-family/c-common.c:5955 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:5960 +#, gcc-internal-format msgid "previously used here" -msgstr "%Jviimeksi käytetty täällä" +msgstr "viimeksi käytetty täällä" -#: c-family/c-common.c:5959 +#: c-family/c-common.c:5964 #, gcc-internal-format msgid "multiple default labels in one switch" msgstr "useita default-nimikkeitä samassa switch-lauseessa" -#: c-family/c-common.c:5961 +#: c-family/c-common.c:5966 #, gcc-internal-format msgid "this is the first default label" msgstr "tämä on ensimmäinen default-nimiö" -#: c-family/c-common.c:6013 +#: c-family/c-common.c:6018 #, gcc-internal-format msgid "case value %qs not in enumerated type" msgstr "case-arvo %qs ei ole luetellussa tyypissä" -#: c-family/c-common.c:6018 +#: c-family/c-common.c:6023 #, gcc-internal-format msgid "case value %qs not in enumerated type %qT" msgstr "case-arvo %qs ei ole luetellussa tyypissä %qT" -#: c-family/c-common.c:6077 +#: c-family/c-common.c:6082 #, gcc-internal-format msgid "switch missing default case" msgstr "switch-lauseesta puuttuu default-tapaus" -#: c-family/c-common.c:6149 +#: c-family/c-common.c:6154 #, gcc-internal-format msgid "enumeration value %qE not handled in switch" msgstr "lueteltua arvoa %qE ei käsitellä switch-lauseessa" -#: c-family/c-common.c:6175 +#: c-family/c-common.c:6180 #, gcc-internal-format msgid "taking the address of a label is non-standard" msgstr "nimikkeen osoitteen ottaminen ei ole standardia" -#: c-family/c-common.c:6369 +#: c-family/c-common.c:6374 #, gcc-internal-format msgid "%qE attribute ignored for field of type %qT" msgstr "%qE-attribuuttia ei huomioida %qT-tyyppiselle kentälle" -#: c-family/c-common.c:6464 c-family/c-common.c:6492 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:6469 c-family/c-common.c:6497 +#, gcc-internal-format msgid "%qE attribute conflicts with attribute %s" -msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" +msgstr "%qE-attribuutti on ristiriidassa attribuutin %s kanssa" -#: c-family/c-common.c:6622 lto/lto-lang.c:227 +#: c-family/c-common.c:6644 lto/lto-lang.c:227 #, fuzzy, gcc-internal-format msgid "%qE attribute has no effect on unit local functions" msgstr "%J%qE-attribuutti soveltuu vain funktioihin" -#: c-family/c-common.c:6776 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:6798 +#, gcc-internal-format msgid "%qE attribute have effect only on public objects" -msgstr "%J%qE-attribuutti soveltuu vain funktioihin" +msgstr "%qE-attribuutti vaikuttaa vain julkisiin objekteihin" -#: c-family/c-common.c:6890 +#: c-family/c-common.c:6912 #, fuzzy, gcc-internal-format msgid "destructor priorities are not supported" msgstr "%Jlohkoattribuutteja ei tueta tälle kohteelle" -#: c-family/c-common.c:6892 +#: c-family/c-common.c:6914 #, gcc-internal-format msgid "constructor priorities are not supported" msgstr "" -#: c-family/c-common.c:6910 +#: c-family/c-common.c:6932 #, gcc-internal-format, gfc-internal-format msgid "destructor priorities from 0 to %d are reserved for the implementation" msgstr "" -#: c-family/c-common.c:6915 +#: c-family/c-common.c:6937 #, gcc-internal-format, gfc-internal-format msgid "constructor priorities from 0 to %d are reserved for the implementation" msgstr "" -#: c-family/c-common.c:6923 +#: c-family/c-common.c:6945 #, gcc-internal-format, gfc-internal-format msgid "destructor priorities must be integers from 0 to %d inclusive" msgstr "" -#: c-family/c-common.c:6926 +#: c-family/c-common.c:6948 #, gcc-internal-format, gfc-internal-format msgid "constructor priorities must be integers from 0 to %d inclusive" msgstr "" -#: c-family/c-common.c:7082 +#: c-family/c-common.c:7104 #, fuzzy, gcc-internal-format msgid "unknown machine mode %qE" msgstr "tuntematon konetila %qs" -#: c-family/c-common.c:7111 +#: c-family/c-common.c:7133 #, fuzzy, gcc-internal-format msgid "specifying vector types with __attribute__ ((mode)) is deprecated" msgstr "vektorityyppien määrittäminen __attribute__ ((mode)) -tyyliin on paheksuttavaa" -#: c-family/c-common.c:7114 +#: c-family/c-common.c:7136 #, gcc-internal-format msgid "use __attribute__ ((vector_size)) instead" msgstr "käytä sen sijaan __attribute__ ((vector_size))" -#: c-family/c-common.c:7123 +#: c-family/c-common.c:7145 #, fuzzy, gcc-internal-format msgid "unable to emulate %qs" msgstr "ei voi emuloida %qs" -#: c-family/c-common.c:7134 +#: c-family/c-common.c:7156 #, gcc-internal-format msgid "invalid pointer mode %qs" msgstr "epäkelpo osoitintila %qs" -#: c-family/c-common.c:7151 +#: c-family/c-common.c:7173 #, gcc-internal-format msgid "signedness of type and machine mode %qs don%'t match" msgstr "" -#: c-family/c-common.c:7162 +#: c-family/c-common.c:7184 #, gcc-internal-format msgid "no data type for mode %qs" msgstr "ei tietotyyppiä tilalle %qs" -#: c-family/c-common.c:7172 +#: c-family/c-common.c:7194 #, gcc-internal-format msgid "cannot use mode %qs for enumeral types" msgstr "luetelluille tyypeille ei voi käyttää tilaa %qs" -#: c-family/c-common.c:7199 +#: c-family/c-common.c:7221 #, gcc-internal-format msgid "mode %qs applied to inappropriate type" msgstr "tilaa %qs sovellettu sopimattomaan tyyppiin" -#: c-family/c-common.c:7231 +#: c-family/c-common.c:7253 #, fuzzy, gcc-internal-format msgid "section attribute cannot be specified for local variables" msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle" -#: c-family/c-common.c:7242 config/bfin/bfin.c:4737 config/bfin/bfin.c:4788 +#: c-family/c-common.c:7264 config/bfin/bfin.c:4737 config/bfin/bfin.c:4788 #: config/bfin/bfin.c:4815 config/bfin/bfin.c:4828 #, fuzzy, gcc-internal-format msgid "section of %q+D conflicts with previous declaration" msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa" -#: c-family/c-common.c:7250 +#: c-family/c-common.c:7272 #, gcc-internal-format msgid "section of %q+D cannot be overridden" msgstr "" -#: c-family/c-common.c:7258 +#: c-family/c-common.c:7280 #, fuzzy, gcc-internal-format msgid "section attribute not allowed for %q+D" msgstr "%Jlohkoattribuutti ei ole sallittu %qD:lle" -#: c-family/c-common.c:7265 +#: c-family/c-common.c:7287 #, fuzzy, gcc-internal-format msgid "section attributes are not supported for this target" msgstr "%Jlohkoattribuutteja ei tueta tälle kohteelle" -#: c-family/c-common.c:7284 +#: c-family/c-common.c:7306 #, fuzzy, gcc-internal-format -#| msgid "requested alignment is not a constant" msgid "requested alignment is not an integer constant" -msgstr "pyydetty tasaus ei ole vakio" +msgstr "pyydetty kohdistus ei ole vakio" -#: c-family/c-common.c:7291 +#: c-family/c-common.c:7313 #, gcc-internal-format msgid "requested alignment is not a power of 2" -msgstr "pyydetty tasaus ei ole kahden potenssi" +msgstr "pyydetty kohdistus ei ole kahden potenssi" -#: c-family/c-common.c:7296 +#: c-family/c-common.c:7318 #, gcc-internal-format msgid "requested alignment is too large" -msgstr "pyydetty tasaus on liian suuri" +msgstr "pyydetty kohdistus on liian suuri" -#: c-family/c-common.c:7379 +#: c-family/c-common.c:7401 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "requested alignment is too large" msgid "requested alignment %d is larger than %d" -msgstr "pyydetty tasaus on liian suuri" +msgstr "pyydetty kohdistus on liian suuri" -#: c-family/c-common.c:7436 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:7458 +#, gcc-internal-format msgid "alignment may not be specified for %q+D" -msgstr "%Jtasausta ei voi määrittää %qD:lle" +msgstr "kohdistusta ei voi määritellä %q+D:lle" -#: c-family/c-common.c:7454 +#: c-family/c-common.c:7476 #, gcc-internal-format msgid "alignment for %q+D was previously specified as %d and may not be decreased" msgstr "" -#: c-family/c-common.c:7458 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:7480 +#, gcc-internal-format msgid "alignment for %q+D must be at least %d" -msgstr "tasauksen pitää olla kahden potenssi, ei %d" +msgstr "kohdistuksen %q+D:lle pitää olla vähintään %d" -#: c-family/c-common.c:7483 +#: c-family/c-common.c:7505 #, fuzzy, gcc-internal-format msgid "inline function %q+D declared weak" msgstr "sisäkkäinen funktio %qs esitelty %<extern%>:ksi" -#: c-family/c-common.c:7488 +#: c-family/c-common.c:7510 #, fuzzy, gcc-internal-format msgid "indirect function %q+D cannot be declared weak" msgstr "sisäkkäinen funktio %qs esitelty %<extern%>:ksi" -#: c-family/c-common.c:7525 +#: c-family/c-common.c:7547 #, fuzzy, gcc-internal-format msgid "%q+D defined both normally and as %qE attribute" msgstr "%J%qD määritelty sekä tavallisesti että aliaksena" -#: c-family/c-common.c:7533 +#: c-family/c-common.c:7555 #, fuzzy, gcc-internal-format msgid "weak %q+D cannot be defined %qE" msgstr "%J%qD on tavallisesti ei-staattinen funktio" -#: c-family/c-common.c:7550 +#: c-family/c-common.c:7572 #, fuzzy, gcc-internal-format msgid "attribute %qE argument not a string" msgstr "haluttu sijainti ei ole kokonaislukuvakio" -#: c-family/c-common.c:7626 +#: c-family/c-common.c:7648 #, fuzzy, gcc-internal-format msgid "indirect function %q+D cannot be declared weakref" msgstr "sisäkkäinen funktio %qs esitelty %<extern%>:ksi" -#: c-family/c-common.c:7648 +#: c-family/c-common.c:7670 #, gcc-internal-format msgid "weakref attribute must appear before alias attribute" -msgstr "" +msgstr "weakref-attribuutin täytyy esiintyä ennen alias-attribuuttia" -#: c-family/c-common.c:7677 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:7699 +#, gcc-internal-format msgid "%qE attribute ignored on non-class types" -msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille" +msgstr "%qE-attribuuttia ei huomioida ei-luokkatyypeille" -#: c-family/c-common.c:7683 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:7705 +#, gcc-internal-format msgid "%qE attribute ignored because %qT is already defined" -msgstr "%qs-attribuuttia ei huomioida %qs:lle" +msgstr "%qE-attribuuttia ei huomioida koska %qT on jo määritelty" -#: c-family/c-common.c:7696 +#: c-family/c-common.c:7718 #, gcc-internal-format msgid "visibility argument not a string" msgstr "näkyvyysargumentti ei ole merkkijono" -#: c-family/c-common.c:7708 +#: c-family/c-common.c:7730 #, fuzzy, gcc-internal-format msgid "%qE attribute ignored on types" msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille" -#: c-family/c-common.c:7724 +#: c-family/c-common.c:7746 #, gcc-internal-format msgid "visibility argument must be one of \"default\", \"hidden\", \"protected\" or \"internal\"" -msgstr "näkyvyysargumentin pitää olla \"default\", \"hidden\", \"protected\" tai \"internal\"" +msgstr "näkyvyysargumentin tulee olla ”default”, ”hidden”, ”protected” tai ”internal”" -#: c-family/c-common.c:7735 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:7757 +#, gcc-internal-format msgid "%qD redeclared with different visibility" -msgstr "%J%qD esitelty uudelleen erityyppisenä symbolina" +msgstr "%qD esitelty uudelleen eri näkyvyydellä" -#: c-family/c-common.c:7738 c-family/c-common.c:7742 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:7760 c-family/c-common.c:7764 +#, gcc-internal-format msgid "%qD was declared %qs which implies default visibility" -msgstr "%J%qD esitelty uudelleen erityyppisenä symbolina" +msgstr "%qD esiteltiin tyyppinä %qs, mikä edellyttää oletusnäkyvyyttä" -#: c-family/c-common.c:7826 +#: c-family/c-common.c:7848 #, gcc-internal-format msgid "tls_model argument not a string" msgstr "tls_model-argumentti ei ole merkkijono" -#: c-family/c-common.c:7839 +#: c-family/c-common.c:7861 #, gcc-internal-format msgid "tls_model argument must be one of \"local-exec\", \"initial-exec\", \"local-dynamic\" or \"global-dynamic\"" msgstr "tls_model-argumentin pitää olla ”local-exec”, ”initial-exec”, ”local-dynamic” tai ”global-dynamic”" -#: c-family/c-common.c:7859 c-family/c-common.c:7965 c-family/c-common.c:8950 +#: c-family/c-common.c:7881 c-family/c-common.c:7987 c-family/c-common.c:8970 #: config/m32c/m32c.c:2926 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE attribute applies only to functions" -msgstr "%J%qE-attribuutti soveltuu vain funktioihin" +msgstr "%qE-attribuutti pätee vain funktioihin" -#: c-family/c-common.c:7865 c-family/c-common.c:7971 c-family/c-common.c:8956 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:7887 c-family/c-common.c:7993 c-family/c-common.c:8976 +#, gcc-internal-format msgid "can%'t set %qE attribute after definition" -msgstr "%Jei voi asettaa %qE-attribuuttia määrittelyn jälkeen" +msgstr "ei voi asettaa %qE-attribuuttia määrittelyn jälkeen" -#: c-family/c-common.c:7911 +#: c-family/c-common.c:7933 #, gcc-internal-format msgid "alloc_size parameter outside range" msgstr "alloc_size-parametri ei ole sallitulla välillä" -#: c-family/c-common.c:8029 +#: c-family/c-common.c:8051 #, fuzzy, gcc-internal-format -#| msgid "%qE attribute ignored" msgid "%qE attribute duplicated" msgstr "%qE-attribuuttia ei huomioida" -#: c-family/c-common.c:8031 +#: c-family/c-common.c:8053 #, fuzzy, gcc-internal-format msgid "%qE attribute follows %qE" -msgstr "%qs-attribuuttia ei huomioida %qs:lle" +msgstr "%qE-attribuuttia ei huomioida %qE:lle" -#: c-family/c-common.c:8130 +#: c-family/c-common.c:8152 #, fuzzy, gcc-internal-format msgid "type was previously declared %qE" msgstr "%Jviimeksi käytetty täällä" -#: c-family/c-common.c:8183 +#: c-family/c-common.c:8205 #, fuzzy, gcc-internal-format -#| msgid "cleanup argument not an identifier" msgid "%qE argument not an identifier" msgstr "puhdistusargumentti ei ole tunniste" -#: c-family/c-common.c:8194 +#: c-family/c-common.c:8216 #, fuzzy, gcc-internal-format msgid "%qD is not compatible with %qD" msgstr "%J%qD on tavallisesti ei-staattinen funktio" -#: c-family/c-common.c:8197 +#: c-family/c-common.c:8219 #, fuzzy, gcc-internal-format -#| msgid "cleanup argument not a function" msgid "transaction_wrap argument is not a function" msgstr "puhdistusargumentti ei ole funktio" -#: c-family/c-common.c:8245 +#: c-family/c-common.c:8267 #, fuzzy, gcc-internal-format msgid "deprecated message is not a string" msgstr "näkyvyysargumentti ei ole merkkijono" -#: c-family/c-common.c:8286 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:8308 +#, gcc-internal-format msgid "%qE attribute ignored for %qE" -msgstr "%qs-attribuuttia ei huomioida %qs:lle" +msgstr "%qE-attribuuttia ei huomioida %qE:lle" -#: c-family/c-common.c:8346 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:8368 +#, gcc-internal-format msgid "invalid vector type for attribute %qE" -msgstr "epäkelpo vektorityyppi attribuutille %qs" +msgstr "epäkelpo vektorityyppi attribuutille %qE" -#: c-family/c-common.c:8352 ada/gcc-interface/utils.c:6307 +#: c-family/c-common.c:8374 ada/gcc-interface/utils.c:6307 #: ada/gcc-interface/utils.c:6401 #, gcc-internal-format msgid "vector size not an integral multiple of component size" msgstr "" -#: c-family/c-common.c:8358 ada/gcc-interface/utils.c:6313 +#: c-family/c-common.c:8380 ada/gcc-interface/utils.c:6313 #: ada/gcc-interface/utils.c:6407 #, gcc-internal-format msgid "zero vector size" msgstr "" -#: c-family/c-common.c:8366 ada/gcc-interface/utils.c:6321 +#: c-family/c-common.c:8388 ada/gcc-interface/utils.c:6321 #: ada/gcc-interface/utils.c:6414 #, gcc-internal-format msgid "number of components of the vector not a power of two" msgstr "vektorin komponenttien määrä ei ole kahden potenssi" -#: c-family/c-common.c:8394 ada/gcc-interface/utils.c:6048 +#: c-family/c-common.c:8416 ada/gcc-interface/utils.c:6048 #, gcc-internal-format msgid "nonnull attribute without arguments on a non-prototype" msgstr "ei-tyhjä attribuutti ilman argumentteja ei-prototyypissä" -#: c-family/c-common.c:8408 ada/gcc-interface/utils.c:6062 +#: c-family/c-common.c:8430 ada/gcc-interface/utils.c:6062 #, gcc-internal-format, gfc-internal-format msgid "nonnull argument has invalid operand number (argument %lu)" msgstr "ei-tyhjällä argumentilla on epäkelpo operandinumero (argumentti %lu)" -#: c-family/c-common.c:8430 ada/gcc-interface/utils.c:6084 +#: c-family/c-common.c:8452 ada/gcc-interface/utils.c:6084 #, gcc-internal-format, gfc-internal-format msgid "nonnull argument with out-of-range operand number (argument %lu, operand %lu)" msgstr "ei-tyhjällä argumentilla arvoalueen ylittävä operandinumero (argumentti %lu,operandi %lu)" # XXX -#: c-family/c-common.c:8438 ada/gcc-interface/utils.c:6093 +#: c-family/c-common.c:8460 ada/gcc-interface/utils.c:6093 #, gcc-internal-format, gfc-internal-format msgid "nonnull argument references non-pointer operand (argument %lu, operand %lu)" msgstr "ei-tyhjä argumentti viittaa ei-osoitinoperandiin (argumentti %lu, operandi %lu)" -#: c-family/c-common.c:8533 +#: c-family/c-common.c:8555 #, fuzzy, gcc-internal-format msgid "not enough variable arguments to fit a sentinel" -msgstr "ei tarpeeksi argumentteja lopetusalkion mahduttamiseksi" +msgstr "ei tarpeeksi muuttuja-argumentteja lopetusalkion mahduttamiseksi" -#: c-family/c-common.c:8547 +#: c-family/c-common.c:8569 #, gcc-internal-format msgid "missing sentinel in function call" msgstr "lopetusalkio puuttuu funktiokutsusta" -#: c-family/c-common.c:8588 +#: c-family/c-common.c:8610 #, gcc-internal-format, gfc-internal-format msgid "null argument where non-null required (argument %lu)" msgstr "tyhjä argumentti, vaikka ei-null vaaditaan (argumentti %lu)" -#: c-family/c-common.c:8653 +#: c-family/c-common.c:8675 #, gcc-internal-format msgid "cleanup argument not an identifier" msgstr "puhdistusargumentti ei ole tunniste" -#: c-family/c-common.c:8660 +#: c-family/c-common.c:8682 #, gcc-internal-format msgid "cleanup argument not a function" msgstr "puhdistusargumentti ei ole funktio" -#: c-family/c-common.c:8697 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:8719 +#, gcc-internal-format msgid "%qE attribute requires prototypes with named arguments" -msgstr "%qs-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja" +msgstr "%qE-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja" -#: c-family/c-common.c:8705 +#: c-family/c-common.c:8727 #, gcc-internal-format msgid "%qE attribute only applies to variadic functions" msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" -#: c-family/c-common.c:8717 ada/gcc-interface/utils.c:6135 +#: c-family/c-common.c:8739 ada/gcc-interface/utils.c:6135 #, gcc-internal-format msgid "requested position is not an integer constant" msgstr "haluttu sijainti ei ole kokonaislukuvakio" -#: c-family/c-common.c:8725 ada/gcc-interface/utils.c:6142 +#: c-family/c-common.c:8747 ada/gcc-interface/utils.c:6142 #, gcc-internal-format msgid "requested position is less than zero" msgstr "haluttu sijainti on pienempi kuin nolla" -#: c-family/c-common.c:8843 +#: c-family/c-common.c:8865 #, gcc-internal-format, gfc-internal-format msgid "bad option %s to optimize attribute" msgstr "" -#: c-family/c-common.c:8846 +#: c-family/c-common.c:8868 #, gcc-internal-format, gfc-internal-format msgid "bad option %s to pragma attribute" msgstr "" -#: c-family/c-common.c:9075 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9095 +#, gcc-internal-format msgid "not enough arguments to function %qE" msgstr "liian vähän argumentteja funktiolle %qE" -#: c-family/c-common.c:9081 c-family/c-common.c:10007 c/c-typeck.c:2954 +#: c-family/c-common.c:9101 c-family/c-common.c:10027 c/c-typeck.c:2954 #, gcc-internal-format msgid "too many arguments to function %qE" msgstr "liian monta argumenttia funktiolle %qE" -#: c-family/c-common.c:9111 c-family/c-common.c:9157 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9131 c-family/c-common.c:9177 +#, gcc-internal-format msgid "non-floating-point argument in call to function %qE" -msgstr "ei-liukulukuargumentti funktiolle %qs" +msgstr "ei-liukulukuargumentti kutsussa funktiolle %qE" -#: c-family/c-common.c:9134 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9154 +#, gcc-internal-format msgid "non-floating-point arguments in call to function %qE" -msgstr "ei-liukulukuargumentti funktiolle %qs" +msgstr "ei-liukulukuargumentteja kutsussa funktiolle %qE" -#: c-family/c-common.c:9150 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9170 +#, gcc-internal-format msgid "non-const integer argument %u in call to function %qE" -msgstr "ei-liukulukuargumentti funktiolle %qs" +msgstr "ei-vakio kokonaiskulukuargumentti %u kutsussa funktiolle %qE" -#: c-family/c-common.c:9170 +#: c-family/c-common.c:9190 #, fuzzy, gcc-internal-format msgid "non-integer argument 3 in call to function %qE" -msgstr "ei-liukulukuargumentti funktiolle %qs" +msgstr "ei-vakio kokonaiskulukuargumentti %u kutsussa funktiolle %qE" -#: c-family/c-common.c:9496 +#: c-family/c-common.c:9516 #, gcc-internal-format msgid "cannot apply %<offsetof%> to static data member %qD" msgstr "" -#: c-family/c-common.c:9501 +#: c-family/c-common.c:9521 #, gcc-internal-format msgid "cannot apply %<offsetof%> when %<operator[]%> is overloaded" msgstr "" -#: c-family/c-common.c:9508 +#: c-family/c-common.c:9528 #, gcc-internal-format msgid "cannot apply %<offsetof%> to a non constant address" msgstr "" -#: c-family/c-common.c:9521 cp/typeck.c:5289 +#: c-family/c-common.c:9541 cp/typeck.c:5289 #, gcc-internal-format msgid "attempt to take address of bit-field structure member %qD" msgstr "" -#: c-family/c-common.c:9573 +#: c-family/c-common.c:9593 #, gcc-internal-format msgid "index %E denotes an offset greater than size of %qT" msgstr "" -#: c-family/c-common.c:9613 +#: c-family/c-common.c:9633 #, gcc-internal-format msgid "the omitted middle operand in ?: will always be %<true%>, suggest explicit middle operand" msgstr "" -#: c-family/c-common.c:9634 +#: c-family/c-common.c:9654 #, fuzzy, gcc-internal-format msgid "assignment of member %qD in read-only object" msgstr "sijoitus kirjoitussuojattuun jäseneen %qD" -#: c-family/c-common.c:9636 +#: c-family/c-common.c:9656 #, fuzzy, gcc-internal-format -#| msgid "increment of data-member %qD in read-only structure" msgid "increment of member %qD in read-only object" msgstr "vain-luku-tietueen datajäsenen %qD kasvatus" -#: c-family/c-common.c:9638 +#: c-family/c-common.c:9658 #, fuzzy, gcc-internal-format -#| msgid "decrement of data-member %qD in read-only structure" msgid "decrement of member %qD in read-only object" msgstr "vain-luku-tietueen datajäsenen %qD vähennys" -#: c-family/c-common.c:9640 +#: c-family/c-common.c:9660 #, fuzzy, gcc-internal-format -#| msgid "read-only location %qE used as %<asm%> output" msgid "member %qD in read-only object used as %<asm%> output" msgstr "kirjoitussuojattua sijaintia %qE käytetään %<asm%>-tulosteena" -#: c-family/c-common.c:9644 +#: c-family/c-common.c:9664 #, gcc-internal-format msgid "assignment of read-only member %qD" msgstr "sijoitus kirjoitussuojattuun jäseneen %qD" -#: c-family/c-common.c:9645 +#: c-family/c-common.c:9665 #, gcc-internal-format msgid "increment of read-only member %qD" msgstr "kirjoitussuojatun jäsenen %qD kasvatus" -#: c-family/c-common.c:9646 +#: c-family/c-common.c:9666 #, gcc-internal-format msgid "decrement of read-only member %qD" msgstr "kirjoitussuojatun jäsenen %qD vähennys" -#: c-family/c-common.c:9647 +#: c-family/c-common.c:9667 #, gcc-internal-format msgid "read-only member %qD used as %<asm%> output" msgstr "" -#: c-family/c-common.c:9651 +#: c-family/c-common.c:9671 #, gcc-internal-format msgid "assignment of read-only variable %qD" msgstr "sijoitus kirjoitussuojattuun muuttujaan %qD" -#: c-family/c-common.c:9652 +#: c-family/c-common.c:9672 #, gcc-internal-format msgid "increment of read-only variable %qD" msgstr "kirjoitussuojatun muuttujan %qD kasvatus" -#: c-family/c-common.c:9653 +#: c-family/c-common.c:9673 #, gcc-internal-format msgid "decrement of read-only variable %qD" msgstr "kirjoitussuojatun muuttujan %qD vähennys" -#: c-family/c-common.c:9654 +#: c-family/c-common.c:9674 #, gcc-internal-format msgid "read-only variable %qD used as %<asm%> output" msgstr "" -#: c-family/c-common.c:9657 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9677 +#, gcc-internal-format msgid "assignment of read-only parameter %qD" -msgstr "sijoitus kirjoitussuojattuun jäseneen %qD" +msgstr "sijoitus kirjoitussuojattuun parametriin %qD" -#: c-family/c-common.c:9658 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9678 +#, gcc-internal-format msgid "increment of read-only parameter %qD" -msgstr "kirjoitussuojatun jäsenen %qD kasvatus" +msgstr "kirjoitussuojatun parametrin %qD kasvatus" -#: c-family/c-common.c:9659 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9679 +#, gcc-internal-format msgid "decrement of read-only parameter %qD" -msgstr "kirjoitussuojatun jäsenen %qD vähennys" +msgstr "kirjoitussuojatun parametrin %qD vähennys" -#: c-family/c-common.c:9660 +#: c-family/c-common.c:9680 #, fuzzy, gcc-internal-format -#| msgid "read-only location %qE used as %<asm%> output" msgid "read-only parameter %qD use as %<asm%> output" -msgstr "kirjoitussuojattua sijaintia %qE käytetään %<asm%>-tulosteena" +msgstr "kirjoitussuojattua parametria %qD käytetään %<asm%>-tulosteena" -#: c-family/c-common.c:9665 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9685 +#, gcc-internal-format msgid "assignment of read-only named return value %qD" -msgstr "kirjoitussuojatun muuttujan %qs sijoitus" +msgstr "sijoitus kirjoitussuojattuun nimettyyn paluuarvoon %qD" -#: c-family/c-common.c:9667 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9687 +#, gcc-internal-format msgid "increment of read-only named return value %qD" -msgstr "kirjoitussuojatun muuttujan %qs sijoitus" +msgstr "kirjoitussuojatun nimetyn paluuarvon %qD kasvatus" -#: c-family/c-common.c:9669 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9689 +#, gcc-internal-format msgid "decrement of read-only named return value %qD" -msgstr "kirjoitussuojatun muuttujan %qs sijoitus" +msgstr "kirjoitussuojatun nimetyn paluuarvon %qD vähennys" -#: c-family/c-common.c:9671 +#: c-family/c-common.c:9691 #, fuzzy, gcc-internal-format -#| msgid "read-only location %qE used as %<asm%> output" msgid "read-only named return value %qD used as %<asm%>output" -msgstr "kirjoitussuojattua sijaintia %qE käytetään %<asm%>-tulosteena" +msgstr "kirjoitussuojattua muuttujaa %qD käytetään %<asm%>-tulosteena" -#: c-family/c-common.c:9676 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9696 +#, gcc-internal-format msgid "assignment of function %qD" -msgstr "Funktio %qs:" +msgstr "funktion %qD sijoitus" -#: c-family/c-common.c:9677 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9697 +#, gcc-internal-format msgid "increment of function %qD" -msgstr "Funktio %qs:" +msgstr "funktion %qD kasvatus" -#: c-family/c-common.c:9678 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9698 +#, gcc-internal-format msgid "decrement of function %qD" -msgstr "Funktio %qs:" +msgstr "funktion %qD vähennys" -#: c-family/c-common.c:9679 +#: c-family/c-common.c:9699 #, fuzzy, gcc-internal-format -#| msgid "read-only location %qE used as %<asm%> output" msgid "function %qD used as %<asm%> output" msgstr "kirjoitussuojattua sijaintia %qE käytetään %<asm%>-tulosteena" -#: c-family/c-common.c:9682 c/c-typeck.c:3902 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9702 c/c-typeck.c:3902 +#, gcc-internal-format msgid "assignment of read-only location %qE" -msgstr "kirjoitussuojatun sijainnin sijoitus" +msgstr "kirjoitussuojatun sijainnin %qE sijoitus" -#: c-family/c-common.c:9683 c/c-typeck.c:3905 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9703 c/c-typeck.c:3905 +#, gcc-internal-format msgid "increment of read-only location %qE" -msgstr "kirjoitussuojatun sijainnin kasvatus" +msgstr "kirjoitussuojatun sijainnin %qE kasvatus" -#: c-family/c-common.c:9684 c/c-typeck.c:3908 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9704 c/c-typeck.c:3908 +#, gcc-internal-format msgid "decrement of read-only location %qE" -msgstr "kirjoitussuojatun sijainnin vähennys" +msgstr "kirjoitussuojatun sijainnin %qE vähennys" -#: c-family/c-common.c:9685 +#: c-family/c-common.c:9705 #, gcc-internal-format msgid "read-only location %qE used as %<asm%> output" msgstr "kirjoitussuojattua sijaintia %qE käytetään %<asm%>-tulosteena" # XXX -#: c-family/c-common.c:9699 +#: c-family/c-common.c:9719 #, gcc-internal-format msgid "lvalue required as left operand of assignment" msgstr "sijoituksen vasemman operandin on oltava lvalue" -#: c-family/c-common.c:9702 +#: c-family/c-common.c:9722 #, gcc-internal-format msgid "lvalue required as increment operand" msgstr "" -#: c-family/c-common.c:9705 +#: c-family/c-common.c:9725 #, gcc-internal-format msgid "lvalue required as decrement operand" msgstr "" -#: c-family/c-common.c:9708 +#: c-family/c-common.c:9728 #, gcc-internal-format msgid "lvalue required as unary %<&%> operand" msgstr "" -#: c-family/c-common.c:9711 +#: c-family/c-common.c:9731 #, fuzzy, gcc-internal-format msgid "lvalue required in asm statement" msgstr "epäkelpo lvalue asm-lauseessa" -#: c-family/c-common.c:9728 +#: c-family/c-common.c:9748 #, fuzzy, gcc-internal-format -#| msgid "invalid type argument of %qs (have %qT)" msgid "invalid type argument (have %qT)" msgstr "virheellinen %qs-tyyppiargumentti (pitäisi olla %qT)" -#: c-family/c-common.c:9732 +#: c-family/c-common.c:9752 #, fuzzy, gcc-internal-format -#| msgid "invalid type argument of %qs (have %qT)" msgid "invalid type argument of array indexing (have %qT)" msgstr "virheellinen %qs-tyyppiargumentti (pitäisi olla %qT)" -#: c-family/c-common.c:9737 +#: c-family/c-common.c:9757 #, fuzzy, gcc-internal-format -#| msgid "invalid type argument of %qs (have %qT)" msgid "invalid type argument of unary %<*%> (have %qT)" msgstr "virheellinen %qs-tyyppiargumentti (pitäisi olla %qT)" -#: c-family/c-common.c:9742 +#: c-family/c-common.c:9762 #, fuzzy, gcc-internal-format -#| msgid "invalid type argument of %qs (have %qT)" msgid "invalid type argument of %<->%> (have %qT)" msgstr "virheellinen %qs-tyyppiargumentti (pitäisi olla %qT)" -#: c-family/c-common.c:9747 +#: c-family/c-common.c:9767 #, fuzzy, gcc-internal-format -#| msgid "invalid type argument of %qs (have %qT)" msgid "invalid type argument of implicit conversion (have %qT)" msgstr "virheellinen %qs-tyyppiargumentti (pitäisi olla %qT)" -#: c-family/c-common.c:9877 cp/init.c:2373 -#, fuzzy, gcc-internal-format +#: c-family/c-common.c:9897 cp/init.c:2373 +#, gcc-internal-format msgid "size of array is too large" -msgstr "taulukon %qs koko on liian suuri" +msgstr "taulukon koko on liian suuri" -#: c-family/c-common.c:9925 c-family/c-common.c:9981 c/c-typeck.c:3185 +#: c-family/c-common.c:9945 c-family/c-common.c:10001 c/c-typeck.c:3185 #, gcc-internal-format msgid "too few arguments to function %qE" msgstr "liian vähän argumentteja funktiolle %qE" -#: c-family/c-common.c:9942 config/mep/mep.c:6175 c/c-typeck.c:5687 +#: c-family/c-common.c:9962 config/mep/mep.c:6175 c/c-typeck.c:5687 #, gcc-internal-format msgid "incompatible type for argument %d of %qE" msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton" -#: c-family/c-common.c:10074 +#: c-family/c-common.c:10094 #, fuzzy, gcc-internal-format msgid "incorrect number of arguments to function %qE" msgstr "liian vähän argumentteja funktiolle %qE" -#: c-family/c-common.c:10082 +#: c-family/c-common.c:10102 #, fuzzy, gcc-internal-format msgid "argument 1 of %qE must be a non-void pointer type" msgstr "ylivuoto vakiolausekkeessa" -#: c-family/c-common.c:10091 +#: c-family/c-common.c:10111 #, fuzzy, gcc-internal-format msgid "argument 1 of %qE must be a pointer to a constant size type" msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta" -#: c-family/c-common.c:10102 +#: c-family/c-common.c:10122 #, fuzzy, gcc-internal-format msgid "argument 1 of %qE must be a pointer to a nonzero size object" msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta" -#: c-family/c-common.c:10117 +#: c-family/c-common.c:10137 #, fuzzy, gcc-internal-format msgid "argument %d of %qE must be a pointer type" msgstr "ylivuoto vakiolausekkeessa" -#: c-family/c-common.c:10124 +#: c-family/c-common.c:10144 #, fuzzy, gcc-internal-format -#| msgid " initializing argument %P of %qD" msgid "size mismatch in argument %d of %qE" msgstr " alustettaessa funktion %2$qD argumenttia %1$P" -#: c-family/c-common.c:10140 +#: c-family/c-common.c:10160 #, fuzzy, gcc-internal-format -#| msgid "incompatible type for argument %d of %qE" msgid "invalid memory model argument %d of %qE" msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton" -#: c-family/c-common.c:10147 +#: c-family/c-common.c:10167 #, fuzzy, gcc-internal-format -#| msgid "incompatible type for argument %d of %qE" msgid "non-integer memory model argument %d of %qE" msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton" -#: c-family/c-common.c:10674 +#: c-family/c-common.c:10694 #, gcc-internal-format msgid "array subscript has type %<char%>" msgstr "taulukon indeksin tyyppi on %<char%>" -#: c-family/c-common.c:10709 c-family/c-common.c:10712 +#: c-family/c-common.c:10729 c-family/c-common.c:10732 #, gcc-internal-format msgid "suggest parentheses around %<+%> inside %<<<%>" msgstr "ehdotetaan sulkeita %<+%>:n ympärille %<<<%>:n sisällä" -#: c-family/c-common.c:10715 c-family/c-common.c:10718 +#: c-family/c-common.c:10735 c-family/c-common.c:10738 #, gcc-internal-format msgid "suggest parentheses around %<-%> inside %<<<%>" msgstr "ehdotetaan sulkeita %<-%>:n ympärille %<<<%>:n sisällä" -#: c-family/c-common.c:10724 c-family/c-common.c:10727 +#: c-family/c-common.c:10744 c-family/c-common.c:10747 #, gcc-internal-format msgid "suggest parentheses around %<+%> inside %<>>%>" msgstr "ehdotetaan sulkeita %<+%>:n ympärille %<>>%>:n sisällä" -#: c-family/c-common.c:10730 c-family/c-common.c:10733 +#: c-family/c-common.c:10750 c-family/c-common.c:10753 #, gcc-internal-format msgid "suggest parentheses around %<-%> inside %<>>%>" msgstr "ehdotetaan sulkeita %<-%>:n ympärille %<>>%>:n sisällä" -#: c-family/c-common.c:10739 c-family/c-common.c:10742 +#: c-family/c-common.c:10759 c-family/c-common.c:10762 #, gcc-internal-format msgid "suggest parentheses around %<&&%> within %<||%>" msgstr "ehdotetaan sulkeita %<&&%>:n ympärille %<||%>:n sisällä" -#: c-family/c-common.c:10749 c-family/c-common.c:10753 +#: c-family/c-common.c:10769 c-family/c-common.c:10773 #, gcc-internal-format msgid "suggest parentheses around arithmetic in operand of %<|%>" msgstr "ehdotetaan sulkeita lausekkeen ympärille %<|%>:n operandissa" -#: c-family/c-common.c:10757 c-family/c-common.c:10760 +#: c-family/c-common.c:10777 c-family/c-common.c:10780 #, gcc-internal-format msgid "suggest parentheses around comparison in operand of %<|%>" msgstr "ehdotetaan sulkeita vertailun ympärille %<|%>:n operandissa" -#: c-family/c-common.c:10765 +#: c-family/c-common.c:10785 #, gcc-internal-format msgid "suggest parentheses around operand of %<!%> or change %<|%> to %<||%> or %<!%> to %<~%>" msgstr "" -#: c-family/c-common.c:10773 c-family/c-common.c:10777 +#: c-family/c-common.c:10793 c-family/c-common.c:10797 #, gcc-internal-format msgid "suggest parentheses around arithmetic in operand of %<^%>" msgstr "ehdotetaan sulkeita lausekkeen ympärille %<^%>:n operandissa" -#: c-family/c-common.c:10781 c-family/c-common.c:10784 +#: c-family/c-common.c:10801 c-family/c-common.c:10804 #, gcc-internal-format msgid "suggest parentheses around comparison in operand of %<^%>" msgstr "ehdotetaan sulkeita vertailun ympärille %<^%>:n operandissa" -#: c-family/c-common.c:10790 c-family/c-common.c:10793 +#: c-family/c-common.c:10810 c-family/c-common.c:10813 #, gcc-internal-format msgid "suggest parentheses around %<+%> in operand of %<&%>" msgstr "ehdotetaan sulkeita %<+%>:n ympärille %<&%>:n operandissa" -#: c-family/c-common.c:10796 c-family/c-common.c:10799 +#: c-family/c-common.c:10816 c-family/c-common.c:10819 #, gcc-internal-format msgid "suggest parentheses around %<-%> in operand of %<&%>" msgstr "ehdotetaan sulkeita %<-%>:n ympärille %<&%>:n operandissa" -#: c-family/c-common.c:10803 c-family/c-common.c:10806 +#: c-family/c-common.c:10823 c-family/c-common.c:10826 #, gcc-internal-format msgid "suggest parentheses around comparison in operand of %<&%>" msgstr "ehdotetaan sulkeita vertailun ympärille %<&%>:n operandissa" -#: c-family/c-common.c:10811 +#: c-family/c-common.c:10831 #, gcc-internal-format msgid "suggest parentheses around operand of %<!%> or change %<&%> to %<&&%> or %<!%> to %<~%>" msgstr "" -#: c-family/c-common.c:10818 c-family/c-common.c:10821 +#: c-family/c-common.c:10838 c-family/c-common.c:10841 #, gcc-internal-format msgid "suggest parentheses around comparison in operand of %<==%>" msgstr "ehdotetaan sulkeita vertailun ympärille %<==%>:n operandissa" -#: c-family/c-common.c:10826 c-family/c-common.c:10829 +#: c-family/c-common.c:10846 c-family/c-common.c:10849 #, gcc-internal-format msgid "suggest parentheses around comparison in operand of %<!=%>" msgstr "ehdotetaan sulkeita vertailun ympärille %<!=%>:n operandissa" -#: c-family/c-common.c:10839 c-family/c-common.c:10845 +#: c-family/c-common.c:10859 c-family/c-common.c:10865 #, gcc-internal-format msgid "comparisons like %<X<=Y<=Z%> do not have their mathematical meaning" msgstr "%<X<=Y<=Z%> -tyylisillä vertailuilla on eri merkitys kuin matematiikassa" -#: c-family/c-common.c:10861 +#: c-family/c-common.c:10881 #, gcc-internal-format msgid "label %q+D defined but not used" msgstr "nimike %q+D määritelty mutta käytettämättä" -#: c-family/c-common.c:10863 +#: c-family/c-common.c:10883 #, gcc-internal-format msgid "label %q+D declared but not defined" msgstr "nimike %qD esitelty muttei määritelty" -#: c-family/c-common.c:10879 +#: c-family/c-common.c:10899 #, gcc-internal-format msgid "division by zero" msgstr "jako nollalla" -#: c-family/c-common.c:10911 +#: c-family/c-common.c:10931 #, gcc-internal-format msgid "comparison between types %qT and %qT" msgstr "tyyppien %qT ja %qT välinen vertailu" -#: c-family/c-common.c:10962 +#: c-family/c-common.c:10982 #, gcc-internal-format msgid "comparison between signed and unsigned integer expressions" msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu" -#: c-family/c-common.c:11013 +#: c-family/c-common.c:11033 #, gcc-internal-format msgid "promoted ~unsigned is always non-zero" msgstr "" -#: c-family/c-common.c:11016 +#: c-family/c-common.c:11036 #, gcc-internal-format msgid "comparison of promoted ~unsigned with constant" msgstr "" -#: c-family/c-common.c:11026 +#: c-family/c-common.c:11046 #, gcc-internal-format msgid "comparison of promoted ~unsigned with unsigned" msgstr "" -#: c-family/c-common.c:11204 +#: c-family/c-common.c:11224 #, fuzzy, gcc-internal-format msgid "typedef %qD locally defined but not used" msgstr "%Jnimike %qD määritelty, mutta ei käytetty" -#: c-family/c-common.c:11443 +#: c-family/c-common.c:11463 #, gcc-internal-format msgid "index value is out of bound" msgstr "" -#: c-family/c-common.c:11481 c-family/c-common.c:11531 -#: c-family/c-common.c:11546 +#: c-family/c-common.c:11501 c-family/c-common.c:11551 +#: c-family/c-common.c:11566 #, fuzzy, gcc-internal-format -#| msgid "conversion from %qT to %qT is ambiguous" msgid "conversion of scalar %qT to vector %qT involves truncation" msgstr "muunnos tyypistä %qT tyyppiin %qT on moniselitteinen" @@ -19358,7 +19168,6 @@ msgstr "funktio ei palauta merkkijonotyyppiä" #: c-family/c-format.c:153 #, fuzzy, gcc-internal-format -#| msgid "format string argument not a string type" msgid "format string argument is not a string type" msgstr "muotomerkkijonoargumentti ei ole merkkijonotyyppiä" @@ -19379,7 +19188,6 @@ msgstr "" #: c-family/c-format.c:214 #, fuzzy, gcc-internal-format -#| msgid "first argument of %q+D should be %<int%>" msgid "format argument should be a %<%s%> reference" msgstr "%q+D:n ensimmäisen argumentin pitäisi olla %<int%>" @@ -19394,9 +19202,9 @@ msgid "%qE is only allowed in Objective-C dialects" msgstr "%qs ei ole kelpo tulostetiedosto" #: c-family/c-format.c:282 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE is an unrecognized format function type" -msgstr "%qs on tunnistamaton muotofunktiotyyppi" +msgstr "%qE on tunnistamaton muotofunktiotyyppi" #: c-family/c-format.c:296 #, gcc-internal-format @@ -19639,25 +19447,21 @@ msgstr "ylimääräisiä tyyppimääreitä muotoiluargumentissa (argumentti %d)" #: c-family/c-format.c:2490 #, fuzzy, gcc-internal-format -#| msgid "format %q.*s expects type %<%s%s%>, but argument %d has type %qT" msgid "%s %<%s%.*s%> expects argument of type %<%s%s%>, but argument %d has type %qT" msgstr "muotoilu %q.*s odottaa tyyppiä %<%s%s%>, mutta %d. argumentin tyyppi on %qT" #: c-family/c-format.c:2497 #, fuzzy, gcc-internal-format -#| msgid "%qs expects a constant argument" msgid "%s %<%s%.*s%> expects a matching %<%s%s%> argument" msgstr "%qs odottaa vakioargumenttia" #: c-family/c-format.c:2505 #, fuzzy, gcc-internal-format -#| msgid "format %q.*s expects type %<%T%s%>, but argument %d has type %qT" msgid "%s %<%s%.*s%> expects argument of type %<%T%s%>, but argument %d has type %qT" msgstr "muotoilu %q.*s odottaa %<%T%s%>-tyyppiä, mutta %d. argumentin tyyppi on %qT" #: c-family/c-format.c:2512 #, fuzzy, gcc-internal-format -#| msgid "%qs expects a constant argument" msgid "%s %<%s%.*s%> expects a matching %<%T%s%> argument" msgstr "%qs odottaa vakioargumenttia" @@ -19749,7 +19553,6 @@ msgstr "tämä desimaalivakio olisi etumerkitön ISO C90 -standardissa" #: c-family/c-lex.c:666 #, fuzzy, gcc-internal-format -#| msgid "integer constant is too large for %qs type" msgid "integer constant is too large for %<unsigned long%> type" msgstr "kokonaislukuvakio on liian suuri tyypille %qs" @@ -19809,14 +19612,14 @@ msgid "%<#pragma omp atomic capture%> uses two different variables for memory" msgstr "" #: c-family/c-omp.c:367 cp/semantics.c:4880 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid type for iteration variable %qE" -msgstr "epäkelpo vektorityyppi attribuutille %qs" +msgstr "virheellinen tyyppi iterointimuuttujalle %qE" #: c-family/c-omp.c:380 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE is not initialized" -msgstr "parametri %qD on alustettu" +msgstr "%qE:a ei ole alustettu" #: c-family/c-omp.c:397 cp/semantics.c:4795 #, gcc-internal-format @@ -19866,7 +19669,7 @@ msgstr "tulostiedosto annettu kahdesti" #: c-family/c-opts.c:822 #, gcc-internal-format msgid "-fexcess-precision=standard for C++" -msgstr "" +msgstr "-fexcess-precision=standard C++-kielelle" #: c-family/c-opts.c:835 #, gcc-internal-format @@ -19961,7 +19764,7 @@ msgstr "" #: c-family/c-opts.c:1401 #, gcc-internal-format msgid "too late for # directive to set debug directory" -msgstr "#-opastimen on myöhäistä asettaa debug-hakemistoa" +msgstr "#-opastimen on liian myöhäistä asettaa vianjäljityshakemistoa" #: c-family/c-pch.c:115 #, gcc-internal-format @@ -19973,37 +19776,37 @@ msgstr "ei voida luoda esikäännettyä otsikkoa %s: %m" msgid "can%'t write to %s: %m" msgstr "ei voi kirjoittaa tiedostoon %s: %m" -#: c-family/c-pch.c:191 +#: c-family/c-pch.c:193 #, gcc-internal-format msgid "can%'t write %s: %m" msgstr "ei voi kirjoittaa tiedostoon %s: %m" -#: c-family/c-pch.c:219 c-family/c-pch.c:260 c-family/c-pch.c:311 +#: c-family/c-pch.c:221 c-family/c-pch.c:262 c-family/c-pch.c:313 #, gcc-internal-format msgid "can%'t read %s: %m" msgstr "ei voi lukea tiedostoa %s: %m" -#: c-family/c-pch.c:417 +#: c-family/c-pch.c:419 #, gcc-internal-format msgid "pch_preprocess pragma should only be used with -fpreprocessed" msgstr "pch_preprocess-pragmaa tulee käyttää vain valitsimen -fpreprocessed kanssa" -#: c-family/c-pch.c:418 +#: c-family/c-pch.c:420 #, gcc-internal-format msgid "use #include instead" msgstr "käytä #includea sen sijaan" -#: c-family/c-pch.c:424 +#: c-family/c-pch.c:426 #, gcc-internal-format msgid "%s: couldn%'t open PCH file: %m" -msgstr "%s: ei voida avata PCH-tiedostoa: %m" +msgstr "%s: ei voitu avata PCH-tiedostoa: %m" -#: c-family/c-pch.c:429 +#: c-family/c-pch.c:431 #, gcc-internal-format msgid "use -Winvalid-pch for more information" msgstr "käytä -Winvalid-pch saadaksesi lisätietoja" -#: c-family/c-pch.c:430 +#: c-family/c-pch.c:432 #, gcc-internal-format, gfc-internal-format msgid "%s: PCH file was invalid" msgstr "%s: PCH-tiedosto oli epäkelpo" @@ -20044,9 +19847,9 @@ msgid "malformed %<#pragma pack(pop[, id])%> - ignored" msgstr "väärinmuodostettu %<#pragma pack(pop[, id])%> - jätetään huomiotta" #: c-family/c-pragma.c:173 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "unknown action %qE for %<#pragma pack%> - ignored" -msgstr "tuntematon toiminto %qs ilmaisulle %<#pragma pack%> - jätetään huomiotta" +msgstr "tuntematon toiminto %qE ilmaisulle %<#pragma pack%> - jätetään huomiotta" #: c-family/c-pragma.c:202 #, gcc-internal-format @@ -20061,12 +19864,12 @@ msgstr "#pragma pack ei vaikuta -fpack-struct-valitsimen kanssa - jätetään hu #: c-family/c-pragma.c:225 #, gcc-internal-format, gfc-internal-format msgid "alignment must be a small power of two, not %d" -msgstr "tasauksen pitää olla kahden potenssi, ei %d" +msgstr "kohdistuksen pitää olla kahden potenssi, ei %d" #: c-family/c-pragma.c:263 #, fuzzy, gcc-internal-format msgid "applying #pragma weak %q+D after first use results in unspecified behavior" -msgstr "%J#pragma weak %qD -ilmaisun soveltaminen ensimmäisen käytön jälkeen käyttäytyy määrittelemättömästi" +msgstr "#pragma weak %q+D -ilmaisun soveltaminen ensimmäisen käytön jälkeen johtaa määrittelemättömään toimintaan" #: c-family/c-pragma.c:354 c-family/c-pragma.c:359 #, gcc-internal-format @@ -20074,9 +19877,9 @@ msgid "malformed #pragma weak, ignored" msgstr "väärinmuodostettu #pragma weak, jätetään huomiotta" #: c-family/c-pragma.c:363 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "junk at end of %<#pragma weak%>" -msgstr "roskaa ilmaisun %<#pragma pack%> lopussa" +msgstr "roskaa ilmaisun %<#pragma weak%> lopussa" #: c-family/c-pragma.c:430 c-family/c-pragma.c:432 #, gcc-internal-format @@ -20084,9 +19887,9 @@ msgid "malformed #pragma redefine_extname, ignored" msgstr "väärinmuodostettu #pragma redefine_extname, jätetään huomiotta" #: c-family/c-pragma.c:435 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "junk at end of %<#pragma redefine_extname%>" -msgstr "roskaa ilmaisun #pragma redefine_extname lopussa" +msgstr "roskaa ilmaisun %<#pragma redefine_extname%> lopussa" #: c-family/c-pragma.c:464 c-family/c-pragma.c:537 #, gcc-internal-format @@ -20119,9 +19922,9 @@ msgid "#pragma GCC visibility must be followed by push or pop" msgstr "#pragma GCC visibility -ilmaisua pitää seurata joko push tai pop" #: c-family/c-pragma.c:668 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "no matching push for %<#pragma GCC visibility pop%>" -msgstr "Vastaava push puuttuu ilmaisulle %<#pragma GCC visibility pop%>" +msgstr "vastaava push puuttuu ilmaisulta %<#pragma GCC visibility pop%>" #: c-family/c-pragma.c:673 c-family/c-pragma.c:680 #, gcc-internal-format @@ -20159,14 +19962,14 @@ msgid "unknown option after %<#pragma GCC diagnostic%> kind" msgstr "tuntematon toiminto %qs ilmaisulle %<#pragma pack%> - jätetään huomiotta" #: c-family/c-pragma.c:747 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "#pragma GCC option is not allowed inside functions" -msgstr "#pragma GCC diagnostic ei ole sallittu funktion sisällä" +msgstr "#pragma GCC option ei ole sallittu funktioiden sisällä" #: c-family/c-pragma.c:760 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<#pragma GCC option%> is not a string" -msgstr "väärinmuodostettu #pragma GCC pch_preprocess, jätetään huomiotta" +msgstr "%<#pragma GCC option%> ei ole merkkijono" #: c-family/c-pragma.c:787 #, gcc-internal-format @@ -20179,9 +19982,9 @@ msgid "#pragma GCC target string... is badly formed" msgstr "" #: c-family/c-pragma.c:816 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "#pragma GCC optimize is not allowed inside functions" -msgstr "#pragma GCC diagnostic ei ole sallittu funktion sisällä" +msgstr "#pragma GCC optimize ei ole sallittu funktioiden sisällä" #: c-family/c-pragma.c:829 #, gcc-internal-format @@ -20199,14 +20002,14 @@ msgid "#pragma GCC optimize string... is badly formed" msgstr "" #: c-family/c-pragma.c:903 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "junk at end of %<#pragma push_options%>" -msgstr "roskaa ilmaisun %<#pragma pack%> lopussa" +msgstr "roskaa ilmaisun %<#pragma push_options%> lopussa" #: c-family/c-pragma.c:933 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "junk at end of %<#pragma pop_options%>" -msgstr "roskaa ilmaisun %<#pragma pack%> lopussa" +msgstr "roskaa ilmaisun %<#pragma pop_options%> lopussa" #: c-family/c-pragma.c:940 #, gcc-internal-format @@ -20214,44 +20017,44 @@ msgid "%<#pragma GCC pop_options%> without a corresponding %<#pragma GCC push_op msgstr "" #: c-family/c-pragma.c:982 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "junk at end of %<#pragma reset_options%>" -msgstr "roskaa ilmaisun #pragma extern_prefix lopussa" +msgstr "roskaa ilmaisun %<#pragma reset_options%> lopussa" #: c-family/c-pragma.c:1020 c-family/c-pragma.c:1027 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "expected a string after %<#pragma message%>" -msgstr "leveä merkkijonovakio %<asm%>-lauseessa" +msgstr "odotettiin merkkijonoa ilmaisun %<#pragma message%> jälkeen" #: c-family/c-pragma.c:1022 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "malformed %<#pragma message%>, ignored" -msgstr "väärinmuodostettu #pragma weak, jätetään huomiotta" +msgstr "väärinmuodostettu %<#pragma message%>, jätetään huomiotta" #: c-family/c-pragma.c:1032 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "junk at end of %<#pragma message%>" -msgstr "roskaa ilmaisun %<#pragma pack%> lopussa" +msgstr "roskaa ilmaisun %<#pragma message%> lopussa" #: c-family/c-pragma.c:1035 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "#pragma message: %s" -msgstr "ohjelmat: %s\n" +msgstr "#pragma message: %s" #: c-family/c-pragma.c:1072 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid location for %<pragma %s%>, ignored" -msgstr "väärinmuodostettu %<#pragma pack%> - jätetään huomiotta" +msgstr "virheelinen sijainti ilmaisulle %<#pragma %s%>, jätetään huomiotta" #: c-family/c-pragma.c:1079 c-family/c-pragma.c:1093 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "malformed %<#pragma %s%>, ignored" -msgstr "väärinmuodostettu #pragma weak, jätetään huomiotta" +msgstr "väärinmuodostettu %<#pragma %s%>, jätetään huomiotta" #: c-family/c-pragma.c:1099 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "junk at end of %<#pragma %s%>" -msgstr "roskaa #pragma %s:n lopussa" +msgstr "roskaa %<#pragma %s%>:n lopussa" #: c-family/c-pragma.c:1117 #, gcc-internal-format @@ -20270,13 +20073,11 @@ msgstr "" #: c-family/c-semantics.c:157 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "wrong type argument to abs" msgid "wrong type argument to %s" msgstr "abs-funktiolle annettu väärä tyyppiargumentti" #: c-family/cppspec.c:92 #, fuzzy, gcc-internal-format -#| msgid "\"%s\" is not a valid option to the preprocessor" msgid "%qs is not a valid option to the preprocessor" msgstr "”%s” ei ole kelvollinen esikääntäjän valitsin" @@ -20296,9 +20097,9 @@ msgid "-mshared-library-id=%s is not between 0 and %d" msgstr "" #: common/config/bfin/bfin-common.c:323 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "-mcpu=%s is not valid" -msgstr "%qs ei ole kelpo tulostetiedosto" +msgstr "-mcpu=%s ei ole kelvollinen" #: common/config/bfin/bfin-common.c:359 #, gcc-internal-format, gfc-internal-format @@ -20392,9 +20193,8 @@ msgstr "" #: common/config/v850/v850-common.c:47 #, fuzzy, gcc-internal-format -#| msgid "requested alignment is too large" msgid "value passed in %qs is too large" -msgstr "pyydetty tasaus on liian suuri" +msgstr "pyydetty kohdistus on liian suuri" #: config/darwin-c.c:87 #, gcc-internal-format @@ -20420,12 +20220,12 @@ msgstr "" #: config/darwin-c.c:139 #, gcc-internal-format msgid "missing '(' after '#pragma unused', ignoring" -msgstr "puuttuva ”(” pragman ”#pragma unused” jälkeen, jätetään huomiotta" +msgstr "puuttuva ”(” ilmaisun ”#pragma unused” jälkeen, jätetään huomiotta" #: config/darwin-c.c:160 #, gcc-internal-format msgid "missing ')' after '#pragma unused', ignoring" -msgstr "puuttuva ”)” pragman ”#pragma unused” jälkeen, jätetään huomiotta" +msgstr "puuttuva ”)” ilmaisun ”#pragma unused” jälkeen, jätetään huomiotta" #: config/darwin-c.c:163 #, gcc-internal-format @@ -20443,9 +20243,9 @@ msgid "malformed '#pragma ms_struct {on|off|reset}', ignoring" msgstr "väärinmuodostettu ”#pragma ms_struct {on|off|reset}”, jätetään huomiotta" #: config/darwin-c.c:185 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "junk at end of '#pragma ms_struct'" -msgstr "roskaa ilmaisun #pragma weak lopussa" +msgstr "roskaa ilmaisun ”#pragma ms_struct” lopussa" #: config/darwin-c.c:411 #, gcc-internal-format, gfc-internal-format @@ -20454,7 +20254,6 @@ msgstr "" #: config/darwin-c.c:594 #, fuzzy, gcc-internal-format -#| msgid "Unknown value %qs of -mmacosx-version-min" msgid "unknown value %qs of -mmacosx-version-min" msgstr "Tuntematon -mmacosx-version-min-arvo %qs" @@ -20490,7 +20289,6 @@ msgstr "" #: config/darwin.c:2689 #, fuzzy, gcc-internal-format -#| msgid "weakref is not supported in this configuration" msgid "protected visibility attribute not supported in this configuration; ignored" msgstr "weakref ei ole tuettu tässä konfiguraatiossa" @@ -20516,13 +20314,11 @@ msgstr "" #: config/darwin.c:3294 #, fuzzy, gcc-internal-format -#| msgid "built-in function %q+D declared as non-function" msgid "built-in function %qD requires the %<-mconstant-cfstrings%> flag" msgstr "sisäinen funktio %q+D esitelty ei-funktiona" #: config/darwin.c:3301 #, fuzzy, gcc-internal-format -#| msgid "built-in function %q+D declared as non-function" msgid "built-in function %qD takes one argument only" msgstr "sisäinen funktio %q+D esitelty ei-funktiona" @@ -20629,18 +20425,16 @@ msgstr "profilointituki VxWorksille" #: config/aarch64/aarch64-builtins.c:1032 #, fuzzy, gcc-internal-format -#| msgid "incompatible type for argument %d of %qE" msgid "incompatible type for argument %d, expected %<const int%>" msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton" #: config/aarch64/aarch64.c:3643 #, gcc-internal-format msgid "function profiling" -msgstr "" +msgstr "funktioprofilointi" #: config/aarch64/aarch64.c:4623 #, fuzzy, gcc-internal-format -#| msgid "missing filename after %qs" msgid "missing feature modifier after %qs" msgstr "tiedostonimi puuttuu %qs:n jälkeen" @@ -20652,34 +20446,29 @@ msgstr "tuntematon konetila %qs" #: config/aarch64/aarch64.c:4675 #, fuzzy, gcc-internal-format -#| msgid "missing path after %qs" msgid "missing arch name in -march=%qs" msgstr "polku puuttuu %qs:n jälkeen" #. ARCH name not found in list. #: config/aarch64/aarch64.c:4699 #, fuzzy, gcc-internal-format -#| msgid "Unknown value %qs of -mmacosx-version-min" msgid "unknown value %qs for -march" msgstr "Tuntematon -mmacosx-version-min-arvo %qs" #: config/aarch64/aarch64.c:4724 #, fuzzy, gcc-internal-format -#| msgid "missing path after %qs" msgid "missing cpu name in -mcpu=%qs" msgstr "polku puuttuu %qs:n jälkeen" #. CPU name not found in list. #: config/aarch64/aarch64.c:4747 #, fuzzy, gcc-internal-format -#| msgid "Unknown value %qs of -mmacosx-version-min" msgid "unknown value %qs for -mcpu" msgstr "Tuntematon -mmacosx-version-min-arvo %qs" #. CPU name not found in list. #: config/aarch64/aarch64.c:4771 #, fuzzy, gcc-internal-format -#| msgid "Unknown value %qs of -mmacosx-version-min" msgid "unknown value %qs for -mtune" msgstr "Tuntematon -mmacosx-version-min-arvo %qs" @@ -20847,9 +20636,8 @@ msgstr "AAPCS ei tue valitsinta -mcallee-super-interworking" #: config/arm/arm.c:1923 #, fuzzy, gcc-internal-format -#| msgid "-fpic and -mapcs-reent are incompatible" msgid "iWMMXt and NEON are incompatible" -msgstr "-fpic ja -mapcs-reent ovat yhteensopimattomat" +msgstr "iWMMXt ja NEON ovat yhteensopimattomat" #: config/arm/arm.c:1927 #, gcc-internal-format @@ -20937,195 +20725,193 @@ msgstr "" #: config/i386/i386.c:34639 config/i386/i386.c:34690 config/i386/i386.c:34762 #: config/m68k/m68k.c:729 config/mcore/mcore.c:3046 config/mep/mep.c:3887 #: config/mep/mep.c:3901 config/mep/mep.c:3975 config/rl78/rl78.c:480 -#: config/rs6000/rs6000.c:24833 config/rx/rx.c:2571 config/sh/sh.c:9515 -#: config/sh/sh.c:9533 config/sh/sh.c:9562 config/sh/sh.c:9644 -#: config/sh/sh.c:9667 config/spu/spu.c:3685 config/stormy16/stormy16.c:2207 +#: config/rs6000/rs6000.c:24833 config/rx/rx.c:2571 config/sh/sh.c:9512 +#: config/sh/sh.c:9530 config/sh/sh.c:9559 config/sh/sh.c:9641 +#: config/sh/sh.c:9664 config/spu/spu.c:3685 config/stormy16/stormy16.c:2207 #: config/v850/v850.c:2082 #, fuzzy, gcc-internal-format msgid "%qE attribute only applies to functions" msgstr "attribuutti %qs pätee vain funktiotyyppeihin" -#: config/arm/arm.c:19315 +#: config/arm/arm.c:19325 #, gcc-internal-format msgid "unable to compute real location of stacked parameter" msgstr "" -#: config/arm/arm.c:21257 +#: config/arm/arm.c:21267 #, fuzzy, gcc-internal-format msgid "argument must be a constant" msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" #. @@@ better error message -#: config/arm/arm.c:21632 config/arm/arm.c:21736 +#: config/arm/arm.c:21642 config/arm/arm.c:21746 #, gcc-internal-format msgid "selector must be an immediate" msgstr "" -#: config/arm/arm.c:21640 config/arm/arm.c:21685 config/arm/arm.c:21743 -#: config/arm/arm.c:21752 +#: config/arm/arm.c:21650 config/arm/arm.c:21695 config/arm/arm.c:21753 +#: config/arm/arm.c:21762 #, gcc-internal-format msgid "the range of selector should be in 0 to 7" msgstr "" -#: config/arm/arm.c:21645 config/arm/arm.c:21754 +#: config/arm/arm.c:21655 config/arm/arm.c:21764 #, gcc-internal-format msgid "the range of selector should be in 0 to 3" msgstr "" -#: config/arm/arm.c:21650 config/arm/arm.c:21756 +#: config/arm/arm.c:21660 config/arm/arm.c:21766 #, gcc-internal-format msgid "the range of selector should be in 0 to 1" msgstr "" -#: config/arm/arm.c:21822 +#: config/arm/arm.c:21832 #, gcc-internal-format msgid "mask must be an immediate" msgstr "" -#: config/arm/arm.c:21827 +#: config/arm/arm.c:21837 #, fuzzy, gcc-internal-format msgid "the range of mask should be in 0 to 255" msgstr "haluttu sijainti ei ole kokonaislukuvakio" -#: config/arm/arm.c:22015 +#: config/arm/arm.c:22025 #, gcc-internal-format msgid "the range of count should be in 0 to 32. please check the intrinsic _mm_rori_pi16 in code." msgstr "" -#: config/arm/arm.c:22017 +#: config/arm/arm.c:22027 #, gcc-internal-format msgid "the range of count should be in 0 to 32. please check the intrinsic _mm_rori_pi32 in code." msgstr "" -#: config/arm/arm.c:22019 +#: config/arm/arm.c:22029 #, gcc-internal-format msgid "the range of count should be in 0 to 32. please check the intrinsic _mm_ror_pi16 in code." msgstr "" -#: config/arm/arm.c:22021 +#: config/arm/arm.c:22031 #, gcc-internal-format msgid "the range of count should be in 0 to 32. please check the intrinsic _mm_ror_pi32 in code." msgstr "" -#: config/arm/arm.c:22027 +#: config/arm/arm.c:22037 #, gcc-internal-format msgid "the range of count should be in 0 to 64. please check the intrinsic _mm_rori_si64 in code." msgstr "" -#: config/arm/arm.c:22029 +#: config/arm/arm.c:22039 #, gcc-internal-format msgid "the range of count should be in 0 to 64. please check the intrinsic _mm_ror_si64 in code." msgstr "" -#: config/arm/arm.c:22034 +#: config/arm/arm.c:22044 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_srli_pi16 in code." msgstr "" -#: config/arm/arm.c:22036 +#: config/arm/arm.c:22046 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_srli_pi32 in code." msgstr "" -#: config/arm/arm.c:22038 +#: config/arm/arm.c:22048 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_srli_si64 in code." msgstr "" -#: config/arm/arm.c:22040 +#: config/arm/arm.c:22050 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_slli_pi16 in code." msgstr "" -#: config/arm/arm.c:22042 +#: config/arm/arm.c:22052 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_slli_pi32 in code." msgstr "" -#: config/arm/arm.c:22044 +#: config/arm/arm.c:22054 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_slli_si64 in code." msgstr "" -#: config/arm/arm.c:22046 +#: config/arm/arm.c:22056 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_srai_pi16 in code." msgstr "" -#: config/arm/arm.c:22048 +#: config/arm/arm.c:22058 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_srai_pi32 in code." msgstr "" -#: config/arm/arm.c:22050 +#: config/arm/arm.c:22060 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_srai_si64 in code." msgstr "" -#: config/arm/arm.c:22052 +#: config/arm/arm.c:22062 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_srl_pi16 in code." msgstr "" -#: config/arm/arm.c:22054 +#: config/arm/arm.c:22064 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_srl_pi32 in code." msgstr "" -#: config/arm/arm.c:22056 +#: config/arm/arm.c:22066 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_srl_si64 in code." msgstr "" -#: config/arm/arm.c:22058 +#: config/arm/arm.c:22068 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_sll_pi16 in code." msgstr "" -#: config/arm/arm.c:22060 +#: config/arm/arm.c:22070 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_sll_pi32 in code." msgstr "" -#: config/arm/arm.c:22062 +#: config/arm/arm.c:22072 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_sll_si64 in code." msgstr "" -#: config/arm/arm.c:22064 +#: config/arm/arm.c:22074 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_sra_pi16 in code." msgstr "" -#: config/arm/arm.c:22066 +#: config/arm/arm.c:22076 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_sra_pi32 in code." msgstr "" -#: config/arm/arm.c:22068 +#: config/arm/arm.c:22078 #, gcc-internal-format msgid "the count should be no less than 0. please check the intrinsic _mm_sra_si64 in code." msgstr "" -#: config/arm/arm.c:22787 +#: config/arm/arm.c:22797 #, gcc-internal-format msgid "no low registers available for popping high registers" msgstr "" -#: config/arm/arm.c:23012 +#: config/arm/arm.c:23022 #, gcc-internal-format msgid "interrupt Service Routines cannot be coded in Thumb mode" msgstr "" #: config/avr/avr-c.c:65 config/avr/avr-c.c:190 #, fuzzy, gcc-internal-format -#| msgid "%qs expects a constant argument" msgid "%qs expects 1 argument but %d given" msgstr "%qs odottaa vakioargumenttia" #: config/avr/avr-c.c:76 #, fuzzy, gcc-internal-format -#| msgid "%qs expects a constant argument" msgid "%qs expects a fixed-point value as argument" msgstr "%qs odottaa vakioargumenttia" @@ -21141,19 +20927,16 @@ msgstr "" #: config/avr/avr-c.c:124 #, fuzzy, gcc-internal-format -#| msgid "%qs expects a constant argument" msgid "%qs expects 2 arguments but %d given" msgstr "%qs odottaa vakioargumenttia" #: config/avr/avr-c.c:136 config/avr/avr-c.c:201 #, fuzzy, gcc-internal-format -#| msgid "%qs expects a constant argument" msgid "%qs expects a fixed-point value as first argument" msgstr "%qs odottaa vakioargumenttia" #: config/avr/avr-c.c:144 #, fuzzy, gcc-internal-format -#| msgid "%qs expects a constant argument" msgid "%qs expects an integer value as second argument" msgstr "%qs odottaa vakioargumenttia" @@ -21257,24 +21040,27 @@ msgstr "" msgid "MCU %qs supported for assembler only" msgstr "" -#: config/avr/avr.c:11718 +#: config/avr/avr.c:10816 +#, fuzzy, gcc-internal-format +msgid "conversion from address space %qs to address space %qs" +msgstr "muunnos tyypistä %qT tyyppiin %qT" + +#: config/avr/avr.c:11778 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "case label does not reduce to an integer constant" msgid "%s expects a compile time integer constant" msgstr "case-nimike ei pelkisty kokonaislukuvakioksi" -#: config/avr/avr.c:11732 +#: config/avr/avr.c:11792 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "%qs expects a constant argument" msgid "%s expects a compile time long integer constant as first argument" msgstr "%qs odottaa vakioargumenttia" -#: config/avr/avr.c:11760 +#: config/avr/avr.c:11820 #, gcc-internal-format, gfc-internal-format msgid "rounding to %d bits has no effect for fixed-point value with %d fractional bits" msgstr "" -#: config/avr/avr.c:11769 +#: config/avr/avr.c:11829 #, gcc-internal-format msgid "rounding result will always be 0" msgstr "" @@ -21287,7 +21073,7 @@ msgstr "" #: config/bfin/bfin.c:2356 #, gcc-internal-format msgid "-mshared-library-id= specified without -mid-shared-library" -msgstr "" +msgstr "-mshared-library-id= määritelty ilman valitsinta -mid-shared-library" #: config/bfin/bfin.c:2360 #, gcc-internal-format @@ -21307,7 +21093,7 @@ msgstr "valitsimia -mbig-endian ja -mlittle-endian ei voi käyttää yhdessä" #: config/bfin/bfin.c:2373 config/m68k/m68k.c:535 #, gcc-internal-format msgid "cannot specify both -msep-data and -mid-shared-library" -msgstr "" +msgstr "ei voi määritellä sekä valitsinta -msep-date että -mid-shared-library" #: config/bfin/bfin.c:2393 #, gcc-internal-format @@ -21325,9 +21111,9 @@ msgid "-mcoreb should be used with -mmulticore" msgstr "" #: config/bfin/bfin.c:2402 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "-mcorea and -mcoreb can%'t be used together" -msgstr "valitsimia -mbig-endian ja -mlittle-endian ei voi käyttää yhdessä" +msgstr "valitsimia -mcorea ja -mcoreb ei voi käyttää yhdessä" #: config/bfin/bfin.c:4641 #, fuzzy, gcc-internal-format @@ -21341,9 +21127,9 @@ msgstr "" #: config/bfin/bfin.c:4758 config/i386/winnt.c:60 config/mep/mep.c:3791 #: config/mep/mep.c:3929 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE attribute only applies to variables" -msgstr "attribuutti %qE pätee vain muuttujiin" +msgstr "%qE-attribuutti pätee vain muuttujiin" #: config/bfin/bfin.c:4765 #, fuzzy, gcc-internal-format @@ -21371,10 +21157,9 @@ msgid "invalid data model option -mdata-model=%s" msgstr "epäkelpo osoitintila %qs" #: config/cr16/cr16.h:431 -#, fuzzy, gcc-internal-format -#| msgid "profiler support for VxWorks" +#, gcc-internal-format msgid "profiler support for CR16" -msgstr "profilointituki VxWorksille" +msgstr "profilointituki CR16:lle" #. This function is for retrieving a part of an instruction name for #. an operator, for immediate output. If that ever happens for @@ -21433,13 +21218,11 @@ msgstr "" #: config/cris/cris.c:2932 #, fuzzy, gcc-internal-format -#| msgid "<unknown>" msgid "unknown src" msgstr "<tuntematon>" #: config/cris/cris.c:2993 #, fuzzy, gcc-internal-format -#| msgid "<unknown operator>" msgid "unknown dest" msgstr "<tuntematon operaattori>" @@ -21524,12 +21307,12 @@ msgstr "" #: config/epiphany/epiphany.c:1439 #, fuzzy, gcc-internal-format msgid "stack_offset must be at least 4" -msgstr "tasauksen pitää olla kahden potenssi, ei %d" +msgstr "kohdistuksen pitää olla kahden potenssi, ei %d" #: config/epiphany/epiphany.c:1441 #, fuzzy, gcc-internal-format msgid "stack_offset must be a multiple of 4" -msgstr "tasauksen pitää olla kahden potenssi, ei %d" +msgstr "kohdistuksen pitää olla kahden potenssi, ei %d" #: config/frv/frv.c:8684 #, gcc-internal-format @@ -21665,7 +21448,6 @@ msgstr "" #: config/i386/i386.c:3191 config/i386/i386.c:3203 #, fuzzy, gcc-internal-format -#| msgid "code model %s does not support PIC mode" msgid "code model %qs not supported in x32 mode" msgstr "koodimalli %s ei tue PIC-tilaa" @@ -21771,7 +21553,6 @@ msgstr "" #: config/i386/i386.c:4229 #, fuzzy, gcc-internal-format -#| msgid "alias argument not a string" msgid "attribute %<target%> argument not a string" msgstr "aliaksen argumentti ei ole merkkijono" @@ -21796,9 +21577,9 @@ msgid "regparam and thiscall attributes are not compatible" msgstr "" #: config/i386/i386.c:4945 config/i386/i386.c:34659 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE attribute requires an integer constant argument" -msgstr "%qs-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja" +msgstr "%qE-attribuutti tarvitsee kokonaislukuvakioargumentin" #: config/i386/i386.c:4951 #, fuzzy, gcc-internal-format @@ -21808,12 +21589,12 @@ msgstr "%Jei voi asettaa %qE-attribuuttia määrittelyn jälkeen" #: config/i386/i386.c:4976 config/i386/i386.c:5019 #, gcc-internal-format msgid "fastcall and cdecl attributes are not compatible" -msgstr "" +msgstr "attribuutit fastcall ja cdecl eivät ole yhteensopivia" #: config/i386/i386.c:4980 #, gcc-internal-format msgid "fastcall and stdcall attributes are not compatible" -msgstr "" +msgstr "attribuutit fastcall ja stdcall eivät ole yhteensopivia" #: config/i386/i386.c:4988 config/i386/i386.c:5037 #, gcc-internal-format @@ -21823,12 +21604,12 @@ msgstr "" #: config/i386/i386.c:4998 config/i386/i386.c:5015 #, gcc-internal-format msgid "stdcall and cdecl attributes are not compatible" -msgstr "" +msgstr "attribuutit stdcall ja cdecl eivät ole yhteensopivia" #: config/i386/i386.c:5002 #, gcc-internal-format msgid "stdcall and fastcall attributes are not compatible" -msgstr "" +msgstr "attribuutit stdcall ja fastcall eivät ole yhteensopivia" #: config/i386/i386.c:5006 config/i386/i386.c:5033 #, gcc-internal-format @@ -21944,7 +21725,6 @@ msgstr "ISO C kieltää sisäkkäiset funktiot" #. around the addition and comparison. #: config/i386/i386.c:11261 #, fuzzy, gcc-internal-format -#| msgid "ISO C90 does not support flexible array members" msgid "-fsplit-stack does not support 3 register parameters" msgstr "ISO C90 ei tue joustavia taulukon jäseniä" @@ -21985,7 +21765,6 @@ msgstr "" #: config/i386/i386.c:29067 config/i386/i386.c:29512 #, fuzzy, gcc-internal-format -#| msgid "dwarf version %d is not supported" msgid "Virtual function multiversioning not supported" msgstr "dwarfin versio %d ei ole tuettu" @@ -22006,7 +21785,6 @@ msgstr "#pragma redefine_extname ei ole tuettu tällä kohteella" #: config/i386/i386.c:29695 #, fuzzy, gcc-internal-format -#| msgid "third argument to %<__builtin_prefetch%> must be a constant" msgid "Parameter to builtin must be a string constant or literal" msgstr "%<__builtin_prefetch%>-funktion kolmannen argumentin pitää olla vakio" @@ -22117,7 +21895,6 @@ msgstr "%qE-attribuuttia ei huomioida" #: config/i386/i386.c:42160 #, fuzzy, gcc-internal-format -#| msgid "Unknown architecture '%s'" msgid "Unknown architecture specific memory model" msgstr "Tuntematon arkkitehtuuri ”%s”" @@ -22169,7 +21946,7 @@ msgstr "" #: config/ia64/ia64-c.c:51 #, gcc-internal-format msgid "malformed #pragma builtin" -msgstr "" +msgstr "vääränmuotoinen #pragma builtin" #: config/ia64/ia64.c:703 #, fuzzy, gcc-internal-format @@ -22177,56 +21954,56 @@ msgid "invalid argument of %qE attribute" msgstr "funktiolle %2$qE annettu argumentin %1$d tyyppi on yhteensopimaton" #: config/ia64/ia64.c:716 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "an address area attribute cannot be specified for local variables" -msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle" +msgstr "osoitealueattribuuttia ei voi määritellä paikallisille muuttujille" #: config/ia64/ia64.c:723 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "address area of %q+D conflicts with previous declaration" -msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa" +msgstr "%q+D:n osoitealue on ristiriidassa edellisen esittelyn kanssa" #: config/ia64/ia64.c:731 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "address area attribute cannot be specified for functions" -msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle" +msgstr "osoitealueattribuuttia ei voi määritellä funktioille" #: config/ia64/ia64.c:764 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE attribute requires a string constant argument" -msgstr "%qs-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja" +msgstr "%qE-attribuutti tarvitsee merkkijonovakioargumentin" -#: config/ia64/ia64.c:5885 config/pa/pa.c:416 config/sh/sh.c:9351 +#: config/ia64/ia64.c:5885 config/pa/pa.c:416 config/sh/sh.c:9348 #: config/spu/spu.c:4897 #, gcc-internal-format msgid "value of -mfixed-range must have form REG1-REG2" msgstr "" -#: config/ia64/ia64.c:5912 config/pa/pa.c:443 config/sh/sh.c:9377 +#: config/ia64/ia64.c:5912 config/pa/pa.c:443 config/sh/sh.c:9374 #: config/spu/spu.c:4923 #, gcc-internal-format, gfc-internal-format msgid "%s-%s is an empty range" -msgstr "" +msgstr "%s-%s on tyhjä väli" #: config/ia64/ia64.c:11098 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "version attribute is not a string" -msgstr "näkyvyysargumentti ei ole merkkijono" +msgstr "versioattribuutti ei ole merkkijono" #: config/iq2000/iq2000.c:1834 #, gcc-internal-format, gfc-internal-format msgid "gp_offset (%ld) or end_offset (%ld) is less than zero" -msgstr "" +msgstr "gp_offset (%ld) tai end_offset (%ld) on pienempi kuin nolla" #: config/iq2000/iq2000.c:2596 #, gcc-internal-format msgid "argument %qd is not a constant" -msgstr "" +msgstr "argumentti %qd ei ole vakio" #: config/iq2000/iq2000.c:2899 config/xtensa/xtensa.c:2438 #, gcc-internal-format msgid "PRINT_OPERAND_ADDRESS, null pointer" -msgstr "" +msgstr "PRINT_OPERAND_ADDRESS, null-osoitin" #: config/iq2000/iq2000.c:3054 #, gcc-internal-format, gfc-internal-format @@ -22236,7 +22013,7 @@ msgstr "" #: config/iq2000/iq2000.c:3063 config/xtensa/xtensa.c:2292 #, gcc-internal-format msgid "PRINT_OPERAND null pointer" -msgstr "" +msgstr "PRINT_OPERAND null-osoitin" #: config/m32c/m32c-pragma.c:55 #, gcc-internal-format @@ -22255,13 +22032,11 @@ msgstr "#pragma GCC memregs ottaa luvun [0..16]" #: config/m32c/m32c-pragma.c:105 #, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma %s" msgid "junk at end of #pragma ADDRESS" msgstr "roskaa #pragma %s:n lopussa" #: config/m32c/m32c-pragma.c:110 #, fuzzy, gcc-internal-format -#| msgid "malformed #pragma GCC visibility push" msgid "malformed #pragma ADDRESS variable address" msgstr "väärinmuodostettu #pragma GCC visibility push" @@ -22276,15 +22051,15 @@ msgid "%qE attribute is not supported for R8C target" msgstr "%Jlohkoattribuutteja ei tueta tälle kohteelle" #. The argument must be a constant integer. -#: config/m32c/m32c.c:2934 config/sh/sh.c:9570 config/sh/sh.c:9676 +#: config/m32c/m32c.c:2934 config/sh/sh.c:9567 config/sh/sh.c:9673 #, fuzzy, gcc-internal-format msgid "%qE attribute argument not an integer constant" msgstr "haluttu sijainti ei ole kokonaislukuvakio" #: config/m32c/m32c.c:2943 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE attribute argument should be between 18 to 255" -msgstr "haluttu sijainti ei ole kokonaislukuvakio" +msgstr "%qE-attribuutin argumentin tulee olla välillä 18..255" #: config/m32c/m32c.c:4119 #, gcc-internal-format @@ -22292,24 +22067,24 @@ msgid "%<bank_switch%> has no effect on non-interrupt functions" msgstr "" #: config/m32c/m32c.c:4223 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<fast_interrupt%> attribute directive ignored" -msgstr "%qs-attribuuttidirektiivi jätetty huomiotta" +msgstr "%<fast_interrupt%>-attribuuttidirektiivi jätetty huomiotta" #: config/m32r/m32r.c:382 #, gcc-internal-format msgid "invalid argument of %qs attribute" -msgstr "" +msgstr "%qs-attribuutin virheellinen argumentti" #: config/m68k/m68k.c:476 #, gcc-internal-format, gfc-internal-format msgid "-mcpu=%s conflicts with -march=%s" -msgstr "" +msgstr "valitsin -mcpu=%s on ristiriidassa valitsimen -march=%s kanssa" #: config/m68k/m68k.c:547 #, gcc-internal-format msgid "-mpcrel -fPIC is not currently supported on selected cpu" -msgstr "" +msgstr "-mpcrel -fPIC ei ole nykyisin tuettu valitulle prosessorille" #: config/m68k/m68k.c:609 #, gcc-internal-format, gfc-internal-format @@ -22347,9 +22122,9 @@ msgid "initialized variable %q+D is marked dllimport" msgstr "" #: config/mep/mep-pragma.c:71 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "junk at end of #pragma io_volatile" -msgstr "roskaa #pragma %s:n lopussa" +msgstr "roskaa ilmaisun #pragma io_volatile lopussa" #: config/mep/mep-pragma.c:85 #, gcc-internal-format @@ -22374,7 +22149,7 @@ msgstr "" #: config/mep/mep-pragma.c:254 #, gcc-internal-format msgid "junk at end of #pragma GCC coprocessor width" -msgstr "roskaa ilmaisun %<#pragma GCC coprocessor width%> lopussa" +msgstr "roskaa ilmaisun pragma GCC coprocessor width lopussa" #: config/mep/mep-pragma.c:261 #, gcc-internal-format @@ -22417,9 +22192,9 @@ msgid "unknown #pragma GCC coprocessor %E" msgstr "tuntematon #pragma GCC coprocessor %E" #: config/mep/mep-pragma.c:392 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "malformed #pragma call" -msgstr "väärinmuodostettu #pragma weak, jätetään huomiotta" +msgstr "väärinmuodostettu #pragma call" #: config/mep/mep.c:351 #, fuzzy, gcc-internal-format @@ -22427,44 +22202,44 @@ msgid "-fpic is not supported" msgstr "valitsin %qs ei ole enää tuettu" #: config/mep/mep.c:353 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "-fPIC is not supported" -msgstr "ISO C ei tue kompleksikokonaiskulutyyppejä" +msgstr "-fPIC ei ole tuettu" #: config/mep/mep.c:355 #, gcc-internal-format msgid "only one of -ms and -mm may be given" -msgstr "" +msgstr "vain yksi valitsimista -ms ja -mm voidaan antaa" #: config/mep/mep.c:357 #, gcc-internal-format msgid "only one of -ms and -ml may be given" -msgstr "" +msgstr "vain yksi valitsimista -ms ja -ml voidaan antaa" #: config/mep/mep.c:359 #, gcc-internal-format msgid "only one of -mm and -ml may be given" -msgstr "" +msgstr "vain yksi valitsimita -mm ja -ml voidaan antaa" #: config/mep/mep.c:361 #, gcc-internal-format msgid "only one of -ms and -mtiny= may be given" -msgstr "" +msgstr "vai yksi valitsimista -ms ja -mtiny voidaan antaa" #: config/mep/mep.c:363 #, gcc-internal-format msgid "only one of -mm and -mtiny= may be given" -msgstr "" +msgstr "vain yksi valitsimista -mm ja -mtiny= voidaan antaa" #: config/mep/mep.c:365 #, gcc-internal-format msgid "-mclip currently has no effect without -mminmax" -msgstr "" +msgstr "valitsimella -mclip ei nykyisin ole vaikutusta ilman valitsinta -mminmax" #: config/mep/mep.c:372 #, gcc-internal-format msgid "-mc= must be -mc=tiny, -mc=near, or -mc=far" -msgstr "" +msgstr "valitsimen -mc= on oltava -mc=tiny, -mc=near, tai -mc=far" #: config/mep/mep.c:1374 #, gcc-internal-format @@ -22487,9 +22262,9 @@ msgid "address region attributes on pointed-to types ignored" msgstr "" #: config/mep/mep.c:3853 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE attribute only applies to variables and functions" -msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" +msgstr "%qE-attribuutti soveltuu vain muuttujiin ja funktioihin" #: config/mep/mep.c:3873 config/mep/mep.c:4189 #, gcc-internal-format @@ -22504,22 +22279,22 @@ msgstr "funktiota %<main%> ei voi määrittää avoimeksi" #: config/mep/mep.c:3913 #, gcc-internal-format msgid "interrupt function must have return type of void" -msgstr "" +msgstr "keskeytysfunktiolla on oltava void-paluutyyppi" #: config/mep/mep.c:3918 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "interrupt function must have no arguments" -msgstr "”-%c”-valitsimelle on annettava argumentti" +msgstr "keskeytysfunktiolla ei saa olla argumentteja" #: config/mep/mep.c:3939 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE attribute allows only an integer constant argument" -msgstr "haluttu sijainti ei ole kokonaislukuvakio" +msgstr "%qE-attribuutti sallii vain kokonaislukuvakioargumentin" #: config/mep/mep.c:3972 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE attribute only applies to functions, not %s" -msgstr "attribuutti %qs pätee vain funktiotyyppeihin" +msgstr "%qE-attribuutti pätee vain funktioihin, ei %s" #: config/mep/mep.c:3983 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -22583,12 +22358,12 @@ msgstr "%J%qD on tavallisesti ei-staattinen funktio" #: config/mep/mep.c:6167 config/mep/mep.c:6284 #, fuzzy, gcc-internal-format msgid "argument %d of %qE must be in the range %d...%d" -msgstr "tasauksen pitää olla kahden potenssi, ei %d" +msgstr "kohdistuksen pitää olla kahden potenssi, ei %d" #: config/mep/mep.c:6170 #, fuzzy, gcc-internal-format msgid "argument %d of %qE must be a multiple of %d" -msgstr "tasauksen pitää olla kahden potenssi, ei %d" +msgstr "kohdistuksen pitää olla kahden potenssi, ei %d" #: config/mep/mep.c:6223 #, fuzzy, gcc-internal-format @@ -22615,22 +22390,32 @@ msgstr "" msgid "unexpected %d byte cop instruction" msgstr "Käytä AltiVec-käskyjä" -#: config/microblaze/microblaze.c:1311 +#: config/microblaze/microblaze.c:1676 #, fuzzy, gcc-internal-format msgid "-fPIC/-fpic not supported for this target" msgstr "säiekohtaista muistia ei tueta tälle kohteelle" -#: config/microblaze/microblaze.c:1323 +#: config/microblaze/microblaze.c:1688 #, fuzzy, gcc-internal-format msgid "%qs is an invalid argument to -mcpu=" msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi" -#: config/microblaze/microblaze.c:1372 +#: config/microblaze/microblaze.c:1737 #, gcc-internal-format msgid "-mxl-multiply-high can be used only with -mcpu=v6.00.a or greater" msgstr "" -#: config/microblaze/microblaze.c:1384 +#: config/microblaze/microblaze.c:1753 +#, gcc-internal-format +msgid "-mxl-reorder can be used only with -mcpu=v8.30.a or greater" +msgstr "" + +#: config/microblaze/microblaze.c:1759 +#, gcc-internal-format +msgid "-mxl-reorder requires -mxl-pattern-compare for -mcpu=v8.30.a" +msgstr "" + +#: config/microblaze/microblaze.c:1764 #, gcc-internal-format msgid "-mxl-multiply-high requires -mno-xl-soft-mul" msgstr "" @@ -22668,7 +22453,7 @@ msgstr "" #: config/mips/mips.c:9771 #, gcc-internal-format msgid "interrupt handlers cannot be MIPS16 functions" -msgstr "" +msgstr "keskeytyskäsittelijät eivät voi olla MIPS16-funktioita" #: config/mips/mips.c:10596 #, gcc-internal-format @@ -22859,12 +22644,12 @@ msgstr "" #: config/mmix/mmix.c:1971 #, gcc-internal-format msgid "stack frame not a multiple of 8 bytes: %wd" -msgstr "" +msgstr "pinokehys ei ole 8:n tavun monikerta: %wd" #: config/mmix/mmix.c:2210 #, gcc-internal-format msgid "stack frame not a multiple of octabyte: %wd" -msgstr "" +msgstr "pinokehys ei ole oktaalitavun monikerta: %wd" #: config/mmix/mmix.c:2496 config/mmix/mmix.c:2555 #, gcc-internal-format, gfc-internal-format @@ -22928,13 +22713,11 @@ msgstr "" #: config/picochip/picochip.c:1589 #, fuzzy, gcc-internal-format -#| msgid "%qD has already been defined" msgid "LCFI labels have already been deferred" msgstr "%qD on jo määritelty" #: config/picochip/picochip.c:1652 #, fuzzy, gcc-internal-format -#| msgid "%qD has already been defined" msgid "LM label has already been deferred" msgstr "%qD on jo määritelty" @@ -22986,18 +22769,18 @@ msgstr "" #: config/picochip/picochip.c:4055 config/picochip/picochip.c:4148 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "%s: Second source operand is not a constant" -msgstr "pyydetty tasaus ei ole vakio" +msgstr "pyydetty kohdistus ei ole vakio" #: config/picochip/picochip.c:4058 config/picochip/picochip.c:4109 #: config/picochip/picochip.c:4151 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "%s: Third source operand is not a constant" -msgstr "pyydetty tasaus ei ole vakio" +msgstr "pyydetty kohdistus ei ole vakio" #: config/picochip/picochip.c:4112 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "%s: Fourth source operand is not a constant" -msgstr "pyydetty tasaus ei ole vakio" +msgstr "pyydetty kohdistus ei ole vakio" #: config/picochip/picochip.c:4410 #, gcc-internal-format, gfc-internal-format @@ -23151,12 +22934,12 @@ msgstr "-pg ei ole tuettu tällä alustalla" #: config/rs6000/rs6000.c:2595 #, gcc-internal-format msgid "-mmultiple is not supported on little endian systems" -msgstr "" +msgstr "valitsin -mmultiple ei ole tuettu little-endian-järjestelmissä" #: config/rs6000/rs6000.c:2602 #, gcc-internal-format msgid "-mstring is not supported on little endian systems" -msgstr "" +msgstr "valitsin -mstring ei ole tuettu little-endian-järjestelmissä" #: config/rs6000/rs6000.c:2711 #, gcc-internal-format, gfc-internal-format @@ -23216,12 +22999,12 @@ msgstr "sisäistä funktiota %qs ei voi ottaa pois käytöstä" #: config/rs6000/rs6000.c:9938 #, gcc-internal-format msgid "argument 1 must be a 5-bit signed literal" -msgstr "" +msgstr "argumentin 1 on oltava 5-bittinen etumerkillinen literaali" #: config/rs6000/rs6000.c:10041 config/rs6000/rs6000.c:11058 #, gcc-internal-format msgid "argument 2 must be a 5-bit unsigned literal" -msgstr "" +msgstr "argumentin 2 on oltava 5-bittinen etumerkitön literaali" #: config/rs6000/rs6000.c:10080 #, gcc-internal-format @@ -23290,25 +23073,21 @@ msgstr "" #: config/rs6000/rs6000.c:11406 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "built-in function %q+D declared as non-function" msgid "Builtin function %s requires the -mvsx option" msgstr "sisäinen funktio %q+D esitelty ei-funktiona" #: config/rs6000/rs6000.c:11408 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "built-in function %q+D declared as non-function" msgid "Builtin function %s requires the -maltivec option" msgstr "sisäinen funktio %q+D esitelty ei-funktiona" #: config/rs6000/rs6000.c:11410 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "built-in function %q+D declared as non-function" msgid "Builtin function %s requires the -mpaired option" msgstr "sisäinen funktio %q+D esitelty ei-funktiona" #: config/rs6000/rs6000.c:11412 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "built-in function %q+D declared as non-function" msgid "Builtin function %s requires the -mspe option" msgstr "sisäinen funktio %q+D esitelty ei-funktiona" @@ -23409,7 +23188,6 @@ msgstr "väärinmuodostettu #pragma GCC pch_preprocess, jätetään huomiotta" #: config/rs6000/rs6000.c:27874 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "%s: PCH file was invalid" msgid "%s\"%s\"%s is invalid" msgstr "%s: PCH-tiedosto oli epäkelpo" @@ -23559,7 +23337,6 @@ msgstr "" #: config/rs6000/e500.h:41 #, fuzzy, gcc-internal-format -#| msgid "-pipe not supported" msgid "64-bit SPE not supported" msgstr "-pipe ei ole tuettu" @@ -23747,63 +23524,63 @@ msgstr "taulukon %qs koko on negatiivinen" msgid "%qs uses dynamic stack allocation" msgstr "" -#: config/sh/sh.c:906 +#: config/sh/sh.c:903 #, gcc-internal-format msgid "ignoring -fschedule-insns because of exception handling bug" msgstr "" -#: config/sh/sh.c:923 +#: config/sh/sh.c:920 #, gcc-internal-format msgid "unwind tables currently require either a frame pointer or -maccumulate-outgoing-args for correctness" msgstr "" -#: config/sh/sh.c:8284 +#: config/sh/sh.c:8281 #, gcc-internal-format msgid "__builtin_saveregs not supported by this subtarget" msgstr "" -#: config/sh/sh.c:9439 +#: config/sh/sh.c:9436 #, fuzzy, gcc-internal-format msgid "%qE attribute only applies to interrupt functions" msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" -#: config/sh/sh.c:9509 +#: config/sh/sh.c:9506 #, fuzzy, gcc-internal-format msgid "%qE attribute is supported only for SH2A" msgstr "%Jlohkoattribuutteja ei tueta tälle kohteelle" -#: config/sh/sh.c:9539 +#: config/sh/sh.c:9536 #, gcc-internal-format msgid "attribute interrupt_handler is not compatible with -m5-compact" msgstr "" -#: config/sh/sh.c:9556 +#: config/sh/sh.c:9553 #, fuzzy, gcc-internal-format msgid "%qE attribute only applies to SH2A" msgstr "attribuutti %qs pätee vain funktiotyyppeihin" -#: config/sh/sh.c:9578 +#: config/sh/sh.c:9575 #, fuzzy, gcc-internal-format msgid "%qE attribute argument should be between 0 to 255" msgstr "haluttu sijainti ei ole kokonaislukuvakio" #. The argument must be a constant string. -#: config/sh/sh.c:9651 +#: config/sh/sh.c:9648 #, fuzzy, gcc-internal-format msgid "%qE attribute argument not a string constant" msgstr "haluttu sijainti ei ole kokonaislukuvakio" -#: config/sh/sh.c:12341 +#: config/sh/sh.c:12338 #, gcc-internal-format msgid "r0 needs to be available as a call-clobbered register" msgstr "" -#: config/sh/sh.c:12362 +#: config/sh/sh.c:12359 #, gcc-internal-format msgid "need a second call-clobbered general purpose register" msgstr "" -#: config/sh/sh.c:12370 +#: config/sh/sh.c:12367 #, gcc-internal-format msgid "need a call-clobbered target register" msgstr "" @@ -23842,7 +23619,6 @@ msgstr "" #: config/sparc/sparc.c:1040 #, fuzzy, gcc-internal-format -#| msgid "thread-local storage not supported for this target" msgid "-fcall-saved-REG is not supported for out registers" msgstr "säiekohtaista muistia ei tueta tällä kohteella" @@ -23883,19 +23659,16 @@ msgstr "" #: config/spu/spu.c:6322 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "%s expects an integer literal in the range [%d, %d]." msgid "%s expects an integer literal in the range [%d, %d]" msgstr "%s odottaa kokonaislukuliteraalia väliltä [%d, %d]." #: config/spu/spu.c:6342 #, fuzzy, gcc-internal-format -#| msgid "%s expects an integer literal in the range [%d, %d]. (" msgid "%s expects an integer literal in the range [%d, %d]. (%wd)" msgstr "%s odottaa kokonaislukuliteraalia väliltä [%d, %d]. (" #: config/spu/spu.c:6371 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "%d least significant bits of %s are ignored." msgid "%d least significant bits of %s are ignored" msgstr "%d vähiten merkitsevää %s:n bittiä ei huomioida." @@ -24010,14 +23783,14 @@ msgid "junk at end of #pragma ghs endzda" msgstr "" #: config/v850/v850.c:2119 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "data area attributes cannot be specified for local variables" -msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle" +msgstr "data-alueattribuutteja ei voi määritellä paikallisille muuttujille" #: 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:n lohko on ristiriidassa edellisen esittelyn kanssa" +msgstr "%q+D:n data-alue on ristiriidassa edellisen esittelyn kanssa" #: config/v850/v850.c:2261 #, gcc-internal-format, gfc-internal-format @@ -24056,19 +23829,16 @@ msgstr "" #: config/vms/vms-c.c:44 #, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma %s" msgid "junk at end of #pragma __nostandard" msgstr "roskaa #pragma %s:n lopussa" #: config/vms/vms-c.c:55 #, fuzzy, gcc-internal-format -#| msgid "junk at end of #pragma %s" msgid "junk at end of #pragma __standard" msgstr "roskaa #pragma %s:n lopussa" #: config/vms/vms-c.c:80 #, fuzzy, gcc-internal-format -#| msgid "malformed '#pragma ms_struct', ignoring" msgid "malformed '#pragma member_alignment', ignoring" msgstr "väärinmuodostettu ”#pragma ms_struct”, jätetään huomiotta" @@ -24079,7 +23849,6 @@ msgstr "" #: config/vms/vms-c.c:100 #, fuzzy, gcc-internal-format -#| msgid "malformed #pragma weak, ignored" msgid "malformed '#pragma member_alignment'" msgstr "väärinmuodostettu #pragma weak, jätetään huomiotta" @@ -24095,7 +23864,6 @@ msgstr "roskaa ilmaisun #pragma weak lopussa" #: config/vms/vms-c.c:202 #, fuzzy, gcc-internal-format -#| msgid "malformed '#pragma options', ignoring" msgid "malformed '#pragma extern_model', ignoring" msgstr "väärin muotoiltu ”#pragma options”, ei huomioida" @@ -24121,7 +23889,6 @@ msgstr "väärinmuodostettu #pragma weak, jätetään huomiotta" #: config/vms/vms-c.c:273 config/vms/vms-c.c:279 #, fuzzy, gcc-internal-format -#| msgid "malformed #pragma extern_prefix, ignored" msgid "malformed '#pragma __extern_prefix', ignoring" msgstr "väärinmuodostettu #pragma extern_prefix, jätetään huomiotta" @@ -24188,24 +23955,23 @@ msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" #: ada/gcc-interface/utils.c:6194 #, fuzzy, gcc-internal-format -#| msgid "%qE attribute ignored" msgid "%qE attribute has no effect" msgstr "%qE-attribuuttia ei huomioida" #: ada/gcc-interface/utils.c:6300 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid vector type for attribute %qs" msgstr "epäkelpo vektorityyppi attribuutille %qs" #: ada/gcc-interface/utils.c:6363 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "attribute %qs applies to array types only" -msgstr "attribuutti %qs pätee vain funktiotyyppeihin" +msgstr "attribuutti %qs soveltuu vain taulukkotyyppeihin" #: ada/gcc-interface/utils.c:6390 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid element type for attribute %qs" -msgstr "epäkelpo vektorityyppi attribuutille %qs" +msgstr "epäkelpo alkiotyyppi attribuutille %qs" #. Except for passing an argument to an unprototyped function, #. this is a constraint violation. When passing an argument to @@ -24224,9 +23990,9 @@ msgid "conversion to non-scalar type requested" msgstr "pyydetty muuntoa ei-skalaarityypiksi" #: c/c-decl.c:731 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "array %q+D assumed to have one element" -msgstr "%Jtaulukolla %qD oletetaan olevan yksi alkio" +msgstr "taulukolla %q+D oletetaan olevan yksi alkio" #: c/c-decl.c:772 #, gcc-internal-format @@ -24244,14 +24010,14 @@ msgid "GCC supports only %u nested scopes" msgstr "GCC tukee korkeintaan %u sisäkkäistä näkyvyysaluetta" #: c/c-decl.c:1112 cp/decl.c:372 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "label %q+D used but not defined" -msgstr "nimikettä %qD käytetty, mutta ei määritelty" +msgstr "nimiötä %q+D käytetty mutta ei määritelty" #: c/c-decl.c:1157 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "nested function %q+D declared but never defined" -msgstr "sisäkkäinen funktio %qs esitelty %<extern%>:ksi" +msgstr "sisäkkäinen funktio %q+D esitelty mutta ei koskaan määritelty" #: c/c-decl.c:1169 #, fuzzy, gcc-internal-format @@ -24265,7 +24031,6 @@ msgstr "käyttämätön muuttuja %q+D" #: c/c-decl.c:1190 #, fuzzy, gcc-internal-format -#| msgid "label %q+D defined but not used" msgid "variable %qD set but not used" msgstr "nimike %q+D määritelty mutta käytettämättä" @@ -24275,34 +24040,34 @@ msgid "type of array %q+D completed incompatibly with implicit initialization" msgstr "%Jtaulukon %qD tyyppi viimeistelty epäkelvosti implisiittisellä alustuksella" #: c/c-decl.c:1474 c/c-decl.c:5869 c/c-decl.c:6699 c/c-decl.c:7410 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "originally defined here" -msgstr "funktion määrittely esitelty %<__thread%>:ksi" +msgstr "alunperin määritelty täällä" #: c/c-decl.c:1544 #, gcc-internal-format msgid "a parameter list with an ellipsis can%'t match an empty parameter name list declaration" -msgstr "kolme pistettä sisältävä parametrilista ei sovellu tyhjään parametrinimi-listan esittelyyn" +msgstr "kolme pistettä sisältävä parametriluettelo ei sovellu tyhjään parametrinimiluettelon esittelyyn" #: c/c-decl.c:1551 #, gcc-internal-format msgid "an argument type that has a default promotion can%'t match an empty parameter name list declaration" -msgstr "argumenttityyppi, jolla on tavallinen tyyppimuunnos, ei sovi tyhjään parametrinimilistaesittelyyn" +msgstr "argumenttityyppi, jolla on tavallinen tyyppimuunnos, ei sovi tyhjään parametrinimiluetteloesittelyyn" #: c/c-decl.c:1592 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "prototype for %q+D declares more arguments than previous old-style definition" -msgstr "%Jfunktion %qD prototyyppi esittelee enemmän argumentteja kuin edellinen, vanhantyylinen määrittely" +msgstr "%q+D:n prototyyppi esittelee enemmän argumentteja kuin edellinen, vanhantyylinen määrittely" #: c/c-decl.c:1598 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "prototype for %q+D declares fewer arguments than previous old-style definition" -msgstr "%Jfunktion %qD prototyyppi esittelee vähemmän argumentteja kuin edellinen, vanhantyylinen määrittely" +msgstr "%q+D:n prototyyppi esittelee vähemmän argumentteja kuin edellinen, vanhantyylinen määrittely" #: c/c-decl.c:1607 #, gcc-internal-format msgid "prototype for %q+D declares argument %d with incompatible type" -msgstr "prototyypin %q+D esittelemällä argumentilla %d on yhteensopimaton tyyppi" +msgstr "%q+D:n prototyypou esittelee yhteensopimatonta tyyppiä olevan argumentin %d" #. If we get here, no errors were found, but do issue a warning #. for this poor-style construct. @@ -24342,9 +24107,9 @@ msgid "declaration of %q+D shadows a built-in function" msgstr "%q+D:n esittely varjostaa sisäänrakennetun funktion" #: c/c-decl.c:1695 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "redeclaration of enumerator %q+D" -msgstr "%Jluetellun tyypin jäsenen %qd uudelleenesittely" +msgstr "luetellun tyypin jäsenen %q+D uudelleenesittely" #. If types don't match for a built-in, throw away the #. built-in. No point in calling locate_old_decl here, it @@ -24357,7 +24122,7 @@ msgstr "ristiriitaiset tyypit sisäiselle funktiolle %q+D" #: c/c-decl.c:1741 c/c-decl.c:1754 c/c-decl.c:1790 #, gcc-internal-format msgid "conflicting types for %q+D" -msgstr "ristiriitaiset tyypit %qD:lle" +msgstr "ristiriitaiset tyypit %q+D:lle" #: c/c-decl.c:1770 #, fuzzy, gcc-internal-format @@ -24381,13 +24146,11 @@ msgstr "ristiriitaiset tyyppimääreet %q+D:lle" #: c/c-decl.c:1812 #, fuzzy, gcc-internal-format -#| msgid "redefinition of typedef %q+D" msgid "redefinition of typedef %q+D with different type" msgstr "typedef %q+D määritelty uudelleen" #: c/c-decl.c:1825 #, fuzzy, gcc-internal-format -#| msgid "redefinition of typedef %q+D" msgid "redefinition of typedef %q+D with variably modified type" msgstr "typedef %q+D määritelty uudelleen" @@ -24492,9 +24255,9 @@ msgid "declaration of %q+D shadows a previous local" msgstr "%J%qD:n esittely varjostaa edellistä paikallista" #: c/c-decl.c:2580 cp/name-lookup.c:1153 cp/name-lookup.c:1196 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "shadowed declaration is here" -msgstr "%Jvarjostunut esittely on täällä" +msgstr "varjostunut esittely on täällä" #: c/c-decl.c:2707 #, gcc-internal-format @@ -24528,7 +24291,6 @@ msgstr "%qE esittelemättä (ensimmäinen käyttökerta tässä funktiossa)" #: c/c-decl.c:3020 #, fuzzy, gcc-internal-format -#| msgid "(Each undeclared identifier is reported only once" msgid "each undeclared identifier is reported only once for each function it appears in" msgstr "(Jokaisesta esittelemättömästä tunnisteesta ilmoitetaan vain" @@ -24553,7 +24315,7 @@ msgid "label %qD defined here" msgstr "nimiö %qD määritelty täällä" #: c/c-decl.c:3111 c/c-decl.c:3383 c/c-typeck.c:6979 cp/class.c:1339 -#: cp/class.c:2928 +#: cp/class.c:2932 #, gcc-internal-format msgid "%qD declared here" msgstr "%qD esitelty täällä" @@ -24564,9 +24326,9 @@ msgid "jump into statement expression" msgstr "ylivuoto vakiolausekkeessa" #: c/c-decl.c:3187 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "duplicate label declaration %qE" -msgstr "%qs-nimikkeen kaksoisesittely" +msgstr "%qE-nimiön kaksoisesittely" #: c/c-decl.c:3285 cp/decl.c:2984 #, gcc-internal-format @@ -24581,12 +24343,12 @@ msgstr "perinteisestä C:stä puuttuu erillinen nimiavaruus nimikkeille, tunnist #: c/c-decl.c:3381 #, gcc-internal-format msgid "switch jumps over variable initialization" -msgstr "" +msgstr "switch hyppää muuttuja-alustuksen yli" #: c/c-decl.c:3382 c/c-decl.c:3393 #, gcc-internal-format msgid "switch starts here" -msgstr "" +msgstr "switch alkaa tästä" #: c/c-decl.c:3392 #, fuzzy, gcc-internal-format @@ -24617,7 +24379,6 @@ msgstr "tyhjä esittely tyyppimääreellä ei esittele tunnistetta uudelleen" # XXX #: c/c-decl.c:3731 #, fuzzy, gcc-internal-format -#| msgid "empty declaration with type qualifier does not redeclare tag" msgid "empty declaration with %<_Alignas%> does not redeclare tag" msgstr "tyhjä esittely tyyppimääreellä ei esittele tunnistetta uudelleen" @@ -24633,7 +24394,6 @@ msgstr "%<inline%> tyhjässä esittelyssä" #: c/c-decl.c:3774 #, fuzzy, gcc-internal-format -#| msgid "%<inline%> in empty declaration" msgid "%<_Noreturn%> in empty declaration" msgstr "%<inline%> tyhjässä esittelyssä" @@ -24664,7 +24424,6 @@ msgstr "tarpeeton tyyppimääre tyhjässä esittelyssä" #: c/c-decl.c:3813 #, fuzzy, gcc-internal-format -#| msgid "useless %<__thread%> in empty declaration" msgid "useless %<_Alignas%> in empty declaration" msgstr "tarpeeton %<__thread%> tyhjässä esittelyssä" @@ -24717,7 +24476,7 @@ msgstr "parametri %qD on alustettu" #. sense to permit them to be initialized given that #. ordinary VLAs may not be initialized. #: c/c-decl.c:4055 c/c-decl.c:4070 c/c-typeck.c:6303 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "variable-sized object may not be initialized" msgstr "muuttuvakokoista objektia ei voi alustaa" @@ -24726,7 +24485,7 @@ msgstr "muuttuvakokoista objektia ei voi alustaa" msgid "variable %qD has initializer but incomplete type" msgstr "muuttujalla %qD on alustin, mutta vaillinainen tyyppi" -#: c/c-decl.c:4150 cp/decl.c:4529 cp/decl.c:12970 +#: c/c-decl.c:4150 cp/decl.c:4529 cp/decl.c:12961 #, fuzzy, gcc-internal-format msgid "inline function %q+D given attribute noinline" msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline" @@ -24738,7 +24497,6 @@ msgstr "alustamaton const %qD" #: c/c-decl.c:4203 cp/init.c:2130 cp/init.c:2145 #, fuzzy, gcc-internal-format -#| msgid "%q+D will be initialized after" msgid "%qD should be initialized" msgstr "%q+D alustetaan jäljempänä kuin" @@ -24758,14 +24516,14 @@ msgid "zero or negative size array %q+D" msgstr "nollan tai negatiivisen kokoinen taulukko %q+D" #: c/c-decl.c:4364 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "storage size of %q+D isn%'t constant" -msgstr "%Jmuuttujan %qD koko muistissa ei ole vakio" +msgstr "muuttujan %q+D koko muistissa ei ole vakio" #: c/c-decl.c:4414 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "ignoring asm-specifier for non-static local variable %q+D" -msgstr "%Jei-staattisen paikallismuuttujan %qD asm-määrittäjä jätetään huomiotta" +msgstr "ei-staattisen paikallismuuttujan %q+D asm-määrittäjä jätetään huomiotta" #: c/c-decl.c:4444 #, gcc-internal-format @@ -24773,14 +24531,14 @@ msgid "cannot put object with volatile field into register" msgstr "ei voi laittaa volatile-kenttäistä objektia rekisteriin" #: c/c-decl.c:4531 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "uninitialized const %qD is invalid in C++" -msgstr "alustamaton const %qD" +msgstr "alustamaton vakio %qD on virheellinen C++-kielessä" #: c/c-decl.c:4589 #, gcc-internal-format msgid "ISO C forbids forward parameter declarations" -msgstr "ISO C kieltää parametrien esittelyn etukäteen" +msgstr "ISO C kieltää parametrien ennakkoesittelyn" #: c/c-decl.c:4684 #, gcc-internal-format @@ -24794,7 +24552,6 @@ msgstr "bittikentän %qs leveys ei ole kokonaislukuvakio" #: c/c-decl.c:4746 #, fuzzy, gcc-internal-format -#| msgid "bit-field %qs width not an integer constant" msgid "bit-field %qs width not an integer constant expression" msgstr "bittikentän %qs leveys ei ole kokonaislukuvakio" @@ -24859,14 +24616,14 @@ msgid "the size of array can %'t be evaluated" msgstr "taulukon kokoa ei voida määrittää" #: c/c-decl.c:4853 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "variable length array %qE is used" -msgstr "Varoita käyttämättömistä muuttujista" +msgstr "käytetään muuttuvapituista taulukkoa %qE" -#: c/c-decl.c:4857 cp/decl.c:8274 +#: c/c-decl.c:4857 cp/decl.c:8277 #, gcc-internal-format msgid "variable length array is used" -msgstr "" +msgstr "käytetään muuttuvapituista taulukkoa" #: c/c-decl.c:5016 c/c-decl.c:5364 c/c-decl.c:5374 #, fuzzy, gcc-internal-format @@ -24879,14 +24636,14 @@ msgid "variably modified field at file scope" msgstr "muuttuja tai kenttä %qs esitelty tyhjäksi" #: c/c-decl.c:5038 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type defaults to %<int%> in declaration of %qE" -msgstr "%qs:n esittelyssä tyyppi on oletuksena %<int%>" +msgstr "%qE:n esittelyssä tyyppi on oletuksena %<int%>" #: c/c-decl.c:5042 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type defaults to %<int%> in type name" -msgstr "%qs:n esittelyssä tyyppi on oletuksena %<int%>" +msgstr "tyypin nimessä tyyppi on oletuksena %<int%>" # XXX #: c/c-decl.c:5075 @@ -24930,26 +24687,26 @@ msgid "function definition declared %<__thread%>" msgstr "funktion määrittely esitelty %<__thread%>:ksi" #: c/c-decl.c:5130 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "storage class specified for structure field %qE" -msgstr "tallennusluokka annettu tietueen kentälle %qs" +msgstr "tallennusluokka annettu tietueen kentälle %qE" #: c/c-decl.c:5133 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "storage class specified for structure field" -msgstr "tallennusluokka annettu tietueen kentälle %qs" +msgstr "tallennusluokka annettu tietueen kentälle" #: c/c-decl.c:5137 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "storage class specified for parameter %qE" -msgstr "tallennusluokka annettu parametrille %qs" +msgstr "tallennusluokka annettu parametrille %qE" #: c/c-decl.c:5140 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "storage class specified for unnamed parameter" -msgstr "tallennusluokka annettu parametrille %qs" +msgstr "tallennusluokka annettu nimettömälle parametrille" -#: c/c-decl.c:5143 cp/decl.c:9283 +#: c/c-decl.c:5143 cp/decl.c:9279 #, gcc-internal-format msgid "storage class specified for typename" msgstr "tallennusluokka annettu typenamelle" @@ -24993,24 +24750,24 @@ msgid "static or type qualifiers in non-parameter array declarator" msgstr "staattinen tai tyyppimääreitä ei-parametrisessa taulukkoesittelijässä" #: c/c-decl.c:5276 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "declaration of %qE as array of voids" -msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" +msgstr "%qE:n esittely taulukollisena void-alkioita" #: c/c-decl.c:5278 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "declaration of type name as array of voids" -msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" +msgstr "tyyppinimen esittely taulukollisena void-alkioita" #: c/c-decl.c:5285 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "declaration of %qE as array of functions" -msgstr "%qs esitelty funktiotaulukkona" +msgstr "%qE:n esittely taulukollisena funktioita" #: c/c-decl.c:5288 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "declaration of type name as array of functions" -msgstr "%qs esitelty funktiotaulukkona" +msgstr "tyyppinimen esittely taulukollisena funktioita" #: c/c-decl.c:5295 c/c-decl.c:7196 #, gcc-internal-format @@ -25043,19 +24800,19 @@ msgid "size of array %qE is negative" msgstr "taulukon %qE koko on negatiivinen" #: c/c-decl.c:5349 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "size of unnamed array is negative" -msgstr "taulukon koko on negatiivinen" +msgstr "nimettömän taulukon koko on negatiivinen" #: c/c-decl.c:5423 c/c-decl.c:5826 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "size of array %qE is too large" -msgstr "taulukon %qs koko on liian suuri" +msgstr "taulukon %qE koko on liian suuri" #: c/c-decl.c:5426 c/c-decl.c:5828 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "size of unnamed array is too large" -msgstr "taulukon %qs koko on liian suuri" +msgstr "nimettömän taulukon koko on liian suuri" #: c/c-decl.c:5463 #, gcc-internal-format @@ -25064,9 +24821,9 @@ msgstr "ISO C90 ei tue joustavia taulukon jäseniä" #. C99 6.7.5.2p4 #: c/c-decl.c:5484 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<[*]%> not in a declaration" -msgstr "%<inline%> tyhjässä esittelyssä" +msgstr "%<[*]%> ei ole esittelyssä" #: c/c-decl.c:5497 #, gcc-internal-format @@ -25074,31 +24831,31 @@ msgid "array type has incomplete element type" msgstr "taulukon tyypillä on vaillinainen alkiotyyppi" #: c/c-decl.c:5591 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE declared as function returning a function" -msgstr "%qs esitelty funktion palauttavana funktiona" +msgstr "%qE esitelty funktion palauttavana funktiona" #: c/c-decl.c:5594 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type name declared as function returning a function" -msgstr "%qs esitelty funktion palauttavana funktiona" +msgstr "tyyppinimi esitelty funktion palauttavana funktiona" #: c/c-decl.c:5601 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE declared as function returning an array" -msgstr "%qs esitelty taulukon palauttavan funktiona" +msgstr "%qE esitelty taulukon palauttavan funktiona" #: c/c-decl.c:5604 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type name declared as function returning an array" -msgstr "%qs esitelty taulukon palauttavan funktiona" +msgstr "tyyppinimi esitelty taulukon palauttavan funktiona" #: c/c-decl.c:5632 -#, gcc-internal-format +#, fuzzy, gcc-internal-format msgid "function definition has qualified void return type" msgstr "funktion määrittely oikeuttaa tyhjän paluutyypin" -#: c/c-decl.c:5635 cp/decl.c:9411 +#: c/c-decl.c:5635 cp/decl.c:9407 #, gcc-internal-format msgid "type qualifiers ignored on function return type" msgstr "tyyppimääreet jätetään huomiotta funktion paluutyypissä" @@ -25124,29 +24881,29 @@ msgid "%qs specified for auto variable %qE" msgstr "epäkelpo vektorityyppi attribuutille %qs" #: c/c-decl.c:5757 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qs specified for parameter %qE" -msgstr "tallennusluokka annettu parametrille %qs" +msgstr "%qs määritelty parametrille %qE" #: c/c-decl.c:5760 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qs specified for unnamed parameter" -msgstr "tallennusluokka annettu parametrille %qs" +msgstr "%qs määritelty nimettömälle parametrille" #: c/c-decl.c:5766 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qs specified for structure field %qE" -msgstr "tallennusluokka annettu tietueen kentälle %qs" +msgstr "%qs määritelty tietueen kentälle %qE" #: c/c-decl.c:5769 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qs specified for structure field" -msgstr "tallennusluokka annettu tietueen kentälle %qs" +msgstr "%qs määritelty tietueen kentälle" #: c/c-decl.c:5782 #, fuzzy, gcc-internal-format msgid "alignment specified for typedef %qE" -msgstr "%Jtasausta ei voi määrittää %qD:lle" +msgstr "kohdistusta ei voi määrittää %q+D:lle" #: c/c-decl.c:5784 #, fuzzy, gcc-internal-format @@ -25166,7 +24923,7 @@ msgstr "tallennusluokka annettu parametrille %qs" #: c/c-decl.c:5796 #, fuzzy, gcc-internal-format msgid "alignment specified for bit-field %qE" -msgstr "%Jtasausta ei voi määrittää %qD:lle" +msgstr "%Jkohdistusta ei voi määrittää %qD:lle" #: c/c-decl.c:5798 #, fuzzy, gcc-internal-format @@ -25209,7 +24966,7 @@ msgstr "ISO C kieltää const- ja volatile-funktiotyypit" msgid "a member of a structure or union cannot have a variably modified type" msgstr "" -#: c/c-decl.c:5915 cp/decl.c:8516 +#: c/c-decl.c:5915 cp/decl.c:8519 #, gcc-internal-format msgid "variable or field %qE declared void" msgstr "muuttuja tai kenttä %qE esitelty voidiksi" @@ -25220,9 +24977,9 @@ msgid "attributes in parameter array declarator ignored" msgstr "parametritaulukon esittelijän attribuutit jätetään huomiotta" #: c/c-decl.c:5980 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "parameter %q+D declared %<inline%>" -msgstr "%Jparametri %qD esitelty %<inline%>:ksi" +msgstr "parametri %q+D esitelty %<inline%>:ksi" #: c/c-decl.c:5982 #, fuzzy, gcc-internal-format @@ -25230,9 +24987,9 @@ msgid "parameter %q+D declared %<_Noreturn%>" msgstr "%Jparametri %qD esitelty %<inline%>:ksi" #: c/c-decl.c:5995 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "field %qE declared as a function" -msgstr "kenttä %qs esitelty funktiona" +msgstr "kenttä %qE esitelty funktiona" #: c/c-decl.c:6002 #, fuzzy, gcc-internal-format @@ -25240,14 +24997,14 @@ msgid "field %qE has incomplete type" msgstr "kentällä %qs on vaillinainen tyyppi" #: c/c-decl.c:6004 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "unnamed field has incomplete type" -msgstr "kentällä %qs on vaillinainen tyyppi" +msgstr "nimettömällä kentällä on vaillinainen tyyppi" #: c/c-decl.c:6021 c/c-decl.c:6032 c/c-decl.c:6035 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid storage class for function %qE" -msgstr "epäkelpo tallennusluokka funktiolle %qs" +msgstr "epäkelpo tallennusluokka funktiolle %qE" #: c/c-decl.c:6086 #, gcc-internal-format @@ -25261,13 +25018,11 @@ msgstr "%qs alustettu ja esitelty %<extern%>-avainsanalla" #: c/c-decl.c:6101 #, fuzzy, gcc-internal-format -#| msgid "ISO C90 does not support %<long long%>" msgid "ISO C99 does not support %<_Noreturn%>" msgstr "ISO C90 ei tue %<long long%> -tyyppiä" #: c/c-decl.c:6104 #, fuzzy, gcc-internal-format -#| msgid "ISO C90 does not support %<long long%>" msgid "ISO C90 does not support %<_Noreturn%>" msgstr "ISO C90 ei tue %<long long%> -tyyppiä" @@ -25283,7 +25038,6 @@ msgstr "muuttuja %qD esitelty %<inline%>:ksi" #: c/c-decl.c:6145 #, fuzzy, gcc-internal-format -#| msgid "variable %q+D declared %<inline%>" msgid "variable %q+D declared %<_Noreturn%>" msgstr "muuttuja %qD esitelty %<inline%>:ksi" @@ -25313,9 +25067,9 @@ msgid "parameter %u (%q+D) has incomplete type" msgstr "parametrilla %u (%q+D) on vaillinainen tyyppi" #: c/c-decl.c:6323 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "parameter %u has incomplete type" -msgstr "%Jparametrilla %u in vaillinainen tyyppi" +msgstr "parametrilla %u in vaillinainen tyyppi" #: c/c-decl.c:6334 #, gcc-internal-format @@ -25323,9 +25077,9 @@ msgid "parameter %u (%q+D) has void type" msgstr "parametrin %u (%q+D) tyyppi on void" #: c/c-decl.c:6338 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "parameter %u has void type" -msgstr "%Jparametrin %u tyyppi on void" +msgstr "parametrin %u tyyppi on void" #: c/c-decl.c:6423 #, fuzzy, gcc-internal-format @@ -25346,13 +25100,13 @@ msgstr "parametrilla %q+D on vain etukäteisesittely" #: c/c-decl.c:6501 #, gcc-internal-format msgid "%<%s %E%> declared inside parameter list" -msgstr "%<%s %E%> esitelty parametrilistan sisällä" +msgstr "%<%s %E%> esitelty parametriluettelon sisällä" #. The %s will be one of 'struct', 'union', or 'enum'. #: c/c-decl.c:6505 #, gcc-internal-format, gfc-internal-format msgid "anonymous %s declared inside parameter list" -msgstr "nimetön %s esitelty parametrilistan sisällä" +msgstr "nimetön %s esitelty parametriluettelon sisällä" #: c/c-decl.c:6510 #, gcc-internal-format @@ -25360,19 +25114,19 @@ msgid "its scope is only this definition or declaration, which is probably not w msgstr "näkyvyysalue on vain tämä määrittely tai esittely, mikä ei todennäköisesti ole sitä, mitä halusit" #: c/c-decl.c:6610 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "enum type defined here" -msgstr "%q+#D määritelty aiemmin täällä" +msgstr "lueteltu tyyppi määritelty täällä" #: c/c-decl.c:6616 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "struct defined here" -msgstr "%q+#D määritelty aiemmin täällä" +msgstr "struct määritelty täällä" #: c/c-decl.c:6622 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "union defined here" -msgstr "%q+#D määritelty aiemmin täällä" +msgstr "union määritelty täällä" #: c/c-decl.c:6695 #, gcc-internal-format @@ -25385,14 +25139,14 @@ msgid "redefinition of %<struct %E%>" msgstr "%<struct %E%> uudelleenmääritelty" #: c/c-decl.c:6706 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "nested redefinition of %<union %E%>" -msgstr "sisäkkäinen uudelleenmäärittely: %<union %s%>" +msgstr "sisäkkäinen %<union %E%>:n uudelleenmäärittely" #: c/c-decl.c:6708 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "nested redefinition of %<struct %E%>" -msgstr "sisäkkäinen uudelleenmäärittely: %<struct %s%>" +msgstr "sisäkkäinen %<struct %E%>:n uudelleenmäärittely" #: c/c-decl.c:6740 c/c-decl.c:7428 #, gcc-internal-format @@ -25406,20 +25160,18 @@ msgstr "esittely ei esittele mitään" #: c/c-decl.c:6816 #, fuzzy, gcc-internal-format -#| msgid "ISO C doesn%'t support unnamed structs/unions" msgid "ISO C99 doesn%'t support unnamed structs/unions" msgstr "ISO C ei tue nimettömiä structeja/unioneita" #: c/c-decl.c:6819 #, fuzzy, gcc-internal-format -#| msgid "ISO C doesn%'t support unnamed structs/unions" msgid "ISO C90 doesn%'t support unnamed structs/unions" msgstr "ISO C ei tue nimettömiä structeja/unioneita" #: c/c-decl.c:6911 c/c-decl.c:6930 c/c-decl.c:6993 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "duplicate member %q+D" -msgstr "%Jjäsenen %qD kaksoiskappale" +msgstr "jäsenen %q+D kaksoiskappale" #: c/c-decl.c:7104 #, gcc-internal-format @@ -25442,19 +25194,19 @@ msgid "struct has no members" msgstr "structilla ei ole jäseniä" #: c/c-decl.c:7176 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "flexible array member in union" -msgstr "%Jjoustava taulukkojäsen unionissa" +msgstr "joustava taulukkojäsen unionissa" #: c/c-decl.c:7182 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "flexible array member not at end of struct" -msgstr "%Jjoustava taulukkojäsen ei ole structin lopussa" +msgstr "joustava taulukkojäsen ei ole structin lopussa" #: c/c-decl.c:7188 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "flexible array member in otherwise empty struct" -msgstr "%Jjoustava taulukkojäsen muuten tyhjässä structissa" +msgstr "joustava taulukkojäsen muuten tyhjässä structissa" #: c/c-decl.c:7307 #, gcc-internal-format @@ -25462,15 +25214,15 @@ msgid "union cannot be made transparent" msgstr "unionista ei voi tehdä läpinäkyvää" #: c/c-decl.c:7401 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "nested redefinition of %<enum %E%>" -msgstr "sisäkkäinen uudelleenmäärittely: %<enum %s%>" +msgstr "sisäkkäinen %<enum %E%>:n uudelleenmäärittely" #. This enum is a named one that has been declared already. #: c/c-decl.c:7408 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "redeclaration of %<enum %E%>" -msgstr "uudelleenmäärittely: %<enum %s>" +msgstr "%<enum %E%>:n uudelleenmäärittely" #: c/c-decl.c:7483 #, gcc-internal-format @@ -25488,7 +25240,7 @@ msgid "enumerator value for %qE is not an integer constant" msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio" #: c/c-decl.c:7616 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "enumerator value for %qE is not an integer constant expression" msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio" @@ -25510,102 +25262,102 @@ msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline" #: c/c-decl.c:7751 #, gcc-internal-format msgid "return type is an incomplete type" -msgstr "palautustyyppi on vaillinainen tyyppi" +msgstr "paluutyyppi on vaillinainen tyyppi" #: c/c-decl.c:7761 #, gcc-internal-format msgid "return type defaults to %<int%>" -msgstr "palautustyyppi on oletuksena %<int%>" +msgstr "paluutyyppi on oletuksena %<int%>" #: c/c-decl.c:7839 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "no previous prototype for %qD" -msgstr "%J%qD:lle ei ole aiempaa prototyyppiä" +msgstr "%qD:lle ei ole edellistä prototyyppiä" #: c/c-decl.c:7848 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qD was used with no prototype before its definition" -msgstr "%J%qD käytössä ilman prototyyppiä ennen määrittelyänsä" +msgstr "%qD käytössä ilman prototyyppiä ennen sen määrittelyä" #: c/c-decl.c:7855 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "no previous declaration for %qD" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "%qD:lle ei ole edellistä esittelyä" #: c/c-decl.c:7865 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qD was used with no declaration before its definition" -msgstr "%J%qD käytössä ilman esittelyä ennen määrittelyänsä" +msgstr "%qD käytössä ilman esittelyä ennen sen määrittelyä" #: c/c-decl.c:7884 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "return type of %qD is not %<int%>" -msgstr "%q+D-funktion paluuarvon tyyppi ei ole %<int%>" +msgstr "%qD:n paluuarvon tyyppi ei ole %<int%>" #: c/c-decl.c:7890 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qD is normally a non-static function" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qD on tavallisesti ei-staattinen funktio" #: c/c-decl.c:7927 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "old-style parameter declarations in prototyped function definition" -msgstr "%Jvanhanmallisia parametriesittelyitä prototyypitetyssä funktiomäärittelyssä" +msgstr "vanhanmallisia parametriesittelyitä prototyypitetyssä funktiomäärittelyssä" #: c/c-decl.c:7941 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "traditional C rejects ISO C style function definitions" -msgstr "%Jperinteinen C ei hyväksy ISO C -tyylisiä funktiomäärittelyitä" +msgstr "perinteinen C ei hyväksy ISO C -tyylisiä funktiomäärittelyitä" #: c/c-decl.c:7957 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "parameter name omitted" -msgstr "%Jparametrin nimi jätetty pois" +msgstr "parametrin nimi jätetty pois" #: c/c-decl.c:7994 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "old-style function definition" -msgstr "%Jvanhanmallinen funktiomäärittely" +msgstr "vanhanmallinen funktiomäärittely" #: c/c-decl.c:8003 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "parameter name missing from parameter list" -msgstr "%Jparametrin nimi puuttuu parametrilistasta" +msgstr "parametrin nimi puuttuu parametriluettelosta" #: c/c-decl.c:8018 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qD declared as a non-parameter" -msgstr "%q+D esitelty ei-parametrina" +msgstr "%qD esitelty ei-parametrina" #: c/c-decl.c:8024 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "multiple parameters named %qD" msgstr "useita parametreja nimellä %qD" #: c/c-decl.c:8033 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "parameter %qD declared with void type" -msgstr "parametri %q+D esitelty void-tyyppisenä" +msgstr "parametri %qD esitelty void-tyyppisenä" #: c/c-decl.c:8062 c/c-decl.c:8066 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type of %qD defaults to %<int%>" -msgstr "%q+D:n oletustyyppi on %<int%>" +msgstr "%qD:n oletustyyppi on %<int%>" #: c/c-decl.c:8086 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "parameter %qD has incomplete type" -msgstr "parametrin %q+D tyyppi on vaillinainen" +msgstr "parametrin %qD tyyppi on vaillinainen" #: c/c-decl.c:8093 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "declaration for parameter %qD but no such parameter" -msgstr "parametrin %q+D esittely, mutta parametria ei ole olemassa" +msgstr "parametrin %qD esittely, mutta parametria ei ole olemassa" #: c/c-decl.c:8145 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "number of arguments doesn%'t match built-in prototype" -msgstr "argumenttien määrä ei vastaa prototyyppiä" +msgstr "argumenttien määrä ei vastaa sisäistä prototyyppiä" #: c/c-decl.c:8156 #, gcc-internal-format @@ -25618,33 +25370,32 @@ msgid "prototype declaration" msgstr "prototyypin esittely" #: c/c-decl.c:8193 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "promoted argument %qD doesn%'t match built-in prototype" -msgstr "tyyppimuunnettu argumentti %qD ei sovi prototyyppiin" +msgstr "ylennetty argumentti %qD ei vastaa sisäistä prototyyppiä" #: c/c-decl.c:8198 #, gcc-internal-format msgid "promoted argument %qD doesn%'t match prototype" -msgstr "tyyppimuunnettu argumentti %qD ei sovi prototyyppiin" +msgstr "ylennetty argumentti %qD ei vastaa prototyyppiä" #: c/c-decl.c:8208 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "argument %qD doesn%'t match built-in prototype" -msgstr "argumentti %qD ei sovi prototyyppiin" +msgstr "argumentti %qD ei vastaa sisäistä prototyyppiä" #: c/c-decl.c:8213 #, gcc-internal-format msgid "argument %qD doesn%'t match prototype" msgstr "argumentti %qD ei sovi prototyyppiin" -#: c/c-decl.c:8396 cp/decl.c:13848 +#: c/c-decl.c:8396 cp/decl.c:13839 #, gcc-internal-format msgid "no return statement in function returning non-void" -msgstr "ei palautuslausetta funktiossa, joka palauttaa ei-tyhjän" +msgstr "ei palautuslausetta funktiossa, joka palauttaa ei-voidin" #: c/c-decl.c:8416 #, fuzzy, gcc-internal-format -#| msgid "parameter %qD is initialized" msgid "parameter %qD set but not used" msgstr "parametri %qD on alustettu" @@ -25698,16 +25449,16 @@ msgid "incompatible address space qualifiers %qs and %qs" msgstr "" #: c/c-decl.c:8886 c/c-decl.c:9216 c/c-decl.c:9645 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "duplicate %qE" -msgstr "ylimääräinen %qE" +msgstr "%qE:n kaksoiskappale" #: c/c-decl.c:8912 c/c-decl.c:9227 c/c-decl.c:9507 #, gcc-internal-format msgid "two or more data types in declaration specifiers" msgstr "yli yksi tietotyyppi esittelymääritteissä" -#: c/c-decl.c:8924 cp/parser.c:22803 +#: c/c-decl.c:8924 cp/parser.c:22807 #, gcc-internal-format msgid "%<long long long%> is too long for GCC" msgstr "%<long long long%> on liian pitkä GCC:lle" @@ -25758,14 +25509,14 @@ msgid "C++ lookup of %qD would return a field, not a type" msgstr "" #: c/c-decl.c:9538 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE fails to be a typedef or built in type" -msgstr "%qs ei ole typedef eikä sisäänrakennettu tyyppi" +msgstr "%qE ei ole typedef eikä sisäinen tyyppi" #: c/c-decl.c:9586 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE is not at beginning of declaration" -msgstr "%qs ei ole esittelyn alussa" +msgstr "%qE ei ole esittelyn alussa" #: c/c-decl.c:9607 #, gcc-internal-format @@ -25830,14 +25581,14 @@ msgstr "ISO C kieltää tyhjät käännösyksiköt" #: c/c-parser.c:1338 c/c-parser.c:7586 #, gcc-internal-format msgid "ISO C does not allow extra %<;%> outside of a function" -msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktioiden ulkopuolella" +msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella" #: c/c-parser.c:1464 c/c-parser.c:2046 c/c-parser.c:3321 #, fuzzy, gcc-internal-format msgid "unknown type name %qE" msgstr "tuntematon konetila %qs" -#: c/c-parser.c:1484 c/c-parser.c:8618 cp/parser.c:28127 +#: c/c-parser.c:1484 c/c-parser.c:8618 cp/parser.c:28131 #, fuzzy, gcc-internal-format msgid "expected declaration specifiers" msgstr "useita tallennuspaikkoja esittelymääritteissä" @@ -25847,7 +25598,7 @@ msgstr "useita tallennuspaikkoja esittelymääritteissä" msgid "expected %<;%>, identifier or %<(%>" msgstr "käytetty %<__thread%> ennen %<extern%>:a" -#: c/c-parser.c:1527 cp/parser.c:24553 cp/parser.c:24627 +#: c/c-parser.c:1527 cp/parser.c:24557 cp/parser.c:24631 #, fuzzy, gcc-internal-format msgid "prefix attributes are ignored for methods" msgstr "%Jlohkoattribuutteja ei tueta tälle kohteelle" @@ -25870,7 +25621,7 @@ msgstr "datamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa" #: c/c-parser.c:1701 cp/parser.c:10614 #, gcc-internal-format msgid "expected %<,%> or %<;%>" -msgstr "" +msgstr "odotettiin %<,%> tai %<;%>" #. This can appear in many cases looking nothing like a #. function definition, so we don't give a more specific @@ -25878,7 +25629,7 @@ msgstr "" #: c/c-parser.c:1708 c/c-parser.c:1724 #, gcc-internal-format msgid "expected %<=%>, %<,%>, %<;%>, %<asm%> or %<__attribute__%>" -msgstr "" +msgstr "odotettiin %<=%>, %<,%>, %<;%>, %<asm%> tai %<__attribute__%>" #: c/c-parser.c:1716 #, gcc-internal-format @@ -25887,24 +25638,21 @@ msgstr "ISO C kieltää sisäkkäiset funktiot" #: c/c-parser.c:1832 #, fuzzy, gcc-internal-format -#| msgid "ISO C90 does not support %<long long%>" msgid "ISO C99 does not support %<_Static_assert%>" msgstr "ISO C90 ei tue %<long long%> -tyyppiä" #: c/c-parser.c:1835 #, fuzzy, gcc-internal-format -#| msgid "ISO C90 does not support %<long long%>" msgid "ISO C90 does not support %<_Static_assert%>" msgstr "ISO C90 ei tue %<long long%> -tyyppiä" -#: c/c-parser.c:1860 c/c-parser.c:3388 c/c-parser.c:8673 cp/parser.c:27998 +#: c/c-parser.c:1860 c/c-parser.c:3388 c/c-parser.c:8673 cp/parser.c:28002 #, gcc-internal-format msgid "expected string literal" msgstr "odotettiin merkkijonoliteraalia" #: c/c-parser.c:1868 #, fuzzy, gcc-internal-format -#| msgid "array subscript is not an integer" msgid "expression in static assertion is not an integer" msgstr "taulukon indeksi ei ole kokonaisluku" @@ -25915,7 +25663,6 @@ msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke" #: c/c-parser.c:1880 #, fuzzy, gcc-internal-format -#| msgid "initializer element is not constant" msgid "expression in static assertion is not constant" msgstr "alustusalkio ei ole vakio" @@ -25931,21 +25678,21 @@ msgstr "" #: c/c-parser.c:7409 c/c-parser.c:7417 c/c-parser.c:7446 c/c-parser.c:7459 #: c/c-parser.c:7764 c/c-parser.c:7888 c/c-parser.c:8316 c/c-parser.c:8351 #: c/c-parser.c:8404 c/c-parser.c:8457 c/c-parser.c:8473 c/c-parser.c:8519 -#: c/c-parser.c:8798 c/c-parser.c:9873 c/c-parser.c:10676 cp/parser.c:23013 -#: cp/parser.c:25397 cp/parser.c:25427 cp/parser.c:25497 cp/parser.c:27718 +#: c/c-parser.c:8798 c/c-parser.c:9873 c/c-parser.c:10676 cp/parser.c:23017 +#: cp/parser.c:25401 cp/parser.c:25431 cp/parser.c:25501 cp/parser.c:27722 #, gcc-internal-format msgid "expected identifier" -msgstr "" +msgstr "odotettu tunniste" -#: c/c-parser.c:2295 cp/parser.c:14837 +#: c/c-parser.c:2295 cp/parser.c:14839 #, gcc-internal-format msgid "comma at end of enumerator list" -msgstr "luetellun tyypin listan lopussa on pilkku" +msgstr "luetellun tyypin luettelon lopussa on pilkku" #: c/c-parser.c:2301 #, gcc-internal-format msgid "expected %<,%> or %<}%>" -msgstr "" +msgstr "odotettiin %<,%> tai %<}%>" #: c/c-parser.c:2332 #, gcc-internal-format @@ -25980,37 +25727,35 @@ msgstr "ISO C kieltää jäsenettömät jäsenesittelyt" #: c/c-parser.c:2695 #, gcc-internal-format msgid "expected %<,%>, %<;%> or %<}%>" -msgstr "" +msgstr "odotettiin %<,%>, %<;%> tai %<}%>" #: c/c-parser.c:2702 #, gcc-internal-format msgid "expected %<:%>, %<,%>, %<;%>, %<}%> or %<__attribute__%>" -msgstr "" +msgstr "odotettiin %<:%>, %<,%>, %<;%>, %<}%> tai %<__attribute__%>" #: c/c-parser.c:2755 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<typeof%> applied to a bit-field" -msgstr "%<typeof%> sovellettu bittikenttään" +msgstr "%<typeof%>:ia sovellettu bittikenttään" #: c/c-parser.c:2789 #, fuzzy, gcc-internal-format -#| msgid "ISO C90 does not support %<long long%>" msgid "ISO C99 does not support %<_Alignas%>" msgstr "ISO C90 ei tue %<long long%> -tyyppiä" #: c/c-parser.c:2792 #, fuzzy, gcc-internal-format -#| msgid "ISO C90 does not support %<long long%>" msgid "ISO C90 does not support %<_Alignas%>" msgstr "ISO C90 ei tue %<long long%> -tyyppiä" #: c/c-parser.c:3020 #, gcc-internal-format msgid "expected identifier or %<(%>" -msgstr "" +msgstr "odotettiin tunnistetta tai %<(%>" #: c/c-parser.c:3227 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "ISO C requires a named argument before %<...%>" msgstr "ISO C vaatii nimetyn argumentin ennen %<...%>:a" @@ -26072,7 +25817,7 @@ msgstr "käytetty %<__thread%> ennen %<extern%>:a" #: c/c-parser.c:4225 cp/parser.c:9134 #, gcc-internal-format msgid "%<else%> without a previous %<if%>" -msgstr "" +msgstr "%<else%> ilman edeltävää %<if%>:iä" #: c/c-parser.c:4242 #, fuzzy, gcc-internal-format @@ -26082,7 +25827,7 @@ msgstr "nimike yhdyslauseen lopussa" #: c/c-parser.c:4287 #, gcc-internal-format msgid "expected %<:%> or %<...%>" -msgstr "" +msgstr "odotettiin %<:%> tai %<...%>" #: c/c-parser.c:4318 #, gcc-internal-format @@ -26092,7 +25837,7 @@ msgstr "" #: c/c-parser.c:4493 #, gcc-internal-format msgid "expected identifier or %<*%>" -msgstr "" +msgstr "odotettiin tunnistetta tai %<*%>" #. Avoid infinite loop in error recovery: #. c_parser_skip_until_found stops at a closing nesting @@ -26130,7 +25875,6 @@ msgstr "epäkelvot operandit binääriselle %s-operaatiolle" #: c/c-parser.c:5022 #, fuzzy, gcc-internal-format -#| msgid "missing sentinel in function call" msgid "missing collection in fast enumeration" msgstr "lopetusalkio puuttuu funktiokutsusta" @@ -26150,63 +25894,59 @@ msgid "traditional C rejects the unary plus operator" msgstr "perinteinen C ei salli unaarista plus-operaattoria" #: c/c-parser.c:6026 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<sizeof%> applied to a bit-field" -msgstr "%<sizeof%> sovellettu bittikenttään" +msgstr "%<sizeof%>:ia sovellettu bittikenttään" #: c/c-parser.c:6047 #, fuzzy, gcc-internal-format -#| msgid "ISO C90 does not support %<long long%>" msgid "ISO C99 does not support %qE" msgstr "ISO C90 ei tue %<long long%> -tyyppiä" #: c/c-parser.c:6050 #, fuzzy, gcc-internal-format -#| msgid "ISO C90 does not support %<long long%>" msgid "ISO C90 does not support %qE" msgstr "ISO C90 ei tue %<long long%> -tyyppiä" #: c/c-parser.c:6101 #, fuzzy, gcc-internal-format -#| msgid "ISO C does not allow extra %<;%> outside of a function" msgid "ISO C does not allow %<%E (expression)%>" -msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktioiden ulkopuolella" +msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella" #: c/c-parser.c:6126 #, fuzzy, gcc-internal-format -#| msgid "cannot take address of bit-field %qD" msgid "cannot take address of %qs" msgstr "bittikentän %qD osoitetta ei voi ottaa" #: c/c-parser.c:6297 c/c-parser.c:6747 c/c-parser.c:6766 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "expected expression" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "odotettiin lauseketta" +# XXXX #: c/c-parser.c:6315 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "braced-group within expression allowed only inside a function" -msgstr "lohkot lausekkeiden sisällä sallitaan vain funktioissa" +msgstr "lohkot lausekkeiden sisällä sallitaan vain funktion sisällä" +# XXXX #: c/c-parser.c:6328 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "ISO C forbids braced-groups within expressions" -msgstr "ISO C kieltää lohkot lausekkeen sisällä" +msgstr "ISO C kieltää lohkot lausekkeiden sisällä" #: c/c-parser.c:6520 #, fuzzy, gcc-internal-format -#| msgid "wrong number of arguments to function %<__builtin_next_arg%>" msgid "wrong number of arguments to %<__builtin_choose_expr%>" msgstr "väärä määrä argumentteja funktiolle %<__builtin_next_arg%>" #: c/c-parser.c:6536 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "first argument to %<__builtin_choose_expr%> not a constant" -msgstr "funktion %<__builtin_choose_expr%> ensimmäinen argumentti ei ole vakio" +msgstr "ensimmäinen argumentti funktiolle %<__builtin_choose_expr%> ei ole vakio" #: c/c-parser.c:6602 #, fuzzy, gcc-internal-format -#| msgid "wrong number of arguments to function %<__builtin_next_arg%>" msgid "wrong number of arguments to %<__builtin_complex%>" msgstr "väärä määrä argumentteja funktiolle %<__builtin_next_arg%>" @@ -26217,18 +25957,16 @@ msgstr "" #: c/c-parser.c:6633 #, fuzzy, gcc-internal-format -#| msgid "%<__builtin_longjmp%> second argument must be 1" msgid "%<__builtin_complex%> operands of different types" msgstr "%<__builtin_longjmp%>-fuktion toisen argumentin pitää olla 1" #: c/c-parser.c:6679 cp/parser.c:5531 #, fuzzy, gcc-internal-format -#| msgid "wrong number of arguments to function %<__builtin_next_arg%>" msgid "wrong number of arguments to %<__builtin_shuffle%>" msgstr "väärä määrä argumentteja funktiolle %<__builtin_next_arg%>" #: c/c-parser.c:6801 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "compound literal has variable size" msgstr "yhdysliteraalin koko on muuttuva" @@ -26245,7 +25983,7 @@ msgstr "ISO C90 kieltää yhdysliteraalit" #: c/c-parser.c:7190 #, fuzzy, gcc-internal-format msgid "expected identifier or %<)%>" -msgstr "%qs määrittää %<auto%>:n tiedostoalue-esittelyssä" +msgstr "odotettiin tunnistetta tai %<(%>" #: c/c-parser.c:7286 #, gcc-internal-format @@ -26274,135 +26012,130 @@ msgstr "useita tallennuspaikkoja esittelymääritteissä" #: c/c-parser.c:8230 #, fuzzy, gcc-internal-format -#| msgid "storage class specified for %qs" msgid "no type or storage class may be specified here," msgstr "tallennusluokka annettu %qs:lle" -#: c/c-parser.c:8320 c/c-parser.c:8377 cp/parser.c:25457 +#: c/c-parser.c:8320 c/c-parser.c:8377 cp/parser.c:25461 #, fuzzy, gcc-internal-format -#| msgid "<unknown operator>" msgid "unknown property attribute" msgstr "<tuntematon operaattori>" -#: c/c-parser.c:8341 cp/parser.c:25417 +#: c/c-parser.c:8341 cp/parser.c:25421 #, fuzzy, gcc-internal-format -#| msgid "missing %<(%> after %<#pragma pack%> - ignored" msgid "missing %<=%> (after %<getter%> attribute)" msgstr "puuttuva %<(%> ilmaisun %<#pragma pack%> jälkeen - jätetään huomiotta" -#: c/c-parser.c:8344 cp/parser.c:25420 +#: c/c-parser.c:8344 cp/parser.c:25424 #, fuzzy, gcc-internal-format -#| msgid "missing %<(%> after %<#pragma pack%> - ignored" msgid "missing %<=%> (after %<setter%> attribute)" msgstr "puuttuva %<(%> ilmaisun %<#pragma pack%> jälkeen - jätetään huomiotta" -#: c/c-parser.c:8358 cp/parser.c:25435 +#: c/c-parser.c:8358 cp/parser.c:25439 #, fuzzy, gcc-internal-format msgid "the %<setter%> attribute may only be specified once" msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle" -#: c/c-parser.c:8363 cp/parser.c:25441 +#: c/c-parser.c:8363 cp/parser.c:25445 #, gcc-internal-format msgid "setter name must terminate with %<:%>" msgstr "" -#: c/c-parser.c:8370 cp/parser.c:25449 +#: c/c-parser.c:8370 cp/parser.c:25453 #, fuzzy, gcc-internal-format msgid "the %<getter%> attribute may only be specified once" msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle" -#: c/c-parser.c:8556 cp/parser.c:28042 +#: c/c-parser.c:8556 cp/parser.c:28046 #, gcc-internal-format msgid "%<#pragma omp barrier%> may only be used in compound statements" msgstr "" -#: c/c-parser.c:8567 cp/parser.c:28057 +#: c/c-parser.c:8567 cp/parser.c:28061 #, gcc-internal-format msgid "%<#pragma omp flush%> may only be used in compound statements" msgstr "" -#: c/c-parser.c:8578 cp/parser.c:28073 +#: c/c-parser.c:8578 cp/parser.c:28077 #, gcc-internal-format msgid "%<#pragma omp taskwait%> may only be used in compound statements" msgstr "" -#: c/c-parser.c:8589 cp/parser.c:28089 +#: c/c-parser.c:8589 cp/parser.c:28093 #, gcc-internal-format msgid "%<#pragma omp taskyield%> may only be used in compound statements" msgstr "" -#: c/c-parser.c:8602 cp/parser.c:28117 +#: c/c-parser.c:8602 cp/parser.c:28121 #, gcc-internal-format msgid "%<#pragma omp section%> may only be used in %<#pragma omp sections%> construct" msgstr "" -#: c/c-parser.c:8608 cp/parser.c:28032 +#: c/c-parser.c:8608 cp/parser.c:28036 #, fuzzy, gcc-internal-format msgid "%<#pragma GCC pch_preprocess%> must be first" msgstr "väärinmuodostettu #pragma GCC pch_preprocess, jätetään huomiotta" -#: c/c-parser.c:8773 cp/parser.c:25705 +#: c/c-parser.c:8773 cp/parser.c:25709 #, gcc-internal-format msgid "too many %qs clauses" msgstr "" -#: c/c-parser.c:8875 cp/parser.c:25820 +#: c/c-parser.c:8875 cp/parser.c:25824 #, fuzzy, gcc-internal-format msgid "collapse argument needs positive constant integer expression" msgstr "etumerkillisen ja etumerkittömän kokonaislukulausekkeen vertailu" -#: c/c-parser.c:8941 cp/parser.c:25871 +#: c/c-parser.c:8941 cp/parser.c:25875 #, gcc-internal-format msgid "expected %<none%> or %<shared%>" -msgstr "" +msgstr "odotettiin %<none%> tai %<shared%>" #: c/c-parser.c:9076 c/c-parser.c:9290 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "expected integer expression" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "odotettiin kokonaislukulauseketta" #: c/c-parser.c:9088 #, gcc-internal-format msgid "%<num_threads%> value must be positive" -msgstr "" +msgstr "%<num_threads%>-arvon on oltava positiivinen" -#: c/c-parser.c:9192 cp/parser.c:26090 +#: c/c-parser.c:9192 cp/parser.c:26094 #, gcc-internal-format msgid "expected %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> or %<max%>" -msgstr "" +msgstr "odotettiin %<+%>, %<*%>, %<-%>, %<&%>, %<^%>, %<|%>, %<&&%>, %<||%>, %<min%> tai %<max%>" -#: c/c-parser.c:9281 cp/parser.c:26175 +#: c/c-parser.c:9281 cp/parser.c:26179 #, gcc-internal-format msgid "schedule %<runtime%> does not take a %<chunk_size%> parameter" msgstr "" -#: c/c-parser.c:9285 cp/parser.c:26178 +#: c/c-parser.c:9285 cp/parser.c:26182 #, gcc-internal-format msgid "schedule %<auto%> does not take a %<chunk_size%> parameter" msgstr "" -#: c/c-parser.c:9303 cp/parser.c:26194 +#: c/c-parser.c:9303 cp/parser.c:26198 #, gcc-internal-format msgid "invalid schedule kind" msgstr "" -#: c/c-parser.c:9431 cp/parser.c:26326 +#: c/c-parser.c:9431 cp/parser.c:26330 #, gcc-internal-format msgid "expected %<#pragma omp%> clause" msgstr "" -#: c/c-parser.c:9440 cp/parser.c:26335 +#: c/c-parser.c:9440 cp/parser.c:26339 #, fuzzy, gcc-internal-format msgid "%qs is not valid for %qs" msgstr "%qs ei ole kelpo tulostetiedosto" -#: c/c-parser.c:9732 cp/parser.c:26619 +#: c/c-parser.c:9732 cp/parser.c:26623 #, fuzzy, gcc-internal-format -#| msgid "junk at end of %<#pragma pack%>" msgid "invalid form of %<#pragma omp atomic%>" msgstr "roskaa ilmaisun %<#pragma pack%> lopussa" -#: c/c-parser.c:9772 c/c-parser.c:9790 cp/parser.c:26650 cp/parser.c:26667 +#: c/c-parser.c:9772 c/c-parser.c:9790 cp/parser.c:26654 cp/parser.c:26671 #, gcc-internal-format msgid "invalid operator for %<#pragma omp atomic%>" msgstr "" @@ -26410,29 +26143,29 @@ msgstr "" #: c/c-parser.c:9876 c/c-parser.c:9897 #, gcc-internal-format msgid "expected %<(%> or end of line" -msgstr "" +msgstr "odotettiin %<(%> tai rivin loppu" -#: c/c-parser.c:9932 cp/parser.c:26939 +#: c/c-parser.c:9932 cp/parser.c:26943 #, fuzzy, gcc-internal-format msgid "for statement expected" msgstr "ylivuoto vakiolausekkeessa" #: c/c-parser.c:9985 cp/semantics.c:4785 cp/semantics.c:4855 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "expected iteration declaration or initialization" -msgstr "%qD esitelty extern-avainsanalla sisäkkäin" +msgstr "odotettiin iteraatioesittelyä tai -alustusta" #: c/c-parser.c:10066 #, gcc-internal-format msgid "not enough perfectly nested loops" msgstr "" -#: c/c-parser.c:10119 cp/parser.c:27284 +#: c/c-parser.c:10119 cp/parser.c:27288 #, gcc-internal-format msgid "collapsed loops not perfectly nested" msgstr "" -#: c/c-parser.c:10157 cp/parser.c:27125 cp/parser.c:27163 cp/pt.c:12692 +#: c/c-parser.c:10157 cp/parser.c:27129 cp/parser.c:27167 cp/pt.c:12687 #, fuzzy, gcc-internal-format msgid "iteration variable %qD should not be firstprivate" msgstr "sisäkkäisessä funktiossa käytetty rekisterimuuttujaa %qD" @@ -26457,27 +26190,27 @@ msgstr "automaattimuuttuja %qE ei voi olla %<threadprivate%>" msgid "%<threadprivate%> %qE has incomplete type" msgstr "%Jparametrin %qD tyyppi on vaillinainen" -#: c/c-parser.c:10823 cp/parser.c:27928 +#: c/c-parser.c:10823 cp/parser.c:27932 #, gcc-internal-format msgid "%<__transaction_cancel%> without transactional memory support enabled" msgstr "" -#: c/c-parser.c:10829 cp/parser.c:27934 +#: c/c-parser.c:10829 cp/parser.c:27938 #, gcc-internal-format msgid "%<__transaction_cancel%> within a %<__transaction_relaxed%>" msgstr "" -#: c/c-parser.c:10838 cp/parser.c:27943 +#: c/c-parser.c:10838 cp/parser.c:27947 #, gcc-internal-format msgid "outer %<__transaction_cancel%> not within outer %<__transaction_atomic%>" msgstr "" -#: c/c-parser.c:10840 cp/parser.c:27946 +#: c/c-parser.c:10840 cp/parser.c:27950 #, gcc-internal-format msgid " or a %<transaction_may_cancel_outer%> function" msgstr "" -#: c/c-parser.c:10846 cp/parser.c:27952 +#: c/c-parser.c:10846 cp/parser.c:27956 #, gcc-internal-format msgid "%<__transaction_cancel%> not within %<__transaction_atomic%>" msgstr "" @@ -26572,7 +26305,7 @@ msgstr "tyypillä %qT ei ole %qE-nimistä jäsentä" #: c/c-typeck.c:2208 #, gcc-internal-format msgid "request for member %qE in something not a structure or union" -msgstr "pyydetty jäsentä %qE jostakin, joka ei ole tietue tai unioni" +msgstr "pyydetty jäsentä %qE jostakin, joka ei ole tietue eikä unioni" #: c/c-typeck.c:2257 #, gcc-internal-format @@ -26586,7 +26319,6 @@ msgstr "" #: c/c-typeck.c:2317 #, fuzzy, gcc-internal-format -#| msgid "subscripted value is neither array nor pointer" msgid "subscripted value is neither array nor pointer nor vector" msgstr "indeksoitu arvo ei ole taulukko eikä osoitin" @@ -26617,25 +26349,21 @@ msgstr "" #: c/c-typeck.c:2679 cp/decl2.c:4524 cp/typeck.c:3478 #, fuzzy, gcc-internal-format -#| msgid "%qD declared here" msgid "declared here" msgstr "%qD esitelty täällä" #: c/c-typeck.c:2746 #, fuzzy, gcc-internal-format -#| msgid "called object %qE is not a function" msgid "called object %qE is not a function or function pointer" msgstr "kutsuttu objekti %qE ei ole funktio" #: c/c-typeck.c:2751 #, fuzzy, gcc-internal-format -#| msgid "called object %qE is not a function" msgid "called object %qD is not a function or function pointer" msgstr "kutsuttu objekti %qE ei ole funktio" #: c/c-typeck.c:2757 #, fuzzy, gcc-internal-format -#| msgid "called object %qE is not a function" msgid "called object is not a function or function pointer" msgstr "kutsuttu objekti %qE ei ole funktio" @@ -26653,9 +26381,9 @@ msgid "function with qualified void return type called" msgstr "funktion määrittely oikeuttaa tyhjän paluutyypin" #: c/c-typeck.c:2951 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "too many arguments to method %qE" -msgstr "liikaa argumentteja funktiolle %s %q+#D" +msgstr "liikaa argumentteja metodille %qE" #: c/c-typeck.c:2990 #, gcc-internal-format, gfc-internal-format @@ -26719,17 +26447,16 @@ msgstr "funktion %2$qE argumentti %1$d annetaan etumerkillisenä prototyypin tak #: c/c-typeck.c:3152 cp/call.c:6219 #, fuzzy, gcc-internal-format -#| msgid "conversion from %qT to %qT is ambiguous" msgid "implicit conversion from %qT to %qT when passing argument to function" msgstr "muunnos tyypistä %qT tyyppiin %qT on moniselitteinen" #: c/c-typeck.c:3267 c/c-typeck.c:3272 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "comparison with string literal results in unspecified behavior" -msgstr "%J#pragma weak %qD -ilmaisun soveltaminen ensimmäisen käytön jälkeen käyttäytyy määrittelemättömästi" +msgstr "vertailu merkkijonoliteraalin kanssa aiheuttaa määrittelemätöntä toimintaa" #: c/c-typeck.c:3286 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "comparison between %qT and %qT" msgstr "tyyppien %qT ja %qT välinen vertailu" @@ -26781,12 +26508,12 @@ msgstr "vähennykselle annettu väärä tyyppiargumentti" #: c/c-typeck.c:3657 #, gcc-internal-format msgid "increment of pointer to unknown structure" -msgstr "tuntemattomaan tietueeseen osoittavan osoittimen kasvatus" +msgstr "tuntemattomaan rakenteeseen osoittavan osoittimen kasvatus" #: c/c-typeck.c:3660 #, gcc-internal-format msgid "decrement of pointer to unknown structure" -msgstr "tuntemattomaan tietueeseen osoittavan osoittimen vähennys" +msgstr "tuntemattomaan rakenteeseen osoittavan osoittimen vähennys" #: c/c-typeck.c:3744 #, gcc-internal-format @@ -26860,13 +26587,11 @@ msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta" #: c/c-typeck.c:4461 #, fuzzy -#| msgid "cast adds new qualifiers to function type" msgid "cast adds %q#v qualifier to function type" msgstr "tyyppimuunnos lisää funktiotyyppiin uusia määreitä" #: c/c-typeck.c:4467 #, fuzzy -#| msgid "cast discards qualifiers from pointer target type" msgid "cast discards %q#v qualifier from pointer target type" msgstr "osoitinkohdetyypin määreitä häviää tyyppimuunnoksessa" @@ -26888,12 +26613,12 @@ msgstr "tyyppimuunnos määrittää funktiotyypin" #: c/c-typeck.c:4561 #, gcc-internal-format msgid "ISO C forbids casting nonscalar to the same type" -msgstr "ISO C kieltää muuntamasta ei-skalaaria samaksi tyypiksi" +msgstr "ISO C kieltää tyyppimuuntamasta ei-skalaaria samaksi tyypiksi" #: c/c-typeck.c:4578 #, gcc-internal-format msgid "ISO C forbids casts to union type" -msgstr "ISO C kieltää muunnokset unionityyppeihin" +msgstr "ISO C kieltää tyyppimuunnokset unionityyppeihin" #: c/c-typeck.c:4588 #, gcc-internal-format @@ -26918,7 +26643,7 @@ msgstr "" #: c/c-typeck.c:4653 #, gcc-internal-format msgid "cast increases required alignment of target type" -msgstr "kohdetyypin vaatima tasaus kasvaa tyyppimuunnoksessa" +msgstr "kohdetyypin vaatima kohdistus kasvaa tyyppimuunnoksessa" #: c/c-typeck.c:4664 #, gcc-internal-format @@ -26928,7 +26653,7 @@ msgstr "tyyppimuunnos osoittimesta erikokoiseen kokonaislukuun" #: c/c-typeck.c:4669 #, gcc-internal-format msgid "cast from function call of type %qT to non-matching type %qT" -msgstr "muunnos %qT-tyyppisestä funktiokutsusta yhteensopimattomaan tyyppiin %qT" +msgstr "tyyppimuunnos %qT-tyyppisestä funktiokutsusta yhteensopimattomaan tyyppiin %qT" #: c/c-typeck.c:4678 cp/typeck.c:6905 #, gcc-internal-format @@ -26948,12 +26673,12 @@ msgstr "ISO C kieltää objektiosoittimen muuntamisen funktio-osoitintyypiksi" #: c/c-typeck.c:4787 #, gcc-internal-format msgid "defining a type in a cast is invalid in C++" -msgstr "" +msgstr "tyypin määritteleminen tyyppimuunnoksessa on virheellistä C++-kielessä" #: c/c-typeck.c:4926 c/c-typeck.c:5223 #, gcc-internal-format msgid "enum conversion in assignment is invalid in C++" -msgstr "" +msgstr "enum-muunnos sijoituksessa on virheellistä C++-kielessä" #. This macro is used to emit diagnostics to ensure that all format #. strings are complete sentences, visible to gettext and checked at @@ -26963,9 +26688,9 @@ msgstr "" #. compile time. It is the same as WARN_FOR_ASSIGNMENT but with an #. extra parameter to enumerate qualifiers. #: c/c-typeck.c:5131 c/c-typeck.c:5161 c/c-typeck.c:5690 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "expected %qT but argument is of type %qT" -msgstr "muotoilu %q.*s edellyttää %<%T%s%>-tyyppiä, mutta %d. argumentin tyyppi on %qT" +msgstr "odotettiin %qT, mutta argumentti on tyyppiä %qT" #: c/c-typeck.c:5221 #, gcc-internal-format @@ -26975,12 +26700,12 @@ msgstr "" #: c/c-typeck.c:5225 c/c-typeck.c:7793 #, gcc-internal-format msgid "enum conversion in initialization is invalid in C++" -msgstr "" +msgstr "enum-muunnos alustuksessa on virheellistä C++-kielessä" #: c/c-typeck.c:5227 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "enum conversion in return is invalid in C++" -msgstr "epäkelvot operandit binääriselle %s-operaatiolle" +msgstr "enum-muunnos palautuksessa on virheellistä C++-kielessä" #: c/c-typeck.c:5256 #, gcc-internal-format @@ -26989,19 +26714,16 @@ msgstr "" #: c/c-typeck.c:5386 c/c-typeck.c:5611 #, fuzzy -#| msgid "passing argument %d of %qE makes integer from pointer without a cast" msgid "passing argument %d of %qE makes %q#v qualified function pointer from unqualified" msgstr "argumentin %d antaminen funktiolle %qE tekee kokonaisluvusta osoittimen ilman tyyppimuunnosta" #: c/c-typeck.c:5389 c/c-typeck.c:5614 #, fuzzy -#| msgid "assignment discards qualifiers from pointer target type" msgid "assignment makes %q#v qualified function pointer from unqualified" msgstr "sijoitus hylkää kohdeosoitintyypin määreitä" #: c/c-typeck.c:5392 c/c-typeck.c:5616 #, fuzzy -#| msgid "initialization discards qualifiers from pointer target type" msgid "initialization makes %q#v qualified function pointer from unqualified" msgstr "alustus hylkää kohdeosoitintyypin määreitä" @@ -27016,19 +26738,16 @@ msgstr "sijoitus hylkää kohdeosoitintyypin määreitä" #: c/c-typeck.c:5404 c/c-typeck.c:5576 #, fuzzy -#| msgid "assignment discards qualifiers from pointer target type" msgid "assignment discards %qv qualifier from pointer target type" msgstr "sijoitus hylkää kohdeosoitintyypin määreitä" #: c/c-typeck.c:5406 c/c-typeck.c:5578 #, fuzzy -#| msgid "initialization discards qualifiers from pointer target type" msgid "initialization discards %qv qualifier from pointer target type" msgstr "alustus hylkää kohdeosoitintyypin määreitä" #: c/c-typeck.c:5408 c/c-typeck.c:5580 #, fuzzy -#| msgid "return discards qualifiers from pointer target type" msgid "return discards %qv qualifier from pointer target type" msgstr "palautus hylkää kohdeosoitintyypin määreitä" @@ -27190,14 +26909,14 @@ msgid "return makes integer from pointer without a cast" msgstr "palautus tekee osoittimesta kokonaisluvun ilman tyyppimuunnosta" #: c/c-typeck.c:5693 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "incompatible types when assigning to type %qT from type %qT" -msgstr "yhteensopimattomat tyypit sijoituksessa" +msgstr "yhteensopimattomat tyypit sijoituksessa tyyppiin %qT tyypistä %qT" #: c/c-typeck.c:5698 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "incompatible types when initializing type %qT using type %qT" -msgstr "yhteensopimattomat tyypit alustuksessa" +msgstr "yhteensopimattomat tyypit alustettaessa tyyppiä %qT käyttäen tyyppiä %qT" #: c/c-typeck.c:5703 #, gcc-internal-format @@ -27263,7 +26982,7 @@ msgstr "alustinalkio ei ole vakiolauseke" #: c/c-typeck.c:6289 c/c-typeck.c:7771 #, gcc-internal-format msgid "initializer element is not computable at load time" -msgstr "alustuselementtiä ei pystytä laskemaan latausajankohtana" +msgstr "alustusalkiota ei pystytä laskemaan latausajankohtana" #: c/c-typeck.c:6307 #, gcc-internal-format @@ -27313,7 +27032,7 @@ msgstr "skalaarialustimessa ylimääräisiä alkioita" #: c/c-typeck.c:7116 c/c-typeck.c:7197 #, gcc-internal-format msgid "array index in non-array initializer" -msgstr "" +msgstr "taulukkoindeksi ei-taulukkoalustimessa" #: c/c-typeck.c:7121 c/c-typeck.c:7253 #, gcc-internal-format @@ -27323,32 +27042,32 @@ msgstr "" #: c/c-typeck.c:7170 #, gcc-internal-format msgid "array index in initializer not of integer type" -msgstr "" +msgstr "taulukkoindeksi alustimessa ei ole kokonaislukutyyppinen" #: c/c-typeck.c:7179 c/c-typeck.c:7188 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "array index in initializer is not an integer constant expression" -msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke" +msgstr "taulukkoindeksi alustimessa ei ole kokonaislukutyyppinen vakiolauseke" #: c/c-typeck.c:7193 c/c-typeck.c:7195 #, gcc-internal-format msgid "nonconstant array index in initializer" -msgstr "ei-vakio taulukon indeksi alustimessa" +msgstr "ei-vakio taulukkoindeksi alustimessa" #: c/c-typeck.c:7199 c/c-typeck.c:7202 #, gcc-internal-format msgid "array index in initializer exceeds array bounds" -msgstr "taulukon indeksi alustimessa ylittää taulukon rajat" +msgstr "taulukkoindeksi alustimessa ylittää taulukon rajat" #: c/c-typeck.c:7216 #, gcc-internal-format msgid "empty index range in initializer" -msgstr "" +msgstr "tyhjä indeksiväli alustimessa" #: c/c-typeck.c:7225 #, gcc-internal-format msgid "array index range in initializer exceeds array bounds" -msgstr "" +msgstr "taulukkoindeksiväli alustimessa ylittää taulukon rajat" #: c/c-typeck.c:7260 #, gcc-internal-format @@ -27363,27 +27082,27 @@ msgstr "" #: c/c-typeck.c:7314 c/c-typeck.c:7341 c/c-typeck.c:7868 #, gcc-internal-format msgid "initialized field overwritten" -msgstr "" +msgstr "alustettu kenttä ylikirjoitettu" #: c/c-typeck.c:8084 #, gcc-internal-format msgid "excess elements in char array initializer" -msgstr "" +msgstr "ylimääräisiä alkioita merkkitaulukkoalustimessa" #: c/c-typeck.c:8091 c/c-typeck.c:8152 #, gcc-internal-format msgid "excess elements in struct initializer" -msgstr "" +msgstr "ylimääräisiä alkioita struct-alustimessa" #: c/c-typeck.c:8167 #, gcc-internal-format msgid "non-static initialization of a flexible array member" -msgstr "" +msgstr "joustavan taulukkojäsenen ei-staattinen alustus" #: c/c-typeck.c:8238 #, gcc-internal-format msgid "excess elements in union initializer" -msgstr "" +msgstr "ylimääräisiä alkioita union-alustimessa" #: c/c-typeck.c:8260 #, gcc-internal-format @@ -27393,17 +27112,17 @@ msgstr "" #: c/c-typeck.c:8328 #, gcc-internal-format msgid "excess elements in array initializer" -msgstr "" +msgstr "ylimääräisiä alkioita taulukkoalustimessa" #: c/c-typeck.c:8362 #, gcc-internal-format msgid "excess elements in vector initializer" -msgstr "" +msgstr "ylimääräisiä alkioita vektorialustimessa" #: c/c-typeck.c:8394 #, gcc-internal-format msgid "excess elements in scalar initializer" -msgstr "" +msgstr "ylimääräisiä alkioita skalaarialustimessa" #: c/c-typeck.c:8631 #, gcc-internal-format @@ -27463,7 +27182,7 @@ msgstr "" #: c/c-typeck.c:8977 cp/parser.c:9265 #, gcc-internal-format msgid "suggest explicit braces to avoid ambiguous %<else%>" -msgstr "ehdotetaan aaltosulkeita epäselvän %<else%>n välttämiseksi" +msgstr "ehdotetaan aaltosulkeita epäselvän %<else%>:n välttämiseksi" #: c/c-typeck.c:9086 cp/parser.c:9994 #, gcc-internal-format @@ -27492,7 +27211,6 @@ msgstr "" #: c/c-typeck.c:9894 c/c-typeck.c:10031 cp/typeck.c:4461 #, fuzzy, gcc-internal-format -#| msgid "Warn about comparison of different enum types" msgid "comparing vectors with different element types" msgstr "Varoita eri enum-tyyppien vertailusta" @@ -27539,7 +27257,7 @@ msgstr "osoittimen ja kokonaisluvun välinen vertailu" #: c/c-typeck.c:10069 #, gcc-internal-format msgid "comparison of complete and incomplete pointers" -msgstr "" +msgstr "täydellisen ja vaillinaisen osoittimen vertailu" #: c/c-typeck.c:10071 #, gcc-internal-format @@ -27548,7 +27266,6 @@ msgstr "ISO C kieltää funktio-osoittimien suuruusvertailun" #: c/c-typeck.c:10076 #, fuzzy, gcc-internal-format -#| msgid "ordered comparison of pointer with integer zero" msgid "ordered comparison of pointer with null pointer" msgstr "osoittimen ja kokonaisluku nollan suuruusvertailu" @@ -27580,7 +27297,6 @@ msgstr "käytetty unionityypin arvoa, vaikka vaaditaan skalaari" #: c/c-typeck.c:10459 #, fuzzy, gcc-internal-format -#| msgid "used struct type value where scalar is required" msgid "used vector type where scalar is required" msgstr "käytetty tietuetyypin arvoa, vaikka vaaditaan skalaari" @@ -27644,8 +27360,8 @@ msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT" #, 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[0] " ehdokas odottaa %d argumenttia, %d annettu" +msgstr[1] " ehdokas odottaa %d argumenttia, %d annettu" #: cp/call.c:3154 #, gcc-internal-format @@ -27654,13 +27370,11 @@ msgstr "" #: cp/call.c:3159 #, fuzzy, gcc-internal-format -#| msgid "<built-in>" msgid "%s%D(%T, %T) <built-in>" msgstr "<sisäinen>" #: cp/call.c:3163 #, fuzzy, gcc-internal-format -#| msgid "<built-in>" msgid "%s%D(%T) <built-in>" msgstr "<sisäinen>" @@ -27784,7 +27498,6 @@ msgstr "" #: cp/call.c:4218 cp/call.c:4249 cp/call.c:4258 #, fuzzy, gcc-internal-format -#| msgid "<unknown operator>" msgid "%<operator%s%>" msgstr "<tuntematon operaattori>" @@ -27795,7 +27508,6 @@ msgstr "" #: cp/call.c:4228 #, fuzzy, gcc-internal-format -#| msgid "<unknown operator>" msgid "%<operator[]%>" msgstr "<tuntematon operaattori>" @@ -27806,7 +27518,6 @@ msgstr "" #: cp/call.c:4239 #, fuzzy, gcc-internal-format -#| msgid "%s" msgid "%qs" msgstr "%s" @@ -27837,7 +27548,6 @@ msgstr "" #: cp/call.c:4433 #, fuzzy, gcc-internal-format -#| msgid "pointer type mismatch in conditional expression" msgid "incompatible vector types in conditional expression: %qT, %qT and %qT" msgstr "ehtolausekkeessa on osoitintyyppiristiriita" @@ -27932,23 +27642,22 @@ msgid "converting to non-pointer type %qT from NULL" msgstr "NULLin muunnos epäosoitintyypiksi %qT" #: cp/call.c:5755 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "converting %<false%> to pointer type for argument %P of %qD" -msgstr "annettu NULL funktion %2$qD ei-osoitinargumenttina %1$P" +msgstr "muunnetaan %<false%> osoitintyyppiksi %2$qD:n argumentissa %1$P" #: cp/call.c:5759 #, fuzzy, gcc-internal-format msgid "converting %<false%> to pointer type %qT" -msgstr "annettu NULL funktion %2$qD ei-osoitinargumenttina %1$P" +msgstr "muunnetaan %<false%> osoitintyyppiksi %qT" #: cp/call.c:5802 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "too many braces around initializer for %qT" -msgstr "alustimen ympäriltä puuttuu aaltosulkeet" +msgstr "liikaa aaltosulkeita %qT:n alustimen ympärillä" #: cp/call.c:5808 #, fuzzy, gcc-internal-format -#| msgid "invalid conversion from %qT to %qT" msgid "invalid user-defined conversion from %qT to %qT" msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT" @@ -27968,9 +27677,9 @@ msgid "converting to %qT from initializer list would use explicit constructor %q msgstr "" #: cp/call.c:5949 cp/call.c:6080 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid " initializing argument %P of %q+D" -msgstr " alustettaessa funktion %2$qD argumenttia %1$P" +msgstr " alustettaessa funktion %2$q+D argumenttia %1$P" # XXX # %s on "initialization", jota EI VOI suomentaa tällä hetkellä. @@ -28000,15 +27709,15 @@ msgid "scoped enum %qT will not promote to an integral type in a future version msgstr "" #: cp/call.c:6268 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "cannot pass objects of non-trivially-copyable type %q#T through %<...%>" -msgstr "%q#T-tyyppisiä epä-POD-objekteja ei voi välittää %<...%>:n kautta, ohjelma tulee keskeytymään ajettaessa" +msgstr "ei-triviaalisti-kopioitavan tyyppisiä %q#T-olioita ei voi välittää %<...%>:n kautta" #. conditionally-supported behavior [expr.call] 5.2.2/7. #: cp/call.c:6300 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "cannot receive objects of non-trivially-copyable type %q#T through %<...%>; " -msgstr "%q#T-tyyppisiä epä-POD-objekteja ei voi vastaanottaa %<...%>:n kautta, ohjelma tulee keskeytymään ajettaessa" +msgstr "ei-triviaalisti-kopioitavan tyyppisiä %q#T-olioita ei voi vastaanottaa %<...%>:n kautta" #: cp/call.c:6359 #, gcc-internal-format @@ -28021,9 +27730,9 @@ msgid "call to %qD uses the default argument for parameter %P, which is not yet msgstr "" #: cp/call.c:6482 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "argument of function call might be a candidate for a format attribute" -msgstr "funktio on ehkä mahdollinen ehdokas %qs-muotoiluattribuutille" +msgstr "funktiokutsun argumentti voi olla ehdokas muotoiluattribuutille" # XXX #: cp/call.c:6526 @@ -28056,108 +27765,107 @@ msgstr "%J%qD esitelty turhaan uudestaan" msgid " (you can disable this with -fno-deduce-init-list)" msgstr "" -#: cp/call.c:7153 +#: cp/call.c:7156 #, gcc-internal-format msgid "could not find class$ field in java interface type %qT" msgstr "" -#: cp/call.c:7414 +#: cp/call.c:7417 #, gcc-internal-format msgid "call to non-function %qD" msgstr "" -#: cp/call.c:7459 cp/typeck.c:2680 +#: cp/call.c:7462 cp/typeck.c:2680 #, gcc-internal-format msgid "cannot call constructor %<%T::%D%> directly" msgstr "" -#: cp/call.c:7461 +#: cp/call.c:7464 #, gcc-internal-format msgid " for a function-style cast, remove the redundant %<::%D%>" msgstr "" -#: cp/call.c:7578 +#: cp/call.c:7581 #, gcc-internal-format msgid "no matching function for call to %<%T::operator %T(%A)%#V%>" msgstr "" -#: cp/call.c:7591 +#: cp/call.c:7594 #, gcc-internal-format msgid "no matching function for call to %<%T::%s(%A)%#V%>" msgstr "" -#: cp/call.c:7616 +#: cp/call.c:7619 #, gcc-internal-format msgid "call of overloaded %<%s(%A)%> is ambiguous" msgstr "" -#: cp/call.c:7645 +#: cp/call.c:7661 #, gcc-internal-format msgid "cannot call member function %qD without object" msgstr "jäsenfunktiota %qD ei voi kutsua ilman oliota" -#: cp/call.c:8410 +#: cp/call.c:8428 #, gcc-internal-format msgid "passing %qT chooses %qT over %qT" msgstr "" -#: cp/call.c:8412 cp/name-lookup.c:5552 +#: cp/call.c:8430 cp/name-lookup.c:5547 #, gcc-internal-format msgid " in call to %qD" msgstr "" -#: cp/call.c:8470 +#: cp/call.c:8488 #, gcc-internal-format msgid "choosing %qD over %qD" msgstr "" -#: cp/call.c:8471 +#: cp/call.c:8489 #, gcc-internal-format msgid " for conversion from %qT to %qT" msgstr "" -#: cp/call.c:8474 +#: cp/call.c:8492 #, gcc-internal-format msgid " because conversion sequence for the argument is better" msgstr "" -#: cp/call.c:8628 +#: cp/call.c:8646 #, gcc-internal-format msgid "default argument mismatch in overload resolution" msgstr "" -#: cp/call.c:8631 +#: cp/call.c:8649 #, gcc-internal-format msgid " candidate 1: %q+#F" -msgstr "" +msgstr " ehdokas 1: %q+#F" -#: cp/call.c:8633 +#: cp/call.c:8651 #, gcc-internal-format msgid " candidate 2: %q+#F" -msgstr "" +msgstr " ehdokas 2: %q+#F" -#: cp/call.c:8677 +#: cp/call.c:8695 #, 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 "ISO C++:n mukaan nämä ovat moniselitteisiä siitä huolimatta, että ensimmäisen huonoin muunnos on parempi kuin toisen huonoin:" -#: cp/call.c:8841 +#: cp/call.c:8859 #, fuzzy, gcc-internal-format -#| msgid "converting from %qT to %qT" msgid "could not convert %qE from %qT to %qT" msgstr "muunnos tyypistä %qT tyyppiin %qT" -#: cp/call.c:9034 +#: cp/call.c:9052 #, gcc-internal-format msgid "a temporary bound to %qD only persists until the constructor exits" msgstr "" -#: cp/call.c:9150 +#: cp/call.c:9168 #, fuzzy, gcc-internal-format msgid "invalid initialization of non-const reference of type %qT from an rvalue of type %qT" msgstr "virheellinen %qT-tyyppisen ei-const-viittauksen alustus %qT-tyyppisestä väliaikaisesta muuttujasta" -#: cp/call.c:9154 +#: cp/call.c:9172 #, gcc-internal-format msgid "invalid initialization of reference of type %qT from expression of type %qT" msgstr "virheellinen %qT-tyyppisen viittauksen alustus %qT-tyyppisestä lausekkeesta" @@ -28179,7 +27887,6 @@ msgstr "Java-luokalla %qT ei voi olla implisiittistä epätriviaalia hajotinta" #: cp/class.c:1120 #, fuzzy, gcc-internal-format -#| msgid "type %qT is not derived from type %qT" msgid "%q#D inherited from %qT" msgstr "tyyppi %qT ei periydy %qT-tyypistä" @@ -28230,7 +27937,6 @@ msgstr "" #: cp/class.c:1331 cp/class.c:1341 #, fuzzy, gcc-internal-format -#| msgid "%qD declared here" msgid "%qT declared here" msgstr "%qD esitelty täällä" @@ -28269,369 +27975,366 @@ msgstr "" msgid "no unique final overrider for %qD in %qT" msgstr "" -#: cp/class.c:2648 +#: cp/class.c:2652 #, fuzzy, gcc-internal-format msgid "%q+#D marked final, but is not virtual" msgstr "%Jnimike %qD määritelty, mutta ei käytetty" -#: cp/class.c:2650 +#: cp/class.c:2654 #, gcc-internal-format msgid "%q+#D marked override, but does not override" msgstr "" #. Here we know it is a hider, and no overrider exists. -#: cp/class.c:2719 +#: cp/class.c:2723 #, gcc-internal-format msgid "%q+D was hidden" -msgstr "" +msgstr "%q+D oli piilotettu" -#: cp/class.c:2720 +#: cp/class.c:2724 #, gcc-internal-format msgid " by %q+D" msgstr "" -#: cp/class.c:2763 cp/decl2.c:1365 +#: cp/class.c:2767 cp/decl2.c:1365 #, gcc-internal-format msgid "%q+#D invalid; an anonymous union can only have non-static data members" msgstr "" # semi-fuzzy -#: cp/class.c:2766 +#: cp/class.c:2770 #, fuzzy, gcc-internal-format msgid "%q+#D invalid; an anonymous struct can only have non-static data members" msgstr "ei-staattista datajäsentä %q+D käytetty virheellisesti" -#: cp/class.c:2774 cp/decl2.c:1371 +#: cp/class.c:2778 cp/decl2.c:1371 #, gcc-internal-format msgid "private member %q+#D in anonymous union" msgstr "" -#: cp/class.c:2776 +#: cp/class.c:2780 #, gcc-internal-format msgid "private member %q+#D in anonymous struct" msgstr "" -#: cp/class.c:2781 cp/decl2.c:1373 +#: cp/class.c:2785 cp/decl2.c:1373 #, gcc-internal-format msgid "protected member %q+#D in anonymous union" msgstr "" -#: cp/class.c:2783 +#: cp/class.c:2787 #, gcc-internal-format msgid "protected member %q+#D in anonymous struct" msgstr "" -#: cp/class.c:2927 +#: cp/class.c:2931 #, gcc-internal-format msgid "the ellipsis in %qD is not inherited" msgstr "" -#: cp/class.c:3103 +#: cp/class.c:3106 #, gcc-internal-format msgid "bit-field %q+#D with non-integral type" msgstr "bittikenttä %+q#D ei ole kokonaislukutyyppinen" -#: cp/class.c:3119 +#: cp/class.c:3122 #, gcc-internal-format msgid "bit-field %q+D width not an integer constant" msgstr "bittikentän %q+D leveys ei ole kokonaislukuvakio" -#: cp/class.c:3124 +#: cp/class.c:3127 #, gcc-internal-format msgid "negative width in bit-field %q+D" msgstr "bittikentän %q+D leveys negatiivinen" -#: cp/class.c:3129 +#: cp/class.c:3132 #, gcc-internal-format msgid "zero width for bit-field %q+D" msgstr "bittikentän %q+D leveys nolla" -#: cp/class.c:3135 +#: cp/class.c:3138 #, gcc-internal-format msgid "width of %q+D exceeds its type" msgstr "bittikentän %q+D leveys ylittää kentän tyypin leveyden" -#: cp/class.c:3139 +#: cp/class.c:3142 #, gcc-internal-format msgid "%q+D is too small to hold all values of %q#T" -msgstr "" +msgstr "%q+D on liian pieni sisältämään %q#T:n kaikkia arvoja" -#: cp/class.c:3198 +#: cp/class.c:3201 #, gcc-internal-format msgid "member %q+#D with constructor not allowed in union" msgstr "" -#: cp/class.c:3201 +#: cp/class.c:3204 #, gcc-internal-format msgid "member %q+#D with destructor not allowed in union" msgstr "" -#: cp/class.c:3203 +#: cp/class.c:3206 #, gcc-internal-format msgid "member %q+#D with copy assignment operator not allowed in union" msgstr "" -#: cp/class.c:3207 +#: cp/class.c:3210 #, gcc-internal-format msgid "unrestricted unions only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/class.c:3244 +#: cp/class.c:3247 #, gcc-internal-format msgid "multiple fields in union %qT initialized" -msgstr "" +msgstr "useita kenttiä unionissa %qT alustettu" -#: cp/class.c:3329 +#: cp/class.c:3332 #, gcc-internal-format msgid "%q+D may not be static because it is a member of a union" -msgstr "" +msgstr "%q+D ei voi olla staattinen koska se on unionin jäsen" -#: cp/class.c:3334 +#: cp/class.c:3337 #, gcc-internal-format msgid "%q+D may not have reference type %qT because it is a member of a union" -msgstr "" +msgstr "%q+D:lla ei voi olla viitetyyppiä %qT, koska se on unionin jäsen" -#: cp/class.c:3345 +#: cp/class.c:3348 #, fuzzy, gcc-internal-format msgid "field %q+D invalidly declared function type" msgstr "kenttä %qs esitelty funktiona" -#: cp/class.c:3351 +#: cp/class.c:3354 #, fuzzy, gcc-internal-format msgid "field %q+D invalidly declared method type" msgstr "%Jparametri %qD esitelty tyhjällä tyypillä" -#: cp/class.c:3407 +#: cp/class.c:3410 #, gcc-internal-format msgid "ignoring packed attribute because of unpacked non-POD field %q+#D" msgstr "" -#: cp/class.c:3504 +#: cp/class.c:3507 #, gcc-internal-format msgid "field %q+#D with same name as class" -msgstr "" +msgstr "kentällä %q+#D on sama nimi kuin luokalla" -#: cp/class.c:3527 +#: cp/class.c:3530 #, gcc-internal-format msgid "%q#T has pointer data members" msgstr "luokalla %q#T on datajäseninä osoittimia" -#: cp/class.c:3532 +#: cp/class.c:3535 #, gcc-internal-format msgid " but does not override %<%T(const %T&)%>" msgstr " mutta ei ylikuormitusta %<%T(const %T&)%>" -#: cp/class.c:3534 +#: cp/class.c:3537 #, gcc-internal-format msgid " or %<operator=(const %T&)%>" msgstr " eikä %<operator=(const %T&)%>" -#: cp/class.c:3538 +#: cp/class.c:3541 #, gcc-internal-format msgid " but does not override %<operator=(const %T&)%>" -msgstr "" +msgstr " mutta ei ylikuormitusta %<operator=(const %T&)%>" -#: cp/class.c:4009 +#: cp/class.c:4012 #, gcc-internal-format msgid "offset of empty base %qT may not be ABI-compliant and maychange in a future version of GCC" msgstr "" -#: cp/class.c:4136 +#: cp/class.c:4139 #, gcc-internal-format msgid "class %qT will be considered nearly empty in a future version of GCC" msgstr "" -#: cp/class.c:4218 +#: cp/class.c:4221 #, gcc-internal-format msgid "initializer specified for non-virtual method %q+D" msgstr "" -#: cp/class.c:4645 +#: cp/class.c:4648 #, gcc-internal-format msgid "method overrides both %<transaction_pure%> and %qE methods" msgstr "" -#: cp/class.c:4666 +#: cp/class.c:4669 #, gcc-internal-format msgid "method declared %qE overriding %qE method" msgstr "" -#: cp/class.c:5132 cp/semantics.c:5826 +#: cp/class.c:5135 cp/semantics.c:5828 #, fuzzy, gcc-internal-format msgid "enclosing class of constexpr non-static member function %q+#D is not a literal type" msgstr "%q+D-funktion paluuarvon tyyppi ei ole %<int%>" -#: cp/class.c:5157 +#: cp/class.c:5160 #, fuzzy, gcc-internal-format -#| msgid "%q#T is not a class" msgid "%q+T is not literal because:" msgstr "%q#T ei ole luokka" -#: cp/class.c:5159 +#: cp/class.c:5162 #, fuzzy, gcc-internal-format -#| msgid "Java class %qT cannot have an implicit non-trivial destructor" msgid " %q+T has a non-trivial destructor" msgstr "Java-luokalla %qT ei voi olla implisiittistä epätriviaalia hajotinta" -#: cp/class.c:5164 +#: cp/class.c:5167 #, 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 "" -#: cp/class.c:5200 +#: cp/class.c:5203 #, gcc-internal-format msgid " base class %qT of %q+T is non-literal" msgstr "" -#: cp/class.c:5214 +#: cp/class.c:5217 #, fuzzy, gcc-internal-format msgid " non-static data member %q+D has non-literal type" msgstr "%Jparametri %qD esitelty %<inline%>:ksi" -#: cp/class.c:5332 +#: cp/class.c:5335 #, gcc-internal-format msgid "non-static reference %q+#D in class without a constructor" msgstr "" -#: cp/class.c:5337 +#: cp/class.c:5340 #, gcc-internal-format msgid "non-static const member %q+#D in class without a constructor" msgstr "" #. If the function is defaulted outside the class, we just #. give the synthesis error. -#: cp/class.c:5363 +#: cp/class.c:5366 #, gcc-internal-format msgid "%q+D declared to take const reference, but implicit declaration would take non-const" msgstr "" -#: cp/class.c:5587 +#: cp/class.c:5590 #, gcc-internal-format msgid "offset of virtual base %qT is not ABI-compliant and may change in a future version of GCC" msgstr "" -#: cp/class.c:5688 +#: cp/class.c:5691 #, gcc-internal-format msgid "direct base %qT inaccessible in %qT due to ambiguity" msgstr "" -#: cp/class.c:5700 +#: cp/class.c:5703 #, gcc-internal-format msgid "virtual base %qT inaccessible in %qT due to ambiguity" msgstr "" -#: cp/class.c:5886 +#: cp/class.c:5889 #, gcc-internal-format msgid "size assigned to %qT may not be ABI-compliant and may change in a future version of GCC" msgstr "" -#: cp/class.c:5926 +#: cp/class.c:5929 #, gcc-internal-format msgid "the offset of %qD may not be ABI-compliant and may change in a future version of GCC" msgstr "" -#: cp/class.c:5954 +#: cp/class.c:5957 #, gcc-internal-format msgid "offset of %q+D is not ABI-compliant and may change in a future version of GCC" msgstr "" -#: cp/class.c:5964 +#: cp/class.c:5967 #, gcc-internal-format msgid "%q+D contains empty classes which may cause base classes to be placed at different locations in a future version of GCC" msgstr "" -#: cp/class.c:6052 +#: cp/class.c:6055 #, gcc-internal-format msgid "layout of classes derived from empty class %qT may change in a future version of GCC" msgstr "tyhjästä luokasta %qT perittyjen luokkien rakenne saattaa muuttua GCC:n tulevissa versioissa" -#: cp/class.c:6220 cp/decl.c:12134 cp/parser.c:18856 +#: cp/class.c:6223 cp/decl.c:12125 cp/parser.c:18860 #, gcc-internal-format msgid "redefinition of %q#T" msgstr "%q#T uudelleenmääritelty" -#: cp/class.c:6369 +#: cp/class.c:6372 #, gcc-internal-format msgid "%q#T has virtual functions and accessible non-virtual destructor" msgstr "luokalla %q#T on virtuaalifunktioita ja käytettävissä oleva epävirtuaalinen hajotin" -#: cp/class.c:6395 +#: cp/class.c:6398 #, fuzzy, gcc-internal-format -#| msgid "class %qT does not have any field named %qD" msgid "type transparent %q#T does not have any fields" msgstr "luokalla %qT ei ole %qD-nimistä kenttää" -#: cp/class.c:6401 +#: cp/class.c:6404 #, gcc-internal-format msgid "type transparent class %qT has base classes" msgstr "" -#: cp/class.c:6405 +#: cp/class.c:6408 #, fuzzy, gcc-internal-format msgid "type transparent class %qT has virtual functions" msgstr "%<this%> ei ole käytettävissä staattisissa jäsenfunktioissa" -#: cp/class.c:6411 +#: cp/class.c:6414 #, gcc-internal-format msgid "type transparent %q#T cannot be made transparent because the type of the first field has a different ABI from the class overall" msgstr "" -#: cp/class.c:6562 +#: cp/class.c:6565 #, gcc-internal-format msgid "trying to finish struct, but kicked out due to previous parse errors" msgstr "" -#: cp/class.c:7071 +#: cp/class.c:7074 #, gcc-internal-format msgid "language string %<\"%E\"%> not recognized" msgstr "" -#: cp/class.c:7160 +#: cp/class.c:7163 #, gcc-internal-format msgid "cannot resolve overloaded function %qD based on conversion to type %qT" msgstr "" -#: cp/class.c:7280 +#: cp/class.c:7283 #, gcc-internal-format msgid "no matches converting function %qD to type %q#T" msgstr "" -#: cp/class.c:7308 +#: cp/class.c:7311 #, gcc-internal-format msgid "converting overloaded function %qD to type %q#T is ambiguous" msgstr "" -#: cp/class.c:7335 +#: cp/class.c:7338 #, gcc-internal-format msgid "assuming pointer to member %qD" msgstr "" -#: cp/class.c:7338 +#: cp/class.c:7341 #, gcc-internal-format msgid "(a pointer to member can only be formed with %<&%E%>)" msgstr "" -#: cp/class.c:7413 cp/class.c:7447 +#: cp/class.c:7416 cp/class.c:7450 #, gcc-internal-format msgid "not enough type information" msgstr "" -#: cp/class.c:7430 cp/cvt.c:173 cp/cvt.c:199 cp/cvt.c:248 +#: cp/class.c:7433 cp/cvt.c:173 cp/cvt.c:199 cp/cvt.c:248 #, gcc-internal-format msgid "cannot convert %qE from type %qT to type %qT" -msgstr "" +msgstr "%qE:ta ei voi muuntaa tyypistä %qT tyyppiin %qT" #. [basic.scope.class] #. #. A name N used in a class S shall refer to the same declaration #. in its context and when re-evaluated in the completed scope of #. S. -#: cp/class.c:7742 cp/decl.c:1325 +#: cp/class.c:7745 cp/decl.c:1325 #, gcc-internal-format msgid "declaration of %q#D" msgstr "" -#: cp/class.c:7743 +#: cp/class.c:7746 #, gcc-internal-format msgid "changes meaning of %qD from %q+#D" msgstr "" @@ -28643,14 +28346,13 @@ msgstr "" #: cp/cvt.c:91 #, fuzzy, gcc-internal-format -#| msgid "cannot convert type %qT to type %qT" msgid "can%'t convert from incomplete type %qT to %qT" msgstr "ei voi muuntaa tyyppiä %qT tyypiksi %qT" #: cp/cvt.c:101 #, gcc-internal-format msgid "conversion of %qE from %qT to %qT is ambiguous" -msgstr "" +msgstr "%qE:n muunnos tyypistä %qT tyyppiin %qT ei ole yksiselitteinen" #: cp/cvt.c:383 #, fuzzy, gcc-internal-format @@ -28750,7 +28452,6 @@ msgstr "" #: cp/cvt.c:1036 #, fuzzy, gcc-internal-format -#| msgid "invalid application of %qs to incomplete type %qT " msgid "indirection will not access object of incomplete type %qT in statement" msgstr "epäkelpo %qs:n soveltaminen vaillinaiseen tyyppiin %qT " @@ -28931,37 +28632,31 @@ msgstr "ei-liukulukuargumentti funktiolle %qs" #: cp/cvt.c:1335 #, fuzzy, gcc-internal-format -#| msgid "left-hand operand of comma expression has no effect" msgid "second operand of conditional expression has no effect" msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta" #: cp/cvt.c:1340 #, fuzzy, gcc-internal-format -#| msgid "left-hand operand of comma expression has no effect" msgid "third operand of conditional expression has no effect" msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta" #: cp/cvt.c:1345 #, fuzzy, gcc-internal-format -#| msgid "left-hand operand of comma expression has no effect" msgid "right operand of comma operator has no effect" msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta" #: cp/cvt.c:1349 #, fuzzy, gcc-internal-format -#| msgid "left-hand operand of comma expression has no effect" msgid "left operand of comma operator has no effect" msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta" #: cp/cvt.c:1353 #, fuzzy, gcc-internal-format -#| msgid "statement with no effect" msgid "statement has no effect" msgstr "lauseella ei ole vaikutusta" #: cp/cvt.c:1357 #, fuzzy, gcc-internal-format -#| msgid "left-hand operand of comma expression has no effect" msgid "for increment expression has no effect" msgstr "pilkkulausekkeen vasemmalla operandilla ei ole vaikutusta" @@ -28973,7 +28668,7 @@ msgstr "NULLin muunnos epäosoitintyypiksi" #: cp/cvt.c:1587 cp/cvt.c:1636 #, gcc-internal-format msgid "ambiguous default type conversion from %qT" -msgstr "" +msgstr "ei-yksiselitteinen oletustyyppimuunnos tyypistä %qT" #: cp/cvt.c:1589 #, gcc-internal-format @@ -28987,7 +28682,6 @@ msgstr "" #: cp/decl.c:640 #, fuzzy, gcc-internal-format -#| msgid "label %q+D defined but not used" msgid "variable %q+D set but not used" msgstr "nimike %q+D määritelty mutta käytettämättä" @@ -28998,9 +28692,9 @@ msgstr "" #: cp/decl.c:1147 cp/decl.c:1756 objc/objc-act.c:3375 objc/objc-act.c:3964 #: objc/objc-act.c:3992 objc/objc-act.c:4048 objc/objc-act.c:6831 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "previous declaration of %q+D" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "%q+D:n edellinen esittely" #: cp/decl.c:1179 #, fuzzy, gcc-internal-format @@ -29008,13 +28702,12 @@ msgid "declaration of %qF has a different exception specifier" msgstr "%qs esitelty funktiotaulukkona" #: cp/decl.c:1181 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "from previous declaration %q+F" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "edellisestä esittelystä %q+F" #: cp/decl.c:1206 #, fuzzy, gcc-internal-format -#| msgid "declaration of %qD as non-member" msgid "redeclaration %qD differs in %<constexpr%>" msgstr "%qD:n esittely ei-jäsenenä" @@ -29049,19 +28742,17 @@ msgid "function %q+D redeclared with attribute noinline" msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline" #: cp/decl.c:1289 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "previous declaration of %q+D was inline" -msgstr "%J%qD:n edellinen esittely oli täällä" +msgstr "%q+D:n edellinen esittely oli inline" #: cp/decl.c:1313 cp/decl.c:1387 #, fuzzy, gcc-internal-format -#| msgid "cannot disable built-in function %qs" msgid "shadowing built-in function %q#D" msgstr "sisäistä funktiota %qs ei voi ottaa pois käytöstä" #: cp/decl.c:1314 cp/decl.c:1388 #, fuzzy, gcc-internal-format -#| msgid "In member function %qs" msgid "shadowing library function %q#D" msgstr "Jäsenfunktio %qs" @@ -29098,22 +28789,22 @@ msgstr "%J%qD:lle ei ole aiempaa esittelyä" #: cp/decl.c:1495 #, gcc-internal-format msgid "declaration of template %q#D" -msgstr "" +msgstr "mallin %q#D esittely" #: cp/decl.c:1496 cp/name-lookup.c:844 cp/name-lookup.c:859 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "conflicts with previous declaration %q+#D" -msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa" +msgstr "on ristiriidassa %q+#D:n edellisen esittelyn kanssa" #: cp/decl.c:1511 cp/decl.c:1536 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "ambiguates old declaration %q+#D" -msgstr "%qs-nimikkeen kaksoisesittely" +msgstr "ei-yksiselitteistää vanhan esittelyn %q+#D" #: cp/decl.c:1519 #, gcc-internal-format msgid "declaration of C function %q#D conflicts with" -msgstr "" +msgstr "C-funktion %q#D esittely on ristiriidassa" #: cp/decl.c:1521 #, fuzzy, gcc-internal-format @@ -29128,7 +28819,7 @@ msgstr "%qs-nimikkeen kaksoisesittely" #: cp/decl.c:1544 #, gcc-internal-format msgid "conflicting declaration %q#D" -msgstr "" +msgstr "ristiriitainen esittely %q#D" #: cp/decl.c:1545 #, fuzzy, gcc-internal-format @@ -29159,15 +28850,15 @@ msgid "%q+#D previously defined here" msgstr "%q+#D määritelty aiemmin täällä" #: cp/decl.c:1610 cp/name-lookup.c:1136 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%q+#D previously declared here" -msgstr "%Jviimeksi käytetty täällä" +msgstr "%q+#D aiemmin esitelty täällä" #. Prototype decl follows defn w/o prototype. #: cp/decl.c:1619 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "prototype for %q+#D" -msgstr "%J%qD:lle ei ole aiempaa prototyyppiä" +msgstr "prototyyppi %q+#D:lle" #: cp/decl.c:1621 #, fuzzy, gcc-internal-format @@ -29182,12 +28873,12 @@ msgstr "%J%qD esitelty uudelleen ilman linkitystä" #: cp/decl.c:1663 #, gcc-internal-format msgid "conflicts with new declaration with %qL linkage" -msgstr "" +msgstr "on ristiriidassa uuden esittelyn kanssa %qL-linkityksellä" #: cp/decl.c:1686 cp/decl.c:1692 #, gcc-internal-format msgid "default argument given for parameter %d of %q#D" -msgstr "" +msgstr "oletusargumentti annettu %2$q#D:n parametrille %1$d" #: cp/decl.c:1688 cp/decl.c:1694 #, fuzzy, gcc-internal-format @@ -29200,14 +28891,14 @@ msgid "redundant redeclaration of %qD in same scope" msgstr "" #: cp/decl.c:1761 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "deleted definition of %qD" -msgstr "%J%qD määritelty uudelleen" +msgstr "%qD:n poistettu määrittely" #: cp/decl.c:1762 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "after previous declaration %q+D" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "%q+D:n edellisen esittelyn jälkeen" #. From [temp.expl.spec]: #. @@ -29223,19 +28914,18 @@ msgid "explicit specialization of %qD after first use" msgstr "" #: cp/decl.c:2248 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%q+D: visibility attribute ignored because it" -msgstr "%qs attribuuttia ei huomioida" +msgstr "%q+D: näkyvyysattribuuttia ei oteta huomioon koska se" #: cp/decl.c:2250 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "conflicts with previous declaration here" -msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa" +msgstr "on ristiriidassa edelliseen tässä olevan esittelyn kanssa" #. Reject two definitions. #: cp/decl.c:2429 cp/decl.c:2458 cp/decl.c:2491 cp/decl.c:2508 cp/decl.c:2581 #, fuzzy, gcc-internal-format -#| msgid "redefinition of %q#T" msgid "redefinition of %q#D" msgstr "%q#T uudelleenmääritelty" @@ -29315,13 +29005,13 @@ msgstr "" #: cp/decl.c:2803 cp/decl.c:2910 #, gcc-internal-format msgid " enters try block" -msgstr "" +msgstr " siirtyy try-lohkoon" #. Can't skip init of __exception_info. #: cp/decl.c:2805 cp/decl.c:2899 cp/decl.c:2912 #, gcc-internal-format msgid " enters catch block" -msgstr "" +msgstr " siirtyy catch-lohkoon" #: cp/decl.c:2815 cp/decl.c:2915 #, gcc-internal-format @@ -29334,9 +29024,9 @@ msgid "jump to label %q+D" msgstr "hyppy nimiöön %q+D" #: cp/decl.c:2903 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid " skips initialization of %q+#D" -msgstr "(%qs:n alustuksen lähistöllä)" +msgstr " ohittaa %q+#D:n alustuksen" #: cp/decl.c:2980 #, gcc-internal-format @@ -29376,12 +29066,12 @@ msgstr "muunnos tyypistä %qT tyyppiin %qT on moniselitteinen" #: cp/decl.c:3351 #, gcc-internal-format msgid "%<typename %T::%D%> names %q#T, which is not a class template" -msgstr "" +msgstr "%<typename %T::%D%> nimeää kohteen %q#T:n, joka ei ole luokkamalli" #: cp/decl.c:3358 #, gcc-internal-format msgid "%<typename %T::%D%> names %q#T, which is not a type" -msgstr "" +msgstr "%<typename %T::%D%> nimeää %q#T:n, joka ei ole tyyppi" #: cp/decl.c:3430 #, gcc-internal-format @@ -29420,13 +29110,11 @@ msgstr "" #: cp/decl.c:4190 #, fuzzy, gcc-internal-format -#| msgid "attribute ignored in declaration of %q+#T" msgid "attribute ignored in declaration of %q#T" msgstr "attribuutti jätetty huomioimatta %q+#T:n esittelyssä" #: cp/decl.c:4193 #, fuzzy, gcc-internal-format -#| msgid "attribute for %q+#T must follow the %qs keyword" msgid "attribute for %q#T must follow the %qs keyword" msgstr "%q+#T:n attribuutin on oltava %qs-avainsanan perässä" @@ -29442,7 +29130,6 @@ msgstr "C++:n sisäinen tietotyyppi %qT määritelty uudelleen" #: cp/decl.c:4238 #, fuzzy, gcc-internal-format -#| msgid "a storage class can only be specified for objects and functions" msgid "%<auto%> can only be specified for variables or function declarations" msgstr "tallennusluokan voi antaa vain objekteille ja funktioille" @@ -29474,12 +29161,12 @@ msgstr "" #: cp/decl.c:4288 #, gcc-internal-format msgid "a storage class can only be specified for objects and functions" -msgstr "tallennusluokan voi antaa vain objekteille ja funktioille" +msgstr "tallennusluokan voi antaa vain olioille ja funktioille" #: cp/decl.c:4294 #, gcc-internal-format msgid "qualifiers can only be specified for objects and functions" -msgstr "" +msgstr "määreet voidaan määrittää vain olioille ja funktioille" #: cp/decl.c:4297 #, fuzzy, gcc-internal-format @@ -29555,17 +29242,17 @@ msgstr "" #: cp/decl.c:4682 #, gcc-internal-format msgid "variable %q#D has initializer but incomplete type" -msgstr "" +msgstr "muuttujalla %q#D on alustin, mutta vaillinaista tyyppiä" #: cp/decl.c:4688 cp/decl.c:5499 #, gcc-internal-format msgid "elements of array %q#D have incomplete type" -msgstr "" +msgstr "taulukon %q#D alkiot ovat vaillinaista tyyppiä" #: cp/decl.c:4695 cp/decl.c:6123 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "declaration of %q#D has no initializer" -msgstr "%J%qD:n esittely varjostaa parametria" +msgstr "%q#D:n esittelyllä ei ole alustimia" #: cp/decl.c:4697 #, gcc-internal-format @@ -29600,25 +29287,25 @@ msgstr "" #: cp/decl.c:4839 #, gcc-internal-format msgid "array size missing in %qD" -msgstr "" +msgstr "%qD-taulukon koko puuttuu" #: cp/decl.c:4850 #, gcc-internal-format msgid "zero-size array %qD" -msgstr "" +msgstr "nollan kokoinen taulukko %qD" #. An automatic variable with an incomplete type: that is an error. #. Don't talk about array types here, since we took care of that #. message in grokdeclarator. #: cp/decl.c:4892 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "storage size of %qD isn%'t known" -msgstr "%Jmuuttujan %qD koko muistissa ei ole tunnettu" +msgstr "%qD:n koko muistissa ei ole tunnettu" #: cp/decl.c:4915 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "storage size of %qD isn%'t constant" -msgstr "%Jmuuttujan %qD koko muistissa ei ole vakio" +msgstr "%qD:n koko muistissa ei ole vakio" #: cp/decl.c:4961 #, gcc-internal-format @@ -29628,7 +29315,7 @@ msgstr "" #: cp/decl.c:4965 #, gcc-internal-format msgid " you can work around this by removing the initializer" -msgstr "" +msgstr " voit kiertää tämän poistamalla alustimen" #: cp/decl.c:4996 #, gcc-internal-format @@ -29672,7 +29359,6 @@ msgstr "" #: cp/decl.c:5226 #, fuzzy, gcc-internal-format -#| msgid "invalid initializer" msgid "invalid initializer for %q#D" msgstr "epäkelpo alustin" @@ -29685,7 +29371,7 @@ msgstr "" #: cp/typeck2.c:1299 cp/typeck2.c:1346 #, gcc-internal-format msgid "too many initializers for %qT" -msgstr "" +msgstr "liikaa alustimia %qT:lle" #: cp/decl.c:5326 #, fuzzy, gcc-internal-format @@ -29705,7 +29391,7 @@ msgstr "taulukon %qD alkioilla on vaillinainen tyyppi" #: cp/decl.c:5510 #, gcc-internal-format msgid "variable-sized object %qD may not be initialized" -msgstr "" +msgstr "muuttuvakokoista objektia %qD ei voi alustaa" #: cp/decl.c:5512 #, gcc-internal-format @@ -29713,25 +29399,24 @@ msgid "variable-sized compound literal" msgstr "muuttuvakokoinen yhdysliteraali" #: cp/decl.c:5567 -#, fuzzy, gcc-internal-format -#| msgid "%qD has an incomplete type" +#, gcc-internal-format msgid "%q#D has incomplete type" -msgstr "%qD on vaillinaista tyyppiä" +msgstr "%q#D on vaillinaista tyyppiä" #: cp/decl.c:5587 #, gcc-internal-format msgid "scalar object %qD requires one element in initializer" -msgstr "" +msgstr "skalaariobjekti %qD vaatii yhden alkion alustimeensa" #: cp/decl.c:5630 #, gcc-internal-format msgid "in C++98 %qD must be initialized by constructor, not by %<{...}%>" -msgstr "" +msgstr "C++98:ssa %qD on alustettava muodostimessa, ei käyttäen %<{...}%>" #: cp/decl.c:5717 #, gcc-internal-format msgid "array %qD initialized by parenthesized string literal %qE" -msgstr "" +msgstr "taulukko %qD alustettu sulkujen sisällä olevalla merkkijonoliteraalilla %qE" #: cp/decl.c:5744 #, gcc-internal-format @@ -29771,247 +29456,240 @@ msgstr "taulukko alustetaan muuttuvasta taulukkolausekkeesta" #: cp/decl.c:6391 #, gcc-internal-format msgid "non-static data member %qD has Java class type" -msgstr "" +msgstr "ei-staattisella datajäsenellä %qD on Java-luokkatyyppi" #: cp/decl.c:6460 #, gcc-internal-format msgid "function %q#D is initialized like a variable" -msgstr "" +msgstr "funktio %q#D alustetaan kuin muuttuja" -#: cp/decl.c:6883 +#: cp/decl.c:6886 #, gcc-internal-format msgid "non-local variable %qD declared %<__thread%> needs dynamic initialization" msgstr "" -#: cp/decl.c:6886 +#: cp/decl.c:6889 #, gcc-internal-format msgid "non-local variable %qD declared %<__thread%> has a non-trivial destructor" msgstr "" -#: cp/decl.c:6892 +#: cp/decl.c:6895 #, gcc-internal-format msgid "C++11 %<thread_local%> allows dynamic initialization and destruction" msgstr "" -#: cp/decl.c:7119 +#: cp/decl.c:7122 #, fuzzy, gcc-internal-format -#| msgid "initializer fails to determine size of %q+D" msgid "initializer fails to determine size of %qT" msgstr "alustin ei pysty päättelemään taulukon %q+D kokoa" -#: cp/decl.c:7123 +#: cp/decl.c:7126 #, fuzzy, gcc-internal-format -#| msgid "array size missing in %q+D" msgid "array size missing in %qT" msgstr "taulukon %q+D koko puuttuu" -#: cp/decl.c:7126 +#: cp/decl.c:7129 #, fuzzy, gcc-internal-format -#| msgid "ISO C forbids zero-size array %qE" msgid "zero-size array %qT" -msgstr "ISO C kieltää nollan kokoisen taulukon %qE" +msgstr "nollan kokoinen taulukko %qD" -#: cp/decl.c:7142 +#: cp/decl.c:7145 #, gcc-internal-format msgid "destructor for alien class %qT cannot be a member" msgstr "" -#: cp/decl.c:7144 +#: cp/decl.c:7147 #, gcc-internal-format msgid "constructor for alien class %qT cannot be a member" msgstr "" -#: cp/decl.c:7168 +#: cp/decl.c:7171 #, fuzzy, gcc-internal-format msgid "%qD declared as a %<virtual%> variable" msgstr "kenttä %qs esitelty funktiona" -#: cp/decl.c:7170 +#: cp/decl.c:7173 #, fuzzy, gcc-internal-format msgid "%qD declared as an %<inline%> variable" msgstr "%q+D esitelty ei-parametrina" -#: cp/decl.c:7172 +#: cp/decl.c:7175 #, gcc-internal-format msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in variable declaration" msgstr "" -#: cp/decl.c:7177 +#: cp/decl.c:7180 #, fuzzy, gcc-internal-format msgid "%qD declared as a %<virtual%> parameter" msgstr "%q+D esitelty ei-parametrina" -#: cp/decl.c:7179 +#: cp/decl.c:7182 #, fuzzy, gcc-internal-format msgid "%qD declared as an %<inline%> parameter" msgstr "%q+D esitelty ei-parametrina" -#: cp/decl.c:7181 +#: cp/decl.c:7184 #, gcc-internal-format msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in parameter declaration" msgstr "" -#: cp/decl.c:7186 +#: cp/decl.c:7189 #, fuzzy, gcc-internal-format msgid "%qD declared as a %<virtual%> type" msgstr "kenttä %qs esitelty funktiona" -#: cp/decl.c:7188 +#: cp/decl.c:7191 #, fuzzy, gcc-internal-format msgid "%qD declared as an %<inline%> type" msgstr "%q+D esitelty ei-parametrina" -#: cp/decl.c:7190 +#: cp/decl.c:7193 #, gcc-internal-format msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in type declaration" msgstr "" -#: cp/decl.c:7195 +#: cp/decl.c:7198 #, fuzzy, gcc-internal-format msgid "%qD declared as a %<virtual%> field" msgstr "kenttä %qs esitelty funktiona" -#: cp/decl.c:7197 +#: cp/decl.c:7200 #, fuzzy, gcc-internal-format msgid "%qD declared as an %<inline%> field" msgstr "kenttä %qs esitelty funktiona" -#: cp/decl.c:7199 +#: cp/decl.c:7202 #, gcc-internal-format msgid "%<const%> and %<volatile%> function specifiers on %qD invalid in field declaration" msgstr "" -#: cp/decl.c:7206 -#, fuzzy, gcc-internal-format +#: cp/decl.c:7209 +#, gcc-internal-format msgid "%q+D declared as a friend" -msgstr "kenttä %qs esitelty funktiona" +msgstr "%q+D esitelty ystävänä" -#: cp/decl.c:7212 +#: cp/decl.c:7215 #, fuzzy, gcc-internal-format msgid "%q+D declared with an exception specification" msgstr "%qs esitelty funktion palauttavana funktiona" -#: cp/decl.c:7246 +#: cp/decl.c:7249 #, gcc-internal-format msgid "definition of %qD is not in namespace enclosing %qT" msgstr "" -#: cp/decl.c:7286 +#: cp/decl.c:7289 #, gcc-internal-format msgid "static member function %q#D declared with type qualifiers" -msgstr "" +msgstr "staattinen jäsenfunktio %q#D esitelty tyyppimääreillä" -#: cp/decl.c:7385 +#: cp/decl.c:7388 #, gcc-internal-format msgid "defining explicit specialization %qD in friend declaration" msgstr "" #. Something like `template <class T> friend void f<T>()'. -#: cp/decl.c:7395 +#: cp/decl.c:7398 #, gcc-internal-format msgid "invalid use of template-id %qD in declaration of primary template" msgstr "" -#: cp/decl.c:7425 +#: cp/decl.c:7428 #, gcc-internal-format msgid "default arguments are not allowed in declaration of friend template specialization %qD" msgstr "" -#: cp/decl.c:7433 +#: cp/decl.c:7436 #, gcc-internal-format msgid "%<inline%> is not allowed in declaration of friend template specialization %qD" msgstr "" -#: cp/decl.c:7475 +#: cp/decl.c:7478 #, gcc-internal-format msgid "cannot declare %<::main%> to be a template" msgstr "" -#: cp/decl.c:7477 +#: cp/decl.c:7480 #, gcc-internal-format msgid "cannot declare %<::main%> to be inline" msgstr "" -#: cp/decl.c:7479 +#: cp/decl.c:7482 #, gcc-internal-format msgid "cannot declare %<::main%> to be static" msgstr "" -#: cp/decl.c:7507 +#: cp/decl.c:7510 #, gcc-internal-format msgid "anonymous type with no linkage used to declare function %q#D with linkage" msgstr "" -#: cp/decl.c:7511 cp/decl.c:7879 cp/decl2.c:3864 +#: cp/decl.c:7514 cp/decl.c:7882 cp/decl2.c:3864 #, gcc-internal-format msgid "%q+#D does not refer to the unqualified type, so it is not used for linkage" msgstr "" -#: cp/decl.c:7517 +#: cp/decl.c:7520 #, fuzzy, gcc-internal-format msgid "type %qT with no linkage used to declare function %q#D with linkage" msgstr "%J%qD esitelty uudelleen ilman linkitystä" -#: cp/decl.c:7539 +#: cp/decl.c:7542 #, gcc-internal-format msgid "static member function %qD cannot have cv-qualifier" msgstr "" -#: cp/decl.c:7540 +#: cp/decl.c:7543 #, gcc-internal-format msgid "non-member function %qD cannot have cv-qualifier" msgstr "" -#: cp/decl.c:7556 +#: cp/decl.c:7559 #, fuzzy, gcc-internal-format msgid "literal operator with C linkage" msgstr "%J%qD esitelty uudelleen ilman linkitystä" -#: cp/decl.c:7565 +#: cp/decl.c:7568 #, fuzzy, gcc-internal-format -#| msgid "invalid IACC argument" msgid "%qD has invalid argument list" msgstr "virheellinen IACC-argumentti" -#: cp/decl.c:7573 +#: cp/decl.c:7576 #, gcc-internal-format msgid "integer suffix %<%s%> shadowed by implementation" msgstr "" -#: cp/decl.c:7579 +#: cp/decl.c:7582 #, gcc-internal-format msgid "floating point suffix %<%s%> shadowed by implementation" msgstr "" -#: cp/decl.c:7585 +#: cp/decl.c:7588 #, fuzzy, gcc-internal-format -#| msgid "invalid use of non-static member function" msgid "%qD must be a non-member function" msgstr "virheellinen ei-staattisen jäsenfunktion käyttö" -#: cp/decl.c:7636 +#: cp/decl.c:7639 #, gcc-internal-format msgid "%<::main%> must return %<int%>" msgstr "" -#: cp/decl.c:7678 +#: cp/decl.c:7681 #, gcc-internal-format msgid "definition of implicitly-declared %qD" msgstr "" -#: cp/decl.c:7683 +#: cp/decl.c:7686 #, fuzzy, gcc-internal-format -#| msgid "redefinition of typedef %q+D" msgid "definition of explicitly-defaulted %q+D" msgstr "typedef %q+D määritelty uudelleen" -#: cp/decl.c:7684 +#: cp/decl.c:7687 #, fuzzy, gcc-internal-format -#| msgid "%q+#D previously defined here" msgid "%q+#D explicitly defaulted here" msgstr "%q+#D määritelty aiemmin täällä" -#: cp/decl.c:7701 cp/decl2.c:738 +#: cp/decl.c:7704 cp/decl2.c:738 #, gcc-internal-format msgid "no %q#D member function declared in class %qT" msgstr "" @@ -30020,894 +29698,880 @@ msgstr "" #. no linkage can only be used to declare extern "C" #. entities. Since it's not always an error in the #. ISO C++ 90 Standard, we only issue a warning. -#: cp/decl.c:7876 +#: cp/decl.c:7879 #, gcc-internal-format msgid "anonymous type with no linkage used to declare variable %q#D with linkage" msgstr "" -#: cp/decl.c:7885 +#: cp/decl.c:7888 #, gcc-internal-format msgid "type %qT with no linkage used to declare variable %q#D with linkage" msgstr "" # semi-fuzzy -#: cp/decl.c:8008 +#: cp/decl.c:8011 #, fuzzy, gcc-internal-format msgid "in-class initialization of static data member %q#D of incomplete type" msgstr "ei-staattista datajäsentä %q+D käytetty virheellisesti" -#: cp/decl.c:8012 +#: cp/decl.c:8015 #, fuzzy, gcc-internal-format -#| msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT" msgid "%<constexpr%> needed for in-class initialization of static data member %q#D of non-integral type" msgstr "ISO C++ kieltää epäkokonaislukutyyppiä %2$qT olevan vakiojäsenen %1$qD alustamisen" -#: cp/decl.c:8015 +#: cp/decl.c:8018 #, fuzzy, gcc-internal-format -#| msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT" msgid "in-class initialization of static data member %q#D of non-literal type" msgstr "ISO C++ kieltää epäkokonaislukutyyppiä %2$qT olevan vakiojäsenen %1$qD alustamisen" -#: cp/decl.c:8028 +#: cp/decl.c:8031 #, gcc-internal-format msgid "invalid in-class initialization of static data member of non-integral type %qT" msgstr "" -#: cp/decl.c:8034 +#: cp/decl.c:8037 #, gcc-internal-format msgid "ISO C++ forbids in-class initialization of non-const static member %qD" msgstr "" -#: cp/decl.c:8038 +#: cp/decl.c:8041 #, gcc-internal-format msgid "ISO C++ forbids initialization of member constant %qD of non-integral type %qT" msgstr "ISO C++ kieltää epäkokonaislukutyyppiä %2$qT olevan vakiojäsenen %1$qD alustamisen" -#: cp/decl.c:8144 cp/decl.c:8172 +#: cp/decl.c:8147 cp/decl.c:8175 #, gcc-internal-format msgid "size of array %qD has non-integral type %qT" msgstr "taulukon %qD koolla on epäkokonaislukutyyppi %qT" -#: cp/decl.c:8147 cp/decl.c:8174 +#: cp/decl.c:8150 cp/decl.c:8177 #, gcc-internal-format msgid "size of array has non-integral type %qT" msgstr "taulukon koolla on epäkokonaislukutyyppi %qT" -#: cp/decl.c:8224 +#: cp/decl.c:8227 #, gcc-internal-format msgid "size of array %qD is negative" msgstr "taulukon %qD koko on negatiivinen" -#: cp/decl.c:8226 +#: cp/decl.c:8229 #, gcc-internal-format msgid "size of array is negative" msgstr "taulukon koko on negatiivinen" -#: cp/decl.c:8240 +#: cp/decl.c:8243 #, gcc-internal-format msgid "ISO C++ forbids zero-size array %qD" msgstr "ISO C++ kieltää nollan kokoisen taulukon %qD" -#: cp/decl.c:8242 +#: cp/decl.c:8245 #, gcc-internal-format msgid "ISO C++ forbids zero-size array" msgstr "ISO C++ kieltää nollan kokoisen taulukon" -#: cp/decl.c:8254 +#: cp/decl.c:8257 #, gcc-internal-format msgid "size of array %qD is not an integral constant-expression" msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke" -#: cp/decl.c:8257 +#: cp/decl.c:8260 #, gcc-internal-format msgid "size of array is not an integral constant-expression" msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke" -#: cp/decl.c:8263 +#: cp/decl.c:8266 #, gcc-internal-format msgid "ISO C++ forbids variable length array %qD" msgstr "ISO C++ kieltää muuttuvakokoisen taulukon %qD" -#: cp/decl.c:8265 +#: cp/decl.c:8268 #, gcc-internal-format msgid "ISO C++ forbids variable length array" msgstr "ISO C++ kieltää muuttuvakokoisen taulukon" -#: cp/decl.c:8271 +#: cp/decl.c:8274 #, gcc-internal-format msgid "variable length array %qD is used" msgstr "" -#: cp/decl.c:8323 +#: cp/decl.c:8326 #, gcc-internal-format msgid "overflow in array dimension" msgstr "taulukon koon ylivuoto" -#: cp/decl.c:8383 +#: cp/decl.c:8386 #, fuzzy, gcc-internal-format msgid "declaration of %qD as array of %<auto%>" msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" -#: cp/decl.c:8391 -#, fuzzy, gcc-internal-format +#: cp/decl.c:8394 +#, gcc-internal-format msgid "declaration of %qD as array of void" -msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" +msgstr "%qD:n esittely void-taulukkona" -#: cp/decl.c:8393 -#, fuzzy, gcc-internal-format +#: cp/decl.c:8396 +#, gcc-internal-format msgid "creating array of void" -msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" +msgstr "luodaan void-taulukko" -#: cp/decl.c:8398 -#, fuzzy, gcc-internal-format +#: cp/decl.c:8401 +#, gcc-internal-format msgid "declaration of %qD as array of functions" -msgstr "%qs esitelty funktiotaulukkona" +msgstr "%qD:n esittely funktioiden taulukkona" -#: cp/decl.c:8400 -#, fuzzy, gcc-internal-format +#: cp/decl.c:8403 +#, gcc-internal-format msgid "creating array of functions" -msgstr "%qs esitelty funktiotaulukkona" +msgstr "luodaan funktioiden taulukko" -#: cp/decl.c:8405 -#, fuzzy, gcc-internal-format +#: cp/decl.c:8408 +#, gcc-internal-format msgid "declaration of %qD as array of references" -msgstr "%qs esitelty funktiotaulukkona" +msgstr "%qD:n esittely viitteiden taulukkona" -#: cp/decl.c:8407 -#, fuzzy, gcc-internal-format +#: cp/decl.c:8410 +#, gcc-internal-format msgid "creating array of references" -msgstr "ehtolausekkeessa on tyyppiristiriita" +msgstr "luodaan viitteiden taulukko" -#: cp/decl.c:8412 -#, fuzzy, gcc-internal-format +#: cp/decl.c:8415 +#, gcc-internal-format msgid "declaration of %qD as array of function members" -msgstr "%qs esitelty funktiotaulukkona" +msgstr "%qD:n esittely funktiojäsenten taulukkona" -#: cp/decl.c:8414 -#, fuzzy, gcc-internal-format +#: cp/decl.c:8417 +#, gcc-internal-format msgid "creating array of function members" -msgstr "%qs esitelty funktiotaulukkona" +msgstr "luodaan funktiojäsenten taulukkoa" -#: cp/decl.c:8428 +#: cp/decl.c:8431 #, gcc-internal-format msgid "declaration of %qD as multidimensional array must have bounds for all dimensions except the first" msgstr "" -#: cp/decl.c:8432 -#, fuzzy, gcc-internal-format +#: cp/decl.c:8435 +#, gcc-internal-format msgid "multidimensional array must have bounds for all dimensions except the first" -msgstr "moniulotteisen taulukon" +msgstr "moniulotteisell taulukolla on oltava rajat kaikkiin suuntiin paitsi ensimmäiseen" -#: cp/decl.c:8467 +#: cp/decl.c:8470 #, gcc-internal-format msgid "return type specification for constructor invalid" msgstr "" -#: cp/decl.c:8477 +#: cp/decl.c:8480 #, gcc-internal-format msgid "return type specification for destructor invalid" msgstr "" -#: cp/decl.c:8490 +#: cp/decl.c:8493 #, gcc-internal-format msgid "return type specified for %<operator %T%>" msgstr "" -#: cp/decl.c:8512 +#: cp/decl.c:8515 #, gcc-internal-format msgid "unnamed variable or field declared void" msgstr "nimetön muuttuja tai kenttä esitelty voidiksi" -#: cp/decl.c:8519 +#: cp/decl.c:8522 #, gcc-internal-format msgid "variable or field declared void" msgstr "muuttuja tai kenttä esitelty voidiksi" -#: cp/decl.c:8720 +#: cp/decl.c:8722 #, fuzzy, gcc-internal-format msgid "invalid use of qualified-name %<::%D%>" msgstr "määrittelemättömän tyypin %<%s %s%> epäkelpo käyttö" -#: cp/decl.c:8723 +#: cp/decl.c:8725 #, fuzzy, gcc-internal-format msgid "invalid use of qualified-name %<%T::%D%>" msgstr "määrittelemättömän tyypin %<%s %s%> epäkelpo käyttö" -#: cp/decl.c:8726 +#: cp/decl.c:8728 #, fuzzy, gcc-internal-format msgid "invalid use of qualified-name %<%D::%D%>" msgstr "määrittelemättömän tyypin %<%s %s%> epäkelpo käyttö" -#: cp/decl.c:8735 -#, fuzzy, gcc-internal-format +#: cp/decl.c:8737 +#, gcc-internal-format msgid "%q#T is not a class or a namespace" -msgstr "%qT ei ole luokka tai nimiavaruus" +msgstr "%q#T ei ole luokka eikä nimiavaruus" -#: cp/decl.c:8743 +#: cp/decl.c:8745 #, gcc-internal-format msgid "type %qT is not derived from type %qT" msgstr "tyyppi %qT ei periydy %qT-tyypistä" -#: cp/decl.c:8759 cp/decl.c:8851 cp/decl.c:8860 cp/decl.c:10242 +#: cp/decl.c:8761 cp/decl.c:8853 cp/decl.c:8862 cp/decl.c:10238 #, gcc-internal-format msgid "declaration of %qD as non-function" msgstr "%qD:n esittely ei-funktiona" -#: cp/decl.c:8765 +#: cp/decl.c:8767 #, gcc-internal-format msgid "declaration of %qD as non-member" msgstr "%qD:n esittely ei-jäsenenä" -#: cp/decl.c:8796 +#: cp/decl.c:8798 #, gcc-internal-format msgid "declarator-id missing; using reserved word %qD" msgstr "" -#: cp/decl.c:8843 -#, fuzzy, gcc-internal-format +#: cp/decl.c:8845 +#, gcc-internal-format msgid "function definition does not declare parameters" -msgstr "funktion määrittely esitelty %<register%>:ksi" +msgstr "funktion määrittely ei esittele parametrejä" -#: cp/decl.c:8868 +#: cp/decl.c:8870 #, fuzzy, gcc-internal-format msgid "declaration of %qD as %<typedef%>" msgstr "tyhjä esittely" -#: cp/decl.c:8873 +#: cp/decl.c:8875 #, fuzzy, gcc-internal-format msgid "declaration of %qD as parameter" msgstr "%J%qD:n esittely varjostaa parametria" -#: cp/decl.c:8906 +#: cp/decl.c:8908 #, fuzzy, gcc-internal-format msgid "%<constexpr%> cannot appear in a typedef declaration" msgstr "%Hprototyypin esittely" -#: cp/decl.c:8914 +#: cp/decl.c:8916 #, gcc-internal-format msgid "two or more data types in declaration of %qs" msgstr "" -#: cp/decl.c:8920 +#: cp/decl.c:8922 #, fuzzy, gcc-internal-format msgid "conflicting specifiers in declaration of %qs" msgstr "%qs:n esittelyssä tyyppi on oletuksena %<int%>" -#: cp/decl.c:8992 cp/decl.c:8995 cp/decl.c:8998 +#: cp/decl.c:8994 cp/decl.c:8997 cp/decl.c:9000 #, gcc-internal-format msgid "ISO C++ forbids declaration of %qs with no type" msgstr "ISO C++ kieltää muuttujan %qs esittelyn ilman tyyppiä" -#: cp/decl.c:9009 +#: cp/decl.c:9011 #, fuzzy, gcc-internal-format msgid "%<__int128%> is not supported by this target" msgstr "säiekohtaista muistia ei tueta tälle kohteelle" -#: cp/decl.c:9014 +#: cp/decl.c:9016 #, fuzzy, gcc-internal-format -#| msgid "ISO C++ 1998 does not support %<long long%>" msgid "ISO C++ does not support %<__int128%> for %qs" msgstr "ISO C++ 1998 ei tue %<long long%> -tyyppiä" -#: cp/decl.c:9035 cp/decl.c:9055 -#, fuzzy, gcc-internal-format +#: cp/decl.c:9037 cp/decl.c:9057 +#, gcc-internal-format msgid "%<signed%> or %<unsigned%> invalid for %qs" -msgstr "sekä %<signed%> että %<unsigned%> esittelymääritteissä" +msgstr "%<signed%> tai %<unsigned%> virheellinen %qs:lle" -#: cp/decl.c:9037 -#, fuzzy, gcc-internal-format +#: cp/decl.c:9039 +#, gcc-internal-format msgid "%<signed%> and %<unsigned%> specified together for %qs" -msgstr "sekä %<signed%> että %<unsigned%> esittelymääritteissä" +msgstr "sekä %<signed%> että %<unsigned%> määritelty %qs:lle" -#: cp/decl.c:9039 -#, fuzzy, gcc-internal-format +#: cp/decl.c:9041 +#, gcc-internal-format msgid "%<long long%> invalid for %qs" -msgstr "%<long long long%> on liian suuri GCC:lle" +msgstr "%<long long%> virheellinen %qs:lle" -#: cp/decl.c:9041 +#: cp/decl.c:9043 #, gcc-internal-format msgid "%<long%> invalid for %qs" -msgstr "" +msgstr "%<long%> virheellinen %qs:lle" -#: cp/decl.c:9043 +#: cp/decl.c:9045 #, gcc-internal-format msgid "%<short%> invalid for %qs" -msgstr "" +msgstr "%<short%> virheellinen %qs:lle" -#: cp/decl.c:9045 -#, fuzzy, gcc-internal-format +#: cp/decl.c:9047 +#, gcc-internal-format msgid "%<long%> or %<short%> invalid for %qs" -msgstr "sekä %<long%> että %<short%> esittelymääritteissä" +msgstr "%<long%> tai %<short%> virheellinen %qs:lle" -#: cp/decl.c:9047 +#: cp/decl.c:9049 #, fuzzy, gcc-internal-format msgid "%<long%>, %<int%>, %<short%>, or %<char%> invalid for %qs" msgstr "sekä %<long%> että %<short%> esittelymääritteissä" -#: cp/decl.c:9049 +#: cp/decl.c:9051 #, gcc-internal-format msgid "%<long%> or %<short%> specified with char for %qs" msgstr "" -#: cp/decl.c:9051 -#, fuzzy, gcc-internal-format +#: cp/decl.c:9053 +#, gcc-internal-format msgid "%<long%> and %<short%> specified together for %qs" -msgstr "sekä %<long%> että %<short%> esittelymääritteissä" +msgstr "sekä %<long%> että %<short%> määritelty %qs:lle" -#: cp/decl.c:9057 -#, fuzzy, gcc-internal-format +#: cp/decl.c:9059 +#, gcc-internal-format msgid "%<short%> or %<long%> invalid for %qs" -msgstr "sekä %<long%> että %<short%> esittelymääritteissä" +msgstr "%<short%> tai %<long%> virheellinen %qs:lle" -#: cp/decl.c:9065 +#: cp/decl.c:9067 #, gcc-internal-format msgid "long, short, signed or unsigned used invalidly for %qs" msgstr "" -#: cp/decl.c:9133 +#: cp/decl.c:9135 #, gcc-internal-format msgid "complex invalid for %qs" msgstr "" -#: cp/decl.c:9161 +#: cp/decl.c:9163 #, gcc-internal-format msgid "qualifiers are not allowed on declaration of %<operator %T%>" msgstr "" -#: cp/decl.c:9193 +#: cp/decl.c:9195 #, gcc-internal-format msgid "member %qD cannot be declared both virtual and static" -msgstr "" - -#: cp/decl.c:9201 -#, gcc-internal-format -msgid "%<%T::%D%> is not a valid declarator" -msgstr "" +msgstr "jäsentä %qD ei voida esitellä sekä virtuaaliseksi että staattiseksi" -#: cp/decl.c:9210 +#: cp/decl.c:9206 #, gcc-internal-format msgid "typedef declaration invalid in parameter declaration" msgstr "" -#: cp/decl.c:9215 -#, fuzzy, gcc-internal-format +#: cp/decl.c:9211 +#, gcc-internal-format msgid "storage class specified for template parameter %qs" -msgstr "tallennusluokka annettu parametrille %qs" +msgstr "tallennusluokka annettu malliparametrille %qs" -#: cp/decl.c:9221 +#: cp/decl.c:9217 #, gcc-internal-format msgid "storage class specifiers invalid in parameter declarations" -msgstr "" +msgstr "tallennusluokkatarkentimet virheellisiä parameteresittelyissä" -#: cp/decl.c:9227 -#, fuzzy, gcc-internal-format +#: cp/decl.c:9223 +#, gcc-internal-format msgid "a parameter cannot be declared %<constexpr%>" -msgstr "%Jparametri %qD esitelty %<inline%>:ksi" +msgstr "parametriksi ei voida esitellä %<constexpr%>:ksi" -#: cp/decl.c:9236 -#, fuzzy, gcc-internal-format +#: cp/decl.c:9232 +#, gcc-internal-format msgid "%<virtual%> outside class declaration" -msgstr "virtual luokan esittelyn ulkopuolella" +msgstr "%<virtual%> luokan esittelyn ulkopuolella" -#: cp/decl.c:9254 +#: cp/decl.c:9250 #, gcc-internal-format msgid "multiple storage classes in declaration of %qs" -msgstr "" +msgstr "useita tallennusluokkia %qs:n esittelyssä" -#: cp/decl.c:9277 +#: cp/decl.c:9273 #, gcc-internal-format msgid "storage class specified for %qs" msgstr "tallennusluokka annettu %qs:lle" -#: cp/decl.c:9281 +#: cp/decl.c:9277 #, gcc-internal-format msgid "storage class specified for parameter %qs" msgstr "tallennusluokka annettu parametrille %qs" -#: cp/decl.c:9294 +#: cp/decl.c:9290 #, gcc-internal-format msgid "nested function %qs declared %<extern%>" msgstr "sisäkkäinen funktio %qs esitelty %<extern%>:ksi" -#: cp/decl.c:9298 +#: cp/decl.c:9294 #, gcc-internal-format msgid "top-level declaration of %qs specifies %<auto%>" msgstr "" -#: cp/decl.c:9305 +#: cp/decl.c:9301 #, gcc-internal-format msgid "function-scope %qs implicitly auto and declared %<__thread%>" msgstr "funktioalue %qs implisiittisesti auto ja esitelty %<__thread%>:ksi" -#: cp/decl.c:9317 +#: cp/decl.c:9313 #, gcc-internal-format msgid "storage class specifiers invalid in friend function declarations" msgstr "" -#: cp/decl.c:9427 +#: cp/decl.c:9423 #, gcc-internal-format msgid "%qs declared as function returning a function" msgstr "%qs esitelty funktion palauttavana funktiona" -#: cp/decl.c:9432 +#: cp/decl.c:9428 #, gcc-internal-format msgid "%qs declared as function returning an array" msgstr "%qs esitelty taulukon palauttavan funktiona" -#: cp/decl.c:9438 +#: cp/decl.c:9434 #, fuzzy, gcc-internal-format -#| msgid "%qs declared as function returning an array" msgid "%qs declared as function returning an abstract class type" msgstr "%qs esitelty taulukon palauttavan funktiona" -#: cp/decl.c:9467 +#: cp/decl.c:9463 #, gcc-internal-format msgid "%qs function uses %<auto%> type specifier without trailing return type" msgstr "" -#: cp/decl.c:9473 +#: cp/decl.c:9469 #, gcc-internal-format msgid "%qs function with trailing return type has %qT as its type rather than plain %<auto%>" msgstr "" #. Not using maybe_warn_cpp0x because this should #. always be an error. -#: cp/decl.c:9484 +#: cp/decl.c:9480 #, gcc-internal-format msgid "trailing return type only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/decl.c:9487 +#: cp/decl.c:9483 #, gcc-internal-format msgid "%qs function with trailing return type not declared with %<auto%> type specifier" msgstr "" -#: cp/decl.c:9520 +#: cp/decl.c:9516 #, gcc-internal-format msgid "destructor cannot be static member function" msgstr "hajotin ei voi olla staattinen jäsenfunktio" -#: cp/decl.c:9521 +#: cp/decl.c:9517 #, fuzzy, gcc-internal-format -#| msgid "destructor cannot be static member function" msgid "constructor cannot be static member function" msgstr "hajotin ei voi olla staattinen jäsenfunktio" -#: cp/decl.c:9525 +#: cp/decl.c:9521 #, gcc-internal-format msgid "destructors may not be cv-qualified" -msgstr "" +msgstr "hajottimet eivät voi olla cv-määriteltyjä" -#: cp/decl.c:9526 +#: cp/decl.c:9522 #, fuzzy, gcc-internal-format -#| msgid "constructors cannot be declared virtual" msgid "constructors may not be cv-qualified" msgstr "muodostimia ei voi esitellä virtuaalisiksi" -#: cp/decl.c:9543 +#: cp/decl.c:9539 #, gcc-internal-format msgid "constructors cannot be declared virtual" msgstr "muodostimia ei voi esitellä virtuaalisiksi" -#: cp/decl.c:9556 +#: cp/decl.c:9552 #, fuzzy, gcc-internal-format msgid "can%'t initialize friend function %qs" msgstr "indeksoitu arvo on osoitin funktioon" #. Cannot be both friend and virtual. -#: cp/decl.c:9560 +#: cp/decl.c:9556 #, gcc-internal-format msgid "virtual functions cannot be friends" msgstr "" -#: cp/decl.c:9564 +#: cp/decl.c:9560 #, gcc-internal-format msgid "friend declaration not in class definition" msgstr "" -#: cp/decl.c:9566 +#: cp/decl.c:9562 #, gcc-internal-format msgid "can%'t define friend function %qs in a local class definition" msgstr "" -#: cp/decl.c:9587 +#: cp/decl.c:9583 #, gcc-internal-format msgid "destructors may not have parameters" msgstr "hajottimilla ei voi olla parametreja" -#: cp/decl.c:9613 +#: cp/decl.c:9609 #, gcc-internal-format msgid "cannot declare pointer to %q#T" msgstr "" -#: cp/decl.c:9626 cp/decl.c:9633 +#: cp/decl.c:9622 cp/decl.c:9629 #, gcc-internal-format msgid "cannot declare reference to %q#T" msgstr "" -#: cp/decl.c:9635 +#: cp/decl.c:9631 #, gcc-internal-format msgid "cannot declare pointer to %q#T member" msgstr "" -#: cp/decl.c:9658 +#: cp/decl.c:9654 #, fuzzy, gcc-internal-format msgid "cannot declare reference to qualified function type %qT" msgstr "tyyppimuunnos lisää funktiotyyppiin uusia määreitä" -#: cp/decl.c:9659 +#: cp/decl.c:9655 #, fuzzy, gcc-internal-format msgid "cannot declare pointer to qualified function type %qT" msgstr "tyyppimuunnos lisää funktiotyyppiin uusia määreitä" -#: cp/decl.c:9733 +#: cp/decl.c:9729 #, gcc-internal-format msgid "cannot declare reference to %q#T, which is not a typedef or a template type argument" msgstr "" -#: cp/decl.c:9797 +#: cp/decl.c:9793 #, fuzzy, gcc-internal-format -#| msgid "both %<_Sat%> and %<complex%> in declaration specifiers" msgid "both %<volatile%> and %<constexpr%> cannot be used here" msgstr "sekä %<_Sat%> että %<complex%> esittelymääritteissä" -#: cp/decl.c:9809 +#: cp/decl.c:9805 #, gcc-internal-format msgid "template-id %qD used as a declarator" msgstr "" -#: cp/decl.c:9833 +#: cp/decl.c:9829 #, gcc-internal-format msgid "member functions are implicitly friends of their class" msgstr "" -#: cp/decl.c:9838 +#: cp/decl.c:9834 #, gcc-internal-format msgid "extra qualification %<%T::%> on member %qs" msgstr "" -#: cp/decl.c:9868 +#: cp/decl.c:9864 #, fuzzy, gcc-internal-format msgid "cannot define member function %<%T::%s%> within %<%T%>" msgstr "funktiota %<main%> ei voi määrittää avoimeksi" -#: cp/decl.c:9870 +#: cp/decl.c:9866 #, fuzzy, gcc-internal-format msgid "cannot declare member function %<%T::%s%> within %<%T%>" msgstr "funktiota %<main%> ei voi määrittää avoimeksi" -#: cp/decl.c:9879 +#: cp/decl.c:9875 #, gcc-internal-format msgid "cannot declare member %<%T::%s%> within %qT" msgstr "" -#: cp/decl.c:9912 +#: cp/decl.c:9908 #, gcc-internal-format msgid "non-parameter %qs cannot be a parameter pack" msgstr "" -#: cp/decl.c:9922 +#: cp/decl.c:9918 #, gcc-internal-format msgid "size of array %qs is too large" msgstr "taulukon %qs koko on liian suuri" -#: cp/decl.c:9933 +#: cp/decl.c:9929 #, gcc-internal-format msgid "data member may not have variably modified type %qT" msgstr "" -#: cp/decl.c:9935 +#: cp/decl.c:9931 #, gcc-internal-format msgid "parameter may not have variably modified type %qT" msgstr "" #. [dcl.fct.spec] The explicit specifier shall only be used in #. declarations of constructors within a class definition. -#: cp/decl.c:9943 +#: cp/decl.c:9939 #, gcc-internal-format msgid "only declarations of constructors can be %<explicit%>" msgstr "vain muodostimen esittely voi olla %<explicit%>" -#: cp/decl.c:9951 +#: cp/decl.c:9947 #, gcc-internal-format msgid "non-member %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.c:9957 +#: cp/decl.c:9953 #, gcc-internal-format msgid "non-object member %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.c:9963 +#: cp/decl.c:9959 #, gcc-internal-format msgid "function %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.c:9968 +#: cp/decl.c:9964 #, gcc-internal-format msgid "static %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.c:9973 +#: cp/decl.c:9969 #, gcc-internal-format msgid "const %qs cannot be declared %<mutable%>" msgstr "" -#: cp/decl.c:9978 +#: cp/decl.c:9974 #, fuzzy, gcc-internal-format msgid "reference %qs cannot be declared %<mutable%>" msgstr "%Jparametri %qD esitelty %<inline%>:ksi" -#: cp/decl.c:10013 +#: cp/decl.c:10009 #, fuzzy, gcc-internal-format msgid "typedef declared %<auto%>" msgstr "%Jparametri %qD esitelty %<inline%>:ksi" -#: cp/decl.c:10023 +#: cp/decl.c:10019 #, gcc-internal-format msgid "typedef name may not be a nested-name-specifier" msgstr "" -#: cp/decl.c:10042 +#: cp/decl.c:10038 #, gcc-internal-format msgid "ISO C++ forbids nested type %qD with same name as enclosing class" msgstr "" -#: cp/decl.c:10143 +#: cp/decl.c:10139 #, gcc-internal-format msgid "qualified function types cannot be used to declare static member functions" msgstr "" -#: cp/decl.c:10145 +#: cp/decl.c:10141 #, gcc-internal-format msgid "qualified function types cannot be used to declare free functions" msgstr "" -#: cp/decl.c:10172 +#: cp/decl.c:10168 #, gcc-internal-format msgid "type qualifiers specified for friend class declaration" msgstr "" -#: cp/decl.c:10177 +#: cp/decl.c:10173 #, gcc-internal-format msgid "%<inline%> specified for friend class declaration" msgstr "" -#: cp/decl.c:10185 +#: cp/decl.c:10181 #, gcc-internal-format msgid "template parameters cannot be friends" msgstr "" -#: cp/decl.c:10187 +#: cp/decl.c:10183 #, gcc-internal-format msgid "friend declaration requires class-key, i.e. %<friend class %T::%D%>" msgstr "" -#: cp/decl.c:10191 +#: cp/decl.c:10187 #, gcc-internal-format msgid "friend declaration requires class-key, i.e. %<friend %#T%>" msgstr "" -#: cp/decl.c:10204 +#: cp/decl.c:10200 #, gcc-internal-format msgid "trying to make class %qT a friend of global scope" msgstr "" -#: cp/decl.c:10222 +#: cp/decl.c:10218 #, gcc-internal-format msgid "invalid qualifiers on non-member function type" -msgstr "" +msgstr "virheelliset määreet ei-jäsenfunktion tyypissä" -#: cp/decl.c:10232 +#: cp/decl.c:10228 #, gcc-internal-format msgid "abstract declarator %qT used as declaration" msgstr "" -#: cp/decl.c:10261 +#: cp/decl.c:10257 #, gcc-internal-format msgid "cannot use %<::%> in parameter declaration" msgstr "" -#: cp/decl.c:10265 -#, fuzzy, gcc-internal-format +#: cp/decl.c:10261 +#, gcc-internal-format msgid "parameter declared %<auto%>" -msgstr "%Jparametri %qD esitelty %<inline%>:ksi" +msgstr "parametri esitelty %<auto%>:ksi" -#: cp/decl.c:10308 +#: cp/decl.c:10304 #, fuzzy, gcc-internal-format msgid "non-static data member declared %<auto%>" msgstr "%Jparametri %qD esitelty %<inline%>:ksi" #. Something like struct S { int N::j; }; -#: cp/decl.c:10330 +#: cp/decl.c:10326 #, gcc-internal-format msgid "invalid use of %<::%>" msgstr "" -#: cp/decl.c:10352 +#: cp/decl.c:10348 #, fuzzy, gcc-internal-format msgid "declaration of function %qD in invalid context" msgstr "%J%qD:n esittely varjostaa parametria" -#: cp/decl.c:10361 +#: cp/decl.c:10357 #, gcc-internal-format msgid "function %qD declared virtual inside a union" msgstr "funktio %qD esitelty virtuaaliseksi unionissa" -#: cp/decl.c:10370 +#: cp/decl.c:10366 #, gcc-internal-format msgid "%qD cannot be declared virtual, since it is always static" msgstr "" -#: cp/decl.c:10386 +#: cp/decl.c:10382 #, gcc-internal-format msgid "expected qualified name in friend declaration for destructor %qD" msgstr "" -#: cp/decl.c:10393 -#, fuzzy, gcc-internal-format +#: cp/decl.c:10389 +#, gcc-internal-format msgid "declaration of %qD as member of %qT" -msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" +msgstr "%qD:n esittely %qT:n jäsenenä" -#: cp/decl.c:10399 -#, fuzzy, gcc-internal-format +#: cp/decl.c:10395 +#, gcc-internal-format msgid "a destructor cannot be %<constexpr%>" -msgstr "hajotin ei voi olla staattinen jäsenfunktio" +msgstr "hajotin ei voi olla %<constexpr%>" -#: cp/decl.c:10405 +#: cp/decl.c:10401 #, fuzzy, gcc-internal-format msgid "expected qualified name in friend declaration for constructor %qD" msgstr "%qD esitelty staattisesti sisäkkäin" -#: cp/decl.c:10451 +#: cp/decl.c:10447 #, gcc-internal-format msgid "field %qD has incomplete type" msgstr "kentällä %qD on vaillinainen tyyppi" -#: cp/decl.c:10453 +#: cp/decl.c:10449 #, gcc-internal-format msgid "name %qT has incomplete type" -msgstr "" +msgstr "nimellä %qT on vaillinainen tyyppi" -#: cp/decl.c:10462 +#: cp/decl.c:10458 #, gcc-internal-format msgid " in instantiation of template %qT" msgstr "" -#: cp/decl.c:10471 +#: cp/decl.c:10467 #, gcc-internal-format msgid "%qE is neither function nor member function; cannot be declared friend" msgstr "" -#: cp/decl.c:10528 +#: cp/decl.c:10524 #, fuzzy, gcc-internal-format msgid "constexpr static data member %qD must have an initializer" msgstr "muuttuvakokoista objektia ei voi alustaa" -#: cp/decl.c:10537 -#, fuzzy, gcc-internal-format +#: cp/decl.c:10533 +#, gcc-internal-format msgid "non-static data member %qE declared %<constexpr%>" -msgstr "%Jparametri %qD esitelty %<inline%>:ksi" +msgstr "ei-staattinen datajäsen %qE esitelty %<constexpr%>:ksi" -#: cp/decl.c:10587 +#: cp/decl.c:10583 #, gcc-internal-format msgid "storage class %<auto%> invalid for function %qs" -msgstr "" +msgstr "tallennusluokka %<auto%> virheellinen funktiolle %qs" -#: cp/decl.c:10589 +#: cp/decl.c:10585 #, gcc-internal-format msgid "storage class %<register%> invalid for function %qs" -msgstr "" +msgstr "tallennusluokka %<register%> virheellinen funktiolle %qs" -#: cp/decl.c:10593 +#: cp/decl.c:10589 #, gcc-internal-format msgid "storage class %<__thread%> invalid for function %qs" -msgstr "" +msgstr "tallennusluokka %<__thread%> virheellinen funktiolle %qs" -#: cp/decl.c:10596 +#: cp/decl.c:10592 #, fuzzy, gcc-internal-format -#| msgid "storage class specified for %qs" msgid "storage class %<thread_local%> invalid for function %qs" -msgstr "tallennusluokka annettu %qs:lle" +msgstr "tallennusluokka %<thread_local%> virheellinen funktiolle %qs" -#: cp/decl.c:10601 +#: cp/decl.c:10597 #, fuzzy, gcc-internal-format msgid "virt-specifiers in %qs not allowed outside a class definition" msgstr "%Jvanhanmallinen funktiomäärittely" -#: cp/decl.c:10612 +#: cp/decl.c:10608 #, gcc-internal-format msgid "%<static%> specified invalid for function %qs declared out of global scope" msgstr "" -#: cp/decl.c:10616 +#: cp/decl.c:10612 #, gcc-internal-format msgid "%<inline%> specifier invalid for function %qs declared out of global scope" msgstr "" -#: cp/decl.c:10624 +#: cp/decl.c:10620 #, gcc-internal-format msgid "virtual non-class function %qs" -msgstr "" +msgstr "virtuaalinen ei-luokkafunktio %qs" -#: cp/decl.c:10631 +#: cp/decl.c:10627 #, fuzzy, gcc-internal-format msgid "%qs defined in a non-class scope" msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille" -#: cp/decl.c:10632 +#: cp/decl.c:10628 #, fuzzy, gcc-internal-format msgid "%qs declared in a non-class scope" msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille" -#: cp/decl.c:10660 +#: cp/decl.c:10655 #, gcc-internal-format msgid "cannot declare member function %qD to have static linkage" msgstr "" #. FIXME need arm citation -#: cp/decl.c:10667 +#: cp/decl.c:10662 #, gcc-internal-format msgid "cannot declare static function inside another function" msgstr "" -#: cp/decl.c:10697 +#: cp/decl.c:10692 #, gcc-internal-format msgid "%<static%> may not be used when defining (as opposed to declaring) a static data member" msgstr "" -#: cp/decl.c:10704 +#: cp/decl.c:10699 #, gcc-internal-format msgid "static member %qD declared %<register%>" msgstr "" -#: cp/decl.c:10710 +#: cp/decl.c:10705 #, gcc-internal-format msgid "cannot explicitly declare member %q#D to have extern linkage" msgstr "" -#: cp/decl.c:10717 +#: cp/decl.c:10712 #, fuzzy, gcc-internal-format -#| msgid "declaration of non-variable %qD in %<for%> loop initial declaration" msgid "declaration of constexpr variable %qD is not a definition" msgstr "ei-muuttujan %qD esittely %<for%>-silmukan alkuesittelyssä" -#: cp/decl.c:10730 +#: cp/decl.c:10725 #, gcc-internal-format msgid "%qs initialized and declared %<extern%>" msgstr "%qs alustettu ja esitelty %<extern%>-avainsanalla" -#: cp/decl.c:10734 +#: cp/decl.c:10729 #, gcc-internal-format msgid "%qs has both %<extern%> and initializer" msgstr "%qs on sekä %<extern%> että alustin" -#: cp/decl.c:10880 +#: cp/decl.c:10874 #, fuzzy, gcc-internal-format msgid "default argument %qE uses %qD" msgstr "tyyppimuunnettu argumentti %qD ei sovi prototyyppiin" -#: cp/decl.c:10882 +#: cp/decl.c:10876 #, gcc-internal-format msgid "default argument %qE uses local variable %qD" msgstr "" -#: cp/decl.c:10970 -#, fuzzy, gcc-internal-format +#: cp/decl.c:10964 +#, gcc-internal-format msgid "parameter %qD has Java class type" -msgstr "parametrin %q+D tyyppi on vaillinainen" +msgstr "parametrilla %qD on Java-luokkatyyppi" -#: cp/decl.c:10998 +#: cp/decl.c:10992 #, gcc-internal-format msgid "parameter %qD invalidly declared method type" -msgstr "" +msgstr "parametri %qD virheellisesti esitelty metodityyppi" -#: cp/decl.c:11023 +#: cp/decl.c:11017 #, gcc-internal-format msgid "parameter %qD includes pointer to array of unknown bound %qT" msgstr "" -#: cp/decl.c:11025 +#: cp/decl.c:11019 #, gcc-internal-format msgid "parameter %qD includes reference to array of unknown bound %qT" msgstr "" @@ -30927,168 +30591,168 @@ msgstr "" #. or implicitly defined), there's no need to worry about their #. existence. Theoretically, they should never even be #. instantiated, but that's hard to forestall. -#: cp/decl.c:11279 +#: cp/decl.c:11273 #, gcc-internal-format msgid "invalid constructor; you probably meant %<%T (const %T&)%>" -msgstr "" +msgstr "virheellinen muodostin; tarkoitit todennäköisesti %<%T (const %T&)%>" -#: cp/decl.c:11401 +#: cp/decl.c:11395 #, gcc-internal-format msgid "%qD may not be declared within a namespace" msgstr "" -#: cp/decl.c:11406 +#: cp/decl.c:11400 #, gcc-internal-format msgid "%qD may not be declared as static" msgstr "" -#: cp/decl.c:11432 +#: cp/decl.c:11426 #, gcc-internal-format msgid "%qD must be a nonstatic member function" msgstr "" -#: cp/decl.c:11441 +#: cp/decl.c:11435 #, gcc-internal-format msgid "%qD must be either a non-static member function or a non-member function" msgstr "" -#: cp/decl.c:11463 +#: cp/decl.c:11457 #, gcc-internal-format msgid "%qD must have an argument of class or enumerated type" msgstr "" -#: cp/decl.c:11492 +#: cp/decl.c:11486 #, gcc-internal-format msgid "conversion to a reference to void will never use a type conversion operator" msgstr "" -#: cp/decl.c:11494 -#, fuzzy, gcc-internal-format +#: cp/decl.c:11488 +#, gcc-internal-format msgid "conversion to void will never use a type conversion operator" -msgstr "epäkelpo %<restrict%>-avainsanan käyttö" +msgstr "muunnnos void-tyypiksi ei koskaan käytä tyyppimuunnosoperaattoria" -#: cp/decl.c:11501 +#: cp/decl.c:11495 #, gcc-internal-format msgid "conversion to a reference to the same type will never use a type conversion operator" msgstr "" -#: cp/decl.c:11503 +#: cp/decl.c:11497 #, gcc-internal-format msgid "conversion to the same type will never use a type conversion operator" msgstr "" -#: cp/decl.c:11511 +#: cp/decl.c:11505 #, gcc-internal-format msgid "conversion to a reference to a base class will never use a type conversion operator" msgstr "" -#: cp/decl.c:11513 +#: cp/decl.c:11507 #, gcc-internal-format msgid "conversion to a base class will never use a type conversion operator" msgstr "" #. 13.4.0.3 -#: cp/decl.c:11522 +#: cp/decl.c:11516 #, gcc-internal-format msgid "ISO C++ prohibits overloading operator ?:" msgstr "ISO C++ kieltää ?:-operaattorin ylikuormituksen" -#: cp/decl.c:11527 +#: cp/decl.c:11521 #, gcc-internal-format msgid "%qD must not have variable number of arguments" -msgstr "" +msgstr "%qD:lla ei saa olla vaihtuvaa määrää argumentteja" -#: cp/decl.c:11578 +#: cp/decl.c:11572 #, gcc-internal-format msgid "postfix %qD must take %<int%> as its argument" msgstr "" -#: cp/decl.c:11581 +#: cp/decl.c:11575 #, gcc-internal-format msgid "postfix %qD must take %<int%> as its second argument" msgstr "" -#: cp/decl.c:11589 +#: cp/decl.c:11583 #, gcc-internal-format msgid "%qD must take either zero or one argument" -msgstr "" +msgstr "%qD:n on otettava joko nolla tai yksi argumenttia" -#: cp/decl.c:11591 +#: cp/decl.c:11585 #, gcc-internal-format msgid "%qD must take either one or two arguments" -msgstr "" +msgstr "%qD:n on otettava joko yksi tai kaksi argumenttia" -#: cp/decl.c:11613 +#: cp/decl.c:11607 #, gcc-internal-format msgid "prefix %qD should return %qT" msgstr "" -#: cp/decl.c:11619 +#: cp/decl.c:11613 #, gcc-internal-format msgid "postfix %qD should return %qT" msgstr "" -#: cp/decl.c:11628 +#: cp/decl.c:11622 #, gcc-internal-format msgid "%qD must take %<void%>" msgstr "" -#: cp/decl.c:11630 cp/decl.c:11639 +#: cp/decl.c:11624 cp/decl.c:11633 #, gcc-internal-format msgid "%qD must take exactly one argument" -msgstr "" +msgstr "%qD:n on otettava tasan yksi argumentti" -#: cp/decl.c:11641 +#: cp/decl.c:11635 #, gcc-internal-format msgid "%qD must take exactly two arguments" -msgstr "" +msgstr "%qD:n on otettava tasan kaksi argumenttia" -#: cp/decl.c:11650 +#: cp/decl.c:11644 #, gcc-internal-format msgid "user-defined %qD always evaluates both arguments" msgstr "" -#: cp/decl.c:11664 +#: cp/decl.c:11658 #, gcc-internal-format msgid "%qD should return by value" msgstr "" -#: cp/decl.c:11675 cp/decl.c:11680 +#: cp/decl.c:11669 cp/decl.c:11674 #, gcc-internal-format msgid "%qD cannot have default arguments" -msgstr "" +msgstr "%qD:lla ei voi olla oletusargumentteja" -#: cp/decl.c:11741 +#: cp/decl.c:11732 #, gcc-internal-format msgid "using template type parameter %qT after %qs" msgstr "" -#: cp/decl.c:11764 +#: cp/decl.c:11755 #, fuzzy, gcc-internal-format msgid "using alias template specialization %qT after %qs" msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa" -#: cp/decl.c:11767 +#: cp/decl.c:11758 #, gcc-internal-format msgid "using typedef-name %qD after %qs" msgstr "" -#: cp/decl.c:11769 -#, fuzzy, gcc-internal-format +#: cp/decl.c:11760 +#, gcc-internal-format msgid "%qD has a previous declaration here" -msgstr "%J%qD:n edellinen esittely oli täällä" +msgstr "%q+D:lla on edellinen esittely täällä" -#: cp/decl.c:11777 +#: cp/decl.c:11768 #, gcc-internal-format msgid "%qT referred to as %qs" msgstr "" -#: cp/decl.c:11778 cp/decl.c:11785 +#: cp/decl.c:11769 cp/decl.c:11776 #, fuzzy, gcc-internal-format msgid "%q+T has a previous declaration here" msgstr "%J%qD:n edellinen esittely oli täällä" -#: cp/decl.c:11784 +#: cp/decl.c:11775 #, gcc-internal-format msgid "%qT referred to as enum" msgstr "" @@ -31100,88 +30764,88 @@ msgstr "" #. void f(class C); // No template header here #. #. then the required template argument is missing. -#: cp/decl.c:11799 +#: cp/decl.c:11790 #, gcc-internal-format msgid "template argument required for %<%s %T%>" msgstr "" -#: cp/decl.c:11849 cp/name-lookup.c:3069 +#: cp/decl.c:11840 cp/name-lookup.c:3062 #, gcc-internal-format msgid "%qD has the same name as the class in which it is declared" -msgstr "" +msgstr "%qD:llä on sama nimi kuin luokalla, jossa se on esitelty" -#: cp/decl.c:11879 cp/name-lookup.c:2561 cp/name-lookup.c:3395 -#: cp/name-lookup.c:3440 cp/parser.c:5076 cp/parser.c:21175 +#: cp/decl.c:11870 cp/name-lookup.c:2561 cp/name-lookup.c:3390 +#: cp/name-lookup.c:3435 cp/parser.c:5076 cp/parser.c:21179 #, gcc-internal-format msgid "reference to %qD is ambiguous" msgstr "" -#: cp/decl.c:11994 +#: cp/decl.c:11985 #, gcc-internal-format msgid "use of enum %q#D without previous declaration" msgstr "" -#: cp/decl.c:12015 +#: cp/decl.c:12006 #, gcc-internal-format msgid "redeclaration of %qT as a non-template" msgstr "" -#: cp/decl.c:12016 -#, fuzzy, gcc-internal-format +#: cp/decl.c:12007 +#, gcc-internal-format msgid "previous declaration %q+D" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "edellinen esittely %q+D" -#: cp/decl.c:12157 +#: cp/decl.c:12148 #, gcc-internal-format msgid "derived union %qT invalid" msgstr "" -#: cp/decl.c:12166 +#: cp/decl.c:12157 #, gcc-internal-format msgid "Java class %qT cannot have multiple bases" msgstr "" -#: cp/decl.c:12177 +#: cp/decl.c:12168 #, gcc-internal-format msgid "Java class %qT cannot have virtual bases" msgstr "" -#: cp/decl.c:12197 +#: cp/decl.c:12188 #, gcc-internal-format msgid "base type %qT fails to be a struct or class type" msgstr "" -#: cp/decl.c:12230 +#: cp/decl.c:12221 #, gcc-internal-format msgid "recursive type %qT undefined" -msgstr "" +msgstr "rekursiivinen tyyppi %qT määrittelemätön" -#: cp/decl.c:12232 +#: cp/decl.c:12223 #, gcc-internal-format msgid "duplicate base type %qT invalid" -msgstr "" +msgstr "perustyypin %qT kaksoiskappale virheellinen" -#: cp/decl.c:12356 +#: cp/decl.c:12347 #, gcc-internal-format msgid "scoped/unscoped mismatch in enum %q#T" msgstr "" -#: cp/decl.c:12359 cp/decl.c:12367 cp/decl.c:12379 cp/parser.c:14742 -#, fuzzy, gcc-internal-format +#: cp/decl.c:12350 cp/decl.c:12358 cp/decl.c:12370 cp/parser.c:14744 +#, gcc-internal-format msgid "previous definition here" -msgstr "%J%qD:n edellinen määrittely oli täällä" +msgstr "edellinen määrittely täällä" -#: cp/decl.c:12364 +#: cp/decl.c:12355 #, gcc-internal-format msgid "underlying type mismatch in enum %q#T" msgstr "" -#: cp/decl.c:12376 +#: cp/decl.c:12367 #, gcc-internal-format msgid "different underlying type in enum %q#T" msgstr "" -#: cp/decl.c:12443 +#: cp/decl.c:12434 #, gcc-internal-format msgid "underlying type %<%T%> of %<%T%> must be an integral type" msgstr "" @@ -31190,85 +30854,82 @@ msgstr "" #. #. IF no integral type can represent all the enumerator values, the #. enumeration is ill-formed. -#: cp/decl.c:12577 +#: cp/decl.c:12568 #, gcc-internal-format msgid "no integral type can represent all of the enumerator values for %qT" msgstr "" -#: cp/decl.c:12718 +#: cp/decl.c:12709 #, fuzzy, gcc-internal-format msgid "enumerator value for %qD is not an integer constant" msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio" -#: cp/decl.c:12764 +#: cp/decl.c:12755 #, fuzzy, gcc-internal-format msgid "incremented enumerator value is too large for %<unsigned long%>" msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio" -#: cp/decl.c:12776 +#: cp/decl.c:12767 #, gcc-internal-format msgid "overflow in enumeration values at %qD" msgstr "" -#: cp/decl.c:12796 +#: cp/decl.c:12787 #, fuzzy, gcc-internal-format msgid "enumerator value %E is too large for underlying type %<%T%>" msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio" -#: cp/decl.c:12886 +#: cp/decl.c:12877 #, gcc-internal-format msgid "return type %q#T is incomplete" -msgstr "" +msgstr "paluutyyppi %q#T on vaillinainen" -#: cp/decl.c:12888 -#, fuzzy, gcc-internal-format +#: cp/decl.c:12879 +#, gcc-internal-format msgid "return type has Java class type %q#T" -msgstr "palautustyyppi on vaillinainen tyyppi" +msgstr "paluutyypillä on Java-luokkatyyppi %q#T" -#: cp/decl.c:13012 cp/typeck.c:8247 +#: cp/decl.c:13003 cp/typeck.c:8252 #, gcc-internal-format msgid "%<operator=%> should return a reference to %<*this%>" msgstr "" -#: cp/decl.c:13108 -#, fuzzy, gcc-internal-format +#: cp/decl.c:13099 +#, gcc-internal-format msgid "no previous declaration for %q+D" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "%q+D:lle ei ole edellistä esittelyä" -#: cp/decl.c:13329 -#, fuzzy, gcc-internal-format +#: cp/decl.c:13320 +#, gcc-internal-format msgid "invalid function declaration" -msgstr "Varoita implisiittisistä funktioesittelyistä" +msgstr "virheellinen funktioesittely" -#: cp/decl.c:13413 +#: cp/decl.c:13404 #, gcc-internal-format msgid "parameter %qD declared void" msgstr "" -#: cp/decl.c:13781 +#: cp/decl.c:13772 #, fuzzy, gcc-internal-format -#| msgid "no return statement in function returning non-void" msgid "no return statements in function returning %qT" msgstr "ei palautuslausetta funktiossa, joka palauttaa ei-tyhjän" -#: cp/decl.c:13783 cp/typeck.c:8135 +#: cp/decl.c:13774 cp/typeck.c:8135 #, 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 "funktion paluuarvojen tyypit eivät ole yhteensopivia %<volatile%>:n takia" -#: cp/decl.c:13879 +#: cp/decl.c:13870 #, fuzzy, gcc-internal-format -#| msgid "label %q+D defined but not used" msgid "parameter %q+D set but not used" msgstr "nimike %q+D määritelty mutta käytettämättä" -#: cp/decl.c:13974 +#: cp/decl.c:13965 #, gcc-internal-format msgid "invalid member function declaration" -msgstr "" +msgstr "virheellinen jäsenfunktioesittely" -#: cp/decl.c:13988 +#: cp/decl.c:13979 #, gcc-internal-format msgid "%qD is already defined in class %qT" msgstr "" @@ -31276,7 +30937,7 @@ msgstr "" #: cp/decl2.c:318 #, gcc-internal-format msgid "name missing for member function" -msgstr "" +msgstr "nimi puuttuu jäsenfunktiolta" #: cp/decl2.c:388 cp/decl2.c:402 #, gcc-internal-format @@ -31291,7 +30952,7 @@ msgstr "" #: cp/decl2.c:439 #, gcc-internal-format msgid "deleting array %q#E" -msgstr "" +msgstr "poistetaan taulukko %q#E" #: cp/decl2.c:445 #, gcc-internal-format @@ -31428,9 +31089,9 @@ msgstr "%<operator new%>:n on palautettava tyyppi %qT" #. The first parameter shall not have an associated default #. argument. #: cp/decl2.c:1491 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "the first parameter of %<operator new%> cannot have a default argument" -msgstr "%<va_start%>-funktion toinen parametri ei ole viimeinen nimetty argumentti" +msgstr "%<operator new%>:n ensimmäisellä parametrilla ei voi olla oletusargumenttia" #: cp/decl2.c:1507 #, gcc-internal-format @@ -31504,97 +31165,97 @@ msgstr "%qD esitelty extern-avainsanalla sisäkkäin" msgid "use of %qD before deduction of %<auto%>" msgstr "%q+D:n oletustyyppi on %<int%>" -#: cp/error.c:3327 +#: cp/error.c:3331 #, gcc-internal-format msgid "extended initializer lists only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3332 +#: cp/error.c:3336 #, gcc-internal-format msgid "explicit conversion operators only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3337 +#: cp/error.c:3341 #, gcc-internal-format msgid "variadic templates only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3342 +#: cp/error.c:3346 #, gcc-internal-format msgid "lambda expressions only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3347 +#: cp/error.c:3351 #, gcc-internal-format msgid "C++0x auto only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3351 +#: cp/error.c:3355 #, gcc-internal-format msgid "scoped enums only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3355 +#: cp/error.c:3359 #, gcc-internal-format msgid "defaulted and deleted functions only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3360 +#: cp/error.c:3364 #, gcc-internal-format msgid "inline namespaces only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3365 +#: cp/error.c:3369 #, gcc-internal-format msgid "override controls (override/final) only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3370 +#: cp/error.c:3374 #, gcc-internal-format msgid "non-static data member initializers only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3375 +#: cp/error.c:3379 #, gcc-internal-format msgid "user-defined literals only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3380 +#: cp/error.c:3384 #, gcc-internal-format msgid "delegating constructors only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3385 +#: cp/error.c:3389 #, gcc-internal-format msgid "inheriting constructors only available with -std=c++11 or -std=gnu++11" msgstr "" -#: cp/error.c:3390 +#: cp/error.c:3394 #, fuzzy, gcc-internal-format msgid "c++11 attributes only available with -std=c++11 or -std=gnu++11" msgstr "attribuutti %qs pätee vain funktiotyyppeihin" -#: cp/error.c:3439 +#: cp/error.c:3443 #, gcc-internal-format msgid "incomplete type %qT used in nested name specifier" msgstr "" -#: cp/error.c:3443 +#: cp/error.c:3447 #, gcc-internal-format msgid "reference to %<%T::%D%> is ambiguous" msgstr "" -#: cp/error.c:3448 cp/typeck.c:2260 +#: cp/error.c:3452 cp/typeck.c:2260 #, gcc-internal-format msgid "%qD is not a member of %qT" msgstr "" -#: cp/error.c:3452 -#, fuzzy, gcc-internal-format +#: cp/error.c:3456 +#, gcc-internal-format msgid "%qD is not a member of %qD" -msgstr "%qs ei ole kelpo tulostetiedosto" +msgstr "%qD ei ole %qD:n jäsen" -#: cp/error.c:3457 +#: cp/error.c:3461 #, fuzzy, gcc-internal-format msgid "%<::%D%> has not been declared" msgstr "%J%qD on tavallisesti ei-staattinen funktio" @@ -31751,9 +31412,9 @@ msgid "member %qD declared as friend before type %qT defined" msgstr "" #: cp/friend.c:561 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "friend declaration %qD in local class without prior declaration" -msgstr "%J%qD:n lohko on ristiriidassa edellisen esittelyn kanssa" +msgstr "friend-esittely %qD paikallisessa luokassa ilman edeltävää esittelyä" #: cp/friend.c:584 #, gcc-internal-format @@ -31767,7 +31428,6 @@ msgstr "" #: cp/init.c:381 #, fuzzy, gcc-internal-format -#| msgid "invalid application of %qs to incomplete type %qT " msgid "value-initialization of incomplete type %qT" msgstr "epäkelpo %qs:n soveltaminen vaillinaiseen tyyppiin %qT " @@ -31792,9 +31452,9 @@ msgid "constructor required before non-static data member for %qD has been parse msgstr "" #: cp/init.c:564 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qD should be initialized in the member initialization list" -msgstr "%J%qD tulisi alustaa jäsenten alustuslistassa" +msgstr "%qD tulee alustaa jäsenten alustuslistassa" #: cp/init.c:582 #, fuzzy, gcc-internal-format @@ -31802,19 +31462,19 @@ msgid "%qD is initialized with itself" msgstr "%q+D on yleensä funktio" #: cp/init.c:676 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid initializer for array member %q#D" -msgstr "alustamaton const-jäsen %qD" +msgstr "virheellinen alustin taulukon jäsenelle %q#D" #: cp/init.c:689 cp/init.c:707 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "uninitialized member %qD with %<const%> type %qT" -msgstr "alustamaton const %qD" +msgstr "alustamaton jäsen %qD %<const%>-tyyppillä %qT" #: cp/init.c:703 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "uninitialized reference member %qD" -msgstr "alustamaton const-jäsen %qD" +msgstr "alustamaton viitejäsen %qD" #: cp/init.c:863 #, gcc-internal-format @@ -31837,9 +31497,9 @@ msgid " base %qT" msgstr "" #: cp/init.c:873 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid " when initialized here" -msgstr "%J tässä alustuksessa" +msgstr " tässä alustuksessa" #: cp/init.c:890 #, fuzzy, gcc-internal-format @@ -31907,9 +31567,9 @@ msgid "bad array initializer" msgstr "" #: cp/init.c:1790 cp/semantics.c:2834 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qT is not a class type" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qT ei ole luokkatyyppi" #: cp/init.c:1844 #, gcc-internal-format @@ -31948,13 +31608,11 @@ msgstr "" #: cp/init.c:2143 #, fuzzy, gcc-internal-format -#| msgid "uninitialized const member %qD" msgid "uninitialized const member in %q#T" msgstr "alustamaton const-jäsen %qD" #: cp/init.c:2254 #, fuzzy, gcc-internal-format -#| msgid "integer overflow in expression" msgid "integer overflow in array size" msgstr "kokonaislukuylivuoto lausekkeessa" @@ -31970,7 +31628,6 @@ msgstr "muuttuja tai kenttä %qs esitelty tyhjäksi" #: cp/init.c:2292 #, fuzzy, gcc-internal-format -#| msgid "ISO C does not support saturating types" msgid "ISO C++ does not support variable-length array types" msgstr "ISO C ei tue saturoituvia tyyppejä" @@ -32011,7 +31668,6 @@ msgstr "" #: cp/init.c:2706 #, fuzzy, gcc-internal-format -#| msgid "array index in initializer exceeds array bounds" msgid "parenthesized initializer in array new" msgstr "taulukon indeksi alustimessa ylittää taulukon rajat" @@ -32217,7 +31873,6 @@ msgstr "alustamaton const %qD" #: cp/method.c:1091 #, fuzzy, gcc-internal-format -#| msgid "uninitialized const member %qD" msgid "uninitialized non-static const member %q#D" msgstr "alustamaton const-jäsen %qD" @@ -32325,19 +31980,19 @@ msgstr "" #. #. This function shall not be overloaded. #: cp/name-lookup.c:799 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid redeclaration of %q+D" -msgstr "%qD esitelty staattisesti sisäkkäin" +msgstr "%q+D:n virheellinen uudelleenesittely" #: cp/name-lookup.c:800 #, gcc-internal-format msgid "as %qD" -msgstr "" +msgstr "nimellä %qD" #: cp/name-lookup.c:841 cp/name-lookup.c:857 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "declaration of %q#D with C language linkage" -msgstr "%J%qD esitelty uudelleen ilman linkitystä" +msgstr "%q#D:n esittely C-kielen linkityksellä" #: cp/name-lookup.c:847 #, fuzzy, gcc-internal-format @@ -32356,7 +32011,6 @@ msgstr "%qD esitelty extern-avainsanalla sisäkkäin" #: cp/name-lookup.c:1047 #, fuzzy, gcc-internal-format -#| msgid "nested extern declaration of %qD" msgid "extern declaration of %q#D doesn%'t match" msgstr "%qD esitelty extern-avainsanalla sisäkkäin" @@ -32417,19 +32071,19 @@ msgid " using obsolete binding at %q+D" msgstr "" #: cp/name-lookup.c:1367 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "(if you use %<-fpermissive%> G++ will accept your code)" -msgstr "(G++ hyväksyy koodin -fpermissive-valitsimella)" +msgstr "(G++ hyväksyy koodin %<-fpermissive%>-valitsimella)" #: cp/name-lookup.c:1422 #, gcc-internal-format msgid "%s %s(%E) %p %d\n" -msgstr "" +msgstr "%s %s(%E) %p %d\n" #: cp/name-lookup.c:1425 #, gcc-internal-format msgid "%s %s %p %d\n" -msgstr "" +msgstr "%s %s %p %d\n" #: cp/name-lookup.c:2254 #, gcc-internal-format @@ -32456,7 +32110,7 @@ msgstr "" #: cp/name-lookup.c:2385 cp/name-lookup.c:2410 #, gcc-internal-format msgid "%qT is not a namespace" -msgstr "" +msgstr "%qT ei ole nimiavaruus" #. 7.3.3/5 #. A using-declaration shall not name a template-id. @@ -32482,100 +32136,99 @@ msgstr "" msgid "%qD not declared" msgstr "" -#: cp/name-lookup.c:3218 +#: cp/name-lookup.c:3211 #, gcc-internal-format msgid "using-declaration for non-member at class scope" msgstr "" -#: cp/name-lookup.c:3225 +#: cp/name-lookup.c:3218 #, gcc-internal-format msgid "%<%T::%D%> names destructor" msgstr "" -#: cp/name-lookup.c:3236 +#: cp/name-lookup.c:3231 #, gcc-internal-format msgid "%<%T::%D%> names constructor in %qT" msgstr "" -#: cp/name-lookup.c:3287 +#: cp/name-lookup.c:3282 #, gcc-internal-format msgid "no members matching %<%T::%D%> in %q#T" msgstr "" -#: cp/name-lookup.c:3374 +#: cp/name-lookup.c:3369 #, gcc-internal-format msgid "declaration of %qD not in a namespace surrounding %qD" msgstr "" -#: cp/name-lookup.c:3382 +#: cp/name-lookup.c:3377 #, fuzzy, gcc-internal-format msgid "explicit qualification in declaration of %qD" msgstr "%qD esitelty staattisesti sisäkkäin" -#: cp/name-lookup.c:3465 +#: cp/name-lookup.c:3460 #, gcc-internal-format msgid "%qD should have been declared inside %qD" msgstr "" -#: cp/name-lookup.c:3509 +#: cp/name-lookup.c:3504 #, fuzzy, gcc-internal-format msgid "%qD attribute requires a single NTBS argument" msgstr "%qs-attribuutti tarvitsee prototyyppejä, joilla nimettyjä argumentteja" -#: cp/name-lookup.c:3516 +#: cp/name-lookup.c:3511 #, gcc-internal-format msgid "%qD attribute is meaningless since members of the anonymous namespace get local symbols" msgstr "" -#: cp/name-lookup.c:3524 cp/name-lookup.c:3936 +#: cp/name-lookup.c:3519 cp/name-lookup.c:3931 #, gcc-internal-format msgid "%qD attribute directive ignored" msgstr "" -#: cp/name-lookup.c:3588 +#: cp/name-lookup.c:3583 #, gcc-internal-format msgid "namespace alias %qD not allowed here, assuming %qD" msgstr "" -#: cp/name-lookup.c:3924 +#: cp/name-lookup.c:3919 #, gcc-internal-format msgid "strong using only meaningful at namespace scope" msgstr "" -#: cp/name-lookup.c:3928 +#: cp/name-lookup.c:3923 #, gcc-internal-format msgid "current namespace %qD does not enclose strongly used namespace %qD" msgstr "" -#: cp/name-lookup.c:4267 +#: cp/name-lookup.c:4262 #, gcc-internal-format msgid "maximum limit of %d namespaces searched for %qE" msgstr "" -#: cp/name-lookup.c:4277 +#: cp/name-lookup.c:4272 #, gcc-internal-format msgid "suggested alternative:" msgid_plural "suggested alternatives:" -msgstr[0] "" -msgstr[1] "" +msgstr[0] "ehdotettu vaihtoehto:" +msgstr[1] "ehdotetut vaihtoehdot:" -#: cp/name-lookup.c:4281 +#: cp/name-lookup.c:4276 #, fuzzy, gcc-internal-format -#| msgid " %q+#D" msgid " %qE" msgstr " %q+#D" -#: cp/name-lookup.c:5551 +#: cp/name-lookup.c:5546 #, gcc-internal-format msgid "argument dependent lookup finds %q+D" msgstr "" -#: cp/name-lookup.c:6088 +#: cp/name-lookup.c:6083 #, gcc-internal-format msgid "XXX entering pop_everything ()\n" msgstr "" -#: cp/name-lookup.c:6097 +#: cp/name-lookup.c:6092 #, gcc-internal-format msgid "XXX leaving pop_everything ()\n" msgstr "" @@ -32587,24 +32240,23 @@ msgstr "" #: cp/parser.c:746 #, fuzzy, gcc-internal-format -#| msgid "identifier %qE conflicts with C++ keyword" msgid "identifier %qE is a keyword in C++11" msgstr "tunniste %qE on ristiriidassa C++:n varatun sanan kanssa" #: cp/parser.c:2402 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<#pragma%> is not allowed here" -msgstr "väärinmuodostettu #pragma GCC pch_preprocess, jätetään huomiotta" +msgstr "%<#pragma%> ei ole sallittu täällä" #: cp/parser.c:2433 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<%E::%E%> has not been declared" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%<%E::%E%> on esittelemättä" #: cp/parser.c:2436 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<::%E%> has not been declared" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%<::%E%> on esittelemättä" #: cp/parser.c:2439 #, fuzzy, gcc-internal-format @@ -32612,65 +32264,59 @@ msgid "request for member %qE in non-class type %qT" msgstr "pyyntö jäsenen %qs käsittelyyn jossain, joka ei ole tietue tai unioni" #: cp/parser.c:2442 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<%T::%E%> has not been declared" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%<%T::%E%> on esittelemättä" #: cp/parser.c:2445 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE has not been declared" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qE on esittelemättä" #: cp/parser.c:2452 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<%E::%E%> is not a type" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%<%E::%E%> ei ole tyyppi" #: cp/parser.c:2456 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a class or namespace" +#, gcc-internal-format msgid "%<%E::%E%> is not a class or namespace" -msgstr "%qT ei ole luokka eikä nimiavaruus" +msgstr "%<%E::%E%> ei ole luokka eikä nimiavaruus" #: cp/parser.c:2461 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a class or namespace" +#, gcc-internal-format msgid "%<%E::%E%> is not a class, namespace, or enumeration" -msgstr "%qT ei ole luokka eikä nimiavaruus" +msgstr "%<%E::%E%> ei ole luokka, nimiavaruus eikä lueteltu tyyppi" #: cp/parser.c:2474 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<::%E%> is not a type" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%<::%E%> ei ole tyyppi" #: cp/parser.c:2477 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a class or namespace" +#, gcc-internal-format msgid "%<::%E%> is not a class or namespace" -msgstr "%qT ei ole luokka eikä nimiavaruus" +msgstr "%<::%E%> ei ole luokka eikä nimiavaruus" #: cp/parser.c:2481 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a class or namespace" +#, gcc-internal-format msgid "%<::%E%> is not a class, namespace, or enumeration" -msgstr "%qT ei ole luokka eikä nimiavaruus" +msgstr "%<::%E%> ei ole luokka, nimiavaruus eikä lueteltu tyyppi" #: cp/parser.c:2493 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE is not a type" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qE ei ole tyyppi" #: cp/parser.c:2496 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a class or namespace" +#, gcc-internal-format msgid "%qE is not a class or namespace" -msgstr "%qT ei ole luokka eikä nimiavaruus" +msgstr "%qE ei ole luokka eikä nimiavaruus" #: cp/parser.c:2500 -#, fuzzy, gcc-internal-format -#| msgid "%qT is not a class or namespace" +#, gcc-internal-format msgid "%qE is not a class, namespace, or enumeration" -msgstr "%qT ei ole luokka eikä nimiavaruus" +msgstr "%qE ei ole luokka, nimiavaruus eikä lueteltu tyyppi" #: cp/parser.c:2563 #, gcc-internal-format @@ -32685,7 +32331,7 @@ msgstr "(mahdollisesti %qT:n määrittelyn perästä puuttuu puolipiste)" #: cp/parser.c:2587 cp/parser.c:5124 cp/pt.c:7090 #, gcc-internal-format msgid "%qT is not a template" -msgstr "" +msgstr "%qT ei ole malli" #: cp/parser.c:2591 #, fuzzy, gcc-internal-format @@ -32693,9 +32339,9 @@ msgid "%qE is not a class template" msgstr "%J%qD on tavallisesti ei-staattinen funktio" #: cp/parser.c:2593 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE is not a template" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qE ei ole malli" #: cp/parser.c:2596 #, fuzzy, gcc-internal-format @@ -32704,36 +32350,31 @@ msgstr "%J%qD on tavallisesti ei-staattinen funktio" #: cp/parser.c:2629 #, fuzzy, gcc-internal-format -#| msgid "floating point overflow in expression" msgid "floating-point literal cannot appear in a constant-expression" msgstr "liukulukuylivuoto lausekkeessa" -#: cp/parser.c:2633 cp/pt.c:13527 +#: cp/parser.c:2633 cp/pt.c:13522 #, gcc-internal-format msgid "a cast to a type other than an integral or enumeration type cannot appear in a constant-expression" msgstr "" #: cp/parser.c:2638 #, fuzzy, gcc-internal-format -#| msgid "size of array is not an integral constant-expression" msgid "%<typeid%> operator cannot appear in a constant-expression" msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke" #: cp/parser.c:2642 #, fuzzy, gcc-internal-format -#| msgid "size of array is not an integral constant-expression" msgid "non-constant compound literals cannot appear in a constant-expression" msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke" #: cp/parser.c:2646 #, fuzzy, gcc-internal-format -#| msgid "size of array is not an integral constant-expression" msgid "a function call cannot appear in a constant-expression" msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke" #: cp/parser.c:2650 #, fuzzy, gcc-internal-format -#| msgid "initializer element is not a constant expression" msgid "an increment cannot appear in a constant-expression" msgstr "alustinalkio ei ole vakiolauseke" @@ -32744,43 +32385,36 @@ msgstr "ylivuoto vakiolausekkeessa" #: cp/parser.c:2658 #, fuzzy, gcc-internal-format -#| msgid "size of array is not an integral constant-expression" msgid "an array reference cannot appear in a constant-expression" msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke" #: cp/parser.c:2662 #, fuzzy, gcc-internal-format -#| msgid "case label is not an integer constant expression" msgid "the address of a label cannot appear in a constant-expression" msgstr "case-nimiö ei ole kokonaislukutyyppinen vakiolauseke" #: cp/parser.c:2666 #, fuzzy, gcc-internal-format -#| msgid "case label is not an integer constant expression" msgid "calls to overloaded operators cannot appear in a constant-expression" msgstr "case-nimiö ei ole kokonaislukutyyppinen vakiolauseke" #: cp/parser.c:2670 #, fuzzy, gcc-internal-format -#| msgid "size of array is not an integral constant-expression" msgid "an assignment cannot appear in a constant-expression" msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke" #: cp/parser.c:2673 #, fuzzy, gcc-internal-format -#| msgid "size of array is not an integral constant-expression" msgid "a comma operator cannot appear in a constant-expression" msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke" #: cp/parser.c:2677 #, fuzzy, gcc-internal-format -#| msgid "size of array is not an integral constant-expression" msgid "a call to a constructor cannot appear in a constant-expression" msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke" #: cp/parser.c:2681 #, fuzzy, gcc-internal-format -#| msgid "size of array is not an integral constant-expression" msgid "a transaction expression cannot appear in a constant-expression" msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke" @@ -32792,12 +32426,12 @@ msgstr "ylivuoto vakiolausekkeessa" #: cp/parser.c:2756 #, gcc-internal-format msgid "invalid use of template-name %qE without an argument list" -msgstr "" +msgstr "mallinimen %qE virheellinen käyttö ilman argumenttiluetteloa" #: cp/parser.c:2759 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid use of destructor %qD as a type" -msgstr "epäkelpo %<restrict%>-avainsanan käyttö" +msgstr "virheellinen hajottimen %qD käyttö tyyppinä" #. Something like 'unsigned A a;' #: cp/parser.c:2762 @@ -32807,9 +32441,9 @@ msgstr "" #. Issue an error message. #: cp/parser.c:2766 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE does not name a type" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qE ei nimeä tyyppiä" #: cp/parser.c:2775 #, gcc-internal-format @@ -32819,23 +32453,23 @@ msgstr "" #: cp/parser.c:2802 #, gcc-internal-format msgid "(perhaps %<typename %T::%E%> was intended)" -msgstr "" +msgstr "(ehkä tarkoitettiin %<typename %T::%E%>)" #: cp/parser.c:2817 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE in namespace %qE does not name a type" -msgstr "luokalla %qT ei ole %qD-nimistä kenttää" +msgstr "%qE nimiavaruudessa %qE ei nimeä tyyppiä" #. A<T>::A<T>() #: cp/parser.c:2823 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<%T::%E%> names the constructor, not the type" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%<%T::%E%> nimeää muodostimen, ei tyyppiä" #: cp/parser.c:2826 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "and %qT has no template constructors" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "ja kohteella %qT:lla ei ole mallimuodostimia" #: cp/parser.c:2831 #, gcc-internal-format @@ -32849,7 +32483,6 @@ msgstr "luokalla %qT ei ole %qD-nimistä kenttää" #: cp/parser.c:3394 #, fuzzy, gcc-internal-format -#| msgid "expected string literal" msgid "expected string-literal" msgstr "odotettiin merkkijonoliteraalia" @@ -32860,7 +32493,6 @@ msgstr "" #: cp/parser.c:3499 #, fuzzy, gcc-internal-format -#| msgid "within this context" msgid "a wide string is invalid in this context" msgstr "tässä yhteydessä" @@ -32871,19 +32503,16 @@ msgstr "" #: cp/parser.c:3682 #, fuzzy, gcc-internal-format -#| msgid "floating constant exceeds range of %qT" msgid "integer literal exceeds range of %qT type" msgstr "liukulukuvakio ylittää %qT:n arvoalueen" #: cp/parser.c:3688 #, fuzzy, gcc-internal-format -#| msgid "floating constant exceeds range of %qT" msgid "floating literal exceeds range of %qT type" msgstr "liukulukuvakio ylittää %qT:n arvoalueen" #: cp/parser.c:3692 #, fuzzy, gcc-internal-format -#| msgid "floating constant truncated to zero" msgid "floating literal truncated to zero" msgstr "liukulukuvakio katkaistu nollaksi" @@ -32904,7 +32533,6 @@ msgstr "" #: cp/parser.c:3831 cp/parser.c:10509 #, fuzzy, gcc-internal-format -#| msgid "empty declaration" msgid "expected declaration" msgstr "tyhjä esittely" @@ -32929,9 +32557,9 @@ msgid "expected primary-expression" msgstr "vektoriylivuoto lausekkeessa" #: cp/parser.c:4127 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<this%> may not be used in this context" -msgstr "%qD on esittelemättä tällä näkyvyysalueella" +msgstr "<this%>-sanaa ei voi käyttää tässä yhteydessä" #: cp/parser.c:4244 #, fuzzy, gcc-internal-format @@ -32939,9 +32567,9 @@ msgid "a template declaration cannot appear at block scope" msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa" #: cp/parser.c:4378 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "local variable %qD may not appear in this context" -msgstr "%qD on esittelemättä tällä näkyvyysalueella" +msgstr "paikallinen muuttuja %qD ei voi esiintyä tässä yhteydessä" #: cp/parser.c:4543 #, fuzzy, gcc-internal-format @@ -32954,9 +32582,9 @@ msgid "scope %qT before %<~%> is not a class-name" msgstr "%qT ei ole luokka tai nimiavaruus" #: cp/parser.c:4797 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "declaration of %<~%T%> as member of %qT" -msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" +msgstr "%<~%T%>:n esittely %qT:n jäsenenä" #: cp/parser.c:4812 #, gcc-internal-format @@ -32968,7 +32596,7 @@ msgstr "" msgid "literal operator suffixes not preceded by %<_%> are reserved for future standardization" msgstr "" -#: cp/parser.c:4857 cp/parser.c:16496 +#: cp/parser.c:4857 cp/parser.c:16498 #, gcc-internal-format msgid "expected unqualified-id" msgstr "" @@ -32984,9 +32612,9 @@ msgid "decltype evaluates to %qT, which is not a class or enumeration type" msgstr "%Jcase-arvo %qs ei ole luetellussa tyypissä" #: cp/parser.c:5125 cp/typeck.c:2531 cp/typeck.c:2551 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qD is not a template" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qD ei ole malli" #: cp/parser.c:5203 #, fuzzy, gcc-internal-format @@ -32995,13 +32623,11 @@ msgstr "useita tallennuspaikkoja esittelymääritteissä" #: cp/parser.c:5400 cp/parser.c:7183 #, fuzzy, gcc-internal-format -#| msgid "new types may not be defined in a return type" msgid "types may not be defined in casts" msgstr "uusia tyyppejä ei voi määritellä paluutyypissä" #: cp/parser.c:5460 #, fuzzy, gcc-internal-format -#| msgid "new types may not be defined in a return type" msgid "types may not be defined in a %<typeid%> expression" msgstr "uusia tyyppejä ei voi määritellä paluutyypissä" @@ -33018,19 +32644,19 @@ msgid "two consecutive %<[%> shall only introduce an attribute" msgstr "" #: cp/parser.c:5999 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE does not have class type" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qE:lla ei ole luokkatyyppiä" #: cp/parser.c:6088 cp/typeck.c:2440 #, gcc-internal-format msgid "invalid use of %qD" -msgstr "" +msgstr "%qD:n virheellinen käyttö" #: cp/parser.c:6097 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<%D::%D%> is not a class member" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%<%D::%D%> ei ole luokan jäsen" #: cp/parser.c:6359 #, gcc-internal-format @@ -33039,19 +32665,16 @@ msgstr "" #: cp/parser.c:6455 #, fuzzy, gcc-internal-format -#| msgid "ISO C does not allow extra %<;%> outside of a function" msgid "ISO C++ does not allow %<alignof%> with a non-type" -msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktioiden ulkopuolella" +msgstr "ISO C ei salli ylimääräisiä %<;%>-merkkejä funktion ulkopuolella" #: cp/parser.c:6540 #, fuzzy, gcc-internal-format -#| msgid "new types may not be defined in a return type" msgid "types may not be defined in %<noexcept%> expressions" msgstr "uusia tyyppejä ei voi määritellä paluutyypissä" #: cp/parser.c:6769 #, fuzzy, gcc-internal-format -#| msgid "new types may not be defined in a return type" msgid "types may not be defined in a new-expression" msgstr "uusia tyyppejä ei voi määritellä paluutyypissä" @@ -33067,7 +32690,6 @@ msgstr "" #: cp/parser.c:6863 #, fuzzy, gcc-internal-format -#| msgid "new types may not be defined in a return type" msgid "types may not be defined in a new-type-id" msgstr "uusia tyyppejä ei voi määritellä paluutyypissä" @@ -33079,7 +32701,7 @@ msgstr "" #: cp/parser.c:7247 #, gcc-internal-format msgid "use of old-style cast" -msgstr "" +msgstr "vanhanmallisen tyyppimuunnoksen käyttö" #: cp/parser.c:7382 #, gcc-internal-format @@ -33087,9 +32709,9 @@ msgid "%<>>%> operator is treated as two right angle brackets in C++11" msgstr "" #: cp/parser.c:7385 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "suggest parentheses around %<>>%> expression" -msgstr "sulkumerkkien käyttö &&:n ympärillä on suositeltavaa ||:n sisällä" +msgstr "suosittellaan sulkumerkkejä %<>>%>-lausekkeen ympärille" #: cp/parser.c:7531 #, gcc-internal-format @@ -33118,13 +32740,11 @@ msgstr "" #: cp/parser.c:8373 #, fuzzy, gcc-internal-format -#| msgid "increment of read-only variable %qD" msgid "capture of non-variable %qD " msgstr "kirjoitussuojatun muuttujan %qD kasvatus" #: cp/parser.c:8375 cp/parser.c:8384 #, fuzzy, gcc-internal-format -#| msgid "%q+D declared here" msgid "%q+#D declared here" msgstr "%q+D esitelty täällä" @@ -33144,13 +32764,12 @@ msgid "explicit by-reference capture of %qD redundant with by-reference capture msgstr "" #: cp/parser.c:8470 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "default argument specified for lambda parameter" -msgstr "tallennusluokka annettu parametrille %qs" +msgstr "oletusargumentti määritelty lambda-parametrille" #: cp/parser.c:8885 #, fuzzy, gcc-internal-format -#| msgid "attributes in parameter array declarator ignored" msgid "attributes at the beginning of statement are ignored" msgstr "parametritaulukon esittelijän attribuutit jätetään huomiotta" @@ -33170,23 +32789,22 @@ msgid "need %<typename%> before %qE because %qT is a dependent scope" msgstr "" #: cp/parser.c:9037 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%<%T::%D%> names the constructor, not the type" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%<%T::%D%> nimeää muodostimen, ei tyyppiä" #: cp/parser.c:9086 #, gcc-internal-format msgid "compound-statement in constexpr function" msgstr "" -#: cp/parser.c:9298 cp/parser.c:23016 +#: cp/parser.c:9298 cp/parser.c:23020 #, fuzzy, gcc-internal-format msgid "expected selection-statement" msgstr "tyhjä esittely" #: cp/parser.c:9331 #, fuzzy, gcc-internal-format -#| msgid "new types may not be defined in a return type" msgid "types may not be defined in conditions" msgstr "uusia tyyppejä ei voi määritellä paluutyypissä" @@ -33210,14 +32828,13 @@ msgstr "" msgid "inconsistent begin/end types in range-based %<for%> statement: %qT and %qT" msgstr "" -#: cp/parser.c:9889 cp/parser.c:23019 +#: cp/parser.c:9889 cp/parser.c:23023 #, fuzzy, gcc-internal-format msgid "expected iteration-statement" msgstr "tyhjä esittely" #: cp/parser.c:9936 #, fuzzy, gcc-internal-format -#| msgid "%<for%> loop initial declarations are only allowed in C99 mode" msgid "range-based %<for%> loops are not allowed in C++98 mode" msgstr "%<for%>-silmukan alkuesittelyt ovat sallittuja vain C99-tilassa" @@ -33225,14 +32842,14 @@ msgstr "%<for%>-silmukan alkuesittelyt ovat sallittuja vain C99-tilassa" #: cp/parser.c:10058 #, gcc-internal-format msgid "ISO C++ forbids computed gotos" -msgstr "" +msgstr "ISO C++ kieltää lasketut goto-käskyt" -#: cp/parser.c:10071 cp/parser.c:23022 +#: cp/parser.c:10071 cp/parser.c:23026 #, fuzzy, gcc-internal-format msgid "expected jump-statement" msgstr "tyhjä esittely" -#: cp/parser.c:10203 cp/parser.c:19157 +#: cp/parser.c:10203 cp/parser.c:19161 #, gcc-internal-format msgid "extra %<;%>" msgstr "ylimääräinen %<;%>" @@ -33240,7 +32857,7 @@ msgstr "ylimääräinen %<;%>" #: cp/parser.c:10436 #, gcc-internal-format msgid "%<__label__%> not at the beginning of a block" -msgstr "" +msgstr "%<__label__%> ei ole lohkon alussa" #: cp/parser.c:10587 #, gcc-internal-format @@ -33265,14 +32882,14 @@ msgid "decl-specifier invalid in condition" msgstr "%Jvanhanmallinen funktiomäärittely" #: cp/parser.c:10966 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "class definition may not be declared a friend" -msgstr "funktion määrittely esitelty %<register%>:ksi" +msgstr "luokkamäärittelyä ei voi esitellä ystäväksi" -#: cp/parser.c:11034 cp/parser.c:19551 +#: cp/parser.c:11034 cp/parser.c:19555 #, gcc-internal-format msgid "templates may not be %<virtual%>" -msgstr "" +msgstr "mallit eivät voi olla virtuaalisia" #: cp/parser.c:11073 #, fuzzy, gcc-internal-format @@ -33281,14 +32898,13 @@ msgstr "rajat määrittelemättömän taulukon epäkelpo käyttö" #: cp/parser.c:11208 #, fuzzy, gcc-internal-format -#| msgid "new types may not be defined in a return type" msgid "types may not be defined in %<decltype%> expressions" msgstr "uusia tyyppejä ei voi määritellä paluutyypissä" #: cp/parser.c:11467 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid use of %<auto%> in conversion operator" -msgstr "epäkelpo %<restrict%>-avainsanan käyttö" +msgstr "virheellinen %<auto%>:n käyttö muunnosoperaattorissa" #: cp/parser.c:11471 #, fuzzy, gcc-internal-format @@ -33301,13 +32917,12 @@ msgid "only constructors take member initializers" msgstr "skalaarialustimen ympärillä on aaltosulkeet" #: cp/parser.c:11582 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "cannot expand initializer for member %<%D%>" -msgstr "alustamaton const-jäsen %qD" +msgstr "ei voi laajentaa alustinta jäsenelle %<%D%>" #: cp/parser.c:11594 #, fuzzy, gcc-internal-format -#| msgid "static declaration of %q+D follows non-static declaration" msgid "mem-initializer for %qD follows constructor delegation" msgstr "%q+D esitelty staattisena, edellinen esittely ei-staattinen" @@ -33333,7 +32948,6 @@ msgstr "leveä merkkijonovakio %<asm%>-lauseessa" #: cp/parser.c:12061 #, fuzzy, gcc-internal-format -#| msgid "expected string literal" msgid "expected suffix identifier" msgstr "odotettiin merkkijonoliteraalia" @@ -33353,12 +32967,12 @@ msgstr "vektoriylivuoto lausekkeessa" msgid "keyword %<export%> not implemented, and will be ignored" msgstr "" -#: cp/parser.c:12317 cp/parser.c:12415 cp/parser.c:12522 cp/parser.c:17611 +#: cp/parser.c:12317 cp/parser.c:12415 cp/parser.c:12522 cp/parser.c:17613 #, fuzzy, gcc-internal-format msgid "template parameter pack %qD cannot have a default argument" msgstr "strftime-muotoilut eivät voi muotoilla argumentteja" -#: cp/parser.c:12321 cp/parser.c:17619 +#: cp/parser.c:12321 cp/parser.c:17621 #, fuzzy, gcc-internal-format msgid "template parameter pack cannot have a default argument" msgstr "strftime-muotoilut eivät voi muotoilla argumentteja" @@ -33373,10 +32987,10 @@ msgstr "strftime-muotoilut eivät voi muotoilla argumentteja" msgid "expected template-id" msgstr "%J%qD on tavallisesti ei-staattinen funktio" -#: cp/parser.c:12658 cp/parser.c:22980 +#: cp/parser.c:12658 cp/parser.c:22984 #, fuzzy, gcc-internal-format msgid "expected %<<%>" -msgstr "käytetty %<__thread%> ennen %<extern%>:a" +msgstr "odotettiin %<<%>" #: cp/parser.c:12665 #, gcc-internal-format @@ -33396,14 +33010,13 @@ msgstr "(G++ hyväksyy koodin -fpermissive-valitsimella)" #: cp/parser.c:12750 #, gcc-internal-format msgid "parse error in template argument list" -msgstr "" +msgstr "jäsennysvirhe malliargumenttien luettelossa" #. The name does not name a template. #: cp/parser.c:12819 cp/parser.c:12934 cp/parser.c:13146 #, fuzzy, gcc-internal-format -#| msgid "expected class name" msgid "expected template-name" -msgstr "odotettiin luokan nimeä" +msgstr "odotettiin mallinimeä" #. Explain what went wrong. #: cp/parser.c:12865 @@ -33428,7 +33041,6 @@ msgstr "liian paljon argumentteja funktiolle %qs" #: cp/parser.c:13256 #, fuzzy, gcc-internal-format -#| msgid "invalid IACC argument" msgid "invalid non-type template argument" msgstr "virheellinen IACC-argumentti" @@ -33459,7 +33071,6 @@ msgstr "vektoriylivuoto lausekkeessa" #: cp/parser.c:13930 #, fuzzy, gcc-internal-format -#| msgid "expected class name" msgid "expected type-name" msgstr "odotettiin luokan nimeä" @@ -33468,167 +33079,163 @@ msgstr "odotettiin luokan nimeä" msgid "elaborated-type-specifier for a scoped enum must not use the %<%D%> keyword" msgstr "" -#: cp/parser.c:14355 +#: cp/parser.c:14357 #, gcc-internal-format msgid "declaration %qD does not declare anything" msgstr "esittely %qD ei esittele mitään" -#: cp/parser.c:14441 +#: cp/parser.c:14443 #, fuzzy, gcc-internal-format msgid "attributes ignored on uninstantiated type" msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille" -#: cp/parser.c:14445 +#: cp/parser.c:14447 #, fuzzy, gcc-internal-format msgid "attributes ignored on template instantiation" msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille" -#: cp/parser.c:14450 +#: cp/parser.c:14452 #, gcc-internal-format msgid "attributes ignored on elaborated-type-specifier that is not a forward declaration" msgstr "" -#: cp/parser.c:14584 +#: cp/parser.c:14586 #, fuzzy, gcc-internal-format msgid "%qD is an enumeration template" msgstr "%J%qD on tavallisesti ei-staattinen funktio" -#: cp/parser.c:14592 +#: cp/parser.c:14594 #, fuzzy, gcc-internal-format -#| msgid "%qD is not a namespace-name" msgid "%qD is not an enumerator-name" msgstr "%qD ei ole nimiavaruuden nimi" -#: cp/parser.c:14655 +#: cp/parser.c:14657 #, fuzzy, gcc-internal-format msgid "expected %<;%> or %<{%>" msgstr "käytetty %<__thread%> ennen %<extern%>:a" -#: cp/parser.c:14703 +#: cp/parser.c:14705 #, fuzzy, gcc-internal-format msgid "cannot add an enumerator list to a template instantiation" msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille" -#: cp/parser.c:14712 cp/parser.c:18714 +#: cp/parser.c:14714 cp/parser.c:18718 #, fuzzy, gcc-internal-format msgid "declaration of %qD in namespace %qD which does not enclose %qD" msgstr "%J%qD:n edellinen esittely oli täällä" -#: cp/parser.c:14717 cp/parser.c:18719 +#: cp/parser.c:14719 cp/parser.c:18723 #, fuzzy, gcc-internal-format msgid "declaration of %qD in %qD which does not enclose %qD" msgstr "%J%qD:n edellinen esittely oli täällä" -#: cp/parser.c:14740 +#: cp/parser.c:14742 #, gcc-internal-format msgid "multiple definition of %q#T" msgstr "" -#: cp/parser.c:14767 +#: cp/parser.c:14769 #, gcc-internal-format msgid "opaque-enum-specifier without name" msgstr "" -#: cp/parser.c:14770 +#: cp/parser.c:14772 #, gcc-internal-format msgid "opaque-enum-specifier must use a simple identifier" msgstr "" -#: cp/parser.c:14946 +#: cp/parser.c:14948 #, gcc-internal-format msgid "%qD is not a namespace-name" msgstr "%qD ei ole nimiavaruuden nimi" -#: cp/parser.c:14947 +#: cp/parser.c:14949 #, fuzzy, gcc-internal-format -#| msgid "expected class name" msgid "expected namespace-name" msgstr "odotettiin luokan nimeä" -#: cp/parser.c:15072 +#: cp/parser.c:15074 #, gcc-internal-format msgid "%<namespace%> definition is not allowed here" msgstr "%<namespace%>-määrittely ei ole sallittu täällä" -#: cp/parser.c:15218 +#: cp/parser.c:15220 #, gcc-internal-format msgid "a template-id may not appear in a using-declaration" msgstr "" -#: cp/parser.c:15258 +#: cp/parser.c:15260 #, gcc-internal-format msgid "access declarations are deprecated in favour of using-declarations; suggestion: add the %<using%> keyword" msgstr "" -#: cp/parser.c:15323 +#: cp/parser.c:15325 #, fuzzy, gcc-internal-format -#| msgid "new types may not be defined in a return type" msgid "types may not be defined in alias template declarations" msgstr "uusia tyyppejä ei voi määritellä paluutyypissä" -#: cp/parser.c:15787 +#: cp/parser.c:15789 #, fuzzy, gcc-internal-format -#| msgid "%<namespace%> definition is not allowed here" msgid "a function-definition is not allowed here" msgstr "%<namespace%>-määrittely ei ole sallittu täällä" -#: cp/parser.c:15799 +#: cp/parser.c:15801 #, fuzzy, gcc-internal-format msgid "an asm-specification is not allowed on a function-definition" msgstr "%Jvanhanmallinen funktiomäärittely" -#: cp/parser.c:15803 +#: cp/parser.c:15805 #, fuzzy, gcc-internal-format msgid "attributes are not allowed on a function-definition" msgstr "%Jvanhanmallinen funktiomäärittely" -#: cp/parser.c:15840 +#: cp/parser.c:15842 #, gcc-internal-format msgid "expected constructor, destructor, or type conversion" msgstr "" #. Anything else is an error. -#: cp/parser.c:15875 cp/parser.c:17782 +#: cp/parser.c:15877 cp/parser.c:17784 #, fuzzy, gcc-internal-format msgid "expected initializer" msgstr "epäkelpo alustin" -#: cp/parser.c:15895 +#: cp/parser.c:15897 #, fuzzy, gcc-internal-format msgid "invalid type in declaration" msgstr "Varoita implisiittisistä funktioesittelyistä" -#: cp/parser.c:15971 +#: cp/parser.c:15973 #, fuzzy, gcc-internal-format msgid "initializer provided for function" msgstr "indeksoitu arvo on osoitin funktioon" -#: cp/parser.c:16005 +#: cp/parser.c:16007 #, gcc-internal-format msgid "attributes after parenthesized initializer ignored" msgstr "" -#: cp/parser.c:16416 +#: cp/parser.c:16418 #, gcc-internal-format msgid "array bound is not an integer constant" msgstr "" -#: cp/parser.c:16542 +#: cp/parser.c:16544 #, fuzzy, gcc-internal-format msgid "cannot define member of dependent typedef %qT" msgstr "parametrilla %P on vaillinainen tyyppi %qT" -#: cp/parser.c:16546 -#, fuzzy, gcc-internal-format +#: cp/parser.c:16548 +#, gcc-internal-format msgid "%<%T::%E%> is not a type" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%<%T::%E%> ei ole tyyppi" -#: cp/parser.c:16574 -#, fuzzy, gcc-internal-format +#: cp/parser.c:16576 +#, gcc-internal-format msgid "invalid use of constructor as a template" -msgstr "epäkelpo %<restrict%>-avainsanan käyttö" +msgstr "muodostimen virheellinen käyttö mallina" -#: cp/parser.c:16576 +#: cp/parser.c:16578 #, gcc-internal-format msgid "use %<%T::%D%> instead of %<%T::%D%> to name the constructor in a qualified name" msgstr "" @@ -33637,268 +33244,262 @@ msgstr "" #. here because we do not have enough #. information about its original syntactic #. form. -#: cp/parser.c:16593 +#: cp/parser.c:16595 #, fuzzy, gcc-internal-format msgid "invalid declarator" msgstr "Varoita implisiittisistä funktioesittelyistä" -#: cp/parser.c:16660 +#: cp/parser.c:16662 #, fuzzy, gcc-internal-format msgid "expected declarator" msgstr "useita tallennuspaikkoja esittelymääritteissä" -#: cp/parser.c:16763 +#: cp/parser.c:16765 #, gcc-internal-format msgid "%qD is a namespace" msgstr "%qD on nimiavaruus" -#: cp/parser.c:16765 +#: cp/parser.c:16767 #, fuzzy, gcc-internal-format msgid "cannot form pointer to member of non-class %q#T" msgstr "parametrilla %P on vaillinainen tyyppi %qT" -#: cp/parser.c:16786 +#: cp/parser.c:16788 #, fuzzy, gcc-internal-format msgid "expected ptr-operator" msgstr "vektoriylivuoto lausekkeessa" -#: cp/parser.c:16845 -#, fuzzy, gcc-internal-format +#: cp/parser.c:16847 +#, gcc-internal-format msgid "duplicate cv-qualifier" -msgstr "case-arvon kaksoiskappale" +msgstr "cv-määreen kaksoiskappale" -#: cp/parser.c:16903 +#: cp/parser.c:16905 #, fuzzy, gcc-internal-format msgid "duplicate virt-specifier" msgstr "case-arvon kaksoiskappale" -#: cp/parser.c:17065 cp/typeck2.c:448 cp/typeck2.c:1685 +#: cp/parser.c:17067 cp/typeck2.c:448 cp/typeck2.c:1685 #, fuzzy, gcc-internal-format msgid "invalid use of %<auto%>" msgstr "epäkelpo %<restrict%>-avainsanan käyttö" -#: cp/parser.c:17084 +#: cp/parser.c:17086 #, fuzzy, gcc-internal-format -#| msgid "new types may not be defined in a return type" msgid "types may not be defined in template arguments" msgstr "uusia tyyppejä ei voi määritellä paluutyypissä" -#: cp/parser.c:17165 +#: cp/parser.c:17167 #, fuzzy, gcc-internal-format msgid "expected type-specifier" msgstr "taulukon indeksin tyyppi on %<char%>" -#: cp/parser.c:17407 -#, fuzzy, gcc-internal-format +#: cp/parser.c:17409 +#, gcc-internal-format msgid "expected %<,%> or %<...%>" -msgstr "käytetty %<__thread%> ennen %<extern%>:a" +msgstr "odotettiin %<,%> tai %<...%>" -#: cp/parser.c:17464 +#: cp/parser.c:17466 #, fuzzy, gcc-internal-format -#| msgid "new types may not be defined in a return type" msgid "types may not be defined in parameter types" msgstr "uusia tyyppejä ei voi määritellä paluutyypissä" -#: cp/parser.c:17590 +#: cp/parser.c:17592 #, gcc-internal-format msgid "deprecated use of default argument for parameter of non-function" msgstr "" -#: cp/parser.c:17594 +#: cp/parser.c:17596 #, gcc-internal-format msgid "default arguments are only permitted for function parameters" msgstr "" -#: cp/parser.c:17613 +#: cp/parser.c:17615 #, fuzzy, gcc-internal-format msgid "parameter pack %qD cannot have a default argument" msgstr "strftime-muotoilut eivät voi muotoilla argumentteja" -#: cp/parser.c:17621 +#: cp/parser.c:17623 #, fuzzy, gcc-internal-format msgid "parameter pack cannot have a default argument" msgstr "strftime-muotoilut eivät voi muotoilla argumentteja" -#: cp/parser.c:17910 +#: cp/parser.c:17914 #, gcc-internal-format msgid "ISO C++ does not allow designated initializers" msgstr "" -#: cp/parser.c:17924 +#: cp/parser.c:17928 #, fuzzy, gcc-internal-format msgid "ISO C++ does not allow C99 designated initializers" msgstr "ISO C90 ei tue joustavia taulukkojäseniä" -#: cp/parser.c:18032 cp/parser.c:18157 +#: cp/parser.c:18036 cp/parser.c:18161 #, fuzzy, gcc-internal-format -#| msgid "expected class name" msgid "expected class-name" msgstr "odotettiin luokan nimeä" -#: cp/parser.c:18337 +#: cp/parser.c:18341 #, fuzzy, gcc-internal-format msgid "expected %<;%> after class definition" msgstr "Käytä AltiVec-käskyjä" -#: cp/parser.c:18339 +#: cp/parser.c:18343 #, fuzzy, gcc-internal-format msgid "expected %<;%> after struct definition" msgstr "Käytä AltiVec-käskyjä" -#: cp/parser.c:18341 +#: cp/parser.c:18345 #, fuzzy, gcc-internal-format msgid "expected %<;%> after union definition" msgstr "%qD esitelty extern-avainsanalla sisäkkäin" -#: cp/parser.c:18662 +#: cp/parser.c:18666 #, fuzzy, gcc-internal-format msgid "expected %<{%> or %<:%>" -msgstr "käytetty %<__thread%> ennen %<extern%>:a" +msgstr "odotettiin %<{%> tai %<:%>" -#: cp/parser.c:18673 +#: cp/parser.c:18677 #, gcc-internal-format msgid "cannot specify %<override%> for a class" msgstr "" -#: cp/parser.c:18681 +#: cp/parser.c:18685 #, gcc-internal-format msgid "global qualification of class name is invalid" msgstr "" -#: cp/parser.c:18688 +#: cp/parser.c:18692 #, fuzzy, gcc-internal-format msgid "qualified name does not name a class" msgstr "esittely ei esittele mitään" -#: cp/parser.c:18700 -#, fuzzy, gcc-internal-format +#: cp/parser.c:18704 +#, gcc-internal-format msgid "invalid class name in declaration of %qD" -msgstr "%qD esitelty staattisesti sisäkkäin" +msgstr "virheellinen luokan nimi %qD:n esittelyssä" -#: cp/parser.c:18733 +#: cp/parser.c:18737 #, gcc-internal-format msgid "extra qualification not allowed" msgstr "" -#: cp/parser.c:18745 +#: cp/parser.c:18749 #, gcc-internal-format msgid "an explicit specialization must be preceded by %<template <>%>" msgstr "" -#: cp/parser.c:18775 -#, fuzzy, gcc-internal-format +#: cp/parser.c:18779 +#, gcc-internal-format msgid "function template %qD redeclared as a class template" -msgstr "%Jsisäänrakennettu funktio %qD esitelty ei-funktiona" +msgstr "funktiomalli %qD esitelty uudelleen luokkamallina" -#: cp/parser.c:18806 +#: cp/parser.c:18810 #, fuzzy, gcc-internal-format msgid "could not resolve typename type" msgstr "%s: ei voida avata PCH-tiedostoa: %m\n" -#: cp/parser.c:18858 -#, fuzzy, gcc-internal-format +#: cp/parser.c:18862 +#, gcc-internal-format msgid "previous definition of %q+#T" -msgstr "edellinen määrittely tyypille %q+#T" +msgstr "edellinen %q+#T:n määrittely" -#: cp/parser.c:18939 cp/parser.c:23025 +#: cp/parser.c:18943 cp/parser.c:23029 #, fuzzy, gcc-internal-format -#| msgid "expected class name" msgid "expected class-key" msgstr "odotettiin luokan nimeä" -#: cp/parser.c:19177 +#: cp/parser.c:19181 #, gcc-internal-format msgid "in C++03 a class-key must be used when declaring a friend" msgstr "" -#: cp/parser.c:19195 -#, fuzzy, gcc-internal-format +#: cp/parser.c:19199 +#, gcc-internal-format msgid "friend declaration does not name a class or function" -msgstr "esittely ei esittele mitään" +msgstr "ystäväesittely ei nimeä luokkaa tai funktiota" -#: cp/parser.c:19213 +#: cp/parser.c:19217 #, gcc-internal-format msgid "a storage class on an anonymous aggregate in class scope is not allowed" msgstr "" -#: cp/parser.c:19418 -#, fuzzy, gcc-internal-format +#: cp/parser.c:19422 +#, gcc-internal-format msgid "pure-specifier on function-definition" -msgstr "%Jvanhanmallinen funktiomäärittely" +msgstr "pure-tarkenne funktiomäärittelyssä" -#: cp/parser.c:19462 -#, fuzzy, gcc-internal-format +#: cp/parser.c:19466 +#, gcc-internal-format msgid "stray %<,%> at end of member declaration" -msgstr "%<inline%> tyhjässä esittelyssä" +msgstr "ylimääräinen %<,%> jäsenesittelyn lopussa" -#: cp/parser.c:19474 +#: cp/parser.c:19478 #, gcc-internal-format msgid "expected %<;%> at end of member declaration" msgstr "" -#: cp/parser.c:19545 +#: cp/parser.c:19549 #, gcc-internal-format msgid "invalid pure specifier (only %<= 0%> is allowed)" msgstr "" -#: cp/parser.c:19580 +#: cp/parser.c:19584 #, fuzzy, gcc-internal-format msgid "a brace-enclosed initializer is not allowed here" msgstr "skalaarialustimen ympärillä on aaltosulkeet" -#: cp/parser.c:19711 +#: cp/parser.c:19715 #, gcc-internal-format msgid "%<virtual%> specified more than once in base-specified" msgstr "" -#: cp/parser.c:19731 +#: cp/parser.c:19735 #, gcc-internal-format msgid "more than one access specifier in base-specified" msgstr "" -#: cp/parser.c:19755 +#: cp/parser.c:19759 #, gcc-internal-format msgid "keyword %<typename%> not allowed outside of templates" msgstr "" -#: cp/parser.c:19758 +#: cp/parser.c:19762 #, gcc-internal-format msgid "keyword %<typename%> not allowed in this context (the base class is implicitly a type)" msgstr "" -#: cp/parser.c:19851 cp/parser.c:19933 +#: cp/parser.c:19855 cp/parser.c:19937 #, fuzzy, gcc-internal-format -#| msgid "new types may not be defined in a return type" msgid "types may not be defined in an exception-specification" msgstr "uusia tyyppejä ei voi määritellä paluutyypissä" -#: cp/parser.c:19915 +#: cp/parser.c:19919 #, gcc-internal-format msgid "dynamic exception specifications are deprecated in C++0x; use %<noexcept%> instead" msgstr "" -#: cp/parser.c:20114 +#: cp/parser.c:20118 #, fuzzy, gcc-internal-format -#| msgid "new types may not be defined in a return type" msgid "types may not be defined in exception-declarations" msgstr "uusia tyyppejä ei voi määritellä paluutyypissä" -#: cp/parser.c:20665 +#: cp/parser.c:20669 #, fuzzy, gcc-internal-format msgid "expected an identifier for the attribute name" msgstr "%qs attribuuttia ei huomioida" -#: cp/parser.c:21334 +#: cp/parser.c:21338 #, gcc-internal-format msgid "specializing member %<%T::%E%> requires %<template<>%> syntax" msgstr "" -#: cp/parser.c:21339 -#, fuzzy, gcc-internal-format +#: cp/parser.c:21343 +#, gcc-internal-format msgid "invalid declaration of %<%T::%E%>" -msgstr "%qD esitelty staattisesti sisäkkäin" +msgstr "virheellinen %<%T::%E%>:n esittely" -#: cp/parser.c:21343 +#: cp/parser.c:21347 #, fuzzy, gcc-internal-format msgid "too few template-parameter-lists" msgstr "%J%qD:n edellinen esittely oli täällä" @@ -33907,349 +33508,344 @@ msgstr "%J%qD:n edellinen esittely oli täällä" #. something like: #. #. template <class T> template <class U> void S::f(); -#: cp/parser.c:21350 +#: cp/parser.c:21354 #, gcc-internal-format msgid "too many template-parameter-lists" msgstr "" -#: cp/parser.c:21647 -#, fuzzy, gcc-internal-format +#: cp/parser.c:21651 +#, gcc-internal-format msgid "named return values are no longer supported" -msgstr "valitsin %qs ei ole enää tuettu" +msgstr "nimetyt paluuarvot eivät ole enää tuettuja" -#: cp/parser.c:21734 +#: cp/parser.c:21738 #, gcc-internal-format msgid "invalid declaration of member template in local class" msgstr "" -#: cp/parser.c:21743 -#, fuzzy, gcc-internal-format +#: cp/parser.c:21747 +#, gcc-internal-format msgid "template with C linkage" -msgstr "%J%qD esitelty uudelleen ilman linkitystä" +msgstr "malli C-linkityksellä" -#: cp/parser.c:21762 +#: cp/parser.c:21766 #, fuzzy, gcc-internal-format msgid "invalid explicit specialization" msgstr "Varoita implisiittisistä funktioesittelyistä" -#: cp/parser.c:21849 +#: cp/parser.c:21853 #, gcc-internal-format msgid "literal operator template %qD has invalid parameter list. Expected non-type template argument pack <char...>" msgstr "" -#: cp/parser.c:21923 +#: cp/parser.c:21927 #, fuzzy, gcc-internal-format msgid "template declaration of %<typedef%>" msgstr "tyhjä esittely" -#: cp/parser.c:22000 +#: cp/parser.c:22004 #, fuzzy, gcc-internal-format msgid "explicit template specialization cannot have a storage class" msgstr "%Hdatamäärittelyllä ei ole tyyppiä eikä tallennusluokkaa" -#: cp/parser.c:22238 +#: cp/parser.c:22242 #, gcc-internal-format msgid "%<>>%> should be %<> >%> within a nested template argument list" msgstr "" -#: cp/parser.c:22251 +#: cp/parser.c:22255 #, gcc-internal-format msgid "spurious %<>>%>, use %<>%> to terminate a template argument list" msgstr "" -#: cp/parser.c:22608 +#: cp/parser.c:22612 #, gcc-internal-format msgid "%<sizeof...%> argument must be surrounded by parentheses" msgstr "" -#: cp/parser.c:22660 +#: cp/parser.c:22664 #, fuzzy, gcc-internal-format msgid "invalid use of %qD in linkage specification" msgstr "rajat määrittelemättömän taulukon epäkelpo käyttö" -#: cp/parser.c:22675 +#: cp/parser.c:22679 #, fuzzy, gcc-internal-format msgid "%<__thread%> before %qD" msgstr "käytetty %<__thread%> ennen %<extern%>:a" -#: cp/parser.c:22809 +#: cp/parser.c:22813 #, gcc-internal-format msgid "ISO C++ 1998 does not support %<long long%>" msgstr "ISO C++ 1998 ei tue %<long long%> -tyyppiä" -#: cp/parser.c:22817 +#: cp/parser.c:22821 #, fuzzy, gcc-internal-format -#| msgid "both %<_Sat%> and %<char%> in declaration specifiers" msgid "both %<__thread%> and %<thread_local%> specified" msgstr "sekä %<_Sat%> että %<char%> esittelymääritteissä" -#: cp/parser.c:22819 +#: cp/parser.c:22823 #, fuzzy, gcc-internal-format msgid "duplicate %qD" msgstr "ylimääräinen %qE" -#: cp/parser.c:22841 -#, fuzzy, gcc-internal-format +#: cp/parser.c:22845 +#, gcc-internal-format msgid "duplicate %qs" -msgstr "ylimääräinen %qs" +msgstr "kaksois-%qs" -#: cp/parser.c:22883 -#, fuzzy, gcc-internal-format -#| msgid "expected class name" +#: cp/parser.c:22887 +#, gcc-internal-format msgid "expected %<new%>" -msgstr "odotettiin luokan nimeä" +msgstr "odotettiin %<new%>" -#: cp/parser.c:22886 -#, fuzzy, gcc-internal-format +#: cp/parser.c:22890 +#, gcc-internal-format msgid "expected %<delete%>" -msgstr "käytetty %<__thread%> ennen %<extern%>:a" +msgstr "odotettiin %<delete%>" -#: cp/parser.c:22889 -#, fuzzy, gcc-internal-format +#: cp/parser.c:22893 +#, gcc-internal-format msgid "expected %<return%>" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "odotettiin %<return%>" -#: cp/parser.c:22895 -#, fuzzy, gcc-internal-format +#: cp/parser.c:22899 +#, gcc-internal-format msgid "expected %<extern%>" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "odotettiin %<extern%>" -#: cp/parser.c:22898 -#, fuzzy, gcc-internal-format -#| msgid "expected class name" +#: cp/parser.c:22902 +#, gcc-internal-format msgid "expected %<static_assert%>" -msgstr "odotettiin luokan nimeä" +msgstr "odotettiin %<static_assert%>" -#: cp/parser.c:22901 -#, fuzzy, gcc-internal-format +#: cp/parser.c:22905 +#, gcc-internal-format msgid "expected %<decltype%>" -msgstr "käytetty %<__thread%> ennen %<extern%>:a" +msgstr "odotettiin %<decltype%>" -#: cp/parser.c:22904 -#, fuzzy, gcc-internal-format +#: cp/parser.c:22908 +#, gcc-internal-format msgid "expected %<operator%>" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "odotettiin %<operator%>" -#: cp/parser.c:22907 -#, fuzzy, gcc-internal-format -#| msgid "expected class name" +#: cp/parser.c:22911 +#, gcc-internal-format msgid "expected %<class%>" -msgstr "odotettiin luokan nimeä" +msgstr "odotettiin %<class%>" -#: cp/parser.c:22910 -#, fuzzy, gcc-internal-format +#: cp/parser.c:22914 +#, gcc-internal-format msgid "expected %<template%>" -msgstr "tyhjä esittely" +msgstr "odotettiin %<template%>" -#: cp/parser.c:22913 -#, fuzzy, gcc-internal-format -#| msgid "expected class name" +#: cp/parser.c:22917 +#, gcc-internal-format msgid "expected %<namespace%>" -msgstr "odotettiin luokan nimeä" +msgstr "odotettiin %<namespace%>" -#: cp/parser.c:22916 +# XXXXXXX +#: cp/parser.c:22920 #, fuzzy, gcc-internal-format msgid "expected %<using%>" msgstr "leveä merkkijonovakio %<asm%>-lauseessa" -#: cp/parser.c:22919 +#: cp/parser.c:22923 #, fuzzy, gcc-internal-format -#| msgid "expected class name" msgid "expected %<asm%>" msgstr "odotettiin luokan nimeä" -#: cp/parser.c:22922 +#: cp/parser.c:22926 #, fuzzy, gcc-internal-format msgid "expected %<try%>" msgstr "taulukon indeksin tyyppi on %<char%>" -#: cp/parser.c:22925 +#: cp/parser.c:22929 #, fuzzy, gcc-internal-format msgid "expected %<catch%>" msgstr "taulukon indeksin tyyppi on %<char%>" -#: cp/parser.c:22928 +#: cp/parser.c:22932 #, fuzzy, gcc-internal-format msgid "expected %<throw%>" msgstr "taulukon indeksin tyyppi on %<char%>" -#: cp/parser.c:22931 +#: cp/parser.c:22935 #, fuzzy, gcc-internal-format msgid "expected %<__label__%>" msgstr "käytetty %<__thread%> ennen %<extern%>:a" -#: cp/parser.c:22934 +#: cp/parser.c:22938 #, fuzzy, gcc-internal-format msgid "expected %<@try%>" msgstr "taulukon indeksin tyyppi on %<char%>" -#: cp/parser.c:22937 +#: cp/parser.c:22941 #, gcc-internal-format msgid "expected %<@synchronized%>" msgstr "" -#: cp/parser.c:22940 +#: cp/parser.c:22944 #, gcc-internal-format msgid "expected %<@throw%>" msgstr "" -#: cp/parser.c:22943 +#: cp/parser.c:22947 #, gcc-internal-format msgid "expected %<__transaction_atomic%>" msgstr "" -#: cp/parser.c:22946 +#: cp/parser.c:22950 #, gcc-internal-format msgid "expected %<__transaction_relaxed%>" msgstr "" -#: cp/parser.c:22977 +#: cp/parser.c:22981 #, fuzzy, gcc-internal-format msgid "expected %<::%>" msgstr "taulukon indeksin tyyppi on %<char%>" -#: cp/parser.c:22989 +#: cp/parser.c:22993 #, gcc-internal-format msgid "expected %<...%>" msgstr "" -#: cp/parser.c:22992 +#: cp/parser.c:22996 #, fuzzy, gcc-internal-format msgid "expected %<*%>" msgstr "taulukon indeksin tyyppi on %<char%>" -#: cp/parser.c:22995 +#: cp/parser.c:22999 #, fuzzy, gcc-internal-format msgid "expected %<~%>" msgstr "taulukon indeksin tyyppi on %<char%>" -#: cp/parser.c:23001 +#: cp/parser.c:23005 #, fuzzy, gcc-internal-format msgid "expected %<:%> or %<::%>" msgstr "käytetty %<__thread%> ennen %<extern%>:a" -#: cp/parser.c:23029 +#: cp/parser.c:23033 #, fuzzy, gcc-internal-format msgid "expected %<class%>, %<typename%>, or %<template%>" msgstr "käytetty %<__thread%> ennen %<extern%>:a" -#: cp/parser.c:23267 +#: cp/parser.c:23271 #, gcc-internal-format msgid "%qs tag used in naming %q#T" msgstr "" -#: cp/parser.c:23272 +#: cp/parser.c:23276 #, fuzzy, gcc-internal-format msgid "%q#T was previously declared here" msgstr "%Jviimeksi käytetty täällä" -#: cp/parser.c:23291 +#: cp/parser.c:23295 #, fuzzy, gcc-internal-format msgid "%qD redeclared with different access" msgstr "%J%qD esitelty uudelleen erityyppisenä symbolina" -#: cp/parser.c:23312 +#: cp/parser.c:23316 #, gcc-internal-format msgid "in C++98 %<template%> (as a disambiguator) is only allowed within templates" msgstr "" # XXX -#: cp/parser.c:23544 +#: cp/parser.c:23548 #, fuzzy, gcc-internal-format msgid "file ends in default argument" msgstr "%Hswitch-lauseesta puuttuu default-nimike" -#: cp/parser.c:23748 cp/parser.c:25010 cp/parser.c:25196 +#: cp/parser.c:23752 cp/parser.c:25014 cp/parser.c:25200 #, gcc-internal-format msgid "misplaced %<@%D%> Objective-C++ construct" msgstr "" -#: cp/parser.c:23870 +#: cp/parser.c:23874 #, gcc-internal-format msgid "objective-c++ message argument(s) are expected" msgstr "" -#: cp/parser.c:23899 +#: cp/parser.c:23903 #, gcc-internal-format msgid "%<@encode%> must specify a type as an argument" msgstr "" -#: cp/parser.c:24275 +#: cp/parser.c:24279 #, gcc-internal-format msgid "invalid Objective-C++ selector name" msgstr "" -#: cp/parser.c:24350 cp/parser.c:24368 +#: cp/parser.c:24354 cp/parser.c:24372 #, fuzzy, gcc-internal-format msgid "objective-c++ method declaration is expected" msgstr "useita tallennuspaikkoja esittelymääritteissä" -#: cp/parser.c:24362 cp/parser.c:24427 +#: cp/parser.c:24366 cp/parser.c:24431 #, fuzzy, gcc-internal-format msgid "method attributes must be specified at the end" msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle" -#: cp/parser.c:24470 +#: cp/parser.c:24474 #, gcc-internal-format msgid "stray %qs between Objective-C++ methods" msgstr "" -#: cp/parser.c:24676 cp/parser.c:24683 cp/parser.c:24690 +#: cp/parser.c:24680 cp/parser.c:24687 cp/parser.c:24694 #, fuzzy, gcc-internal-format msgid "invalid type for instance variable" msgstr "epäkelpo vektorityyppi attribuutille %qs" -#: cp/parser.c:24804 +#: cp/parser.c:24808 #, gcc-internal-format msgid "identifier expected after %<@protocol%>" msgstr "" -#: cp/parser.c:24975 +#: cp/parser.c:24979 #, gcc-internal-format msgid "attributes may not be specified before the %<@%D%> Objective-C++ keyword" msgstr "" -#: cp/parser.c:24982 +#: cp/parser.c:24986 #, fuzzy, gcc-internal-format msgid "prefix attributes are ignored before %<@%D%>" msgstr "%qs-attribuuttia ei huomioida %qs:lle" -#: cp/parser.c:25255 cp/parser.c:25262 cp/parser.c:25269 +#: cp/parser.c:25259 cp/parser.c:25266 cp/parser.c:25273 #, fuzzy, gcc-internal-format msgid "invalid type for property" msgstr "void-lausekkeen epäkelpo käyttö" -#: cp/parser.c:27000 +#: cp/parser.c:27004 #, gcc-internal-format msgid "parenthesized initialization is not allowed in OpenMP %<for%> loop" msgstr "" -#: cp/parser.c:27168 cp/pt.c:12695 +#: cp/parser.c:27172 cp/pt.c:12690 #, fuzzy, gcc-internal-format msgid "iteration variable %qD should not be reduction" msgstr "sisäkkäisessä funktiossa käytetty rekisterimuuttujaa %qD" -#: cp/parser.c:27238 +#: cp/parser.c:27242 #, gcc-internal-format msgid "not enough collapsed for loops" msgstr "" -#: cp/parser.c:27796 cp/semantics.c:5105 +#: cp/parser.c:27800 cp/semantics.c:5105 #, gcc-internal-format msgid "%<__transaction_relaxed%> without transactional memory support enabled" msgstr "" -#: cp/parser.c:27798 cp/semantics.c:5107 +#: cp/parser.c:27802 cp/semantics.c:5107 #, gcc-internal-format msgid "%<__transaction_atomic%> without transactional memory support enabled" msgstr "" -#: cp/parser.c:27995 +#: cp/parser.c:27999 #, gcc-internal-format msgid "junk at end of %<#pragma GCC pch_preprocess%>" msgstr "roskaa ilmaisun %<#pragma GCC pch_preprocess%> lopussa" -#: cp/parser.c:28174 +#: cp/parser.c:28178 #, gcc-internal-format msgid "inter-module optimizations not implemented for C++" msgstr "moduulienvälisiä optimointeja ei ole toteutettu C++:lle" @@ -34338,13 +33934,11 @@ msgstr "" #: cp/pt.c:1747 #, fuzzy, gcc-internal-format -#| msgid "candidate is: %+#D" msgid "candidate is: %#D" msgstr "ehdokas on: %+#D" #: cp/pt.c:1754 #, fuzzy, gcc-internal-format -#| msgid "%s %+#T" msgid "%s %#D" msgstr "%s %+#T" @@ -34368,7 +33962,7 @@ msgstr "" msgid "ambiguous template specialization %qD for %q+D" msgstr "" -#: cp/pt.c:2273 cp/pt.c:17968 +#: cp/pt.c:2273 cp/pt.c:17964 #, gcc-internal-format msgid "%qD is not a static data member of a class template" msgstr "" @@ -34426,9 +34020,9 @@ msgid "default argument specified in explicit specialization" msgstr "" #: cp/pt.c:2482 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qD is not a template function" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qD ei ole mallifunktio" #: cp/pt.c:2490 #, fuzzy, gcc-internal-format @@ -34476,17 +34070,17 @@ msgstr "" #: cp/pt.c:3374 cp/pt.c:4097 #, gcc-internal-format msgid " %qD" -msgstr "" +msgstr " %qD" #: cp/pt.c:3376 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid " <anonymous>" -msgstr "<nimetön>" +msgstr " <nimetön>" #: cp/pt.c:3493 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "declaration of %q+#D" -msgstr "%J%qD esitelty turhaan uudestaan" +msgstr "%q+#D:n esittely" #: cp/pt.c:3494 #, gcc-internal-format @@ -34728,7 +34322,6 @@ msgstr "" #: cp/pt.c:5250 #, fuzzy, gcc-internal-format -#| msgid "comparison between types %qT and %qT" msgid " mismatched types %qT and %qT" msgstr "tyyppien %qT ja %qT välinen vertailu" @@ -34774,7 +34367,6 @@ msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi" #: cp/pt.c:5360 #, fuzzy, gcc-internal-format -#| msgid "cannot convert type %qT to type %qT" msgid " cannot convert %qE (type %qT) to type %qT" msgstr "ei voi muuntaa tyyppiä %qT tyypiksi %qT" @@ -34785,7 +34377,6 @@ msgstr "" #: cp/pt.c:5377 #, fuzzy, gcc-internal-format -#| msgid "type %qT is not derived from type %qT" msgid " %qT is not derived from %qT" msgstr "tyyppi %qT ei periydy %qT-tyypistä" @@ -34855,9 +34446,9 @@ msgid "%q#D is not a valid template argument for type %qT because a reference va msgstr "" #: cp/pt.c:5733 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE is not a valid template argument for type %qT because it is not an object with external linkage" -msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi" +msgstr "%qE ei ole kelvollinen malliargumentti tyypille %qT, koska se ei ole objekti ulkoisella linkityksellä" #: cp/pt.c:5741 #, gcc-internal-format @@ -34917,7 +34508,7 @@ msgstr " odotettiin %qT-tyyppistä vakiota, saatiin %qT" #: cp/pt.c:6257 #, gcc-internal-format msgid " expected a class template, got %qE" -msgstr "" +msgstr " odotettiin luokkamallia, saatiin %qE" #: cp/pt.c:6259 #, gcc-internal-format @@ -34932,7 +34523,7 @@ msgstr " odotettiin tyyppiä, saatiin %qT" #: cp/pt.c:6274 #, gcc-internal-format msgid " expected a class template, got %qT" -msgstr "" +msgstr " odotettiin luokkamallia, saatiin %qT" #: cp/pt.c:6319 #, fuzzy, gcc-internal-format @@ -34982,9 +34573,9 @@ msgid "non-template type %qT used as a template" msgstr "" #: cp/pt.c:7104 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "for template declaration %q+D" -msgstr "tyhjä esittely" +msgstr "malliesittelylle %q+D" #: cp/pt.c:7925 msgid "template instantiation depth exceeds maximum of %d (use -ftemplate-depth= to increase the maximum) substituting %qS" @@ -35028,252 +34619,252 @@ msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" #. #. is an attempt to declare a variable with function #. type. -#: cp/pt.c:10656 +#: cp/pt.c:10651 #, gcc-internal-format msgid "variable %qD has function type" msgstr "muuttujalla %qD on funktiotyyppi" -#: cp/pt.c:10828 +#: cp/pt.c:10823 #, gcc-internal-format msgid "invalid parameter type %qT" msgstr "virheellinen parametrityyppi %qT" -#: cp/pt.c:10830 +#: cp/pt.c:10825 #, gcc-internal-format msgid "in declaration %q+D" msgstr "esittelyssä %q+D" -#: cp/pt.c:10906 +#: cp/pt.c:10901 #, gcc-internal-format msgid "function returning an array" -msgstr "" +msgstr "taulukon palauttava funktio" -#: cp/pt.c:10908 +#: cp/pt.c:10903 #, gcc-internal-format msgid "function returning a function" -msgstr "" +msgstr "funktion palauttava funktio" -#: cp/pt.c:10938 +#: cp/pt.c:10933 #, gcc-internal-format msgid "creating pointer to member function of non-class type %qT" msgstr "" -#: cp/pt.c:11503 +#: cp/pt.c:11498 #, gcc-internal-format msgid "forming reference to void" msgstr "" -#: cp/pt.c:11505 +#: cp/pt.c:11500 #, fuzzy, gcc-internal-format msgid "forming pointer to reference type %qT" msgstr "parametrilla %P on vaillinainen tyyppi %qT" -#: cp/pt.c:11507 +#: cp/pt.c:11502 #, gcc-internal-format msgid "forming reference to reference type %qT" msgstr "" -#: cp/pt.c:11556 +#: cp/pt.c:11551 #, gcc-internal-format msgid "creating pointer to member of non-class type %qT" msgstr "" -#: cp/pt.c:11562 +#: cp/pt.c:11557 #, gcc-internal-format msgid "creating pointer to member reference type %qT" msgstr "" -#: cp/pt.c:11568 +#: cp/pt.c:11563 #, gcc-internal-format msgid "creating pointer to member of type void" msgstr "" -#: cp/pt.c:11630 +#: cp/pt.c:11625 #, gcc-internal-format msgid "creating array of %qT" msgstr "" -#: cp/pt.c:11636 +#: cp/pt.c:11631 #, gcc-internal-format msgid "creating array of %qT, which is an abstract class type" msgstr "" -#: cp/pt.c:11665 +#: cp/pt.c:11660 #, gcc-internal-format msgid "%qT is not a class, struct, or union type" msgstr "%qT ei ole luokka-, struct- eikä unionityyppi" -#: cp/pt.c:11702 +#: cp/pt.c:11697 #, fuzzy, gcc-internal-format msgid "%qT resolves to %qT, which is not an enumeration type" msgstr "%Jcase-arvo %qs ei ole luetellussa tyypissä" -#: cp/pt.c:11710 +#: cp/pt.c:11705 #, gcc-internal-format msgid "%qT resolves to %qT, which is is not a class type" msgstr "" -#: cp/pt.c:11827 +#: cp/pt.c:11822 #, gcc-internal-format msgid "use of %qs in template" msgstr "" -#: cp/pt.c:11969 +#: cp/pt.c:11964 #, gcc-internal-format msgid "qualifying type %qT does not match destructor name ~%qT" msgstr "" -#: cp/pt.c:11984 +#: cp/pt.c:11979 #, gcc-internal-format msgid "dependent-name %qE is parsed as a non-type, but instantiation yields a type" msgstr "" -#: cp/pt.c:11986 +#: cp/pt.c:11981 #, gcc-internal-format msgid "say %<typename %E%> if a type is meant" msgstr "" -#: cp/pt.c:12134 +#: cp/pt.c:12129 #, gcc-internal-format msgid "using invalid field %qD" -msgstr "" +msgstr "käytetään virheellistä kenttää %qD" -#: cp/pt.c:12502 cp/pt.c:13323 +#: cp/pt.c:12497 cp/pt.c:13318 #, fuzzy, gcc-internal-format msgid "invalid use of pack expansion expression" msgstr "void-lausekkeen epäkelpo käyttö" -#: cp/pt.c:12506 cp/pt.c:13327 +#: cp/pt.c:12501 cp/pt.c:13322 #, gcc-internal-format msgid "use %<...%> to expand argument pack" msgstr "" -#: cp/pt.c:13973 +#: cp/pt.c:13968 #, 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 "" -#: cp/pt.c:13982 +#: cp/pt.c:13977 #, gcc-internal-format msgid "declarations in dependent base %qT are not found by unqualified lookup" msgstr "" -#: cp/pt.c:13987 +#: cp/pt.c:13982 #, gcc-internal-format msgid "use %<this->%D%> instead" msgstr "" -#: cp/pt.c:13990 +#: cp/pt.c:13985 #, fuzzy, gcc-internal-format msgid "use %<%T::%D%> instead" msgstr "%J%qD on tavallisesti ei-staattinen funktio" -#: cp/pt.c:13994 +#: cp/pt.c:13989 #, fuzzy, gcc-internal-format msgid "%q+D declared here, later in the translation unit" msgstr "%J%qD esitelty avoimeksi määrittelyn jälkeen" -#: cp/pt.c:14254 +#: cp/pt.c:14249 #, gcc-internal-format msgid "%qT is not a class or namespace" msgstr "%qT ei ole luokka eikä nimiavaruus" -#: cp/pt.c:14257 +#: cp/pt.c:14252 #, gcc-internal-format msgid "%qD is not a class or namespace" msgstr "%qD ei ole luokka eikä nimiavaruus" -#: cp/pt.c:14563 -#, fuzzy, gcc-internal-format +#: cp/pt.c:14558 +#, gcc-internal-format msgid "%qT is/uses anonymous type" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "%qT on/käyttää anonyymiä tyyppiä" -#: cp/pt.c:14565 -#, fuzzy, gcc-internal-format +#: cp/pt.c:14560 +#, gcc-internal-format msgid "template argument for %qD uses local type %qT" -msgstr "tyyppimuunnettu argumentti %qD ei sovi prototyyppiin" +msgstr "%qD:n malliargumentti käyttää paikallista tyyppiä %qT" -#: cp/pt.c:14575 +#: cp/pt.c:14570 #, gcc-internal-format msgid "%qT is a variably modified type" msgstr "" -#: cp/pt.c:14589 +#: cp/pt.c:14584 #, gcc-internal-format msgid "integral expression %qE is not constant" msgstr "" -#: cp/pt.c:14607 +#: cp/pt.c:14602 #, gcc-internal-format msgid " trying to instantiate %qD" msgstr "" -#: cp/pt.c:17925 +#: cp/pt.c:17921 #, gcc-internal-format msgid "ambiguous class template instantiation for %q#T" msgstr "" -#: cp/pt.c:17929 +#: cp/pt.c:17925 #, gcc-internal-format msgid "%s %+#T" msgstr "%s %+#T" -#: cp/pt.c:17953 cp/pt.c:18036 +#: cp/pt.c:17949 cp/pt.c:18032 #, gcc-internal-format msgid "explicit instantiation of non-template %q#D" msgstr "" -#: cp/pt.c:17974 cp/pt.c:18031 +#: cp/pt.c:17970 cp/pt.c:18027 #, gcc-internal-format msgid "no matching template for %qD found" msgstr "" -#: cp/pt.c:17979 +#: cp/pt.c:17975 #, gcc-internal-format msgid "type %qT for explicit instantiation %qD does not match declared type %qT" msgstr "" -#: cp/pt.c:17987 +#: cp/pt.c:17983 #, gcc-internal-format msgid "explicit instantiation of %q#D" msgstr "" -#: cp/pt.c:18023 +#: cp/pt.c:18019 #, gcc-internal-format msgid "duplicate explicit instantiation of %q#D" msgstr "" -#: cp/pt.c:18046 cp/pt.c:18143 +#: cp/pt.c:18042 cp/pt.c:18139 #, fuzzy, gcc-internal-format msgid "ISO C++ 1998 forbids the use of %<extern%> on explicit instantiations" msgstr "ISO C++ kieltää metodiosoittimen käytön vähennyslaskussa" -#: cp/pt.c:18051 cp/pt.c:18160 +#: cp/pt.c:18047 cp/pt.c:18156 #, gcc-internal-format msgid "storage class %qD applied to template instantiation" msgstr "" -#: cp/pt.c:18119 +#: cp/pt.c:18115 #, fuzzy, gcc-internal-format msgid "explicit instantiation of non-class template %qD" msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" -#: cp/pt.c:18121 +#: cp/pt.c:18117 #, gcc-internal-format msgid "explicit instantiation of non-template type %qT" msgstr "" -#: cp/pt.c:18130 +#: cp/pt.c:18126 #, gcc-internal-format msgid "explicit instantiation of %q#T before definition of template" msgstr "" -#: cp/pt.c:18148 +#: cp/pt.c:18144 #, gcc-internal-format msgid "ISO C++ forbids the use of %qE on explicit instantiations" msgstr "" -#: cp/pt.c:18194 +#: cp/pt.c:18190 #, gcc-internal-format msgid "duplicate explicit instantiation of %q#T" msgstr "" @@ -35285,47 +34876,47 @@ msgstr "" #. member function or static data member of a class template #. shall be present in every translation unit in which it is #. explicitly instantiated. -#: cp/pt.c:18723 +#: cp/pt.c:18719 #, gcc-internal-format msgid "explicit instantiation of %qD but no definition available" msgstr "" -#: cp/pt.c:18908 +#: cp/pt.c:18904 #, 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 "" -#: cp/pt.c:19288 +#: cp/pt.c:19284 #, fuzzy, gcc-internal-format msgid "invalid template non-type parameter" msgstr "%J%qD on tavallisesti ei-staattinen funktio" -#: cp/pt.c:19290 +#: cp/pt.c:19286 #, fuzzy, gcc-internal-format msgid "%q#T is not a valid type for a template non-type parameter" msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi" -#: cp/pt.c:20508 +#: cp/pt.c:20504 #, gcc-internal-format msgid "deducing from brace-enclosed initializer list requires #include <initializer_list>" msgstr "" -#: cp/pt.c:20579 +#: cp/pt.c:20575 #, fuzzy, gcc-internal-format msgid "unable to deduce lambda return type from %qE" msgstr "ei voi emuloida %qs" -#: cp/pt.c:20581 +#: cp/pt.c:20577 #, fuzzy, gcc-internal-format msgid "unable to deduce %qT from %qE" msgstr "ei voi emuloida %qs" -#: cp/pt.c:20595 +#: cp/pt.c:20591 #, gcc-internal-format msgid "inconsistent types %qT and %qT deduced for lambda return type" msgstr "" -#: cp/pt.c:20599 +#: cp/pt.c:20595 #, gcc-internal-format msgid "inconsistent deduction for %qT: %qT and then %qT" msgstr "" @@ -35421,9 +35012,9 @@ msgid "conflicting type attributes specified for %q+#D" msgstr "%J ristiriitaiset tyyppimääreet %qD:lle" #: cp/search.c:1959 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "deleted function %q+D" -msgstr "%qD esitelty extern-avainsanalla sisäkkäin" +msgstr "poistettu funktio %q+D" #: cp/search.c:1960 #, gcc-internal-format @@ -35431,9 +35022,9 @@ msgid "overriding non-deleted function %q+D" msgstr "" #: cp/search.c:1965 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "non-deleted function %q+D" -msgstr "Funktio %qs:" +msgstr "poistamaton funktio %q+D" #: cp/search.c:1966 #, fuzzy, gcc-internal-format @@ -35477,17 +35068,17 @@ msgstr "" msgid "__label__ declarations are only allowed in function scopes" msgstr "" -#: cp/semantics.c:1557 +#: cp/semantics.c:1558 #, gcc-internal-format msgid "invalid use of member %q+D in static member function" msgstr "jäsentä %q+D käytetty virheellisesti staattisessa jäsenfunktiossa" -#: cp/semantics.c:1559 +#: cp/semantics.c:1560 #, gcc-internal-format msgid "invalid use of non-static data member %q+D" msgstr "ei-staattisen datajäsenen %q+D virheellinen käyttö" -#: cp/semantics.c:1560 +#: cp/semantics.c:1561 #, gcc-internal-format msgid "from this location" msgstr "tästä kohdasta" @@ -35528,9 +35119,9 @@ msgid "%qE is not of type %qT" msgstr "%qE ei ole tyyppiä %qT" #: cp/semantics.c:2403 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "compound literal of non-object type %qT" -msgstr "yhdysliteraalin koko on muuttuva" +msgstr "ei-objektityyppinen yhdysliteraali %qT" #: cp/semantics.c:2515 #, gcc-internal-format @@ -35562,7 +35153,7 @@ msgstr "" msgid "invalid base-class specification" msgstr "" -#: cp/semantics.c:3074 cp/semantics.c:9106 +#: cp/semantics.c:3074 cp/semantics.c:9123 #, fuzzy, gcc-internal-format msgid "%qD is not captured" msgstr "%J%qD on tavallisesti ei-staattinen funktio" @@ -35626,7 +35217,6 @@ msgstr "%Jcase-arvo %qs ei ole luetellussa tyypissä" #. Parameter packs can only be used in templates #: cp/semantics.c:3613 #, fuzzy, gcc-internal-format -#| msgid "useless type qualifier in empty declaration" msgid "Parameter pack __bases only valid in template declaration" msgstr "tarpeeton tyyppimääre tyhjässä esittelyssä" @@ -35691,271 +35281,268 @@ msgid "difference between %qE and %qD does not have integer type" msgstr "" #. Report the error. -#: cp/semantics.c:5224 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: cp/semantics.c:5226 +#, gcc-internal-format, gfc-internal-format msgid "static assertion failed: %s" -msgstr "verify_flow_info epäonnistui" +msgstr "staattinen väite epäonnistui: %s" -#: cp/semantics.c:5227 -#, fuzzy, gcc-internal-format +#: cp/semantics.c:5229 +#, gcc-internal-format msgid "non-constant condition for static assertion" -msgstr "%J%qD esitelty ei-staattisena, edellinen esittely staattinen" +msgstr "ei-vakio ehto staattiselle väitteelle" -#: cp/semantics.c:5256 -#, fuzzy, gcc-internal-format +#: cp/semantics.c:5258 +#, gcc-internal-format msgid "argument to decltype must be an expression" -msgstr "ylivuoto vakiolausekkeessa" +msgstr "decltypen argumentin on oltava lauseke" -#: cp/semantics.c:5281 +#: cp/semantics.c:5283 #, fuzzy, gcc-internal-format msgid "decltype cannot resolve address of overloaded function" msgstr "%J%qD on tavallisesti ei-staattinen funktio" -#: cp/semantics.c:5612 +#: cp/semantics.c:5614 #, gcc-internal-format msgid "__is_convertible_to" msgstr "" -#: cp/semantics.c:5730 +#: cp/semantics.c:5732 #, gcc-internal-format msgid "the type %qT of constexpr variable %qD is not literal" msgstr "" -#: cp/semantics.c:5800 +#: cp/semantics.c:5802 #, fuzzy, gcc-internal-format msgid "invalid type for parameter %d of constexpr function %q+#D" msgstr "epäkelpo tallennusluokka funktiolle %qs" -#: cp/semantics.c:5814 +#: cp/semantics.c:5816 #, fuzzy, gcc-internal-format msgid "invalid return type %qT of constexpr function %q+D" msgstr "epäkelpo tallennusluokka funktiolle %qs" -#: cp/semantics.c:5836 +#: cp/semantics.c:5838 #, fuzzy, gcc-internal-format -#| msgid "%q#T is not a class" msgid "%q#T has virtual base classes" msgstr "%q#T ei ole luokka" -#: cp/semantics.c:6036 +#: cp/semantics.c:6038 #, gcc-internal-format msgid "constexpr constructor does not have empty body" msgstr "" -#: cp/semantics.c:6122 +#: cp/semantics.c:6124 #, gcc-internal-format msgid "body of %<constexpr%> constructor cannot be a function-try-block" msgstr "" -#: cp/semantics.c:6245 +#: cp/semantics.c:6247 #, gcc-internal-format msgid "%<constexpr%> constructor for union %qT must initialize exactly one non-static data member" msgstr "" -#: cp/semantics.c:6285 +#: cp/semantics.c:6287 #, fuzzy, gcc-internal-format msgid "uninitialized member %qD in %<constexpr%> constructor" msgstr "alustamaton const %qD" -#: cp/semantics.c:6316 +#: cp/semantics.c:6318 #, fuzzy, gcc-internal-format msgid "body of constexpr function %qD not a return-statement" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: cp/semantics.c:6371 +#: cp/semantics.c:6373 #, fuzzy, gcc-internal-format msgid "%q+D is not usable as a constexpr function because:" msgstr "%J%qD on tavallisesti ei-staattinen funktio" -#: cp/semantics.c:6706 +#: cp/semantics.c:6708 #, fuzzy, gcc-internal-format msgid "expression %qE does not designate a constexpr function" msgstr "esittely ei esittele mitään" -#: cp/semantics.c:6720 cp/semantics.c:8360 +#: cp/semantics.c:6722 cp/semantics.c:8362 #, fuzzy, gcc-internal-format msgid "call to non-constexpr function %qD" msgstr "Funktio %qs:" #. The definition of fun was somehow unsuitable. -#: cp/semantics.c:6748 +#: cp/semantics.c:6750 #, fuzzy, gcc-internal-format msgid "%qD called in a constant expression" msgstr "ylivuoto vakiolausekkeessa" -#: cp/semantics.c:6752 +#: cp/semantics.c:6754 #, fuzzy, gcc-internal-format msgid "%qD used before its definition" msgstr "%J%qD käytössä ilman prototyyppiä ennen määrittelyänsä" -#: cp/semantics.c:6786 +#: cp/semantics.c:6788 #, fuzzy, gcc-internal-format -#| msgid "protocol %qE has circular dependency" msgid "call has circular dependency" msgstr "protokollalla %qE on kehäriippuvuus" -#: cp/semantics.c:6794 +#: cp/semantics.c:6796 #, gcc-internal-format, gfc-internal-format msgid "constexpr evaluation depth exceeds maximum of %d (use -fconstexpr-depth= to increase the maximum)" msgstr "" -#: cp/semantics.c:6858 +#: cp/semantics.c:6860 #, fuzzy, gcc-internal-format msgid "%q+E is not a constant expression" msgstr "ylivuoto vakiolausekkeessa" -#: cp/semantics.c:7004 +#: cp/semantics.c:7006 #, fuzzy, gcc-internal-format msgid "array subscript out of bound" msgstr "taulukon indeksi ei ole kokonaisluku" -#: cp/semantics.c:7050 cp/semantics.c:7110 cp/semantics.c:7804 +#: cp/semantics.c:7052 cp/semantics.c:7112 cp/semantics.c:7806 #, fuzzy, gcc-internal-format msgid "%qE is not a constant expression" msgstr "ylivuoto vakiolausekkeessa" -#: cp/semantics.c:7056 +#: cp/semantics.c:7058 #, fuzzy, gcc-internal-format msgid "mutable %qD is not usable in a constant expression" msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio" -#: cp/semantics.c:7071 +#: cp/semantics.c:7073 #, fuzzy, gcc-internal-format msgid "accessing %qD member instead of initialized %qD member in constant expression" msgstr "taulukon koko ei ole kokonaislukutyyppinen vakiolauseke" -#: cp/semantics.c:7630 +#: cp/semantics.c:7632 #, fuzzy, gcc-internal-format msgid "accessing value of %qE through a %qT glvalue in a constant expression" msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio" -#: cp/semantics.c:7665 +#: cp/semantics.c:7667 #, fuzzy, gcc-internal-format msgid "the value of %qD is not usable in a constant expression" msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio" -#: cp/semantics.c:7672 +#: cp/semantics.c:7674 #, fuzzy, gcc-internal-format msgid "%qD used in its own initializer" msgstr "parametri %qD on alustettu" -#: cp/semantics.c:7677 +#: cp/semantics.c:7679 #, fuzzy, gcc-internal-format msgid "%q#D is not const" msgstr "%J%qD on tavallisesti ei-staattinen funktio" -#: cp/semantics.c:7680 +#: cp/semantics.c:7682 #, fuzzy, gcc-internal-format msgid "%q#D is volatile" msgstr "%J%qD on tavallisesti ei-staattinen funktio" -#: cp/semantics.c:7684 +#: cp/semantics.c:7686 #, fuzzy, gcc-internal-format -#| msgid "initializer element is not a constant expression" msgid "%qD was not initialized with a constant expression" msgstr "alustinalkio ei ole vakiolauseke" -#: cp/semantics.c:7693 +#: cp/semantics.c:7695 #, fuzzy, gcc-internal-format msgid "%qD was not declared %<constexpr%>" msgstr "%Jparametri %qD esitelty %<inline%>:ksi" -#: cp/semantics.c:7696 +#: cp/semantics.c:7698 #, fuzzy, gcc-internal-format msgid "%qD does not have integral or enumeration type" msgstr "%J%qD on tavallisesti ei-staattinen funktio" -#: cp/semantics.c:7792 cp/semantics.c:8492 +#: cp/semantics.c:7794 cp/semantics.c:8494 #, fuzzy, gcc-internal-format msgid "use of the value of the object being constructed in a constant expression" msgstr "luetellun tyypin jäsenen %qE arvo ei ole kokonaislukuvakio" -#: cp/semantics.c:7820 cp/semantics.c:8630 +#: cp/semantics.c:7822 cp/semantics.c:8644 #, fuzzy, gcc-internal-format msgid "temporary of non-literal type %qT in a constant expression" msgstr "ylivuoto vakiolausekkeessa" -#: cp/semantics.c:8087 cp/semantics.c:8534 cp/semantics.c:8794 +#: cp/semantics.c:8089 cp/semantics.c:8536 cp/semantics.c:8811 #, fuzzy, gcc-internal-format -#| msgid "size of array %qD is not an integral constant-expression" msgid "expression %qE is not a constant-expression" msgstr "taulukon %qD koko ei ole kokonaislukutyyppinen vakiolauseke" -#: cp/semantics.c:8092 +#: cp/semantics.c:8094 #, fuzzy, gcc-internal-format msgid "unexpected expression %qE of kind %s" msgstr "vektoriylivuoto lausekkeessa" -#: cp/semantics.c:8124 +#: cp/semantics.c:8126 #, gcc-internal-format msgid "%qT cannot be the type of a complete constant expression because it has mutable sub-objects" msgstr "" -#: cp/semantics.c:8137 +#: cp/semantics.c:8139 #, gcc-internal-format msgid "conversion from pointer type %qT to arithmetic type %qT in a constant-expression" msgstr "" -#: cp/semantics.c:8308 +#: cp/semantics.c:8310 #, gcc-internal-format msgid "expression %qE has side-effects" msgstr "" -#: cp/semantics.c:8378 +#: cp/semantics.c:8380 #, gcc-internal-format msgid "calling a member function of the object being constructed in a constant expression" msgstr "" -#: cp/semantics.c:8460 +#: cp/semantics.c:8462 #, gcc-internal-format msgid "address-of an object %qE with thread local or automatic storage is not a constant expression" msgstr "" -#: cp/semantics.c:8546 +#: cp/semantics.c:8548 #, gcc-internal-format msgid "typeid-expression is not a constant expression because %qE is of polymorphic type" msgstr "" -#: cp/semantics.c:8559 +#: cp/semantics.c:8561 #, fuzzy, gcc-internal-format -#| msgid "initializer element is not a constant expression" msgid "difference of two pointer expressions is not a constant expression" msgstr "alustinalkio ei ole vakiolauseke" -#: cp/semantics.c:8578 +#: cp/semantics.c:8580 #, fuzzy, gcc-internal-format -#| msgid "initializer element is not a constant expression" msgid "pointer comparison expression is not a constant expression" msgstr "alustinalkio ei ole vakiolauseke" -#: cp/semantics.c:8679 +#: cp/semantics.c:8619 +#, fuzzy, gcc-internal-format +msgid "cast to non-integral type %qT in a constant expression" +msgstr "ylivuoto vakiolausekkeessa" + +#: cp/semantics.c:8695 #, fuzzy, gcc-internal-format -#| msgid "initializer element is not a constant expression" msgid "division by zero is not a constant-expression" msgstr "alustinalkio ei ole vakiolauseke" -#: cp/semantics.c:8802 +#: cp/semantics.c:8819 #, fuzzy, gcc-internal-format -#| msgid "nonconstant array index in initializer" msgid "non-constant array initialization" msgstr "ei-vakio taulukon indeksi alustimessa" -#: cp/semantics.c:8811 +#: cp/semantics.c:8828 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "unexpected AST of kind %s" msgstr "vektoriylivuoto lausekkeessa" -#: cp/semantics.c:9303 +#: cp/semantics.c:9320 #, gcc-internal-format msgid "cannot capture %qE by reference" msgstr "" -#: cp/semantics.c:9326 +#: cp/semantics.c:9343 #, fuzzy, gcc-internal-format msgid "already captured %qD in lambda expression" msgstr "epäkelvot operandit binääriselle %s-operaatiolle" -#: cp/semantics.c:9472 +#: cp/semantics.c:9515 #, fuzzy, gcc-internal-format msgid "%<this%> was not captured for this lambda function" msgstr "%<this%> ei ole käytettävissä staattisissa jäsenfunktioissa" @@ -35965,95 +35552,95 @@ msgstr "%<this%> ei ole käytettävissä staattisissa jäsenfunktioissa" msgid "%qV qualifiers cannot be applied to %qT" msgstr "" -#: cp/tree.c:3084 +#: cp/tree.c:3078 #, gcc-internal-format msgid "%qE attribute can only be applied to Java class definitions" msgstr "" -#: cp/tree.c:3113 +#: cp/tree.c:3107 #, gcc-internal-format msgid "%qE attribute can only be applied to class definitions" msgstr "" -#: cp/tree.c:3119 +#: cp/tree.c:3113 #, gcc-internal-format msgid "%qE is obsolete; g++ vtables are now COM-compatible by default" msgstr "%qE on vanhentunut; g++:n vtable'it ovat nyt oletusarvoisesti COM-yhteensopivia" -#: cp/tree.c:3143 +#: cp/tree.c:3137 #, gcc-internal-format msgid "requested init_priority is not an integer constant" msgstr "" -#: cp/tree.c:3164 +#: cp/tree.c:3158 #, gcc-internal-format msgid "can only use %qE attribute on file-scope definitions of objects of class type" msgstr "" -#: cp/tree.c:3172 +#: cp/tree.c:3166 #, gcc-internal-format msgid "requested init_priority is out of range" msgstr "" -#: cp/tree.c:3182 +#: cp/tree.c:3176 #, gcc-internal-format msgid "requested init_priority is reserved for internal use" msgstr "" -#: cp/tree.c:3193 +#: cp/tree.c:3187 #, gcc-internal-format msgid "%qE attribute is not supported on this platform" msgstr "" -#: cp/tree.c:3220 +#: cp/tree.c:3214 #, fuzzy, gcc-internal-format msgid "redeclaration of %qD adds abi tag %E" msgstr "%qs:n esittely taulukollisena tyhjiä alkioita" -#: cp/tree.c:3226 +#: cp/tree.c:3220 #, fuzzy, gcc-internal-format msgid "previous declaration here" msgstr "%J%qD:n edellinen esittely oli täällä" -#: cp/tree.c:3243 +#: cp/tree.c:3237 #, fuzzy, gcc-internal-format msgid "%qE attribute applied to non-class, non-enum type %qT" msgstr "%qs-attribuuttia ei huomioida ei-luokkatyypeille" -#: cp/tree.c:3249 +#: cp/tree.c:3243 #, fuzzy, gcc-internal-format msgid "%qE attribute applied to %qT after its definition" msgstr "%J%qE-attribuutti soveltuu vain funktioihin" -#: cp/tree.c:3271 +#: cp/tree.c:3265 #, fuzzy, gcc-internal-format msgid "%qE attribute applied to non-function %qD" msgstr "%J%qE-attribuutti soveltuu vain funktioihin" -#: cp/tree.c:3276 +#: cp/tree.c:3270 #, fuzzy, gcc-internal-format msgid "%qE attribute applied to extern \"C\" function %qD" msgstr "%J%qE-attribuutti soveltuu vain funktioihin" -#: cp/tree.c:3977 +#: cp/tree.c:3971 #, fuzzy, gcc-internal-format msgid "zero as null pointer constant" msgstr "haluttu sijainti ei ole kokonaislukuvakio" -#: cp/tree.c:3990 +#: cp/tree.c:3984 #, gcc-internal-format, gfc-internal-format msgid "lang_* check: failed in %s, at %s:%d" msgstr "" #: cp/typeck.c:451 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "comparison between distinct pointer types %qT and %qT lacks a cast" -msgstr "tyyppien %qT ja %qT välinen vertailu" +msgstr "erilaisten osoitintyyppien %qT ja %qT välisestä vertailusta puuttuu tyyppimuunnos" #: cp/typeck.c:457 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "conversion between distinct pointer types %qT and %qT lacks a cast" -msgstr "tyyppien %qT ja %qT välinen vertailu" +msgstr "erilaisten osoitintyyppien %qT ja %qT välisestä muunnoksesta puuttuu tyyppimuunnos" #: cp/typeck.c:463 #, gcc-internal-format @@ -36172,9 +35759,9 @@ msgid "invalid access to non-static data member %qD of NULL object" msgstr "ei-staattista datajäsentä %q+D käytetty virheellisesti" #: cp/typeck.c:2478 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "object type %qT does not match destructor name ~%qT" -msgstr "prototyypille %q#D ei ole vastinetta luokassa %qT" +msgstr "objektityyppi %qT ei täsmää hajottimen nimen ~%qT kanssa" #: cp/typeck.c:2486 #, gcc-internal-format @@ -36208,7 +35795,6 @@ msgstr "" #: cp/typeck.c:2906 #, fuzzy, gcc-internal-format -#| msgid "invalid use of flexible array member" msgid "invalid use of array indexing on pointer to member" msgstr "joustavien taulukkoalkioiden epäkelpo käyttö" @@ -36274,7 +35860,6 @@ msgstr "kenttä %qs esitelty funktiona" #: cp/typeck.c:3412 #, fuzzy, gcc-internal-format -#| msgid "destructor cannot be static member function" msgid "expression cannot be used as a function" msgstr "hajotin ei voi olla staattinen jäsenfunktio" @@ -36285,31 +35870,26 @@ msgstr "liikaa argumentteja funktiolle %s %q+#D" #: cp/typeck.c:3462 #, fuzzy, gcc-internal-format -#| msgid "too few arguments to function %qE" msgid "too few arguments to constructor %q#D" msgstr "liian vähän argumentteja funktiolle %qE" #: cp/typeck.c:3467 #, fuzzy, gcc-internal-format -#| msgid "too many arguments to function %qE" msgid "too many arguments to member function %q#D" msgstr "liian monta argumenttia funktiolle %qE" #: cp/typeck.c:3468 #, fuzzy, gcc-internal-format -#| msgid "too few arguments to function %qE" msgid "too few arguments to member function %q#D" msgstr "liian vähän argumentteja funktiolle %qE" #: cp/typeck.c:3474 #, fuzzy, gcc-internal-format -#| msgid "too many arguments to function %qE" msgid "too many arguments to function %q#D" msgstr "liian monta argumenttia funktiolle %qE" #: cp/typeck.c:3475 #, fuzzy, gcc-internal-format -#| msgid "too few arguments to function %qE" msgid "too few arguments to function %q#D" msgstr "liian vähän argumentteja funktiolle %qE" @@ -36354,14 +35934,14 @@ msgid "NULL used in arithmetic" msgstr "NULL-arvon käyttö laskutoimituksessa" #: cp/typeck.c:4188 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "left rotate count is negative" -msgstr "taulukon %qs koko on negatiivinen" +msgstr "vasemmalle kierron laskuri on negatiivinen" #: cp/typeck.c:4189 #, gcc-internal-format msgid "right rotate count is negative" -msgstr "" +msgstr "oikealle kierron laskuri on negatiivinen" #: cp/typeck.c:4195 #, gcc-internal-format @@ -36374,9 +35954,9 @@ msgid "right rotate count >= width of type" msgstr "" #: cp/typeck.c:4217 cp/typeck.c:4451 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "comparison with string literal results in unspecified behaviour" -msgstr "%J#pragma weak %qD -ilmaisun soveltaminen ensimmäisen käytön jälkeen käyttäytyy määrittelemättömästi" +msgstr "vertailu merkkijonoliteraaliin johtaa määrittelemättömään toimintaan" #: cp/typeck.c:4237 cp/typeck.c:4250 #, gcc-internal-format @@ -36497,14 +36077,14 @@ msgid "ISO C++ forbids decrementing an enum" msgstr "ISO C++ kieltää enumin vähentämisen" #: cp/typeck.c:5539 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "cannot increment a pointer to incomplete type %qT" -msgstr "parametrilla %P on vaillinainen tyyppi %qT" +msgstr "ei voida kasvattaa osoitinta vaillinaiseen tyyppiin %qT" #: cp/typeck.c:5540 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "cannot decrement a pointer to incomplete type %qT" -msgstr "parametrilla %P on vaillinainen tyyppi %qT" +msgstr "ei voida vähentää osoitinta vaillinaiseen tyyppiin %qT" #: cp/typeck.c:5551 #, gcc-internal-format @@ -36519,7 +36099,7 @@ msgstr "ISO C++ kieltää %qT-tyyppisen osoittimen vähentämisen" #: cp/typeck.c:5585 #, gcc-internal-format msgid "invalid use of Boolean expression as operand to %<operator--%>" -msgstr "" +msgstr "virheellinen loogisen lausekkeen käyttö operandina %<operator--%>:lle" #: cp/typeck.c:5747 #, gcc-internal-format @@ -36567,30 +36147,29 @@ msgid "no context to resolve type of %qE" msgstr "" #: cp/typeck.c:6024 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "cast from type %qT to type %qT casts away qualifiers" -msgstr "virheellinen const_cast tyypistä %qT tyyppiin %qT" +msgstr "tyyppimuunnos tyypistä %qT tyyppiin %qT hylkää määreet" #: cp/typeck.c:6030 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "static_cast from type %qT to type %qT casts away qualifiers" -msgstr "virheellinen const_cast tyypistä %qT tyyppiin %qT" +msgstr "static_cast-muunnos tyypistä %qT tyyppiin %qT hylkää määreet" #: cp/typeck.c:6036 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "reinterpret_cast from type %qT to type %qT casts away qualifiers" -msgstr "virheellinen const_cast tyypistä %qT tyyppiin %qT" +msgstr "reinterpret_cast-muunnos tyypistä %qT tyyppiin %qT hylkää määreet" #: cp/typeck.c:6063 -#, fuzzy, gcc-internal-format -#| msgid "%qE is not of type %qT" +#, gcc-internal-format msgid "useless cast to type %qT" -msgstr "%qE ei ole tyyppiä %qT" +msgstr "tarpeeton tyyppimuunnos tyyppiin %qT" #: cp/typeck.c:6405 #, gcc-internal-format msgid "invalid static_cast from type %qT to type %qT" -msgstr "" +msgstr "virheellinen static_cast-muunnos tyypistä %qT tyyppiin %qT" #: cp/typeck.c:6431 #, gcc-internal-format @@ -36610,7 +36189,7 @@ msgstr "muunnoksessa tyypistä %qT tyyppiin %qT menetetään tarkkuutta" #: cp/typeck.c:6593 #, gcc-internal-format msgid "cast from %qT to %qT increases required alignment of target type" -msgstr "" +msgstr "muunnos tyypistä %qT tyyppiin %qT kasvattaa kohdetyypin vaadittua kohdistusta" #. Only issue a warning, as we have always supported this #. where possible, and it is necessary in some cases. DR 195 @@ -36649,12 +36228,12 @@ msgstr "virheellinen const_cast tyypistä %qT tyyppiin %qT" #: cp/typeck.c:6877 cp/typeck.c:6885 #, gcc-internal-format msgid "ISO C++ forbids casting to an array type %qT" -msgstr "" +msgstr "ISO C++ kieltää tyyppimuunnoksen taulukkotyyppiin %qT" #: cp/typeck.c:6894 #, gcc-internal-format msgid "invalid cast to function type %qT" -msgstr "" +msgstr "virheellinen tyyppimuunnos funktiotyyppiin %qT" #: cp/typeck.c:7176 #, gcc-internal-format @@ -36663,24 +36242,23 @@ msgstr "" #: cp/typeck.c:7237 #, fuzzy, gcc-internal-format -#| msgid "nonconstant array index in initializer" msgid "assigning to an array from an initializer list" msgstr "ei-vakio taulukon indeksi alustimessa" #: cp/typeck.c:7251 #, gcc-internal-format msgid "incompatible types in assignment of %qT to %qT" -msgstr "" +msgstr "vaillinaiset tyypit %qT:n sijoituksessa tyyppiin %qT" #: cp/typeck.c:7265 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "array used as initializer" -msgstr "skalaarialustimen ympärillä on aaltosulkeet" +msgstr "taulukkoa käytetty alustimena" #: cp/typeck.c:7267 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid array assignment" -msgstr "epäkelpo lvalue sijoituksessa" +msgstr "virheellinen taulukkosijoitus" #: cp/typeck.c:7374 #, gcc-internal-format @@ -36709,7 +36287,6 @@ msgstr "ei voi muuntaa tyypistä %1$qT tyyppiin %2$qT %4$qD:n argumentiksi %3$qP #: cp/typeck.c:7819 #, fuzzy, gcc-internal-format -#| msgid "cannot convert %qT to %qT for argument %qP to %qD" msgid "cannot convert %qT to %qT in default argument" msgstr "ei voi muuntaa tyypistä %1$qT tyyppiin %2$qT %4$qD:n argumentiksi %3$qP" @@ -36717,7 +36294,6 @@ msgstr "ei voi muuntaa tyypistä %1$qT tyyppiin %2$qT %4$qD:n argumentiksi %3$qP # %s on "initialization", jota EI VOI suomentaa tällä hetkellä. #: cp/typeck.c:7823 #, fuzzy, gcc-internal-format -#| msgid "cannot convert %qT to %qT in %s" msgid "cannot convert %qT to %qT in argument passing" msgstr "ei voi muuntaa tyypistä %qT tyyppiin %qT (%s)" @@ -36725,7 +36301,6 @@ msgstr "ei voi muuntaa tyypistä %qT tyyppiin %qT (%s)" # %s on "initialization", jota EI VOI suomentaa tällä hetkellä. #: cp/typeck.c:7827 #, fuzzy, gcc-internal-format -#| msgid "cannot convert %qT to %qT in %s" msgid "cannot convert %qT to %qT" msgstr "ei voi muuntaa tyypistä %qT tyyppiin %qT (%s)" @@ -36733,7 +36308,6 @@ msgstr "ei voi muuntaa tyypistä %qT tyyppiin %qT (%s)" # %s on "initialization", jota EI VOI suomentaa tällä hetkellä. #: cp/typeck.c:7831 #, fuzzy, gcc-internal-format -#| msgid "cannot convert %qT to %qT in %s" msgid "cannot convert %qT to %qT in initialization" msgstr "ei voi muuntaa tyypistä %qT tyyppiin %qT (%s)" @@ -36741,7 +36315,6 @@ msgstr "ei voi muuntaa tyypistä %qT tyyppiin %qT (%s)" # %s on "initialization", jota EI VOI suomentaa tällä hetkellä. #: cp/typeck.c:7835 #, fuzzy, gcc-internal-format -#| msgid "cannot convert %qT to %qT in %s" msgid "cannot convert %qT to %qT in return" msgstr "ei voi muuntaa tyypistä %qT tyyppiin %qT (%s)" @@ -36749,7 +36322,6 @@ msgstr "ei voi muuntaa tyypistä %qT tyyppiin %qT (%s)" # %s on "initialization", jota EI VOI suomentaa tällä hetkellä. #: cp/typeck.c:7839 #, fuzzy, gcc-internal-format -#| msgid "cannot convert %qT to %qT in %s" msgid "cannot convert %qT to %qT in assignment" msgstr "ei voi muuntaa tyypistä %qT tyyppiin %qT (%s)" @@ -36794,14 +36366,14 @@ msgid "reference to non-lvalue returned" msgstr "" #: cp/typeck.c:8059 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "reference to local variable %q+D returned" -msgstr "palautettu viittaus paikalliseen muuttujaan %qD" +msgstr "palautettu viittaus paikalliseen muuttujaan %q+D" #: cp/typeck.c:8062 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "address of local variable %q+D returned" -msgstr "halutaan globaalin rekisterimuuttujan %qD osoite" +msgstr "palautettu osoite paikalliseen muuttujaan %q+D" #: cp/typeck.c:8099 #, gcc-internal-format @@ -36822,28 +36394,33 @@ msgid "returning a value from a constructor" msgstr "arvon palautus muodostimesta" #. Give a helpful error message. -#: cp/typeck.c:8133 cp/typeck.c:8172 +#: cp/typeck.c:8133 cp/typeck.c:8177 #, gcc-internal-format msgid "return-statement with no value, in function returning %qT" msgstr "return-lause ilman arvoa funktiossa, jonka paluutyyppi on %qT" -#: cp/typeck.c:8191 +#: cp/typeck.c:8141 +#, fuzzy, gcc-internal-format +msgid "returning initializer list" +msgstr "skalaarialustimen ympärillä on aaltosulkeet" + +#: cp/typeck.c:8196 #, gcc-internal-format msgid "return-statement with a value, in function returning 'void'" msgstr "arvo return-lauseelle funktiossa, jonka paluutyyppi on ”void”" -#: cp/typeck.c:8221 +#: cp/typeck.c:8226 #, gcc-internal-format msgid "%<operator new%> must not return NULL unless it is declared %<throw()%> (or -fcheck-new is in effect)" msgstr "%<operator new%> ei saa palauttaa NULLia ellei esittely ole %<throw()%> (tai -fcheck-new ole voimassa)" #. Make this a permerror because we used to accept it. -#: cp/typeck.c:8789 +#: cp/typeck.c:8794 #, gcc-internal-format msgid "using temporary as lvalue" msgstr "" -#: cp/typeck.c:8791 +#: cp/typeck.c:8796 #, gcc-internal-format msgid "using xvalue (rvalue reference) as lvalue" msgstr "" @@ -36856,44 +36433,42 @@ msgstr "tyyppi %qT ei ole tyypin %qT kantatyyppi" #: cp/typeck2.c:105 #, gcc-internal-format msgid "assignment of constant field %qD" -msgstr "vakiokenttään %qD sijoitus" +msgstr "sijoitus vakiokenttään %qD" #: cp/typeck2.c:107 #, fuzzy, gcc-internal-format -#| msgid "read-only location %qE used as %<asm%> output" msgid "constant field %qD used as %<asm%> output" msgstr "kirjoitussuojattua sijaintia %qE käytetään %<asm%>-tulosteena" #: cp/typeck2.c:109 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "increment of constant field %qD" -msgstr "kirjoitussuojatun muuttujan %qD kasvatus" +msgstr "vakiokentän %qD kasvatus" #: cp/typeck2.c:111 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "decrement of constant field %qD" -msgstr "kirjoitussuojatun muuttujan %qD vähennys" +msgstr "vakiokentän %qD vähennys" #: cp/typeck2.c:118 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "assignment of read-only reference %qD" -msgstr "sijoitus kirjoitussuojattuun jäseneen %qD" +msgstr "sijoitus kirjoitussuojattuun viitteeseen %qD" #: cp/typeck2.c:120 #, fuzzy, gcc-internal-format -#| msgid "read-only location %qE used as %<asm%> output" msgid "read-only reference %qD used as %<asm%> output" msgstr "kirjoitussuojattua sijaintia %qE käytetään %<asm%>-tulosteena" #: cp/typeck2.c:122 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "increment of read-only reference %qD" -msgstr "kirjoitussuojatun jäsenen %qD kasvatus" +msgstr "kirjoitussuojatun viitteen %qD kasvatus" #: cp/typeck2.c:124 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "decrement of read-only reference %qD" -msgstr "kirjoitussuojatun jäsenen %qD vähennys" +msgstr "kirjoitussuojatun viitteen %qD vähennys" #: cp/typeck2.c:308 #, gcc-internal-format @@ -36953,13 +36528,11 @@ msgstr "" #: cp/typeck2.c:390 #, fuzzy, gcc-internal-format -#| msgid "%qD has an incomplete type" msgid "%q+D has incomplete type" msgstr "%qD on vaillinaista tyyppiä" #: cp/typeck2.c:403 #, fuzzy, gcc-internal-format -#| msgid "invalid use of incomplete typedef %qD" msgid "invalid use of incomplete type %q#T" msgstr "vaillinaisen tyypin typedef %qD epäkelpo käyttö" @@ -36990,19 +36563,16 @@ msgstr "" #: cp/typeck2.c:451 #, fuzzy, gcc-internal-format -#| msgid "invalid use of incomplete typedef %qD" msgid "invalid use of template type parameter %qT" msgstr "vaillinaisen tyypin typedef %qD epäkelpo käyttö" #: cp/typeck2.c:456 #, fuzzy, gcc-internal-format -#| msgid "invalid use of incomplete typedef %qD" msgid "invalid use of template template parameter %qT" msgstr "vaillinaisen tyypin typedef %qD epäkelpo käyttö" #: cp/typeck2.c:462 #, fuzzy, gcc-internal-format -#| msgid "invalid use of incomplete typedef %qD" msgid "invalid use of dependent type %qT" msgstr "vaillinaisen tyypin typedef %qD epäkelpo käyttö" @@ -37029,17 +36599,17 @@ msgstr "" #: cp/typeck2.c:674 #, gcc-internal-format msgid "constructor syntax used, but no constructor declared for type %qT" -msgstr "" +msgstr "muodostinsyntaksia on käytetty, mutta %qT-tyypin muodostinta ei ole esitelty" #: cp/typeck2.c:687 #, gcc-internal-format msgid "cannot initialize arrays using this syntax" -msgstr "" +msgstr "taulukoita ei voi alustaa tätä syntaksia käyttäen" #: cp/typeck2.c:830 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "narrowing conversion of %qE from %qT to %qT inside { }" -msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT" +msgstr "%qE:n kaventava muunnos tyypistä %qT tyyppiin %qT { }:n sisällä" #: cp/typeck2.c:834 #, fuzzy, gcc-internal-format @@ -37049,12 +36619,12 @@ msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT" #: cp/typeck2.c:897 #, gcc-internal-format msgid "int-array initialized from non-wide string" -msgstr "" +msgstr "int-taulukko alustettu epäleveästä merkkijonosta" #: cp/typeck2.c:903 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "int-array initialized from incompatible wide string" -msgstr "wchar_t-taulukkoa alustetaan epäleveästä merkkijonosta" +msgstr "int-taulukko alustettu yhteensopimattomasta leveästä merkkijonosta" #: cp/typeck2.c:923 #, gcc-internal-format @@ -37138,7 +36708,6 @@ msgstr "" #: cp/typeck2.c:1678 #, fuzzy, gcc-internal-format -#| msgid "invalid cast from type %qT to type %qT" msgid "functional cast to array type %qT" msgstr "virheellinen muunnos tyypistä %qT tyyppiin %qT" @@ -37180,22 +36749,22 @@ msgstr "" #: fortran/arith.c:1918 #, gcc-internal-format, gfc-internal-format msgid "Arithmetic overflow converting %s to %s at %L. This check can be disabled with the option -fno-range-check" -msgstr "" +msgstr "Aritmeettinen ylivuoto muunnettaessa %s arvoksi %s kohdassa %L. Tämä tarkistus voidaan ottaa pois käytöstä valitsimella -fno-range-check" #: fortran/arith.c:1923 #, gcc-internal-format, gfc-internal-format msgid "Arithmetic underflow converting %s to %s at %L. This check can be disabled with the option -fno-range-check" -msgstr "" +msgstr "Aritmeettien alivuoto muunnettaessa %s arvoksi %s kohdassa %L. Tämä tarkistus voidaan ottaa pois käytöstä valitsimella -fno-range-check" #: fortran/arith.c:1928 #, gcc-internal-format, gfc-internal-format msgid "Arithmetic NaN converting %s to %s at %L. This check can be disabled with the option -fno-range-check" -msgstr "" +msgstr "Aritmeettinen NaN muunnettaessa %s arvoksi %s kohdassa %L. Tämä tarkistus voidaan ottaa pois käytöstä valitsimella -fno-range-check" #: fortran/arith.c:1933 #, gcc-internal-format, gfc-internal-format msgid "Division by zero converting %s to %s at %L" -msgstr "" +msgstr "Jako nollalla muunnettaessa %s arvoksi %s kohdassa %L" #: fortran/arith.c:1937 #, gcc-internal-format, gfc-internal-format @@ -37213,9 +36782,9 @@ msgid "The Hollerith constant at %L is too long to convert to %s" msgstr "" #: fortran/array.c:94 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected array subscript at %C" -msgstr "taulukon indeksin tyyppi on %<char%>" +msgstr "Odotettiin taulukkoindeksiä kohdassa %C" #: fortran/array.c:103 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -37235,12 +36804,12 @@ msgstr "taulukon indeksin tyyppi on %<char%>" #: fortran/array.c:192 #, gcc-internal-format, gfc-internal-format msgid "Invalid form of array reference at %C" -msgstr "" +msgstr "Virheellinen taulukkoviitemuoto kohdassa %C" #: fortran/array.c:197 fortran/array.c:270 #, gcc-internal-format, gfc-internal-format msgid "Array reference at %C cannot have more than %d dimensions" -msgstr "" +msgstr "Taulukkoviitteellä kohdassa %C ei voi olla yli %d ulottuvuutta" #: fortran/array.c:212 fortran/array.c:598 fortran/check.c:2162 #: fortran/check.c:3944 fortran/check.c:3982 fortran/check.c:4153 @@ -37328,7 +36897,7 @@ msgstr "" #: fortran/array.c:567 fortran/array.c:676 #, gcc-internal-format, gfc-internal-format msgid "Expected another dimension in array declaration at %C" -msgstr "" +msgstr "Odotettiin toista ulottuvuutta taulukkoesittelyssä kohdassa %C" #: fortran/array.c:573 fortran/array.c:604 fortran/array.c:682 #, gcc-internal-format, gfc-internal-format @@ -37360,117 +36929,118 @@ msgstr "muuttuvakokoista objektia ei voi alustaa" msgid "DO-iterator '%s' at %L is inside iterator of the same name" msgstr "" -#: fortran/array.c:1010 fortran/array.c:1143 +#: fortran/array.c:1010 fortran/array.c:1154 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in array constructor at %C" -msgstr "" +msgstr "Syntaksivirhe taulukkomuodostimessa kohdassa %C" -#: fortran/array.c:1062 +#: fortran/array.c:1063 #, gcc-internal-format, gfc-internal-format msgid "[...] style array constructors at %C" msgstr "" -#: fortran/array.c:1083 +#: fortran/array.c:1085 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "Array constructor including type specification at %C" msgstr "%qD esitelty extern-avainsanalla sisäkkäin" -#: fortran/array.c:1089 fortran/match.c:3469 +#: fortran/array.c:1094 fortran/match.c:3469 #, gcc-internal-format, gfc-internal-format msgid "Type-spec at %L cannot contain a deferred type parameter" msgstr "" -#: fortran/array.c:1105 +#: fortran/array.c:1116 #, gcc-internal-format, gfc-internal-format msgid "Empty array constructor at %C is not allowed" -msgstr "" +msgstr "Tyhjä taulukkomuodostin kohdassa %C ei ole sallittu" -#: fortran/array.c:1190 +#: fortran/array.c:1201 #, gcc-internal-format, gfc-internal-format msgid "Element in %s array constructor at %L is %s" -msgstr "" +msgstr "Alkio %s-taulukkomuodostimessa kohdassa %L on %s" -#: fortran/array.c:1518 +#: fortran/array.c:1529 #, gcc-internal-format, gfc-internal-format msgid "Iterator step at %L cannot be zero" -msgstr "" +msgstr "Iteraattoriaskel kohdassa %L ei voi olla nolla" #. Problems occur when we get something like #. integer :: a(lots) = (/(i, i=1, lots)/) -#: fortran/array.c:1655 fortran/expr.c:1535 fortran/trans-array.c:5370 +#: fortran/array.c:1666 fortran/expr.c:1535 fortran/trans-array.c:5370 #, 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 "" -#: fortran/array.c:1826 +#: fortran/array.c:1837 #, gcc-internal-format, gfc-internal-format msgid "AC-IMPLIED-DO initial expression references control variable at %L" msgstr "" -#: fortran/array.c:1833 +#: fortran/array.c:1844 #, gcc-internal-format, gfc-internal-format msgid "AC-IMPLIED-DO final expression references control variable at %L" msgstr "" -#: fortran/array.c:1840 +#: fortran/array.c:1851 #, gcc-internal-format, gfc-internal-format msgid "AC-IMPLIED-DO step expression references control variable at %L" msgstr "" -#: fortran/array.c:1852 +#: fortran/array.c:1863 #, gcc-internal-format, gfc-internal-format msgid "Array constructor value at %L shall not be unlimited polymorphic [F2008: C4106]" msgstr "" -#: fortran/array.c:1935 +#: fortran/array.c:1946 #, gcc-internal-format, gfc-internal-format msgid "Different CHARACTER lengths (%d/%d) in array constructor at %L" msgstr "" +# Intrisiittinen funktio on monissa ohjelmointikielissä sama kuin built-in funktio. #: fortran/check.c:46 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be a scalar" -msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava skalaari" #: fortran/check.c:62 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be %s" -msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava %4$s" #: fortran/check.c:90 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be a numeric type" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava numeerinen tyyppi" #: fortran/check.c:105 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or REAL" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava INTEGER tai REAL" #: fortran/check.c:122 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be REAL or COMPLEX" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava REAL tai COMPLEX" #: fortran/check.c:139 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or PROCEDURE" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava INTEGER tai PROCEDURE" #: fortran/check.c:168 fortran/check.c:5226 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be a constant" -msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava vakio" #: fortran/check.c:177 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Invalid kind for %s at %L" -msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT" +msgstr "" #: fortran/check.c:196 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be double precision" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava kaksoistarkkuusliukuluku" #: fortran/check.c:219 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -37480,12 +37050,12 @@ msgstr "%<__builtin_args_info%>-funktion argumentti puuttuu" #: fortran/check.c:236 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be a logical array" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava looginen taulukko" #: fortran/check.c:262 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be an array" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava taulukko" #: fortran/check.c:283 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -37520,42 +37090,42 @@ msgstr "" #: fortran/check.c:406 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be the same type and kind as '%s'" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava saman tyyppinen ja kaltainen kuin ”%4$s”" #: fortran/check.c:423 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be of rank %d" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava %4$d tasoa" #: fortran/check.c:438 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must not be OPTIONAL" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentti ”%1$s” kohdassa %3$L ei saa olla OPTIONAL" #: fortran/check.c:459 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be ALLOCATABLE" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava ALLOCATABLE" #: fortran/check.c:477 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be of kind %d" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava %4$d:n kaltainen" #: fortran/check.c:515 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L cannot be INTENT(IN)" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L ei voi olla INTENT(IN)" #: fortran/check.c:536 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be a variable" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava muuttuja" #: fortran/check.c:585 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "'dim' argument of '%s' intrinsic at %L is not a valid codimension index" -msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentti ”%1$s” kohdassa %3$L ei ole kelvollinen ulottuvuusindeksi" #: fortran/check.c:638 #, gcc-internal-format, gfc-internal-format @@ -37565,12 +37135,12 @@ msgstr "" #: fortran/check.c:736 #, gcc-internal-format, gfc-internal-format msgid "Unequal character lengths (%ld/%ld) in %s at %L" -msgstr "" +msgstr "Erisuuret merkkipituudet (%ld/%ld) merkkijonossa %s kohdassa %L" #: fortran/check.c:858 fortran/check.c:5195 #, gcc-internal-format, gfc-internal-format msgid "'%s' and '%s' arguments of '%s' intrinsic at %L must have the same type" -msgstr "" +msgstr "kääntäjänsisäisen ”%3$s”-funktion argumenttien ”%1$s” ja ”%2$s” kohdassa %4$L on oltava samaa tyyppiä" #: fortran/check.c:867 fortran/check.c:1806 fortran/check.c:1932 #: fortran/check.c:2006 fortran/check.c:2358 @@ -37591,12 +37161,12 @@ msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" #: fortran/check.c:930 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be a pointer or target VARIABLE or FUNCTION" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava osoitin tai VARIABLE tai FUNCTION" #: fortran/check.c:939 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be a POINTER or a TARGET" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava POINTER tai TARGET" #: fortran/check.c:964 #, gcc-internal-format, gfc-internal-format @@ -37641,12 +37211,12 @@ msgstr "liian paljon argumentteja funktiolle %qs" #: fortran/check.c:1256 fortran/check.c:1426 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must not be present if 'x' is COMPLEX" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentti ”%1$s” kohdassa %3$L ei saa olla läsnä, jos ”x” on COMPLEX-tyyppinen " #: fortran/check.c:1265 fortran/check.c:1435 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must have a type of either REAL or INTEGER" -msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava joko REAL tai INTEGER" #: fortran/check.c:1279 fortran/check.c:1284 #, gcc-internal-format, gfc-internal-format @@ -37662,19 +37232,19 @@ msgid "'%s' intrinsic with KIND argument at %L" msgstr "" #: fortran/check.c:1367 fortran/check.c:1617 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L has invalid shape in dimension %d (%ld/%ld)" -msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" +msgstr "" #: fortran/check.c:1382 fortran/check.c:1632 fortran/check.c:1660 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "'%s' argument of intrinsic '%s' at %L of must have rank %d or be a scalar" -msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava tasoa %d tai sen on oltava skalaari" #: fortran/check.c:1485 fortran/check.c:2452 fortran/check.c:2460 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be numeric or LOGICAL" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava numeerinen tai LOGICAL" #: fortran/check.c:1499 #, gcc-internal-format, gfc-internal-format @@ -37684,7 +37254,7 @@ msgstr "" #: fortran/check.c:1518 fortran/check.c:1526 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be default real" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava oletusreaaliluku" #: fortran/check.c:1547 #, gcc-internal-format, gfc-internal-format @@ -37704,12 +37274,12 @@ msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" #: fortran/check.c:1902 #, gcc-internal-format, gfc-internal-format msgid "Argument of %s at %L must be of length one" -msgstr "" +msgstr "Argumentin %s kohdassa %L on oltava pituudeltaan yksi" #: fortran/check.c:1961 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be the same kind as '%s'" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava merkkijonon ”%4$s” kaltainen" #: fortran/check.c:2051 #, gcc-internal-format, gfc-internal-format @@ -37724,17 +37294,17 @@ msgstr "" #: fortran/check.c:2124 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be a non-derived type" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava ei-perityn tyyppinen" #: fortran/check.c:2331 #, gcc-internal-format, gfc-internal-format msgid "Intrinsic '%s' at %L must have at least two arguments" -msgstr "" +msgstr "Kääntäjänsisäisellä ”%s”-funktiolla kohdassa %L on oltava vähintään kaksi argumenttia" #: fortran/check.c:2364 #, gcc-internal-format, gfc-internal-format msgid "'a%d' argument of '%s' intrinsic at %L must be %s(%d)" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”a%1$d” kohdassa %3$L on oltava %4$s(%5$d)" #: fortran/check.c:2395 #, gcc-internal-format, gfc-internal-format @@ -37744,12 +37314,12 @@ msgstr "" #: fortran/check.c:2402 #, gcc-internal-format, gfc-internal-format msgid "'a1' argument of '%s' intrinsic at %L must be INTEGER, REAL or CHARACTER" -msgstr "" +msgstr "kääntäjänsisäisen ”%s”-funktion ”al” kohdassa %L on oltava INTEGER, REAL tai CHARACTER" #: fortran/check.c:2469 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Argument types of '%s' intrinsic at %L must match (%s/%s)" -msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" +msgstr "Kääntäjänsisäisen ”%s”-funktion argumenttityyppien kohdassa %L on täsmättävä (%s/%s)" #: fortran/check.c:2483 #, gcc-internal-format, gfc-internal-format @@ -37764,12 +37334,12 @@ msgstr "" #: fortran/check.c:2511 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be of rank 1 or 2" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion ”%1$s”-argumentin kohdassa %3$L on oltava tasoa 1 tai 2" #: fortran/check.c:2686 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER" -msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava POINTER" #: fortran/check.c:2746 #, gcc-internal-format, gfc-internal-format @@ -37819,17 +37389,17 @@ msgstr "" #: fortran/check.c:3011 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be of a dummy variable" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava valemuuttuja" #: fortran/check.c:3019 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be of an OPTIONAL dummy variable" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava OPTIONAL-valemuuttuja" #: fortran/check.c:3038 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must not be a subobject of '%s'" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentti ”%1$s” kohdassa %3$L ”ei saa olla ”%4$s”:n aliobjekti" #: fortran/check.c:3086 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -37839,12 +37409,12 @@ msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" #: fortran/check.c:3190 #, gcc-internal-format, gfc-internal-format msgid "'shape' argument of 'reshape' intrinsic at %L must be an array of constant size" -msgstr "" +msgstr "kääntäjänsisäisen ”reshape”-funktion argumentti ”shape” kohdassa %L ei saa olla vakiokokoinen taulukko" #: fortran/check.c:3200 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L is empty" -msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on tyhjä" #: fortran/check.c:3207 #, gcc-internal-format, gfc-internal-format @@ -37852,24 +37422,24 @@ msgid "'shape' argument of 'reshape' intrinsic at %L has more than %d elements" msgstr "" #: fortran/check.c:3224 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L has negative element (%d)" -msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentilla ”%1$s” kohdassa %3$L on negatiivinen alkio (%4$d)" #: fortran/check.c:3264 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L has wrong number of elements (%d/%d)" -msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on väärä määrä alkioita (%4$d/%5$d)" #: fortran/check.c:3282 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L has out-of-range dimension (%d)" -msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on lukualueen ulkopuolinen ulottuvuus (%4$d)" #: fortran/check.c:3291 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L has invalid permutation of dimensions (dimension '%d' duplicated)" -msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on virheellinen ulottuvuuksia permutaatio (ulottuvuus ”%4$d” kahteen kertaan)" #: fortran/check.c:3327 #, gcc-internal-format, gfc-internal-format @@ -37879,12 +37449,12 @@ msgstr "" #: fortran/check.c:3344 fortran/check.c:3363 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L cannot be of type %s" -msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava %4$s" #: fortran/check.c:3354 fortran/check.c:3373 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be of an extensible type" -msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava laajennettavaa tyyppiä" #: fortran/check.c:3472 #, gcc-internal-format, gfc-internal-format @@ -37899,7 +37469,7 @@ msgstr "" #: fortran/check.c:3538 #, gcc-internal-format, gfc-internal-format msgid "'source' argument of 'shape' intrinsic at %L must not be an assumed size array" -msgstr "" +msgstr "kääntäjänsisäisen ”shape”-funktion argumentti ”source” kohdassa %L ei saa olla oletetun kokoinen taulukko" #: fortran/check.c:3615 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -37922,9 +37492,9 @@ msgid "'%s' argument of '%s' intrinsic at %L must be less than rank %d" msgstr "" #: fortran/check.c:3690 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L is not a valid dimension index" -msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentti ”%1$s” kohdassa %3$L ei ole kelvollinen ulottuvuusindeksi" #: fortran/check.c:3953 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -37944,7 +37514,7 @@ msgstr "" #: fortran/check.c:4079 #, gcc-internal-format, gfc-internal-format msgid "'MOLD' argument of 'TRANSFER' intrinsic at %L must not be %s" -msgstr "" +msgstr "kääntäjänsisäisen ”TRANSFER”-funktion argumentti ”MOLD” kohdassa %L ei saa olla %s" #: fortran/check.c:4107 #, gcc-internal-format, gfc-internal-format @@ -37952,24 +37522,24 @@ msgid "Intrinsic TRANSFER at %L has partly undefined result: source size %ld < r msgstr "" #: fortran/check.c:4229 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must have the same rank as '%s' or be a scalar" -msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava samaa tasoa kuin ”%4$s” tai sen on oltava skalaari" #: fortran/check.c:4242 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' and '%s' arguments of '%s' intrinsic at %L must have identical shape." -msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" +msgstr "kääntäjänsisäisen ”%3$s”-funktion argumenttien ”%1$s” ja ”%2$s” kohdassa %4$L on oltava muodoltaan identtisiä." #: fortran/check.c:4501 fortran/check.c:4533 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Size of '%s' argument of '%s' intrinsic at %L too small (%i/%i)" -msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" +msgstr "Kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” koko kohdassa %3$L on liian pieni (%4$i/%5$i)" #: fortran/check.c:4541 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Too many arguments to %s at %L" -msgstr "liikaa argumentteja funktiolle %s %q+#D" +msgstr "Liikaa argumentteja funktiolle %s kohdassa %L" #: fortran/check.c:4827 #, gcc-internal-format, gfc-internal-format @@ -37979,7 +37549,7 @@ msgstr "" #: fortran/check.c:5179 fortran/check.c:5187 #, gcc-internal-format, gfc-internal-format msgid "'%s' argument of '%s' intrinsic at %L must be INTEGER or LOGICAL" -msgstr "" +msgstr "kääntäjänsisäisen ”%2$s”-funktion argumentin ”%1$s” kohdassa %3$L on oltava INTEGER tai LOGICAL" #: fortran/class.c:561 #, gcc-internal-format, gfc-internal-format @@ -38006,12 +37576,12 @@ msgstr "" #: fortran/cpp.c:447 #, gcc-internal-format msgid "To enable preprocessing, use -cpp" -msgstr "" +msgstr "Esiprosessoinnin käyttööottamiseksi, käytä valitsinta -cpp" #: fortran/cpp.c:544 fortran/cpp.c:555 fortran/cpp.c:661 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "opening output file %s: %s" -msgstr "avataan tulostetiedosto %s: %m" +msgstr "avataan tulostetiedosto %s: %s" #: fortran/data.c:65 #, gcc-internal-format, gfc-internal-format @@ -38026,22 +37596,22 @@ msgstr "" #: fortran/data.c:161 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "Initialization string starting at %L was truncated to fit the variable (%d/%d)" -msgstr "alustus yhteensopimattomasta osoitintyypistä" +msgstr "alustusmerkkijono typistetty, jotta se täsmäisi muuttujaan kohdassa %L" #: fortran/data.c:250 #, gcc-internal-format, gfc-internal-format msgid "'%s' at %L already is initialized at %L" -msgstr "" +msgstr "”%s” kohdassa %L on jo alustettu kohdassa %L" #: fortran/data.c:274 #, gcc-internal-format, gfc-internal-format msgid "Data element below array lower bound at %L" -msgstr "" +msgstr "Data-alkio taulukon alarajan alapuolella kohdassa %L" #: fortran/data.c:291 fortran/data.c:380 #, gcc-internal-format, gfc-internal-format msgid "Data element above array upper bound at %L" -msgstr "" +msgstr "Data-alkio taulukon ylärajan yläpuolella kohdassa %L" #: fortran/data.c:321 fortran/data.c:487 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -38061,22 +37631,22 @@ msgstr "" #: fortran/decl.c:382 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' must be a PARAMETER in DATA statement at %C" -msgstr "" +msgstr "Symbolin ”%s” täytyy olla PARAMETER DATA-lauseessa kohdassa %C" #: fortran/decl.c:407 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Invalid initializer %s in Data statement at %C" -msgstr "epäkelpo osoitintila %qs" +msgstr "Virheellinen alustin %s Data-lauseessa kohdassa %C" #: fortran/decl.c:509 #, gcc-internal-format, gfc-internal-format msgid "Initialization at %C is not allowed in a PURE procedure" -msgstr "" +msgstr "Alustus kohdassa %C ei ole sallittu PURE-proseduurissa" #: fortran/decl.c:571 #, gcc-internal-format, gfc-internal-format msgid "DATA statement at %C is not allowed in a PURE procedure" -msgstr "" +msgstr "DATA-lause kohdassa %C ei ole sallittu PURE-proseduurissa" #: fortran/decl.c:600 #, gcc-internal-format, gfc-internal-format @@ -38096,7 +37666,7 @@ msgstr "" #: fortran/decl.c:726 #, gcc-internal-format, gfc-internal-format msgid "Conflict in attributes of function argument at %C" -msgstr "" +msgstr "Ristiriita funktioargumentin attribuuteissa kohdassa %C" #: fortran/decl.c:753 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -38106,12 +37676,12 @@ msgstr "epäkelpo osoitintila %qs" #: fortran/decl.c:784 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in character length specification at %C" -msgstr "" +msgstr "Syntaksivirhe merkkipituusspesifikaatiossa kohdassa %C" #: fortran/decl.c:906 #, gcc-internal-format, gfc-internal-format msgid "Procedure '%s' at %C is already defined at %L" -msgstr "" +msgstr "Proseduuri ”%s” kohdassa %C on jo määritelty kohdassa %L" #: fortran/decl.c:914 #, gcc-internal-format, gfc-internal-format @@ -38121,7 +37691,7 @@ msgstr "Nimi ”%s” kohdassa %C on jo määritelty geneerisenä rajapintana ko #: fortran/decl.c:927 #, gcc-internal-format, gfc-internal-format msgid "Procedure '%s' at %C has an explicit interface and must not have attributes declared at %L" -msgstr "" +msgstr "Proseduurilla ”%s” kohdassa %C on eksplisiittinen rajapinta ja sillä ei saa olla attribuutteja, jotka on esitelty kohdassa %L" #: fortran/decl.c:999 #, gcc-internal-format, gfc-internal-format @@ -38181,12 +37751,12 @@ msgstr "" #: fortran/decl.c:1227 #, gcc-internal-format, gfc-internal-format msgid "CHARACTER expression at %L is being truncated (%d/%d)" -msgstr "" +msgstr "CHARACTER-lauseke kohdassa %L on typistetty (%d/%d)" #: fortran/decl.c:1234 #, 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 "Taulukkomuodostimen CHARACTER-alkioiden kohdassa %L on oltava saman pituisia (%d/%d)" #: fortran/decl.c:1324 #, gcc-internal-format, gfc-internal-format @@ -38196,7 +37766,7 @@ msgstr "" #: fortran/decl.c:1334 #, gcc-internal-format, gfc-internal-format msgid "PARAMETER at %L is missing an initializer" -msgstr "" +msgstr "PARAMETER kohdassa %L on ilman alustinta" #: fortran/decl.c:1344 #, gcc-internal-format, gfc-internal-format @@ -38264,9 +37834,9 @@ msgid "non-NULL pointer initialization at %C" msgstr "vektoriylivuoto lausekkeessa" #: fortran/decl.c:1786 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Function name '%s' not allowed at %C" -msgstr "%Jlohkoattribuutti ei ole sallittu %qD:lle" +msgstr "Funktionimi ”%s” ei ole sallittu kohdassa %C" #: fortran/decl.c:1853 #, gcc-internal-format, gfc-internal-format @@ -38289,9 +37859,9 @@ msgid "Old-style initialization at %C" msgstr "vektoriylivuoto lausekkeessa" #: fortran/decl.c:2014 fortran/decl.c:4963 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Initialization at %C isn't for a pointer variable" -msgstr "alustus tekee osoittimesta kokonaisluvun ilman tyyppimuunnosta" +msgstr "Alustus kohdassa %C ei ole osoitinmuuttuja" #: fortran/decl.c:2027 #, gcc-internal-format, gfc-internal-format @@ -38299,14 +37869,14 @@ msgid "Pointer initialization at %C requires '=>', not '='" msgstr "" #: fortran/decl.c:2036 fortran/decl.c:7804 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected an initialization expression at %C" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "Odotettiin alustuslauseketta kohdassa %C" #: fortran/decl.c:2043 #, gcc-internal-format, gfc-internal-format msgid "Initialization of variable at %C is not allowed in a PURE procedure" -msgstr "" +msgstr "Muuttujan alustus kohdassa %C ei ole sallittu PURE-proseduurissa" #: fortran/decl.c:2056 #, gcc-internal-format, gfc-internal-format @@ -38314,29 +37884,29 @@ msgid "Initialization of allocatable component at %C is not allowed" msgstr "" #: fortran/decl.c:2110 fortran/decl.c:2146 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Old-style type declaration %s*%d not supported at %C" -msgstr "%J%qD:n esittely varjostaa parametria" +msgstr "Vanhantyylinen esittely %s*%d ei ole tuettu kohdassa %C" #: fortran/decl.c:2151 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Nonstandard type declaration %s*%d at %C" -msgstr "%qD esitelty extern-avainsanalla sisäkkäin" +msgstr "Ei-vakio tyyppiesittely %s*%d kohdassa %C" #: fortran/decl.c:2202 fortran/decl.c:2278 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Missing right parenthesis at %C" -msgstr "polku puuttuu option %qs jälkeen" +msgstr "Puuttuva oikea sulje kohdassa %C" #: fortran/decl.c:2215 fortran/decl.c:2349 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected initialization expression at %C" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "Odotettiin alustuslauseketta kohdassa %C" #: fortran/decl.c:2223 fortran/decl.c:2355 #, gcc-internal-format, gfc-internal-format msgid "Expected scalar initialization expression at %C" -msgstr "" +msgstr "Odotettiin skalaarialustuslauseketta kohdassa %C" #: fortran/decl.c:2254 #, gcc-internal-format, gfc-internal-format @@ -38361,7 +37931,7 @@ msgstr "" #: fortran/decl.c:2507 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in CHARACTER declaration at %C" -msgstr "" +msgstr "Syntaksivirhe CHARACTER-esittelyssä kohdassa %C" #: fortran/decl.c:2592 #, gcc-internal-format, gfc-internal-format @@ -38396,7 +37966,6 @@ msgstr "" #: fortran/decl.c:2777 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Fortran 2003: CLASS statement at %C" msgid "CLASS statement at %C" msgstr "Fortran 2003: CLASS-lause kohdassa %C" @@ -38404,7 +37973,7 @@ msgstr "Fortran 2003: CLASS-lause kohdassa %C" #: fortran/decl.c:3208 #, gcc-internal-format, gfc-internal-format msgid "Type name '%s' at %C is ambiguous" -msgstr "" +msgstr "Tyyppinimi ”%s” kohdassa %C ei ole yksiselitteinen" #: fortran/decl.c:2841 #, gcc-internal-format, gfc-internal-format @@ -38424,7 +37993,7 @@ msgstr "" #: fortran/decl.c:3063 #, gcc-internal-format, gfc-internal-format msgid "Empty IMPLICIT statement at %C" -msgstr "" +msgstr "Tyhjä IMPLICIT-lause kohdassa %C" #: fortran/decl.c:3165 #, gcc-internal-format, gfc-internal-format @@ -38454,22 +38023,22 @@ msgstr "" #: fortran/decl.c:3264 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in IMPORT statement at %C" -msgstr "" +msgstr "Syntaksivirhe IMPORT-lauseessa kohdassa %C" #: fortran/decl.c:3563 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "Missing codimension specification at %C" -msgstr "lopetusalkio puuttuu funktiokutsusta" +msgstr "Puuttuva ulottuvuusspesifikaatio kohdassa %C" #: fortran/decl.c:3565 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Missing dimension specification at %C" -msgstr "lopetusalkio puuttuu funktiokutsusta" +msgstr "Puuttuva ulottuvuusspesifikaatio kohdassa %C" #: fortran/decl.c:3648 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Duplicate %s attribute at %L" -msgstr "ylimääräinen %<restrict%>" +msgstr "Kaksoiskappele %s attribuutti kohdassa %L" #: fortran/decl.c:3667 #, gcc-internal-format, gfc-internal-format @@ -38479,7 +38048,7 @@ msgstr "" #: fortran/decl.c:3677 #, gcc-internal-format, gfc-internal-format msgid "Attribute at %L is not allowed in a TYPE definition" -msgstr "" +msgstr "Attribuutti kohdassa %L ei ole sallittu TYPE-määrittelyssä" #: fortran/decl.c:3695 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -38489,7 +38058,7 @@ msgstr "%Jvanhanmallinen funktiomäärittely" #: fortran/decl.c:3706 #, gcc-internal-format, gfc-internal-format msgid "%s attribute at %L is not allowed outside of the specification part of a module" -msgstr "" +msgstr "%s-attribuutti kohdassa %L ei ole sallittu moduulin spesifikaatio-osan ulkopuolella" #: fortran/decl.c:3721 #, gcc-internal-format, gfc-internal-format @@ -38504,7 +38073,7 @@ msgstr "ylimääräinen %<restrict%>" #: fortran/decl.c:3780 fortran/decl.c:6804 #, gcc-internal-format, gfc-internal-format msgid "PROTECTED at %C only allowed in specification part of a module" -msgstr "" +msgstr "PROTECTED kohdassa %C on sallittu vain moduulin spesifikaatio-osassa" #: fortran/decl.c:3786 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -38524,7 +38093,7 @@ msgstr "ylimääräinen %<restrict%>" #: fortran/decl.c:3873 #, gcc-internal-format, gfc-internal-format msgid "Multiple identifiers provided with single NAME= specifier at %C" -msgstr "" +msgstr "Useita tunnisteita tarjottu yhdellä NAME= tarkenteella kohdassa %C" #: fortran/decl.c:3970 #, gcc-internal-format, gfc-internal-format @@ -38554,22 +38123,22 @@ msgstr "" #: fortran/decl.c:4030 #, gcc-internal-format, gfc-internal-format msgid "Variable '%s' at %L cannot have both the POINTER and BIND(C) attributes" -msgstr "" +msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä POINTER- että BIND(C)-attribuutit" #: fortran/decl.c:4038 #, gcc-internal-format, gfc-internal-format msgid "Variable '%s' at %L cannot have both the ALLOCATABLE and BIND(C) attributes" -msgstr "" +msgstr "Muuttujalla ”%s” kohdassa %L ei voi olla sekä ALLOCATABLE- että BIND(C)-attribuutit" #: fortran/decl.c:4050 #, gcc-internal-format, gfc-internal-format msgid "Return type of BIND(C) function '%s' at %L cannot be an array" -msgstr "" +msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla taulukko" #: fortran/decl.c:4058 #, gcc-internal-format, gfc-internal-format msgid "Return type of BIND(C) function '%s' at %L cannot be a character string" -msgstr "" +msgstr "BIND(C)-funktion ”%s” paluutyyppi kohdassa %L ei voi olla merkkijono" #. Use gfc_warning_now because we won't say that the symbol fails #. just because of this. @@ -38596,9 +38165,9 @@ msgid "Derived type at %C has not been previously defined and so cannot appear i msgstr "" #: fortran/decl.c:4337 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Syntax error in data declaration at %C" -msgstr "%qD esitelty extern-avainsanalla sisäkkäin" +msgstr "Syntaksivirhe data-esittelyssä kohdassa %C" #: fortran/decl.c:4411 #, gcc-internal-format, gfc-internal-format @@ -38613,27 +38182,27 @@ msgstr "" #: fortran/decl.c:4530 #, gcc-internal-format, gfc-internal-format msgid "Name '%s' at %C is the name of the procedure" -msgstr "" +msgstr "Nimi ”%s” kohdassa %C on proseduurin nimi" #: fortran/decl.c:4542 #, gcc-internal-format, gfc-internal-format msgid "Unexpected junk in formal argument list at %C" -msgstr "" +msgstr "Odottamatonta roskaa muodollisessa argumenttiluettelossa kohdassa %C" #: fortran/decl.c:4559 #, gcc-internal-format, gfc-internal-format msgid "Duplicate symbol '%s' in formal argument list at %C" -msgstr "" +msgstr "Kaksoiskappalesymboli ”%s” muodollisessa argumenttiluettelossa paikassa %C" #: fortran/decl.c:4610 #, gcc-internal-format, gfc-internal-format msgid "RESULT variable at %C must be different than function name" -msgstr "" +msgstr "RESULT-muuttujan paikassa %C on oltava erilainen kuin funktionimen" #: fortran/decl.c:4687 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Unexpected junk after function declaration at %C" -msgstr "%qD esitelty extern-avainsanalla sisäkkäin" +msgstr "Odottamatonta roskaa funktioesittelyn jälkeen kohdassa %C" #: fortran/decl.c:4697 fortran/decl.c:5730 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -38663,12 +38232,12 @@ msgstr "" #: fortran/decl.c:4985 fortran/decl.c:5168 fortran/decl.c:8286 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in PROCEDURE statement at %C" -msgstr "" +msgstr "Syntaksivirhe PROCEDURE-lauseessa kohdassa %C" #: fortran/decl.c:5034 fortran/decl.c:8187 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected '::' after binding-attributes at %C" -msgstr "tyhjä esittely" +msgstr "Odotettiin ”::” binding-attribuutin jälkeen kohdassa %C" #: fortran/decl.c:5041 #, gcc-internal-format, gfc-internal-format @@ -38681,14 +38250,14 @@ msgid "Procedure pointer component at %C" msgstr "tyhjä esittely" #: fortran/decl.c:5111 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Syntax error in procedure pointer component at %C" -msgstr "kokonaislukuylivuoto lausekkeessa" +msgstr "Syntaksivirhe proseduuriosoitinkomponentissa kohdassa %C" #: fortran/decl.c:5129 #, gcc-internal-format, gfc-internal-format msgid "PROCEDURE at %C must be in a generic interface" -msgstr "" +msgstr "PROCEDURE-lauseen kohdassa %C on oltava geneerisessä rajapinnassa" #: fortran/decl.c:5138 fortran/decl.c:7311 #, gcc-internal-format, gfc-internal-format @@ -38703,11 +38272,11 @@ msgstr "tyhjä esittely" #: fortran/decl.c:5276 #, gcc-internal-format, gfc-internal-format msgid "Expected formal argument list in function definition at %C" -msgstr "" +msgstr "Odotetiin muodollista argumenttiluetteloa funktiomäärittelyssä kohdassa %C" #: fortran/decl.c:5300 fortran/decl.c:5304 fortran/decl.c:5508 #: fortran/decl.c:5512 fortran/decl.c:5698 fortran/decl.c:5702 -#: fortran/symbol.c:1588 +#: fortran/symbol.c:1577 #, gcc-internal-format, gfc-internal-format msgid "BIND(C) attribute at %L can only be used for variables or common blocks" msgstr "" @@ -38803,9 +38372,9 @@ msgid "Missing closing paren for binding label at %C" msgstr "" #: fortran/decl.c:5852 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "No binding name is allowed in BIND(C) at %C" -msgstr "%Jlohkoattribuutti ei ole sallittu %qD:lle" +msgstr "Sitomisnimeä ei ole sallittu BIND(C):ssä kohdassa %C" #: fortran/decl.c:5858 #, gcc-internal-format, gfc-internal-format @@ -38818,40 +38387,40 @@ msgid "NAME not allowed on BIND(C) for ABSTRACT INTERFACE at %C" msgstr "" #: fortran/decl.c:6094 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Unexpected END statement at %C" -msgstr "tyhjä esittely" +msgstr "Odottamaton END-lause kohdassa %C" #: fortran/decl.c:6102 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "END statement instead of %s statement at %L" -msgstr "tyhjä esittely" +msgstr "Ei välitetä lausenimiöstä tyhjässä lauseessa kohdassa %L" #. We would have required END [something]. #: fortran/decl.c:6110 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "%s statement expected at %L" -msgstr "ylivuoto vakiolausekkeessa" +msgstr "%s-lausetta odotettiin kohdassa %L" #: fortran/decl.c:6121 #, gcc-internal-format, gfc-internal-format msgid "Expecting %s statement at %C" -msgstr "" +msgstr "Odotettiin %s-lausetta kohdassa %C" #: fortran/decl.c:6137 #, gcc-internal-format, gfc-internal-format msgid "Expected block name of '%s' in %s statement at %C" -msgstr "" +msgstr "Odotettiin ”%s”-lohkonimeä %s-lauseessa kohdassa %C" #: fortran/decl.c:6154 #, gcc-internal-format, gfc-internal-format msgid "Expected terminating name at %C" -msgstr "" +msgstr "Odotettiin päättävää nimeä kohdassa %C" #: fortran/decl.c:6163 fortran/decl.c:6171 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected label '%s' for %s statement at %C" -msgstr "tyhjä esittely" +msgstr "Odotettiin nimiötä ”%s” %s-lauseelle kohdassa %C" #: fortran/decl.c:6265 #, gcc-internal-format, gfc-internal-format @@ -38874,29 +38443,29 @@ msgid "Array specification must be deferred at %L" msgstr "" #: fortran/decl.c:6389 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Unexpected character in variable list at %C" -msgstr "tyhjä esittely" +msgstr "Odottamaton merkki muuttujaluettelossa kohdassa %C" #: fortran/decl.c:6426 #, gcc-internal-format, gfc-internal-format msgid "Expected '(' at %C" -msgstr "" +msgstr "Odotettiin ”(” kohdassa %C" #: fortran/decl.c:6440 fortran/decl.c:6480 #, gcc-internal-format, gfc-internal-format msgid "Expected variable name at %C" -msgstr "" +msgstr "Odotettiin muuttujanimeä kohdassa %C" #: fortran/decl.c:6456 #, gcc-internal-format, gfc-internal-format msgid "Cray pointer at %C must be an integer" -msgstr "" +msgstr "Cray-osoittimen kohdassa %C on oltava kokonaisluku" #: fortran/decl.c:6460 #, gcc-internal-format, gfc-internal-format msgid "Cray pointer at %C has %d bytes of precision; memory addresses require %d bytes" -msgstr "" +msgstr "Cray-osoittimella kohdassa %C on %d-tavun tarkkuus; muistiosoitteet vaativat %d tavua" #: fortran/decl.c:6466 #, gcc-internal-format, gfc-internal-format @@ -38906,12 +38475,12 @@ msgstr "Odotettiin merkkiä ”,” kohdassa %C" #: fortran/decl.c:6529 #, gcc-internal-format, gfc-internal-format msgid "Expected \")\" at %C" -msgstr "Odotettiin merkkiä ”)” kohdassa %C" +msgstr "Odotettiin ”)” kohdassa %C" #: fortran/decl.c:6541 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected \",\" or end of statement at %C" -msgstr "tyhjä esittely" +msgstr "Odotettiin ”,” tai lauseen loppua kohdassa %C" #: fortran/decl.c:6567 #, gcc-internal-format, gfc-internal-format @@ -38951,7 +38520,7 @@ msgstr "tyhjä esittely" #: fortran/decl.c:6850 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in PROTECTED statement at %C" -msgstr "" +msgstr "Syntaksivirhe PROTECTED-lauseessa kohdassa %C" #: fortran/decl.c:6874 #, gcc-internal-format, gfc-internal-format @@ -38966,27 +38535,27 @@ msgstr "" #: fortran/decl.c:6939 #, gcc-internal-format, gfc-internal-format msgid "Expected variable name at %C in PARAMETER statement" -msgstr "" +msgstr "Odotettiin muuttujanimeä kohdassa %C PARAMETER-lauseessa" #: fortran/decl.c:6946 #, gcc-internal-format, gfc-internal-format msgid "Expected = sign in PARAMETER statement at %C" -msgstr "" +msgstr "Odotettiin =-merkkiä PARAMETER-lauseessa kohdassa %C" #: fortran/decl.c:6952 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected expression at %C in PARAMETER statement" -msgstr "tyhjä esittely" +msgstr "Odotettiin lauseketta kohdassa %C PARAMETER-lauseessa" #: fortran/decl.c:6972 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Initializing already initialized variable at %C" -msgstr "alustus yhteensopimattomasta osoitintyypistä" +msgstr "Alustetaan jo alustettu muuttuja kohdassa %C" #: fortran/decl.c:7007 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Unexpected characters in PARAMETER statement at %C" -msgstr "tyhjä esittely" +msgstr "Odottamattomia merkkejä PARAMETER-lauseessa kohdassa %C" #: fortran/decl.c:7031 #, gcc-internal-format, gfc-internal-format @@ -39001,7 +38570,7 @@ msgstr "" #: fortran/decl.c:7090 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in SAVE statement at %C" -msgstr "" +msgstr "Syntaksivirhe SAVE-lauseessa kohdassa %C" #: fortran/decl.c:7104 #, gcc-internal-format, gfc-internal-format @@ -39011,17 +38580,17 @@ msgstr "" #: fortran/decl.c:7108 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "VALUE statement at %C" -msgstr "tyhjä esittely" +msgstr "Fortran 2003: VALUE-lause kohdassa %C" #: fortran/decl.c:7148 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in VALUE statement at %C" -msgstr "" +msgstr "Syntaksivirhe VALUE-lauseessa kohdassa %C" #: fortran/decl.c:7159 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "VOLATILE statement at %C" -msgstr "tyhjä esittely" +msgstr "Fortran 2003: VOLATILE-lause kohdassa %C" #: fortran/decl.c:7183 #, gcc-internal-format, gfc-internal-format @@ -39031,11 +38600,10 @@ msgstr "" #: fortran/decl.c:7209 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in VOLATILE statement at %C" -msgstr "" +msgstr "Syntaksivirhe VOLATILE-lauseessa kohdassa %C" #: fortran/decl.c:7220 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Fortran 2003: CLASS statement at %C" msgid "ASYNCHRONOUS statement at %C" msgstr "Fortran 2003: CLASS-lause kohdassa %C" @@ -39057,7 +38625,7 @@ msgstr "" #: fortran/decl.c:7394 #, gcc-internal-format, gfc-internal-format msgid "Ambiguous symbol in TYPE definition at %C" -msgstr "" +msgstr "Monimerkityksellinen symboli TYPE-määrittelyssä kohdassa %C" #: fortran/decl.c:7400 #, gcc-internal-format, gfc-internal-format @@ -39092,12 +38660,12 @@ msgstr "" #: fortran/decl.c:7478 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "ABSTRACT type at %C" -msgstr "ei voi kirjoittaa tiedostoon %s: %m" +msgstr "ABSTRACT-tyyppiä ”%s” käytetty kohdassa %L" #: fortran/decl.c:7543 #, gcc-internal-format, gfc-internal-format msgid "Expected :: in TYPE definition at %C" -msgstr "" +msgstr "Odotettiin :: TYPE-määrittelyssä kohdassa %C" #: fortran/decl.c:7554 #, gcc-internal-format, gfc-internal-format @@ -39127,7 +38695,7 @@ msgstr "" #: fortran/decl.c:7742 #, gcc-internal-format, gfc-internal-format msgid "Enumerator exceeds the C integer type at %C" -msgstr "" +msgstr "Enumeraattori ylittää C-kokonaislukutyypin kohdassa %C" #: fortran/decl.c:7821 #, gcc-internal-format, gfc-internal-format @@ -39135,19 +38703,19 @@ msgid "ENUMERATOR %L not initialized with integer expression" msgstr "" #: fortran/decl.c:7869 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "ENUM definition statement expected before %C" -msgstr "ylivuoto vakiolausekkeessa" +msgstr "ENUM-määrittelylause odotettiin ennen kohdetta %C" #: fortran/decl.c:7905 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in ENUMERATOR definition at %C" -msgstr "" +msgstr "Syntaksivirhe ENUMERATOR-määrittelyssä kohdassa %C" #: fortran/decl.c:7952 fortran/decl.c:7967 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Duplicate access-specifier at %C" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "Kaksoiskappale pääsy-tarkenne kohdassa %C" #: fortran/decl.c:7987 #, gcc-internal-format, gfc-internal-format @@ -39160,9 +38728,9 @@ msgid "Binding attributes already specify passing, illegal PASS at %C" msgstr "" #: fortran/decl.c:8034 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Duplicate POINTER attribute at %C" -msgstr "ylimääräinen %<restrict%>" +msgstr "Kaksoiskappale POINTER-attribuutti kohdassa %C" #: fortran/decl.c:8052 #, gcc-internal-format, gfc-internal-format @@ -39175,14 +38743,14 @@ msgid "Duplicate DEFERRED at %C" msgstr "" #: fortran/decl.c:8081 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected access-specifier at %C" -msgstr "taulukon indeksin tyyppi on %<char%>" +msgstr "Odotettiin käyttöoikeustarkennetta kohdassa %C" #: fortran/decl.c:8083 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected binding attribute at %C" -msgstr "%qs attribuuttia ei huomioida" +msgstr "Odotettiin sitomisattribuuttia kohdassa %C" #: fortran/decl.c:8091 #, gcc-internal-format, gfc-internal-format @@ -39197,12 +38765,12 @@ msgstr "" #: fortran/decl.c:8145 #, gcc-internal-format, gfc-internal-format msgid "Interface-name expected after '(' at %C" -msgstr "" +msgstr "Rajapintanimeä odotettiin merkin ”(” jälkeen kohdassa %C" #: fortran/decl.c:8151 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "')' expected at %C" -msgstr "taulukon indeksin tyyppi on %<char%>" +msgstr "”)” odotettiin kohdassa %C" #: fortran/decl.c:8171 #, gcc-internal-format, gfc-internal-format @@ -39215,14 +38783,14 @@ msgid "PROCEDURE(interface) at %C should be declared DEFERRED" msgstr "" #: fortran/decl.c:8199 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected binding name at %C" -msgstr "tyhjä esittely" +msgstr "Odotettiin sitomisnimeä kohteessa %C" #: fortran/decl.c:8203 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "PROCEDURE list at %C" -msgstr "%qD esitelty extern-avainsanalla sisäkkäin" +msgstr "Roskaa PROCEDURE-esittelyn jälkeen kohdassa %C" #: fortran/decl.c:8216 #, gcc-internal-format, gfc-internal-format @@ -39235,9 +38803,9 @@ msgid "'::' needed in PROCEDURE binding with explicit target at %C" msgstr "" #: fortran/decl.c:8232 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected binding target after '=>' at %C" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "Odotettiin sitomiskohteen jälkeen ”=>” kohdassa %C" #: fortran/decl.c:8249 #, gcc-internal-format, gfc-internal-format @@ -39255,19 +38823,19 @@ msgid "GENERIC at %C must be inside a derived-type CONTAINS" msgstr "" #: fortran/decl.c:8329 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected '::' at %C" -msgstr "taulukon indeksin tyyppi on %<char%>" +msgstr "Odotettiin ”::” kohdassa %C" #: fortran/decl.c:8341 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected generic name or operator descriptor at %C" -msgstr "tyhjä esittely" +msgstr "Odotettiin geneeristä nimeä tai operaattorimäärittelijää kohdassa %C" #: fortran/decl.c:8367 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected '=>' at %C" -msgstr "taulukon indeksin tyyppi on %<char%>" +msgstr "Odotettiin ”=>” kohdassa %C" #: fortran/decl.c:8409 #, gcc-internal-format, gfc-internal-format @@ -39280,9 +38848,9 @@ msgid "Binding at %C must have the same access as already defined binding '%s'" msgstr "" #: fortran/decl.c:8466 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected specific binding name at %C" -msgstr "tyhjä esittely" +msgstr "Odotettiin erityistä sitomisnimeä kohdassa %C" #: fortran/decl.c:8476 #, gcc-internal-format, gfc-internal-format @@ -39310,19 +38878,19 @@ msgid "Empty FINAL at %C" msgstr "" #: fortran/decl.c:8569 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected module procedure name at %C" -msgstr "tyhjä esittely" +msgstr "Odotettiin moduuliproseduurinimeä kohdassa %C" #: fortran/decl.c:8579 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected ',' at %C" -msgstr "taulukon indeksin tyyppi on %<char%>" +msgstr "Odotettiin ”,” kohdassa %C" #: fortran/decl.c:8585 #, gcc-internal-format, gfc-internal-format msgid "Unknown procedure name \"%s\" at %C" -msgstr "" +msgstr "Tuntematon proseduurinimi ”%s” kohdassa %C" #: fortran/decl.c:8599 #, gcc-internal-format, gfc-internal-format @@ -39330,14 +38898,14 @@ msgid "'%s' at %C is already defined as FINAL procedure!" msgstr "" #: fortran/decl.c:8668 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Unknown attribute in !GCC$ ATTRIBUTES statement at %C" -msgstr "tyhjä esittely" +msgstr "Tuntematon attribuutti !GCC$ ATTRIBUTES-lauseessa kohdassa %C" #: fortran/decl.c:8715 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Syntax error in !GCC$ ATTRIBUTES statement at %C" -msgstr "kokonaislukuylivuoto lausekkeessa" +msgstr "Syntaksivirhe !GCC$ ATTRIBUTES-lauseessa kohdassa %C" #. We are told not to check dependencies. #. We do it, however, and issue a warning in case we find one. @@ -39355,19 +38923,19 @@ msgid " Included at %s:%d:" msgstr "" #: fortran/error.c:423 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "<During initialization>\n" -msgstr "(%qs:n alustuksen lähistöllä)" +msgstr "<Alustuksen aikana>\n" #: fortran/error.c:758 #, gcc-internal-format, gfc-internal-format msgid "Error count reached limit of %d." -msgstr "" +msgstr "Virhelaskuri tavoitti rajan %d." #: fortran/error.c:1054 #, gcc-internal-format msgid "Internal Error at (1):" -msgstr "" +msgstr "Sisäinen virhe kohdassa (1):" #: fortran/expr.c:1229 #, gcc-internal-format, gfc-internal-format @@ -39547,17 +39115,17 @@ msgstr "" #: fortran/expr.c:3118 #, gcc-internal-format, gfc-internal-format msgid "'%s' at %L is not a VALUE" -msgstr "" +msgstr "”%s” kohdassa %L ei ole VALUE" #: fortran/expr.c:3125 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Incompatible ranks %d and %d in assignment at %L" -msgstr "yhteensopimattomat tyypit sijoituksessa" +msgstr "Yhteensopimattomat tasot %d ja %d sijoituksessa kohdassa %L" #: fortran/expr.c:3132 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Variable type is UNKNOWN in assignment at %L" -msgstr "yhteensopimattomat tyypit sijoituksessa" +msgstr "Muuttujatyyppi on UNKNOWN sijoituksessa kohdassa %L" #: fortran/expr.c:3144 #, gcc-internal-format, gfc-internal-format @@ -39610,14 +39178,14 @@ msgid "Possible change of value in conversion from %s to %s at %L" msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT" #: fortran/expr.c:3243 fortran/intrinsic.c:4342 fortran/intrinsic.c:4368 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Conversion from %s to %s at %L" -msgstr "muunnos tyypistä %qT tyyppiin %qT" +msgstr "Muunnos tyypistä %s tyyppiin %s kohdassa %L" #: fortran/expr.c:3264 -#, 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 "yhteensopimattomat tyypit sijoituksessa" +msgstr "Yhteensopimattomat tyypit DATA-lauseessa kohdassa %L; yritettiin muuntaa tyyppi %s tyypiksi %s" #: fortran/expr.c:3300 #, gcc-internal-format, gfc-internal-format @@ -39660,9 +39228,9 @@ msgid "Pointer object at %L shall not have a coindex" msgstr "muuttuvakokoista objektia ei voi alustaa" #: fortran/expr.c:3415 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Invalid procedure pointer assignment at %L" -msgstr "tyhjä esittely" +msgstr "Virheellinen proseduuriosoitinsijoitus kohdassa %L" #: fortran/expr.c:3435 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -39675,14 +39243,14 @@ msgid "Abstract interface '%s' is invalid in procedure pointer assignment at %L" msgstr "" #: fortran/expr.c:3453 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Statement function '%s' is invalid in procedure pointer assignment at %L" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "Käskyfunktio ”%s” on virheellinen proseduuriosoitinsijoituksessa kohdassa %L" #: fortran/expr.c:3459 #, gcc-internal-format, gfc-internal-format msgid "Internal procedure '%s' is invalid in procedure pointer assignment at %L" -msgstr "" +msgstr "Sisäinen proseduuri ”%s” on virheellinen proseduuriosoittimessa kohdassa %L" #: fortran/expr.c:3467 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -39700,9 +39268,9 @@ msgid "Mismatch in the procedure pointer assignment at %L: mismatch in the calli msgstr "" #: fortran/expr.c:3549 fortran/expr.c:3557 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Interface mismatch in procedure pointer assignment at %L: %s" -msgstr "tyhjä esittely" +msgstr "Rajapintatäsmäämättömyys proseduuriosoitinsijoituksessa kohdassa %L: %s" #: fortran/expr.c:3573 #, gcc-internal-format, gfc-internal-format @@ -39710,9 +39278,9 @@ msgid "Data-pointer-object &L must be unlimited polymorphic, a sequence derived msgstr "" #: fortran/expr.c:3579 -#, 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 "yhteensopimattomat tyypit sijoituksessa" +msgstr "Eri tyypit osoitinsijoituksessa kohdassa %L; yritettiin tyypin %s sijoitusta tyyppiin %s" #: fortran/expr.c:3588 #, gcc-internal-format, gfc-internal-format @@ -39794,72 +39362,72 @@ msgstr "(%qs:n alustuksen lähistöllä)" msgid "Procedure pointer initialization target at %L may not be a procedure pointer" msgstr "" -#: fortran/expr.c:4692 +#: fortran/expr.c:4693 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "Fortran 2008: Pointer functions in variable definition context (%s) at %L" msgstr "vektoriylivuoto lausekkeessa" -#: fortran/expr.c:4700 +#: fortran/expr.c:4701 #, gcc-internal-format, gfc-internal-format msgid "Non-variable expression in variable definition context (%s) at %L" msgstr "" -#: fortran/expr.c:4708 +#: fortran/expr.c:4709 #, gcc-internal-format, gfc-internal-format msgid "Named constant '%s' in variable definition context (%s) at %L" msgstr "" -#: fortran/expr.c:4717 +#: fortran/expr.c:4718 #, gcc-internal-format, gfc-internal-format msgid "'%s' in variable definition context (%s) at %L is not a variable" msgstr "" -#: fortran/expr.c:4728 +#: fortran/expr.c:4729 #, gcc-internal-format, gfc-internal-format msgid "Non-POINTER in pointer association context (%s) at %L" msgstr "" -#: fortran/expr.c:4741 +#: fortran/expr.c:4742 #, gcc-internal-format, gfc-internal-format msgid "LOCK_TYPE in variable definition context (%s) at %L" msgstr "" -#: fortran/expr.c:4770 +#: fortran/expr.c:4771 #, gcc-internal-format, gfc-internal-format msgid "Dummy argument '%s' with INTENT(IN) in pointer association context (%s) at %L" msgstr "" -#: fortran/expr.c:4778 +#: fortran/expr.c:4779 #, gcc-internal-format, gfc-internal-format msgid "Dummy argument '%s' with INTENT(IN) in variable definition context (%s) at %L" msgstr "" -#: fortran/expr.c:4791 +#: fortran/expr.c:4792 #, gcc-internal-format, gfc-internal-format msgid "Variable '%s' is PROTECTED and can not appear in a pointer association context (%s) at %L" msgstr "" -#: fortran/expr.c:4799 +#: fortran/expr.c:4800 #, gcc-internal-format, gfc-internal-format msgid "Variable '%s' is PROTECTED and can not appear in a variable definition context (%s) at %L" msgstr "" -#: fortran/expr.c:4811 +#: fortran/expr.c:4812 #, gcc-internal-format, gfc-internal-format msgid "Variable '%s' can not appear in a variable definition context (%s) at %L in PURE procedure" msgstr "" -#: fortran/expr.c:4870 +#: fortran/expr.c:4871 #, gcc-internal-format, gfc-internal-format msgid "'%s' at %L associated to vector-indexed target can not be used in a variable definition context (%s)" msgstr "" -#: fortran/expr.c:4874 +#: fortran/expr.c:4875 #, gcc-internal-format, gfc-internal-format msgid "'%s' at %L associated to expression can not be used in a variable definition context (%s)" msgstr "" -#: fortran/expr.c:4886 +#: fortran/expr.c:4887 #, gcc-internal-format, gfc-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" msgstr "" @@ -39871,7 +39439,7 @@ msgstr "ei voi avata syötetiedostoa: %s" #: fortran/frontend-passes.c:518 fortran/trans-array.c:1041 #: fortran/trans-array.c:5866 fortran/trans-array.c:7150 -#: fortran/trans-intrinsic.c:5445 +#: fortran/trans-intrinsic.c:5444 #, gcc-internal-format, gfc-internal-format msgid "Creating array temporary at %L" msgstr "" @@ -39914,17 +39482,17 @@ msgstr "" #: fortran/interface.c:175 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in generic specification at %C" -msgstr "" +msgstr "Syntaksivirhe geneerisessä spesifikaatiossa kohdassa %C" #: fortran/interface.c:202 #, gcc-internal-format, gfc-internal-format msgid "Syntax error: Trailing garbage in INTERFACE statement at %C" -msgstr "" +msgstr "Syntaksivirhe: Loppuroskaa INTERFACE-lauseessa kohdassa %C" #: fortran/interface.c:221 #, gcc-internal-format, gfc-internal-format msgid "Dummy procedure '%s' at %C cannot have a generic interface" -msgstr "" +msgstr "Valeproseduurilla ”%s” kohdassa %C ei voi olla geneeristä rajapintaa" #: fortran/interface.c:254 #, gcc-internal-format, gfc-internal-format @@ -39934,22 +39502,22 @@ msgstr "" #: fortran/interface.c:262 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in ABSTRACT INTERFACE statement at %C" -msgstr "" +msgstr "Syntaksivirhe ABSTRACT INTERFACE -käskyssä kohdassa %C" #: fortran/interface.c:293 #, gcc-internal-format, gfc-internal-format msgid "Syntax error: Trailing garbage in END INTERFACE statement at %C" -msgstr "" +msgstr "Syntaksivirhe: Loppuroskaa END INTERFACE -käskyssä kohdassa %C" #: fortran/interface.c:306 #, gcc-internal-format, gfc-internal-format msgid "Expected a nameless interface at %C" -msgstr "" +msgstr "Odotettiin nimetöntä rajapintaa kohdassa %C" #: fortran/interface.c:319 #, gcc-internal-format, gfc-internal-format msgid "Expected 'END INTERFACE ASSIGNMENT (=)' at %C" -msgstr "" +msgstr "Odotettiin 'END INTERFACE ASSIGNMENT (=)' kohdassa %C" #: fortran/interface.c:349 #, gcc-internal-format, gfc-internal-format @@ -39959,12 +39527,12 @@ msgstr "" #: fortran/interface.c:363 #, gcc-internal-format, gfc-internal-format msgid "Expecting 'END INTERFACE OPERATOR (.%s.)' at %C" -msgstr "" +msgstr "Odotettiin 'END INTERFACE OPERATOR (.%s.)' kohdassa %C" #: fortran/interface.c:374 #, gcc-internal-format, gfc-internal-format msgid "Expecting 'END INTERFACE %s' at %C" -msgstr "" +msgstr "Odotettiin 'END INTERFACE %s' kohdassa %C" #: fortran/interface.c:624 #, gcc-internal-format, gfc-internal-format @@ -39989,7 +39557,7 @@ msgstr "" #: fortran/interface.c:687 #, gcc-internal-format, gfc-internal-format msgid "Assignment operator interface at %L must not redefine an INTRINSIC type assignment" -msgstr "" +msgstr "Sijoitusoperaattorirajapinta kohdassa %L ei saa määritellä uudelleen INTRINSIC-tyyppisijoitusta" #: fortran/interface.c:696 #, gcc-internal-format, gfc-internal-format @@ -40006,12 +39574,12 @@ msgstr "" msgid "Second argument of defined assignment at %L must be INTENT(IN)" msgstr "" -#: fortran/interface.c:723 fortran/resolve.c:14797 +#: fortran/interface.c:723 fortran/resolve.c:14799 #, gcc-internal-format, gfc-internal-format msgid "First argument of operator interface at %L must be INTENT(IN)" msgstr "" -#: fortran/interface.c:730 fortran/resolve.c:14815 +#: fortran/interface.c:730 fortran/resolve.c:14817 #, gcc-internal-format, gfc-internal-format msgid "Second argument of operator interface at %L must be INTENT(IN)" msgstr "" @@ -40043,7 +39611,6 @@ msgstr "" #: fortran/interface.c:1491 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Invalid procedure argument at %L" msgid "Internal procedure '%s' in %s at %L" msgstr "Virheellinen proseduuriargumentti kohdassa %L" @@ -40105,7 +39672,7 @@ msgstr "" #: fortran/interface.c:1923 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "Actual argument to '%s' at %L must be polymorphic" -msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta" +msgstr "Tämänhetkisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L" #: fortran/interface.c:1931 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -40175,12 +39742,12 @@ msgstr "" #: fortran/interface.c:2433 #, gcc-internal-format, gfc-internal-format msgid "Keyword argument '%s' at %L is not in the procedure" -msgstr "" +msgstr "Avainsana-argumentti ”%s” kohdassa %L ei ole proseduurissa" #: fortran/interface.c:2441 #, gcc-internal-format, gfc-internal-format msgid "Keyword argument '%s' at %L is already associated with another actual argument" -msgstr "" +msgstr "Avainsana-argumentti ”%s” kohdassa %L on jo liitetty toiseen varsinaiseen argumenttiin" #: fortran/interface.c:2451 #, gcc-internal-format, gfc-internal-format @@ -40195,7 +39762,7 @@ msgstr "" #: fortran/interface.c:2471 #, gcc-internal-format, gfc-internal-format msgid "Unexpected alternate return spec in subroutine call at %L" -msgstr "" +msgstr "Odottamaton vaihtoehtoinen paluumäärittely alirutiinikutsussa kohdassa %L" #: fortran/interface.c:2498 #, gcc-internal-format, gfc-internal-format @@ -40238,24 +39805,24 @@ msgid "Actual argument contains too few elements for dummy argument '%s' (%lu/%l msgstr "" #: fortran/interface.c:2608 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected a procedure pointer for argument '%s' at %L" -msgstr "tyhjä esittely" +msgstr "Odotettiin proseduuriosoitinta argumentille ”%s” kohdassa %L" #: fortran/interface.c:2619 #, gcc-internal-format, gfc-internal-format msgid "Expected a procedure for argument '%s' at %L" -msgstr "" +msgstr "Odotettiin proseduuria argumentille ”%s” kohdassa %L" #: fortran/interface.c:2633 #, gcc-internal-format, gfc-internal-format msgid "Actual argument for '%s' cannot be an assumed-size array at %L" -msgstr "" +msgstr "Varsinainen argumentti kohteelle ”%s” ei voi olla oletetunkokoinen taulukko kohdassa %L" #: fortran/interface.c:2642 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Actual argument for '%s' must be a pointer at %L" -msgstr "argumentin %d antamisessa funktiolle %qE tehdään osoitin kokonaisluvusta ilman tyyppimuunnosta" +msgstr "Varsinaisen argumentin kohteelle ”%s” on oltava osoitin kohdassa %L" #: fortran/interface.c:2652 #, gcc-internal-format, gfc-internal-format @@ -40409,7 +39976,6 @@ msgstr "" #: fortran/interface.c:3785 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Name '%s' at %C is already defined as a generic interface at %L" msgid "Entity '%s' at %L is already present in the interface" msgstr "Nimi ”%s” kohdassa %C on jo määritelty geneerisenä rajapintana kohdassa %L" @@ -40499,9 +40065,9 @@ msgid "The intrinsic '%s' at %L is not included in the selected standard but %s msgstr "" #: fortran/intrinsic.c:3530 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Too many arguments in call to '%s' at %L" -msgstr "liikaa argumentteja funktiolle %s %q+#D" +msgstr "Liikaa argumentteja funktiokutsussa ”%s” kohdassa %L" #: fortran/intrinsic.c:3545 #, gcc-internal-format, gfc-internal-format @@ -40554,14 +40120,14 @@ msgid "Subroutine call to intrinsic '%s' at %L is not PURE" msgstr "" #: fortran/intrinsic.c:4307 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Extension: Conversion from %s to %s at %L" -msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT" +msgstr "Laajennus: Muunnos tyypistä %s tyypiksi %s kohdassa %L" #: fortran/intrinsic.c:4421 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Can't convert %s to %s at %L" -msgstr "ei voi kirjoittaa tiedostoon %s: %m" +msgstr "Ei voi muuntaa tyyppiä %s tyyppiin %s kohdassa %L" #: fortran/intrinsic.c:4515 #, gcc-internal-format, gfc-internal-format @@ -40611,7 +40177,7 @@ msgstr "" #: fortran/io.c:784 #, gcc-internal-format, gfc-internal-format msgid "Extension: Missing positive width after L descriptor at %L" -msgstr "" +msgstr "Laajennus: Puuttuva positiivinen leveys L-määrittelijän jälkeen kohdassa %L" #: fortran/io.c:828 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -40619,19 +40185,19 @@ msgid "'G0' in format at %L" msgstr "päättämätön muotoilumerkkijono" #: fortran/io.c:856 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Positive width required in format specifier %s at %L" -msgstr "tunnistamaton muotomäärite" +msgstr "Positiivinen leveys vaadittu muotomäärittelijässä %s kohdassa %L" #: fortran/io.c:872 fortran/io.c:879 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Period required in format specifier %s at %L" -msgstr "tunnistamaton muotomäärite" +msgstr "Piste vaadittu muotomääritteessä %s kohdassa %L" #: fortran/io.c:951 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Period required in format specifier at %L" -msgstr "tunnistamaton muotomäärite" +msgstr "Piste vaadittu muotomääritteessä kohdassa %L" #: fortran/io.c:973 #, gcc-internal-format, gfc-internal-format @@ -40644,9 +40210,9 @@ msgid "Missing comma at %L" msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT" #: fortran/io.c:1143 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "%s in format string at %L" -msgstr "päättämätön muotoilumerkkijono" +msgstr "%s muotoilumerkkijonossa kohdassa %L" #: fortran/io.c:1180 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -40659,19 +40225,19 @@ msgid "Format statement in module main block at %C" msgstr "" #: fortran/io.c:1208 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Missing format label at %C" -msgstr "tiedostonimi puuttuu option %qs jälkeen" +msgstr "Puuttuva muotonimiö kohdassa %C" #: fortran/io.c:1263 fortran/io.c:1294 fortran/io.c:1359 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Invalid value for %s specification at %C" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "Virheellinen arvo %s-spesifikaatiolle kohdassa %C" #: fortran/io.c:1269 fortran/io.c:1300 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Duplicate %s specification at %C" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "Kaksoiskappale %s-spesifikaatio kohdassa %C" #: fortran/io.c:1307 #, gcc-internal-format, gfc-internal-format @@ -40679,14 +40245,14 @@ msgid "Variable %s cannot be INTENT(IN) at %C" msgstr "" #: fortran/io.c:1314 -#, 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 "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle" +msgstr "Muuttuja %s ei voida liittää PURE-proseduuriin kohdassa %C" #: fortran/io.c:1365 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Duplicate %s label specification at %C" -msgstr "%qs-nimikkeen kaksoisesittely" +msgstr "Kaksoiskappale %s-nimiöspesifikaatio kohdassa %C" #: fortran/io.c:1385 #, gcc-internal-format, gfc-internal-format @@ -40846,7 +40412,7 @@ msgstr "" #: fortran/io.c:2250 #, gcc-internal-format, gfc-internal-format msgid "CLOSE statement not allowed in PURE procedure at %C" -msgstr "" +msgstr "CLOSE-lause ei ole sallittu PURE-proseduurissa kohdassa %C" #: fortran/io.c:2310 #, gcc-internal-format, gfc-internal-format @@ -40854,19 +40420,19 @@ msgid "CLOSE statement at %L requires a UNIT number" msgstr "" #: fortran/io.c:2318 -#, 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 "tyhjä esittely" +msgstr "UNIT-numeron CLOSE-lauseessa kohdassa %L täytyy olla epänegatiivinen" #: fortran/io.c:2416 fortran/match.c:2681 #, gcc-internal-format, gfc-internal-format msgid "%s statement not allowed in PURE procedure at %C" -msgstr "" +msgstr "%s-lause ei ole sallittu PURE-proseduurissa kohdassa %C" #: fortran/io.c:2451 fortran/io.c:2883 #, gcc-internal-format, gfc-internal-format msgid "UNIT number in statement at %L must be non-negative" -msgstr "" +msgstr "UNIT-numeron lauseessa kohdassa %L täytyy olla epänegatiivinen" #: fortran/io.c:2483 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -40879,9 +40445,9 @@ msgid "Duplicate UNIT specification at %C" msgstr "" #: fortran/io.c:2613 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Duplicate format specification at %C" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "Kaksoiskappalemuotospesifikaatio kohdassa %C" #: fortran/io.c:2630 #, gcc-internal-format, gfc-internal-format @@ -40889,9 +40455,9 @@ msgid "Symbol '%s' in namelist '%s' is INTENT(IN) at %C" msgstr "" #: fortran/io.c:2666 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Duplicate NML specification at %C" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "Kaksoiskappale-NML-spesifikaatio kohdassa %C" #: fortran/io.c:2675 #, gcc-internal-format, gfc-internal-format @@ -40904,9 +40470,9 @@ msgid "END tag at %C not allowed in output statement" msgstr "" #: fortran/io.c:2817 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "UNIT not specified at %L" -msgstr "-I- annettu kahdesti" +msgstr "UNIT ei ole määritelty kohdassa %L" #: fortran/io.c:2829 #, gcc-internal-format, gfc-internal-format @@ -40939,45 +40505,45 @@ msgid "Comma before i/o item list at %L" msgstr "virheellinen muunnos tyypistä %qT tyypiksi %qT" #: fortran/io.c:2924 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "ERR tag label %d at %L not defined" -msgstr "%Jnimikettä %qD käytetty, mutta ei määritelty" +msgstr "ERR-tunnistenimiötä %d kohdassa %L ei ole määritelty" #: fortran/io.c:2936 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "END tag label %d at %L not defined" -msgstr "%Jnimikettä %qD käytetty, mutta ei määritelty" +msgstr "END-tunnistenimiötä %d kohdassa %L ei ole määritelty" #: fortran/io.c:2948 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "EOR tag label %d at %L not defined" -msgstr "%Jnimikettä %qD käytetty, mutta ei määritelty" +msgstr "EOR-tunnistenimiötä %d kohdassa %L ei ole määritelty" #: fortran/io.c:2958 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "FORMAT label %d at %L not defined" -msgstr "%Jnimikettä %qD käytetty, mutta ei määritelty" +msgstr "FORMAT-nimiö %d kohdassa %L ei ole määritelty" #: fortran/io.c:3080 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in I/O iterator at %C" -msgstr "" +msgstr "Syntaksivirhe siirräntäiteraattorissa kohdassa %C" #: fortran/io.c:3111 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected variable in READ statement at %C" -msgstr "tyhjä esittely" +msgstr "Odotettiin muuttujaa READ-lauseessa kohdassa %C" #: fortran/io.c:3117 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected expression in %s statement at %C" -msgstr "tyhjä esittely" +msgstr "Odotettiin lauseketta %s-lauseessa kohdassa %C" #. A general purpose syntax error. -#: fortran/io.c:3175 fortran/io.c:3774 fortran/gfortran.h:2496 +#: fortran/io.c:3175 fortran/io.c:3774 fortran/gfortran.h:2506 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in %s statement at %C" -msgstr "" +msgstr "Syntaksivirhe %s-lauseessa kohdassa %C" #: fortran/io.c:3260 #, gcc-internal-format, gfc-internal-format @@ -40985,9 +40551,9 @@ msgid "Internal file at %L with namelist" msgstr "" #: fortran/io.c:3318 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "ASYNCHRONOUS= specifier at %L must be an initialization expression" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "ASYNCHRONOUS= määrite kohdassa %L täytyy olla alustuslauseke" #: fortran/io.c:3386 #, gcc-internal-format, gfc-internal-format @@ -41012,7 +40578,7 @@ msgstr "" #: fortran/io.c:3808 #, gcc-internal-format, gfc-internal-format msgid "PRINT statement at %C not allowed within PURE procedure" -msgstr "" +msgstr "PRINT-lause kohdassa %C ei ole sallittu PURE-proseduurin sisällä" #: fortran/io.c:3968 fortran/io.c:4022 #, gcc-internal-format, gfc-internal-format @@ -41050,19 +40616,19 @@ msgid "WAIT statement not allowed in PURE procedure at %C" msgstr "" #: fortran/match.c:164 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Missing ')' in statement at or before %L" -msgstr "ylivuoto vakiolausekkeessa" +msgstr "Puuttuva ”)” lauseessa kohdassa tai ennen kohtaa %L" #: fortran/match.c:169 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Missing '(' in statement at or before %L" -msgstr "ylivuoto vakiolausekkeessa" +msgstr "Puuttuva ”(” lauseessa kohdassa tai ennen kohtaa %L" #: fortran/match.c:366 #, gcc-internal-format, gfc-internal-format msgid "Integer too large at %C" -msgstr "" +msgstr "Kokonaisluku liian suuri kohdassa %C" #: fortran/match.c:459 fortran/parse.c:692 #, gcc-internal-format, gfc-internal-format @@ -41085,14 +40651,14 @@ msgid "Duplicate construct label '%s' at %C" msgstr "" #: fortran/match.c:535 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Invalid character in name at %C" -msgstr "epäkelpo osoitintila %qs" +msgstr "Virheellinen merkki nimessä kohdassa %C" #: fortran/match.c:548 #, gcc-internal-format, gfc-internal-format msgid "Name at %C is too long" -msgstr "" +msgstr "Nimi kohdassa %C on liian pitkä" #: fortran/match.c:559 #, gcc-internal-format, gfc-internal-format @@ -41122,12 +40688,12 @@ msgstr "" #: fortran/match.c:1011 #, gcc-internal-format, gfc-internal-format msgid "Expected a step value in iterator at %C" -msgstr "" +msgstr "Odotettiin askelarvoa iteraattorissa kohdassa %C" #: fortran/match.c:1023 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in iterator at %C" -msgstr "" +msgstr "Syntaksivirhe iteraattorissa kohdassa %C" #: fortran/match.c:1264 #, gcc-internal-format, gfc-internal-format @@ -41140,49 +40706,49 @@ msgid "Arithmetic IF statement at %C" msgstr "tyhjä esittely" #: fortran/match.c:1450 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Syntax error in IF-expression at %C" -msgstr "kokonaislukuylivuoto lausekkeessa" +msgstr "Syntaksivirhe IF-lausekkeessa kohdassa %C" #: fortran/match.c:1461 #, gcc-internal-format, gfc-internal-format msgid "Block label not appropriate for arithmetic IF statement at %C" -msgstr "" +msgstr "Lohkonimiö ei ole sopiva aritmeettiselle IF-lauseelle kohdassa %C" #: fortran/match.c:1499 -#, 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 "tyhjä esittely" +msgstr "Lohkonimiö ei ole sopiva IF-lauseelle kohdassa %C" #: fortran/match.c:1585 #, gcc-internal-format, gfc-internal-format msgid "Cannot assign to a named constant at %C" -msgstr "" +msgstr "Ei voi sijoitaa nimettyyn vakioon kohdassa %C" #: fortran/match.c:1595 #, gcc-internal-format, gfc-internal-format msgid "Unclassifiable statement in IF-clause at %C" -msgstr "" +msgstr "Luokittelematon lause IF-lauseessa kohdassa %C" #: fortran/match.c:1602 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in IF-clause at %C" -msgstr "" +msgstr "Syntaksivirhe IF-lauseessa kohdassa %C" #: fortran/match.c:1646 #, gcc-internal-format, gfc-internal-format msgid "Unexpected junk after ELSE statement at %C" -msgstr "" +msgstr "Odottamatonta roskaa ELSE-lauseen jälkeen kohdassa %C" #: fortran/match.c:1652 fortran/match.c:1687 #, gcc-internal-format, gfc-internal-format msgid "Label '%s' at %C doesn't match IF label '%s'" -msgstr "" +msgstr "Nimiö ”%s” kohdassa %C ei täsmää IF nimiön ”%s” kanssa" #: fortran/match.c:1681 #, gcc-internal-format, gfc-internal-format msgid "Unexpected junk after ELSE IF statement at %C" -msgstr "" +msgstr "Odottamatonta roskaa ELSE IF -lauseen jälkeen kohdassa %C" #: fortran/match.c:1745 #, gcc-internal-format, gfc-internal-format @@ -41419,7 +40985,6 @@ msgstr "" #: fortran/match.c:3224 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Fortran 2003: CLASS statement at %C" msgid "ASSIGN statement at %C" msgstr "Fortran 2003: CLASS-lause kohdassa %C" @@ -41594,19 +41159,19 @@ msgid "RETURN statement in main program at %C" msgstr "" #: fortran/match.c:4101 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected component reference at %C" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "Odotettiin komponenttiviitettä kohdassa %C" #: fortran/match.c:4107 #, gcc-internal-format, gfc-internal-format msgid "Junk after CALL at %C" -msgstr "" +msgstr "Roskaa CALL-lauseen jälkeen kohdassa %C" #: fortran/match.c:4117 -#, 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 "tyhjä esittely" +msgstr "Odotettiin tyyppiriippuvaista proseduuria tai proseduurin osoitinkomponenttia kohdassa %C" #: fortran/match.c:4337 #, gcc-internal-format, gfc-internal-format @@ -41616,7 +41181,7 @@ msgstr "" #: fortran/match.c:4373 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %C is already an external symbol that is not COMMON" -msgstr "" +msgstr "Symboli ”%s” kohdassa %C on jo ulkoinen symboli, joka ei ole COMMON" #. If we find an error, just print it and continue, #. cause it's just semantic, and we can see if there @@ -41634,7 +41199,7 @@ msgstr "" #: fortran/match.c:4449 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %C is already in a COMMON block" -msgstr "" +msgstr "Symboli ”%s” kohdassa %C on jo COMMON-lohkossa" #: fortran/match.c:4457 #, gcc-internal-format, gfc-internal-format @@ -41709,7 +41274,7 @@ msgstr "liian paljon argumentteja funktiolle %qs" #: fortran/match.c:5074 #, gcc-internal-format, gfc-internal-format msgid "Expected initialization expression in CASE at %C" -msgstr "" +msgstr "Odotettiin alustuslauseketta CASE-lauseessa kohdassa %C" #: fortran/match.c:5106 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -41724,17 +41289,17 @@ msgstr "" #: fortran/match.c:5466 #, gcc-internal-format, gfc-internal-format msgid "Unexpected CASE statement at %C" -msgstr "" +msgstr "Odottamaton CASE-lause kohdassa %C" #: fortran/match.c:5518 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Syntax error in CASE specification at %C" -msgstr "%qD esitelty extern-avainsanalla sisäkkäin" +msgstr "Syntaksivirhe CASE-spesifikaatiossa kohdassa %C" #: fortran/match.c:5536 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Unexpected TYPE IS statement at %C" -msgstr "tyhjä esittely" +msgstr "Odottamaton TYPE IS -lause kohdassa %C" #: fortran/match.c:5565 #, gcc-internal-format, gfc-internal-format @@ -41742,14 +41307,14 @@ msgid "The type-spec shall not specify a sequence derived type or a type with th msgstr "" #: fortran/match.c:5577 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Syntax error in TYPE IS specification at %C" -msgstr "%qD esitelty extern-avainsanalla sisäkkäin" +msgstr "Syntaksivirhe TYPE IS -spesifikaatiossa kohdassa %C" #: fortran/match.c:5650 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Syntax error in CLASS IS specification at %C" -msgstr "%qD esitelty extern-avainsanalla sisäkkäin" +msgstr "Syntaksvirhe CLASS IS -spesifikaatiossa kohdassa %C" #: fortran/match.c:5772 #, gcc-internal-format, gfc-internal-format @@ -41772,14 +41337,14 @@ msgid "The name '%s' cannot be used as a defined operator at %C" msgstr "" #: 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 "vektoriylivuoto lausekkeessa" +msgstr "Odotettiin oikeaa sulkumerkkiä lausekkeessa kohdassa %C" #: fortran/matchexp.c:279 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected exponent in expression at %C" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "Odotettiin eksponenttia lausekkeessa kohdassa %C" #: fortran/matchexp.c:317 fortran/matchexp.c:322 fortran/matchexp.c:426 #: fortran/matchexp.c:431 @@ -41800,7 +41365,7 @@ msgstr "" #: fortran/module.c:579 #, gcc-internal-format, gfc-internal-format msgid "\"::\" was expected after module nature at %C but was not found" -msgstr "" +msgstr "odotettiin ”::” moduuliluonteen jälkeen paikassa %C, mutta ei löytynyt" #: fortran/module.c:590 #, gcc-internal-format, gfc-internal-format @@ -41825,22 +41390,22 @@ msgstr "" #: fortran/module.c:1012 #, gcc-internal-format, gfc-internal-format msgid "Reading module %s at line %d column %d: %s" -msgstr "" +msgstr "Luetaan moduulia %s rivillä %d sarake %d: %s" #: fortran/module.c:1016 #, gcc-internal-format, gfc-internal-format msgid "Writing module %s at line %d column %d: %s" -msgstr "" +msgstr "Kirjoitetaan moduuli %s rivillä %d sarake %d: %s" #: fortran/module.c:1020 #, gcc-internal-format, gfc-internal-format msgid "Module %s at line %d column %d: %s" -msgstr "" +msgstr "Moduuli %s rivillä %d sarakkeessa %d: %s" #: fortran/module.c:1468 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Error writing modules file: %s" -msgstr "%s: virhe kirjoitettaessa tiedostoa ”%s”: %s\n" +msgstr "Virhe kirjoitettaessa moduulitiedostoa %s" #: fortran/module.c:3413 #, gcc-internal-format, gfc-internal-format @@ -41870,7 +41435,7 @@ msgstr "" #: fortran/module.c:5515 #, gcc-internal-format, gfc-internal-format msgid "Can't open module file '%s' for writing at %C: %s" -msgstr "" +msgstr "Ei voi avata moduulitiedostoa ”%s” kirjoittamista varten kohdassa %C: %s" #: fortran/module.c:5548 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -41878,25 +41443,25 @@ msgid "Error writing module file '%s' for writing: %s" msgstr "%s: virhe kirjoitettaessa tiedostoa ”%s”: %s\n" #: fortran/module.c:5557 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Can't delete module file '%s': %s" -msgstr "syötetiedoston avaaminen ei onnistu: %s" +msgstr "Ei voida poistaa moduulitiedostoa ”%s”: %s" #: fortran/module.c:5560 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Can't rename module file '%s' to '%s': %s" -msgstr "%s: virhe kirjoitettaessa tiedostoa ”%s”: %s\n" +msgstr "Ei voida nimetä uudelleen moduulitiedostoa ”%s” nimellä ”%s”: %s" #: fortran/module.c:5566 #, gcc-internal-format, gfc-internal-format msgid "Can't delete temporary module file '%s': %s" -msgstr "" +msgstr "Ei voida poistaa tilapäistä moduulitiedostoa ”%s”: %s" #: fortran/module.c:5585 fortran/module.c:5797 fortran/module.c:5830 #: fortran/module.c:5872 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' already declared" -msgstr "" +msgstr "Symboli ”%s” on jo esitelty" #: fortran/module.c:5689 fortran/module.c:5968 #, gcc-internal-format, gfc-internal-format @@ -41946,7 +41511,7 @@ msgstr "" #: fortran/module.c:6174 #, gcc-internal-format, gfc-internal-format msgid "Can't open module file '%s' for reading at %C: %s" -msgstr "" +msgstr "Ei voi avata moduulitiedostoa ”%s” lukemista varten kohdassa %C: %s" #: fortran/module.c:6182 #, gcc-internal-format, gfc-internal-format @@ -42069,9 +41634,9 @@ msgid "SCHEDULE clause's chunk_size at %L requires a scalar INTEGER expression" msgstr "" #: fortran/openmp.c:885 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Object '%s' is not a variable at %L" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "Objekti ”%s” ei ole muuttuja kohdassa %L" #: fortran/openmp.c:894 fortran/openmp.c:905 fortran/openmp.c:913 #: fortran/openmp.c:924 @@ -42217,32 +41782,32 @@ msgstr "" #: fortran/openmp.c:1405 #, gcc-internal-format, gfc-internal-format msgid "!$OMP ATOMIC assignment intrinsic IAND, IOR or IEOR must have two arguments at %L" -msgstr "" +msgstr "kääntäjänsisäisellä ”!$OMP ATOMIC”-sijoituksella IAND, IOR tai IEOR täytyy olla kaksi argumenttia kohdassa %L" #: fortran/openmp.c:1412 #, gcc-internal-format, gfc-internal-format msgid "!$OMP ATOMIC assignment intrinsic must be MIN, MAX, IAND, IOR or IEOR at %L" -msgstr "" +msgstr "kääntäjänsisäisen ”!$OMP ATOMIC”-sijoituksen on oltava MIN, MAX, IAND, IOR tai IEOR kohdassa %L" #: fortran/openmp.c:1428 #, gcc-internal-format, gfc-internal-format msgid "!$OMP ATOMIC intrinsic arguments except one must not reference '%s' at %L" -msgstr "" +msgstr "kääntäjänsisäiset ”!$OMP ATOMIC”-argumentit paitsi yksi eivät saa viitata kohteeseen ”%s” kohdassa %L" #: fortran/openmp.c:1431 #, gcc-internal-format, gfc-internal-format msgid "!$OMP ATOMIC intrinsic arguments must be scalar at %L" -msgstr "" +msgstr "kääntäjänsisäisten ”!$OMP ATOMIC”-argumenttien on oltava skaalaareja kohdassa %L" #: fortran/openmp.c:1437 #, gcc-internal-format, gfc-internal-format msgid "First or last !$OMP ATOMIC intrinsic argument must be '%s' at %L" -msgstr "" +msgstr "Ensimmäisen tai viimeisen kääntäjänsisäisen ”!$OMP ATOMIC”-argumentin on oltava ”%s” kohdassa %L" #: fortran/openmp.c:1455 #, 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”-sijoituksen on oltava operaattori tai kääntäjänsisäinen oikealla puolella kohdassa %L" #: fortran/openmp.c:1469 #, gcc-internal-format, gfc-internal-format @@ -42262,12 +41827,12 @@ msgstr "" #: fortran/openmp.c:1671 #, gcc-internal-format, gfc-internal-format msgid "!$OMP DO iteration variable must not be THREADPRIVATE at %L" -msgstr "" +msgstr "”!$OMP DO”-iteraatiomuuttuja ei saa olla THREADPRIVATE kohdassa %L" #: fortran/openmp.c:1679 #, gcc-internal-format, gfc-internal-format msgid "!$OMP DO iteration variable present on clause other than PRIVATE or LASTPRIVATE at %L" -msgstr "" +msgstr "”!$OMP DO”-iteraatiomuuttuja on läsnä muussa lauseessa kuin PRIVATE tai LASTPRIVATE kohdassa %L" #: fortran/openmp.c:1697 #, gcc-internal-format, gfc-internal-format @@ -42392,7 +41957,7 @@ msgstr "" #: fortran/parse.c:519 #, gcc-internal-format, gfc-internal-format msgid "Unclassifiable statement at %C" -msgstr "" +msgstr "Luokittelemiskelvoton lause kohdassa %C" #: fortran/parse.c:541 #, gcc-internal-format, gfc-internal-format @@ -42410,24 +41975,24 @@ msgid "Unclassifiable GCC directive at %C" msgstr "" #: fortran/parse.c:695 fortran/parse.c:869 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Zero is not a valid statement label at %C" -msgstr "epäkelpo lvalue asm-lauseessa" +msgstr "Nolla ei ole kelvollinen lausekenimiö kohdassa %C" #: fortran/parse.c:702 fortran/parse.c:861 #, gcc-internal-format, gfc-internal-format msgid "Non-numeric character in statement label at %C" -msgstr "" +msgstr "Ei-numeerinen merkki lausenimiössä kohdassa %C" #: fortran/parse.c:714 fortran/parse.c:910 #, gcc-internal-format, gfc-internal-format msgid "Semicolon at %C needs to be preceded by statement" -msgstr "" +msgstr "Lauseen on edellettävä puolipistettä kohdassa %C" #: fortran/parse.c:722 fortran/parse.c:925 #, gcc-internal-format, gfc-internal-format msgid "Ignoring statement label in empty statement at %L" -msgstr "" +msgstr "Ei välitetä lausenimiöstä tyhjässä lauseessa kohdassa %L" #: fortran/parse.c:771 fortran/parse.c:912 #, gcc-internal-format, gfc-internal-format @@ -42445,9 +42010,9 @@ msgid "FORMAT statement at %L does not have a statement label" msgstr "" #: fortran/parse.c:1757 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Unexpected %s statement at %C" -msgstr "tyhjä esittely" +msgstr "Odottamaton %s-lause kohdassa %C" #: fortran/parse.c:1904 #, gcc-internal-format, gfc-internal-format @@ -42457,17 +42022,17 @@ msgstr "" #: fortran/parse.c:1921 #, gcc-internal-format, gfc-internal-format msgid "Unexpected end of file in '%s'" -msgstr "" +msgstr "Odottamaton tiedoston loppu tiedostossa ”%s”" #: fortran/parse.c:1953 #, gcc-internal-format, gfc-internal-format msgid "Derived-type '%s' with SEQUENCE must not have a CONTAINS section at %C" -msgstr "" +msgstr "Perityllä tyypillä ”%s” SEQUENCE:lla ei saa olla CONTAINS-lohkoa kohdassa %C" #: fortran/parse.c:1956 #, gcc-internal-format, gfc-internal-format msgid "Derived-type '%s' with BIND(C) must not have a CONTAINS section at %C" -msgstr "" +msgstr "Perityllä tyypillä ”%s” BIND(C):llä ei saa olla CONTAINS-lohkoa kohdassa %C" #: fortran/parse.c:1976 #, gcc-internal-format, gfc-internal-format @@ -42592,7 +42157,7 @@ msgstr "" #: fortran/parse.c:2420 #, gcc-internal-format, gfc-internal-format msgid "Unexpected %s statement in INTERFACE block at %C" -msgstr "" +msgstr "Odottamaton %s-lause INTERFACE-lohkossa kohdassa %C" #: fortran/parse.c:2444 #, gcc-internal-format, gfc-internal-format @@ -42602,7 +42167,7 @@ msgstr "" #: fortran/parse.c:2477 #, gcc-internal-format, gfc-internal-format msgid "Unexpected %s statement at %C in INTERFACE body" -msgstr "" +msgstr "Odottamaton %s-lause kohdassa %C INTERFACE-rungossa" #: fortran/parse.c:2495 #, gcc-internal-format, gfc-internal-format @@ -42642,12 +42207,12 @@ msgstr "" #: fortran/parse.c:2850 #, gcc-internal-format, gfc-internal-format msgid "Unexpected %s statement in WHERE block at %C" -msgstr "" +msgstr "Odottamaton %s-lause WHERE-lohkossa kohdassa %C" #: fortran/parse.c:2909 #, gcc-internal-format, gfc-internal-format msgid "Unexpected %s statement in FORALL block at %C" -msgstr "" +msgstr "Odottamaton %s-lause FORALL-lohkossa kohdassa %C" #: fortran/parse.c:2960 #, gcc-internal-format, gfc-internal-format @@ -42657,12 +42222,12 @@ msgstr "" #: fortran/parse.c:2978 #, gcc-internal-format, gfc-internal-format msgid "Duplicate ELSE statements at %L and %C" -msgstr "" +msgstr "Kaksoiskappale-ELSE-lauseet kohdissa %L ja %C" #: fortran/parse.c:3039 #, gcc-internal-format, gfc-internal-format msgid "Expected a CASE or END SELECT statement following SELECT CASE at %C" -msgstr "" +msgstr "Odotettiin CASE- tai END SELECT-lausetta seuraavaa SELECT CASE-lausetta kohdassa %C" #: fortran/parse.c:3122 #, gcc-internal-format, gfc-internal-format @@ -42691,13 +42256,11 @@ msgstr "" #: fortran/parse.c:3342 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "In constructor %qs" msgid "BLOCK construct at %C" msgstr "Muodostin %qs" #: fortran/parse.c:3372 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "In constructor %qs" msgid "ASSOCIATE construct at %C" msgstr "Muodostin %qs" @@ -42739,7 +42302,7 @@ msgstr "" #: fortran/parse.c:4081 #, gcc-internal-format, gfc-internal-format msgid "Unexpected %s statement in CONTAINS section at %C" -msgstr "" +msgstr "Odottamaton %s-lause CONTAINS-lohkossa kohdassa %C" #: fortran/parse.c:4105 #, gcc-internal-format, gfc-internal-format @@ -42764,12 +42327,12 @@ msgstr "" #: fortran/parse.c:4279 #, gcc-internal-format, gfc-internal-format msgid "Unexpected %s statement in BLOCK DATA at %C" -msgstr "" +msgstr "Odottamaton %s-lause BLOCK DATA -lohkossa kohdassa %C" #: fortran/parse.c:4324 #, gcc-internal-format, gfc-internal-format msgid "Unexpected %s statement in MODULE at %C" -msgstr "" +msgstr "Odottamaton %s-lause MODULE-lohkossa kohdassa %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 @@ -42780,9 +42343,9 @@ msgid "Two main PROGRAMs at %L and %C" msgstr "" #: fortran/primary.c:105 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Missing kind-parameter at %C" -msgstr "tiedostonimi puuttuu option %qs jälkeen" +msgstr "Puuttuva kind-parametri kohdassa %C" #: fortran/primary.c:232 #, gcc-internal-format, gfc-internal-format @@ -42825,9 +42388,9 @@ msgid "Empty set of digits in BOZ constant at %C" msgstr "" #: fortran/primary.c:410 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Illegal character in BOZ constant at %C" -msgstr "täytemerkki strfmon-muotoilussa" +msgstr "Virheellinen merkki BOZ-vakiossa kohdassa %C" #: fortran/primary.c:433 #, gcc-internal-format, gfc-internal-format @@ -42917,7 +42480,7 @@ msgstr "" #: fortran/primary.c:1204 #, gcc-internal-format, gfc-internal-format msgid "Expected PARAMETER symbol in complex constant at %C" -msgstr "" +msgstr "Odotettiin PARAMETER-symbolia kompleksivakiossa kohdassa %C" #: fortran/primary.c:1210 #, gcc-internal-format, gfc-internal-format @@ -42952,12 +42515,12 @@ msgstr "" #: fortran/primary.c:1649 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "argument list function at %C" -msgstr "liian vähän argumentteja funktiolle %qs" +msgstr "Tuntematon argumenttiluettelofunktio kohdassa %L" #: fortran/primary.c:1718 #, gcc-internal-format, gfc-internal-format msgid "Expected alternate return label at %C" -msgstr "" +msgstr "Odotettiin vaihtoehtoista paluunimiötä kohdassa %C" #: fortran/primary.c:1736 #, gcc-internal-format, gfc-internal-format @@ -42967,7 +42530,7 @@ msgstr "" #: fortran/primary.c:1782 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in argument list at %C" -msgstr "" +msgstr "Syntaksivirhe argumenttiluettelossa kohdassa %C" #: fortran/primary.c:1841 #, gcc-internal-format, gfc-internal-format @@ -42995,9 +42558,9 @@ msgid "Expected structure component name at %C" msgstr "" #: fortran/primary.c:1989 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Expected argument list at %C" -msgstr "liian paljon argumentteja funktiolle %qs" +msgstr "Odotettiin argumenttiluetteloa kohdassa %C" #: fortran/primary.c:2020 #, fuzzy, gcc-internal-format, gfc-internal-format @@ -43062,32 +42625,32 @@ msgstr "" #: fortran/primary.c:2864 #, gcc-internal-format, gfc-internal-format msgid "Unexpected use of subroutine name '%s' at %C" -msgstr "" +msgstr "Odottamaton alirutiininimen ”%s” käyttö kohdassa %C" #: fortran/primary.c:2895 #, gcc-internal-format, gfc-internal-format msgid "Statement function '%s' requires argument list at %C" -msgstr "" +msgstr "Käskyfunktio ”%s” vaatii argumenttiluettelon kohdassa %C" #: fortran/primary.c:2898 #, gcc-internal-format, gfc-internal-format msgid "Function '%s' requires an argument list at %C" -msgstr "" +msgstr "Funktio ”%s” vaatii argumenttiluettelon kohdassa %C" #: fortran/primary.c:2948 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Missing argument to '%s' at %C" -msgstr "liikaa argumentteja funktiolle %s %q+#D" +msgstr "Puuttuva argumentti kohteelle ”%s” kohdassa %C" #: fortran/primary.c:3107 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Missing argument list in function '%s' at %C" -msgstr "lopetusalkio puuttuu funktiokutsusta" +msgstr "Puuttuva argumenttiluettelo funktiossa ”%s” kohdassa %C" #: fortran/primary.c:3141 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Symbol at %C is not appropriate for an expression" -msgstr "liukulukuylivuoto lausekkeessa" +msgstr "Symboli kohdassa %C ei sovellu lausekkeeseen" #: fortran/primary.c:3240 #, gcc-internal-format, gfc-internal-format @@ -43095,19 +42658,19 @@ msgid "Named constant at %C in an EQUIVALENCE" msgstr "" #: fortran/primary.c:3274 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "'%s' at %C is not a variable" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "”%s” kohdassa %C ei ole muuttuja" #: fortran/resolve.c:125 #, gcc-internal-format, gfc-internal-format msgid "'%s' at %L is of the ABSTRACT type '%s'" -msgstr "" +msgstr "”%s” kohdassa %L on ABSTRACT-tyyppiä ”%s”" #: fortran/resolve.c:128 #, gcc-internal-format, gfc-internal-format msgid "ABSTRACT type '%s' used at %L" -msgstr "" +msgstr "ABSTRACT-tyyppiä ”%s” käytetty kohdassa %L" #: fortran/resolve.c:145 #, gcc-internal-format, gfc-internal-format @@ -43372,7 +42935,7 @@ msgstr "" #: fortran/resolve.c:1458 #, gcc-internal-format, gfc-internal-format msgid "'%s' at %L is ambiguous" -msgstr "" +msgstr "”%s” kohdassa %L ei ole yksiselitteinen" #: fortran/resolve.c:1462 #, gcc-internal-format, gfc-internal-format @@ -43421,7 +42984,6 @@ msgstr "" #: fortran/resolve.c:1742 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "Invalid procedure argument at %L" msgid "Internal procedure '%s' is used as actual argument at %L" msgstr "Virheellinen proseduuriargumentti kohdassa %L" @@ -43438,7 +43000,7 @@ msgstr "" #: fortran/resolve.c:1799 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %L is ambiguous" -msgstr "" +msgstr "Symboli ”%s” kohdassa %L ei ole yksiselitteinen" #: fortran/resolve.c:1854 #, gcc-internal-format, gfc-internal-format @@ -43565,7 +43127,7 @@ msgstr "" msgid "Unable to resolve the specific function '%s' at %L" msgstr "" -#: fortran/resolve.c:2630 fortran/resolve.c:14732 +#: fortran/resolve.c:2630 fortran/resolve.c:14734 #, gcc-internal-format, gfc-internal-format msgid "Function '%s' at %L has no IMPLICIT type" msgstr "" @@ -43587,7 +43149,6 @@ msgstr "" #: fortran/resolve.c:2895 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "pointers are not permitted as case values" msgid "Coindexed argument not permitted in '%s' call at %L" msgstr "osoittimet eivät ole sallittuja case-arvoja" @@ -43692,9 +43253,9 @@ msgid "ENTRY '%s' at %L cannot be called recursively, as function '%s' is not RE msgstr "" #: fortran/resolve.c:3315 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Function '%s' at %L cannot be called recursively, as it is not RECURSIVE" -msgstr "muuttuvakokoista objektia ei voi alustaa" +msgstr "Funktiota ”%s” kohdassa %L ei voida kutsua rekursiivisesti, koska se ei ole RECURSIVE" #: fortran/resolve.c:3354 #, gcc-internal-format, gfc-internal-format @@ -43784,7 +43345,7 @@ msgstr "" #: fortran/resolve.c:4405 #, gcc-internal-format, gfc-internal-format msgid "Array reference at %L is out of bounds (%ld < %ld) in dimension %d" -msgstr "" +msgstr "Taulukkoviite kohdassa %L on rajojen ulkopuolella (%ld < %ld) ulottuvuudessa %d" #: fortran/resolve.c:4410 #, gcc-internal-format, gfc-internal-format @@ -43907,9 +43468,9 @@ msgid "Substring end index at %L exceeds the string length" msgstr "" #: fortran/resolve.c:4918 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Substring end index at %L is too large" -msgstr "pyydetty tasaus on liian suuri" +msgstr "Alimerkkijonon loppuindeksi kohdassa %L on liian suuri" #: fortran/resolve.c:5070 #, gcc-internal-format, gfc-internal-format @@ -44033,7 +43594,7 @@ msgstr "" #: fortran/resolve.c:6654 fortran/resolve.c:6661 #, gcc-internal-format, gfc-internal-format msgid "%s at %L must be INTEGER" -msgstr "" +msgstr "%s:n kohdassa %L täytyy olla INTEGER" #: fortran/resolve.c:6705 #, gcc-internal-format, gfc-internal-format @@ -44192,22 +43753,22 @@ msgstr "" #: fortran/resolve.c:7827 #, gcc-internal-format, gfc-internal-format msgid "CASE label at %L overlaps with CASE label at %L" -msgstr "" +msgstr "CASE-nimiö kohdassa %L menee CASE-nimiön päälle kohdassa %L" #: fortran/resolve.c:7878 #, gcc-internal-format, gfc-internal-format msgid "Expression in CASE statement at %L must be of type %s" -msgstr "" +msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %s-tyyppinen" #: fortran/resolve.c:7889 -#, 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 "tyhjä esittely" +msgstr "Lauseke CASE-lauseessa kohdassa %L on oltava %d-kaltainen" #: fortran/resolve.c:7902 #, gcc-internal-format, gfc-internal-format msgid "Expression in CASE statement at %L must be scalar" -msgstr "" +msgstr "Lausekkeen CASE-lauseessa kohdassa %L on oltava skalaari" #: fortran/resolve.c:7948 #, gcc-internal-format, gfc-internal-format @@ -44373,7 +43934,7 @@ msgstr "" #: fortran/resolve.c:8946 #, gcc-internal-format, gfc-internal-format msgid "Branch at %L may result in an infinite loop" -msgstr "" +msgstr "Haarautuminen kohdassa %L voi aiheuttaa ikisilmukan" #. Note: A label at END CRITICAL does not leave the CRITICAL #. construct as END CRITICAL is still part of it. @@ -44416,9 +43977,9 @@ msgid "Unsupported statement inside WHERE at %L" msgstr "" #: fortran/resolve.c:9144 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Assignment to a FORALL index variable at %L" -msgstr "kirjoitussuojatun muuttujan %qs sijoitus" +msgstr "Sijoitus FORALL-indeksimuuttujaan kohdassa %L" #: fortran/resolve.c:9153 #, gcc-internal-format, gfc-internal-format @@ -44544,9 +44105,9 @@ msgid "CHARACTER variable at %L has negative length %d, the length has been set msgstr "" #: fortran/resolve.c:10748 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "String length at %L is too large" -msgstr "taulukon %qs koko on liian suuri" +msgstr "Merkkijonon pituus kohdassa %L on liian suuri" #: fortran/resolve.c:11084 #, gcc-internal-format, gfc-internal-format @@ -44616,24 +44177,24 @@ msgid "COMMON variable '%s' at %L must have constant character length" msgstr "" #: fortran/resolve.c:11334 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Allocatable '%s' at %L cannot have an initializer" -msgstr "muuttuvakokoista objektia ei voi alustaa" +msgstr "Varattavalla ”%s” kohdassa %L ei voi olla alustinta" #: fortran/resolve.c:11337 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "External '%s' at %L cannot have an initializer" -msgstr "muuttuvakokoista objektia ei voi alustaa" +msgstr "Ulkoisella ”%s” kohdassa %L ei voi olla alustinta" #: fortran/resolve.c:11341 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Dummy '%s' at %L cannot have an initializer" -msgstr "muuttuvakokoista objektia ei voi alustaa" +msgstr "Tyhjällä ”%s” kohdassa %L ei voi olla alustinta" #: fortran/resolve.c:11344 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Intrinsic '%s' at %L cannot have an initializer" -msgstr "muuttuvakokoista objektia ei voi alustaa" +msgstr "Luontaisella ”%s” kohdassa %L ei voi olla alustinta" #: fortran/resolve.c:11347 #, gcc-internal-format, gfc-internal-format @@ -44641,9 +44202,9 @@ msgid "Function result '%s' at %L cannot have an initializer" msgstr "" #: fortran/resolve.c:11350 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Automatic array '%s' at %L cannot have an initializer" -msgstr "muuttuvakokoista objektia ei voi alustaa" +msgstr "Automaattitaulukolla ”%s” kohdassa %L ei voi olla alustinta" #: fortran/resolve.c:11393 #, gcc-internal-format, gfc-internal-format @@ -44661,19 +44222,19 @@ msgid "Procedure '%s' in PUBLIC interface '%s' at %L takes dummy arguments of '% msgstr "" #: fortran/resolve.c:11479 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Function '%s' at %L cannot have an initializer" -msgstr "muuttuvakokoista objektia ei voi alustaa" +msgstr "Funktiolla ”%s” kohdassa %L ei voi olla alustinta" #: fortran/resolve.c:11488 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "External object '%s' at %L may not have an initializer" -msgstr "muuttuvakokoista objektia ei voi alustaa" +msgstr "Ulkoisella objektilla ”%s” kohdassa %L ei voi olla alustinta" #: fortran/resolve.c:11496 #, gcc-internal-format, gfc-internal-format msgid "ELEMENTAL function '%s' at %L must have a scalar result" -msgstr "" +msgstr "ELEMENTAL-funktiolla ”%s” kohdassa %L täytyy olla skalaaritulos" #: fortran/resolve.c:11506 #, gcc-internal-format, gfc-internal-format @@ -44683,22 +44244,22 @@ msgstr "" #: fortran/resolve.c:11525 #, gcc-internal-format, gfc-internal-format msgid "CHARACTER(*) function '%s' at %L cannot be array-valued" -msgstr "" +msgstr "CHARACTER(*)-funktio ”%s” kohdassa %L ei voi olla taulukkoarvoinen" #: fortran/resolve.c:11529 #, gcc-internal-format, gfc-internal-format msgid "CHARACTER(*) function '%s' at %L cannot be pointer-valued" -msgstr "" +msgstr "CHARACTER(*)-funktio ”%s” kohdassa %L ei voi olla osoitinarvoinen" #: fortran/resolve.c:11533 #, gcc-internal-format, gfc-internal-format msgid "CHARACTER(*) function '%s' at %L cannot be pure" -msgstr "" +msgstr "CHARACTER(*)-funktio ”%s” kohdassa %L ei voi olla puhdas" #: fortran/resolve.c:11537 #, gcc-internal-format, gfc-internal-format msgid "CHARACTER(*) function '%s' at %L cannot be recursive" -msgstr "" +msgstr "CHARACTER(*)-funktio ”%s” kohdassa %L ei voi olla rekursiivinen" #: fortran/resolve.c:11550 #, gcc-internal-format, gfc-internal-format @@ -44706,24 +44267,24 @@ msgid "CHARACTER(*) function '%s' at %L" msgstr "" #: fortran/resolve.c:11604 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "PROCEDURE attribute conflicts with SAVE attribute in '%s' at %L" -msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" +msgstr "PROCEDURE-attribuutti on ristiriidassa SAVE-attribuutin kanssa kohteessa ”%s” kohdassa %L" #: fortran/resolve.c:11610 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "PROCEDURE attribute conflicts with INTENT attribute in '%s' at %L" -msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" +msgstr "PROCEDURE-attribuutti on ristiriidassa INTENT-attribuutin kanssa kohteessa ”%s” kohdassa %L" #: fortran/resolve.c:11616 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "PROCEDURE attribute conflicts with RESULT attribute in '%s' at %L" -msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" +msgstr "PROCEDURE-attribuutti on ristiriidassa RESULT-attribuutin kanssa kohteessa ”%s” kohdassa %L" #: fortran/resolve.c:11624 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "EXTERNAL attribute conflicts with FUNCTION attribute in '%s' at %L" -msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" +msgstr "EXTERNAL-attribuutti on ristiriidassa FUNCTION-attribuutin kanssa kohteessa ”%s” kohdassa %L" #: fortran/resolve.c:11630 #, gcc-internal-format, gfc-internal-format @@ -44741,9 +44302,9 @@ msgid "FINAL procedure at %L must have exactly one argument" msgstr "" #: fortran/resolve.c:11695 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Argument of FINAL procedure at %L must be of type '%s'" -msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" +msgstr "FINAL-proseduurin argumentin kohdassa %L täytyy olla tyyppiä ”%s”" #: fortran/resolve.c:11703 #, gcc-internal-format, gfc-internal-format @@ -44917,24 +44478,24 @@ msgid "Procedure pointer component '%s' with PASS at %L must have at least one a msgstr "" #: fortran/resolve.c:12707 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Argument '%s' of '%s' with PASS(%s) at %L must be of the derived type '%s'" -msgstr "%<__builtin_args_info%>-funktion argumentin pitää olla vakio" +msgstr "Argumentin ”%s”/”%s” PASS(%s) kohdassa %L täytyy olla perittyä tyyppiä ”%s”" #: fortran/resolve.c:12717 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Argument '%s' of '%s' with PASS(%s) at %L must be scalar" -msgstr "%<__builtin_expect%>-funktion toisen argumentin pitää olla vakio" +msgstr "Argumentin ”%s”/”%s” PASS(%s) kohdassa %L täytyy olla skalaari" #: fortran/resolve.c:12726 #, gcc-internal-format, gfc-internal-format msgid "Argument '%s' of '%s' with PASS(%s) at %L may not have the POINTER attribute" -msgstr "" +msgstr "Argumentilla ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla POINTER-attribuuttia" #: fortran/resolve.c:12735 #, gcc-internal-format, gfc-internal-format msgid "Argument '%s' of '%s' with PASS(%s) at %L may not be ALLOCATABLE" -msgstr "" +msgstr "Argumentti ”%s”/”%s” PASS(%s) kohdassa %L ei voi olla ALLOCATABLE" #: fortran/resolve.c:12772 #, gcc-internal-format, gfc-internal-format @@ -44976,412 +44537,410 @@ msgstr "" msgid "Component '%s' with CLASS at %L must be allocatable or pointer" msgstr "" -#: fortran/resolve.c:12934 +#: fortran/resolve.c:12936 #, gcc-internal-format, gfc-internal-format msgid "Generic name '%s' of function '%s' at %L being the same name as derived type at %L" msgstr "" -#: fortran/resolve.c:12990 +#: fortran/resolve.c:12992 #, gcc-internal-format, gfc-internal-format msgid "Assumed size array '%s' in namelist '%s' at %L is not allowed" msgstr "" -#: fortran/resolve.c:12996 +#: fortran/resolve.c:12998 #, gcc-internal-format, gfc-internal-format msgid "NAMELIST array object '%s' with assumed shape in namelist '%s' at %L" msgstr "" -#: fortran/resolve.c:13003 +#: fortran/resolve.c:13005 #, gcc-internal-format, gfc-internal-format msgid "NAMELIST array object '%s' with nonconstant shape in namelist '%s' at %L" msgstr "" -#: fortran/resolve.c:13012 +#: fortran/resolve.c:13014 #, gcc-internal-format, gfc-internal-format msgid "NAMELIST object '%s' with nonconstant character length in namelist '%s' at %L" msgstr "" -#: fortran/resolve.c:13022 +#: fortran/resolve.c:13024 #, gcc-internal-format, gfc-internal-format msgid "NAMELIST object '%s' in namelist '%s' at %L is polymorphic and requires a defined input/output procedure" msgstr "" -#: fortran/resolve.c:13032 +#: fortran/resolve.c:13034 #, gcc-internal-format, gfc-internal-format msgid "NAMELIST object '%s' in namelist '%s' at %L with ALLOCATABLE or POINTER components" msgstr "" #. FIXME: Once UDDTIO is implemented, the following can be #. removed. -#: fortran/resolve.c:13040 +#: fortran/resolve.c:13042 #, gcc-internal-format, gfc-internal-format msgid "NAMELIST object '%s' in namelist '%s' at %L has ALLOCATABLE or POINTER components and thus requires a defined input/output procedure" msgstr "" -#: fortran/resolve.c:13057 +#: fortran/resolve.c:13059 #, gcc-internal-format, gfc-internal-format msgid "NAMELIST object '%s' was declared PRIVATE and cannot be member of PUBLIC namelist '%s' at %L" msgstr "" -#: fortran/resolve.c:13067 +#: fortran/resolve.c:13069 #, gcc-internal-format, gfc-internal-format msgid "NAMELIST object '%s' has use-associated PRIVATE components and cannot be member of namelist '%s' at %L" msgstr "" -#: fortran/resolve.c:13078 +#: fortran/resolve.c:13080 #, gcc-internal-format, gfc-internal-format msgid "NAMELIST object '%s' has PRIVATE components and cannot be a member of PUBLIC namelist '%s' at %L" msgstr "" -#: fortran/resolve.c:13105 +#: fortran/resolve.c:13107 #, gcc-internal-format, gfc-internal-format msgid "PROCEDURE attribute conflicts with NAMELIST attribute in '%s' at %L" msgstr "" -#: fortran/resolve.c:13124 +#: fortran/resolve.c:13126 #, gcc-internal-format, gfc-internal-format msgid "Parameter array '%s' at %L cannot be automatic or of deferred shape" msgstr "" -#: fortran/resolve.c:13136 +#: fortran/resolve.c:13138 #, gcc-internal-format, gfc-internal-format msgid "Implicitly typed PARAMETER '%s' at %L doesn't match a later IMPLICIT type" msgstr "" -#: fortran/resolve.c:13147 +#: fortran/resolve.c:13149 #, gcc-internal-format, gfc-internal-format msgid "Incompatible derived type in PARAMETER at %L" msgstr "" -#: fortran/resolve.c:13230 +#: fortran/resolve.c:13232 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "PROTECTED attribute conflicts with EXTERNAL attribute at %L" msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" -#: fortran/resolve.c:13233 +#: fortran/resolve.c:13235 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "PROCEDURE attribute conflicts with PROTECTED attribute at %L" msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" -#: fortran/resolve.c:13322 +#: fortran/resolve.c:13324 #, gcc-internal-format, gfc-internal-format msgid "'%s' at %L has the CONTIGUOUS attribute but is not an array pointer or an assumed-shape or assumed-rank array" msgstr "" -#: fortran/resolve.c:13340 +#: fortran/resolve.c:13342 #, gcc-internal-format, gfc-internal-format msgid "Assumed size array at %L must be a dummy argument" msgstr "" -#: fortran/resolve.c:13343 +#: fortran/resolve.c:13345 #, gcc-internal-format, gfc-internal-format msgid "Assumed shape array at %L must be a dummy argument" msgstr "" -#: fortran/resolve.c:13351 +#: fortran/resolve.c:13353 #, gcc-internal-format, gfc-internal-format msgid "Assumed-rank array at %L must be a dummy argument" msgstr "" -#: fortran/resolve.c:13358 +#: fortran/resolve.c:13360 #, gcc-internal-format, gfc-internal-format msgid "Assumed-rank array at %L may not have the VALUE or CODIMENSION attribute" msgstr "" -#: fortran/resolve.c:13371 +#: fortran/resolve.c:13373 #, gcc-internal-format, gfc-internal-format msgid "Symbol at %L is not a DUMMY variable" msgstr "" -#: fortran/resolve.c:13377 +#: fortran/resolve.c:13379 #, gcc-internal-format, gfc-internal-format msgid "'%s' at %L cannot have the VALUE attribute because it is not a dummy argument" msgstr "" -#: fortran/resolve.c:13387 +#: fortran/resolve.c:13389 #, gcc-internal-format, gfc-internal-format msgid "Character dummy variable '%s' at %L with VALUE attribute must have constant length" msgstr "" -#: fortran/resolve.c:13396 +#: fortran/resolve.c:13398 #, gcc-internal-format, gfc-internal-format msgid "C interoperable character dummy variable '%s' at %L with VALUE attribute must have length one" msgstr "" -#: fortran/resolve.c:13409 fortran/resolve.c:13522 +#: fortran/resolve.c:13411 fortran/resolve.c:13524 #, gcc-internal-format, gfc-internal-format msgid "The derived type '%s' at %L is of type '%s', which has not been defined" msgstr "" -#: fortran/resolve.c:13422 +#: fortran/resolve.c:13424 #, gcc-internal-format, gfc-internal-format msgid "Assumed type of variable %s at %L is only permitted for dummy variables" msgstr "" -#: fortran/resolve.c:13429 +#: fortran/resolve.c:13431 #, gcc-internal-format, gfc-internal-format msgid "Assumed-type variable %s at %L may not have the ALLOCATABLE, CODIMENSION, POINTER or VALUE attribute" msgstr "" -#: fortran/resolve.c:13436 +#: fortran/resolve.c:13438 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "Assumed-type variable %s at %L may not have the INTENT(OUT) attribute" msgstr "muuttuvakokoista objektia ei voi alustaa" -#: fortran/resolve.c:13443 +#: fortran/resolve.c:13445 #, gcc-internal-format, gfc-internal-format msgid "Assumed-type variable %s at %L shall not be an explicit-shape array" msgstr "" -#: fortran/resolve.c:13468 +#: fortran/resolve.c:13470 #, gcc-internal-format, gfc-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" msgstr "" -#: fortran/resolve.c:13548 +#: fortran/resolve.c:13550 #, gcc-internal-format, gfc-internal-format msgid "PUBLIC %s '%s' at %L of PRIVATE derived type '%s'" msgstr "" -#: fortran/resolve.c:13562 +#: fortran/resolve.c:13564 #, 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 "" -#: fortran/resolve.c:13580 +#: fortran/resolve.c:13582 #, gcc-internal-format, gfc-internal-format msgid "The INTENT(OUT) dummy argument '%s' at %L is ASSUMED SIZE and so cannot have a default initializer" msgstr "" -#: fortran/resolve.c:13592 +#: fortran/resolve.c:13594 #, gcc-internal-format, gfc-internal-format msgid "Dummy argument '%s' at %L of LOCK_TYPE shall not be INTENT(OUT)" msgstr "" -#: fortran/resolve.c:13604 +#: fortran/resolve.c:13606 #, gcc-internal-format, gfc-internal-format msgid "Function result '%s' at %L shall not be a coarray or have a coarray component" msgstr "" -#: fortran/resolve.c:13613 +#: fortran/resolve.c:13615 #, gcc-internal-format, gfc-internal-format msgid "Variable '%s' at %L of TYPE(C_PTR) or TYPE(C_FUNPTR) shall not be a coarray" msgstr "" -#: fortran/resolve.c:13625 +#: fortran/resolve.c:13627 #, gcc-internal-format, gfc-internal-format msgid "Variable '%s' at %L with coarray component shall be a nonpointer, nonallocatable scalar" msgstr "" -#: fortran/resolve.c:13640 +#: fortran/resolve.c:13642 #, gcc-internal-format, gfc-internal-format msgid "Variable '%s' at %L is a coarray and is not ALLOCATABLE, SAVE nor a dummy argument" msgstr "" -#: fortran/resolve.c:13648 +#: fortran/resolve.c:13650 #, gcc-internal-format, gfc-internal-format msgid "Coarray variable '%s' at %L shall not have codimensions with deferred shape" msgstr "" -#: fortran/resolve.c:13655 +#: fortran/resolve.c:13657 #, gcc-internal-format, gfc-internal-format msgid "Allocatable coarray variable '%s' at %L must have deferred shape" msgstr "" -#: fortran/resolve.c:13667 +#: fortran/resolve.c:13669 #, gcc-internal-format, gfc-internal-format msgid "Variable '%s' at %L is INTENT(OUT) and can thus not be an allocatable coarray or have coarray components" msgstr "" -#: fortran/resolve.c:13676 +#: fortran/resolve.c:13678 #, gcc-internal-format, gfc-internal-format msgid "Coarray dummy variable '%s' at %L not allowed in BIND(C) procedure '%s'" msgstr "" -#: fortran/resolve.c:13692 +#: fortran/resolve.c:13694 #, gcc-internal-format, gfc-internal-format msgid "LOGICAL dummy argument '%s' at %L with non-C_Bool kind in BIND(C) procedure '%s'" msgstr "" -#: fortran/resolve.c:13698 +#: fortran/resolve.c:13700 #, gcc-internal-format, gfc-internal-format msgid "LOGICAL result variable '%s' at %L with non-C_Bool kind in BIND(C) procedure '%s'" msgstr "" -#: fortran/resolve.c:13778 +#: fortran/resolve.c:13780 #, gcc-internal-format, gfc-internal-format msgid "Threadprivate at %L isn't SAVEd" msgstr "" -#: fortran/resolve.c:13871 +#: fortran/resolve.c:13873 #, gcc-internal-format, gfc-internal-format msgid "BLOCK DATA element '%s' at %L must be in COMMON" msgstr "" -#: fortran/resolve.c:13877 +#: fortran/resolve.c:13879 #, gcc-internal-format, gfc-internal-format msgid "DATA array '%s' at %L must be specified in a previous declaration" msgstr "" -#: fortran/resolve.c:13886 +#: fortran/resolve.c:13888 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "DATA element '%s' at %L cannot have a coindex" msgstr "muuttuvakokoista objektia ei voi alustaa" -#: fortran/resolve.c:13900 +#: fortran/resolve.c:13902 #, gcc-internal-format, gfc-internal-format msgid "DATA element '%s' at %L is a pointer and so must be a full array" msgstr "" -#: fortran/resolve.c:13946 +#: fortran/resolve.c:13948 #, gcc-internal-format, gfc-internal-format msgid "Nonconstant array section at %L in DATA statement" msgstr "" -#: fortran/resolve.c:13959 +#: fortran/resolve.c:13961 #, gcc-internal-format, gfc-internal-format msgid "DATA statement at %L has more variables than values" msgstr "" -#: fortran/resolve.c:14058 +#: fortran/resolve.c:14060 #, gcc-internal-format, gfc-internal-format msgid "start of implied-do loop at %L could not be simplified to a constant value" msgstr "" -#: fortran/resolve.c:14066 +#: fortran/resolve.c:14068 #, gcc-internal-format, gfc-internal-format msgid "end of implied-do loop at %L could not be simplified to a constant value" msgstr "" -#: fortran/resolve.c:14074 +#: fortran/resolve.c:14076 #, gcc-internal-format, gfc-internal-format msgid "step of implied-do loop at %L could not be simplified to a constant value" msgstr "" -#: fortran/resolve.c:14199 +#: fortran/resolve.c:14201 #, gcc-internal-format, gfc-internal-format msgid "DATA statement at %L has more values than variables" msgstr "" -#: fortran/resolve.c:14337 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: fortran/resolve.c:14339 +#, gcc-internal-format, gfc-internal-format msgid "Label %d at %L defined but not used" -msgstr "%Jnimike %qD määritelty, mutta ei käytetty" +msgstr "Nimiö %d kohdassa %L on määritelty, mutta ei käytetty" -#: fortran/resolve.c:14342 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: fortran/resolve.c:14344 +#, gcc-internal-format, gfc-internal-format msgid "Label %d at %L defined but cannot be used" -msgstr "%Jnimike %qD määritelty, mutta ei käytetty" +msgstr "Nimiö %d kohdassa %L on määritelty, mutta sitä ei voida käyttää" -#: fortran/resolve.c:14426 +#: fortran/resolve.c:14428 #, gcc-internal-format, gfc-internal-format msgid "Derived type variable '%s' at %L must have SEQUENCE attribute to be an EQUIVALENCE object" msgstr "" -#: fortran/resolve.c:14435 +#: fortran/resolve.c:14437 #, gcc-internal-format, gfc-internal-format msgid "Derived type variable '%s' at %L cannot have ALLOCATABLE components to be an EQUIVALENCE object" msgstr "" -#: fortran/resolve.c:14443 +#: fortran/resolve.c:14445 #, gcc-internal-format, gfc-internal-format msgid "Derived type variable '%s' at %L with default initialization cannot be in EQUIVALENCE with a variable in COMMON" msgstr "" -#: fortran/resolve.c:14459 +#: fortran/resolve.c:14461 #, gcc-internal-format, gfc-internal-format msgid "Derived type variable '%s' at %L with pointer component(s) cannot be an EQUIVALENCE object" msgstr "" -#: fortran/resolve.c:14562 +#: fortran/resolve.c:14564 #, gcc-internal-format, gfc-internal-format msgid "Syntax error in EQUIVALENCE statement at %L" msgstr "" -#: fortran/resolve.c:14577 +#: fortran/resolve.c:14579 #, 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 "" -#: fortran/resolve.c:14589 +#: fortran/resolve.c:14591 #, gcc-internal-format, gfc-internal-format msgid "Common block member '%s' at %L cannot be an EQUIVALENCE object in the pure procedure '%s'" msgstr "" -#: fortran/resolve.c:14598 +#: fortran/resolve.c:14600 #, gcc-internal-format, gfc-internal-format msgid "Named constant '%s' at %L cannot be an EQUIVALENCE object" msgstr "" -#: fortran/resolve.c:14677 +#: fortran/resolve.c:14679 #, gcc-internal-format, gfc-internal-format msgid "Array '%s' at %L with non-constant bounds cannot be an EQUIVALENCE object" msgstr "" -#: fortran/resolve.c:14688 +#: fortran/resolve.c:14690 #, gcc-internal-format, gfc-internal-format msgid "Structure component '%s' at %L cannot be an EQUIVALENCE object" msgstr "" -#: fortran/resolve.c:14699 +#: fortran/resolve.c:14701 #, gcc-internal-format, gfc-internal-format msgid "Substring at %L has length zero" msgstr "" -#: fortran/resolve.c:14742 +#: fortran/resolve.c:14744 #, gcc-internal-format, gfc-internal-format msgid "PUBLIC function '%s' at %L of PRIVATE type '%s'" msgstr "" -#: fortran/resolve.c:14755 +#: fortran/resolve.c:14757 #, gcc-internal-format, gfc-internal-format msgid "ENTRY '%s' at %L has no IMPLICIT type" msgstr "" -#: fortran/resolve.c:14772 +#: fortran/resolve.c:14774 #, gcc-internal-format, gfc-internal-format msgid "User operator procedure '%s' at %L must be a FUNCTION" msgstr "" -#: fortran/resolve.c:14782 +#: fortran/resolve.c:14784 #, gcc-internal-format, gfc-internal-format msgid "User operator procedure '%s' at %L cannot be assumed character length" msgstr "" -#: fortran/resolve.c:14790 +#: fortran/resolve.c:14792 #, gcc-internal-format, gfc-internal-format msgid "User operator procedure '%s' at %L must have at least one argument" msgstr "" -#: fortran/resolve.c:14804 +#: fortran/resolve.c:14806 #, gcc-internal-format, gfc-internal-format msgid "First argument of operator interface at %L cannot be optional" msgstr "" -#: fortran/resolve.c:14822 +#: fortran/resolve.c:14824 #, gcc-internal-format, gfc-internal-format msgid "Second argument of operator interface at %L cannot be optional" msgstr "" -#: fortran/resolve.c:14829 +#: fortran/resolve.c:14831 #, gcc-internal-format, gfc-internal-format msgid "Operator interface at %L must have, at most, two arguments" msgstr "" -#: fortran/resolve.c:14905 +#: fortran/resolve.c:14907 #, gcc-internal-format, gfc-internal-format msgid "Contained procedure '%s' at %L of a PURE procedure must also be PURE" msgstr "" #: fortran/scanner.c:335 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "ignoring duplicate directory \"%s\"\n" msgid "Include directory \"%s\": %s" msgstr "jätetään hakemiston ”%s” kaksoiskappale huomiotta,\n" #: fortran/scanner.c:341 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "ignoring nonexistent directory \"%s\"\n" msgid "Nonexistent include directory \"%s\"" msgstr "jätetään puuttuva hakemisto ”%s” huomiotta\n" @@ -45436,9 +44995,9 @@ msgid "%s:%d: Illegal preprocessor directive" msgstr "" #: fortran/scanner.c:1953 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Can't open file '%s'" -msgstr "syötetiedoston avaaminen ei onnistu: %s" +msgstr "Ei voi avata tiedostoa ”%s”" #: fortran/simplify.c:86 #, gcc-internal-format, gfc-internal-format @@ -45471,14 +45030,14 @@ msgid "Invalid KIND parameter of %s at %L" msgstr "" #: fortran/simplify.c:701 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Argument of %s function at %L is negative" -msgstr "%qs ei ole kelpo tulostetiedosto" +msgstr "Funktion %s argumentti kohdassa %L on negatiivinen" #: fortran/simplify.c:708 -#, 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 "%<__builtin_args_info%>-funktion argumentti on rajojen ulkopuolella" +msgstr "Funktion %s argumentti kohdassa %L on lukualueen [0,127] ulkopuolella" #: fortran/simplify.c:726 #, gcc-internal-format, gfc-internal-format @@ -45631,338 +45190,338 @@ msgstr "" msgid "Character '%s' in string at %L cannot be converted into character kind %d" msgstr "" -#: fortran/symbol.c:134 +#: fortran/symbol.c:123 #, gcc-internal-format, gfc-internal-format msgid "Duplicate IMPLICIT NONE statement at %C" msgstr "" -#: fortran/symbol.c:174 +#: fortran/symbol.c:163 #, gcc-internal-format, gfc-internal-format msgid "Letter '%c' already set in IMPLICIT statement at %C" msgstr "" -#: fortran/symbol.c:196 +#: fortran/symbol.c:185 #, gcc-internal-format, gfc-internal-format msgid "Cannot specify IMPLICIT at %C after IMPLICIT NONE" msgstr "" -#: fortran/symbol.c:206 +#: fortran/symbol.c:195 #, gcc-internal-format, gfc-internal-format msgid "Letter %c already has an IMPLICIT type at %C" msgstr "" -#: fortran/symbol.c:262 +#: fortran/symbol.c:251 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %L has no IMPLICIT type" msgstr "" #. BIND(C) variables should not be implicitly declared. -#: fortran/symbol.c:279 +#: fortran/symbol.c:268 #, gcc-internal-format, gfc-internal-format msgid "Implicitly declared BIND(C) variable '%s' at %L may not be C interoperable" msgstr "" #. Dummy args to a BIND(C) routine may not be interoperable if #. they are implicitly typed. -#: fortran/symbol.c:294 +#: fortran/symbol.c:283 #, gcc-internal-format, gfc-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" msgstr "" -#: fortran/symbol.c:335 +#: fortran/symbol.c:324 #, gcc-internal-format, gfc-internal-format msgid "Function result '%s' at %L has no IMPLICIT type" msgstr "" -#: fortran/symbol.c:424 +#: fortran/symbol.c:413 #, gcc-internal-format, gfc-internal-format msgid "%s attribute not allowed in BLOCK DATA program unit at %L" msgstr "" -#: fortran/symbol.c:448 +#: fortran/symbol.c:437 #, gcc-internal-format, gfc-internal-format msgid "Namelist group name at %L cannot have the SAVE attribute" msgstr "" -#: fortran/symbol.c:482 +#: fortran/symbol.c:471 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "Procedure pointer at %C" msgstr "tyhjä esittely" -#: fortran/symbol.c:644 +#: fortran/symbol.c:633 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "%s attribute applied to %s %s at %L" msgstr "attribuutti %qs pätee vain funktiotyyppeihin" -#: fortran/symbol.c:651 +#: fortran/symbol.c:640 #, gcc-internal-format, gfc-internal-format msgid "BIND(C) applied to %s %s at %L" msgstr "" -#: fortran/symbol.c:762 fortran/symbol.c:1485 +#: fortran/symbol.c:751 fortran/symbol.c:1474 #, gcc-internal-format, gfc-internal-format msgid "%s attribute conflicts with %s attribute at %L" msgstr "" -#: fortran/symbol.c:765 +#: fortran/symbol.c:754 #, gcc-internal-format, gfc-internal-format msgid "%s attribute conflicts with %s attribute in '%s' at %L" msgstr "" -#: fortran/symbol.c:773 +#: fortran/symbol.c:762 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "%s attribute with %s attribute at %L" msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" -#: fortran/symbol.c:779 +#: fortran/symbol.c:768 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "%s attribute with %s attribute in '%s' at %L" msgstr "%qE-attribuutti soveltuu vain variadisiin funktioihin" -#: fortran/symbol.c:823 +#: fortran/symbol.c:812 #, gcc-internal-format, gfc-internal-format msgid "Cannot change attributes of USE-associated symbol at %L" msgstr "" -#: fortran/symbol.c:826 +#: fortran/symbol.c:815 #, gcc-internal-format, gfc-internal-format msgid "Cannot change attributes of USE-associated symbol %s at %L" msgstr "" -#: fortran/symbol.c:842 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: fortran/symbol.c:831 +#, gcc-internal-format, gfc-internal-format msgid "Duplicate %s attribute specified at %L" -msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline" +msgstr "Kaksoiskappale-%s-attribuutti määritelty kohdassa %L" -#: fortran/symbol.c:884 +#: fortran/symbol.c:873 #, gcc-internal-format, gfc-internal-format msgid "ALLOCATABLE specified outside of INTERFACE body at %L" msgstr "" -#: fortran/symbol.c:910 +#: fortran/symbol.c:899 #, gcc-internal-format, gfc-internal-format msgid "CODIMENSION specified for '%s' outside its INTERFACE body at %L" msgstr "" -#: fortran/symbol.c:936 +#: fortran/symbol.c:925 #, gcc-internal-format, gfc-internal-format msgid "DIMENSION specified for '%s' outside its INTERFACE body at %L" msgstr "" -#: fortran/symbol.c:1066 +#: fortran/symbol.c:1055 #, gcc-internal-format, gfc-internal-format msgid "Cray Pointee at %L appears in multiple pointer() statements" msgstr "" -#: fortran/symbol.c:1085 +#: fortran/symbol.c:1074 #, gcc-internal-format, gfc-internal-format msgid "Duplicate PROTECTED attribute specified at %L" msgstr "" -#: fortran/symbol.c:1119 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: fortran/symbol.c:1108 +#, gcc-internal-format, gfc-internal-format msgid "SAVE attribute at %L cannot be specified in a PURE procedure" -msgstr "%Jlohkoattribuuttia ei voi määrittää paikalliselle muuttujalle" +msgstr "SAVE-attribuuttia kohdassa %L ei voida määritellä PURE-proseduurissa" -#: fortran/symbol.c:1130 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: fortran/symbol.c:1119 +#, gcc-internal-format, gfc-internal-format msgid "Duplicate SAVE attribute specified at %L" -msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline" +msgstr "Kaksoiskappale SAVE-attribuutti määritelty kohdassa %L" -#: fortran/symbol.c:1151 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: fortran/symbol.c:1140 +#, gcc-internal-format, gfc-internal-format msgid "Duplicate VALUE attribute specified at %L" -msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline" +msgstr "Kaksoiskappale VALUE-attribuutti määritelty kohdassa %L" -#: fortran/symbol.c:1171 +#: fortran/symbol.c:1160 #, gcc-internal-format, gfc-internal-format msgid "Duplicate VOLATILE attribute specified at %L" msgstr "" -#: fortran/symbol.c:1190 +#: fortran/symbol.c:1179 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "Duplicate ASYNCHRONOUS attribute specified at %L" msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline" -#: fortran/symbol.c:1481 +#: fortran/symbol.c:1470 #, gcc-internal-format, gfc-internal-format msgid "%s attribute of '%s' conflicts with %s attribute at %L" msgstr "" -#: fortran/symbol.c:1515 +#: fortran/symbol.c:1504 #, gcc-internal-format, gfc-internal-format msgid "%s procedure at %L is already declared as %s procedure" msgstr "" -#: fortran/symbol.c:1550 +#: fortran/symbol.c:1539 #, gcc-internal-format, gfc-internal-format msgid "INTENT (%s) conflicts with INTENT(%s) at %L" msgstr "" -#: fortran/symbol.c:1574 +#: fortran/symbol.c:1563 #, gcc-internal-format, gfc-internal-format msgid "ACCESS specification at %L was already specified" msgstr "" -#: fortran/symbol.c:1591 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: fortran/symbol.c:1580 +#, gcc-internal-format, gfc-internal-format msgid "Duplicate BIND attribute specified at %L" -msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline" +msgstr "Kaksoiskappale-BIND-attribuutti määritelty kohdassa %L" -#: fortran/symbol.c:1598 +#: fortran/symbol.c:1587 #, gcc-internal-format, gfc-internal-format msgid "BIND(C) at %L" msgstr "" -#: fortran/symbol.c:1615 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: fortran/symbol.c:1604 +#, gcc-internal-format, gfc-internal-format msgid "Duplicate EXTENDS attribute specified at %L" -msgstr "%Javoimelle funktiolle %qD annettu attribuutti noinline" +msgstr "Kaksoiskappale-EXTENDS-attribuutti määritelty kohdassa %L" -#: fortran/symbol.c:1619 +#: fortran/symbol.c:1608 #, gcc-internal-format, gfc-internal-format msgid "EXTENDS at %L" msgstr "" -#: fortran/symbol.c:1641 +#: fortran/symbol.c:1630 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %L already has an explicit interface" msgstr "" -#: fortran/symbol.c:1648 +#: fortran/symbol.c:1637 #, gcc-internal-format, gfc-internal-format msgid "'%s' at %L has attributes specified outside its INTERFACE body" msgstr "" -#: fortran/symbol.c:1682 +#: fortran/symbol.c:1671 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %L conflicts with symbol from module '%s', use-associated at %L" msgstr "" -#: fortran/symbol.c:1686 +#: fortran/symbol.c:1675 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %L already has basic type of %s" msgstr "" -#: fortran/symbol.c:1693 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: fortran/symbol.c:1682 +#, gcc-internal-format, gfc-internal-format msgid "Procedure '%s' at %L may not have basic type of %s" -msgstr "muuttuvakokoista objektia ei voi alustaa" +msgstr "Proseduuri ”%s” kohdassa %L ei voi olla perustyyppiä %s" -#: fortran/symbol.c:1705 +#: fortran/symbol.c:1694 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %L cannot have a type" msgstr "" -#: fortran/symbol.c:1874 +#: fortran/symbol.c:1863 #, gcc-internal-format, gfc-internal-format msgid "Component '%s' at %C already declared at %L" msgstr "" -#: fortran/symbol.c:1885 +#: fortran/symbol.c:1874 #, gcc-internal-format, gfc-internal-format msgid "Component '%s' at %C already in the parent type at %L" msgstr "" -#: fortran/symbol.c:1970 +#: fortran/symbol.c:1959 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %C is ambiguous" msgstr "" -#: fortran/symbol.c:2002 +#: fortran/symbol.c:1991 #, gcc-internal-format, gfc-internal-format msgid "Derived type '%s' at %C is being used before it is defined" msgstr "" -#: fortran/symbol.c:2040 +#: fortran/symbol.c:2029 #, gcc-internal-format, gfc-internal-format msgid "Component '%s' at %C is a PRIVATE component of '%s'" msgstr "" -#: fortran/symbol.c:2058 +#: fortran/symbol.c:2047 #, gcc-internal-format, gfc-internal-format msgid "'%s' at %C is not a member of the '%s' structure" msgstr "" -#: fortran/symbol.c:2196 +#: fortran/symbol.c:2186 #, gcc-internal-format, gfc-internal-format msgid "Duplicate statement label %d at %L and %L" msgstr "" -#: fortran/symbol.c:2207 +#: fortran/symbol.c:2197 #, gcc-internal-format, gfc-internal-format msgid "Label %d at %C already referenced as branch target" msgstr "" -#: fortran/symbol.c:2217 +#: fortran/symbol.c:2207 #, gcc-internal-format, gfc-internal-format msgid "Label %d at %C already referenced as a format label" msgstr "" -#: fortran/symbol.c:2223 +#: fortran/symbol.c:2213 #, gcc-internal-format, gfc-internal-format msgid "DO termination statement which is not END DO or CONTINUE with label %d at %C" msgstr "" -#: fortran/symbol.c:2265 +#: fortran/symbol.c:2255 #, gcc-internal-format, gfc-internal-format msgid "Label %d at %C previously used as a FORMAT label" msgstr "" -#: fortran/symbol.c:2274 +#: fortran/symbol.c:2264 #, gcc-internal-format, gfc-internal-format msgid "Label %d at %C previously used as branch target" msgstr "" -#: fortran/symbol.c:2280 +#: fortran/symbol.c:2270 #, gcc-internal-format, gfc-internal-format msgid "Shared DO termination label %d at %C" msgstr "" -#: fortran/symbol.c:2600 +#: fortran/symbol.c:2590 #, gcc-internal-format, gfc-internal-format msgid "Name '%s' at %C is an ambiguous reference to '%s' from module '%s'" msgstr "" -#: fortran/symbol.c:2603 +#: fortran/symbol.c:2593 #, gcc-internal-format, gfc-internal-format msgid "Name '%s' at %C is an ambiguous reference to '%s' from current program unit" msgstr "" #. Symbol is from another namespace. -#: fortran/symbol.c:2788 +#: fortran/symbol.c:2808 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' at %C has already been host associated" msgstr "" -#: fortran/symbol.c:3665 +#: fortran/symbol.c:3793 #, gcc-internal-format, gfc-internal-format msgid "Derived type '%s' declared at %L must have the BIND attribute to be C interoperable" msgstr "" -#: fortran/symbol.c:3683 +#: fortran/symbol.c:3811 #, gcc-internal-format, gfc-internal-format msgid "Derived type '%s' with BIND(C) attribute at %L is empty, and may be inaccessible by the C companion processor" msgstr "" -#: fortran/symbol.c:3704 +#: fortran/symbol.c:3832 #, gcc-internal-format, gfc-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" msgstr "" -#: fortran/symbol.c:3714 +#: fortran/symbol.c:3842 #, gcc-internal-format, gfc-internal-format msgid "Procedure pointer component '%s' at %L cannot be a member of the BIND(C) derived type '%s' at %L" msgstr "" -#: fortran/symbol.c:3725 +#: fortran/symbol.c:3853 #, gcc-internal-format, gfc-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" msgstr "" #. If the derived type is bind(c), all fields must be #. interop. -#: fortran/symbol.c:3764 +#: fortran/symbol.c:3892 #, gcc-internal-format, gfc-internal-format msgid "Component '%s' in derived type '%s' at %L may not be C interoperable, even though derived type '%s' is BIND(C)" msgstr "" @@ -45970,25 +45529,25 @@ msgstr "" #. If derived type is param to bind(c) routine, or to one #. of the iso_c_binding procs, it must be interoperable, so #. all fields must interop too. -#: fortran/symbol.c:3773 +#: fortran/symbol.c:3901 #, gcc-internal-format, gfc-internal-format msgid "Component '%s' in derived type '%s' at %L may not be C interoperable" msgstr "" -#: fortran/symbol.c:3787 +#: fortran/symbol.c:3915 #, gcc-internal-format, gfc-internal-format msgid "Derived type '%s' at %L cannot be declared with both PRIVATE and BIND(C) attributes" msgstr "" -#: fortran/symbol.c:3795 +#: fortran/symbol.c:3923 #, gcc-internal-format, gfc-internal-format msgid "Derived type '%s' at %L cannot have the SEQUENCE attribute because it is BIND(C)" msgstr "" -#: fortran/symbol.c:4688 fortran/symbol.c:4694 +#: fortran/symbol.c:4816 fortran/symbol.c:4822 #, gcc-internal-format, gfc-internal-format msgid "Symbol '%s' is used before it is typed at %L" -msgstr "" +msgstr "Symbolia ”%s” käytetään ennen kuin sille määritellään tyyppi kohdassa %L" #: fortran/target-memory.c:656 #, gcc-internal-format, gfc-internal-format @@ -46087,66 +45646,66 @@ msgid "gfc_conv_constant_to_tree(): invalid type: %s" msgstr "" #: fortran/trans-const.c:379 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "non-constant initialization expression at %L" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "ei-vakio alustuslauseke kohdassa %L" #: fortran/trans-decl.c:1378 #, gcc-internal-format msgid "intrinsic variable which isn't a procedure" msgstr "" -#: fortran/trans-decl.c:3556 fortran/trans-decl.c:5433 +#: fortran/trans-decl.c:3556 fortran/trans-decl.c:5435 #, gcc-internal-format, gfc-internal-format msgid "Return value of function '%s' at %L not set" -msgstr "" +msgstr "Funktion ”%s” paluuarvoa kohdassa %L ei ole asetettu" -#: fortran/trans-decl.c:3883 +#: fortran/trans-decl.c:3885 #, fuzzy, gcc-internal-format msgid "Deferred type parameter not yet supported" msgstr "%Jlohkoattribuutteja ei tueta tälle kohteelle" -#: fortran/trans-decl.c:4090 +#: fortran/trans-decl.c:4092 #, gcc-internal-format, gfc-internal-format msgid "backend decl for module variable %s already exists" msgstr "" -#: fortran/trans-decl.c:4614 +#: fortran/trans-decl.c:4616 #, gcc-internal-format, gfc-internal-format msgid "Dummy argument '%s' at %L was declared INTENT(OUT) but was not set" msgstr "" -#: fortran/trans-decl.c:4618 +#: fortran/trans-decl.c:4620 #, gcc-internal-format, gfc-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" msgstr "" -#: fortran/trans-decl.c:4627 fortran/trans-decl.c:4742 +#: fortran/trans-decl.c:4629 fortran/trans-decl.c:4744 #, gcc-internal-format, gfc-internal-format msgid "Unused dummy argument '%s' at %L" msgstr "" -#: fortran/trans-decl.c:4641 +#: fortran/trans-decl.c:4643 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "Unused module variable '%s' which has been explicitly imported at %L" msgstr "%Jmuuttuja %qD esitelty %<inline%>:ksi" -#: fortran/trans-decl.c:4649 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: fortran/trans-decl.c:4651 +#, gcc-internal-format, gfc-internal-format msgid "Unused variable '%s' declared at %L" -msgstr "%Jmuuttuja %qD esitelty %<inline%>:ksi" +msgstr "Käyttämätön muuttuja ”%s” esitelty kohdassa %L" -#: fortran/trans-decl.c:4697 -#, fuzzy, gcc-internal-format, gfc-internal-format +#: fortran/trans-decl.c:4699 +#, gcc-internal-format, gfc-internal-format msgid "Unused parameter '%s' declared at %L" -msgstr "%Jparametri %qD esitelty %<inline%>:ksi" +msgstr "Käyttämätön parameteri ”%s” esitelty kohdassa %L" -#: fortran/trans-decl.c:4700 +#: fortran/trans-decl.c:4702 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "Unused parameter '%s' which has been explicitly imported at %L" msgstr "%Jparametri %qD esitelty %<inline%>:ksi" -#: fortran/trans-decl.c:4715 +#: fortran/trans-decl.c:4717 #, gcc-internal-format, gfc-internal-format msgid "Return value '%s' of function '%s' declared at %L not set" msgstr "" @@ -46167,9 +45726,9 @@ msgid "Unknown intrinsic op" msgstr "" #: fortran/trans-expr.c:3694 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "Unknown argument list function at %L" -msgstr "liian vähän argumentteja funktiolle %qs" +msgstr "Tuntematon argumenttiluettelofunktio kohdassa %L" #: fortran/trans-intrinsic.c:853 #, gcc-internal-format, gfc-internal-format @@ -46182,12 +45741,12 @@ msgstr "" msgid "'dim' argument of %s intrinsic at %L is not a valid dimension index" msgstr "" -#: fortran/trans-io.c:2032 +#: fortran/trans-io.c:2034 #, gcc-internal-format, gfc-internal-format msgid "Derived type '%s' at %L has PRIVATE components" msgstr "" -#: fortran/trans-io.c:2183 +#: fortran/trans-io.c:2185 #, gcc-internal-format, gfc-internal-format msgid "Bad IO basetype (%d)" msgstr "" @@ -46290,17 +45849,17 @@ msgstr "" #: java/class.c:1632 #, gcc-internal-format msgid "abstract method in non-abstract class" -msgstr "" +msgstr "abstrakti metodi ei-abstraktissa luokassa" #: java/class.c:2695 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "non-static method %q+D overrides static method" -msgstr "%J%qD esitelty ei-staattisena, edellinen esittely staattinen" +msgstr "ei-staattinen metodi %q+D korvaa staattisen metodin" #: java/decl.c:1204 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%q+D used prior to declaration" -msgstr "%Hprototyypin esittely" +msgstr "%q+D:a käytetty ennen esittelyä" #: java/decl.c:1627 #, gcc-internal-format @@ -46405,7 +45964,6 @@ msgstr "" #. duplicate code from LOAD macro #: java/expr.c:3547 #, fuzzy, gcc-internal-format -#| msgid "unrecognized address" msgid "unrecognized wide sub-instruction" msgstr "tunnistamaton osoite" @@ -46422,7 +45980,7 @@ msgstr "" #: java/jcf-parse.c:1097 #, gcc-internal-format msgid "bad string constant" -msgstr "" +msgstr "virheellinen merkkijonovakio" #: java/jcf-parse.c:1115 #, gcc-internal-format, gfc-internal-format @@ -46453,12 +46011,12 @@ msgstr "" #: java/jcf-parse.c:1462 #, gcc-internal-format msgid "error while parsing fields" -msgstr "" +msgstr "virhe jäsennettäessä kenttiä" #: java/jcf-parse.c:1465 #, gcc-internal-format msgid "error while parsing methods" -msgstr "" +msgstr "virhe jäsennettäessä metodeja" #: java/jcf-parse.c:1468 #, gcc-internal-format @@ -46478,11 +46036,10 @@ msgstr "puuttuva Code-attribuutti" #: java/jcf-parse.c:1848 #, gcc-internal-format msgid "no input file specified" -msgstr "" +msgstr "syötetiedostoa ei ole annettu" #: java/jcf-parse.c:1883 #, fuzzy, gcc-internal-format -#| msgid "can't close input file %s: %m" msgid "can%'t close input file %s: %m" msgstr "ei voida sulkea syötetiedostoa %s: %m" @@ -46494,7 +46051,7 @@ msgstr "virheellinen zip/jar-tiedosto %s" #: java/jcf-parse.c:2128 #, gcc-internal-format, gfc-internal-format msgid "error while reading %s from zip file" -msgstr "" +msgstr "virhe luettaessa %s zip-tiedostosta" #: java/jvspec.c:395 #, gcc-internal-format @@ -46509,7 +46066,7 @@ msgstr "%qs ei ole kelpo tulostetiedosto" #: java/jvspec.c:404 #, gcc-internal-format msgid "--resource requires -o" -msgstr "" +msgstr "valitsin --resource vaatii valitsimen -o" #: java/jvspec.c:411 #, gcc-internal-format @@ -46519,12 +46076,12 @@ msgstr "" #: java/jvspec.c:418 #, gcc-internal-format msgid "cannot specify both -C and -o" -msgstr "" +msgstr "ei voi määritellä sekä valitsinta -C että valitsinta -o" #: java/jvspec.c:430 #, gcc-internal-format msgid "cannot create temporary file" -msgstr "" +msgstr "ei voi luoda tilapäistä tiedostoa" #: java/jvspec.c:452 #, gcc-internal-format @@ -46564,22 +46121,22 @@ msgstr "" #: java/mangle_name.c:324 java/mangle_name.c:401 #, gcc-internal-format msgid "internal error - invalid Utf8 name" -msgstr "" +msgstr "sisäinen virhe - virheellinen Utf8-nimi" #: java/typeck.c:424 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "junk at end of signature string" -msgstr "roskaa ilmaisun #pragma weak lopussa" +msgstr "roskaa signatuurimerkkijonon lopussa" #: java/verify-glue.c:377 -#, fuzzy, gcc-internal-format, gfc-internal-format +#, gcc-internal-format, gfc-internal-format msgid "verification failed: %s" -msgstr "verify_flow_info epäonnistui" +msgstr "verifiointi epäonnistui: %s" #: java/verify-glue.c:379 #, gcc-internal-format, gfc-internal-format msgid "verification failed at PC=%d: %s" -msgstr "" +msgstr "verifiointi epäonnistui kohdassa PC=%d: %s" #: java/verify-glue.c:467 #, gcc-internal-format @@ -46593,7 +46150,6 @@ msgstr "" #: lto/lto-object.c:112 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "pex_init failed: %s" msgid "open %s failed: %s" msgstr "pex_init epäonnistui: %s" @@ -46605,13 +46161,11 @@ msgstr "%s: %s" #: lto/lto-object.c:158 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "%s: %s" msgid "%s: %s: %s" msgstr "%s: %s" #: lto/lto-object.c:200 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "fclose %s" msgid "close: %s" msgstr "fclose %s" @@ -46631,9 +46185,9 @@ msgid "bytecode stream: garbage at the end of symbols section" msgstr "" #: lto/lto.c:2145 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "could not parse hex number" -msgstr "%s: ei voida avata PCH-tiedostoa: %m\n" +msgstr "ei voitu jäsentää heksadesimaalinumeroa" #: lto/lto.c:2177 #, gcc-internal-format, gfc-internal-format @@ -46641,14 +46195,14 @@ msgid "unexpected file name %s in linker resolution file. Expected %s" msgstr "" #: lto/lto.c:2186 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "could not parse file offset" -msgstr "%s: ei voida avata PCH-tiedostoa: %m\n" +msgstr "ei voitu jäsentää tiedostosiirrosta" #: lto/lto.c:2189 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "unexpected offset" -msgstr "vektoriylivuoto lausekkeessa" +msgstr "odottamaton siirros" #: lto/lto.c:2211 #, fuzzy, gcc-internal-format @@ -46673,7 +46227,7 @@ msgstr "" #: lto/lto.c:2440 #, fuzzy, gcc-internal-format, gfc-internal-format msgid "Cannot open %s" -msgstr "syötetiedoston avaaminen ei onnistu: %s" +msgstr "Ei voi avata tiedostoa ”%s”" #: lto/lto.c:2461 #, gcc-internal-format, gfc-internal-format @@ -46682,7 +46236,6 @@ msgstr "" #: lto/lto.c:2472 #, fuzzy, gcc-internal-format, gfc-internal-format -#| msgid "can%'t read %s: %m" msgid "Cannot read %s" msgstr "ei voi lukea tiedostoa %s: %m" @@ -46692,9 +46245,9 @@ msgid "no LTRANS output list filename provided" msgstr "kirjoitettaessa tulostetta tiedostoon %s: %m" #: lto/lto.c:2597 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "opening LTRANS output list %s: %m" -msgstr "avataan tulostetiedosto %s: %m" +msgstr "avattaessa LTRANS-tulosteluetteloa %s: %m" #: lto/lto.c:2640 #, gcc-internal-format @@ -46702,19 +46255,19 @@ msgid "lto_obj_file_open() failed" msgstr "" #: lto/lto.c:2694 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "writing to LTRANS output list %s: %m" -msgstr "kirjoitettaessa tulostetta tiedostoon %s: %m" +msgstr "kirjoitettaessa LTRANS-tulosteluetteloa %s: %m" #: lto/lto.c:2702 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "closing LTRANS output list %s: %m" -msgstr "avataan tulostetiedosto %s: %m" +msgstr "suljettaessa LTRANS-tulosteluetteloa %s: %m" #: lto/lto.c:2929 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "could not open symbol resolution file: %m" -msgstr "%s: ei voida avata PCH-tiedostoa: %m\n" +msgstr "ei voitu avata symbolinselvitystiedostoa: %m" #: lto/lto.c:3046 #, gcc-internal-format @@ -46845,7 +46398,6 @@ msgstr "" #. a different matter. #: objc/objc-act.c:913 #, fuzzy, gcc-internal-format -#| msgid "opaque vector types cannot be initialized" msgid "property can not be a bit-field" msgstr "läpinäkymättömiä vektorityyppejä ei voida alustaa" @@ -46984,27 +46536,27 @@ msgstr "" #: objc/objc-act.c:2551 #, gcc-internal-format msgid "comparison of distinct Objective-C types lacks a cast" -msgstr "" +msgstr "erilaisten Objective-C-tyyppien vertailusta puuttuu tyyppimuunnos" #: objc/objc-act.c:2555 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "initialization from distinct Objective-C type" -msgstr "alustus yhteensopimattomasta osoitintyypistä" +msgstr "alustus erilaisesta Objective-C-tyypistä" #: objc/objc-act.c:2559 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "assignment from distinct Objective-C type" -msgstr "alustus yhteensopimattomasta osoitintyypistä" +msgstr "sijoitus erilaisesta Objective-C-tyypistä" #: objc/objc-act.c:2563 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "distinct Objective-C type in return" -msgstr "yhteensopimattomat tyypin palautuksessa" +msgstr "erilainen Objective-C-tyyppi palautuksessa" #: objc/objc-act.c:2567 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "passing argument %d of %qE from distinct Objective-C type" -msgstr "yhteensopimatonta osoitintyyppiä olevan argumentin %d antaminen funktiolle %qE" +msgstr "argumentin %d/%qE välitys erilaisesta Objective-C-tyypistä" #: objc/objc-act.c:2705 #, gcc-internal-format @@ -47034,15 +46586,15 @@ msgid "protocol %qE has circular dependency" msgstr "protokollalla %qE on kehäriippuvuus" #: objc/objc-act.c:2853 objc/objc-act.c:5676 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "cannot find protocol declaration for %qE" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "ei löydetä protokollaesittelyä %qE:lle" #: objc/objc-act.c:3155 objc/objc-act.c:3810 objc/objc-act.c:6389 #: objc/objc-act.c:6864 objc/objc-act.c:6937 objc/objc-act.c:6990 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "cannot find interface declaration for %qE" -msgstr "%qD esitelty extern-avainsanalla sisäkkäin" +msgstr "ei löydetä rajapintaesittelyä %qE:lle" #: objc/objc-act.c:3159 #, gcc-internal-format @@ -47055,9 +46607,9 @@ msgid "cannot find reference tag for class %qE" msgstr "%qD esitelty extern-avainsanalla sisäkkäin" #: objc/objc-act.c:3309 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE is not an Objective-C class name or alias" -msgstr "%qs ei ole kelpo tulostetiedosto" +msgstr "%qE ei ole Objective-C-luokkanimi eikä -alias" #: objc/objc-act.c:3324 objc/objc-act.c:3355 objc/objc-act.c:6770 #: objc/objc-act.c:8093 objc/objc-act.c:8144 @@ -47068,17 +46620,17 @@ msgstr "" #: objc/objc-act.c:3329 #, gcc-internal-format msgid "cannot find class %qE" -msgstr "" +msgstr "ei löydetä luokkaa %qE" #: objc/objc-act.c:3331 #, gcc-internal-format msgid "class %qE already exists" -msgstr "" +msgstr "luokka %qE on jo olemassa" #: objc/objc-act.c:3373 objc/objc-act.c:6829 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "%qE redeclared as different kind of symbol" -msgstr "%J%qD esitelty uudelleen erityyppisenä symbolina" +msgstr "%qE esitelty uudelleen erityyppisenä symbolina" #: objc/objc-act.c:3664 #, gcc-internal-format @@ -47107,7 +46659,6 @@ msgstr "" #: objc/objc-act.c:3961 objc/objc-act.c:3989 objc/objc-act.c:4045 #, fuzzy, gcc-internal-format -#| msgid "unused variable %q+D" msgid "duplicate instance variable %q+D" msgstr "käyttämätön muuttuja %q+D" @@ -47129,7 +46680,7 @@ msgstr "%<void%> vain parametrina ei ole oikeutettu" #: objc/objc-act.c:4240 #, gcc-internal-format msgid "exception of type %<%T%> will be caught" -msgstr "" +msgstr "%<%T%>-tyyppinen poikkeus siepataan" #: objc/objc-act.c:4242 #, gcc-internal-format @@ -47169,7 +46720,7 @@ msgstr "" #: objc/objc-act.c:4658 #, gcc-internal-format msgid "can not use an object as parameter to a method" -msgstr "" +msgstr "ei voi käyttää objektia metodin parametrinä" #: objc/objc-act.c:4702 #, gcc-internal-format @@ -47177,14 +46728,14 @@ msgid "method argument attributes are not available in Objective-C 1.0" msgstr "" #: objc/objc-act.c:5085 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "multiple methods named %<%c%E%> found" -msgstr "%Juseita parametreja nimellä %qD" +msgstr "löytyi useita metodeja nimellä %<%c%E%>" #: objc/objc-act.c:5088 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "using %<%c%s%>" -msgstr "%J%s %<%c%s%>" +msgstr "käytetään %<%c%s%>" #: objc/objc-act.c:5097 #, fuzzy, gcc-internal-format @@ -47241,9 +46792,9 @@ msgstr "" #. We have a type, but it's not an Objective-C type (!). #: objc/objc-act.c:5566 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "invalid receiver type %qs" -msgstr "epäkelpo osoitintila %qs" +msgstr "virheellinen vastaanottajatyyppi %qs" #: objc/objc-act.c:5583 #, gcc-internal-format @@ -47253,27 +46804,27 @@ msgstr "" #: objc/objc-act.c:5597 #, gcc-internal-format msgid "%qE may not respond to %<%c%E%>" -msgstr "" +msgstr "%qE ei välttämättä vastaa viestiin %<%c%E%>" #: objc/objc-act.c:5605 #, gcc-internal-format msgid "no %<%c%E%> method found" -msgstr "" +msgstr "ei löytynyt %<%c%E%>-methodia" #: objc/objc-act.c:5612 #, gcc-internal-format msgid "(Messages without a matching method signature" -msgstr "" +msgstr "(Viestien ilman täsmäävää metodisignatuuria" #: objc/objc-act.c:5614 #, gcc-internal-format msgid "will be assumed to return %<id%> and accept" -msgstr "" +msgstr "oletetaan palauttavan %<id%> ja hyväksyvän" #: objc/objc-act.c:5616 #, gcc-internal-format msgid "%<...%> as arguments.)" -msgstr "" +msgstr "%<...%> argumentteina.)" #: objc/objc-act.c:5725 #, gcc-internal-format @@ -47336,7 +46887,6 @@ msgstr "muuttujalla %qD on alustin, mutta vaillinainen tyyppi" #: objc/objc-act.c:6225 #, fuzzy, gcc-internal-format -#| msgid "invalid use of flexible array member" msgid "instance variable %qs uses flexible array member" msgstr "joustavien taulukkoalkioiden epäkelpo käyttö" @@ -47353,14 +46903,14 @@ msgstr "hajottimella ei voi olla parametreja" #. Vtable pointers are Real Bad(tm), since Obj-C cannot #. initialize them. #: objc/objc-act.c:6270 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type %qE has virtual member functions" -msgstr "%<this%> ei ole käytettävissä staattisissa jäsenfunktioissa" +msgstr "tyypillä %qE on virtuaalisia jäsenfunktioita" #: objc/objc-act.c:6271 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "illegal aggregate type %qE specified for instance variable %qs" -msgstr "%Jei-staattisen paikallismuuttujan %qD asm-määrittäjä jätetään huomiotta" +msgstr "virheellinen aggregaattityyppi %qE määritelty instanssimuuttujalle %qs" #: objc/objc-act.c:6281 #, gcc-internal-format @@ -47378,24 +46928,24 @@ msgid "C++ constructors and destructors will not be invoked for Objective-C fiel msgstr "" #: objc/objc-act.c:6418 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "instance variable %qE is declared private" -msgstr "halutaan rekisterimuuttujan %qD osoite" +msgstr "instanssimuuttuja %qE on esitelty yksityisenä" #: objc/objc-act.c:6429 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "instance variable %qE is %s; this will be a hard error in the future" -msgstr "halutaan rekisterimuuttujan %qD osoite" +msgstr "instanssimuuttuja %qE on %s; tämä saattaa olla kova virhe tulevaisuudessa" #: objc/objc-act.c:6436 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "instance variable %qE is declared %s" -msgstr "%Jmuuttuja %qD esitelty %<inline%>:ksi" +msgstr "instanssimuuttuja %qE esiteltiin nimellä %s" #: objc/objc-act.c:6547 objc/objc-act.c:6662 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "incomplete implementation of class %qE" -msgstr "funktion %qD yhteensopimaton implisiittinen esittely" +msgstr "luokan %qE vaillinainen toteutus" #: objc/objc-act.c:6551 objc/objc-act.c:6666 #, fuzzy, gcc-internal-format @@ -47403,9 +46953,9 @@ msgid "incomplete implementation of category %qE" msgstr "funktion %qD yhteensopimaton implisiittinen esittely" #: objc/objc-act.c:6560 objc/objc-act.c:6674 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "method definition for %<%c%E%> not found" -msgstr "sisäkkäinen uudelleenmäärittely: %<struct %s%>" +msgstr "%<%c%E%>:n metodimäärittelyä ei löytynyt" #: objc/objc-act.c:6715 #, gcc-internal-format @@ -47428,19 +46978,19 @@ msgid "conflicting super class name %qE" msgstr "%qs:n esittelyssä tyyppi on oletuksena %<int%>" #: objc/objc-act.c:6880 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "previous declaration of %qE" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "%qE:n edellinen esittely" #: objc/objc-act.c:6882 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "previous declaration" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "edellinen esittely" #: objc/objc-act.c:6895 objc/objc-act.c:6897 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "duplicate interface declaration for class %qE" -msgstr "%qs-nimikkeen kaksoisesittely" +msgstr "kaksoiskappale-rajapintaesittely luokalle %qE" #: objc/objc-act.c:7216 objc/objc-act.c:7411 #, gcc-internal-format @@ -47550,19 +47100,19 @@ msgid "protocol %qE is deprecated" msgstr "%J%qD on tavallisesti ei-staattinen funktio" #: objc/objc-act.c:8189 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "duplicate declaration for protocol %qE" -msgstr "%qs-nimikkeen kaksoisesittely" +msgstr "protokollan %qE esittelyn kaksoiskappale" #: objc/objc-act.c:8699 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "conflicting types for %<%c%s%>" -msgstr "ristiriitaiset tyypit %qD:lle" +msgstr "ristiriitaiset tyypit kohteelle %<%c%s%>:lle" #: objc/objc-act.c:8703 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "previous declaration of %<%c%s%>" -msgstr "%J%qD:lle ei ole aiempaa esittelyä" +msgstr "%<%c%s%>:n aikasempi esittely" #: objc/objc-act.c:8803 #, gcc-internal-format @@ -47585,9 +47135,9 @@ msgid "instance variable %qs is declared private" msgstr "halutaan rekisterimuuttujan %qD osoite" #: objc/objc-act.c:9379 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "local declaration of %qE hides instance variable" -msgstr "%J%qD:n esittely varjostaa edellistä paikallista" +msgstr "%qE:n paikallinen esittely piilottaa instanssimuuttujan" #. This can happen if DECL_ARTIFICIAL (*expr_p), but #. should be impossible for real properties, which always @@ -47613,9 +47163,9 @@ msgid "collection in fast enumeration is not an object" msgstr "" #: objc/objc-encoding.c:130 -#, fuzzy, gcc-internal-format +#, gcc-internal-format msgid "type %qT does not have a known size" -msgstr "%J%qD on tavallisesti ei-staattinen funktio" +msgstr "tyypillä %qT ei ole tunnettua kokoa" #: objc/objc-encoding.c:718 #, gcc-internal-format diff --git a/gcc/simplify-rtx.c b/gcc/simplify-rtx.c index 9bb31e76ed9..17a3d12e076 100644 --- a/gcc/simplify-rtx.c +++ b/gcc/simplify-rtx.c @@ -1470,6 +1470,29 @@ simplify_unary_operation_1 (enum rtx_code code, enum machine_mode mode, rtx op) } } + /* (zero_extend:M (subreg:N <X:O>)) is <X:O> (for M == O) or + (zero_extend:M <X:O>), if X doesn't have any non-zero bits outside + of mode N. E.g. + (zero_extend:SI (subreg:QI (and:SI (reg:SI) (const_int 63)) 0)) is + (and:SI (reg:SI) (const_int 63)). */ + if (GET_CODE (op) == SUBREG + && GET_MODE_PRECISION (GET_MODE (op)) + < GET_MODE_PRECISION (GET_MODE (SUBREG_REG (op))) + && GET_MODE_PRECISION (GET_MODE (SUBREG_REG (op))) + <= HOST_BITS_PER_WIDE_INT + && GET_MODE_PRECISION (mode) + >= GET_MODE_PRECISION (GET_MODE (SUBREG_REG (op))) + && subreg_lowpart_p (op) + && (nonzero_bits (SUBREG_REG (op), GET_MODE (SUBREG_REG (op))) + & ~GET_MODE_MASK (GET_MODE (op))) == 0) + { + if (GET_MODE_PRECISION (mode) + == GET_MODE_PRECISION (GET_MODE (SUBREG_REG (op)))) + return SUBREG_REG (op); + return simplify_gen_unary (ZERO_EXTEND, mode, SUBREG_REG (op), + GET_MODE (SUBREG_REG (op))); + } + #if defined(POINTERS_EXTEND_UNSIGNED) && !defined(HAVE_ptr_extend) /* As we do not know which address space the pointer is referring to, we can do this only if the target does not support different pointer @@ -2818,6 +2841,7 @@ simplify_binary_operation_1 (enum rtx_code code, enum machine_mode mode, HOST_WIDE_INT mask = INTVAL (trueop1) << count; if (mask >> count == INTVAL (trueop1) + && trunc_int_for_mode (mask, mode) == mask && (mask & nonzero_bits (XEXP (op0, 0), mode)) == 0) return simplify_gen_binary (ASHIFTRT, mode, plus_constant (mode, XEXP (op0, 0), diff --git a/gcc/target.def b/gcc/target.def index 3ba3e0a2454..e18ef87b5cc 100644 --- a/gcc/target.def +++ b/gcc/target.def @@ -35,14 +35,32 @@ HOOK_VECTOR (TARGET_ASM_OUT, asm_out) /* Opening and closing parentheses for asm expression grouping. */ DEFHOOKPOD (open_paren, - "", + "These target hooks are C string constants, describing the syntax in the\n\ +assembler for grouping arithmetic expressions. If not overridden, they\n\ +default to normal parentheses, which is correct for most assemblers.", const char *, "(") DEFHOOKPODX (close_paren, const char *, ")") /* Assembler instructions for creating various kinds of integer object. */ DEFHOOKPOD (byte_op, - "", + "@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_HI_OP\n\ +@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_SI_OP\n\ +@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_DI_OP\n\ +@deftypevrx {Target Hook} {const char *} TARGET_ASM_ALIGNED_TI_OP\n\ +@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_HI_OP\n\ +@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_SI_OP\n\ +@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_DI_OP\n\ +@deftypevrx {Target Hook} {const char *} TARGET_ASM_UNALIGNED_TI_OP\n\ +These hooks specify assembly directives for creating certain kinds\n\ +of integer object. The @code{TARGET_ASM_BYTE_OP} directive creates a\n\ +byte-sized object, the @code{TARGET_ASM_ALIGNED_HI_OP} one creates an\n\ +aligned two-byte object, and so on. Any of the hooks may be\n\ +@code{NULL}, indicating that no suitable directive is available.\n\ +\n\ +The compiler will print these strings at the start of a new line,\n\ +followed immediately by the object's initial value. In most cases,\n\ +the string should contain a tab, a pseudo-op, and then another tab.", const char *, "\t.byte\t") DEFHOOKPOD (aligned_op, "*", struct asm_int_op, TARGET_ASM_ALIGNED_INT_OP) DEFHOOKPOD (unaligned_op, "*", struct asm_int_op, TARGET_ASM_UNALIGNED_INT_OP) @@ -51,7 +69,9 @@ DEFHOOKPOD (unaligned_op, "*", struct asm_int_op, TARGET_ASM_UNALIGNED_INT_OP) LABEL_ALIGN_AFTER_BARRIER. */ DEFHOOK (label_align_after_barrier_max_skip, - "", + "The maximum number of bytes to skip before @var{label} when applying\n\ +@code{LABEL_ALIGN_AFTER_BARRIER}. This works only if\n\ +@code{ASM_OUTPUT_MAX_SKIP_ALIGN} is defined.", int, (rtx label), default_label_align_after_barrier_max_skip) @@ -59,7 +79,9 @@ DEFHOOK LOOP_ALIGN. */ DEFHOOK (loop_align_max_skip, - "", + "The maximum number of bytes to skip when applying @code{LOOP_ALIGN} to\n\ +@var{label}. This works only if @code{ASM_OUTPUT_MAX_SKIP_ALIGN} is\n\ +defined.", int, (rtx label), default_loop_align_max_skip) @@ -67,7 +89,9 @@ DEFHOOK LABEL_ALIGN. */ DEFHOOK (label_align_max_skip, - "", + "The maximum number of bytes to skip when applying @code{LABEL_ALIGN}\n\ +to @var{label}. This works only if @code{ASM_OUTPUT_MAX_SKIP_ALIGN}\n\ +is defined.", int, (rtx label), default_label_align_max_skip) @@ -75,7 +99,9 @@ DEFHOOK JUMP_ALIGN. */ DEFHOOK (jump_align_max_skip, - "", + "The maximum number of bytes to skip before @var{label} when applying\n\ +@code{JUMP_ALIGN}. This works only if\n\ +@code{ASM_OUTPUT_MAX_SKIP_ALIGN} is defined.", int, (rtx label), default_jump_align_max_skip) @@ -86,7 +112,16 @@ DEFHOOK and UNALIGNED_OP are NULL. */ DEFHOOK (integer, - "", + "The @code{assemble_integer} function uses this hook to output an\n\ +integer object. @var{x} is the object's value, @var{size} is its size\n\ +in bytes and @var{aligned_p} indicates whether it is aligned. The\n\ +function should return @code{true} if it was able to output the\n\ +object. If it returns false, @code{assemble_integer} will try to\n\ +split the object into smaller parts.\n\ +\n\ +The default implementation of this hook will use the\n\ +@code{TARGET_ASM_BYTE_OP} family of strings, returning @code{false}\n\ +when the relevant string is @code{NULL}.", /* Only handles cases for which BYTE_OP, ALIGNED_OP and UNALIGNED_OP are NULL. */ bool, (rtx x, unsigned int size, int aligned_p), @@ -95,14 +130,23 @@ DEFHOOK /* Output code that will globalize a label. */ DEFHOOK (globalize_label, - "", + "This target hook is a function to output to the stdio stream\n\ +@var{stream} some commands that will make the label @var{name} global;\n\ +that is, available for reference from other files.\n\ +\n\ +The default implementation relies on a proper definition of\n\ +@code{GLOBAL_ASM_OP}.", void, (FILE *stream, const char *name), default_globalize_label) /* Output code that will globalize a declaration. */ DEFHOOK (globalize_decl_name, - "", + "This target hook is a function to output to the stdio stream\n\ +@var{stream} some commands that will make the name associated with @var{decl}\n\ +global; that is, available for reference from other files.\n\ +\n\ +The default implementation uses the TARGET_ASM_GLOBALIZE_LABEL target hook.", void, (FILE *stream, tree decl), default_globalize_decl_name) /* Output code that will emit a label for unwind info, if this @@ -112,14 +156,26 @@ DEFHOOK this is only a placeholder for an omitted FDE. */ DEFHOOK (emit_unwind_label, - "", + "This target hook emits a label at the beginning of each FDE@. It\n\ +should be defined on targets where FDEs need special labels, and it\n\ +should write the appropriate label, for the FDE associated with the\n\ +function declaration @var{decl}, to the stdio stream @var{stream}.\n\ +The third argument, @var{for_eh}, is a boolean: true if this is for an\n\ +exception table. The fourth argument, @var{empty}, is a boolean:\n\ +true if this is a placeholder label for an omitted FDE@.\n\ +\n\ +The default is that FDEs are not given nonlocal labels.", void, (FILE *stream, tree decl, int for_eh, int empty), default_emit_unwind_label) /* Output code that will emit a label to divide up the exception table. */ DEFHOOK (emit_except_table_label, - "", + "This target hook emits a label at the beginning of the exception table.\n\ +It should be defined on targets where it is desirable for the table\n\ +to be broken up according to function.\n\ +\n\ +The default is that no label is emitted.", void, (FILE *stream), default_emit_except_table_label) @@ -135,7 +191,9 @@ DEFHOOK /* Emit any directives required to unwind this instruction. */ DEFHOOK (unwind_emit, - "", + "This target hook emits assembly directives required to unwind the\n\ +given instruction. This is only used when @code{TARGET_EXCEPT_UNWIND_INFO}\n\ +returns @code{UI_TARGET}.", void, (FILE *stream, rtx insn), NULL) @@ -157,21 +215,47 @@ DEFHOOK_UNDOC /* Output an internal label. */ DEFHOOK (internal_label, - "", + "A function to output to the stdio stream @var{stream} a label whose\n\ +name is made from the string @var{prefix} and the number @var{labelno}.\n\ +\n\ +It is absolutely essential that these labels be distinct from the labels\n\ +used for user-level functions and variables. Otherwise, certain programs\n\ +will have name conflicts with internal labels.\n\ +\n\ +It is desirable to exclude internal labels from the symbol table of the\n\ +object file. Most assemblers have a naming convention for labels that\n\ +should be excluded; on many systems, the letter @samp{L} at the\n\ +beginning of a label has this effect. You should find out what\n\ +convention your system uses, and follow it.\n\ +\n\ +The default version of this function utilizes @code{ASM_GENERATE_INTERNAL_LABEL}.", void, (FILE *stream, const char *prefix, unsigned long labelno), default_internal_label) /* Output label for the constant. */ DEFHOOK (declare_constant_name, - "", + "A target hook to output to the stdio stream @var{file} any text necessary\n\ +for declaring the name @var{name} of a constant which is being defined. This\n\ +target hook is responsible for outputting the label definition (perhaps using\n\ +@code{assemble_label}). The argument @var{exp} is the value of the constant,\n\ +and @var{size} is the size of the constant in bytes. The @var{name}\n\ +will be an internal label.\n\ +\n\ +The default version of this target hook, define the @var{name} in the\n\ +usual manner as a label (by means of @code{assemble_label}).\n\ +\n\ +You may wish to use @code{ASM_OUTPUT_TYPE_DIRECTIVE} in this target hook.", void, (FILE *file, const char *name, const_tree expr, HOST_WIDE_INT size), default_asm_declare_constant_name) /* Emit a ttype table reference to a typeinfo object. */ DEFHOOK (ttype, - "", + "This hook is used to output a reference from a frame unwinding table to\n\ +the type_info object identified by @var{sym}. It should return @code{true}\n\ +if the reference was output. Returning @code{false} will cause the\n\ +reference to be output using the normal Dwarf2 routines.", bool, (rtx sym), hook_bool_rtx_false) @@ -179,42 +263,140 @@ DEFHOOK associated with the tree decl. */ DEFHOOK (assemble_visibility, - "", + "This target hook is a function to output to @var{asm_out_file} some\n\ +commands that will make the symbol(s) associated with @var{decl} have\n\ +hidden, protected or internal visibility as specified by @var{visibility}.", void, (tree decl, int visibility), default_assemble_visibility) /* Output the assembler code for entry to a function. */ DEFHOOK (function_prologue, - "", + "If defined, a function that outputs the assembler code for entry to a\n\ +function. The prologue is responsible for setting up the stack frame,\n\ +initializing the frame pointer register, saving registers that must be\n\ +saved, and allocating @var{size} additional bytes of storage for the\n\ +local variables. @var{size} is an integer. @var{file} is a stdio\n\ +stream to which the assembler code should be output.\n\ +\n\ +The label for the beginning of the function need not be output by this\n\ +macro. That has already been done when the macro is run.\n\ +\n\ +@findex regs_ever_live\n\ +To determine which registers to save, the macro can refer to the array\n\ +@code{regs_ever_live}: element @var{r} is nonzero if hard register\n\ +@var{r} is used anywhere within the function. This implies the function\n\ +prologue should save register @var{r}, provided it is not one of the\n\ +call-used registers. (@code{TARGET_ASM_FUNCTION_EPILOGUE} must likewise use\n\ +@code{regs_ever_live}.)\n\ +\n\ +On machines that have ``register windows'', the function entry code does\n\ +not save on the stack the registers that are in the windows, even if\n\ +they are supposed to be preserved by function calls; instead it takes\n\ +appropriate steps to ``push'' the register stack, if any non-call-used\n\ +registers are used in the function.\n\ +\n\ +@findex frame_pointer_needed\n\ +On machines where functions may or may not have frame-pointers, the\n\ +function entry code must vary accordingly; it must set up the frame\n\ +pointer if one is wanted, and not otherwise. To determine whether a\n\ +frame pointer is in wanted, the macro can refer to the variable\n\ +@code{frame_pointer_needed}. The variable's value will be 1 at run\n\ +time in a function that needs a frame pointer. @xref{Elimination}.\n\ +\n\ +The function entry code is responsible for allocating any stack space\n\ +required for the function. This stack space consists of the regions\n\ +listed below. In most cases, these regions are allocated in the\n\ +order listed, with the last listed region closest to the top of the\n\ +stack (the lowest address if @code{STACK_GROWS_DOWNWARD} is defined, and\n\ +the highest address if it is not defined). You can use a different order\n\ +for a machine if doing so is more convenient or required for\n\ +compatibility reasons. Except in cases where required by standard\n\ +or by a debugger, there is no reason why the stack layout used by GCC\n\ +need agree with that used by other compilers for a machine.", void, (FILE *file, HOST_WIDE_INT size), default_function_pro_epilogue) /* Output the assembler code for end of prologue. */ DEFHOOK (function_end_prologue, - "", + "If defined, a function that outputs assembler code at the end of a\n\ +prologue. This should be used when the function prologue is being\n\ +emitted as RTL, and you have some extra assembler that needs to be\n\ +emitted. @xref{prologue instruction pattern}.", void, (FILE *file), no_asm_to_stream) /* Output the assembler code for start of epilogue. */ DEFHOOK (function_begin_epilogue, - "", + "If defined, a function that outputs assembler code at the start of an\n\ +epilogue. This should be used when the function epilogue is being\n\ +emitted as RTL, and you have some extra assembler that needs to be\n\ +emitted. @xref{epilogue instruction pattern}.", void, (FILE *file), no_asm_to_stream) /* Output the assembler code for function exit. */ DEFHOOK (function_epilogue, - "", + "If defined, a function that outputs the assembler code for exit from a\n\ +function. The epilogue is responsible for restoring the saved\n\ +registers and stack pointer to their values when the function was\n\ +called, and returning control to the caller. This macro takes the\n\ +same arguments as the macro @code{TARGET_ASM_FUNCTION_PROLOGUE}, and the\n\ +registers to restore are determined from @code{regs_ever_live} and\n\ +@code{CALL_USED_REGISTERS} in the same way.\n\ +\n\ +On some machines, there is a single instruction that does all the work\n\ +of returning from the function. On these machines, give that\n\ +instruction the name @samp{return} and do not define the macro\n\ +@code{TARGET_ASM_FUNCTION_EPILOGUE} at all.\n\ +\n\ +Do not define a pattern named @samp{return} if you want the\n\ +@code{TARGET_ASM_FUNCTION_EPILOGUE} to be used. If you want the target\n\ +switches to control whether return instructions or epilogues are used,\n\ +define a @samp{return} pattern with a validity condition that tests the\n\ +target switches appropriately. If the @samp{return} pattern's validity\n\ +condition is false, epilogues will be used.\n\ +\n\ +On machines where functions may or may not have frame-pointers, the\n\ +function exit code must vary accordingly. Sometimes the code for these\n\ +two cases is completely different. To determine whether a frame pointer\n\ +is wanted, the macro can refer to the variable\n\ +@code{frame_pointer_needed}. The variable's value will be 1 when compiling\n\ +a function that needs a frame pointer.\n\ +\n\ +Normally, @code{TARGET_ASM_FUNCTION_PROLOGUE} and\n\ +@code{TARGET_ASM_FUNCTION_EPILOGUE} must treat leaf functions specially.\n\ +The C variable @code{current_function_is_leaf} is nonzero for such a\n\ +function. @xref{Leaf Functions}.\n\ +\n\ +On some machines, some functions pop their arguments on exit while\n\ +others leave that for the caller to do. For example, the 68020 when\n\ +given @option{-mrtd} pops arguments in functions that take a fixed\n\ +number of arguments.\n\ +\n\ +@findex pops_args\n\ +@findex crtl->args.pops_args\n\ +Your definition of the macro @code{RETURN_POPS_ARGS} decides which\n\ +functions pop their own arguments. @code{TARGET_ASM_FUNCTION_EPILOGUE}\n\ +needs to know what was decided. The number of bytes of the current\n\ +function's arguments that this function should pop is available in\n\ +@code{crtl->args.pops_args}. @xref{Scalar Return}.", void, (FILE *file, HOST_WIDE_INT size), default_function_pro_epilogue) /* Initialize target-specific sections. */ DEFHOOK (init_sections, - "", + "Define this hook if you need to do something special to set up the\n\ +@file{varasm.c} sections, or if your target has some special sections\n\ +of its own that you need to create.\n\ +\n\ +GCC calls this hook after processing the command line, but before writing\n\ +any assembly code, and before calling any of the section-returning hooks\n\ +described below.", void, (void), hook_void_void) @@ -223,7 +405,11 @@ DEFHOOK which this section is associated. */ DEFHOOK (named_section, - "", + "Output assembly directives to switch to section @var{name}. The section\n\ +should have attributes as specified by @var{flags}, which is a bit mask\n\ +of the @code{SECTION_*} flags defined in @file{output.h}. If @var{decl}\n\ +is non-NULL, it is the @code{VAR_DECL} or @code{FUNCTION_DECL} with which\n\ +this section is associated.", void, (const char *name, unsigned int flags, tree decl), default_no_named_section) @@ -236,7 +422,13 @@ DEFHOOK Return NULL if function should go to default text section. */ DEFHOOK (function_section, - "", + "Return preferred text (sub)section for function @var{decl}.\n\ +Main purpose of this function is to separate cold, normal and hot\n\ +functions. @var{startup} is true when function is known to be used only\n\ +at startup (from static constructors or it is @code{main()}).\n\ +@var{exit} is true when function is known to be used only at exit\n\ +(from static destructors).\n\ +Return NULL if function should go to default text section.", section *, (tree decl, enum node_frequency freq, bool startup, bool exit), default_function_section) @@ -257,7 +449,15 @@ DEFHOOK local relocations should be placed in a read-write section. */ DEFHOOK (reloc_rw_mask, - "", + "Return a mask describing how relocations should be treated when\n\ +selecting sections. Bit 1 should be set if global relocations\n\ +should be placed in a read-write section; bit 0 should be set if\n\ +local relocations should be placed in a read-write section.\n\ +\n\ +The default version of this function returns 3 when @option{-fpic}\n\ +is in effect, and 0 otherwise. The hook is typically redefined\n\ +when the target cannot support (some kinds of) dynamic relocations\n\ +in read-only sections even in executables.", int, (void), default_reloc_rw_mask) @@ -267,7 +467,17 @@ DEFHOOK ALIGN is the required alignment of the data. */ DEFHOOK (select_section, - "", + "Return the section into which @var{exp} should be placed. You can\n\ +assume that @var{exp} is either a @code{VAR_DECL} node or a constant of\n\ +some sort. @var{reloc} indicates whether the initial value of @var{exp}\n\ +requires link-time relocations. Bit 0 is set when variable contains\n\ +local relocations only, while bit 1 is set for global relocations.\n\ +@var{align} is the constant alignment in bits.\n\ +\n\ +The default version of this function takes care of putting read-only\n\ +variables in @code{readonly_data_section}.\n\ +\n\ +See also @var{USE_SELECT_SECTION_FOR_FUNCTIONS}.", section *, (tree exp, int reloc, unsigned HOST_WIDE_INT align), default_select_section) @@ -275,7 +485,15 @@ DEFHOOK alignment in bits. */ DEFHOOK (select_rtx_section, - "", + "Return the section into which a constant @var{x}, of mode @var{mode},\n\ +should be placed. You can assume that @var{x} is some kind of\n\ +constant in RTL@. The argument @var{mode} is redundant except in the\n\ +case of a @code{const_int} rtx. @var{align} is the constant alignment\n\ +in bits.\n\ +\n\ +The default version of this function takes care of putting symbolic\n\ +constants in @code{flag_pic} mode in @code{data_section} and everything\n\ +else in @code{readonly_data_section}.", section *, (enum machine_mode mode, rtx x, unsigned HOST_WIDE_INT align), default_select_rtx_section) @@ -283,14 +501,27 @@ DEFHOOK for SELECT_SECTION. */ DEFHOOK (unique_section, - "", + "Build up a unique section name, expressed as a @code{STRING_CST} node,\n\ +and assign it to @samp{DECL_SECTION_NAME (@var{decl})}.\n\ +As with @code{TARGET_ASM_SELECT_SECTION}, @var{reloc} indicates whether\n\ +the initial value of @var{exp} requires link-time relocations.\n\ +\n\ +The default version of this function appends the symbol name to the\n\ +ELF section name that would normally be used for the symbol. For\n\ +example, the function @code{foo} would be placed in @code{.text.foo}.\n\ +Whatever the actual target object format, this is often good enough.", void, (tree decl, int reloc), default_unique_section) /* Return the readonly data section associated with function DECL. */ DEFHOOK (function_rodata_section, - "", + "Return the readonly data section associated with\n\ +@samp{DECL_SECTION_NAME (@var{decl})}.\n\ +The default version of this function selects @code{.gnu.linkonce.r.name} if\n\ +the function's section is @code{.gnu.linkonce.t.name}, @code{.rodata.name}\n\ +if function is in @code{.text.name}, and the normal readonly-data section\n\ +otherwise.", section *, (tree decl), default_function_rodata_section) @@ -313,13 +544,25 @@ DEFHOOK /* Output a constructor for a symbol with a given priority. */ DEFHOOK (constructor, - "", + "If defined, a function that outputs assembler code to arrange to call\n\ +the function referenced by @var{symbol} at initialization time.\n\ +\n\ +Assume that @var{symbol} is a @code{SYMBOL_REF} for a function taking\n\ +no arguments and with no return value. If the target supports initialization\n\ +priorities, @var{priority} is a value between 0 and @code{MAX_INIT_PRIORITY};\n\ +otherwise it must be @code{DEFAULT_INIT_PRIORITY}.\n\ +\n\ +If this macro is not defined by the target, a suitable default will\n\ +be chosen if (1) the target supports arbitrary section names, (2) the\n\ +target defines @code{CTORS_SECTION_ASM_OP}, or (3) @code{USE_COLLECT2}\n\ +is not defined.", void, (rtx symbol, int priority), NULL) /* Output a destructor for a symbol with a given priority. */ DEFHOOK (destructor, - "", + "This is like @code{TARGET_ASM_CONSTRUCTOR} but used for termination\n\ +functions rather than initialization functions.", void, (rtx symbol, int priority), NULL) /* Output the assembler code for a thunk function. THUNK_DECL is the @@ -329,7 +572,45 @@ DEFHOOK *(*this + vcall_offset) should be added to THIS. */ DEFHOOK (output_mi_thunk, - "", + "A function that outputs the assembler code for a thunk\n\ +function, used to implement C++ virtual function calls with multiple\n\ +inheritance. The thunk acts as a wrapper around a virtual function,\n\ +adjusting the implicit object parameter before handing control off to\n\ +the real function.\n\ +\n\ +First, emit code to add the integer @var{delta} to the location that\n\ +contains the incoming first argument. Assume that this argument\n\ +contains a pointer, and is the one used to pass the @code{this} pointer\n\ +in C++. This is the incoming argument @emph{before} the function prologue,\n\ +e.g.@: @samp{%o0} on a sparc. The addition must preserve the values of\n\ +all other incoming arguments.\n\ +\n\ +Then, if @var{vcall_offset} is nonzero, an additional adjustment should be\n\ +made after adding @code{delta}. In particular, if @var{p} is the\n\ +adjusted pointer, the following adjustment should be made:\n\ +\n\ +@smallexample\n\ +p += (*((ptrdiff_t **)p))[vcall_offset/sizeof(ptrdiff_t)]\n\ +@end smallexample\n\ +\n\ +After the additions, emit code to jump to @var{function}, which is a\n\ +@code{FUNCTION_DECL}. This is a direct pure jump, not a call, and does\n\ +not touch the return address. Hence returning from @var{FUNCTION} will\n\ +return to whoever called the current @samp{thunk}.\n\ +\n\ +The effect must be as if @var{function} had been called directly with\n\ +the adjusted first argument. This macro is responsible for emitting all\n\ +of the code for a thunk function; @code{TARGET_ASM_FUNCTION_PROLOGUE}\n\ +and @code{TARGET_ASM_FUNCTION_EPILOGUE} are not invoked.\n\ +\n\ +The @var{thunk_fndecl} is redundant. (@var{delta} and @var{function}\n\ +have already been extracted from it.) It might possibly be useful on\n\ +some targets, but probably not.\n\ +\n\ +If you do not define this macro, the target-independent code in the C++\n\ +front end will generate a less efficient heavyweight thunk that calls\n\ +@var{function} instead of jumping to it. The generic approach does\n\ +not support varargs.", void, (FILE *file, tree thunk_fndecl, HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset, tree function), NULL) @@ -342,7 +623,11 @@ DEFHOOK text to the output file. */ DEFHOOK (can_output_mi_thunk, - "", + "A function that returns true if TARGET_ASM_OUTPUT_MI_THUNK would be able\n\ +to output the assembler code for the thunk function specified by the\n\ +arguments it is passed, and false otherwise. In the latter case, the\n\ +generic approach will be used by the C++ front end, with the limitations\n\ +previously exposed.", bool, (const_tree thunk_fndecl, HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset, const_tree function), hook_bool_const_tree_hwi_hwi_const_tree_false) @@ -351,14 +636,20 @@ DEFHOOK translation unit. */ DEFHOOK (file_start, - "", + "Output to @code{asm_out_file} any text which the assembler expects to\n\ +find at the beginning of a file. The default behavior is controlled\n\ +by two flags, documented below. Unless your target's assembler is\n\ +quite unusual, if you override the default, you should call\n\ +@code{default_file_start} at some point in your target hook. This\n\ +lets other target files rely on these variables.", void, (void), default_file_start) /* Output any boilerplate text needed at the end of a translation unit. */ DEFHOOK (file_end, - "", + "Output to @code{asm_out_file} any text which the assembler expects\n\ +to find at the end of a file. The default is to output nothing.", void, (void), hook_void_void) @@ -366,7 +657,9 @@ DEFHOOK LTO output stream. */ DEFHOOK (lto_start, - "", + "Output to @code{asm_out_file} any text which the assembler expects\n\ +to find at the start of an LTO section. The default is to output\n\ +nothing.", void, (void), hook_void_void) @@ -374,7 +667,9 @@ DEFHOOK LTO output stream. */ DEFHOOK (lto_end, - "", + "Output to @code{asm_out_file} any text which the assembler expects\n\ +to find at the end of an LTO section. The default is to output\n\ +nothing.", void, (void), hook_void_void) @@ -382,7 +677,11 @@ DEFHOOK translation unit before debug and unwind info is emitted. */ DEFHOOK (code_end, - "", + "Output to @code{asm_out_file} any text which is needed before emitting\n\ +unwind info and debug info at the end of a file. Some targets emit\n\ +here PIC setup thunks that cannot be emitted at the end of file,\n\ +because they couldn't have unwind info then. The default is to output\n\ +nothing.", void, (void), hook_void_void) @@ -390,7 +689,9 @@ DEFHOOK external. */ DEFHOOK (external_libcall, - "", + "This target hook is a function to output to @var{asm_out_file} an assembler\n\ +pseudo-op to declare a library function name external. The name of the\n\ +library function is given by @var{symref}, which is a @code{symbol_ref}.", void, (rtx symref), default_external_libcall) @@ -398,14 +699,58 @@ DEFHOOK linker to not dead code strip this symbol. */ DEFHOOK (mark_decl_preserved, - "", + "This target hook is a function to output to @var{asm_out_file} an assembler\n\ +directive to annotate @var{symbol} as used. The Darwin target uses the\n\ +.no_dead_code_strip directive.", void, (const char *symbol), hook_void_constcharptr) /* Output a record of the command line switches that have been passed. */ DEFHOOK (record_gcc_switches, - "", + "Provides the target with the ability to record the gcc command line\n\ +switches that have been passed to the compiler, and options that are\n\ +enabled. The @var{type} argument specifies what is being recorded.\n\ +It can take the following values:\n\ +\n\ +@table @gcctabopt\n\ +@item SWITCH_TYPE_PASSED\n\ +@var{text} is a command line switch that has been set by the user.\n\ +\n\ +@item SWITCH_TYPE_ENABLED\n\ +@var{text} is an option which has been enabled. This might be as a\n\ +direct result of a command line switch, or because it is enabled by\n\ +default or because it has been enabled as a side effect of a different\n\ +command line switch. For example, the @option{-O2} switch enables\n\ +various different individual optimization passes.\n\ +\n\ +@item SWITCH_TYPE_DESCRIPTIVE\n\ +@var{text} is either NULL or some descriptive text which should be\n\ +ignored. If @var{text} is NULL then it is being used to warn the\n\ +target hook that either recording is starting or ending. The first\n\ +time @var{type} is SWITCH_TYPE_DESCRIPTIVE and @var{text} is NULL, the\n\ +warning is for start up and the second time the warning is for\n\ +wind down. This feature is to allow the target hook to make any\n\ +necessary preparations before it starts to record switches and to\n\ +perform any necessary tidying up after it has finished recording\n\ +switches.\n\ +\n\ +@item SWITCH_TYPE_LINE_START\n\ +This option can be ignored by this target hook.\n\ +\n\ +@item SWITCH_TYPE_LINE_END\n\ +This option can be ignored by this target hook.\n\ +@end table\n\ +\n\ +The hook's return value must be zero. Other return values may be\n\ +supported in the future.\n\ +\n\ +By default this hook is set to NULL, but an example implementation is\n\ +provided for ELF based targets. Called @var{elf_record_gcc_switches},\n\ +it records the switches as ASCII text inside a new, string mergeable\n\ +section in the assembler output file. The name of the new section is\n\ +provided by the @code{TARGET_ASM_RECORD_GCC_SWITCHES_SECTION} target\n\ +hook.", int, (print_switch_type type, const char *text), NULL) @@ -415,13 +760,23 @@ DEFHOOK this information. */ DEFHOOKPOD (record_gcc_switches_section, - "", + "This is the name of the section that will be created by the example\n\ +ELF implementation of the @code{TARGET_ASM_RECORD_GCC_SWITCHES} target\n\ +hook.", const char *, ".GCC.command.line") /* Output the definition of a section anchor. */ DEFHOOK (output_anchor, - "", + "Write the assembly code to define section anchor @var{x}, which is a\n\ +@code{SYMBOL_REF} for which @samp{SYMBOL_REF_ANCHOR_P (@var{x})} is true.\n\ +The hook is called with the assembly output position set to the beginning\n\ +of @code{SYMBOL_REF_BLOCK (@var{x})}.\n\ +\n\ +If @code{ASM_OUTPUT_DEF} is available, the hook's default definition uses\n\ +it to define the symbol as @samp{. + SYMBOL_REF_BLOCK_OFFSET (@var{x})}.\n\ +If @code{ASM_OUTPUT_DEF} is not available, the hook's default definition\n\ +is @code{NULL}, which disables the use of section anchors altogether.", void, (rtx x), default_asm_output_anchor) @@ -437,21 +792,39 @@ DEFHOOK /* Output a DTP-relative reference to a TLS symbol. */ DEFHOOK (output_dwarf_dtprel, - "", + "If defined, this target hook is a function which outputs a DTP-relative\n\ +reference to the given TLS symbol of the specified size.", void, (FILE *file, int size, rtx x), NULL) /* Some target machines need to postscan each insn after it is output. */ DEFHOOK (final_postscan_insn, - "", + "If defined, this target hook is a function which is executed just after the\n\ +output of assembler code for @var{insn}, to change the mode of the assembler\n\ +if necessary.\n\ +\n\ +Here the argument @var{opvec} is the vector containing the operands\n\ +extracted from @var{insn}, and @var{noperands} is the number of\n\ +elements of the vector which contain meaningful data for this insn.\n\ +The contents of this vector are what was used to convert the insn\n\ +template into assembler code, so you can change the assembler mode\n\ +by checking the contents of the vector.", void, (FILE *file, rtx insn, rtx *opvec, int noperands), NULL) /* Emit the trampoline template. This hook may be NULL. */ DEFHOOK (trampoline_template, - "", + "This hook is called by @code{assemble_trampoline_template} to output,\n\ +on the stream @var{f}, assembler code for a block of data that contains\n\ +the constant parts of a trampoline. This code should not include a\n\ +label---the label is taken care of automatically.\n\ +\n\ +If you do not define this hook, it means no template is needed\n\ +for the target. Do not define this hook on systems where the block move\n\ +code to copy the trampoline into place would be larger than the code\n\ +to generate it on the spot.", void, (FILE *f), NULL) @@ -468,7 +841,15 @@ DEFHOOK DEFHOOK (output_addr_const_extra, - "", + "A target hook to recognize @var{rtx} patterns that @code{output_addr_const}\n\ +can't deal with, and output assembly code to @var{file} corresponding to\n\ +the pattern @var{x}. This may be used to allow machine-dependent\n\ +@code{UNSPEC}s to appear within constants.\n\ +\n\ +If target hook fails to recognize a pattern, it must return @code{false},\n\ +so that a standard error message is printed. If it prints an error message\n\ +itself, by calling, for example, @code{output_operand_lossage}, it may just\n\ +return @code{true}.", bool, (FILE *file, rtx x), hook_bool_FILEptr_rtx_false) @@ -531,13 +912,28 @@ HOOK_VECTOR (TARGET_SCHED, sched) the dependence LINK. The default is to make no adjustment. */ DEFHOOK (adjust_cost, - "", + "This function corrects the value of @var{cost} based on the\n\ +relationship between @var{insn} and @var{dep_insn} through the\n\ +dependence @var{link}. It should return the new value. The default\n\ +is to make no adjustment to @var{cost}. This can be used for example\n\ +to specify to the scheduler using the traditional pipeline description\n\ +that an output- or anti-dependence does not incur the same cost as a\n\ +data-dependence. If the scheduler using the automaton based pipeline\n\ +description, the cost of anti-dependence is zero and the cost of\n\ +output-dependence is maximum of one and the difference of latency\n\ +times of the first and the second insns. If these values are not\n\ +acceptable, you could use the hook to modify them too. See also\n\ +@pxref{Processor pipeline description}.", int, (rtx insn, rtx link, rtx dep_insn, int cost), NULL) /* Adjust the priority of an insn as you see fit. Returns the new priority. */ DEFHOOK (adjust_priority, - "", + "This hook adjusts the integer scheduling priority @var{priority} of\n\ +@var{insn}. It should return the new priority. Increase the priority to\n\ +execute @var{insn} earlier, reduce the priority to execute @var{insn}\n\ +later. Do not define this hook if you do not need to adjust the\n\ +scheduling priorities of insns.", int, (rtx insn, int priority), NULL) /* Function which returns the maximum number of insns that can be @@ -545,50 +941,104 @@ DEFHOOK over an entire compilation. The default is 1. */ DEFHOOK (issue_rate, - "", + "This hook returns the maximum number of instructions that can ever\n\ +issue at the same time on the target machine. The default is one.\n\ +Although the insn scheduler can define itself the possibility of issue\n\ +an insn on the same cycle, the value can serve as an additional\n\ +constraint to issue insns on the same simulated processor cycle (see\n\ +hooks @samp{TARGET_SCHED_REORDER} and @samp{TARGET_SCHED_REORDER2}).\n\ +This value must be constant over the entire compilation. If you need\n\ +it to vary depending on what the instructions are, you must use\n\ +@samp{TARGET_SCHED_VARIABLE_ISSUE}.", int, (void), NULL) /* Calculate how much this insn affects how many more insns we can emit this cycle. Default is they all cost the same. */ DEFHOOK (variable_issue, - "", + "This hook is executed by the scheduler after it has scheduled an insn\n\ +from the ready list. It should return the number of insns which can\n\ +still be issued in the current cycle. The default is\n\ +@samp{@w{@var{more} - 1}} for insns other than @code{CLOBBER} and\n\ +@code{USE}, which normally are not counted against the issue rate.\n\ +You should define this hook if some insns take more machine resources\n\ +than others, so that fewer insns can follow them in the same cycle.\n\ +@var{file} is either a null pointer, or a stdio stream to write any\n\ +debug output to. @var{verbose} is the verbose level provided by\n\ +@option{-fsched-verbose-@var{n}}. @var{insn} is the instruction that\n\ +was scheduled.", int, (FILE *file, int verbose, rtx insn, int more), NULL) /* Initialize machine-dependent scheduling code. */ DEFHOOK (init, - "", + "This hook is executed by the scheduler at the beginning of each block of\n\ +instructions that are to be scheduled. @var{file} is either a null\n\ +pointer, or a stdio stream to write any debug output to. @var{verbose}\n\ +is the verbose level provided by @option{-fsched-verbose-@var{n}}.\n\ +@var{max_ready} is the maximum number of insns in the current scheduling\n\ +region that can be live at the same time. This can be used to allocate\n\ +scratch space if it is needed, e.g.@: by @samp{TARGET_SCHED_REORDER}.", void, (FILE *file, int verbose, int max_ready), NULL) /* Finalize machine-dependent scheduling code. */ DEFHOOK (finish, - "", + "This hook is executed by the scheduler at the end of each block of\n\ +instructions that are to be scheduled. It can be used to perform\n\ +cleanup of any actions done by the other scheduling hooks. @var{file}\n\ +is either a null pointer, or a stdio stream to write any debug output\n\ +to. @var{verbose} is the verbose level provided by\n\ +@option{-fsched-verbose-@var{n}}.", void, (FILE *file, int verbose), NULL) /* Initialize machine-dependent function wide scheduling code. */ DEFHOOK (init_global, - "", + "This hook is executed by the scheduler after function level initializations.\n\ +@var{file} is either a null pointer, or a stdio stream to write any debug output to.\n\ +@var{verbose} is the verbose level provided by @option{-fsched-verbose-@var{n}}.\n\ +@var{old_max_uid} is the maximum insn uid when scheduling begins.", void, (FILE *file, int verbose, int old_max_uid), NULL) /* Finalize machine-dependent function wide scheduling code. */ DEFHOOK (finish_global, - "", + "This is the cleanup hook corresponding to @code{TARGET_SCHED_INIT_GLOBAL}.\n\ +@var{file} is either a null pointer, or a stdio stream to write any debug output to.\n\ +@var{verbose} is the verbose level provided by @option{-fsched-verbose-@var{n}}.", void, (FILE *file, int verbose), NULL) /* Reorder insns in a machine-dependent fashion, in two different places. Default does nothing. */ DEFHOOK (reorder, - "", + "This hook is executed by the scheduler after it has scheduled the ready\n\ +list, to allow the machine description to reorder it (for example to\n\ +combine two small instructions together on @samp{VLIW} machines).\n\ +@var{file} is either a null pointer, or a stdio stream to write any\n\ +debug output to. @var{verbose} is the verbose level provided by\n\ +@option{-fsched-verbose-@var{n}}. @var{ready} is a pointer to the ready\n\ +list of instructions that are ready to be scheduled. @var{n_readyp} is\n\ +a pointer to the number of elements in the ready list. The scheduler\n\ +reads the ready list in reverse order, starting with\n\ +@var{ready}[@var{*n_readyp} @minus{} 1] and going to @var{ready}[0]. @var{clock}\n\ +is the timer tick of the scheduler. You may modify the ready list and\n\ +the number of ready insns. The return value is the number of insns that\n\ +can issue this cycle; normally this is just @code{issue_rate}. See also\n\ +@samp{TARGET_SCHED_REORDER2}.", int, (FILE *file, int verbose, rtx *ready, int *n_readyp, int clock), NULL) DEFHOOK (reorder2, - "", + "Like @samp{TARGET_SCHED_REORDER}, but called at a different time. That\n\ +function is called whenever the scheduler starts a new cycle. This one\n\ +is called once per iteration over a cycle, immediately after\n\ +@samp{TARGET_SCHED_VARIABLE_ISSUE}; it can reorder the ready list and\n\ +return the number of insns to be scheduled in the same cycle. Defining\n\ +this hook can be useful if there are frequent situations where\n\ +scheduling one insn causes other insns to become ready in the same\n\ +cycle. These other insns can then be taken into account properly.", int, (FILE *file, int verbose, rtx *ready, int *n_readyp, int clock), NULL) /* The following member value is a pointer to a function called @@ -596,7 +1046,13 @@ DEFHOOK by two parameter values (head and tail correspondingly). */ DEFHOOK (dependencies_evaluation_hook, - "", + "This hook is called after evaluation forward dependencies of insns in\n\ +chain given by two parameter values (@var{head} and @var{tail}\n\ +correspondingly) but before insns scheduling of the insn chain. For\n\ +example, it can be used for better insn classification if it requires\n\ +analysis of dependencies. This hook can use backward and forward\n\ +dependencies of the insn scheduler because they are already\n\ +calculated.", void, (rtx head, rtx tail), NULL) /* The values of the following four members are pointers to functions @@ -611,22 +1067,31 @@ DEFHOOK DEFHOOK (init_dfa_pre_cycle_insn, - "", + "The hook can be used to initialize data used by the previous hook.", void, (void), NULL) DEFHOOK (dfa_pre_cycle_insn, - "", + "The hook returns an RTL insn. The automaton state used in the\n\ +pipeline hazard recognizer is changed as if the insn were scheduled\n\ +when the new simulated processor cycle starts. Usage of the hook may\n\ +simplify the automaton pipeline description for some @acronym{VLIW}\n\ +processors. If the hook is defined, it is used only for the automaton\n\ +based pipeline description. The default is not to change the state\n\ +when the new simulated processor cycle starts.", rtx, (void), NULL) DEFHOOK (init_dfa_post_cycle_insn, - "", + "The hook is analogous to @samp{TARGET_SCHED_INIT_DFA_PRE_CYCLE_INSN} but\n\ +used to initialize data used by the previous hook.", void, (void), NULL) DEFHOOK (dfa_post_cycle_insn, - "", + "The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used\n\ +to changed the state as if the insn were scheduled when the new\n\ +simulated processor cycle finishes.", rtx, (void), NULL) /* The values of the following two members are pointers to @@ -636,12 +1101,18 @@ DEFHOOK DEFHOOK (dfa_pre_advance_cycle, - "", + "The hook to notify target that the current simulated cycle is about to finish.\n\ +The hook is analogous to @samp{TARGET_SCHED_DFA_PRE_CYCLE_INSN} but used\n\ +to change the state in more complicated situations - e.g., when advancing\n\ +state on a single insn is not enough.", void, (void), NULL) DEFHOOK (dfa_post_advance_cycle, - "", + "The hook to notify target that new simulated cycle has just started.\n\ +The hook is analogous to @samp{TARGET_SCHED_DFA_POST_CYCLE_INSN} but used\n\ +to change the state in more complicated situations - e.g., when advancing\n\ +state on a single insn is not enough.", void, (void), NULL) /* The following member value is a pointer to a function returning value @@ -653,7 +1124,32 @@ DEFHOOK insns on the same cycle. */ DEFHOOK (first_cycle_multipass_dfa_lookahead, - "", + "This hook controls better choosing an insn from the ready insn queue\n\ +for the @acronym{DFA}-based insn scheduler. Usually the scheduler\n\ +chooses the first insn from the queue. If the hook returns a positive\n\ +value, an additional scheduler code tries all permutations of\n\ +@samp{TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD ()}\n\ +subsequent ready insns to choose an insn whose issue will result in\n\ +maximal number of issued insns on the same cycle. For the\n\ +@acronym{VLIW} processor, the code could actually solve the problem of\n\ +packing simple insns into the @acronym{VLIW} insn. Of course, if the\n\ +rules of @acronym{VLIW} packing are described in the automaton.\n\ +\n\ +This code also could be used for superscalar @acronym{RISC}\n\ +processors. Let us consider a superscalar @acronym{RISC} processor\n\ +with 3 pipelines. Some insns can be executed in pipelines @var{A} or\n\ +@var{B}, some insns can be executed only in pipelines @var{B} or\n\ +@var{C}, and one insn can be executed in pipeline @var{B}. The\n\ +processor may issue the 1st insn into @var{A} and the 2nd one into\n\ +@var{B}. In this case, the 3rd insn will wait for freeing @var{B}\n\ +until the next cycle. If the scheduler issues the 3rd insn the first,\n\ +the processor could issue all 3 insns per cycle.\n\ +\n\ +Actually this code demonstrates advantages of the automaton based\n\ +pipeline hazard recognizer. We try quickly and easy many insn\n\ +schedules to choose the best one.\n\ +\n\ +The default is no multipass scheduling.", int, (void), NULL) /* The following member value is pointer to a function controlling @@ -662,7 +1158,13 @@ DEFHOOK passed as the parameter, the insn will be not chosen to be issued. */ DEFHOOK (first_cycle_multipass_dfa_lookahead_guard, - "", + "\n\ +This hook controls what insns from the ready insn queue will be\n\ +considered for the multipass insn scheduling. If the hook returns\n\ +zero for @var{insn}, the insn will be not chosen to\n\ +be issued.\n\ +\n\ +The default is that any ready insns can be chosen to be issued.", int, (rtx insn), NULL) /* This hook prepares the target for a new round of multipass @@ -676,7 +1178,8 @@ DEFHOOK scheduling on current cycle. */ DEFHOOK (first_cycle_multipass_begin, - "", + "This hook prepares the target backend for a new round of multipass\n\ +scheduling.", void, (void *data, char *ready_try, int n_ready, bool first_cycle_insn_p), NULL) @@ -692,7 +1195,7 @@ DEFHOOK to a state before issuing INSN. */ DEFHOOK (first_cycle_multipass_issue, - "", + "This hook is called when multipass scheduling evaluates instruction INSN.", void, (void *data, char *ready_try, int n_ready, rtx insn, const void *prev_data), NULL) @@ -707,7 +1210,8 @@ DEFHOOK elements in READY_TRY to non-zero. */ DEFHOOK (first_cycle_multipass_backtrack, - "", + "This is called when multipass scheduling backtracks from evaluation of\n\ +an instruction.", void, (const void *data, char *ready_try, int n_ready), NULL) /* This hook notifies the target about the result of the concluded current @@ -720,7 +1224,8 @@ DEFHOOK usually after advancing the cycle count. */ DEFHOOK (first_cycle_multipass_end, - "", + "This hook notifies the target about the result of the concluded current\n\ +round of multipass scheduling.", void, (const void *data), NULL) /* This hook is called to initialize target-specific data for multipass @@ -730,7 +1235,7 @@ DEFHOOK described in DFA. */ DEFHOOK (first_cycle_multipass_init, - "", + "This hook initializes target-specific data used in multipass scheduling.", void, (void *data), NULL) /* This hook is called to finalize target-specific data for multipass @@ -740,7 +1245,7 @@ DEFHOOK described in DFA. */ DEFHOOK (first_cycle_multipass_fini, - "", + "This hook finalizes target-specific data used in multipass scheduling.", void, (void *data), NULL) /* The following member value is pointer to a function called by @@ -756,7 +1261,16 @@ DEFHOOK the previous insn has been issued and the current processor cycle. */ DEFHOOK (dfa_new_cycle, - "", + "This hook is called by the insn scheduler before issuing @var{insn}\n\ +on cycle @var{clock}. If the hook returns nonzero,\n\ +@var{insn} is not issued on this processor cycle. Instead,\n\ +the processor cycle is advanced. If *@var{sort_p}\n\ +is zero, the insn ready queue is not sorted on the new cycle\n\ +start as usually. @var{dump} and @var{verbose} specify the file and\n\ +verbosity level to use for debugging output.\n\ +@var{last_clock} and @var{clock} are, respectively, the\n\ +processor cycle on which the previous insn has been issued,\n\ +and the current processor cycle.", int, (FILE *dump, int verbose, rtx insn, int last_clock, int clock, int *sort_p), NULL) @@ -772,7 +1286,24 @@ DEFHOOK second insn (second parameter). */ DEFHOOK (is_costly_dependence, - "", + "This hook is used to define which dependences are considered costly by\n\ +the target, so costly that it is not advisable to schedule the insns that\n\ +are involved in the dependence too close to one another. The parameters\n\ +to this hook are as follows: The first parameter @var{_dep} is the dependence\n\ +being evaluated. The second parameter @var{cost} is the cost of the\n\ +dependence as estimated by the scheduler, and the third\n\ +parameter @var{distance} is the distance in cycles between the two insns.\n\ +The hook returns @code{true} if considering the distance between the two\n\ +insns the dependence between them is considered costly by the target,\n\ +and @code{false} otherwise.\n\ +\n\ +Defining this hook can be useful in multiple-issue out-of-order machines,\n\ +where (a) it's practically hopeless to predict the actual data/resource\n\ +delays, however: (b) there's a better chance to predict the actual grouping\n\ +that will be formed, and (c) correctly emulating the grouping can be very\n\ +important. In such targets one may want to allow issuing dependent insns\n\ +closer to one another---i.e., closer than the dependence distance; however,\n\ +not in cases of ``costly dependences'', which this hooks allows to define.", bool, (struct _dep *_dep, int cost, int distance), NULL) DEFHOOK_UNDOC @@ -787,7 +1318,9 @@ DEFHOOK_UNDOC that new instructions were emitted. */ DEFHOOK (h_i_d_extended, - "", + "This hook is called by the insn scheduler after emitting a new instruction to\n\ +the instruction stream. The hook notifies a target backend to extend its\n\ +per instruction data structures.", void, (void), NULL) /* Next 5 functions are for multi-point scheduling. */ @@ -795,31 +1328,33 @@ DEFHOOK /* Allocate memory for scheduler context. */ DEFHOOK (alloc_sched_context, - "", + "Return a pointer to a store large enough to hold target scheduling context.", void *, (void), NULL) /* Fills the context from the local machine scheduler context. */ DEFHOOK (init_sched_context, - "", + "Initialize store pointed to by @var{tc} to hold target scheduling context.\n\ +It @var{clean_p} is true then initialize @var{tc} as if scheduler is at the\n\ +beginning of the block. Otherwise, copy the current context into @var{tc}.", void, (void *tc, bool clean_p), NULL) /* Sets local machine scheduler context to a saved value. */ DEFHOOK (set_sched_context, - "", + "Copy target scheduling context pointed to by @var{tc} to the current context.", void, (void *tc), NULL) /* Clears a scheduler context so it becomes like after init. */ DEFHOOK (clear_sched_context, - "", + "Deallocate internal data in target scheduling context pointed to by @var{tc}.", void, (void *tc), NULL) /* Frees the scheduler context. */ DEFHOOK (free_sched_context, - "", + "Deallocate a store for target scheduling context pointed to by @var{tc}.", void, (void *tc), NULL) /* The following member value is a pointer to a function called @@ -834,7 +1369,14 @@ DEFHOOK generated one. */ DEFHOOK (speculate_insn, - "", + "This hook is called by the insn scheduler when @var{insn} has only\n\ +speculative dependencies and therefore can be scheduled speculatively.\n\ +The hook is used to check if the pattern of @var{insn} has a speculative\n\ +version and, in case of successful check, to generate that speculative\n\ +pattern. The hook should return 1, if the instruction has a speculative form,\n\ +or @minus{}1, if it doesn't. @var{request} describes the type of requested\n\ +speculation. If the return value equals 1 then @var{new_pat} is assigned\n\ +the generated speculative pattern.", int, (rtx insn, unsigned int dep_status, rtx *new_pat), NULL) /* The following member value is a pointer to a function called @@ -842,7 +1384,9 @@ DEFHOOK passed as the parameter needs a recovery block. */ DEFHOOK (needs_block_p, - "", + "This hook is called by the insn scheduler during generation of recovery code\n\ +for @var{insn}. It should return @code{true}, if the corresponding check\n\ +instruction should branch to recovery code, or @code{false} otherwise.", bool, (unsigned int dep_status), NULL) /* The following member value is a pointer to a function called @@ -854,7 +1398,14 @@ DEFHOOK is being performed. */ DEFHOOK (gen_spec_check, - "", + "This hook is called by the insn scheduler to generate a pattern for recovery\n\ +check instruction. If @var{mutate_p} is zero, then @var{insn} is a\n\ +speculative instruction for which the check should be generated.\n\ +@var{label} is either a label of a basic block, where recovery code should\n\ +be emitted, or a null pointer, when requested check doesn't branch to\n\ +recovery code (a simple check). If @var{mutate_p} is nonzero, then\n\ +a pattern for a branchy check corresponding to a simple check denoted by\n\ +@var{insn} should be generated. In this case @var{label} can't be null.", rtx, (rtx insn, rtx label, unsigned int ds), NULL) /* The following member value is a pointer to a function controlling @@ -865,7 +1416,16 @@ DEFHOOK that stand at the first position of the ready list. */ DEFHOOK (first_cycle_multipass_dfa_lookahead_guard_spec, - "", + "This hook is used as a workaround for\n\ +@samp{TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD} not being\n\ +called on the first instruction of the ready list. The hook is used to\n\ +discard speculative instructions that stand first in the ready list from\n\ +being scheduled on the current cycle. If the hook returns @code{false},\n\ +@var{insn} will not be chosen to be issued.\n\ +For non-speculative instructions,\n\ +the hook should always return @code{true}. For example, in the ia64 backend\n\ +the hook is used to cancel data speculative insns when the ALAT table\n\ +is nearly full.", bool, (const_rtx insn), NULL) /* The following member value is a pointer to a function that provides @@ -873,7 +1433,10 @@ DEFHOOK The parameter is a pointer to spec_info variable. */ DEFHOOK (set_sched_flags, - "", + "This hook is used by the insn scheduler to find out what features should be\n\ +enabled/used.\n\ +The structure *@var{spec_info} should be filled in by the target.\n\ +The structure describes speculation types that can be used in the scheduler.", void, (struct spec_info_def *spec_info), NULL) DEFHOOK_UNDOC @@ -898,7 +1461,12 @@ DEFHOOK_UNDOC to ddg variable. */ DEFHOOK (sms_res_mii, - "", + "This hook is called by the swing modulo scheduler to calculate a\n\ +resource-based lower bound which is based on the resources available in\n\ +the machine and the resources required by each instruction. The target\n\ +backend can use @var{g} to calculate such bound. A very simple lower\n\ +bound will be used in case this hook is not implemented: the total number\n\ +of instructions divided by the issue rate.", int, (struct ddg *g), NULL) /* The following member value is a function that initializes dispatch @@ -906,7 +1474,8 @@ DEFHOOK parameters. */ DEFHOOK (dispatch_do, -"", +"This hook is called by Haifa Scheduler. It performs the operation specified\n\ +in its second parameter.", void, (rtx insn, int x), hook_void_rtx_int) @@ -915,7 +1484,8 @@ hook_void_rtx_int) as the second parameter is true. */ DEFHOOK (dispatch, -"", +"This hook is called by Haifa Scheduler. It returns true if dispatch scheduling\n\ +is supported in hardware and the condition specified in the parameter is true.", bool, (rtx insn, int x), hook_bool_rtx_int_false) @@ -948,14 +1518,44 @@ HOOK_VECTOR (TARGET_VECTORIZE, vectorize) function. */ DEFHOOK (builtin_mask_for_load, - "", + "This hook should return the DECL of a function @var{f} that given an\n\ +address @var{addr} as an argument returns a mask @var{m} that can be\n\ +used to extract from two vectors the relevant data that resides in\n\ +@var{addr} in case @var{addr} is not properly aligned.\n\ +\n\ +The autovectorizer, when vectorizing a load operation from an address\n\ +@var{addr} that may be unaligned, will generate two vector loads from\n\ +the two aligned addresses around @var{addr}. It then generates a\n\ +@code{REALIGN_LOAD} operation to extract the relevant data from the\n\ +two loaded vectors. The first two arguments to @code{REALIGN_LOAD},\n\ +@var{v1} and @var{v2}, are the two vectors, each of size @var{VS}, and\n\ +the third argument, @var{OFF}, defines how the data will be extracted\n\ +from these two vectors: if @var{OFF} is 0, then the returned vector is\n\ +@var{v2}; otherwise, the returned vector is composed from the last\n\ +@var{VS}-@var{OFF} elements of @var{v1} concatenated to the first\n\ +@var{OFF} elements of @var{v2}.\n\ +\n\ +If this hook is defined, the autovectorizer will generate a call\n\ +to @var{f} (using the DECL tree that this hook returns) and will\n\ +use the return value of @var{f} as the argument @var{OFF} to\n\ +@code{REALIGN_LOAD}. Therefore, the mask @var{m} returned by @var{f}\n\ +should comply with the semantics expected by @code{REALIGN_LOAD}\n\ +described above.\n\ +If this hook is not defined, then @var{addr} will be used as\n\ +the argument @var{OFF} to @code{REALIGN_LOAD}, in which case the low\n\ +log2(@var{VS}) @minus{} 1 bits of @var{addr} will be considered.", tree, (void), NULL) /* Returns a code for builtin that realizes vectorized version of function, or NULL_TREE if not available. */ DEFHOOK (builtin_vectorized_function, - "", + "This hook should return the decl of a function that implements the\n\ +vectorized variant of the builtin function with builtin function code\n\ +@var{code} or @code{NULL_TREE} if such a function is not available.\n\ +The value of @var{fndecl} is the builtin function declaration. The\n\ +return type of the vectorized function shall be of vector type\n\ +@var{vec_type_out} and the argument types should be @var{vec_type_in}.", tree, (tree fndecl, tree vec_type_out, tree vec_type_in), default_builtin_vectorized_function) @@ -963,7 +1563,15 @@ DEFHOOK vector conversion, or NULL_TREE if not available. */ DEFHOOK (builtin_conversion, - "", + "This hook should return the DECL of a function that implements conversion of the\n\ +input vector of type @var{src_type} to type @var{dest_type}.\n\ +The value of @var{code} is one of the enumerators in @code{enum tree_code} and\n\ +specifies how the conversion is to be applied\n\ +(truncation, rounding, etc.).\n\ +\n\ +If this hook is defined, the autovectorizer will use the\n\ +@code{TARGET_VECTORIZE_BUILTIN_CONVERSION} target hook when vectorizing\n\ +conversion. Otherwise, it will return @code{NULL_TREE}.", tree, (unsigned code, tree dest_type, tree src_type), default_builtin_vectorized_conversion) @@ -972,7 +1580,9 @@ DEFHOOK on the data type and misalignment value. */ DEFHOOK (builtin_vectorization_cost, - "", + "Returns cost of different scalar or vector statements for vectorization cost model.\n\ +For vector memory operations the cost may depend on type (@var{vectype}) and\n\ +misalignment value (@var{misalign}).", int, (enum vect_cost_for_stmt type_of_cost, tree vectype, int misalign), default_builtin_vectorization_cost) @@ -980,7 +1590,7 @@ DEFHOOK iterations) for the given type. */ DEFHOOK (vector_alignment_reachable, - "", + "Return true if vector alignment is reachable (by peeling N iterations) for the given type.", bool, (const_tree type, bool is_packed), default_builtin_vector_alignment_reachable) @@ -988,7 +1598,7 @@ DEFHOOK A NULL indicates that all constants are valid permutations. */ DEFHOOK (vec_perm_const_ok, - "", + "Return true if a vector created for @code{vec_perm_const} is valid.", bool, (enum machine_mode, const unsigned char *sel), NULL) @@ -997,7 +1607,11 @@ DEFHOOK is true if the access is defined in a packed struct. */ DEFHOOK (support_vector_misalignment, - "", + "This hook should return true if the target supports misaligned vector\n\ +store/load of a specific factor denoted in the @var{misalignment}\n\ +parameter. The vector store/load should be of machine mode @var{mode} and\n\ +the elements in the vectors should be of type @var{type}. @var{is_packed}\n\ +parameter is true if the memory access is defined in a packed struct.", bool, (enum machine_mode mode, const_tree type, int misalignment, bool is_packed), default_builtin_support_vector_misalignment) @@ -1024,7 +1638,10 @@ DEFHOOK scalar mode. */ DEFHOOK (preferred_simd_mode, - "", + "This hook should return the preferred mode for vectorizing scalar\n\ +mode @var{mode}. The default is\n\ +equal to @code{word_mode}, because the vectorizer can do some\n\ +transformations even in absence of specialized @acronym{SIMD} hardware.", enum machine_mode, (enum machine_mode mode), default_preferred_simd_mode) @@ -1033,7 +1650,10 @@ DEFHOOK after processing the preferred one derived from preferred_simd_mode. */ DEFHOOK (autovectorize_vector_sizes, - "", + "This hook should return a mask of sizes that should be iterated over\n\ +after trying to autovectorize using the vector size derived from the\n\ +mode returned by @code{TARGET_VECTORIZE_PREFERRED_SIMD_MODE}.\n\ +The default is zero which means to not iterate over other vector sizes.", unsigned int, (void), default_autovectorize_vector_sizes) @@ -1041,7 +1661,11 @@ DEFHOOK /* Target builtin that implements vector gather operation. */ DEFHOOK (builtin_gather, - "", + "Target builtin that implements vector gather operation. @var{mem_vectype}\n\ +is the vector type of the load and @var{index_type} is scalar type of\n\ +the index, scaled by @var{scale}.\n\ +The default is @code{NULL_TREE} which means to not vectorize gather\n\ +loads.", tree, (const_tree mem_vectype, const_tree index_type, int scale), NULL) @@ -1110,7 +1734,13 @@ HOOK_VECTOR_END (vectorize) end of the code affected by an attribute or pragma. */ DEFHOOK (override_options_after_change, - "", + "This target function is similar to the hook @code{TARGET_OPTION_OVERRIDE}\n\ +but is called when the optimize level is changed via an attribute or\n\ +pragma or when it is reset at the end of the code affected by the\n\ +attribute or pragma. It is not called at the beginning of compilation\n\ +when @code{TARGET_OPTION_OVERRIDE} is called so if you want to perform these\n\ +actions then, you should have @code{TARGET_OPTION_OVERRIDE} call\n\ +@code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE}.", void, (void), hook_void_void) @@ -1123,35 +1753,65 @@ DEFHOOK_UNDOC /* Return machine mode for libgcc expanded cmp instructions. */ DEFHOOK (libgcc_cmp_return_mode, - "", + "This target hook should return the mode to be used for the return value\n\ +of compare instructions expanded to libgcc calls. If not defined\n\ +@code{word_mode} is returned which is the right choice for a majority of\n\ +targets.", enum machine_mode, (void), default_libgcc_cmp_return_mode) /* Return machine mode for libgcc expanded shift instructions. */ DEFHOOK (libgcc_shift_count_mode, - "", + "This target hook should return the mode to be used for the shift count operand\n\ +of shift instructions expanded to libgcc calls. If not defined\n\ +@code{word_mode} is returned which is the right choice for a majority of\n\ +targets.", enum machine_mode, (void), default_libgcc_shift_count_mode) /* Return machine mode to be used for _Unwind_Word type. */ DEFHOOK (unwind_word_mode, - "", + "Return machine mode to be used for @code{_Unwind_Word} type.\n\ +The default is to use @code{word_mode}.", enum machine_mode, (void), default_unwind_word_mode) /* Given two decls, merge their attributes and return the result. */ DEFHOOK (merge_decl_attributes, - "", + "Define this target hook if the merging of decl attributes needs special\n\ +handling. If defined, the result is a list of the combined\n\ +@code{DECL_ATTRIBUTES} of @var{olddecl} and @var{newdecl}.\n\ +@var{newdecl} is a duplicate declaration of @var{olddecl}. Examples of\n\ +when this is needed are when one attribute overrides another, or when an\n\ +attribute is nullified by a subsequent definition. This function may\n\ +call @code{merge_attributes} to handle machine-independent merging.\n\ +\n\ +@findex TARGET_DLLIMPORT_DECL_ATTRIBUTES\n\ +If the only target-specific handling you require is @samp{dllimport}\n\ +for Microsoft Windows targets, you should define the macro\n\ +@code{TARGET_DLLIMPORT_DECL_ATTRIBUTES} to @code{1}. The compiler\n\ +will then define a function called\n\ +@code{merge_dllimport_decl_attributes} which can then be defined as\n\ +the expansion of @code{TARGET_MERGE_DECL_ATTRIBUTES}. You can also\n\ +add @code{handle_dll_attribute} in the attribute table for your port\n\ +to perform initial processing of the @samp{dllimport} and\n\ +@samp{dllexport} attributes. This is done in @file{i386/cygwin.h} and\n\ +@file{i386/i386.c}, for example.", tree, (tree olddecl, tree newdecl), merge_decl_attributes) /* Given two types, merge their attributes and return the result. */ DEFHOOK (merge_type_attributes, - "", + "Define this target hook if the merging of type attributes needs special\n\ +handling. If defined, the result is a list of the combined\n\ +@code{TYPE_ATTRIBUTES} of @var{type1} and @var{type2}. It is assumed\n\ +that @code{comptypes} has already been called and returned 1. This\n\ +function may call @code{merge_attributes} to handle machine-independent\n\ +merging.", tree, (tree type1, tree type2), merge_type_attributes) @@ -1159,14 +1819,22 @@ DEFHOOK Ignored if NULL. */ DEFHOOKPOD (attribute_table, - "", + "If defined, this target hook points to an array of @samp{struct\n\ +attribute_spec} (defined in @file{tree.h}) specifying the machine\n\ +specific attributes for this target and some of the restrictions on the\n\ +entities to which these attributes are applied and the arguments they\n\ +take.", const struct attribute_spec *, NULL) /* Return true iff attribute NAME expects a plain identifier as its first argument. */ DEFHOOK (attribute_takes_identifier_p, - "", + "If defined, this target hook is a function which returns true if the\n\ +machine-specific attribute named @var{name} expects an identifier\n\ +given as its first argument to be passed on as a plain identifier, not\n\ +subjected to name lookup. If this is not defined, the default is\n\ +false for all machine-specific attributes.", bool, (const_tree name), hook_bool_const_tree_false) @@ -1175,21 +1843,35 @@ DEFHOOK (which causes a warning to be generated). */ DEFHOOK (comp_type_attributes, - "", + "If defined, this target hook is a function which returns zero if the attributes on\n\ +@var{type1} and @var{type2} are incompatible, one if they are compatible,\n\ +and two if they are nearly compatible (which causes a warning to be\n\ +generated). If this is not defined, machine-specific attributes are\n\ +supposed always to be compatible.", int, (const_tree type1, const_tree type2), hook_int_const_tree_const_tree_1) /* Assign default attributes to the newly defined TYPE. */ DEFHOOK (set_default_type_attributes, - "", + "If defined, this target hook is a function which assigns default attributes to\n\ +the newly defined @var{type}.", void, (tree type), hook_void_tree) /* Insert attributes on the newly created DECL. */ DEFHOOK (insert_attributes, - "", + "Define this target hook if you want to be able to add attributes to a decl\n\ +when it is being created. This is normally useful for back ends which\n\ +wish to implement a pragma by using the attributes which correspond to\n\ +the pragma's effect. The @var{node} argument is the decl which is being\n\ +created. The @var{attr_ptr} argument is a pointer to the attribute list\n\ +for this decl. The list itself should not be modified, since it may be\n\ +shared with other decls, but attributes may be chained on the head of\n\ +the list and @code{*@var{attr_ptr}} modified to point to the new\n\ +attributes, or a copy of the list may be made if further changes are\n\ +needed.", void, (tree node, tree *attr_ptr), hook_void_tree_treeptr) @@ -1197,7 +1879,11 @@ DEFHOOK can be inlined despite its machine attributes, false otherwise. */ DEFHOOK (function_attribute_inlinable_p, - "", + "@cindex inlining\n\ +This target hook returns @code{true} if it is ok to inline @var{fndecl}\n\ +into the current function, despite its having target-specific\n\ +attributes, @code{false} otherwise. By default, if a function has a\n\ +target specific attribute attached to it, it will not be inlined.", bool, (const_tree fndecl), hook_bool_const_tree_false) @@ -1205,7 +1891,31 @@ DEFHOOK Microsoft Visual C++ bitfield layout rules. */ DEFHOOK (ms_bitfield_layout_p, - "", + "This target hook returns @code{true} if bit-fields in the given\n\ +@var{record_type} are to be laid out following the rules of Microsoft\n\ +Visual C/C++, namely: (i) a bit-field won't share the same storage\n\ +unit with the previous bit-field if their underlying types have\n\ +different sizes, and the bit-field will be aligned to the highest\n\ +alignment of the underlying types of itself and of the previous\n\ +bit-field; (ii) a zero-sized bit-field will affect the alignment of\n\ +the whole enclosing structure, even if it is unnamed; except that\n\ +(iii) a zero-sized bit-field will be disregarded unless it follows\n\ +another bit-field of nonzero size. If this hook returns @code{true},\n\ +other macros that control bit-field layout are ignored.\n\ +\n\ +When a bit-field is inserted into a packed record, the whole size\n\ +of the underlying type is used by one or more same-size adjacent\n\ +bit-fields (that is, if its long:3, 32 bits is used in the record,\n\ +and any additional adjacent long bit-fields are packed into the same\n\ +chunk of 32 bits. However, if the size changes, a new field of that\n\ +size is allocated). In an unpacked record, this is the same as using\n\ +alignment, but not equivalent when packing.\n\ +\n\ +If both MS bit-fields and @samp{__attribute__((packed))} are used,\n\ +the latter will take precedence. If @samp{__attribute__((packed))} is\n\ +used on a single field when MS bit-fields are in use, it will take\n\ +precedence for that field, but the alignment of the rest of the structure\n\ +may affect its placement.", bool, (const_tree record_type), hook_bool_const_tree_false) @@ -1228,21 +1938,24 @@ DEFHOOK_UNDOC /* True if the target supports decimal floating point. */ DEFHOOK (decimal_float_supported_p, - "", + "Returns true if the target supports decimal floating point.", bool, (void), default_decimal_float_supported_p) /* True if the target supports fixed-point. */ DEFHOOK (fixed_point_supported_p, - "", + "Returns true if the target supports fixed-point arithmetic.", bool, (void), default_fixed_point_supported_p) /* Return true if anonymous bitfields affect structure alignment. */ DEFHOOK (align_anon_bitfield, - "", + "When @code{PCC_BITFIELD_TYPE_MATTERS} is true this hook will determine\n\ +whether unnamed bitfields affect the alignment of the containing\n\ +structure. The hook should return true if the structure should inherit\n\ +the alignment requirements of an unnamed bitfield's type.", bool, (void), hook_bool_void_false) @@ -1250,14 +1963,32 @@ DEFHOOK Return false if they should use the container type. */ DEFHOOK (narrow_volatile_bitfield, - "", + "This target hook should return @code{true} if accesses to volatile bitfields\n\ +should use the narrowest mode possible. It should return @code{false} if\n\ +these accesses should use the bitfield container type.\n\ +\n\ +The default is @code{!TARGET_STRICT_ALIGN}.", bool, (void), hook_bool_void_false) /* Set up target-specific built-in functions. */ DEFHOOK (init_builtins, - "", + "Define this hook if you have any machine-specific built-in functions\n\ +that need to be defined. It should be a function that performs the\n\ +necessary setup.\n\ +\n\ +Machine specific built-in functions can be useful to expand special machine\n\ +instructions that would otherwise not normally be generated because\n\ +they have no equivalent in the source language (for example, SIMD vector\n\ +instructions or prefetch instructions).\n\ +\n\ +To create a built-in function, call the function\n\ +@code{lang_hooks.builtin_function}\n\ +which is defined by the language front end. You can use any type nodes set\n\ +up by @code{build_common_tree_nodes};\n\ +only language front ends that use those two functions will call\n\ +@samp{TARGET_INIT_BUILTINS}.", void, (void), hook_void_void) @@ -1267,13 +1998,27 @@ DEFHOOK is outside of the range of valid target builtin function codes. */ DEFHOOK (builtin_decl, - "", + "Define this hook if you have any machine-specific built-in functions\n\ +that need to be defined. It should be a function that returns the\n\ +builtin function declaration for the builtin function code @var{code}.\n\ +If there is no such builtin and it cannot be initialized at this time\n\ +if @var{initialize_p} is true the function should return @code{NULL_TREE}.\n\ +If @var{code} is out of range the function should return\n\ +@code{error_mark_node}.", tree, (unsigned code, bool initialize_p), NULL) /* Expand a target-specific builtin. */ DEFHOOK (expand_builtin, - "", + "\n\ +Expand a call to a machine specific built-in function that was set up by\n\ +@samp{TARGET_INIT_BUILTINS}. @var{exp} is the expression for the\n\ +function call; the result should go to @var{target} if that is\n\ +convenient, and have mode @var{mode} if that is convenient.\n\ +@var{subtarget} may be used as the target for computing one of\n\ +@var{exp}'s operands. @var{ignore} is nonzero if the value is to be\n\ +ignored. This function should return the result of the call to the\n\ +built-in function.", rtx, (tree exp, rtx target, rtx subtarget, enum machine_mode mode, int ignore), default_expand_builtin) @@ -1285,14 +2030,28 @@ DEFHOOK has type VEC(tree,gc)*, but we don't want to include tree.h here. */ DEFHOOK (resolve_overloaded_builtin, - "", + "Select a replacement for a machine specific built-in function that\n\ +was set up by @samp{TARGET_INIT_BUILTINS}. This is done\n\ +@emph{before} regular type checking, and so allows the target to\n\ +implement a crude form of function overloading. @var{fndecl} is the\n\ +declaration of the built-in function. @var{arglist} is the list of\n\ +arguments passed to the built-in function. The result is a\n\ +complete expression that implements the operation, usually\n\ +another @code{CALL_EXPR}.\n\ +@var{arglist} really has type @samp{VEC(tree,gc)*}", tree, (unsigned int /*location_t*/ loc, tree fndecl, void *arglist), NULL) /* Fold a target-specific builtin to a tree valid for both GIMPLE and GENERIC. */ DEFHOOK (fold_builtin, - "", + "Fold a call to a machine specific built-in function that was set up by\n\ +@samp{TARGET_INIT_BUILTINS}. @var{fndecl} is the declaration of the\n\ +built-in function. @var{n_args} is the number of arguments passed to\n\ +the function; the arguments themselves are pointed to by @var{argp}.\n\ +The result is another tree, valid for both GIMPLE and GENERIC,\n\ +containing a simplified expression for the call's result. If\n\ +@var{ignore} is true the value will be ignored.", tree, (tree fndecl, int n_args, tree *argp, bool ignore), hook_tree_tree_int_treep_bool_null) @@ -1316,7 +2075,12 @@ was made to the GIMPLE stream.", and 0 if they are the same. */ DEFHOOK (compare_version_priority, - "", + "This hook is used to compare the target attributes in two functions to\n\ +determine which function's features get higher priority. This is used\n\ +during function multi-versioning to figure out the order in which two\n\ +versions must be dispatched. A function version with a higher priority\n\ +is checked for dispatching earlier. @var{decl1} and @var{decl2} are\n\ + the two function decls that will be compared.", int, (tree decl1, tree decl2), NULL) /* Target hook is used to generate the dispatcher logic to invoke the right @@ -1325,7 +2089,10 @@ DEFHOOK must be generated. */ DEFHOOK (generate_version_dispatcher_body, - "", + "This hook is used to generate the dispatcher logic to invoke the right\n\ +function version at run-time for a given set of function versions.\n\ +@var{arg} points to the callgraph node of the dispatcher function whose\n\ +body must be generated.", tree, (void *arg), NULL) /* Target hook is used to get the dispatcher function for a set of function @@ -1334,14 +2101,23 @@ DEFHOOK identical versions. */ DEFHOOK (get_function_versions_dispatcher, - "", + "This hook is used to get the dispatcher function for a set of function\n\ +versions. The dispatcher function is called to invoke the right function\n\ +version at run-time. @var{decl} is one version from a set of semantically\n\ +identical versions.", tree, (void *decl), NULL) /* Returns a code for a target-specific builtin that implements reciprocal of the function, or NULL_TREE if not available. */ DEFHOOK (builtin_reciprocal, - "", + "This hook should return the DECL of a function that implements reciprocal of\n\ +the builtin function with builtin function code @var{fn}, or\n\ +@code{NULL_TREE} if such a function is not available. @var{md_fn} is true\n\ +when @var{fn} is a code of a machine-dependent builtin function. When\n\ +@var{sqrt} is true, additional optimizations that apply only to the reciprocal\n\ +of a square root function are performed, and only reciprocals of @code{sqrt}\n\ +function are valid.", tree, (unsigned fn, bool md_fn, bool sqrt), default_builtin_reciprocal) @@ -1350,14 +2126,50 @@ DEFHOOK NULL. */ DEFHOOK (mangle_type, - "", + "If your target defines any fundamental types, or any types your target\n\ +uses should be mangled differently from the default, define this hook\n\ +to return the appropriate encoding for these types as part of a C++\n\ +mangled name. The @var{type} argument is the tree structure representing\n\ +the type to be mangled. The hook may be applied to trees which are\n\ +not target-specific fundamental types; it should return @code{NULL}\n\ +for all such types, as well as arguments it does not recognize. If the\n\ +return value is not @code{NULL}, it must point to a statically-allocated\n\ +string constant.\n\ +\n\ +Target-specific fundamental types might be new fundamental types or\n\ +qualified versions of ordinary fundamental types. Encode new\n\ +fundamental types as @samp{@w{u @var{n} @var{name}}}, where @var{name}\n\ +is the name used for the type in source code, and @var{n} is the\n\ +length of @var{name} in decimal. Encode qualified versions of\n\ +ordinary types as @samp{@w{U @var{n} @var{name} @var{code}}}, where\n\ +@var{name} is the name used for the type qualifier in source code,\n\ +@var{n} is the length of @var{name} as above, and @var{code} is the\n\ +code used to represent the unqualified version of this type. (See\n\ +@code{write_builtin_type} in @file{cp/mangle.c} for the list of\n\ +codes.) In both cases the spaces are for clarity; do not include any\n\ +spaces in your string.\n\ +\n\ +This hook is applied to types prior to typedef resolution. If the mangled\n\ +name for a particular type depends only on that type's main variant, you\n\ +can perform typedef resolution yourself using @code{TYPE_MAIN_VARIANT}\n\ +before mangling.\n\ +\n\ +The default version of this hook always returns @code{NULL}, which is\n\ +appropriate for a target that does not define any new fundamental\n\ +types.", const char *, (const_tree type), hook_constcharptr_const_tree_null) /* Make any adjustments to libfunc names needed for this target. */ DEFHOOK (init_libfuncs, - "", + "This hook should declare additional library routines or rename\n\ +existing ones, using the functions @code{set_optab_libfunc} and\n\ +@code{init_one_libfunc} defined in @file{optabs.c}.\n\ +@code{init_optabs} calls this macro after initializing all the normal\n\ +library routines.\n\ +\n\ +The default is to do nothing. Most ports don't need to define this hook.", void, (void), hook_void_void) @@ -1377,7 +2189,15 @@ is set to true, the @file{tm.h} file must also\n\ /* ??? Should be merged with SELECT_SECTION and UNIQUE_SECTION. */ DEFHOOK (section_type_flags, - "", + "Choose a set of section attributes for use by @code{TARGET_ASM_NAMED_SECTION}\n\ +based on a variable or function decl, a section name, and whether or not the\n\ +declaration's initializer may contain runtime relocations. @var{decl} may be\n\ +null, in which case read-write data should be assumed.\n\ +\n\ +The default version of this function handles choosing code vs data,\n\ +read-only vs read-write data, and @code{flag_pic}. You should only\n\ +need to override this if your target has special flags that might be\n\ +set via @code{__attribute__}.", unsigned int, (tree decl, const char *name, int reloc), default_section_type_flags) @@ -1385,7 +2205,18 @@ DEFHOOK not, at the current point in the compilation. */ DEFHOOK (cannot_modify_jumps_p, - "", + "This target hook returns @code{true} past the point in which new jump\n\ +instructions could be created. On machines that require a register for\n\ +every jump such as the SHmedia ISA of SH5, this point would typically be\n\ +reload, so this target hook should be defined to a function such as:\n\ +\n\ +@smallexample\n\ +static bool\n\ +cannot_modify_jumps_past_reload_p ()\n\ +@{\n\ + return (reload_completed || reload_in_progress);\n\ +@}\n\ +@end smallexample", bool, (void), hook_bool_void_false) @@ -1404,7 +2235,11 @@ DEFHOOK optimizations should be applied. */ DEFHOOK (branch_target_register_class, - "", + "This target hook returns a register class for which branch target register\n\ +optimizations should be applied. All registers in this class should be\n\ +usable interchangeably. After reload, registers in this class will be\n\ +re-allocated and loads will be hoisted out of loops and be subjected\n\ +to inter-block scheduling.", reg_class_t, (void), default_branch_target_register_class) @@ -1414,35 +2249,66 @@ DEFHOOK already been generated. */ DEFHOOK (branch_target_register_callee_saved, - "", + "Branch target register optimization will by default exclude callee-saved\n\ +registers\n\ +that are not already live during the current function; if this target hook\n\ +returns true, they will be included. The target code must than make sure\n\ +that all target registers in the class returned by\n\ +@samp{TARGET_BRANCH_TARGET_REGISTER_CLASS} that might need saving are\n\ +saved. @var{after_prologue_epilogue_gen} indicates if prologues and\n\ +epilogues have already been generated. Note, even if you only return\n\ +true when @var{after_prologue_epilogue_gen} is false, you still are likely\n\ +to have to make special provisions in @code{INITIAL_ELIMINATION_OFFSET}\n\ +to reserve space for caller-saved target registers.", bool, (bool after_prologue_epilogue_gen), hook_bool_bool_false) /* Return true if the target supports conditional execution. */ DEFHOOK (have_conditional_execution, - "", + "This target hook returns true if the target supports conditional execution.\n\ +This target hook is required only when the target has several different\n\ +modes and they have different conditional execution capability, such as ARM.", bool, (void), default_have_conditional_execution) /* Return a new value for loop unroll size. */ DEFHOOK (loop_unroll_adjust, - "", + "This target hook returns a new value for the number of times @var{loop}\n\ +should be unrolled. The parameter @var{nunroll} is the number of times\n\ +the loop is to be unrolled. The parameter @var{loop} is a pointer to\n\ +the loop, which is going to be checked for unrolling. This target hook\n\ +is required only when the target has special constraints like maximum\n\ +number of memory accesses.", unsigned, (unsigned nunroll, struct loop *loop), NULL) /* True if X is a legitimate MODE-mode immediate operand. */ DEFHOOK (legitimate_constant_p, - "", + "This hook returns true if @var{x} is a legitimate constant for a\n\ +@var{mode}-mode immediate operand on the target machine. You can assume that\n\ +@var{x} satisfies @code{CONSTANT_P}, so you need not check this.\n\ +\n\ +The default definition returns true.", bool, (enum machine_mode mode, rtx x), hook_bool_mode_rtx_true) /* True if the constant X cannot be placed in the constant pool. */ DEFHOOK (cannot_force_const_mem, - "", + "This hook should return true if @var{x} is of a form that cannot (or\n\ +should not) be spilled to the constant pool. @var{mode} is the mode\n\ +of @var{x}.\n\ +\n\ +The default version of this hook returns false.\n\ +\n\ +The primary reason to define this hook is to prevent reload from\n\ +deciding that a non-legitimate constant would be better reloaded\n\ +from the constant pool instead of spilling and reloading a register\n\ +holding the constant. This restriction is often true of addresses\n\ +of TLS symbols for various targets.", bool, (enum machine_mode mode, rtx x), hook_bool_mode_rtx_false) @@ -1454,7 +2320,10 @@ DEFHOOK_UNDOC /* True if X is considered to be commutative. */ DEFHOOK (commutative_p, - "", + "This target hook returns @code{true} if @var{x} is considered to be commutative.\n\ +Usually, this is just COMMUTATIVE_P (@var{x}), but the HP PA doesn't consider\n\ +PLUS to be commutative inside a MEM@. @var{outer_code} is the rtx code\n\ +of the enclosing rtl, if known, otherwise it is UNKNOWN.", bool, (const_rtx x, int outer_code), hook_bool_const_rtx_commutative_p) @@ -1462,7 +2331,20 @@ DEFHOOK on the mode of the memory reference it is used in. */ DEFHOOK (mode_dependent_address_p, - "", + "This hook returns @code{true} if memory address @var{addr} in address\n\ +space @var{addrspace} can have\n\ +different meanings depending on the machine mode of the memory\n\ +reference it is used for or if the address is valid for some modes\n\ +but not others.\n\ +\n\ +Autoincrement and autodecrement addresses typically have mode-dependent\n\ +effects because the amount of the increment or decrement is the size\n\ +of the operand being addressed. Some machines have other mode-dependent\n\ +addresses. Many RISC machines have no mode-dependent addresses.\n\ +\n\ +You may assume that @var{addr} is a valid address for the machine.\n\ +\n\ +The default version of this hook returns @code{false}.", bool, (const_rtx addr, addr_space_t addrspace), default_mode_dependent_address_p) @@ -1470,14 +2352,39 @@ DEFHOOK ways to make it legitimate. Return X or an invalid address on failure. */ DEFHOOK (legitimize_address, - "", + "This hook is given an invalid memory address @var{x} for an\n\ +operand of mode @var{mode} and should try to return a valid memory\n\ +address.\n\ +\n\ +@findex break_out_memory_refs\n\ +@var{x} will always be the result of a call to @code{break_out_memory_refs},\n\ +and @var{oldx} will be the operand that was given to that function to produce\n\ +@var{x}.\n\ +\n\ +The code of the hook should not alter the substructure of\n\ +@var{x}. If it transforms @var{x} into a more legitimate form, it\n\ +should return the new @var{x}.\n\ +\n\ +It is not necessary for this hook to come up with a legitimate address,\n\ +with the exception of native TLS addresses (@pxref{Emulated TLS}).\n\ +The compiler has standard ways of doing so in all cases. In fact, if\n\ +the target supports only emulated TLS, it\n\ +is safe to omit this hook or make it return @var{x} if it cannot find\n\ +a valid way to legitimize the address. But often a machine-dependent\n\ +strategy can generate better code.", rtx, (rtx x, rtx oldx, enum machine_mode mode), default_legitimize_address) /* Given an address RTX, undo the effects of LEGITIMIZE_ADDRESS. */ DEFHOOK (delegitimize_address, - "", + "This hook is used to undo the possibly obfuscating effects of the\n\ +@code{LEGITIMIZE_ADDRESS} and @code{LEGITIMIZE_RELOAD_ADDRESS} target\n\ +macros. Some backend implementations of these macros wrap symbol\n\ +references inside an @code{UNSPEC} rtx to represent PIC or similar\n\ +addressing modes. This target hook allows GCC's optimizers to understand\n\ +the semantics of these opaque @code{UNSPEC}s by converting them back\n\ +into their original form.", rtx, (rtx x), delegitimize_mem_from_attrs) @@ -1485,46 +2392,126 @@ DEFHOOK section. */ DEFHOOK (const_not_ok_for_debug_p, - "", + "This hook should return true if @var{x} should not be emitted into\n\ +debug sections.", bool, (rtx x), hook_bool_rtx_false) /* Given an address RTX, say whether it is valid. */ DEFHOOK (legitimate_address_p, - "", + "A function that returns whether @var{x} (an RTX) is a legitimate memory\n\ +address on the target machine for a memory operand of mode @var{mode}.\n\ +\n\ +Legitimate addresses are defined in two variants: a strict variant and a\n\ +non-strict one. The @var{strict} parameter chooses which variant is\n\ +desired by the caller.\n\ +\n\ +The strict variant is used in the reload pass. It must be defined so\n\ +that any pseudo-register that has not been allocated a hard register is\n\ +considered a memory reference. This is because in contexts where some\n\ +kind of register is required, a pseudo-register with no hard register\n\ +must be rejected. For non-hard registers, the strict variant should look\n\ +up the @code{reg_renumber} array; it should then proceed using the hard\n\ +register number in the array, or treat the pseudo as a memory reference\n\ +if the array holds @code{-1}.\n\ +\n\ +The non-strict variant is used in other passes. It must be defined to\n\ +accept all pseudo-registers in every context where some kind of\n\ +register is required.\n\ +\n\ +Normally, constant addresses which are the sum of a @code{symbol_ref}\n\ +and an integer are stored inside a @code{const} RTX to mark them as\n\ +constant. Therefore, there is no need to recognize such sums\n\ +specifically as legitimate addresses. Normally you would simply\n\ +recognize any @code{const} as legitimate.\n\ +\n\ +Usually @code{PRINT_OPERAND_ADDRESS} is not prepared to handle constant\n\ +sums that are not marked with @code{const}. It assumes that a naked\n\ +@code{plus} indicates indexing. If so, then you @emph{must} reject such\n\ +naked constant sums as illegitimate addresses, so that none of them will\n\ +be given to @code{PRINT_OPERAND_ADDRESS}.\n\ +\n\ +@cindex @code{TARGET_ENCODE_SECTION_INFO} and address validation\n\ +On some machines, whether a symbolic address is legitimate depends on\n\ +the section that the address refers to. On these machines, define the\n\ +target hook @code{TARGET_ENCODE_SECTION_INFO} to store the information\n\ +into the @code{symbol_ref}, and then check for it here. When you see a\n\ +@code{const}, you will have to look inside it to find the\n\ +@code{symbol_ref} in order to determine the section. @xref{Assembler\n\ +Format}.\n\ +\n\ +@cindex @code{GO_IF_LEGITIMATE_ADDRESS}\n\ +Some ports are still using a deprecated legacy substitute for\n\ +this hook, the @code{GO_IF_LEGITIMATE_ADDRESS} macro. This macro\n\ +has this syntax:\n\ +\n\ +@example\n\ +#define GO_IF_LEGITIMATE_ADDRESS (@var{mode}, @var{x}, @var{label})\n\ +@end example\n\ +\n\ +@noindent\n\ +and should @code{goto @var{label}} if the address @var{x} is a valid\n\ +address on the target machine for a memory operand of mode @var{mode}.\n\ +\n\ +@findex REG_OK_STRICT\n\ +Compiler source files that want to use the strict variant of this\n\ +macro define the macro @code{REG_OK_STRICT}. You should use an\n\ +@code{#ifdef REG_OK_STRICT} conditional to define the strict variant in\n\ +that case and the non-strict variant otherwise.\n\ +\n\ +Using the hook is usually simpler because it limits the number of\n\ +files that are recompiled when changes are made.", bool, (enum machine_mode mode, rtx x, bool strict), default_legitimate_address_p) /* True if the given constant can be put into an object_block. */ DEFHOOK (use_blocks_for_constant_p, - "", + "This hook should return true if pool entries for constant @var{x} can\n\ +be placed in an @code{object_block} structure. @var{mode} is the mode\n\ +of @var{x}.\n\ +\n\ +The default version returns false for all constants.", bool, (enum machine_mode mode, const_rtx x), hook_bool_mode_const_rtx_false) /* True if the given decl can be put into an object_block. */ DEFHOOK (use_blocks_for_decl_p, - "", + "This hook should return true if pool entries for @var{decl} should\n\ +be placed in an @code{object_block} structure.\n\ +\n\ +The default version returns true for all decls.", bool, (const_tree decl), hook_bool_const_tree_true) /* The minimum and maximum byte offsets for anchored addresses. */ DEFHOOKPOD (min_anchor_offset, - "", + "The minimum offset that should be applied to a section anchor.\n\ +On most targets, it should be the smallest offset that can be\n\ +applied to a base register while still giving a legitimate address\n\ +for every mode. The default value is 0.", HOST_WIDE_INT, 0) DEFHOOKPOD (max_anchor_offset, - "", + "Like @code{TARGET_MIN_ANCHOR_OFFSET}, but the maximum (inclusive)\n\ +offset that should be applied to section anchors. The default\n\ +value is 0.", HOST_WIDE_INT, 0) /* True if section anchors can be used to access the given symbol. */ DEFHOOK (use_anchors_for_symbol_p, - "", + "Return true if GCC should attempt to use anchors to access @code{SYMBOL_REF}\n\ +@var{x}. You can assume @samp{SYMBOL_REF_HAS_BLOCK_INFO_P (@var{x})} and\n\ +@samp{!SYMBOL_REF_ANCHOR_P (@var{x})}.\n\ +\n\ +The default version is correct for most targets, but you might need to\n\ +intercept this hook to handle things like target-specific attributes\n\ +or target-specific sections.", bool, (const_rtx x), default_use_anchors_for_symbol_p) @@ -1542,7 +2529,16 @@ The default value of this hook is based on target's libc.", this is an indirect call. */ DEFHOOK (function_ok_for_sibcall, - "", + "True if it is ok to do sibling call optimization for the specified\n\ +call expression @var{exp}. @var{decl} will be the called function,\n\ +or @code{NULL} if this is an indirect call.\n\ +\n\ +It is not uncommon for limitations of calling conventions to prevent\n\ +tail calls to functions outside the current unit of translation, or\n\ +during PIC compilation. The hook is used to enforce these restrictions,\n\ +as the @code{sibcall} md pattern can not fail, or fall over to a\n\ +``normal'' call. The criteria for successful sibling call optimization\n\ +may vary greatly between different architectures.", bool, (tree decl, tree exp), hook_bool_tree_tree_false) @@ -1551,13 +2547,29 @@ DEFHOOK level, outside of any function scope. */ DEFHOOK (set_current_function, - "", + "The compiler invokes this hook whenever it changes its current function\n\ +context (@code{cfun}). You can define this function if\n\ +the back end needs to perform any initialization or reset actions on a\n\ +per-function basis. For example, it may be used to implement function\n\ +attributes that affect register usage or code generation patterns.\n\ +The argument @var{decl} is the declaration for the new function context,\n\ +and may be null to indicate that the compiler has left a function context\n\ +and is returning to processing at the top level.\n\ +The default hook function does nothing.\n\ +\n\ +GCC sets @code{cfun} to a dummy function context during initialization of\n\ +some parts of the back end. The hook function is not invoked in this\n\ +situation; you need not worry about the hook being invoked recursively,\n\ +or when the back end is in a partially-initialized state.\n\ +@code{cfun} might be @code{NULL} to indicate processing at top level,\n\ +outside of any function scope.", void, (tree decl), hook_void_tree) /* True if EXP should be placed in a "small data" section. */ DEFHOOK (in_small_data_p, - "", + "Returns true if @var{exp} should be placed into a ``small data'' section.\n\ +The default version of this hook always returns false.", bool, (const_tree exp), hook_bool_const_tree_false) @@ -1565,7 +2577,13 @@ DEFHOOK to the current executable or shared library. */ DEFHOOK (binds_local_p, - "", + "Returns true if @var{exp} names an object for which name resolution\n\ +rules must resolve to the current ``module'' (dynamic shared library\n\ +or executable image).\n\ +\n\ +The default version of this hook implements the name resolution rules\n\ +for ELF, which has a looser model of global name binding than other\n\ +currently supported object file formats.", bool, (const_tree exp), default_binds_local_p) @@ -1584,7 +2602,13 @@ The default version of this hook use the target macro\n\ The default is to return ID without modification. */ DEFHOOK (mangle_decl_assembler_name, - "", + "Define this hook if you need to postprocess the assembler name generated\n\ +by target-independent code. The @var{id} provided to this hook will be\n\ +the computed name (e.g., the macro @code{DECL_NAME} of the @var{decl} in C,\n\ +or the mangled name of the @var{decl} in C++). The return value of the\n\ +hook is an @code{IDENTIFIER_NODE} for the appropriate mangled name on\n\ +your target system. The default implementation of this hook just\n\ +returns the @var{id} provided.", tree, (tree decl, tree id), default_mangle_decl_assembler_name) @@ -1592,14 +2616,50 @@ DEFHOOK the associated SYMBOL_REF. */ DEFHOOK (encode_section_info, - "", + "Define this hook if references to a symbol or a constant must be\n\ +treated differently depending on something about the variable or\n\ +function named by the symbol (such as what section it is in).\n\ +\n\ +The hook is executed immediately after rtl has been created for\n\ +@var{decl}, which may be a variable or function declaration or\n\ +an entry in the constant pool. In either case, @var{rtl} is the\n\ +rtl in question. Do @emph{not} use @code{DECL_RTL (@var{decl})}\n\ +in this hook; that field may not have been initialized yet.\n\ +\n\ +In the case of a constant, it is safe to assume that the rtl is\n\ +a @code{mem} whose address is a @code{symbol_ref}. Most decls\n\ +will also have this form, but that is not guaranteed. Global\n\ +register variables, for instance, will have a @code{reg} for their\n\ +rtl. (Normally the right thing to do with such unusual rtl is\n\ +leave it alone.)\n\ +\n\ +The @var{new_decl_p} argument will be true if this is the first time\n\ +that @code{TARGET_ENCODE_SECTION_INFO} has been invoked on this decl. It will\n\ +be false for subsequent invocations, which will happen for duplicate\n\ +declarations. Whether or not anything must be done for the duplicate\n\ +declaration depends on whether the hook examines @code{DECL_ATTRIBUTES}.\n\ +@var{new_decl_p} is always true when the hook is called for a constant.\n\ +\n\ +@cindex @code{SYMBOL_REF_FLAG}, in @code{TARGET_ENCODE_SECTION_INFO}\n\ +The usual thing for this hook to do is to record flags in the\n\ +@code{symbol_ref}, using @code{SYMBOL_REF_FLAG} or @code{SYMBOL_REF_FLAGS}.\n\ +Historically, the name string was modified if it was necessary to\n\ +encode more than one bit of information, but this practice is now\n\ +discouraged; use @code{SYMBOL_REF_FLAGS}.\n\ +\n\ +The default definition of this hook, @code{default_encode_section_info}\n\ +in @file{varasm.c}, sets a number of commonly-useful bits in\n\ +@code{SYMBOL_REF_FLAGS}. Check whether the default does what you need\n\ +before overriding it.", void, (tree decl, rtx rtl, int new_decl_p), default_encode_section_info) /* Undo the effects of encode_section_info on the symbol string. */ DEFHOOK (strip_name_encoding, - "", + "Decode @var{name} and return the real name part, sans\n\ +the characters that @code{TARGET_ENCODE_SECTION_INFO}\n\ +may have added.", const char *, (const char *name), default_strip_name_encoding) @@ -1607,7 +2667,27 @@ DEFHOOK return the mask that they apply. Return 0 otherwise. */ DEFHOOK (shift_truncation_mask, - "", + "This function describes how the standard shift patterns for @var{mode}\n\ +deal with shifts by negative amounts or by more than the width of the mode.\n\ +@xref{shift patterns}.\n\ +\n\ +On many machines, the shift patterns will apply a mask @var{m} to the\n\ +shift count, meaning that a fixed-width shift of @var{x} by @var{y} is\n\ +equivalent to an arbitrary-width shift of @var{x} by @var{y & m}. If\n\ +this is true for mode @var{mode}, the function should return @var{m},\n\ +otherwise it should return 0. A return value of 0 indicates that no\n\ +particular behavior is guaranteed.\n\ +\n\ +Note that, unlike @code{SHIFT_COUNT_TRUNCATED}, this function does\n\ +@emph{not} apply to general shift rtxes; it applies only to instructions\n\ +that are generated by the named shift patterns.\n\ +\n\ +The default implementation of this function returns\n\ +@code{GET_MODE_BITSIZE (@var{mode}) - 1} if @code{SHIFT_COUNT_TRUNCATED}\n\ +and 0 otherwise. This definition is always safe, but if\n\ +@code{SHIFT_COUNT_TRUNCATED} is false, and some shift patterns\n\ +nevertheless truncate the shift count, you may get better code\n\ +by overriding it.", unsigned HOST_WIDE_INT, (enum machine_mode mode), default_shift_truncation_mask) @@ -1616,7 +2696,12 @@ DEFHOOK the reciprocal. */ DEFHOOK (min_divisions_for_recip_mul, - "", + "When @option{-ffast-math} is in effect, GCC tries to optimize\n\ +divisions by the same divisor, by turning them into multiplications by\n\ +the reciprocal. This target hook specifies the minimum number of divisions\n\ +that should be there for GCC to perform the optimization for a variable\n\ +of mode @var{mode}. The default implementation returns 3 if the machine\n\ +has an instruction for the division, and 2 if it does not.", unsigned int, (enum machine_mode mode), default_min_divisions_for_recip_mul) @@ -1627,14 +2712,40 @@ DEFHOOK necessarily defined at this point. */ DEFHOOK (mode_rep_extended, - "", + "The representation of an integral mode can be such that the values\n\ +are always extended to a wider integral mode. Return\n\ +@code{SIGN_EXTEND} if values of @var{mode} are represented in\n\ +sign-extended form to @var{rep_mode}. Return @code{UNKNOWN}\n\ +otherwise. (Currently, none of the targets use zero-extended\n\ +representation this way so unlike @code{LOAD_EXTEND_OP},\n\ +@code{TARGET_MODE_REP_EXTENDED} is expected to return either\n\ +@code{SIGN_EXTEND} or @code{UNKNOWN}. Also no target extends\n\ +@var{mode} to @var{rep_mode} so that @var{rep_mode} is not the next\n\ +widest integral mode and currently we take advantage of this fact.)\n\ +\n\ +Similarly to @code{LOAD_EXTEND_OP} you may return a non-@code{UNKNOWN}\n\ +value even if the extension is not performed on certain hard registers\n\ +as long as for the @code{REGNO_REG_CLASS} of these hard registers\n\ +@code{CANNOT_CHANGE_MODE_CLASS} returns nonzero.\n\ +\n\ +Note that @code{TARGET_MODE_REP_EXTENDED} and @code{LOAD_EXTEND_OP}\n\ +describe two related properties. If you define\n\ +@code{TARGET_MODE_REP_EXTENDED (mode, word_mode)} you probably also want\n\ +to define @code{LOAD_EXTEND_OP (mode)} to return the same type of\n\ +extension.\n\ +\n\ +In order to enforce the representation of @code{mode},\n\ +@code{TRULY_NOOP_TRUNCATION} should return false when truncating to\n\ +@code{mode}.", int, (enum machine_mode mode, enum machine_mode rep_mode), default_mode_rep_extended) /* True if MODE is valid for a pointer in __attribute__((mode("MODE"))). */ DEFHOOK (valid_pointer_mode, - "", + "Define this to return nonzero if the port can handle pointers\n\ +with machine mode @var{mode}. The default version of this\n\ +hook returns true for both @code{ptr_mode} and @code{Pmode}.", bool, (enum machine_mode mode), default_valid_pointer_mode) @@ -1657,14 +2768,20 @@ HOOK_VECTOR (TARGET_ADDR_SPACE_HOOKS, addr_space) /* MODE to use for a pointer into another address space. */ DEFHOOK (pointer_mode, - "", + "Define this to return the machine mode to use for pointers to\n\ +@var{address_space} if the target supports named address spaces.\n\ +The default version of this hook returns @code{ptr_mode} for the\n\ +generic address space only.", enum machine_mode, (addr_space_t address_space), default_addr_space_pointer_mode) /* MODE to use for an address in another address space. */ DEFHOOK (address_mode, - "", + "Define this to return the machine mode to use for addresses in\n\ +@var{address_space} if the target supports named address spaces.\n\ +The default version of this hook returns @code{Pmode} for the\n\ +generic address space only.", enum machine_mode, (addr_space_t address_space), default_addr_space_address_mode) @@ -1672,7 +2789,13 @@ DEFHOOK in another address space. */ DEFHOOK (valid_pointer_mode, - "", + "Define this to return nonzero if the port can handle pointers\n\ +with machine mode @var{mode} to address space @var{as}. This target\n\ +hook is the same as the @code{TARGET_VALID_POINTER_MODE} target hook,\n\ +except that it includes explicit named address space support. The default\n\ +version of this hook returns true for the modes returned by either the\n\ +@code{TARGET_ADDR_SPACE_POINTER_MODE} or @code{TARGET_ADDR_SPACE_ADDRESS_MODE}\n\ +target hooks for the given address space.", bool, (enum machine_mode mode, addr_space_t as), default_addr_space_valid_pointer_mode) @@ -1680,7 +2803,12 @@ DEFHOOK space for a given mode. */ DEFHOOK (legitimate_address_p, - "", + "Define this to return true if @var{exp} is a valid address for mode\n\ +@var{mode} in the named address space @var{as}. The @var{strict}\n\ +parameter says whether strict addressing is in effect after reload has\n\ +finished. This target hook is the same as the\n\ +@code{TARGET_LEGITIMATE_ADDRESS_P} target hook, except that it includes\n\ +explicit named address space support.", bool, (enum machine_mode mode, rtx exp, bool strict, addr_space_t as), default_addr_space_legitimate_address_p) @@ -1689,21 +2817,34 @@ DEFHOOK independent methods to make the address valid. */ DEFHOOK (legitimize_address, - "", + "Define this to modify an invalid address @var{x} to be a valid address\n\ +with mode @var{mode} in the named address space @var{as}. This target\n\ +hook is the same as the @code{TARGET_LEGITIMIZE_ADDRESS} target hook,\n\ +except that it includes explicit named address space support.", rtx, (rtx x, rtx oldx, enum machine_mode mode, addr_space_t as), default_addr_space_legitimize_address) /* True if one named address space is a subset of another named address. */ DEFHOOK (subset_p, - "", + "Define this to return whether the @var{subset} named address space is\n\ +contained within the @var{superset} named address space. Pointers to\n\ +a named address space that is a subset of another named address space\n\ +will be converted automatically without a cast if used together in\n\ +arithmetic operations. Pointers to a superset address space can be\n\ +converted to pointers to a subset address space via explicit casts.", bool, (addr_space_t subset, addr_space_t superset), default_addr_space_subset_p) /* Function to convert an rtl expression from one address space to another. */ DEFHOOK (convert, - "", + "Define this to convert the pointer expression represented by the RTL\n\ +@var{op} with type @var{from_type} that points to a named address\n\ +space to a new pointer expression with type @var{to_type} that points\n\ +to a different named address space. When this hook it called, it is\n\ +guaranteed that one of the two address spaces is a subset of the other,\n\ +as determined by the @code{TARGET_ADDR_SPACE_SUBSET_P} target hook.", rtx, (rtx op, tree from_type, tree to_type), default_addr_space_convert) @@ -1717,7 +2858,15 @@ HOOK_VECTOR_END (addr_space) the arithmetic is supported. */ DEFHOOK (scalar_mode_supported_p, - "", + "Define this to return nonzero if the port is prepared to handle\n\ +insns involving scalar mode @var{mode}. For a scalar mode to be\n\ +considered supported, all the basic arithmetic and comparisons\n\ +must work.\n\ +\n\ +The default version of this hook returns true for any mode\n\ +required to handle the basic C types (as defined by the port).\n\ +Included here are the double-word arithmetic supported by the\n\ +code in @file{optabs.c}.", bool, (enum machine_mode mode), default_scalar_mode_supported_p) @@ -1726,7 +2875,9 @@ DEFHOOK for further details. */ DEFHOOK (vector_mode_supported_p, - "", + "Define this to return nonzero if the port is prepared to handle\n\ +insns involving vector mode @var{mode}. At the very least, it\n\ +must have move patterns for this mode.", bool, (enum machine_mode mode), hook_bool_mode_false) @@ -1776,7 +2927,24 @@ If this hook allows @code{val} to have a scalar mode, then\n\ TO, using MODE. */ DEFHOOK (register_move_cost, - "", + "This target hook should return the cost of moving data of mode @var{mode}\n\ +from a register in class @var{from} to one in class @var{to}. The classes\n\ +are expressed using the enumeration values such as @code{GENERAL_REGS}.\n\ +A value of 2 is the default; other values are interpreted relative to\n\ +that.\n\ +\n\ +It is not required that the cost always equal 2 when @var{from} is the\n\ +same as @var{to}; on some machines it is expensive to move between\n\ +registers if they are not general registers.\n\ +\n\ +If reload sees an insn consisting of a single @code{set} between two\n\ +hard registers, and if @code{TARGET_REGISTER_MOVE_COST} applied to their\n\ +classes returns a value of 2, reload does not check to ensure that the\n\ +constraints of the insn are met. Setting a cost of other than 2 will\n\ +allow reload to verify that the constraints are met. You should do this\n\ +if the @samp{mov@var{m}} pattern's constraints do not allow such copying.\n\ +\n\ +The default version of this function returns 2.", int, (enum machine_mode mode, reg_class_t from, reg_class_t to), default_register_move_cost) @@ -1785,7 +2953,27 @@ DEFHOOK license grant. Also, the documentation uses a different name for RCLASS. */ DEFHOOK (memory_move_cost, - "", + "This target hook should return the cost of moving data of mode @var{mode}\n\ +between a register of class @var{rclass} and memory; @var{in} is @code{false}\n\ +if the value is to be written to memory, @code{true} if it is to be read in.\n\ +This cost is relative to those in @code{TARGET_REGISTER_MOVE_COST}.\n\ +If moving between registers and memory is more expensive than between two\n\ +registers, you should add this target hook to express the relative cost.\n\ +\n\ +If you do not add this target hook, GCC uses a default cost of 4 plus\n\ +the cost of copying via a secondary reload register, if one is\n\ +needed. If your machine requires a secondary reload register to copy\n\ +between memory and a register of @var{rclass} but the reload mechanism is\n\ +more complex than copying via an intermediate, use this target hook to\n\ +reflect the actual cost of the move.\n\ +\n\ +GCC defines the function @code{memory_move_secondary_cost} if\n\ +secondary reloads are needed. It computes the costs due to copying via\n\ +a secondary register. If your machine copies from memory using a\n\ +secondary register in the conventional way but the default base value of\n\ +4 is not correct for your machine, use this target hook to add some other\n\ +value to the result of that function. The arguments to that function\n\ +are the same as to this target hook.", int, (enum machine_mode mode, reg_class_t rclass, bool in), default_memory_move_cost) @@ -1795,7 +2983,35 @@ DEFHOOK but it should prevent extending the lifetime of these registers. */ DEFHOOK (small_register_classes_for_mode_p, - "", + "Define this to return nonzero for machine modes for which the port has\n\ +small register classes. If this target hook returns nonzero for a given\n\ +@var{mode}, the compiler will try to minimize the lifetime of registers\n\ +in @var{mode}. The hook may be called with @code{VOIDmode} as argument.\n\ +In this case, the hook is expected to return nonzero if it returns nonzero\n\ +for any mode.\n\ +\n\ +On some machines, it is risky to let hard registers live across arbitrary\n\ +insns. Typically, these machines have instructions that require values\n\ +to be in specific registers (like an accumulator), and reload will fail\n\ +if the required hard register is used for another purpose across such an\n\ +insn.\n\ +\n\ +Passes before reload do not know which hard registers will be used\n\ +in an instruction, but the machine modes of the registers set or used in\n\ +the instruction are already known. And for some machines, register\n\ +classes are small for, say, integer registers but not for floating point\n\ +registers. For example, the AMD x86-64 architecture requires specific\n\ +registers for the legacy x86 integer instructions, but there are many\n\ +SSE registers for floating point operations. On such targets, a good\n\ +strategy may be to return nonzero from this hook for @code{INTEGRAL_MODE_P}\n\ +machine modes but zero for the SSE register classes.\n\ +\n\ +The default version of this hook returns false for any mode. It is always\n\ +safe to redefine this hook to return with a nonzero value. But if you\n\ +unnecessarily define it, you will reduce the amount of optimizations\n\ +that can be performed in some cases. If you do not define this hook\n\ +to return a nonzero value when it is required, the compiler will run out\n\ +of spill registers and print a fatal error message.", bool, (enum machine_mode mode), hook_bool_mode_false) @@ -1815,7 +3031,35 @@ DEFHOOKPOD not necessarily defined at this point. */ DEFHOOK (rtx_costs, - "", + "This target hook describes the relative costs of RTL expressions.\n\ +\n\ +The cost may depend on the precise form of the expression, which is\n\ +available for examination in @var{x}, and the fact that @var{x} appears\n\ +as operand @var{opno} of an expression with rtx code @var{outer_code}.\n\ +That is, the hook can assume that there is some rtx @var{y} such\n\ +that @samp{GET_CODE (@var{y}) == @var{outer_code}} and such that\n\ +either (a) @samp{XEXP (@var{y}, @var{opno}) == @var{x}} or\n\ +(b) @samp{XVEC (@var{y}, @var{opno})} contains @var{x}.\n\ +\n\ +@var{code} is @var{x}'s expression code---redundant, since it can be\n\ +obtained with @code{GET_CODE (@var{x})}.\n\ +\n\ +In implementing this hook, you can use the construct\n\ +@code{COSTS_N_INSNS (@var{n})} to specify a cost equal to @var{n} fast\n\ +instructions.\n\ +\n\ +On entry to the hook, @code{*@var{total}} contains a default estimate\n\ +for the cost of the expression. The hook should modify this value as\n\ +necessary. Traditionally, the default costs are @code{COSTS_N_INSNS (5)}\n\ +for multiplications, @code{COSTS_N_INSNS (7)} for division and modulus\n\ +operations, and @code{COSTS_N_INSNS (1)} for all other operations.\n\ +\n\ +When optimizing for code size, i.e.@: when @code{speed} is\n\ +false, this target hook should be used to estimate the relative\n\ +size cost of an expression, again relative to @code{COSTS_N_INSNS}.\n\ +\n\ +The hook returns true when all subexpressions of @var{x} have been\n\ +processed, and false when @code{rtx_cost} should recurse.", bool, (rtx x, int code, int outer_code, int opno, int *total, bool speed), hook_bool_rtx_int_int_int_intp_bool_false) @@ -1823,21 +3067,75 @@ DEFHOOK invalid addresses. */ DEFHOOK (address_cost, - "", + "This hook computes the cost of an addressing mode that contains\n\ +@var{address}. If not defined, the cost is computed from\n\ +the @var{address} expression and the @code{TARGET_RTX_COST} hook.\n\ +\n\ +For most CISC machines, the default cost is a good approximation of the\n\ +true cost of the addressing mode. However, on RISC machines, all\n\ +instructions normally have the same length and execution time. Hence\n\ +all addresses will have equal costs.\n\ +\n\ +In cases where more than one form of an address is known, the form with\n\ +the lowest cost will be used. If multiple forms have the same, lowest,\n\ +cost, the one that is the most complex will be used.\n\ +\n\ +For example, suppose an address that is equal to the sum of a register\n\ +and a constant is used twice in the same basic block. When this macro\n\ +is not defined, the address will be computed in a register and memory\n\ +references will be indirect through that register. On machines where\n\ +the cost of the addressing mode containing the sum is no higher than\n\ +that of a simple indirect reference, this will produce an additional\n\ +instruction and possibly require an additional register. Proper\n\ +specification of this macro eliminates this overhead for such machines.\n\ +\n\ +This hook is never called with an invalid address.\n\ +\n\ +On machines where an address involving more than one register is as\n\ +cheap as an address computation involving only one register, defining\n\ +@code{TARGET_ADDRESS_COST} to reflect this can cause two registers to\n\ +be live over a region of code where only one would have been if\n\ +@code{TARGET_ADDRESS_COST} were not defined in that manner. This effect\n\ +should be considered in the definition of this macro. Equivalent costs\n\ +should probably only be given to addresses with different numbers of\n\ +registers on machines with lots of registers.", int, (rtx address, enum machine_mode mode, addr_space_t as, bool speed), default_address_cost) /* Return where to allocate pseudo for a given hard register initial value. */ DEFHOOK (allocate_initial_value, - "", + "\n\ +When the initial value of a hard register has been copied in a pseudo\n\ +register, it is often not necessary to actually allocate another register\n\ +to this pseudo register, because the original hard register or a stack slot\n\ +it has been saved into can be used. @code{TARGET_ALLOCATE_INITIAL_VALUE}\n\ +is called at the start of register allocation once for each hard register\n\ +that had its initial value copied by using\n\ +@code{get_func_hard_reg_initial_val} or @code{get_hard_reg_initial_val}.\n\ +Possible values are @code{NULL_RTX}, if you don't want\n\ +to do any special allocation, a @code{REG} rtx---that would typically be\n\ +the hard register itself, if it is known not to be clobbered---or a\n\ +@code{MEM}.\n\ +If you are returning a @code{MEM}, this is only a hint for the allocator;\n\ +it might decide to use another register anyways.\n\ +You may use @code{current_function_is_leaf} or \n\ +@code{REG_N_SETS} in the hook to determine if the hard\n\ +register in question will not be clobbered.\n\ +The default value of this hook is @code{NULL}, which disables any special\n\ +allocation.", rtx, (rtx hard_reg), NULL) /* Return nonzero if evaluating UNSPEC X might cause a trap. FLAGS has the same meaning as in rtlanal.c: may_trap_p_1. */ DEFHOOK (unspec_may_trap_p, - "", + "This target hook returns nonzero if @var{x}, an @code{unspec} or\n\ +@code{unspec_volatile} operation, might cause a trap. Targets can use\n\ +this hook to enhance precision of analysis for @code{unspec} and\n\ +@code{unspec_volatile} operations. You may call @code{may_trap_p_1}\n\ +to analyze inner elements of @var{x} in which case @var{flags} should be\n\ +passed along.", int, (const_rtx x, unsigned flags), default_unspec_may_trap_p) @@ -1849,7 +3147,12 @@ DEFHOOK hook should return NULL_RTX. */ DEFHOOK (dwarf_register_span, - "", + "Given a register, this hook should return a parallel of registers to\n\ +represent where to find the register pieces. Define this hook if the\n\ +register and its mode are represented in Dwarf in non-contiguous\n\ +locations, or if the register should be represented in more than one\n\ +register in Dwarf. Otherwise, this hook should return @code{NULL_RTX}.\n\ +If not defined, the default is to return @code{NULL_RTX}.", rtx, (rtx reg), hook_rtx_rtx_null) @@ -1859,7 +3162,12 @@ DEFHOOK code, given the address of the table. */ DEFHOOK (init_dwarf_reg_sizes_extra, - "", + "If some registers are represented in Dwarf-2 unwind information in\n\ +multiple pieces, define this hook to fill in information about the\n\ +sizes of those pieces in the table used by the unwinder at runtime.\n\ +It will be called by @code{expand_builtin_init_dwarf_reg_sizes} after\n\ +filling in a single size corresponding to each hard register;\n\ +@var{address} is the address of the table.", void, (tree address), hook_void_tree) @@ -1872,7 +3180,18 @@ DEFHOOK at by the second argument should be set to -1. */ DEFHOOK (fixed_condition_code_regs, - "", + "On targets which do not use @code{(cc0)}, and which use a hard\n\ +register rather than a pseudo-register to hold condition codes, the\n\ +regular CSE passes are often not able to identify cases in which the\n\ +hard register is set to a common value. Use this hook to enable a\n\ +small pass which optimizes such cases. This hook should return true\n\ +to enable this pass, and it should set the integers to which its\n\ +arguments point to the hard register numbers used for condition codes.\n\ +When there is only one such register, as is true on most systems, the\n\ +integer pointed to by @var{p2} should be set to\n\ +@code{INVALID_REGNUM}.\n\ +\n\ +The default version of this hook returns false.", bool, (unsigned int *p1, unsigned int *p2), hook_bool_uintp_uintp_false) @@ -1883,7 +3202,16 @@ DEFHOOK VOIDmode. */ DEFHOOK (cc_modes_compatible, - "", + "On targets which use multiple condition code modes in class\n\ +@code{MODE_CC}, it is sometimes the case that a comparison can be\n\ +validly done in more than one mode. On such a system, define this\n\ +target hook to take two mode arguments and to return a mode in which\n\ +both comparisons may be validly done. If there is no such mode,\n\ +return @code{VOIDmode}.\n\ +\n\ +The default version of this hook checks whether the modes are the\n\ +same. If they are, it returns that mode. If they are different, it\n\ +returns @code{VOIDmode}.", enum machine_mode, (enum machine_mode m1, enum machine_mode m2), default_cc_modes_compatible) @@ -1891,34 +3219,59 @@ DEFHOOK delayed-branch scheduling. */ DEFHOOK (machine_dependent_reorg, - "", + "If non-null, this hook performs a target-specific pass over the\n\ +instruction stream. The compiler will run it at all optimization levels,\n\ +just before the point at which it normally does delayed-branch scheduling.\n\ +\n\ +The exact purpose of the hook varies from target to target. Some use\n\ +it to do transformations that are necessary for correctness, such as\n\ +laying out in-function constant pools or avoiding hardware hazards.\n\ +Others use it as an opportunity to do some machine-dependent optimizations.\n\ +\n\ +You need not implement the hook if it has nothing to do. The default\n\ +definition is null.", void, (void), NULL) /* Create the __builtin_va_list type. */ DEFHOOK (build_builtin_va_list, - "", + "This hook returns a type node for @code{va_list} for the target.\n\ +The default version of the hook returns @code{void*}.", tree, (void), std_build_builtin_va_list) /* Enumerate the va list variants. */ DEFHOOK (enum_va_list_p, - "", + "This target hook is used in function @code{c_common_nodes_and_builtins}\n\ +to iterate through the target specific builtin types for va_list. The\n\ +variable @var{idx} is used as iterator. @var{pname} has to be a pointer\n\ +to a @code{const char *} and @var{ptree} a pointer to a @code{tree} typed\n\ +variable.\n\ +The arguments @var{pname} and @var{ptree} are used to store the result of\n\ +this macro and are set to the name of the va_list builtin type and its\n\ +internal type.\n\ +If the return value of this macro is zero, then there is no more element.\n\ +Otherwise the @var{IDX} should be increased for the next call of this\n\ +macro to iterate through all types.", int, (int idx, const char **pname, tree *ptree), NULL) /* Get the cfun/fndecl calling abi __builtin_va_list type. */ DEFHOOK (fn_abi_va_list, - "", + "This hook returns the va_list type of the calling convention specified by\n\ +@var{fndecl}.\n\ +The default version of this hook returns @code{va_list_type_node}.", tree, (tree fndecl), std_fn_abi_va_list) /* Get the __builtin_va_list type dependent on input type. */ DEFHOOK (canonical_va_list_type, - "", + "This hook returns the va_list type of the calling convention specified by the\n\ +type of @var{type}. If @var{type} is not a valid va_list type, it returns\n\ +@code{NULL_TREE}.", tree, (tree type), std_canonical_va_list_type) @@ -1931,7 +3284,10 @@ DEFHOOK_UNDOC /* Gimplifies a VA_ARG_EXPR. */ DEFHOOK (gimplify_va_arg_expr, - "", + "This hook performs target-specific gimplification of\n\ +@code{VA_ARG_EXPR}. The first two parameters correspond to the\n\ +arguments to @code{va_arg}; the latter two are as in\n\ +@code{gimplify.c:gimplify_expr}.", tree, (tree valist, tree type, gimple_seq *pre_p, gimple_seq *post_p), std_gimplify_va_arg_expr) @@ -1942,13 +3298,26 @@ DEFHOOK or an error message if not. */ DEFHOOK (get_pch_validity, - "", + "This hook returns a pointer to the data needed by\n\ +@code{TARGET_PCH_VALID_P} and sets\n\ +@samp{*@var{sz}} to the size of the data in bytes.", void *, (size_t *sz), default_get_pch_validity) DEFHOOK (pch_valid_p, - "", + "This hook checks whether the options used to create a PCH file are\n\ +compatible with the current settings. It returns @code{NULL}\n\ +if so and a suitable error message if not. Error messages will\n\ +be presented to the user and must be localized using @samp{_(@var{msg})}.\n\ +\n\ +@var{data} is the data that was returned by @code{TARGET_GET_PCH_VALIDITY}\n\ +when the PCH file was created and @var{sz} is the size of that data in bytes.\n\ +It's safe to assume that the data was created by the same version of the\n\ +compiler, so no format checking is needed.\n\ +\n\ +The default definition of @code{default_pch_valid_p} should be\n\ +suitable for most targets.", const char *, (const void *data, size_t sz), default_pch_valid_p) @@ -1966,7 +3335,11 @@ to do anything here.", otherwise it returns an error message. */ DEFHOOK (check_pch_target_flags, - "", + "If this hook is nonnull, the default implementation of\n\ +@code{TARGET_PCH_VALID_P} will use it to check for compatible values\n\ +of @code{target_flags}. @var{pch_flags} specifies the value that\n\ +@code{target_flags} had when the PCH file was created. The return\n\ +value is the same as for @code{TARGET_PCH_VALID_P}.", const char *, (int pch_flags), NULL) /* True if the compiler should give an enum type only as many @@ -1974,7 +3347,12 @@ DEFHOOK that type. */ DEFHOOK (default_short_enums, - "", + "This target hook should return true if the compiler should give an\n\ +@code{enum} type only as many bytes as it takes to represent the range\n\ +of possible values of that type. It should return false if all\n\ +@code{enum} types should be allocated like @code{int}.\n\ +\n\ +The default is to return false.", bool, (void), hook_bool_void_false) @@ -1982,7 +3360,11 @@ DEFHOOK of the current frame into the built-in setjmp buffer. */ DEFHOOK (builtin_setjmp_frame_value, - "", + "This target hook should return an rtx that is used to store\n\ +the address of the current frame into the built in @code{setjmp} buffer.\n\ +The default value, @code{virtual_stack_vars_rtx}, is correct for most\n\ +machines. One reason you may need to define this target hook is if\n\ +@code{hard_frame_pointer_rtx} is the appropriate value on your machine.", rtx, (void), default_builtin_setjmp_frame_value) @@ -1990,7 +3372,14 @@ DEFHOOK the port wishes to automatically clobber for an asm. */ DEFHOOK (md_asm_clobbers, - "", + "This target hook should add to @var{clobbers} @code{STRING_CST} trees for\n\ +any hard regs the port wishes to automatically clobber for an asm.\n\ +It should return the result of the last @code{tree_cons} used to add a\n\ +clobber. The @var{outputs}, @var{inputs} and @var{clobber} lists are the\n\ +corresponding parameters to the asm and may be inspected to avoid\n\ +clobbering a register that is an input or output of the asm. You can use\n\ +@code{tree_overlaps_hard_reg_set}, declared in @file{tree.h}, to test\n\ +for overlap with regards to asm-declared registers.", tree, (tree outputs, tree inputs, tree clobbers), hook_tree_tree_tree_tree_3rd_identity) @@ -2001,7 +3390,9 @@ DEFHOOK the function is being declared as an int. */ DEFHOOK (dwarf_calling_convention, - "", + "Define this to enable the dwarf attribute @code{DW_AT_calling_convention} to\n\ +be emitted for each function. Instead of an integer return the enum\n\ +value for the @code{DW_CC_} tag.", int, (const_tree function), hook_int_const_tree_0) @@ -2014,7 +3405,19 @@ DEFHOOK to let the backend emit the call frame instructions. */ DEFHOOK (dwarf_handle_frame_unspec, - "", + "This target hook allows the backend to emit frame-related insns that\n\ +contain UNSPECs or UNSPEC_VOLATILEs. The DWARF 2 call frame debugging\n\ +info engine will invoke it on insns of the form\n\ +@smallexample\n\ +(set (reg) (unspec [@dots{}] UNSPEC_INDEX))\n\ +@end smallexample\n\ +and\n\ +@smallexample\n\ +(set (reg) (unspec_volatile [@dots{}] UNSPECV_INDEX)).\n\ +@end smallexample\n\ +to let the backend emit the call frame instructions. @var{label} is\n\ +the CFI label attached to the insn, @var{pattern} is the pattern of\n\ +the insn and @var{index} is @code{UNSPEC_INDEX} or @code{UNSPECV_INDEX}.", void, (const char *label, rtx pattern, int index), NULL) /* ??? Documenting this hook requires a GFDL license grant. */ @@ -2030,7 +3433,14 @@ DEFHOOK_UNDOC protection guard variable. The type of this DECL is ptr_type_node. */ DEFHOOK (stack_protect_guard, - "", + "This hook returns a @code{DECL} node for the external variable to use\n\ +for the stack protection guard. This variable is initialized by the\n\ +runtime to some random value and is used to initialize the guard value\n\ +that is placed at the top of the local stack frame. The type of this\n\ +variable must be @code{ptr_type_node}.\n\ +\n\ +The default version of this hook creates a variable called\n\ +@samp{__stack_chk_guard}, which is normally defined in @file{libgcc2.c}.", tree, (void), default_stack_protect_guard) @@ -2038,7 +3448,13 @@ DEFHOOK that is invoked when a check vs the guard variable fails. */ DEFHOOK (stack_protect_fail, - "", + "This hook returns a @code{CALL_EXPR} that alerts the runtime that the\n\ +stack protect guard variable has been modified. This expression should\n\ +involve a call to a @code{noreturn} function.\n\ +\n\ +The default version of this hook invokes a function called\n\ +@samp{__stack_chk_fail}, taking no arguments. This function is\n\ +normally defined in @file{libgcc2.c}.", tree, (void), default_external_stack_protect_fail) @@ -2046,7 +3462,16 @@ DEFHOOK otherwise it returns an error message. */ DEFHOOK (invalid_within_doloop, - "", + "\n\ +Take an instruction in @var{insn} and return NULL if it is valid within a\n\ +low-overhead loop, otherwise return a string explaining why doloop\n\ +could not be applied.\n\ +\n\ +Many targets use special registers for low-overhead looping. For any\n\ +instruction that clobbers these this function should return a string indicating\n\ +the reason why the doloop could not be applied.\n\ +By default, the RTL loop optimizer does not use a present doloop pattern for\n\ +loops containing function calls or branch on table instructions.", const char *, (const_rtx insn), default_invalid_within_doloop) @@ -2071,13 +3496,28 @@ DEFHOOK value. */ DEFHOOKPOD (const_anchor, - "", + "On some architectures it can take multiple instructions to synthesize\n\ +a constant. If there is another constant already in a register that\n\ +is close enough in value then it is preferable that the new constant\n\ +is computed from this register using immediate addition or\n\ +subtraction. We accomplish this through CSE. Besides the value of\n\ +the constant we also add a lower and an upper constant anchor to the\n\ +available expressions. These are then queried when encountering new\n\ +constants. The anchors are computed by rounding the constant up and\n\ +down to a multiple of the value of @code{TARGET_CONST_ANCHOR}.\n\ +@code{TARGET_CONST_ANCHOR} should be the maximum positive value\n\ +accepted by immediate-add plus one. We currently assume that the\n\ +value of @code{TARGET_CONST_ANCHOR} is a power of 2. For example, on\n\ +MIPS, where add-immediate takes a 16-bit signed value,\n\ +@code{TARGET_CONST_ANCHOR} is set to @samp{0x8000}. The default value\n\ +is zero, which disables this optimization.", unsigned HOST_WIDE_INT, 0) /* Defines, which target-dependent bits (upper 16) are used by port */ DEFHOOK (memmodel_check, - "", + "Validate target specific memory model mask bits. When NULL no target specific\n\ +memory model bits are allowed.", unsigned HOST_WIDE_INT, (unsigned HOST_WIDE_INT val), NULL) /* Defines an offset bitwise ored into shifted address to get corresponding @@ -2097,31 +3537,96 @@ HOOK_VECTOR (TARGET_CALLS, calls) DEFHOOK (promote_function_mode, - "", + "Like @code{PROMOTE_MODE}, but it is applied to outgoing function arguments or\n\ +function return values. The target hook should return the new mode\n\ +and possibly change @code{*@var{punsignedp}} if the promotion should\n\ +change signedness. This function is called only for scalar @emph{or\n\ +pointer} types.\n\ +\n\ +@var{for_return} allows to distinguish the promotion of arguments and\n\ +return values. If it is @code{1}, a return value is being promoted and\n\ +@code{TARGET_FUNCTION_VALUE} must perform the same promotions done here.\n\ +If it is @code{2}, the returned mode should be that of the register in\n\ +which an incoming parameter is copied, or the outgoing result is computed;\n\ +then the hook should return the same mode as @code{promote_mode}, though\n\ +the signedness may be different.\n\ +\n\ +@var{type} can be NULL when promoting function arguments of libcalls.\n\ +\n\ +The default is to not promote arguments and return values. You can\n\ +also define the hook to @code{default_promote_function_mode_always_promote}\n\ +if you would like to apply the same rules given by @code{PROMOTE_MODE}.", enum machine_mode, (const_tree type, enum machine_mode mode, int *punsignedp, const_tree funtype, int for_return), default_promote_function_mode) DEFHOOK (promote_prototypes, - "", + "This target hook returns @code{true} if an argument declared in a\n\ +prototype as an integral type smaller than @code{int} should actually be\n\ +passed as an @code{int}. In addition to avoiding errors in certain\n\ +cases of mismatch, it also makes for better code on certain machines.\n\ +The default is to not promote prototypes.", bool, (const_tree fntype), hook_bool_const_tree_false) DEFHOOK (struct_value_rtx, - "", + "This target hook should return the location of the structure value\n\ +address (normally a @code{mem} or @code{reg}), or 0 if the address is\n\ +passed as an ``invisible'' first argument. Note that @var{fndecl} may\n\ +be @code{NULL}, for libcalls. You do not need to define this target\n\ +hook if the address is always passed as an ``invisible'' first\n\ +argument.\n\ +\n\ +On some architectures the place where the structure value address\n\ +is found by the called function is not the same place that the\n\ +caller put it. This can be due to register windows, or it could\n\ +be because the function prologue moves it to a different place.\n\ +@var{incoming} is @code{1} or @code{2} when the location is needed in\n\ +the context of the called function, and @code{0} in the context of\n\ +the caller.\n\ +\n\ +If @var{incoming} is nonzero and the address is to be found on the\n\ +stack, return a @code{mem} which refers to the frame pointer. If\n\ +@var{incoming} is @code{2}, the result is being used to fetch the\n\ +structure value address at the beginning of a function. If you need\n\ +to emit adjusting code, you should do it at this point.", rtx, (tree fndecl, int incoming), hook_rtx_tree_int_null) DEFHOOK (return_in_memory, - "", + "This target hook should return a nonzero value to say to return the\n\ +function value in memory, just as large structures are always returned.\n\ +Here @var{type} will be the data type of the value, and @var{fntype}\n\ +will be the type of the function doing the returning, or @code{NULL} for\n\ +libcalls.\n\ +\n\ +Note that values of mode @code{BLKmode} must be explicitly handled\n\ +by this function. Also, the option @option{-fpcc-struct-return}\n\ +takes effect regardless of this macro. On most systems, it is\n\ +possible to leave the hook undefined; this causes a default\n\ +definition to be used, whose value is the constant 1 for @code{BLKmode}\n\ +values, and 0 otherwise.\n\ +\n\ +Do not use this hook to indicate that structures and unions should always\n\ +be returned in memory. You should instead use @code{DEFAULT_PCC_STRUCT_RETURN}\n\ +to indicate this.", bool, (const_tree type, const_tree fntype), default_return_in_memory) DEFHOOK (return_in_msb, - "", + "This hook should return true if values of type @var{type} are returned\n\ +at the most significant end of a register (in other words, if they are\n\ +padded at the least significant end). You can assume that @var{type}\n\ +is returned in a register; the caller is required to check this.\n\ +\n\ +Note that the register provided by @code{TARGET_FUNCTION_VALUE} must\n\ +be able to hold the complete return value. For example, if a 1-, 2-\n\ +or 3-byte structure is returned at the most significant end of a\n\ +4-byte register, @code{TARGET_FUNCTION_VALUE} should provide an\n\ +@code{SImode} rtx.", bool, (const_tree type), hook_bool_const_tree_false) @@ -2130,28 +3635,81 @@ DEFHOOK from __builtin_va_arg. */ DEFHOOK (pass_by_reference, - "", + "This target hook should return @code{true} if an argument at the\n\ +position indicated by @var{cum} should be passed by reference. This\n\ +predicate is queried after target independent reasons for being\n\ +passed by reference, such as @code{TREE_ADDRESSABLE (type)}.\n\ +\n\ +If the hook returns true, a copy of that argument is made in memory and a\n\ +pointer to the argument is passed instead of the argument itself.\n\ +The pointer is passed in whatever way is appropriate for passing a pointer\n\ +to that type.", bool, (cumulative_args_t cum, enum machine_mode mode, const_tree type, bool named), hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false) DEFHOOK (expand_builtin_saveregs, - "", + "If defined, this hook produces the machine-specific code for a call to\n\ +@code{__builtin_saveregs}. This code will be moved to the very\n\ +beginning of the function, before any parameter access are made. The\n\ +return value of this function should be an RTX that contains the value\n\ +to use as the return of @code{__builtin_saveregs}.", rtx, (void), default_expand_builtin_saveregs) /* Returns pretend_argument_size. */ DEFHOOK (setup_incoming_varargs, - "", + "This target hook offers an alternative to using\n\ +@code{__builtin_saveregs} and defining the hook\n\ +@code{TARGET_EXPAND_BUILTIN_SAVEREGS}. Use it to store the anonymous\n\ +register arguments into the stack so that all the arguments appear to\n\ +have been passed consecutively on the stack. Once this is done, you can\n\ +use the standard implementation of varargs that works for machines that\n\ +pass all their arguments on the stack.\n\ +\n\ +The argument @var{args_so_far} points to the @code{CUMULATIVE_ARGS} data\n\ +structure, containing the values that are obtained after processing the\n\ +named arguments. The arguments @var{mode} and @var{type} describe the\n\ +last named argument---its machine mode and its data type as a tree node.\n\ +\n\ +The target hook should do two things: first, push onto the stack all the\n\ +argument registers @emph{not} used for the named arguments, and second,\n\ +store the size of the data thus pushed into the @code{int}-valued\n\ +variable pointed to by @var{pretend_args_size}. The value that you\n\ +store here will serve as additional offset for setting up the stack\n\ +frame.\n\ +\n\ +Because you must generate code to push the anonymous arguments at\n\ +compile time without knowing their data types,\n\ +@code{TARGET_SETUP_INCOMING_VARARGS} is only useful on machines that\n\ +have just a single category of argument register and use it uniformly\n\ +for all data types.\n\ +\n\ +If the argument @var{second_time} is nonzero, it means that the\n\ +arguments of the function are being analyzed for the second time. This\n\ +happens for an inline function, which is not actually compiled until the\n\ +end of the source file. The hook @code{TARGET_SETUP_INCOMING_VARARGS} should\n\ +not generate any instructions in this case.", void, (cumulative_args_t args_so_far, enum machine_mode mode, tree type, int *pretend_args_size, int second_time), default_setup_incoming_varargs) DEFHOOK (strict_argument_naming, - "", + "Define this hook to return @code{true} if the location where a function\n\ +argument is passed depends on whether or not it is a named argument.\n\ +\n\ +This hook controls how the @var{named} argument to @code{TARGET_FUNCTION_ARG}\n\ +is set for varargs and stdarg functions. If this hook returns\n\ +@code{true}, the @var{named} argument is always true for named\n\ +arguments, and false for unnamed arguments. If it returns @code{false},\n\ +but @code{TARGET_PRETEND_OUTGOING_VARARGS_NAMED} returns @code{true},\n\ +then all arguments are treated as named. Otherwise, all named arguments\n\ +except the last are treated as named.\n\ +\n\ +You need not define this hook if it always returns @code{false}.", bool, (cumulative_args_t ca), hook_bool_CUMULATIVE_ARGS_false) @@ -2160,7 +3718,12 @@ DEFHOOK targetm.calls.strict_argument_naming(). */ DEFHOOK (pretend_outgoing_varargs_named, - "", + "If you need to conditionally change ABIs so that one works with\n\ +@code{TARGET_SETUP_INCOMING_VARARGS}, but the other works like neither\n\ +@code{TARGET_SETUP_INCOMING_VARARGS} nor @code{TARGET_STRICT_ARGUMENT_NAMING} was\n\ +defined, then define this hook to return @code{true} if\n\ +@code{TARGET_SETUP_INCOMING_VARARGS} is used, @code{false} otherwise.\n\ +Otherwise, you should not define this hook.", bool, (cumulative_args_t ca), default_pretend_outgoing_varargs_named) @@ -2168,7 +3731,16 @@ DEFHOOK should be passed as two scalars. */ DEFHOOK (split_complex_arg, - "", + "This hook should return true if parameter of type @var{type} are passed\n\ +as two scalar parameters. By default, GCC will attempt to pack complex\n\ +arguments into the target's word size. Some ABIs require complex arguments\n\ +to be split and treated as their individual components. For example, on\n\ +AIX64, complex floats should be passed in a pair of floating point\n\ +registers, even though a complex float would fit in one 64-bit floating\n\ +point register.\n\ +\n\ +The default value of this hook is @code{NULL}, which is treated as always\n\ +false.", bool, (const_tree type), NULL) /* Return true if type T, mode MODE, may not be passed in registers, @@ -2177,7 +3749,10 @@ DEFHOOK Need audit to verify that this is the case. */ DEFHOOK (must_pass_in_stack, - "", + "This target hook should return @code{true} if we should not pass @var{type}\n\ +solely in registers. The file @file{expr.h} defines a\n\ +definition that is usually appropriate, refer to @file{expr.h} for additional\n\ +documentation.", bool, (enum machine_mode mode, const_tree type), must_pass_in_stack_var_size_or_pad) @@ -2186,7 +3761,16 @@ DEFHOOK the caller. It is never called for TYPE requiring constructors. */ DEFHOOK (callee_copies, - "", + "The function argument described by the parameters to this hook is\n\ +known to be passed by reference. The hook should return true if the\n\ +function argument should be copied by the callee instead of copied\n\ +by the caller.\n\ +\n\ +For any argument for which the hook returns true, if it can be\n\ +determined that the argument is not modified, then a copy need\n\ +not be generated.\n\ +\n\ +The default version of this hook always returns false.", bool, (cumulative_args_t cum, enum machine_mode mode, const_tree type, bool named), hook_bool_CUMULATIVE_ARGS_mode_tree_bool_false) @@ -2196,7 +3780,22 @@ DEFHOOK in registers; the balance is therefore passed on the stack. */ DEFHOOK (arg_partial_bytes, - "", + "This target hook returns the number of bytes at the beginning of an\n\ +argument that must be put in registers. The value must be zero for\n\ +arguments that are passed entirely in registers or that are entirely\n\ +pushed on the stack.\n\ +\n\ +On some machines, certain arguments must be passed partially in\n\ +registers and partially in memory. On these machines, typically the\n\ +first few words of arguments are passed in registers, and the rest\n\ +on the stack. If a multi-word argument (a @code{double} or a\n\ +structure) crosses that boundary, its first few words must be passed\n\ +in registers and the rest must be pushed. This macro tells the\n\ +compiler when this occurs, and how many bytes should go in registers.\n\ +\n\ +@code{TARGET_FUNCTION_ARG} for these arguments should return the first\n\ +register to be used by the caller for this argument; likewise\n\ +@code{TARGET_FUNCTION_INCOMING_ARG}, for the called function.", int, (cumulative_args_t cum, enum machine_mode mode, tree type, bool named), hook_int_CUMULATIVE_ARGS_mode_tree_bool_0) @@ -2205,7 +3804,15 @@ DEFHOOK argument. */ DEFHOOK (function_arg_advance, - "", + "This hook updates the summarizer variable pointed to by @var{ca} to\n\ +advance past an argument in the argument list. The values @var{mode},\n\ +@var{type} and @var{named} describe that argument. Once this is done,\n\ +the variable @var{cum} is suitable for analyzing the @emph{following}\n\ +argument with @code{TARGET_FUNCTION_ARG}, etc.\n\ +\n\ +This hook need not do anything if the argument in question was passed\n\ +on the stack. The compiler knows how to track the amount of stack space\n\ +used for arguments without any special help.", void, (cumulative_args_t ca, enum machine_mode mode, const_tree type, bool named), default_function_arg_advance) @@ -2216,7 +3823,56 @@ DEFHOOK argument. */ DEFHOOK (function_arg, - "", + "Return an RTX indicating whether a function argument is passed in a\n\ +register and if so, which register.\n\ +\n\ +The arguments are @var{ca}, which summarizes all the previous\n\ +arguments; @var{mode}, the machine mode of the argument; @var{type},\n\ +the data type of the argument as a tree node or 0 if that is not known\n\ +(which happens for C support library functions); and @var{named},\n\ +which is @code{true} for an ordinary argument and @code{false} for\n\ +nameless arguments that correspond to @samp{@dots{}} in the called\n\ +function's prototype. @var{type} can be an incomplete type if a\n\ +syntax error has previously occurred.\n\ +\n\ +The return value is usually either a @code{reg} RTX for the hard\n\ +register in which to pass the argument, or zero to pass the argument\n\ +on the stack.\n\ +\n\ +The value of the expression can also be a @code{parallel} RTX@. This is\n\ +used when an argument is passed in multiple locations. The mode of the\n\ +@code{parallel} should be the mode of the entire argument. The\n\ +@code{parallel} holds any number of @code{expr_list} pairs; each one\n\ +describes where part of the argument is passed. In each\n\ +@code{expr_list} the first operand must be a @code{reg} RTX for the hard\n\ +register in which to pass this part of the argument, and the mode of the\n\ +register RTX indicates how large this part of the argument is. The\n\ +second operand of the @code{expr_list} is a @code{const_int} which gives\n\ +the offset in bytes into the entire argument of where this part starts.\n\ +As a special exception the first @code{expr_list} in the @code{parallel}\n\ +RTX may have a first operand of zero. This indicates that the entire\n\ +argument is also stored on the stack.\n\ +\n\ +The last time this hook is called, it is called with @code{MODE ==\n\ +VOIDmode}, and its result is passed to the @code{call} or @code{call_value}\n\ +pattern as operands 2 and 3 respectively.\n\ +\n\ +@cindex @file{stdarg.h} and register arguments\n\ +The usual way to make the ISO library @file{stdarg.h} work on a\n\ +machine where some arguments are usually passed in registers, is to\n\ +cause nameless arguments to be passed on the stack instead. This is\n\ +done by making @code{TARGET_FUNCTION_ARG} return 0 whenever\n\ +@var{named} is @code{false}.\n\ +\n\ +@cindex @code{TARGET_MUST_PASS_IN_STACK}, and @code{TARGET_FUNCTION_ARG}\n\ +@cindex @code{REG_PARM_STACK_SPACE}, and @code{TARGET_FUNCTION_ARG}\n\ +You may use the hook @code{targetm.calls.must_pass_in_stack}\n\ +in the definition of this macro to determine if this argument is of a\n\ +type that must be passed in the stack. If @code{REG_PARM_STACK_SPACE}\n\ +is not defined and @code{TARGET_FUNCTION_ARG} returns nonzero for such an\n\ +argument, the compiler will abort. If @code{REG_PARM_STACK_SPACE} is\n\ +defined, the argument will be computed in the stack and then loaded into\n\ +a register.", rtx, (cumulative_args_t ca, enum machine_mode mode, const_tree type, bool named), default_function_arg) @@ -2225,14 +3881,28 @@ DEFHOOK location where the argument will appear to the callee. */ DEFHOOK (function_incoming_arg, - "", + "Define this hook if the target machine has ``register windows'', so\n\ +that the register in which a function sees an arguments is not\n\ +necessarily the same as the one in which the caller passed the\n\ +argument.\n\ +\n\ +For such machines, @code{TARGET_FUNCTION_ARG} computes the register in\n\ +which the caller passes the value, and\n\ +@code{TARGET_FUNCTION_INCOMING_ARG} should be defined in a similar\n\ +fashion to tell the function being called where the arguments will\n\ +arrive.\n\ +\n\ +If @code{TARGET_FUNCTION_INCOMING_ARG} is not defined,\n\ +@code{TARGET_FUNCTION_ARG} serves both purposes.", rtx, (cumulative_args_t ca, enum machine_mode mode, const_tree type, bool named), default_function_incoming_arg) DEFHOOK (function_arg_boundary, - "", + "This hook returns the alignment boundary, in bits, of an argument\n\ +with the specified mode and type. The default hook returns\n\ +@code{PARM_BOUNDARY} for all arguments.", unsigned int, (enum machine_mode mode, const_tree type), default_function_arg_boundary) @@ -2249,7 +3919,9 @@ value.", is not allowed for this 'val' argument; NULL otherwise. */ DEFHOOK (invalid_arg_for_unprototyped_fn, - "", + "If defined, this macro returns the diagnostic message when it is\n\ +illegal to pass argument @var{val} to function @var{funcdecl}\n\ +with prototype @var{typelist}.", const char *, (const_tree typelist, const_tree funcdecl, const_tree val), hook_invalid_arg_for_unprototyped_fn) @@ -2257,7 +3929,47 @@ DEFHOOK specified by FN_DECL_OR_TYPE with a return type of RET_TYPE. */ DEFHOOK (function_value, - "", + "\n\ +Define this to return an RTX representing the place where a function\n\ +returns or receives a value of data type @var{ret_type}, a tree node\n\ +representing a data type. @var{fn_decl_or_type} is a tree node\n\ +representing @code{FUNCTION_DECL} or @code{FUNCTION_TYPE} of a\n\ +function being called. If @var{outgoing} is false, the hook should\n\ +compute the register in which the caller will see the return value.\n\ +Otherwise, the hook should return an RTX representing the place where\n\ +a function returns a value.\n\ +\n\ +On many machines, only @code{TYPE_MODE (@var{ret_type})} is relevant.\n\ +(Actually, on most machines, scalar values are returned in the same\n\ +place regardless of mode.) The value of the expression is usually a\n\ +@code{reg} RTX for the hard register where the return value is stored.\n\ +The value can also be a @code{parallel} RTX, if the return value is in\n\ +multiple places. See @code{TARGET_FUNCTION_ARG} for an explanation of the\n\ +@code{parallel} form. Note that the callee will populate every\n\ +location specified in the @code{parallel}, but if the first element of\n\ +the @code{parallel} contains the whole return value, callers will use\n\ +that element as the canonical location and ignore the others. The m68k\n\ +port uses this type of @code{parallel} to return pointers in both\n\ +@samp{%a0} (the canonical location) and @samp{%d0}.\n\ +\n\ +If @code{TARGET_PROMOTE_FUNCTION_RETURN} returns true, you must apply\n\ +the same promotion rules specified in @code{PROMOTE_MODE} if\n\ +@var{valtype} is a scalar type.\n\ +\n\ +If the precise function being called is known, @var{func} is a tree\n\ +node (@code{FUNCTION_DECL}) for it; otherwise, @var{func} is a null\n\ +pointer. This makes it possible to use a different value-returning\n\ +convention for specific functions when all their calls are\n\ +known.\n\ +\n\ +Some target machines have ``register windows'' so that the register in\n\ +which a function returns its value is not the same as the one in which\n\ +the caller sees the value. For such machines, you should return\n\ +different RTX depending on @var{outgoing}.\n\ +\n\ +@code{TARGET_FUNCTION_VALUE} is not used for return values with\n\ +aggregate data types, because these are returned in another way. See\n\ +@code{TARGET_STRUCT_VALUE_RTX} and related macros, below.", rtx, (const_tree ret_type, const_tree fn_decl_or_type, bool outgoing), default_function_value) @@ -2265,7 +3977,14 @@ DEFHOOK calling the function FN_NAME. */ DEFHOOK (libcall_value, - "", + "Define this hook if the back-end needs to know the name of the libcall\n\ +function in order to determine where the result should be returned.\n\ +\n\ +The mode of the result is given by @var{mode} and the name of the called\n\ +library function is given by @var{fun}. The hook should return an RTX\n\ +representing the place where the library function result will be returned.\n\ +\n\ +If this hook is not defined, then LIBCALL_VALUE will be used.", rtx, (enum machine_mode mode, const_rtx fun), default_libcall_value) @@ -2273,7 +3992,18 @@ DEFHOOK a function value as seen by the caller. */ DEFHOOK (function_value_regno_p, - "", + "A target hook that return @code{true} if @var{regno} is the number of a hard\n\ +register in which the values of called function may come back.\n\ +\n\ +A register whose use for returning values is limited to serving as the\n\ +second of a pair (for a value of type @code{double}, say) need not be\n\ +recognized by this target hook.\n\ +\n\ +If the machine has register windows, so that the caller and the called\n\ +function use different registers for the return value, this target hook\n\ +should recognize only the caller's register numbers.\n\ +\n\ +If this hook is not defined, then FUNCTION_VALUE_REGNO_P will be used.", bool, (const unsigned int regno), default_function_value_regno_p) @@ -2288,21 +4018,32 @@ DEFHOOK_UNDOC /* Update the current function stack boundary if needed. */ DEFHOOK (update_stack_boundary, - "", + "Define this macro to update the current function stack boundary if\n\ +necessary.", void, (void), NULL) /* Handle stack alignment and return an rtx for Dynamic Realign Argument Pointer if necessary. */ DEFHOOK (get_drap_rtx, - "", + "This hook should return an rtx for Dynamic Realign Argument Pointer (DRAP) if a\n\ +different argument pointer register is needed to access the function's\n\ +argument list due to stack realignment. Return @code{NULL} if no DRAP\n\ +is needed.", rtx, (void), NULL) /* Return true if all function parameters should be spilled to the stack. */ DEFHOOK (allocate_stack_slots_for_args, - "", + "When optimization is disabled, this hook indicates whether or not\n\ +arguments should be allocated to stack slots. Normally, GCC allocates\n\ +stacks slots for arguments when not optimizing in order to make\n\ +debugging easier. However, when a function is declared with\n\ +@code{__attribute__((naked))}, there is no stack frame, and the compiler\n\ +cannot safely move arguments from the registers in which they are passed\n\ +to the stack. Therefore, this hook should return true in general, but\n\ +false for naked functions. The default implementation always returns true.", bool, (void), hook_bool_void_true) @@ -2310,7 +4051,25 @@ DEFHOOK then it should be for the callee; otherwise for the caller. */ DEFHOOK (static_chain, - "", + "This hook replaces the use of @code{STATIC_CHAIN_REGNUM} et al for\n\ +targets that may use different static chain locations for different\n\ +nested functions. This may be required if the target has function\n\ +attributes that affect the calling conventions of the function and\n\ +those calling conventions use different static chain locations.\n\ +\n\ +The default version of this hook uses @code{STATIC_CHAIN_REGNUM} et al.\n\ +\n\ +If the static chain is passed in memory, this hook should be used to\n\ +provide rtx giving @code{mem} expressions that denote where they are stored.\n\ +Often the @code{mem} expression as seen by the caller will be at an offset\n\ +from the stack pointer and the @code{mem} expression as seen by the callee\n\ +will be at an offset from the frame pointer.\n\ +@findex stack_pointer_rtx\n\ +@findex frame_pointer_rtx\n\ +@findex arg_pointer_rtx\n\ +The variables @code{stack_pointer_rtx}, @code{frame_pointer_rtx}, and\n\ +@code{arg_pointer_rtx} will have been initialized and should be used\n\ +to refer to those items.", rtx, (const_tree fndecl, bool incoming_p), default_static_chain) @@ -2318,14 +4077,35 @@ DEFHOOK static chain value of CHAIN. */ DEFHOOK (trampoline_init, - "", + "This hook is called to initialize a trampoline.\n\ +@var{m_tramp} is an RTX for the memory block for the trampoline; @var{fndecl}\n\ +is the @code{FUNCTION_DECL} for the nested function; @var{static_chain} is an\n\ +RTX for the static chain value that should be passed to the function\n\ +when it is called.\n\ +\n\ +If the target defines @code{TARGET_ASM_TRAMPOLINE_TEMPLATE}, then the\n\ +first thing this hook should do is emit a block move into @var{m_tramp}\n\ +from the memory block returned by @code{assemble_trampoline_template}.\n\ +Note that the block move need only cover the constant parts of the\n\ +trampoline. If the target isolates the variable parts of the trampoline\n\ +to the end, not all @code{TRAMPOLINE_SIZE} bytes need be copied.\n\ +\n\ +If the target requires any other actions, such as flushing caches or\n\ +enabling stack execution, these actions should be performed after\n\ +initializing the trampoline proper.", void, (rtx m_tramp, tree fndecl, rtx static_chain), default_trampoline_init) /* Adjust the address of the trampoline in a target-specific way. */ DEFHOOK (trampoline_adjust_address, - "", + "This hook should perform any machine-specific adjustment in\n\ +the address of the trampoline. Its argument contains the address of the\n\ +memory block that was passed to @code{TARGET_TRAMPOLINE_INIT}. In case\n\ +the address to be used for a function call should be different from the\n\ +address at which the template was stored, the different address should\n\ +be returned; otherwise @var{addr} should be returned unchanged.\n\ +If this hook is not defined, @var{addr} will be used for function calls.", rtx, (rtx addr), NULL) /* Return the number of bytes of its own arguments that a function @@ -2334,7 +4114,41 @@ DEFHOOK /* ??? tm.texi has no types for the parameters. */ DEFHOOK (return_pops_args, - "", + "This target hook returns the number of bytes of its own arguments that\n\ +a function pops on returning, or 0 if the function pops no arguments\n\ +and the caller must therefore pop them all after the function returns.\n\ +\n\ +@var{fundecl} is a C variable whose value is a tree node that describes\n\ +the function in question. Normally it is a node of type\n\ +@code{FUNCTION_DECL} that describes the declaration of the function.\n\ +From this you can obtain the @code{DECL_ATTRIBUTES} of the function.\n\ +\n\ +@var{funtype} is a C variable whose value is a tree node that\n\ +describes the function in question. Normally it is a node of type\n\ +@code{FUNCTION_TYPE} that describes the data type of the function.\n\ +From this it is possible to obtain the data types of the value and\n\ +arguments (if known).\n\ +\n\ +When a call to a library function is being considered, @var{fundecl}\n\ +will contain an identifier node for the library function. Thus, if\n\ +you need to distinguish among various library functions, you can do so\n\ +by their names. Note that ``library function'' in this context means\n\ +a function used to perform arithmetic, whose name is known specially\n\ +in the compiler and was not mentioned in the C code being compiled.\n\ +\n\ +@var{size} is the number of bytes of arguments passed on the\n\ +stack. If a variable number of bytes is passed, it is zero, and\n\ +argument popping will always be the responsibility of the calling function.\n\ +\n\ +On the VAX, all functions always pop their arguments, so the definition\n\ +of this macro is @var{size}. On the 68000, using the standard\n\ +calling convention, no functions pop their arguments, so the value of\n\ +the macro is always 0 in this case. But an alternative calling\n\ +convention is available in which functions that take a fixed number of\n\ +arguments pop them but other functions (such as @code{printf}) pop\n\ +nothing (the caller pops all). When this convention is in use,\n\ +@var{funtype} is examined to determine whether a function takes a fixed\n\ +number of arguments.", int, (tree fundecl, tree funtype, int size), default_return_pops_args) @@ -2364,7 +4178,9 @@ HOOK_VECTOR_END (calls) to TOTYPE is not allowed, NULL otherwise. */ DEFHOOK (invalid_conversion, - "", + "If defined, this macro returns the diagnostic message when it is\n\ +invalid to convert from @var{fromtype} to @var{totype}, or @code{NULL}\n\ +if validity should be determined by the front end.", const char *, (const_tree fromtype, const_tree totype), hook_constcharptr_const_tree_const_tree_null) @@ -2372,7 +4188,10 @@ DEFHOOK not permitted on TYPE, NULL otherwise. */ DEFHOOK (invalid_unary_op, - "", + "If defined, this macro returns the diagnostic message when it is\n\ +invalid to apply operation @var{op} (where unary plus is denoted by\n\ +@code{CONVERT_EXPR}) to an operand of type @var{type}, or @code{NULL}\n\ +if validity should be determined by the front end.", const char *, (int op, const_tree type), hook_constcharptr_int_const_tree_null) @@ -2380,7 +4199,10 @@ DEFHOOK is not permitted on TYPE1 and TYPE2, NULL otherwise. */ DEFHOOK (invalid_binary_op, - "", + "If defined, this macro returns the diagnostic message when it is\n\ +invalid to apply operation @var{op} to operands of types @var{type1}\n\ +and @var{type2}, or @code{NULL} if validity should be determined by\n\ +the front end.", const char *, (int op, const_tree type1, const_tree type2), hook_constcharptr_int_const_tree_const_tree_null) @@ -2388,7 +4210,10 @@ DEFHOOK function parameter type, NULL otherwise. */ DEFHOOK (invalid_parameter_type, - "", + "If defined, this macro returns the diagnostic message when it is\n\ +invalid for functions to include parameters of type @var{type},\n\ +or @code{NULL} if validity should be determined by\n\ +the front end. This is currently used only by the C and C++ front ends.", const char *, (const_tree type), hook_constcharptr_const_tree_null) @@ -2396,7 +4221,10 @@ DEFHOOK function return type, NULL otherwise. */ DEFHOOK (invalid_return_type, - "", + "If defined, this macro returns the diagnostic message when it is\n\ +invalid for functions to have return type @var{type},\n\ +or @code{NULL} if validity should be determined by\n\ +the front end. This is currently used only by the C and C++ front ends.", const char *, (const_tree type), hook_constcharptr_const_tree_null) @@ -2405,7 +4233,12 @@ DEFHOOK or NULL_TREE otherwise. */ DEFHOOK (promoted_type, - "", + "If defined, this target hook returns the type to which values of\n\ +@var{type} should be promoted when they appear in expressions,\n\ +analogous to the integer promotions, or @code{NULL_TREE} to use the\n\ +front end's normal promotion rules. This hook is useful when there are\n\ +target-specific types with special promotion rules.\n\ +This is currently used only by the C and C++ front ends.", tree, (const_tree type), hook_tree_const_tree_null) @@ -2414,7 +4247,12 @@ DEFHOOK the standard conversion rules. */ DEFHOOK (convert_to_type, - "", + "If defined, this hook returns the result of converting @var{expr} to\n\ +@var{type}. It should return the converted expression,\n\ +or @code{NULL_TREE} to apply the front end's normal conversion rules.\n\ +This hook is useful when there are target-specific types with special\n\ +conversion rules.\n\ +This is currently used only by the C and C++ front ends.", tree, (tree type, tree expr), hook_tree_tree_tree_null) @@ -2496,14 +4334,104 @@ DEFHOOK be accessed using BLKmode. */ DEFHOOK (member_type_forces_blk, - "", + "Return true if a structure, union or array containing @var{field} should\n\ +be accessed using @code{BLKMODE}.\n\ +\n\ +If @var{field} is the only field in the structure, @var{mode} is its\n\ +mode, otherwise @var{mode} is VOIDmode. @var{mode} is provided in the\n\ +case where structures of one field would require the structure's mode to\n\ +retain the field's mode.\n\ +\n\ +Normally, this is not needed.", bool, (const_tree field, enum machine_mode mode), default_member_type_forces_blk) /* Return the class for a secondary reload, and fill in extra information. */ DEFHOOK (secondary_reload, - "", + "Many machines have some registers that cannot be copied directly to or\n\ +from memory or even from other types of registers. An example is the\n\ +@samp{MQ} register, which on most machines, can only be copied to or\n\ +from general registers, but not memory. Below, we shall be using the\n\ +term 'intermediate register' when a move operation cannot be performed\n\ +directly, but has to be done by copying the source into the intermediate\n\ +register first, and then copying the intermediate register to the\n\ +destination. An intermediate register always has the same mode as\n\ +source and destination. Since it holds the actual value being copied,\n\ +reload might apply optimizations to re-use an intermediate register\n\ +and eliding the copy from the source when it can determine that the\n\ +intermediate register still holds the required value.\n\ +\n\ +Another kind of secondary reload is required on some machines which\n\ +allow copying all registers to and from memory, but require a scratch\n\ +register for stores to some memory locations (e.g., those with symbolic\n\ +address on the RT, and those with certain symbolic address on the SPARC\n\ +when compiling PIC)@. Scratch registers need not have the same mode\n\ +as the value being copied, and usually hold a different value than\n\ +that being copied. Special patterns in the md file are needed to\n\ +describe how the copy is performed with the help of the scratch register;\n\ +these patterns also describe the number, register class(es) and mode(s)\n\ +of the scratch register(s).\n\ +\n\ +In some cases, both an intermediate and a scratch register are required.\n\ +\n\ +For input reloads, this target hook is called with nonzero @var{in_p},\n\ +and @var{x} is an rtx that needs to be copied to a register of class\n\ +@var{reload_class} in @var{reload_mode}. For output reloads, this target\n\ +hook is called with zero @var{in_p}, and a register of class @var{reload_class}\n\ +needs to be copied to rtx @var{x} in @var{reload_mode}.\n\ +\n\ +If copying a register of @var{reload_class} from/to @var{x} requires\n\ +an intermediate register, the hook @code{secondary_reload} should\n\ +return the register class required for this intermediate register.\n\ +If no intermediate register is required, it should return NO_REGS.\n\ +If more than one intermediate register is required, describe the one\n\ +that is closest in the copy chain to the reload register.\n\ +\n\ +If scratch registers are needed, you also have to describe how to\n\ +perform the copy from/to the reload register to/from this\n\ +closest intermediate register. Or if no intermediate register is\n\ +required, but still a scratch register is needed, describe the\n\ +copy from/to the reload register to/from the reload operand @var{x}.\n\ +\n\ +You do this by setting @code{sri->icode} to the instruction code of a pattern\n\ +in the md file which performs the move. Operands 0 and 1 are the output\n\ +and input of this copy, respectively. Operands from operand 2 onward are\n\ +for scratch operands. These scratch operands must have a mode, and a\n\ +single-register-class\n\ +@c [later: or memory]\n\ +output constraint.\n\ +\n\ +When an intermediate register is used, the @code{secondary_reload}\n\ +hook will be called again to determine how to copy the intermediate\n\ +register to/from the reload operand @var{x}, so your hook must also\n\ +have code to handle the register class of the intermediate operand.\n\ +\n\ +@c [For later: maybe we'll allow multi-alternative reload patterns -\n\ +@c the port maintainer could name a mov<mode> pattern that has clobbers -\n\ +@c and match the constraints of input and output to determine the required\n\ +@c alternative. A restriction would be that constraints used to match\n\ +@c against reloads registers would have to be written as register class\n\ +@c constraints, or we need a new target macro / hook that tells us if an\n\ +@c arbitrary constraint can match an unknown register of a given class.\n\ +@c Such a macro / hook would also be useful in other places.]\n\ +\n\ +\n\ +@var{x} might be a pseudo-register or a @code{subreg} of a\n\ +pseudo-register, which could either be in a hard register or in memory.\n\ +Use @code{true_regnum} to find out; it will return @minus{}1 if the pseudo is\n\ +in memory and the hard register number if it is in a register.\n\ +\n\ +Scratch operands in memory (constraint @code{\"=m\"} / @code{\"=&m\"}) are\n\ +currently not supported. For the time being, you will have to continue\n\ +to use @code{SECONDARY_MEMORY_NEEDED} for that purpose.\n\ +\n\ +@code{copy_cost} also uses this target hook to find out how values are\n\ +copied. If you want it to include some extra cost for the need to allocate\n\ +(a) scratch register(s), set @code{sri->extra_cost} to the additional cost.\n\ +Or if two dependent moves are supposed to have a lower cost than the sum\n\ +of the individual moves due to expected fortuitous scheduling and/or special\n\ +forwarding logic, you can set @code{sri->extra_cost} to a negative amount.", reg_class_t, (bool in_p, rtx x, reg_class_t reload_class, enum machine_mode reload_mode, secondary_reload_info *sri), @@ -2513,7 +4441,37 @@ DEFHOOK return the class of reg to actually use. */ DEFHOOK (preferred_reload_class, - "", + "A target hook that places additional restrictions on the register class\n\ +to use when it is necessary to copy value @var{x} into a register in class\n\ +@var{rclass}. The value is a register class; perhaps @var{rclass}, or perhaps\n\ +another, smaller class.\n\ +\n\ +The default version of this hook always returns value of @code{rclass} argument.\n\ +\n\ +Sometimes returning a more restrictive class makes better code. For\n\ +example, on the 68000, when @var{x} is an integer constant that is in range\n\ +for a @samp{moveq} instruction, the value of this macro is always\n\ +@code{DATA_REGS} as long as @var{rclass} includes the data registers.\n\ +Requiring a data register guarantees that a @samp{moveq} will be used.\n\ +\n\ +One case where @code{TARGET_PREFERRED_RELOAD_CLASS} must not return\n\ +@var{rclass} is if @var{x} is a legitimate constant which cannot be\n\ +loaded into some register class. By returning @code{NO_REGS} you can\n\ +force @var{x} into a memory location. For example, rs6000 can load\n\ +immediate values into general-purpose registers, but does not have an\n\ +instruction for loading an immediate value into a floating-point\n\ +register, so @code{TARGET_PREFERRED_RELOAD_CLASS} returns @code{NO_REGS} when\n\ +@var{x} is a floating-point constant. If the constant can't be loaded\n\ +into any kind of register, code generation will be better if\n\ +@code{TARGET_LEGITIMATE_CONSTANT_P} makes the constant illegitimate instead\n\ +of using @code{TARGET_PREFERRED_RELOAD_CLASS}.\n\ +\n\ +If an insn has pseudos in it after register allocation, reload will go\n\ +through the alternatives and call repeatedly @code{TARGET_PREFERRED_RELOAD_CLASS}\n\ +to find the best one. Returning @code{NO_REGS}, in this case, makes\n\ +reload add a @code{!} in front of the constraint: the x86 back-end uses\n\ +this feature to discourage usage of 387 registers when math is done in\n\ +the SSE registers (and vice versa).", reg_class_t, (rtx x, reg_class_t rclass), default_preferred_reload_class) @@ -2522,14 +4480,33 @@ DEFHOOK input reloads. */ DEFHOOK (preferred_output_reload_class, - "", + "Like @code{TARGET_PREFERRED_RELOAD_CLASS}, but for output reloads instead of\n\ +input reloads.\n\ +\n\ +The default version of this hook always returns value of @code{rclass}\n\ +argument.\n\ +\n\ +You can also use @code{TARGET_PREFERRED_OUTPUT_RELOAD_CLASS} to discourage\n\ +reload from using some alternatives, like @code{TARGET_PREFERRED_RELOAD_CLASS}.", reg_class_t, (rtx x, reg_class_t rclass), default_preferred_output_reload_class) DEFHOOK (class_likely_spilled_p, - "", + "A target hook which returns @code{true} if pseudos that have been assigned\n\ +to registers of class @var{rclass} would likely be spilled because\n\ +registers of @var{rclass} are needed for spill registers.\n\ +\n\ +The default version of this target hook returns @code{true} if @var{rclass}\n\ +has exactly one register and @code{false} otherwise. On most machines, this\n\ +default should be used. For generally register-starved machines, such as\n\ +i386, or machines with right register constraints, such as SH, this hook\n\ +can be used to avoid excessive spilling.\n\ +\n\ +This hook is also used by some of the global intra-procedural code\n\ +transformations to throtle code motion, to avoid increasing register\n\ +pressure.", bool, (reg_class_t rclass), default_class_likely_spilled_p) @@ -2537,7 +4514,20 @@ DEFHOOK needed to represent mode MODE in a register of class RCLASS. */ DEFHOOK (class_max_nregs, - "", + "A target hook returns the maximum number of consecutive registers\n\ +of class @var{rclass} needed to hold a value of mode @var{mode}.\n\ +\n\ +This is closely related to the macro @code{HARD_REGNO_NREGS}. In fact,\n\ +the value returned by @code{TARGET_CLASS_MAX_NREGS (@var{rclass},\n\ +@var{mode})} target hook should be the maximum value of\n\ +@code{HARD_REGNO_NREGS (@var{regno}, @var{mode})} for all @var{regno}\n\ +values in the class @var{rclass}.\n\ +\n\ +This target hook helps control the handling of multiple-word values\n\ +in the reload pass.\n\ +\n\ +The default version of this target hook returns the size of @var{mode}\n\ +in words.", unsigned char, (reg_class_t rclass, enum machine_mode mode), default_class_max_nregs) @@ -2560,7 +4550,12 @@ DEFHOOK processing while initializing for variable expansion. */ DEFHOOK (expand_to_rtl_hook, - "", + "This hook is called just before expansion into rtl, allowing the target\n\ +to perform additional initializations or analysis before the expansion.\n\ +For example, the rs6000 port uses it to allocate a scratch stack slot\n\ +for use in copying SDmode values between memory and floating point\n\ +registers whenever the function being expanded has any SDmode\n\ +usage.", void, (void), hook_void_void) @@ -2569,7 +4564,8 @@ DEFHOOK but will be later. */ DEFHOOK (instantiate_decls, - "", + "This hook allows the backend to perform additional instantiations on rtl\n\ +that are not actually in any insns yet, but will be later.", void, (void), hook_void_void) @@ -2577,7 +4573,13 @@ DEFHOOK in peephole2. */ DEFHOOK (hard_regno_scratch_ok, - "", + "This target hook should return @code{true} if it is OK to use a hard register\n\ +@var{regno} as scratch reg in peephole2.\n\ +\n\ +One common use of this macro is to prevent using of a register that\n\ +is not saved by a prologue in an interrupt handler.\n\ +\n\ +The default version of this hook always returns @code{true}.", bool, (unsigned int regno), default_hard_regno_scratch_ok) @@ -2585,14 +4587,38 @@ DEFHOOK use a jump-table instead of a tree of conditional branches. */ DEFHOOK (case_values_threshold, - "", + "This function return the smallest number of different values for which it\n\ +is best to use a jump-table instead of a tree of conditional branches.\n\ +The default is four for machines with a @code{casesi} instruction and\n\ +five otherwise. This is best for most machines.", unsigned int, (void), default_case_values_threshold) /* Retutn true if a function must have and use a frame pointer. */ DEFHOOK (frame_pointer_required, - "", + "This target hook should return @code{true} if a function must have and use\n\ +a frame pointer. This target hook is called in the reload pass. If its return\n\ +value is @code{true} the function will have a frame pointer.\n\ +\n\ +This target hook can in principle examine the current function and decide\n\ +according to the facts, but on most machines the constant @code{false} or the\n\ +constant @code{true} suffices. Use @code{false} when the machine allows code\n\ +to be generated with no frame pointer, and doing so saves some time or space.\n\ +Use @code{true} when there is no possible advantage to avoiding a frame\n\ +pointer.\n\ +\n\ +In certain cases, the compiler does not know how to produce valid code\n\ +without a frame pointer. The compiler recognizes those cases and\n\ +automatically gives the function a frame pointer regardless of what\n\ +@code{TARGET_FRAME_POINTER_REQUIRED} returns. You don't need to worry about\n\ +them.\n\ +\n\ +In a function that does not require a frame pointer, the frame pointer\n\ +register can be allocated for ordinary usage, unless you mark it as a\n\ +fixed register. See @code{FIXED_REGISTERS} for more information.\n\ +\n\ +Default return value is @code{false}.", bool, (void), hook_bool_void_false) @@ -2600,7 +4626,14 @@ DEFHOOK from-reg with register number to-reg. */ DEFHOOK (can_eliminate, - "", + "This target hook should returns @code{true} if the compiler is allowed to\n\ +try to replace register number @var{from_reg} with register number\n\ +@var{to_reg}. This target hook need only be defined if @code{ELIMINABLE_REGS}\n\ +is defined, and will usually be @code{true}, since most of the cases\n\ +preventing register elimination are things that the compiler already\n\ +knows about.\n\ +\n\ +Default return value is @code{true}.", bool, (const int from_reg, const int to_reg), hook_bool_const_int_const_int_true) @@ -2609,7 +4642,35 @@ DEFHOOK target. */ DEFHOOK (conditional_register_usage, - "", + "This hook may conditionally modify five variables\n\ +@code{fixed_regs}, @code{call_used_regs}, @code{global_regs},\n\ +@code{reg_names}, and @code{reg_class_contents}, to take into account\n\ +any dependence of these register sets on target flags. The first three\n\ +of these are of type @code{char []} (interpreted as Boolean vectors).\n\ +@code{global_regs} is a @code{const char *[]}, and\n\ +@code{reg_class_contents} is a @code{HARD_REG_SET}. Before the macro is\n\ +called, @code{fixed_regs}, @code{call_used_regs},\n\ +@code{reg_class_contents}, and @code{reg_names} have been initialized\n\ +from @code{FIXED_REGISTERS}, @code{CALL_USED_REGISTERS},\n\ +@code{REG_CLASS_CONTENTS}, and @code{REGISTER_NAMES}, respectively.\n\ +@code{global_regs} has been cleared, and any @option{-ffixed-@var{reg}},\n\ +@option{-fcall-used-@var{reg}} and @option{-fcall-saved-@var{reg}}\n\ +command options have been applied.\n\ +\n\ +@cindex disabling certain registers\n\ +@cindex controlling register usage\n\ +If the usage of an entire class of registers depends on the target\n\ +flags, you may indicate this to GCC by using this macro to modify\n\ +@code{fixed_regs} and @code{call_used_regs} to 1 for each of the\n\ +registers in the classes which should not be used by GCC@. Also define\n\ +the macro @code{REG_CLASS_FROM_LETTER} / @code{REG_CLASS_FROM_CONSTRAINT}\n\ +to return @code{NO_REGS} if it\n\ +is called with a letter for a class that shouldn't be used.\n\ +\n\ +(However, if this class is not included in @code{GENERAL_REGS} and all\n\ +of the insn patterns whose constraints permit this class are\n\ +controlled by target switches, then GCC will automatically avoid using\n\ +these registers when the target switches are opposed to them.)", void, (void), hook_void_void) @@ -2636,28 +4697,37 @@ HOOK_VECTOR (TARGET_CXX, cxx) /* Return the integer type used for guard variables. */ DEFHOOK (guard_type, - "", + "Define this hook to override the integer type used for guard variables.\n\ +These are used to implement one-time construction of static objects. The\n\ +default is long_long_integer_type_node.", tree, (void), default_cxx_guard_type) /* Return true if only the low bit of the guard should be tested. */ DEFHOOK (guard_mask_bit, - "", + "This hook determines how guard variables are used. It should return\n\ +@code{false} (the default) if the first byte should be used. A return value of\n\ +@code{true} indicates that only the least significant bit should be used.", bool, (void), hook_bool_void_false) /* Returns the size of the array cookie for an array of type. */ DEFHOOK (get_cookie_size, - "", + "This hook returns the size of the cookie to use when allocating an array\n\ +whose elements have the indicated @var{type}. Assumes that it is already\n\ +known that a cookie is needed. The default is\n\ +@code{max(sizeof (size_t), alignof(type))}, as defined in section 2.7 of the\n\ +IA64/Generic C++ ABI@.", tree, (tree type), default_cxx_get_cookie_size) /* Returns true if the element size should be stored in the array cookie. */ DEFHOOK (cookie_has_size, - "", + "This hook should return @code{true} if the element size should be stored in\n\ +array cookies. The default is to return @code{false}.", bool, (void), hook_bool_void_false) @@ -2665,13 +4735,20 @@ DEFHOOK deciding if a class should be exported or imported. */ DEFHOOK (import_export_class, - "", + "If defined by a backend this hook allows the decision made to export\n\ +class @var{type} to be overruled. Upon entry @var{import_export}\n\ +will contain 1 if the class is going to be exported, @minus{}1 if it is going\n\ +to be imported and 0 otherwise. This function should return the\n\ +modified value and perform any other actions necessary to support the\n\ +backend's targeted operating system.", int, (tree type, int import_export), NULL) /* Returns true if constructors and destructors return "this". */ DEFHOOK (cdtor_returns_this, - "", + "This hook should return @code{true} if constructors and destructors return\n\ +the address of the object created/destroyed. The default is to return\n\ +@code{false}.", bool, (void), hook_bool_void_false) @@ -2680,7 +4757,13 @@ DEFHOOK itself. Returning true is the behavior required by the Itanium C++ ABI. */ DEFHOOK (key_method_may_be_inline, - "", + "This hook returns true if the key method for a class (i.e., the method\n\ +which, if defined in the current translation unit, causes the virtual\n\ +table to be emitted) may be an inline function. Under the standard\n\ +Itanium C++ ABI the key method may be an inline function so long as\n\ +the function is not declared inline in the class definition. Under\n\ +some variants of the ABI, an inline function can never be the key\n\ +method. The default is to return @code{true}.", bool, (void), hook_bool_void_true) @@ -2702,7 +4785,11 @@ DEFHOOK only one translation unit will not be COMDAT. */ DEFHOOK (class_data_always_comdat, - "", + "This hook returns true (the default) if virtual tables and other\n\ +similar implicit class data objects are always COMDAT if they have\n\ +external linkage. If this hook returns false, then class data for\n\ +classes whose virtual table will be emitted in only one translation\n\ +unit will not be COMDAT.", bool, (void), hook_bool_void_true) @@ -2711,7 +4798,9 @@ DEFHOOK false if it should not be COMDAT. */ DEFHOOK (library_rtti_comdat, - "", + "This hook returns true (the default) if the RTTI information for\n\ +the basic types which is defined in the C++ runtime should always\n\ +be COMDAT, false if it should not be COMDAT.", bool, (void), hook_bool_void_true) @@ -2719,7 +4808,9 @@ DEFHOOK destructors. */ DEFHOOK (use_aeabi_atexit, - "", + "This hook returns true if @code{__aeabi_atexit} (as defined by the ARM EABI)\n\ +should be used to register static destructors when @option{-fuse-cxa-atexit}\n\ +is in effect. The default is to return false to use @code{__cxa_atexit}.", bool, (void), hook_bool_void_false) @@ -2727,7 +4818,11 @@ DEFHOOK __cxa_atexit to register static destructors. */ DEFHOOK (use_atexit_for_cxa_atexit, - "", + "This hook returns true if the target @code{atexit} function can be used\n\ +in the same manner as @code{__cxa_atexit} to register C++ static\n\ +destructors. This requires that @code{atexit}-registered functions in\n\ +shared libraries are run in the correct order when the libraries are\n\ +unloaded. The default is to return false.", bool, (void), hook_bool_void_false) @@ -2755,47 +4850,66 @@ HOOK_VECTOR (TARGET_EMUTLS, emutls) /* Name of the address and common functions. */ DEFHOOKPOD (get_address, - "", + "Contains the name of the helper function that uses a TLS control\n\ +object to locate a TLS instance. The default causes libgcc's\n\ +emulated TLS helper function to be used.", const char *, "__builtin___emutls_get_address") DEFHOOKPOD (register_common, - "", + "Contains the name of the helper function that should be used at\n\ +program startup to register TLS objects that are implicitly\n\ +initialized to zero. If this is @code{NULL}, all TLS objects will\n\ +have explicit initializers. The default causes libgcc's emulated TLS\n\ +registration function to be used.", const char *, "__builtin___emutls_register_common") /* Prefixes for proxy variable and template. */ DEFHOOKPOD (var_section, - "", + "Contains the name of the section in which TLS control variables should\n\ +be placed. The default of @code{NULL} allows these to be placed in\n\ +any section.", const char *, NULL) DEFHOOKPOD (tmpl_section, - "", + "Contains the name of the section in which TLS initializers should be\n\ +placed. The default of @code{NULL} allows these to be placed in any\n\ +section.", const char *, NULL) /* Prefixes for proxy variable and template. */ DEFHOOKPOD (var_prefix, - "", + "Contains the prefix to be prepended to TLS control variable names.\n\ +The default of @code{NULL} uses a target-specific prefix.", const char *, NULL) DEFHOOKPOD (tmpl_prefix, - "", + "Contains the prefix to be prepended to TLS initializer objects. The\n\ +default of @code{NULL} uses a target-specific prefix.", const char *, NULL) /* Function to generate field definitions of the proxy variable. */ DEFHOOK (var_fields, - "", + "Specifies a function that generates the FIELD_DECLs for a TLS control\n\ +object type. @var{type} is the RECORD_TYPE the fields are for and\n\ +@var{name} should be filled with the structure tag, if the default of\n\ +@code{__emutls_object} is unsuitable. The default creates a type suitable\n\ +for libgcc's emulated TLS function.", tree, (tree type, tree *name), default_emutls_var_fields) /* Function to initialize a proxy variable. */ DEFHOOK (var_init, - "", + "Specifies a function that generates the CONSTRUCTOR to initialize a\n\ +TLS control object. @var{var} is the TLS control object, @var{decl}\n\ +is the TLS object and @var{tmpl_addr} is the address of the\n\ +initializer. The default initializes libgcc's emulated TLS control object.", tree, (tree var, tree decl, tree tmpl_addr), default_emutls_var_init) @@ -2803,13 +4917,16 @@ DEFHOOK proxy variable. */ DEFHOOKPOD (var_align_fixed, - "", + "Specifies whether the alignment of TLS control variable objects is\n\ +fixed and should not be increased as some backends may do to optimize\n\ +single objects. The default is false.", bool, false) /* Whether we can emit debug information for TLS vars. */ DEFHOOKPOD (debug_form_tls_address, - "", + "Specifies whether a DWARF @code{DW_OP_form_tls_address} location descriptor\n\ +may be used to describe emulated TLS control objects.", bool, false) HOOK_VECTOR_END (emutls) @@ -2823,28 +4940,43 @@ HOOK_VECTOR (TARGET_OPTION_HOOKS, target_option_hooks) DECL_FUNCTION_SPECIFIC_TARGET in the function decl node. */ DEFHOOK (valid_attribute_p, - "", + "This hook is called to parse @code{attribute(target(\"...\"))}, which\n\ +allows setting target-specific options on individual functions.\n\ +These function-specific options may differ\n\ +from the options specified on the command line. The hook should return\n\ +@code{true} if the options are valid.\n\ +\n\ +The hook should set the @code{DECL_FUNCTION_SPECIFIC_TARGET} field in\n\ +the function declaration to hold a pointer to a target-specific\n\ +@code{struct cl_target_option} structure.", bool, (tree fndecl, tree name, tree args, int flags), default_target_option_valid_attribute_p) /* Function to save any extra target state in the target options structure. */ DEFHOOK (save, - "", + "This hook is called to save any additional target-specific information\n\ +in the @code{struct cl_target_option} structure for function-specific\n\ +options.\n\ +@xref{Option file format}.", void, (struct cl_target_option *ptr), NULL) /* Function to restore any extra target state from the target options structure. */ DEFHOOK (restore, - "", + "This hook is called to restore any additional target-specific\n\ +information in the @code{struct cl_target_option} structure for\n\ +function-specific options.", void, (struct cl_target_option *ptr), NULL) /* Function to print any extra target state from the target options structure. */ DEFHOOK (print, - "", + "This hook is called to print any additional target-specific\n\ +information in the @code{struct cl_target_option} structure for\n\ +function-specific options.", void, (FILE *file, int indent, struct cl_target_option *ptr), NULL) /* Function to parse arguments to be validated for #pragma target, and to @@ -2853,14 +4985,27 @@ DEFHOOK true if the options are valid, and set the current state. */ DEFHOOK (pragma_parse, - "", + "This target hook parses the options for @code{#pragma GCC target}, which\n\ +sets the target-specific options for functions that occur later in the\n\ +input stream. The options accepted should be the same as those handled by the\n\ +@code{TARGET_OPTION_VALID_ATTRIBUTE_P} hook.", bool, (tree args, tree pop_target), default_target_option_pragma_parse) /* Do option overrides for the target. */ DEFHOOK (override, - "", + "Sometimes certain combinations of command options do not make sense on\n\ +a particular target machine. You can override the hook\n\ +@code{TARGET_OPTION_OVERRIDE} to take account of this. This hooks is called\n\ +once just after all the command options have been parsed.\n\ +\n\ +Don't use this hook to turn on various extra optimizations for\n\ +@option{-O}. That is what @code{TARGET_OPTION_OPTIMIZATION} is for.\n\ +\n\ +If you need to do something whenever the optimization level is\n\ +changed via the optimize attribute or pragma, see\n\ +@code{TARGET_OVERRIDE_OPTIONS_AFTER_CHANGE}", void, (void), hook_void_void) @@ -2870,7 +5015,11 @@ DEFHOOK that is, they are compiled for different target machines. */ DEFHOOK (function_versions, - "", + "This target hook returns @code{true} if @var{DECL1} and @var{DECL2} are\n\ +versions of the same function. @var{DECL1} and @var{DECL2} are function\n\ +versions if and only if they have the same function signature and\n\ +different target specific attributes, that is, they are compiled for\n\ +different target machines.", bool, (tree decl1, tree decl2), hook_bool_tree_tree_false) @@ -2879,7 +5028,10 @@ DEFHOOK #define HOOK_PREFIX "TARGET_" DEFHOOK (can_inline_p, - "", + "This target hook returns @code{false} if the @var{caller} function\n\ +cannot inline @var{callee}, based on target specific information. By\n\ +default, inlining is not allowed if the callee function has function\n\ +specific target options and the caller does not use the same options.", bool, (tree caller, tree callee), default_target_can_inline_p) @@ -2890,7 +5042,12 @@ HOOK_VECTOR_END (target_option) bits in the bitmap passed in. */ DEFHOOK (extra_live_on_entry, - "", + "Add any hard registers to @var{regs} that are live on entry to the\n\ +function. This hook only needs to be defined to provide registers that\n\ +cannot be found by examination of FUNCTION_ARG_REGNO_P, the callee saved\n\ +registers, STATIC_CHAIN_INCOMING_REGNUM, STATIC_CHAIN_REGNUM,\n\ +TARGET_STRUCT_VALUE_RTX, FRAME_POINTER_REGNUM, EH_USES,\n\ +FRAME_POINTER_REGNUM, ARG_POINTER_REGNUM, and the PIC_OFFSET_TABLE_REGNUM.", void, (bitmap regs), hook_void_bitmap) @@ -2914,7 +5071,16 @@ DEFHOOK /* Determine the type of unwind info to emit for debugging. */ DEFHOOK (debug_unwind_info, - "", + "This hook defines the mechanism that will be used for describing frame\n\ +unwind information to the debugger. Normally the hook will return\n\ +@code{UI_DWARF2} if DWARF 2 debug information is enabled, and\n\ +return @code{UI_NONE} otherwise.\n\ +\n\ +A target may return @code{UI_DWARF2} even when DWARF 2 debug information\n\ +is disabled in order to always output DWARF 2 frame information.\n\ +\n\ +A target may return @code{UI_TARGET} if it has ABI specified unwind tables.\n\ +This will suppress generation of the normal debug frame unwind information.", enum unwind_info_type, (void), default_debug_unwind_info) @@ -2922,7 +5088,25 @@ DEFHOOK defined at this time. */ DEFHOOK (canonicalize_comparison, - "", + "On some machines not all possible comparisons are defined, but you can\n\ +convert an invalid comparison into a valid one. For example, the Alpha\n\ +does not have a @code{GT} comparison, but you can use an @code{LT}\n\ +comparison instead and swap the order of the operands.\n\ +\n\ +On such machines, implement this hook to do any required conversions.\n\ +@var{code} is the initial comparison code and @var{op0} and @var{op1}\n\ +are the left and right operands of the comparison, respectively. If\n\ +@var{op0_preserve_value} is @code{true} the implementation is not\n\ +allowed to change the value of @var{op0} since the value might be used\n\ +in RTXs which aren't comparisons. E.g. the implementation is not\n\ +allowed to swap operands in that case.\n\ +\n\ +GCC will not assume that the comparison resulting from this macro is\n\ +valid but will see if the resulting insn matches a pattern in the\n\ +@file{md} file.\n\ +\n\ +You need not to implement this hook if it would never change the\n\ +comparison code or operands.", void, (int *code, rtx *op0, rtx *op1, bool op0_preserve_value), default_canonicalize_comparison) @@ -2939,59 +5123,90 @@ DEFHOOKPOD and then using ASM_OUTPUT_SKIP to allocate the space. */ DEFHOOKPOD (have_switchable_bss_sections, - "", + "This flag is true if we can create zeroed data by switching to a BSS\n\ +section and then using @code{ASM_OUTPUT_SKIP} to allocate the space.\n\ +This is true on most ELF targets.", bool, false) /* True if "native" constructors and destructors are supported, false if we're using collect2 for the job. */ DEFHOOKPOD (have_ctors_dtors, - "", + "This value is true if the target supports some ``native'' method of\n\ +collecting constructors and destructors to be run at startup and exit.\n\ +It is false if we must use @command{collect2}.", bool, false) /* True if thread-local storage is supported. */ DEFHOOKPOD (have_tls, - "", + "Contains the value true if the target supports thread-local storage.\n\ +The default value is false.", bool, false) /* True if a small readonly data section is supported. */ DEFHOOKPOD (have_srodata_section, - "", + "Contains the value true if the target places read-only\n\ +``small data'' into a separate section. The default value is false.", bool, false) /* True if EH frame info sections should be zero-terminated. */ DEFHOOKPOD (terminate_dw2_eh_frame_info, - "", + "Contains the value true if the target should add a zero word onto the\n\ +end of a Dwarf-2 frame info section when used for exception handling.\n\ +Default value is false if @code{EH_FRAME_SECTION_NAME} is defined, and\n\ +true otherwise.", bool, true) /* True if #NO_APP should be emitted at the beginning of assembly output. */ DEFHOOKPOD (asm_file_start_app_off, - "", + "If this flag is true, the text of the macro @code{ASM_APP_OFF} will be\n\ +printed as the very first line in the assembly file, unless\n\ +@option{-fverbose-asm} is in effect. (If that macro has been defined\n\ +to the empty string, this variable has no effect.) With the normal\n\ +definition of @code{ASM_APP_OFF}, the effect is to notify the GNU\n\ +assembler that it need not bother stripping comments or extra\n\ +whitespace from its input. This allows it to work a bit faster.\n\ +\n\ +The default is false. You should not set it to true unless you have\n\ +verified that your port does not generate any extra whitespace or\n\ +comments that will cause GAS to issue errors in NO_APP mode.", bool, false) /* True if output_file_directive should be called for main_input_filename at the beginning of assembly output. */ DEFHOOKPOD (asm_file_start_file_directive, - "", + "If this flag is true, @code{output_file_directive} will be called\n\ +for the primary source file, immediately after printing\n\ +@code{ASM_APP_OFF} (if that is enabled). Most ELF assemblers expect\n\ +this to be done. The default is false.", bool, false) /* True if the target is allowed to reorder memory accesses unless synchronization is explicitly requested. */ DEFHOOKPOD (relaxed_ordering, - "", + "If set to @code{true}, means that the target's memory model does not\n\ +guarantee that loads which do not depend on one another will access\n\ +main memory in the order of the instruction stream; if ordering is\n\ +important, an explicit memory barrier must be used. This is true of\n\ +many recent processors which implement a policy of ``relaxed,''\n\ +``weak,'' or ``release'' memory consistency, such as Alpha, PowerPC,\n\ +and ia64. The default is @code{false}.", bool, false) /* Returns true if we should generate exception tables for use with the ARM EABI. The effects the encoding of function exception specifications. */ DEFHOOKPOD (arm_eabi_unwinder, - "", + "This flag should be set to @code{true} on targets that use an ARM EABI\n\ +based unwinding library, and @code{false} on other targets. This effects\n\ +the format of unwinding tables, and how the unwinder in entered after\n\ +running a cleanup. The default is @code{false}.", bool, false) DEFHOOKPOD diff --git a/gcc/testsuite/ChangeLog b/gcc/testsuite/ChangeLog index d3cf90ea698..57ab286f6bf 100644 --- a/gcc/testsuite/ChangeLog +++ b/gcc/testsuite/ChangeLog @@ -1,3 +1,168 @@ +2013-07-11 Sriraman Tallam <tmsriram@google.com> + + PR target/57362 + * g++.dg/ext/pr57362.C: New. + +2013-07-11 Georg-Johann Lay <avr@gjlay.de> + + PR target/57631 + * gcc.target/avr/torture/pr57631.c: New test. + +2013-07-10 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/57827 + * g++.dg/cpp0x/constexpr-ice7.C: New. + +2013-07-10 Janis Johnson <janisjo@codesourcery.com> + + * gcc.target/powerpc/20020118-1.c: Force 128-bit stack alignment + for EABI targets. + * gcc.c-torture/execute/nest-align-1.x: New. + +2013-07-10 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/57874 + * g++.dg/cpp0x/sfinae48.C: New. + +2013-07-10 Jakub Jelinek <jakub@redhat.com> + + PR preprocessor/57824 + * c-c++-common/raw-string-17.c: New test. + * c-c++-common/gomp/pr57824.c: New test. + +2013-07-10 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/57869 + * g++.dg/cpp0x/reinterpret_cast1.C: New. + * g++.dg/warn/Wconditionally-supported-1.C: Likewise. + * g++.dg/conversion/dr195.C: Update. + * g++.dg/expr/cast2.C: Likewise. + +2013-07-10 Jakub Jelinek <jakub@redhat.com> + + * c-c++-common/raw-string-18.c: New test. + * c-c++-common/raw-string-19.c: New test. + + PR preprocessor/57757 + * g++.dg/cpp/paste1.C: New test. + * g++.dg/cpp/paste2.C: New test. + +2013-07-10 Graham Stott <grahams@btinternet.com> + + * gcc.target/mips/mulsize-1.c: New. + * gcc.target/mips/mulsize-2.c: New. + * gcc.target/mips/mulsize-3.c: New. + * gcc.target/mips/mulsize-4.c: New. + +2013-07-09 Marc Glisse <marc.glisse@inria.fr> + + PR c++/53094 + * g++.dg/cpp0x/constexpr-53094-1.C: Adjust. + * g++.dg/ext/vector24.C: New testcase. + +2013-07-09 Marc Glisse <marc.glisse@inria.fr> + + PR c++/53000 + * g++.dg/cpp0x/decltype17.C: Adjust. + +2013-07-09 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/51786 + * g++.dg/cpp0x/pr51786.C: New. + +2013-07-08 Janis Johnson <janisjo@codesourcery.com> + + * gcc.target/powerpc/tfmode_off.c: Skip for EABI targets. + + * gcc.target/powerpc/ppc-spe64-1.c: Update expected error message. + + * gcc.target/powerpc/pr47197.c: Require powerpc_altivec_ok. + + * gcc.target/powerpc/sd-vsx.c: Require dfp. + * gcc.target/powerpc/sd-pwr6.c: Likewise. + +2013-07-08 Tobias Burnus <burnus@net-b.de> + + PR fortran/57834 + * gfortran.dg/c_f_pointer_tests_8.f90: New. + +2013-07-08 Tobias Burnus <burnus@net-b.de> + + PR fortran/50554 + * gfortran.dg/do_check_9.f90: New. + +2013-07-08 Tobias Burnus <burnus@net-b.de> + + PR fortran/57785 + * gfortran.dg/dot_product_2.f90: New. + +2013-07-08 Tobias Burnus <burnus@net-b.de> + + PR fortran/57469 + * gfortran.dg/warn_unused_dummy_argument_4.f90: New. + +2013-07-08 Manfred Schwarb <manfred99@gmx.ch> + + * gfortran.dg/defined_assignment_7.f90: Fix dg-do. + * gfortran.dg/finalize_10.f90: Fix dg-final. + +2013-07-08 Jakub Jelinek <jakub@redhat.com> + + PR target/57819 + * gcc.target/i386/pr57819.c: New test. + + PR rtl-optimization/57829 + * gcc.c-torture/execute/pr57829.c: New test. + +2013-07-08 Michael Zolotukhin <michael.v.zolotukhin@gmail.com> + + * gcc.target/i386/memcpy-vector_loop-1.c: New. + * gcc.target/i386/memcpy-vector_loop-2.c: New. + +2013-07-06 Uros Bizjak <ubizjak@gmail.com> + + PR target/57807 + * gcc.target/i386/pr57807.c: New test. + +2013-07-06 Jakub Jelinek <jakub@redhat.com> + + PR target/29776 + * gcc.dg/tree-ssa/vrp89.c: New test. + +2013-07-06 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/28262 + * g++.dg/parse/defarg16.C: New. + +2013-07-05 Vladimir Makarov <vmakarov@redhat.com> + + PR rtl-optimization/55342 + * gcc.target/i386/pr55342.c: New. + +2013-07-05 Marcus Shawcroft <marcus.shawcroft@arm.com> + + * gcc.dg/pr57518.c: Adjust scan-rtl-dump-not pattern. + +2013-07-05 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/14263 + * g++.dg/inherit/virtual10.C: New. + +2013-07-04 Joern Rennecke <joern.rennecke@embecosm.com> + + PR c/57821 + * gcc.dg/large-size-array-6.c: New test. + +2013-07-04 Paolo Carlini <paolo.carlini@oracle.com> + + PR c++/38634 + * g++.dg/template/crash116.C: New. + +2013-07-04 Joern Rennecke <joern.rennecke@embecosm.com> + + * gcc.dg/tree-ssa/vrp66.c: Make conditional on { target { ! int16 } } . + * gcc.dg/tree-ssa/vrp66-int16-sw.c: New test. + 2013-07-04 Paolo Carlini <paolo.carlini@oracle.com> PR c++/54998 @@ -232,18 +397,19 @@ 2013-06-21 Balaji V. Iyer <balaji.v.iyer@intel.com> * c-c++-common/cilk-plus/AN/array_test1.c: Make this an execution test. - Also changed the returns from error as distinct values so that debugging - can get easier. + Also changed the returns from error as distinct values so that + debugging can get easier. * c-c++-common/cilk-plus/AN/if_test_errors.c (main): Made certain - errors specific to C, if necessary. Also added new error hooks for C++. + errors specific to C, if necessary. Also added new error + hooks for C++. * c-c++-common/cilk-plus/AN/misc.c (main): Likewise. * c-c++-common/cilk-plus/AN/parser_errors.c (main): Likewise. * c-c++-common/cilk-plus/AN/parser_errors2.c (main): Likewise. * c-c++-common/cilk-plus/AN/parser_errors3.c (main): Likewise. * c-c++-common/cilk-plus/AN/pr57541.c (main): Likewise. - * c-c++-common/cilk-plus/AN/parser_errors4.c (main): In addition to the - same changes as parser_errors3.c, spaces were added between colons to - not confuse C++ compiler with 2 colons as scope. + * c-c++-common/cilk-plus/AN/parser_errors4.c (main): In addition to + the same changes as parser_errors3.c, spaces were added between colons + to not confuse C++ compiler with 2 colons as scope. * c-c++-common/cilk-plus/AN/vla.c: Make this test C specific. * g++.dg/cilk-plus/AN/array_test1_tplt.cc: New test. * g++.dg/cilk-plus/AN/array_test2_tplt.cc: Likewise. @@ -255,7 +421,8 @@ * g++.dg/cilk-plus/AN/preincr_test.cc: Likewise. * g++.dg/cilk-plus/AN/postincr_test.cc: Likewise. * g++.dg/cilk-plus/cilk-plus.exp: New script. - * gcc/testsuite/g++.dg/dg.exp: Included Cilk Plus C++ tests in the list. + * gcc/testsuite/g++.dg/dg.exp: Included Cilk Plus C++ tests + in the list. 2013-06-21 Joseph Myers <joseph@codesourcery.com> @@ -290,7 +457,7 @@ PR tree-optimization/57584 * gcc.dg/torture/pr57584.c: New testcase. -2013-06-19 <singhai@google.com> +2013-06-19 Sharad Singhai <singhai@google.com> * g++.dg/gcov/gcov-8.C: New testcase. * lib/gcov.exp: Handle intermediate format. @@ -1665,7 +1832,7 @@ 2013-05-14 Joern Rennecke <joern.rennecke@embecosm.com> * gcc.c-torture/compile/limits-externdecl.c [target avr-*-*]: - Expect "size of array is too large" error. + Expect "size of array is too large" error. 2013-05-14 Rainer Orth <ro@CeBiTec.Uni-Bielefeld.DE> diff --git a/gcc/testsuite/c-c++-common/gomp/pr57824.c b/gcc/testsuite/c-c++-common/gomp/pr57824.c new file mode 100644 index 00000000000..a303da24c6b --- /dev/null +++ b/gcc/testsuite/c-c++-common/gomp/pr57824.c @@ -0,0 +1,14 @@ +/* PR preprocessor/57824 */ +/* { dg-do compile } */ +/* { dg-options "-std=gnu99 -fopenmp" { target c } } */ +/* { dg-options "-std=c++11 -fopenmp" { target c++ } } */ + +void bar (); + +void foo () +{ +#pragma omp parallel num_threads(sizeof R"( +abc +)") + bar (); +} diff --git a/gcc/testsuite/c-c++-common/raw-string-17.c b/gcc/testsuite/c-c++-common/raw-string-17.c new file mode 100644 index 00000000000..30df020082e --- /dev/null +++ b/gcc/testsuite/c-c++-common/raw-string-17.c @@ -0,0 +1,30 @@ +/* PR preprocessor/57824 */ +/* { dg-do run } */ +/* { dg-options "-std=gnu99" { target c } } */ +/* { dg-options "-std=c++11" { target c++ } } */ + +#define S(s) s +#define T(s) s "\n" + +const char x[] = R"( +abc +)"; +const char y[] = S(R"( +abc +)"); +const char z[] = "\nabc\n"; +const char w[] = T(R"( +abc)"); + +int +main () +{ + if (sizeof x != sizeof y + || sizeof x != sizeof z + || sizeof x != sizeof w + || __builtin_memcmp (x, y, sizeof x) + || __builtin_memcmp (x, z, sizeof x) + || __builtin_memcmp (x, w, sizeof x)) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/c-c++-common/raw-string-18.c b/gcc/testsuite/c-c++-common/raw-string-18.c new file mode 100644 index 00000000000..8d4381d1310 --- /dev/null +++ b/gcc/testsuite/c-c++-common/raw-string-18.c @@ -0,0 +1,21 @@ +/* PR preprocessor/57824 */ +/* { dg-do compile } */ +/* { dg-options "-std=gnu99 -fdump-tree-optimized-lineno" { target c } } */ +/* { dg-options "-std=c++11 -fdump-tree-optimized-lineno" { target c++ } } */ + +const char x[] = R"( +abc +def +ghi +)"; + +int +main () +{ + extern void foo (); foo (); + return 0; +} + +/* Verify call to foo is on line 15. */ +/* { dg-final { scan-tree-dump ": 15\[]:]\[^\n\r]*foo" "optimized" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ diff --git a/gcc/testsuite/c-c++-common/raw-string-19.c b/gcc/testsuite/c-c++-common/raw-string-19.c new file mode 100644 index 00000000000..08121a89f84 --- /dev/null +++ b/gcc/testsuite/c-c++-common/raw-string-19.c @@ -0,0 +1,22 @@ +/* PR preprocessor/57824 */ +/* { dg-do compile } */ +/* { dg-options "-std=gnu99 -fdump-tree-optimized-lineno -save-temps" { target c } } */ +/* { dg-options "-std=c++11 -fdump-tree-optimized-lineno -save-temps" { target c++ } } */ + +const char x[] = R"( +abc +def +ghi +)"; + +int +main () +{ + extern void foo (); foo (); + return 0; +} + +/* Verify call to foo is on line 15. */ +/* { dg-final { scan-tree-dump ": 15\[]:]\[^\n\r]*foo" "optimized" } } */ +/* { dg-final { cleanup-tree-dump "optimized" } } */ +/* { dg-final { cleanup-saved-temps } } */ diff --git a/gcc/testsuite/g++.dg/conversion/dr195.C b/gcc/testsuite/g++.dg/conversion/dr195.C index 8502c1578b6..cb26623e11f 100644 --- a/gcc/testsuite/g++.dg/conversion/dr195.C +++ b/gcc/testsuite/g++.dg/conversion/dr195.C @@ -1,11 +1,12 @@ // Copyright (C) 2004 Free Software Foundation, Inc. // Contributed by Nathan Sidwell 20 Oct 2004 <nathan@codesourcery.com> -// DR 195 will allow conversions between function and object pointers -// under some circumstances. It is in drafting, so we don't implement -// it (yet). +// DR 195 was about allowing conversions between function and object +// pointers under some circumstances. The issue got resolved for C++11, +// which, in 5.2.10 p8 says that: "Converting a function pointer to an +// object pointer type or vice versa is conditionally-supported." -// This checks we warn when being pedantic. +// This checks we don't warn anymore with -pedantic. typedef void (*PF)(void); typedef void *PV; @@ -18,12 +19,12 @@ void foo () PO po; /* the following two will almost definitly be ok with 195. */ - pf = reinterpret_cast <PF>(pv); // { dg-warning "casting between" "" } - pv = reinterpret_cast <PV>(pf); // { dg-warning "casting between" "" } + pf = reinterpret_cast <PF>(pv); + pv = reinterpret_cast <PV>(pf); /* the following two might or might not be ok with 195. */ - pf = reinterpret_cast <PF>(po); // { dg-warning "casting between" "" } - po = reinterpret_cast <PO>(pf); // { dg-warning "casting between" "" } + pf = reinterpret_cast <PF>(po); + po = reinterpret_cast <PO>(pf); /* These will never be ok, as they are implicit. */ pv = pf; // { dg-error "invalid conversion" "" } diff --git a/gcc/testsuite/g++.dg/cpp/paste1.C b/gcc/testsuite/g++.dg/cpp/paste1.C new file mode 100644 index 00000000000..a33fdf5c436 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp/paste1.C @@ -0,0 +1,14 @@ +// PR preprocessor/57757 +// { dg-do compile } +// { dg-options "-std=c++11" } + +#define S(x) x +extern S("C")void exit (int); +int +main () +{ + (void) (S("foo")and 0); + const wchar_t *p = S(L"foo")L"bar"; + const char *a = S("foo")R"(bar)"; + exit (0); +} diff --git a/gcc/testsuite/g++.dg/cpp/paste2.C b/gcc/testsuite/g++.dg/cpp/paste2.C new file mode 100644 index 00000000000..89a659e6bb9 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp/paste2.C @@ -0,0 +1,15 @@ +// PR preprocessor/57757 +// { dg-do compile } +// { dg-options "-std=c++11 -save-temps" } +// { dg-final cleanup-saved-temps } + +#define S(x) x +extern S("C")void exit (int); +int +main () +{ + (void) (S("foo")and 0); + const wchar_t *p = S(L"foo")L"bar"; + const char *a = S("foo")R"(bar)"; + exit (0); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-53094-1.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-53094-1.C index c24ff60219d..e49023d869e 100644 --- a/gcc/testsuite/g++.dg/cpp0x/constexpr-53094-1.C +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-53094-1.C @@ -3,4 +3,4 @@ typedef float __attribute__ ((vector_size (4 * sizeof (float)))) V4; constexpr V4 v = { 1, 1, 1, 0 }; -constexpr V4 r = v[0] + v; // { dg-bogus "not a constant expression" "" { xfail *-*-* } } +constexpr V4 r = v[0] + v; diff --git a/gcc/testsuite/g++.dg/cpp0x/constexpr-ice7.C b/gcc/testsuite/g++.dg/cpp0x/constexpr-ice7.C new file mode 100644 index 00000000000..4fa3a831454 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/constexpr-ice7.C @@ -0,0 +1,15 @@ +// PR c++/57827 +// { dg-do compile { target c++11 } } + +struct C +{ + constexpr int fun (int x) + { + return x + 1; + } + + int a = 2; + int b = fun(a); +}; + +C c; diff --git a/gcc/testsuite/g++.dg/cpp0x/decltype17.C b/gcc/testsuite/g++.dg/cpp0x/decltype17.C index 3c98105fced..7f36ff01e50 100644 --- a/gcc/testsuite/g++.dg/cpp0x/decltype17.C +++ b/gcc/testsuite/g++.dg/cpp0x/decltype17.C @@ -24,6 +24,6 @@ int main() return 1; if (strcmp (typeid(g).name(), "FRivE") != 0) return 2; - if (strcmp (typeid(h).name(), "FivE") != 0) + if (strcmp (typeid(h).name(), "FOivE") != 0) return 3; } diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-auto3.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-auto3.C new file mode 100644 index 00000000000..013ed5264ea --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-auto3.C @@ -0,0 +1,24 @@ +// PR c++/57526 +// { dg-require-effective-target c++11 } + +template<class T> +struct A +{ + void bar( ) { } + + void foo( ) + { + auto* this_ptr = this; + auto lc = [&]( ) + { + this_ptr->bar(); + }; + lc(); + } +}; + +int main() +{ + A<int> a; + a.foo(); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-return1.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-return1.C new file mode 100644 index 00000000000..4b353b64c37 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-return1.C @@ -0,0 +1,26 @@ +// PR c++/57437 +// { dg-require-effective-target c++11 } + +struct A { + int i; + + A(): i(42) {} + A(const A&) = default; + A(A&& a): i(a.i) { a.i = 0; } +}; + +int main() +{ + A x; + + auto y = [x] () mutable { + x.i++; + return x; + }; + + if (y().i != 43) + __builtin_abort (); + + if (y().i != 44) + __builtin_abort (); +} diff --git a/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-template12.C b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-template12.C new file mode 100644 index 00000000000..635af97d763 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/lambda/lambda-template12.C @@ -0,0 +1,19 @@ +// PR c++/57568 +// { dg-require-effective-target c++11 } + +template < class T > +struct remove_reference +{ typedef int type; }; +template < class T > +class X +{ + enum Q { }; + bool f () + { + Q a; + [&a]{ + typename remove_reference < decltype (a) >::type t; + }; + } +}; +template class X< int >; diff --git a/gcc/testsuite/g++.dg/cpp0x/pr51786.C b/gcc/testsuite/g++.dg/cpp0x/pr51786.C new file mode 100644 index 00000000000..69b7441588f --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/pr51786.C @@ -0,0 +1,8 @@ +// PR c++/51786 +// { dg-do compile { target c++11 } } + +enum E {}; +struct A {}; + +void foo() { decltype(E{}); } // { dg-error "does not declare anything" } +void bar() { decltype(A{}); } // { dg-error "does not declare anything" } diff --git a/gcc/testsuite/g++.dg/cpp0x/reinterpret_cast1.C b/gcc/testsuite/g++.dg/cpp0x/reinterpret_cast1.C new file mode 100644 index 00000000000..7c0463eac55 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/reinterpret_cast1.C @@ -0,0 +1,6 @@ +// PR c++/57869 +// { dg-do compile { target c++11 } } + +void* po = 0; +void (*pf)() = reinterpret_cast<decltype(pf)>(po); +static_assert(sizeof(po) >= sizeof(pf), "Conversion not supported"); diff --git a/gcc/testsuite/g++.dg/cpp0x/sfinae48.C b/gcc/testsuite/g++.dg/cpp0x/sfinae48.C new file mode 100644 index 00000000000..ba728d9de8f --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/sfinae48.C @@ -0,0 +1,21 @@ +// PR c++/57874 +// { dg-do compile { target c++11 } } + +namespace NX +{ + struct X {}; + void foo(X) {} +} + +namespace NY +{ + struct Y {}; +} + +template<class T> +auto ADLfoo(T&&) -> decltype((foo(T{}), short())); + +char ADLfoo(...); + +static_assert(sizeof(ADLfoo(NY::Y{})) == 1, ""); +static_assert(sizeof(ADLfoo(NX::X{})) == 2, ""); diff --git a/gcc/testsuite/g++.dg/cpp0x/variadic-sizeof2.C b/gcc/testsuite/g++.dg/cpp0x/variadic-sizeof2.C new file mode 100644 index 00000000000..dfc245d1621 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp0x/variadic-sizeof2.C @@ -0,0 +1,14 @@ +// PR c++/57471 +// { dg-require-effective-target c++11 } + +struct A +{ + static constexpr bool value = true; +}; + +template<typename... Types> +struct B +{ + static_assert(A::value, ""); + static_assert(sizeof...(Types) == 0, ""); +}; diff --git a/gcc/testsuite/g++.dg/cpp1y/vla10.C b/gcc/testsuite/g++.dg/cpp1y/vla10.C new file mode 100644 index 00000000000..1c672903092 --- /dev/null +++ b/gcc/testsuite/g++.dg/cpp1y/vla10.C @@ -0,0 +1,24 @@ +// PR c++/57402 +// { dg-options "-std=c++1y -pedantic-errors" } + +int i = 2; + +int main() +{ + { + int a[i]; + a[1] = 0xbeef; + } + { + int a[i] = { 1 }; + if (a[1] != 0) + __builtin_abort (); + a[1] = 0xbeef; + } + { + int a[i] = { }; + if (a[1] != 0) + __builtin_abort (); + a[1] = 0xbeef; + } +} diff --git a/gcc/testsuite/g++.dg/debug/template2.C b/gcc/testsuite/g++.dg/debug/template2.C new file mode 100644 index 00000000000..9f5bcd9b101 --- /dev/null +++ b/gcc/testsuite/g++.dg/debug/template2.C @@ -0,0 +1,14 @@ +// PR c++/57545 + +template<typename T, long unsigned int N> +struct array { + T data[N]; +}; + +template<typename T> +struct derived { + typedef long unsigned int size_type; + static const size_type n = 42; + + array<int, n> a; +}; diff --git a/gcc/testsuite/g++.dg/expr/cast2.C b/gcc/testsuite/g++.dg/expr/cast2.C index 1ccda2b4804..f3c18d5feec 100644 --- a/gcc/testsuite/g++.dg/expr/cast2.C +++ b/gcc/testsuite/g++.dg/expr/cast2.C @@ -1,5 +1,5 @@ void (*p)(); void f() { - (void *)p; // { dg-warning "forbids cast" } + (void *)p; } diff --git a/gcc/testsuite/g++.dg/expr/const1.C b/gcc/testsuite/g++.dg/expr/const1.C new file mode 100644 index 00000000000..9371b27b28f --- /dev/null +++ b/gcc/testsuite/g++.dg/expr/const1.C @@ -0,0 +1,9 @@ +// PR c++/57551 + +extern unsigned long ADDR; + +unsigned long f(){ + const unsigned long* const var=&ADDR; + const unsigned long retval=var[1]; + return retval; +} diff --git a/gcc/testsuite/g++.dg/ext/pr57362.C b/gcc/testsuite/g++.dg/ext/pr57362.C new file mode 100644 index 00000000000..67f96857e8d --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/pr57362.C @@ -0,0 +1,199 @@ +/* { dg-do compile { target i?86-*-* x86_64-*-* } } */ +/* { dg-require-ifunc "" } */ + +__attribute__((target("default"))) +int foo(void) { return 1; } +__attribute__((target("128bit-long-double"))) +int foo(void) { return 1; } +__attribute__((target("80387"))) +int foo(void) { return 1; } +__attribute__((target("96bit-long-double"))) +int foo(void) { return 1; } +__attribute__((target("long-double-80"))) +int foo(void) { return 1; } +__attribute__((target("long-double-64"))) +int foo(void) { return 1; } +__attribute__((target("accumulate-outgoing-args"))) +int foo(void) { return 1; } +__attribute__((target("align-double"))) +int foo(void) { return 1; } +__attribute__((target("align-stringops"))) +int foo(void) { return 1; } +__attribute__((target("fancy-math-387"))) +int foo(void) { return 1; } +__attribute__((target("force-drap"))) +int foo(void) { return 1; } +__attribute__((target("fp-ret-in-387"))) +int foo(void) { return 1; } +__attribute__((target("hard-float"))) +int foo(void) { return 1; } +__attribute__((target("ieee-fp"))) +int foo(void) { return 1; } +__attribute__((target("inline-all-stringops"))) +int foo(void) { return 1; } +__attribute__((target("inline-stringops-dynamically"))) +int foo(void) { return 1; } +__attribute__((target("intel-syntax"))) +int foo(void) { return 1; } +__attribute__((target("ms-bitfields"))) +int foo(void) { return 1; } +__attribute__((target("no-align-stringops"))) +int foo(void) { return 1; } +__attribute__((target("no-fancy-math-387"))) +int foo(void) { return 1; } +__attribute__((target("no-push-args"))) +int foo(void) { return 1; } +__attribute__((target("no-red-zone"))) +int foo(void) { return 1; } +__attribute__((target("omit-leaf-frame-pointer"))) +int foo(void) { return 1; } +__attribute__((target("pc32"))) +int foo(void) { return 1; } +__attribute__((target("pc64"))) +int foo(void) { return 1; } +__attribute__((target("pc80"))) +int foo(void) { return 1; } +__attribute__((target("push-args"))) +int foo(void) { return 1; } +__attribute__((target("red-zone"))) +int foo(void) { return 1; } +__attribute__((target("rtd"))) +int foo(void) { return 1; } +__attribute__((target("soft-float"))) +int foo(void) { return 1; } +__attribute__((target("sseregparm"))) +int foo(void) { return 1; } +__attribute__((target("stackrealign"))) +int foo(void) { return 1; } +__attribute__((target("stack-arg-probe"))) +int foo(void) { return 1; } +__attribute__((target("tls-direct-seg-refs"))) +int foo(void) { return 1; } +__attribute__((target("vect8-ret-in-mem"))) +int foo(void) { return 1; } +__attribute__((target("recip"))) +int foo(void) { return 1; } +__attribute__((target("cld"))) +int foo(void) { return 1; } +__attribute__((target("vzeroupper"))) +int foo(void) { return 1; } +__attribute__((target("dispatch-scheduler"))) +int foo(void) { return 1; } +__attribute__((target("prefer-avx128"))) +int foo(void) { return 1; } +__attribute__((target("32"))) +int foo(void) { return 1; } +__attribute__((target("64"))) +int foo(void) { return 1; } +__attribute__((target("x32"))) +int foo(void) { return 1; } +__attribute__((target("mmx"))) +int foo(void) { return 1; } +__attribute__((target("3dnow"))) +int foo(void) { return 1; } +__attribute__((target("3dnowa"))) +int foo(void) { return 1; } +__attribute__((target("sse"))) +int foo(void) { return 1; } +__attribute__((target("sse2"))) +int foo(void) { return 1; } +__attribute__((target("sse3"))) +int foo(void) { return 1; } +__attribute__((target("ssse3"))) +int foo(void) { return 1; } +__attribute__((target("sse4.1"))) +int foo(void) { return 1; } +__attribute__((target("sse4.2"))) +int foo(void) { return 1; } +__attribute__((target("sse4"))) +int foo(void) { return 1; } +__attribute__((target("no-sse4"))) +int foo(void) { return 1; } +__attribute__((target("sse5"))) +int foo(void) { return 1; } +__attribute__((target("avx"))) +int foo(void) { return 1; } +__attribute__((target("avx2"))) +int foo(void) { return 1; } +__attribute__((target("fma"))) +int foo(void) { return 1; } +__attribute__((target("sse4a"))) +int foo(void) { return 1; } +__attribute__((target("fma4"))) +int foo(void) { return 1; } +__attribute__((target("xop"))) +int foo(void) { return 1; } +__attribute__((target("lwp"))) +int foo(void) { return 1; } +__attribute__((target("abm"))) +int foo(void) { return 1; } +__attribute__((target("popcnt"))) +int foo(void) { return 1; } +__attribute__((target("bmi"))) +int foo(void) { return 1; } +__attribute__((target("bmi2"))) +int foo(void) { return 1; } +__attribute__((target("lzcnt"))) +int foo(void) { return 1; } +__attribute__((target("hle"))) +int foo(void) { return 1; } +__attribute__((target("rdseed"))) +int foo(void) { return 1; } +__attribute__((target("prfchw"))) +int foo(void) { return 1; } +__attribute__((target("adx"))) +int foo(void) { return 1; } +__attribute__((target("fxsr"))) +int foo(void) { return 1; } +__attribute__((target("xsave"))) +int foo(void) { return 1; } +__attribute__((target("xsaveopt"))) +int foo(void) { return 1; } +__attribute__((target("tbm"))) +int foo(void) { return 1; } +__attribute__((target("cx16"))) +int foo(void) { return 1; } +__attribute__((target("sahf"))) +int foo(void) { return 1; } +__attribute__((target("movbe"))) +int foo(void) { return 1; } +__attribute__((target("crc32"))) +int foo(void) { return 1; } +__attribute__((target("aes"))) +int foo(void) { return 1; } +__attribute__((target("pclmul"))) +int foo(void) { return 1; } +__attribute__((target("sse2avx"))) +int foo(void) { return 1; } +__attribute__((target("fsgsbase"))) +int foo(void) { return 1; } +__attribute__((target("rdrnd"))) +int foo(void) { return 1; } +__attribute__((target("f16c"))) +int foo(void) { return 1; } +__attribute__((target("fentry"))) +int foo(void) { return 1; } +__attribute__((target("8bit-idiv"))) +int foo(void) { return 1; } +__attribute__((target("avx256-split-unaligned-load"))) +int foo(void) { return 1; } +__attribute__((target("avx256-split-unaligned-store"))) +int foo(void) { return 1; } +__attribute__((target("rtm"))) +int foo(void) { return 1; } +//--------------- + +#include <stdio.h> + int main (void) + { + int result; + result = foo(); + printf("Result is %d\n", result); + return result; + } + +/* { dg-prune-output "attribute.* is unknown" } */ +/* { dg-prune-output "redefinition of int foo" } */ +/* { dg-prune-output "previous declaration of int foo" } */ +/* { dg-prune-output "int foo.* previously defined here" } */ +/* { dg-prune-output "No dispatcher found for" } */ diff --git a/gcc/testsuite/g++.dg/ext/vector24.C b/gcc/testsuite/g++.dg/ext/vector24.C new file mode 100644 index 00000000000..3eca7fb0bf9 --- /dev/null +++ b/gcc/testsuite/g++.dg/ext/vector24.C @@ -0,0 +1,8 @@ +// { dg-do compile { target c++11 } } + +typedef long vec __attribute__((vector_size(2*sizeof(long)))); +constexpr vec v = { 33, 42 }; +constexpr auto l0 = v[0]; +constexpr auto l1 = v[1]; +static_assert(l0==33,"Fail"); +static_assert(l1==42,"Fail"); diff --git a/gcc/testsuite/g++.dg/inherit/virtual10.C b/gcc/testsuite/g++.dg/inherit/virtual10.C new file mode 100644 index 00000000000..4cb858b9293 --- /dev/null +++ b/gcc/testsuite/g++.dg/inherit/virtual10.C @@ -0,0 +1,11 @@ +// PR c++/14263 + +struct A { }; + +struct B : virtual A { }; + +int main() +{ + A* p = new B; + B* q = static_cast<B*>(p); // { dg-error "cannot convert from pointer to base class 'A' to pointer to derived class 'B' because the base is virtual" } +} diff --git a/gcc/testsuite/g++.dg/parse/defarg16.C b/gcc/testsuite/g++.dg/parse/defarg16.C new file mode 100644 index 00000000000..8eb0014ddbf --- /dev/null +++ b/gcc/testsuite/g++.dg/parse/defarg16.C @@ -0,0 +1,4 @@ +// PR c++/28262 + +typedef void (funcptrhack) (int = 10); // { dg-error "default arguments" } +typedef funcptrhack * funcptr; diff --git a/gcc/testsuite/g++.dg/parse/ref-qual2.C b/gcc/testsuite/g++.dg/parse/ref-qual2.C new file mode 100644 index 00000000000..a78597b0cd4 --- /dev/null +++ b/gcc/testsuite/g++.dg/parse/ref-qual2.C @@ -0,0 +1,6 @@ +// PR c++/57532 + +int main() +{ + return (int() & int()); +} diff --git a/gcc/testsuite/g++.dg/template/access27.C b/gcc/testsuite/g++.dg/template/access27.C new file mode 100644 index 00000000000..967e10f6a5b --- /dev/null +++ b/gcc/testsuite/g++.dg/template/access27.C @@ -0,0 +1,17 @@ +// PR c++/57550 + +template <bool (double)> bool Wrapper(double); +template <class T> void MakeHandler(bool (T)); + +class Handler +{ +public: + template <typename T> static void SetPrimitiveHandlers() + { + MakeHandler(Wrapper<Append<T> >); + } +private : + template <typename T> static bool Append(T); +}; + +template void Handler::SetPrimitiveHandlers<double>(); diff --git a/gcc/testsuite/g++.dg/template/crash116.C b/gcc/testsuite/g++.dg/template/crash116.C new file mode 100644 index 00000000000..d26c591ef43 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/crash116.C @@ -0,0 +1,13 @@ +// PR c++/38634 + +template<int> struct A +{ + A(); +}; + +template<int N, char> A<N>::A() // { dg-error "template|required" } +{ + struct B {}; +} + +A<0> a; diff --git a/gcc/testsuite/g++.dg/template/using23.C b/gcc/testsuite/g++.dg/template/using23.C new file mode 100644 index 00000000000..abb90de4cd8 --- /dev/null +++ b/gcc/testsuite/g++.dg/template/using23.C @@ -0,0 +1,15 @@ +// PR c++/57831 + +struct A { + void f(); +}; +template <class T> struct B : T { + typedef T base; + using base::f; // If I write "using B<T>::f" it's ok + void g( ) { + B<T>::f(); // This is OK as expected + (this->*&T::f)(); // This is also OK + (this->*&B<T>::f)(); // This causes error + } +}; +template struct B< A >; diff --git a/gcc/testsuite/g++.dg/warn/Wconditionally-supported-1.C b/gcc/testsuite/g++.dg/warn/Wconditionally-supported-1.C new file mode 100644 index 00000000000..8cc5966eda8 --- /dev/null +++ b/gcc/testsuite/g++.dg/warn/Wconditionally-supported-1.C @@ -0,0 +1,25 @@ +// { dg-options "-Wconditionally-supported" } + +// DR 195 was about allowing conversions between function and object +// pointers under some circumstances. The issue got resolved for C++11, +// which, in 5.2.10 p8 says that: "Converting a function pointer to an +// object pointer type or vice versa is conditionally-supported." + +// This checks we warn with -Wconditionally-supported. + +typedef void (*PF)(void); +typedef void *PV; +typedef int *PO; + +void foo () +{ + PF pf; + PV pv; + PO po; + + pf = reinterpret_cast <PF>(pv); // { dg-warning "conditionally-supported" } + pv = reinterpret_cast <PV>(pf); // { dg-warning "conditionally-supported" } + + pf = reinterpret_cast <PF>(po); // { dg-warning "conditionally-supported" } + po = reinterpret_cast <PO>(pf); // { dg-warning "conditionally-supported" } +} diff --git a/gcc/testsuite/gcc.c-torture/execute/nest-align-1.x b/gcc/testsuite/gcc.c-torture/execute/nest-align-1.x new file mode 100644 index 00000000000..392d9aaa898 --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/execute/nest-align-1.x @@ -0,0 +1,5 @@ +# Force bigger stack alignment for PowerPC EABI targets. +if { [istarget "powerpc-*-eabi*"] } { + set additional_flags "-mno-eabi" +} +return 0 diff --git a/gcc/testsuite/gcc.c-torture/execute/pr57829.c b/gcc/testsuite/gcc.c-torture/execute/pr57829.c new file mode 100644 index 00000000000..b5c3d185d0a --- /dev/null +++ b/gcc/testsuite/gcc.c-torture/execute/pr57829.c @@ -0,0 +1,31 @@ +/* PR rtl-optimization/57829 */ + +__attribute__((noinline, noclone)) +int +f1 (int k) +{ + return 2 | ((k - 1) >> ((int) sizeof (int) * __CHAR_BIT__ - 1)); +} + +__attribute__((noinline, noclone)) +long int +f2 (long int k) +{ + return 2L | ((k - 1L) >> ((int) sizeof (long int) * __CHAR_BIT__ - 1)); +} + +__attribute__((noinline, noclone)) +int +f3 (int k) +{ + k &= 63; + return 4 | ((k + 2) >> 5); +} + +int +main () +{ + if (f1 (1) != 2 || f2 (1L) != 2L || f3 (63) != 6 || f3 (1) != 4) + __builtin_abort (); + return 0; +} diff --git a/gcc/testsuite/gcc.dg/large-size-array-6.c b/gcc/testsuite/gcc.dg/large-size-array-6.c new file mode 100644 index 00000000000..f7da47e9372 --- /dev/null +++ b/gcc/testsuite/gcc.dg/large-size-array-6.c @@ -0,0 +1,6 @@ +/* PR c/57821 */ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ +static char * name[] = { + [0x8000000000000000] = "bar" + }; /* { dg-error "too large" } */ diff --git a/gcc/testsuite/gcc.dg/pr57518.c b/gcc/testsuite/gcc.dg/pr57518.c index 4c84a856b5d..47e819c3e44 100644 --- a/gcc/testsuite/gcc.dg/pr57518.c +++ b/gcc/testsuite/gcc.dg/pr57518.c @@ -2,7 +2,7 @@ /* { dg-do compile } */ /* { dg-options "-O2 -fdump-rtl-ira" } */ -/* { dg-final { scan-rtl-dump-not "REG_EQUIV.*mem.*\"ip\"" "ira" } } */ +/* { dg-final { scan-rtl-dump-not "REG_EQUIV\[^\n\]*mem\[^\n\]*\"ip\"" "ira" } } */ char ip[10]; int total; diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp66-int16-sw.c b/gcc/testsuite/gcc.dg/tree-ssa/vrp66-int16-sw.c new file mode 100644 index 00000000000..b194d2370e0 --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp66-int16-sw.c @@ -0,0 +1,914 @@ +/* PR tree-optimization/52267 */ +/* { dg-do run { target { int16 } } } */ +/* { dg-options "-O2" } */ + +extern void abort (void); + +#define BITSM1 (sizeof (int) * __CHAR_BIT__ - 1) +#define BITSH ((sizeof (int) - sizeof (short)) * __CHAR_BIT__) + +void +f1 (unsigned int s) +{ + if ((s & (7U << (BITSM1 - 2))) != 0) + { + if (s == (0xc000U << BITSH) - 1 || s == (0xf000U << BITSH) - 1 + || s == (0x9000U << BITSH) - 1 || s == (0xa031U << BITSH) - 1 + || s == (0xbfbfU << BITSH) || s == (0xc000U << BITSH) + || s == (0xf000U << BITSH) || s == (0x9000U << BITSH) + || s == (0xc000U << BITSH) + 1 || s == -1U || s == -15U + || s == 0x3cbf || s == 0x3cc0 + || s == -15550U || s == -15552U || s == (0x7000 << BITSH) - 1 + || s == (0x7000 << BITSH) || s == (1 << (BITSM1 - 2)) + || s == 1U + __INT_MAX__ || s == -32U + || s == (3 << (BITSM1 - 2)) + 2 || s == -5U || s == -63U + || s == -64U || s == -65U || s == 6U + __INT_MAX__ || s == -8189U + || s == -8191U || s == -8192U || s == -8193U || s == -8250U + || s == -8255U || s == -8256U || s == -8257U || s == __INT_MAX__ + || s == __INT_MAX__ + 9U) + return; + } + else + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3f || s == 1 + || s == (1 << (BITSM1 - 2)) - 1 || s == 2 || s == 24 || s == 5) + return; + } + abort (); +} + +void +f2 (int s) +{ + if ((s & (7U << (BITSM1 - 2))) == 0) + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3f || s == 1 + || s == (1 << (BITSM1 - 2)) - 1 || s == 2 || s == 24 || s == 5) + return; + } + else + { + if (s == (-0x4000 << BITSH) - 1 || s == (-0x1000 << BITSH) - 1 + || s == (-0x7000 << BITSH) - 1 || s == (-0x5fcf << BITSH) - 1 + || s == (-0x4041 << BITSH) || s == (-0x4000 << BITSH) + || s == (-0x1000 << BITSH) || s == (-0x7000 << BITSH) + || s == (-0x4000 << BITSH) + 1 || s == -1 || s == -15 || s == -15550 + || s == 0x3cbf || s == 0x3cc0 + || s == -15552 || s == (0x7000 << BITSH) - 1 + || s == (0x7000 << BITSH) || s == (1 << (BITSM1 - 2)) + || s == -__INT_MAX__ - 1 || s == -32 || s == (3 << (BITSM1 - 2)) + 2 + || s == -5 || s == -63 || s == -64 || s == -65 + || s == -__INT_MAX__ + 4 || s == -8189 || s == -8191 || s == -8192 + || s == -8193 || s == -8250 || s == -8255 || s == -8256 + || s == -8257 || s == __INT_MAX__ || s == -__INT_MAX__ + 7) + return; + } + abort (); +} + +void +f3 (unsigned int s) +{ + if ((s & 0x3cc0) == 0) + { + if (s == 0 || s == 0x20 || s == 0x3f + || s == (0xc000U << BITSH) + || s == (0xc000U << BITSH) + 1 || s == 1 + || s == 1U + __INT_MAX__ || s == 2 || s == 24 + || s == 5 || s == 6U + __INT_MAX__ + || s == __INT_MAX__ + 9U) + return; + } + else + { + if (s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == (0xbfbfU << BITSH) || s == (0xf000U << BITSH) + || s == (0x9000U << BITSH) + || s == (0x7000 << BITSH) || s == (1 << (BITSM1 - 2)) + || s == (3 << (BITSM1 - 2)) + 2 + || s == 0x3cbf || s == 0x3cc0 || s == (0xc000U << BITSH) - 1 + || s == (0xf000U << BITSH) - 1 || s == (0x9000U << BITSH) - 1 + || s == (0xa031U << BITSH) - 1 || s == -1U || s == -15U + || s == -15550U || s == -15552U || s == (0x7000 << BITSH) - 1 + || s == (1 << (BITSM1 - 2)) - 1 || s == -32U || s == -5U + || s == -63U || s == -64U || s == -65U || s == -8189U || s == -8191U + || s == -8192U || s == -8193U || s == -8250U || s == -8255U + || s == -8256U || s == -8257U || s == __INT_MAX__) + return; + } + abort (); +} + +void +f4 (int s) +{ + if ((s & 0x3cc0) == 0) + { + if (s == 0 || s == 0x20 || s == 0x3f + || s == (-0x4000 << BITSH) + || s == (-0x4000 << BITSH) + 1 || s == 1 + || s == -__INT_MAX__ - 1 || s == 2 || s == 24 + || s == 5 || s == -__INT_MAX__ + 4 + || s == -__INT_MAX__ + 7) + return; + } + else + { + if (s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == (-0x4041 << BITSH) || s == (-0x1000 << BITSH) + || s == (-0x7000 << BITSH) + || s == (0x7000 << BITSH) || s == (1 << (BITSM1 - 2)) + || s == (3 << (BITSM1 - 2)) + 2 + || s == 0x3cbf || s == 0x3cc0 || s == (-0x4000 << BITSH) - 1 + || s == (-0x1000 << BITSH) - 1 || s == (-0x7000 << BITSH) - 1 + || s == (-0x5fcf << BITSH) - 1 || s == -1 || s == -15 || s == -15550 + || s == -15552 || s == (0x7000 << BITSH) - 1 + || s == (1 << (BITSM1 - 2)) - 1 || s == -32 || s == -5 || s == -63 + || s == -64 || s == -65 || s == -8189 || s == -8191 || s == -8192 + || s == -8193 || s == -8250 || s == -8255 || s == -8256 + || s == -8257 || s == __INT_MAX__) + return; + } + abort (); +} + +void +f5 (int s) +{ + if ((s & 0x3cc0U) == 0) + { + if (s == 0 || s == 0x20 || s == 0x3f + || s == (-0x4000 << BITSH) + || s == (-0x4000 << BITSH) + 1 || s == 1 + || s == -__INT_MAX__ - 1 || s == 2 || s == 24 + || s == 5 || s == -__INT_MAX__ + 4 + || s == -__INT_MAX__ + 7) + return; + } + else + { + if (s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == (-0x4041 << BITSH) || s == (-0x1000 << BITSH) + || s == (-0x7000 << BITSH) + || s == (0x7000 << BITSH) || s == (1 << (BITSM1 - 2)) + || s == (3 << (BITSM1 - 2)) + 2 + || s == 0x3cbf || s == 0x3cc0 || s == (-0x4000 << BITSH) - 1 + || s == (-0x1000 << BITSH) - 1 || s == (-0x7000 << BITSH) - 1 + || s == (-0x5fcf << BITSH) - 1 || s == -1 || s == -15 || s == -15550 + || s == -15552 || s == (0x7000 << BITSH) - 1 + || s == (1 << (BITSM1 - 2)) - 1 || s == -32 || s == -5 || s == -63 + || s == -64 || s == -65 || s == -8189 || s == -8191 || s == -8192 + || s == -8193 || s == -8250 || s == -8255 || s == -8256 + || s == -8257 || s == __INT_MAX__) + return; + } + abort (); +} + +void +f6 (unsigned int s) +{ + if ((s & 0x3cc0) == 0x3cc0) + { + if (s == 0x3cc0 || s == (0xc000U << BITSH) - 1 + || s == -1U || s == -15U + || s == (1 << (BITSM1 - 2)) - 1 + || s == -32U || s == -5U || s == -63U || s == -64U + || s == __INT_MAX__) + return; + } + else + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == (0xf000U << BITSH) - 1 || s == (0x9000U << BITSH) - 1 + || s == (0xa031U << BITSH) - 1 + || s == (0x7000 << BITSH) - 1 + || s == 0x20 || s == 0x3cbf || s == 0x3f || s == (0xbfbfU << BITSH) + || s == (0xc000U << BITSH) || s == (0xf000U << BITSH) + || s == (0x9000U << BITSH) || s == (0xc000U << BITSH) + 1 || s == 1 + || s == -15550U || s == -15552U || s == (0x7000 << BITSH) + || s == (1 << (BITSM1 - 2)) || s == 1U + __INT_MAX__ || s == 2 + || s == 24 || s == (3 << (BITSM1 - 2)) + 2 || s == 5 || s == -65U + || s == 6U + __INT_MAX__ || s == -8189U || s == -8191U + || s == -8192U || s == -8193U || s == -8250U || s == -8255U + || s == -8256U || s == -8257U || s == __INT_MAX__ + 9U) + return; + } + abort (); +} + +void +f7 (int s) +{ + if ((s & 0x3cc0) == 0x3cc0) + { + if (s == 0x3cc0 || s == (-0x4000 << BITSH) - 1 + || s == -1 || s == -15 + || s == (1 << (BITSM1 - 2)) - 1 + || s == -32 || s == -5 || s == -63 || s == -64 || s == __INT_MAX__) + return; + } + else + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == (-0x1000 << BITSH) - 1 || s == (-0x7000 << BITSH) - 1 + || s == (-0x5fcf << BITSH) - 1 + || s == (0x7000 << BITSH) - 1 + || s == 0x20 || s == 0x3cbf || s == 0x3f || s == (-0x4041 << BITSH) + || s == (-0x4000 << BITSH) || s == (-0x1000 << BITSH) + || s == (-0x7000 << BITSH) || s == (-0x4000 << BITSH) + 1 || s == 1 + || s == -15550 || s == -15552 || s == (0x7000 << BITSH) + || s == (1 << (BITSM1 - 2)) || s == -__INT_MAX__ - 1 || s == 2 + || s == 24 || s == (3 << (BITSM1 - 2)) + 2 || s == 5 || s == -65 + || s == -__INT_MAX__ + 4 || s == -8189 || s == -8191 || s == -8192 + || s == -8193 || s == -8250 || s == -8255 || s == -8256 + || s == -8257 || s == -__INT_MAX__ + 7) + return; + } + abort (); +} + +void +f8 (int s) +{ + if ((s & 0x3cc0U) == 0x3cc0) + { + if (s == 0x3cc0 || s == (-0x4000 << BITSH) - 1 + || s == -1 || s == -15 + || s == (1 << (BITSM1 - 2)) - 1 + || s == -32 || s == -5 || s == -63 || s == -64 || s == __INT_MAX__) + return; + } + else + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == (-0x1000 << BITSH) - 1 || s == (-0x7000 << BITSH) - 1 + || s == (-0x5fcf << BITSH) - 1 + || s == (0x7000 << BITSH) - 1 + || s == 0x20 || s == 0x3cbf || s == 0x3f || s == (-0x4041 << BITSH) + || s == (-0x4000 << BITSH) || s == (-0x1000 << BITSH) + || s == (-0x7000 << BITSH) || s == (-0x4000 << BITSH) + 1 || s == 1 + || s == -15550 || s == -15552 || s == (0x7000 << BITSH) + || s == (1 << (BITSM1 - 2)) || s == -__INT_MAX__ - 1 || s == 2 + || s == 24 || s == (3 << (BITSM1 - 2)) + 2 || s == 5 || s == -65 + || s == -__INT_MAX__ + 4 || s == -8189 || s == -8191 || s == -8192 + || s == -8193 || s == -8250 || s == -8255 || s == -8256 + || s == -8257 || s == -__INT_MAX__ + 7) + return; + } + abort (); +} + +void +f9 (unsigned int s) +{ + if ((s & 0x3cc0) >= 0x1cc0) + { + if (s == 0x1cc0 || s == 0x1fff || s == 0x2000 || s == 0x3cbf + || s == 0x3cc0 || s == (0xc000U << BITSH) - 1 + || s == (0xf000U << BITSH) - 1 + || s == (0xbfbfU << BITSH) || s == (0xf000U << BITSH) + || s == (0x7000 << BITSH) + || s == (1 << (BITSM1 - 2)) || s == (3 << (BITSM1 - 2)) + 2 + || s == (0xa031U << BITSH) - 1 || s == -1U || s == -15U + || s == (0x7000 << BITSH) - 1 || s == (1 << (BITSM1 - 2)) - 1 + || s == -32U || s == -5U || s == -63U || s == -64U || s == -65U + || s == -8189U || s == -8191U || s == -8192U || s == -8193U + || s == -8250U || s == -8255U || s == -8256U || s == __INT_MAX__) + return; + } + else + { + if (s == 0 || s == 0x1cbf || s == 0x20 || s == 0x3f + || s == (0x9000U << BITSH) - 1 || s == (0xc000U << BITSH) + || s == (0x9000U << BITSH) + || s == (0xc000U << BITSH) + 1 || s == 1 || s == -15550U + || s == -15552U + || s == 1U + __INT_MAX__ || s == 2 + || s == 24 || s == 5 + || s == 6U + __INT_MAX__ || s == -8257U || s == __INT_MAX__ + 9U) + return; + } + abort (); +} + +void +f10 (unsigned int s) +{ + if ((s & 0x3cc0) > 0x1cc0) + { + if (s == 0x2000 || s == 0x3cbf || s == 0x3cc0 + || s == (0xc000U << BITSH) - 1 || s == (0xf000U << BITSH) - 1 + || s == (0xbfbfU << BITSH) || s == (0xa031U << BITSH) - 1 + || s == (0xf000U << BITSH) + || s == -1U || s == -15U || s == (0x7000 << BITSH) - 1 + || s == (0x7000 << BITSH) || s == (1 << (BITSM1 - 2)) + || s == -32U || s == (3 << (BITSM1 - 2)) + 2 || s == -5U + || s == -63U || s == -64U || s == -65U || s == -8189U || s == -8191U + || s == -8192U || s == __INT_MAX__) + return; + } + else + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x20 + || s == 0x3f || s == (0x9000U << BITSH) - 1 + || s == (0xc000U << BITSH) || s == (0x9000U << BITSH) + || s == (0xc000U << BITSH) + 1 || s == 1 || s == -15550U + || s == -15552U || s == (1 << (BITSM1 - 2)) - 1 + || s == 1U + __INT_MAX__ || s == 2 + || s == 24 || s == 5 + || s == 6U + __INT_MAX__ || s == -8193U || s == -8250U + || s == -8255U || s == -8256U || s == -8257U + || s == __INT_MAX__ + 9U) + return; + } + abort (); +} + +void +f11 (int s) +{ + if ((s & 0x3cc0) >= 0x1cc0) + { + if (s == 0x1cc0 || s == 0x1fff || s == 0x2000 || s == 0x3cbf + || s == 0x3cc0 || s == (-0x4000 << BITSH) - 1 + || s == (-0x1000 << BITSH) - 1 + || s == (-0x4041 << BITSH) + || s == (-0x1000 << BITSH) + || s == (0x7000 << BITSH) || s == (1 << (BITSM1 - 2)) + || s == (3 << (BITSM1 - 2)) + 2 + || s == (-0x5fcf << BITSH) - 1 || s == -1 || s == -15 + || s == (0x7000 << BITSH) - 1 || s == (1 << (BITSM1 - 2)) - 1 + || s == -32 || s == -5 || s == -63 || s == -64 || s == -65 + || s == -8189 || s == -8191 || s == -8192 || s == -8193 + || s == -8250 || s == -8255 || s == -8256 || s == __INT_MAX__) + return; + } + else + { + if (s == 0 || s == 0x1cbf || s == 0x20 || s == 0x3f + || s == (-0x7000 << BITSH) - 1 || s == (-0x4000 << BITSH) + || s == (-0x7000 << BITSH) + || s == (-0x4000 << BITSH) + 1 || s == 1 || s == -15550 + || s == -15552 + || s == -__INT_MAX__ - 1 || s == 2 || s == 24 + || s == 5 || s == -__INT_MAX__ + 4 + || s == -8257 || s == -__INT_MAX__ + 7) + return; + } + abort (); +} + +void +f12 (int s) +{ + if ((s & 0x3cc0) > 0x1cc0) + { + if (s == 0x2000 || s == 0x3cbf || s == 0x3cc0 + || s == (-0x4000 << BITSH) - 1 || s == (-0x1000 << BITSH) - 1 + || s == (-0x5fcf << BITSH) - 1 + || s == (-0x4041 << BITSH) + || s == (-0x1000 << BITSH) + || s == -1 || s == -15 || s == (0x7000 << BITSH) - 1 + || s == (0x7000 << BITSH) || s == (1 << (BITSM1 - 2)) + || s == (3 << (BITSM1 - 2)) + 2 + || s == -32 || s == -5 || s == -63 + || s == -64 || s == -65 || s == -8189 || s == -8191 || s == -8192 + || s == __INT_MAX__) + return; + } + else + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x20 + || s == 0x3f || s == (-0x7000 << BITSH) - 1 + || s == (-0x4000 << BITSH) || s == (-0x7000 << BITSH) + || s == (-0x4000 << BITSH) + 1 || s == 1 || s == -15550 + || s == -15552 || s == (1 << (BITSM1 - 2)) - 1 + || s == -__INT_MAX__ - 1 || s == 2 || s == 24 + || s == 5 || s == -__INT_MAX__ + 4 + || s == -8193 || s == -8250 || s == -8255 || s == -8256 + || s == -8257 || s == -__INT_MAX__ + 7) + return; + } + abort (); +} + +void +f13 (unsigned int s) +{ + if ((s & (0xe071U << BITSH)) > (0xb030U << BITSH)) + { + if (s == (0xf000U << BITSH) - 1 || s == (0xc000U << BITSH) + || s == (0xf000U << BITSH) || s == (0xc000U << BITSH) + 1 + || s == -1U || s == -15U || s == -15550U || s == -15552U + || s == -32U || s == -5U || s == -63U || s == -64U || s == -65U + || s == -8189U || s == -8191U || s == -8192U || s == -8193U + || s == -8250U || s == -8255U || s == -8256U || s == -8257U) + return; + } + else + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3cbf || s == 0x3cc0 || s == 0x3f + || s == (0xc000U << BITSH) - 1 || s == (0x9000U << BITSH) - 1 + || s == (0xa031U << BITSH) - 1 || s == (0xbfbfU << BITSH) + || s == (0x9000U << BITSH) || s == 1 || s == (0x7000 << BITSH) - 1 + || s == (0x7000 << BITSH) || s == (1 << (BITSM1 - 2)) + || s == (1 << (BITSM1 - 2)) - 1 || s == 1U + __INT_MAX__ || s == 2 + || s == 24 || s == (3 << (BITSM1 - 2)) + 2 || s == 5 + || s == 6U + __INT_MAX__ || s == __INT_MAX__ + || s == __INT_MAX__ + 9U) + return; + } + abort (); +} + +void +f14 (unsigned int s) +{ + if ((s & (0xe071U << BITSH)) > (0xa030U << BITSH)) + { + if (s == (0xc000U << BITSH) - 1 || s == (0xf000U << BITSH) - 1 + || s == (0xbfbfU << BITSH) || s == (0xc000U << BITSH) + || s == (0xf000U << BITSH) || s == (0xc000U << BITSH) + 1 + || s == -1U || s == -15U || s == -15550U || s == -15552U + || s == -32U || s == -5U || s == -63U || s == -64U || s == -65U + || s == -8189U || s == -8191U || s == -8192U || s == -8193U + || s == -8250U || s == -8255U || s == -8256U || s == -8257U) + return; + } + else + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3cbf || s == 0x3cc0 || s == 0x3f + || s == (0x9000U << BITSH) - 1 || s == (0xa031U << BITSH) - 1 + || s == (0x9000U << BITSH) || s == 1 || s == (0x7000 << BITSH) - 1 + || s == (0x7000 << BITSH) || s == (1 << (BITSM1 - 2)) + || s == (1 << (BITSM1 - 2)) - 1 || s == 1U + __INT_MAX__ || s == 2 + || s == 24 || s == (3 << (BITSM1 - 2)) + 2 || s == 5 + || s == 6U + __INT_MAX__ || s == __INT_MAX__ + || s == __INT_MAX__ + 9U) + return; + } + abort (); +} + +void +f15 (int s) +{ + if ((s & ((-0x1f8f) << BITSH)) > ((-0x4fd0) << BITSH)) + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3cbf || s == 0x3cc0 || s == 0x3f + || s == (-0x1000 << BITSH) - 1 || s == (-0x4000 << BITSH) + || s == (-0x1000 << BITSH) || s == (-0x4000 << BITSH) + 1 || s == 1 + || s == -1 || s == -15 || s == -15550 || s == -15552 + || s == (0x7000 << BITSH) - 1 || s == (0x7000 << BITSH) + || s == (1 << (BITSM1 - 2)) || s == (1 << (BITSM1 - 2)) - 1 + || s == 2 || s == 24 || s == -32 || s == (3 << (BITSM1 - 2)) + 2 + || s == 5 || s == -5 || s == -63 || s == -64 || s == -65 + || s == -8189 || s == -8191 || s == -8192 || s == -8193 + || s == -8250 || s == -8255 || s == -8256 || s == -8257 + || s == __INT_MAX__) + return; + } + else + { + if (s == (-0x4000 << BITSH) - 1 || s == (-0x7000 << BITSH) - 1 + || s == (-0x5fcf << BITSH) - 1 || s == (-0x4041 << BITSH) + || s == (-0x7000 << BITSH) || s == -__INT_MAX__ - 1 + || s == -__INT_MAX__ + 4 || s == -__INT_MAX__ + 7) + return; + } + abort (); +} + +void +f16 (int s) +{ + if ((s & ((-0x1f8f) << BITSH)) >= ((-0x4fd0) << BITSH)) + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3cbf || s == 0x3cc0 || s == 0x3f + || s == (-0x1000 << BITSH) - 1 || s == (-0x4000 << BITSH) + || s == (-0x1000 << BITSH) || s == (-0x4000 << BITSH) + 1 || s == 1 + || s == -1 || s == -15 || s == -15550 || s == -15552 + || s == (0x7000 << BITSH) - 1 || s == (0x7000 << BITSH) + || s == (1 << (BITSM1 - 2)) || s == (1 << (BITSM1 - 2)) - 1 + || s == 2 || s == 24 || s == -32 || s == (3 << (BITSM1 - 2)) + 2 + || s == 5 || s == -5 || s == -63 || s == -64 || s == -65 + || s == -8189 || s == -8191 || s == -8192 || s == -8193 + || s == -8250 || s == -8255 || s == -8256 || s == -8257 + || s == __INT_MAX__) + return; + } + else + { + if (s == (-0x4000 << BITSH) - 1 || s == (-0x7000 << BITSH) - 1 + || s == (-0x5fcf << BITSH) - 1 || s == (-0x4041 << BITSH) + || s == (-0x7000 << BITSH) || s == -__INT_MAX__ - 1 + || s == -__INT_MAX__ + 4 || s == -__INT_MAX__ + 7) + return; + } + abort (); +} + +void +f17 (int s) +{ + if ((s & ((-0x4000 << BITSH) | 1)) != -__INT_MAX__ - 1) + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3cbf || s == 0x3cc0 || s == 0x3f + || s == (-0x4000 << BITSH) - 1 || s == (-0x1000 << BITSH) - 1 + || s == (-0x7000 << BITSH) - 1 || s == (-0x4041 << BITSH) + || s == (-0x4000 << BITSH) || s == (-0x1000 << BITSH) + || s == (-0x4000 << BITSH) + 1 || s == 1 || s == -1 || s == -15 + || s == -15550 || s == -15552 || s == (0x7000 << BITSH) - 1 + || s == (0x7000 << BITSH) || s == (1 << (BITSM1 - 2)) + || s == (1 << (BITSM1 - 2)) - 1 || s == 2 || s == 24 || s == -32 + || s == (3 << (BITSM1 - 2)) + 2 || s == 5 || s == -5 || s == -63 + || s == -64 || s == -65 || s == -__INT_MAX__ + 4 || s == -8189 + || s == -8191 || s == -8192 || s == -8193 || s == -8250 + || s == -8255 || s == -8256 || s == -8257 || s == __INT_MAX__) + return; + } + else + { + if (s == (-0x5fcf << BITSH) - 1 || s == (-0x7000 << BITSH) + || s == -__INT_MAX__ - 1 || s == -__INT_MAX__ + 7) + return; + } + abort (); +} + +void +f18 (int s) +{ + if ((s & ((-0x4000 << BITSH) | 1)) != ((-0x4000 << BITSH) | 1)) + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3cbf || s == 0x3cc0 || s == 0x3f + || s == (-0x4000 << BITSH) - 1 || s == (-0x7000 << BITSH) - 1 + || s == (-0x5fcf << BITSH) - 1 || s == (-0x4041 << BITSH) + || s == (-0x4000 << BITSH) || s == (-0x1000 << BITSH) + || s == (-0x7000 << BITSH) || s == 1 || s == -15550 || s == -15552 + || s == (0x7000 << BITSH) - 1 || s == (0x7000 << BITSH) + || s == (1 << (BITSM1 - 2)) || s == (1 << (BITSM1 - 2)) - 1 + || s == -__INT_MAX__ - 1 || s == 2 || s == 24 || s == -32 + || s == (3 << (BITSM1 - 2)) + 2 || s == 5 || s == -64 + || s == -__INT_MAX__ + 4 || s == -8192 || s == -8250 || s == -8256 + || s == __INT_MAX__ || s == -__INT_MAX__ + 7) + return; + } + else + { + if (s == (-0x1000 << BITSH) - 1 || s == (-0x4000 << BITSH) + 1 + || s == -1 || s == -15 || s == -5 || s == -63 || s == -65 + || s == -8189 || s == -8191 || s == -8193 || s == -8255 + || s == -8257) + return; + } + abort (); +} + +void +f19 (int s) +{ + if ((s & ((-0x4000 << BITSH) | 1)) != ((0x4000 << BITSH) | 1)) + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3cbf || s == 0x3cc0 || s == 0x3f + || s == (-0x4000 << BITSH) - 1 || s == (-0x1000 << BITSH) - 1 + || s == (-0x7000 << BITSH) - 1 || s == (-0x5fcf << BITSH) - 1 + || s == (-0x4041 << BITSH) || s == (-0x4000 << BITSH) + || s == (-0x1000 << BITSH) || s == (-0x7000 << BITSH) + || s == (-0x4000 << BITSH) + 1 || s == 1 || s == -1 || s == -15 + || s == -15550 || s == -15552 || s == (0x7000 << BITSH) + || s == (1 << (BITSM1 - 2)) || s == (1 << (BITSM1 - 2)) - 1 + || s == -__INT_MAX__ - 1 || s == 2 || s == 24 || s == -32 + || s == (3 << (BITSM1 - 2)) + 2 || s == 5 || s == -5 || s == -63 + || s == -64 || s == -65 || s == -__INT_MAX__ + 4 || s == -8189 + || s == -8191 || s == -8192 || s == -8193 || s == -8250 + || s == -8255 || s == -8256 || s == -8257 || s == -__INT_MAX__ + 7) + return; + } + else + { + if (s == (0x7000 << BITSH) - 1 || s == __INT_MAX__) + return; + } + abort (); +} + +void +f20 (int s) +{ + if ((s & (-0x1000 << BITSH)) != -__INT_MAX__ - 1) + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3cbf || s == 0x3cc0 || s == 0x3f + || s == (-0x4000 << BITSH) - 1 || s == (-0x1000 << BITSH) - 1 + || s == (-0x5fcf << BITSH) - 1 || s == (-0x4041 << BITSH) + || s == (-0x4000 << BITSH) || s == (-0x1000 << BITSH) + || s == (-0x7000 << BITSH) || s == (-0x4000 << BITSH) + 1 || s == 1 + || s == -1 || s == -15 || s == -15550 || s == -15552 + || s == (0x7000 << BITSH) - 1 || s == (0x7000 << BITSH) + || s == (1 << (BITSM1 - 2)) || s == (1 << (BITSM1 - 2)) - 1 + || s == 2 || s == 24 || s == -32 || s == (3 << (BITSM1 - 2)) + 2 + || s == 5 || s == -5 || s == -63 || s == -64 || s == -65 + || s == -8189 || s == -8191 || s == -8192 || s == -8193 + || s == -8250 || s == -8255 || s == -8256 || s == -8257 + || s == __INT_MAX__) + return; + } + else + { + if (s == (-0x7000 << BITSH) - 1 || s == -__INT_MAX__ - 1 + || s == -__INT_MAX__ + 4 || s == -__INT_MAX__ + 7) + return; + } + abort (); +} + +void +f21 (int s) +{ + if ((s & (-0x1000 << BITSH)) != (-0x1000 << BITSH)) + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3cbf || s == 0x3cc0 || s == 0x3f + || s == (-0x4000 << BITSH) - 1 || s == (-0x1000 << BITSH) - 1 + || s == (-0x7000 << BITSH) - 1 || s == (-0x5fcf << BITSH) - 1 + || s == (-0x4041 << BITSH) || s == (-0x4000 << BITSH) + || s == (-0x7000 << BITSH) || s == (-0x4000 << BITSH) + 1 || s == 1 + || s == -15550 || s == -15552 + || s == (0x7000 << BITSH) - 1 || s == (0x7000 << BITSH) + || s == (1 << (BITSM1 - 2)) || s == (1 << (BITSM1 - 2)) - 1 + || s == -__INT_MAX__ - 1 || s == 2 || s == 24 + || s == (3 << (BITSM1 - 2)) + 2 || s == 5 || s == -__INT_MAX__ + 4 + || s == -8189 || s == -8191 || s == -8192 || s == -8193 + || s == -8250 || s == -8255 || s == -8256 || s == -8257 + || s == __INT_MAX__ || s == -__INT_MAX__ + 7) + return; + } + else + { + if (s == (-0x1000 << BITSH) || s == -1 || s == -15 + || s == -32 || s == -5 || s == -63 || s == -64 + || s == -65) + return; + } + abort (); +} + +void +f22 (int s) +{ + if ((s & (-0x1000 << BITSH)) != (0x7000 << BITSH)) + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3cbf || s == 0x3cc0 || s == 0x3f + || s == (-0x4000 << BITSH) - 1 || s == (-0x1000 << BITSH) - 1 + || s == (-0x7000 << BITSH) - 1 || s == (-0x5fcf << BITSH) - 1 + || s == (-0x4041 << BITSH) || s == (-0x4000 << BITSH) + || s == (-0x1000 << BITSH) || s == (-0x7000 << BITSH) + || s == (-0x4000 << BITSH) + 1 || s == 1 || s == -1 || s == -15 + || s == -15550 || s == -15552 || s == (0x7000 << BITSH) - 1 + || s == (1 << (BITSM1 - 2)) || s == (1 << (BITSM1 - 2)) - 1 + || s == -__INT_MAX__ - 1 || s == 2 || s == 24 || s == -32 + || s == (3 << (BITSM1 - 2)) + 2 || s == 5 || s == -5 || s == -63 + || s == -64 || s == -65 || s == -__INT_MAX__ + 4 || s == -8189 + || s == -8191 || s == -8192 || s == -8193 || s == -8250 + || s == -8255 || s == -8256 || s == -8257 || s == -__INT_MAX__ + 7) + return; + } + else + { + if (s == (0x7000 << BITSH) || s == __INT_MAX__) + return; + } + abort (); +} + +void +f23 (unsigned int s) +{ + if ((s & (0xf000U << BITSH)) != (0x7000 << BITSH)) + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3cbf || s == 0x3cc0 || s == 0x3f + || s == (0xc000U << BITSH) - 1 || s == (0xf000U << BITSH) - 1 + || s == (0x9000U << BITSH) - 1 || s == (0xa031U << BITSH) - 1 + || s == (0xbfbfU << BITSH) || s == (0xc000U << BITSH) + || s == (0xf000U << BITSH) || s == (0x9000U << BITSH) + || s == (0xc000U << BITSH) + 1 || s == 1 || s == -1U || s == -15U + || s == -15550U || s == -15552U || s == (0x7000 << BITSH) - 1 + || s == (1 << (BITSM1 - 2)) || s == (1 << (BITSM1 - 2)) - 1 + || s == 1U + __INT_MAX__ || s == 2 || s == 24 || s == -32U + || s == (3 << (BITSM1 - 2)) + 2 || s == 5 || s == -5U || s == -63U + || s == -64U || s == -65U || s == 6U + __INT_MAX__ || s == -8189U + || s == -8191U || s == -8192U || s == -8193U || s == -8250U + || s == -8255U || s == -8256U || s == -8257U + || s == __INT_MAX__ + 9U) + return; + } + else + { + if (s == (0x7000 << BITSH) || s == __INT_MAX__) + return; + } + abort (); +} + +void +f24 (unsigned int s) +{ + if ((s & (0xf000U << BITSH)) != (0x8000U << BITSH)) + { + if (s == 0 || s == 0x1cbf || s == 0x1cc0 || s == 0x1fff || s == 0x2000 + || s == 0x20 || s == 0x3cbf || s == 0x3cc0 || s == 0x3f + || s == (0xc000U << BITSH) - 1 || s == (0xf000U << BITSH) - 1 + || s == (0xa031U << BITSH) - 1 || s == (0xbfbfU << BITSH) + || s == (0xc000U << BITSH) || s == (0xf000U << BITSH) + || s == (0x9000U << BITSH) || s == (0xc000U << BITSH) + 1 || s == 1 + || s == -1U || s == -15U || s == -15550U || s == -15552U + || s == (0x7000 << BITSH) - 1 || s == (0x7000 << BITSH) + || s == (1 << (BITSM1 - 2)) || s == (1 << (BITSM1 - 2)) - 1 + || s == 2 || s == 24 || s == -32U || s == (3 << (BITSM1 - 2)) + 2 + || s == 5 || s == -5U || s == -63U || s == -64U || s == -65U + || s == -8189U || s == -8191U || s == -8192U || s == -8193U + || s == -8250U || s == -8255U || s == -8256U || s == -8257U + || s == __INT_MAX__) + return; + } + else + { + if (s == (0x9000U << BITSH) - 1 || s == 1U + __INT_MAX__ + || s == 6U + __INT_MAX__ || s == __INT_MAX__ + 9U) + return; + } + abort (); +} + +/* Make this easier to run on microcontroller architectures by using a switch + statements instead of arrays. + We still don't want the compiler to constant-propagate the array contents, + so use an asm in each accessor function with to hide what's going on. */ + +int +svals (int i) +{ + asm ("" : "=g" (i) : "0" (i)); + switch (i) + { + case 0: return 0; + case 1: return 0x1cbf; + case 2: return 0x1cc0; + case 3: return 0x1fff; + case 4: return 0x2000; + case 5: return 0x20; + case 6: return 0x3cbf; + case 7: return 0x3cc0; + case 8: return 0x3f; + case 9: return (-0x4000 << BITSH) - 1; + case 10: return (-0x1000 << BITSH) - 1; + case 11: return (-0x7000 << BITSH) - 1; + case 12: return (-0x5fcf << BITSH) - 1; + case 13: return (-0x4041 << BITSH); + case 14: return (-0x4000 << BITSH); + case 15: return (-0x1000 << BITSH); + case 16: return (-0x7000 << BITSH); + case 17: return (-0x4000 << BITSH) + 1; + case 18: return 1; + case 19: return -1; + case 20: return -15; + case 21: return -15550; + case 22: return -15552; + case 23: return (0x7000 << BITSH) - 1; + case 24: return (0x7000 << BITSH); + case 25: return (1 << (BITSM1 - 2)); + case 26: return (1 << (BITSM1 - 2)) - 1; + case 27: return -__INT_MAX__ - 1; + case 28: return 2; + case 29: return 24; + case 30: return -32; + case 31: return (3 << (BITSM1 - 2)) + 2; + case 32: return 5; + case 33: return -5; + case 34: return -63; + case 35: return -64; + case 36: return -65; + case 37: return -__INT_MAX__ + 4; + case 38: return -8189; + case 39: return -8191; + case 40: return -8192; + case 41: return -8193; + case 42: return -8250; + case 43: return -8255; + case 44: return -8256; + case 45: return -8257; + case 46: return __INT_MAX__; + case 47: return -__INT_MAX__ + 7; +#define SVAL_NUM 48 + default: abort (); + } +}; + +unsigned int +uvals (int i) +{ + asm ("" : "=g" (i) : "0" (i)); + switch (i) + { + case 0: return 0; + case 1: return 0x1cbf; + case 2: return 0x1cc0; + case 3: return 0x1fff; + case 4: return 0x2000; + case 5: return 0x20; + case 6: return 0x3cbf; + case 7: return 0x3cc0; + case 8: return 0x3f; + case 9: return (0xc000U << BITSH) - 1; + case 10: return (0xf000U << BITSH) - 1; + case 11: return (0x9000U << BITSH) - 1; + case 12: return (0xa031U << BITSH) - 1; + case 13: return (0xbfbfU << BITSH); + case 14: return (0xc000U << BITSH); + case 15: return (0xf000U << BITSH); + case 16: return (0x9000U << BITSH); + case 17: return (0xc000U << BITSH) + 1; + case 18: return 1; + case 19: return -1U; + case 20: return -15U; + case 21: return -15550U; + case 22: return -15552U; + case 23: return (0x7000 << BITSH) - 1; + case 24: return (0x7000 << BITSH); + case 25: return (1 << (BITSM1 - 2)); + case 26: return (1 << (BITSM1 - 2)) - 1; + case 27: return 1U + __INT_MAX__; + case 28: return 2; + case 29: return 24; + case 30: return -32U; + case 31: return (3 << (BITSM1 - 2)) + 2; + case 32: return 5; + case 33: return -5U; + case 34: return -63U; + case 35: return -64U; + case 36: return -65U; + case 37: return 6U + __INT_MAX__; + case 38: return -8189U; + case 39: return -8191U; + case 40: return -8192U; + case 41: return -8193U; + case 42: return -8250U; + case 43: return -8255U; + case 44: return -8256U; + case 45: return -8257U; + case 46: return __INT_MAX__; + case 47: return __INT_MAX__ + 9U; +#define UVAL_NUM 48 + default: abort (); + } +}; + +int +main () +{ + int i; + for (i = 0; i < SVAL_NUM; i++) + { + f2 (svals (i)); + f4 (svals (i)); + f5 (svals (i)); + f7 (svals (i)); + f8 (svals (i)); + f11 (svals (i)); + f12 (svals (i)); + f15 (svals (i)); + f16 (svals (i)); + f17 (svals (i)); + f18 (svals (i)); + f19 (svals (i)); + f20 (svals (i)); + f21 (svals (i)); + f22 (svals (i)); + } + for (i = 0; i < UVAL_NUM; i++) + { + f1 (uvals (i)); + f3 (uvals (i)); + f6 (uvals (i)); + f9 (uvals (i)); + f10 (uvals (i)); + f13 (uvals (i)); + f14 (uvals (i)); + f23 (uvals (i)); + f24 (uvals (i)); + } + return 0; +} diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp66.c b/gcc/testsuite/gcc.dg/tree-ssa/vrp66.c index 19e0450ac5b..6a6ab3463fe 100644 --- a/gcc/testsuite/gcc.dg/tree-ssa/vrp66.c +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp66.c @@ -1,5 +1,5 @@ /* PR tree-optimization/52267 */ -/* { dg-do run } */ +/* { dg-do run { target { ! int16 } } } */ /* { dg-options "-O2" } */ extern void abort (void); diff --git a/gcc/testsuite/gcc.dg/tree-ssa/vrp89.c b/gcc/testsuite/gcc.dg/tree-ssa/vrp89.c new file mode 100644 index 00000000000..3e1d96e42af --- /dev/null +++ b/gcc/testsuite/gcc.dg/tree-ssa/vrp89.c @@ -0,0 +1,57 @@ +/* PR target/29776 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -fdump-tree-vrp1" } */ +/* { dg-final { scan-tree-dump-not "link_error" "vrp1"} } */ +/* { dg-final { cleanup-tree-dump "vrp1" } } */ + +#define A(fn, arg, min, max) \ + if (__builtin_##fn (arg) < min || __builtin_##fn (arg) > max) \ + link_error (); +#define B(fn, min, max) \ + A (fn, a, min, max) A (fn##l, b, min, max) A (fn##ll, c, min, max) +#define C(fn, min, sub) \ + A (fn, a, min, ((int) sizeof (a) * __CHAR_BIT__ - sub)) \ + A (fn##l, b, min, ((int) sizeof (b) * __CHAR_BIT__ - sub)) \ + A (fn##ll, c, min, ((int) sizeof (c) * __CHAR_BIT__ - sub)) +#define D(fn, sub1, sub2) \ + A (fn, a, ((int) sizeof (a) * __CHAR_BIT__ - sub1), \ + ((int) sizeof (a) * __CHAR_BIT__ - sub2)) \ + A (fn##l, b, ((int) sizeof (b) * __CHAR_BIT__ - sub1), \ + ((int) sizeof (b) * __CHAR_BIT__ - sub2)) \ + A (fn##ll, c, ((int) sizeof (c) * __CHAR_BIT__ - sub1), \ + ((int) sizeof (c) * __CHAR_BIT__ - sub2)) + +extern void link_error (void); + +unsigned int d; +unsigned long e; +unsigned long long f; + +void +foo (unsigned int a, unsigned long b, unsigned long long c) +{ + B (parity, 0, 1) + C (ffs, 0, 0) + C (popcount, 0, 0) + C (clz, 0, 0) + C (ctz, -1, 0) + a &= 63; + b &= 63; + c &= 63; + B (ffs, 0, 6) + B (popcount, 0, 6) + a += 3; b += 3; c += 3; + B (ffs, 1, 7) + B (popcount, 1, 7) + a = 32U + (d & 1023U); + b = 32UL + (e & 1023UL); + c = 32ULL + (f & 1023ULL); + D (clz, 11, 6) + B (ctz, 0, 10) +} + +void +bar (int a, long b, long long c) +{ + C (clrsb, 0, 1) +} diff --git a/gcc/testsuite/gcc.target/avr/torture/pr57631.c b/gcc/testsuite/gcc.target/avr/torture/pr57631.c new file mode 100644 index 00000000000..ecefbfc81b7 --- /dev/null +++ b/gcc/testsuite/gcc.target/avr/torture/pr57631.c @@ -0,0 +1,17 @@ +/* PR target/57631 */ +/* { dg-do compile } */ + +void __attribute__((signal)) func1 (void) __asm ("__vector1"); +void func1 (void) +{ +} + +void __attribute__((signal)) func2 (void) __asm ("__vecto1"); +void func2 (void) /* { dg-warning "misspelled signal handler" } */ +{ +} + +void __attribute__((signal)) __vector_3 (void) __asm ("__vecto1"); +void __vector_3 (void) /* { dg-warning "misspelled signal handler" } */ +{ +} diff --git a/gcc/testsuite/gcc.target/i386/memcpy-vector_loop-1.c b/gcc/testsuite/gcc.target/i386/memcpy-vector_loop-1.c new file mode 100644 index 00000000000..c61c067951b --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/memcpy-vector_loop-1.c @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=atom -minline-all-stringops -mstringop-strategy=vector_loop" } */ +/* { dg-final { scan-assembler-times "movdqa" 8 { target { ! { ia32 } } } } } */ +/* { dg-final { scan-assembler-times "movdqa" 4 { target { ia32 } } } } */ + +char a[2048]; +char b[2048]; +void t (void) +{ + __builtin_memcpy (a, b, 2048); +} + diff --git a/gcc/testsuite/gcc.target/i386/memcpy-vector_loop-2.c b/gcc/testsuite/gcc.target/i386/memcpy-vector_loop-2.c new file mode 100644 index 00000000000..8a646d509a1 --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/memcpy-vector_loop-2.c @@ -0,0 +1,12 @@ +/* { dg-do compile } */ +/* { dg-options "-O2 -march=atom -minline-all-stringops -mstringop-strategy=vector_loop" } */ +/* { dg-final { scan-assembler-times "movdqa" 4} } */ + +char *a; +char *b; +void t (void) +{ + __builtin_memcpy (a, b, 2048); +} + + diff --git a/gcc/testsuite/gcc.target/i386/pr55342.c b/gcc/testsuite/gcc.target/i386/pr55342.c new file mode 100644 index 00000000000..0d9e6c6238c --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr55342.c @@ -0,0 +1,28 @@ +/* PR rtl-optimization/55342 */ +/* { dg-do compile } */ +/* { dg-options "-O2" } */ +/* { dg-final { scan-assembler-not "notb" } } */ + + +void convert_image(unsigned char *in, unsigned char *out, int size) { + int i; + unsigned char * read = in, + * write = out; + for(i = 0; i < size; i++) { + unsigned char r = *read++; + unsigned char g = *read++; + unsigned char b = *read++; + unsigned char c, m, y, k, tmp; + c = 255 - r; + m = 255 - g; + y = 255 - b; + if (c < m) + k = ((c) > (y)?(y):(c)); + else + k = ((m) > (y)?(y):(m)); + *write++ = c - k; + *write++ = m - k; + *write++ = y - k; + *write++ = k; + } +} diff --git a/gcc/testsuite/gcc.target/i386/pr57807.c b/gcc/testsuite/gcc.target/i386/pr57807.c new file mode 100644 index 00000000000..48c1e99e96d --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr57807.c @@ -0,0 +1,11 @@ +/* { dg-do assemble } */ +/* { dg-options "-msse2 -masm=intel" } */ +/* { dg-require-effective-target sse2 } */ +/* { dg-require-effective-target masm_intel } */ + +typedef double __v2df __attribute__((__vector_size__(16))); +typedef double __m128d __attribute__((__vector_size__(16), __may_alias__)); + +__m128d _mm_unpacklo_pd(__m128d __A, __m128d __B) { + return (__m128d)__builtin_ia32_unpcklpd((__v2df)__A, (__v2df)__B); +} diff --git a/gcc/testsuite/gcc.target/i386/pr57819.c b/gcc/testsuite/gcc.target/i386/pr57819.c new file mode 100644 index 00000000000..b086a40c4ce --- /dev/null +++ b/gcc/testsuite/gcc.target/i386/pr57819.c @@ -0,0 +1,38 @@ +/* PR target/57819 */ +/* { dg-do compile } */ +/* { dg-options "-O2 -mtune=core2" } */ + +void foo (void); + +__extension__ typedef __INTPTR_TYPE__ intptr_t; + +int +test1 (intptr_t x, intptr_t n) +{ + n &= sizeof (intptr_t) * __CHAR_BIT__ - 1; + + if (x & ((intptr_t) 1 << n)) + foo (); + + return 0; +} + +int +test2 (intptr_t x, intptr_t n) +{ + if (x & ((intptr_t) 1 << ((int) n & (sizeof (intptr_t) * __CHAR_BIT__ - 1)))) + foo (); + + return 0; +} + +int +test3 (intptr_t x, intptr_t n) +{ + if (x & ((intptr_t) 1 << ((int) n & ((int) sizeof (intptr_t) * __CHAR_BIT__ - 1)))) + foo (); + + return 0; +} + +/* { dg-final { scan-assembler-not "and\[lq\]\[ \t\]" } } */ diff --git a/gcc/testsuite/gcc.target/mips/mulsize-1.c b/gcc/testsuite/gcc.target/mips/mulsize-1.c new file mode 100644 index 00000000000..4dd5a19a985 --- /dev/null +++ b/gcc/testsuite/gcc.target/mips/mulsize-1.c @@ -0,0 +1,9 @@ +/* { dg-final { scan-assembler "\t.globl\tf7" } } */ +/* { dg-final { scan-assembler "\tsubu\t" } } */ +/* { dg-final { scan-assembler-not "\tli\t" } } */ +/* { dg-final { scan-assembler-not "\tmul\t" } } */ +int +f7(int x) +{ + return x * 7; +} diff --git a/gcc/testsuite/gcc.target/mips/mulsize-2.c b/gcc/testsuite/gcc.target/mips/mulsize-2.c new file mode 100644 index 00000000000..c427bfa78f1 --- /dev/null +++ b/gcc/testsuite/gcc.target/mips/mulsize-2.c @@ -0,0 +1,9 @@ +/* { dg-final { scan-assembler "\t.globl\tf9" } } */ +/* { dg-final { scan-assembler "\tsubu\t" } } */ +/* { dg-final { scan-assembler-not "\tli\t" } } */ +/* { dg-final { scan-assembler-not "\tmul\t" } } */ +int +f9(int x) +{ + return x * 9; +} diff --git a/gcc/testsuite/gcc.target/mips/mulsize-3.c b/gcc/testsuite/gcc.target/mips/mulsize-3.c new file mode 100644 index 00000000000..552d8c99dfa --- /dev/null +++ b/gcc/testsuite/gcc.target/mips/mulsize-3.c @@ -0,0 +1,12 @@ +/* { dg-final { scan-assembler "\t.globl\tf15" } } */ +/* { dg-final { scan-assembler "\tsll\t" } } */ +/* { dg-final { scan-assembler "\tsubu\t" } } */ +/* { dg-final { scan-assembler-not "\tli\t" } } */ +/* { dg-final { scan-assembler-not "\tmul\t" } } */ +int +f15(int x) +{ + return x * 15; +} + +
\ No newline at end of file diff --git a/gcc/testsuite/gcc.target/mips/mulsize-4.c b/gcc/testsuite/gcc.target/mips/mulsize-4.c new file mode 100644 index 00000000000..7694d2c03dc --- /dev/null +++ b/gcc/testsuite/gcc.target/mips/mulsize-4.c @@ -0,0 +1,11 @@ +/* { dg-final { scan-assembler "\t.globl\tf17" } } */ +/* { dg-final { scan-assembler "\tsll\t" } } */ +/* { dg-final { scan-assembler "\taddu\t" } } */ +/* { dg-final { scan-assembler-not "\tli\t" } } */ +/* { dg-final { scan-assembler-not "\tmul\t" } } */ +int +f17(int x) +{ + return x * 17; +} +
\ No newline at end of file diff --git a/gcc/testsuite/gcc.target/powerpc/20020118-1.c b/gcc/testsuite/gcc.target/powerpc/20020118-1.c index 49197b49032..b92dd2a7a35 100644 --- a/gcc/testsuite/gcc.target/powerpc/20020118-1.c +++ b/gcc/testsuite/gcc.target/powerpc/20020118-1.c @@ -1,6 +1,8 @@ /* { dg-do run { target powerpc*-*-* } }*/ /* VxWorks only guarantees 64 bits of alignment (STACK_BOUNDARY == 64). */ /* { dg-skip-if "" { "powerpc*-*-vxworks*" } { "*" } { "" } } */ +/* Force 128-bit stack alignment for eabi targets. */ +/* { dg-options "-mno-eabi" { target powerpc*-*-eabi* } } */ /* Test local alignment. Test new target macro STARTING_FRAME_PHASE. */ /* Origin: Aldy Hernandez <aldyh@redhat.com>. */ diff --git a/gcc/testsuite/gcc.target/powerpc/ppc-spe64-1.c b/gcc/testsuite/gcc.target/powerpc/ppc-spe64-1.c index f07e818faec..a9d632bf9f3 100644 --- a/gcc/testsuite/gcc.target/powerpc/ppc-spe64-1.c +++ b/gcc/testsuite/gcc.target/powerpc/ppc-spe64-1.c @@ -4,4 +4,4 @@ /* { dg-options "-m64" } */ /* { dg-error "-m64 not supported in this configuration" "SPE not 64-bit" { target *-*-* } 0 } */ -/* { dg-error "64-bit E500 not supported" "64-bit E500" { target *-*-* } 0 } */ +/* { dg-error "64-bit SPE not supported" "64-bit SPE" { target *-*-* } 0 } */ diff --git a/gcc/testsuite/gcc.target/powerpc/pr47197.c b/gcc/testsuite/gcc.target/powerpc/pr47197.c index 729dcfb364a..a8930f2a5c8 100644 --- a/gcc/testsuite/gcc.target/powerpc/pr47197.c +++ b/gcc/testsuite/gcc.target/powerpc/pr47197.c @@ -1,4 +1,5 @@ /* { dg-do compile } */ +/* { dg-require-effective-target powerpc_altivec_ok } */ /* { dg-options "-maltivec" } */ /* Compile-only test to ensure that expressions can be passed to diff --git a/gcc/testsuite/gcc.target/powerpc/sd-pwr6.c b/gcc/testsuite/gcc.target/powerpc/sd-pwr6.c index 98f7615daef..59b68ee36e2 100644 --- a/gcc/testsuite/gcc.target/powerpc/sd-pwr6.c +++ b/gcc/testsuite/gcc.target/powerpc/sd-pwr6.c @@ -1,6 +1,7 @@ /* { dg-do compile { target { powerpc*-*-* } } } */ /* { dg-skip-if "" { powerpc*-*-darwin* powerpc-ibm-aix* } { "*" } { "" } } */ /* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-require-effective-target dfp } */ /* { dg-options "-O2 -mcpu=power6 -mhard-dfp" } */ /* { dg-final { scan-assembler-not "lfiwzx" } } */ /* { dg-final { scan-assembler-times "lfd" 2 } } */ diff --git a/gcc/testsuite/gcc.target/powerpc/sd-vsx.c b/gcc/testsuite/gcc.target/powerpc/sd-vsx.c index 7a3c6d8777d..c7cb7511282 100644 --- a/gcc/testsuite/gcc.target/powerpc/sd-vsx.c +++ b/gcc/testsuite/gcc.target/powerpc/sd-vsx.c @@ -1,6 +1,7 @@ /* { dg-do compile { target { powerpc*-*-* } } } */ /* { dg-skip-if "" { powerpc*-*-darwin* powerpc-ibm-aix* } { "*" } { "" } } */ /* { dg-require-effective-target powerpc_vsx_ok } */ +/* { dg-require-effective-target dfp } */ /* { dg-options "-O2 -mcpu=power7 -mhard-dfp" } */ /* { dg-final { scan-assembler-times "lfiwzx" 2 } } */ /* { dg-final { scan-assembler-times "stfiwx" 1 } } */ diff --git a/gcc/testsuite/gcc.target/powerpc/tfmode_off.c b/gcc/testsuite/gcc.target/powerpc/tfmode_off.c index 32b23e6fa7b..e6578ef31a8 100644 --- a/gcc/testsuite/gcc.target/powerpc/tfmode_off.c +++ b/gcc/testsuite/gcc.target/powerpc/tfmode_off.c @@ -1,5 +1,6 @@ /* { dg-do assemble } */ /* { dg-skip-if "" { powerpc-ibm-aix* } { "*" } { "" } } */ +/* { dg-skip-if "no TFmode" { powerpc-*-eabi* } { "*" } { "" } } */ /* { dg-options "-O2 -fno-align-functions -mtraceback=no -save-temps" } */ typedef float TFmode __attribute__ ((mode (TF))); diff --git a/gcc/testsuite/gfortran.dg/c_f_pointer_tests_8.f90 b/gcc/testsuite/gfortran.dg/c_f_pointer_tests_8.f90 new file mode 100644 index 00000000000..d82c9ea8a3c --- /dev/null +++ b/gcc/testsuite/gfortran.dg/c_f_pointer_tests_8.f90 @@ -0,0 +1,37 @@ +! { dg-do compile } +! { dg-options "-std=f2003" } +! +! PR fortran/57834 +! +! (Gave a bogus warning before.) +! +program main + + use iso_c_binding + use iso_fortran_env + + implicit none + + interface + function strerror(errno) bind(C, NAME = 'strerror') + import + type(C_PTR) :: strerror + integer(C_INT), value :: errno + end function + end interface + + integer :: i + type(C_PTR) :: cptr + character(KIND=C_CHAR), pointer :: str(:) + + cptr = strerror(INT(42, KIND = C_INT)) + call C_F_POINTER(cptr, str, [255]) + + do i = 1, SIZE(str) + if (str(i) == C_NULL_CHAR) exit + write (ERROR_UNIT, '(A1)', ADVANCE = 'NO') str(i:i) + enddo + + write (ERROR_UNIT, '(1X)') + +end program main diff --git a/gcc/testsuite/gfortran.dg/defined_assignment_7.f90 b/gcc/testsuite/gfortran.dg/defined_assignment_7.f90 index 5f60f50e781..b2e43535e6b 100644 --- a/gcc/testsuite/gfortran.dg/defined_assignment_7.f90 +++ b/gcc/testsuite/gfortran.dg/defined_assignment_7.f90 @@ -1,4 +1,4 @@ -! { dg-compile } +! { dg-do compile } ! ! PR fortran/57508 ! diff --git a/gcc/testsuite/gfortran.dg/do_check_9.f90 b/gcc/testsuite/gfortran.dg/do_check_9.f90 new file mode 100644 index 00000000000..9cc133b8f6a --- /dev/null +++ b/gcc/testsuite/gfortran.dg/do_check_9.f90 @@ -0,0 +1,14 @@ +! { dg-do compile } +! +! PR fortran/50554 +! +! Contributed by Vittorio Zecca +! +! INQUIRE cannot redefine DO index +! + do I=1,10 ! { dg-error "cannot be redefined inside loop beginning at" } + inquire(iolength=I) n ! { dg-error "cannot be redefined inside loop beginning at" } + inquire(99,size=I) ! { dg-error "cannot be redefined inside loop beginning at" } + read(99,'(i4)',size=I,advance="no") n ! { dg-error "cannot be redefined inside loop beginning at" } + end do + end diff --git a/gcc/testsuite/gfortran.dg/dot_product_2.f90 b/gcc/testsuite/gfortran.dg/dot_product_2.f90 new file mode 100644 index 00000000000..a5fe3b05178 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/dot_product_2.f90 @@ -0,0 +1,38 @@ +! { dg-do compile } +! { dg-options "-fdump-tree-original" } +! +! PR fortran/57785 +! +! Contributed by Kontantinos Anagnostopoulos +! +! The implicit complex conjugate was missing for DOT_PRODUCT + + +! For the following, the compile-time simplification fails for SUM; +! see PR fortran/56342. Hence, a manually expanded SUM is used. + +!if (DOT_PRODUCT ((/ (1.0, 2.0), (2.0, 3.0) /), (/ (1.0, 1.0), (1.0, 4.0) /)) & +! /= SUM (CONJG ((/ (1.0, 2.0), (2.0, 3.0) /))*(/ (1.0, 1.0), (1.0, 4.0) /))) & +! call abort () +! +!if (ANY (MATMUL ((/ (1.0, 2.0), (2.0, 3.0) /), & +! RESHAPE ((/ (1.0, 1.0), (1.0, 4.0) /),(/2, 1/))) /= & +! SUM ((/ (1.0, 2.0), (2.0, 3.0) /)*(/ (1.0, 1.0), (1.0, 4.0) /)))) & +! call abort () + + +if (DOT_PRODUCT ((/ (1.0, 2.0), (2.0, 3.0) /), (/ (1.0, 1.0), (1.0, 4.0) /)) & + /= CONJG (cmplx(1.0, 2.0)) * cmplx(1.0, 1.0) & + + CONJG (cmplx(2.0, 3.0)) * cmplx(1.0, 4.0)) & + call abort () + +if (ANY (MATMUL ((/ (1.0, 2.0), (2.0, 3.0) /), & + RESHAPE ((/ (1.0, 1.0), (1.0, 4.0) /),(/2, 1/))) & + /= cmplx(1.0, 2.0) * cmplx(1.0, 1.0) & + + cmplx(2.0, 3.0) * cmplx(1.0, 4.0))) & + call abort () +end + + +! { dg-final { scan-tree-dump-not "abort" "original" } } +! { dg-final { cleanup-tree-dump "original" } } diff --git a/gcc/testsuite/gfortran.dg/finalize_10.f90 b/gcc/testsuite/gfortran.dg/finalize_10.f90 index c56e13a09f1..e042f11146c 100644 --- a/gcc/testsuite/gfortran.dg/finalize_10.f90 +++ b/gcc/testsuite/gfortran.dg/finalize_10.f90 @@ -32,8 +32,8 @@ end subroutine foo ! FINALIZE TYPE: ! { dg-final { scan-tree-dump-times "parm.\[0-9\]+.data = \\(void \\*\\) &\\(\\*aa.\[0-9\]+\\)\\\[0\\\];" 1 "original" } } -! { dg!final { scan-tree-dump-times "__final_m_T2 (&parm.\[0-9\]+, 0, 0);" 1 "original" } } -! { dg!final { scan-tree-dump-times "desc.\[0-9\]+.data = \\(void \\* restrict\\) bb;" 1 "original" } } -! { dg!final { scan-tree-dump-times "__final_m_T2 (&desc.\[0-9\]+, 0, 0);" 1 "original" } } +! { dg-final { scan-tree-dump-times "__final_m_T2 \\(&parm.\[0-9\]+, 0, 0\\);" 1 "original" } } +! { dg-final { scan-tree-dump-times "desc.\[0-9\]+.data = \\(void \\* restrict\\) bb;" 1 "original" } } +! { dg-final { scan-tree-dump-times "__final_m_T2 \\(&desc.\[0-9\]+, 0, 0\\);" 1 "original" } } ! { dg-final { cleanup-tree-dump "original" } } diff --git a/gcc/testsuite/gfortran.dg/warn_unused_dummy_argument_4.f90 b/gcc/testsuite/gfortran.dg/warn_unused_dummy_argument_4.f90 new file mode 100644 index 00000000000..79e5fa1bf13 --- /dev/null +++ b/gcc/testsuite/gfortran.dg/warn_unused_dummy_argument_4.f90 @@ -0,0 +1,16 @@ +! { dg-do compile } +! { dg-options "-Wall" } +! +! PR fortran/57469 +! +! Contributed by Vladimir Fuka +! +! Don't warn for unused dummy arguments when they are used in namelists +! + subroutine read_command_line(line,a,b) + character(*),intent(in) :: line + intent(inout) :: a,b + namelist /cmd/ a,b + + read(line,nml = cmd) + end diff --git a/gcc/tree-complex.c b/gcc/tree-complex.c index d43172be3bf..5caba01cde4 100644 --- a/gcc/tree-complex.c +++ b/gcc/tree-complex.c @@ -1472,7 +1472,7 @@ expand_complex_operations_1 (gimple_stmt_iterator *gsi) case EQ_EXPR: case NE_EXPR: /* Note, both GIMPLE_ASSIGN and GIMPLE_COND may have an EQ_EXPR - subocde, so we need to access the operands using gimple_op. */ + subcode, so we need to access the operands using gimple_op. */ inner_type = TREE_TYPE (gimple_op (stmt, 1)); if (TREE_CODE (inner_type) != COMPLEX_TYPE) return; diff --git a/gcc/tree-vrp.c b/gcc/tree-vrp.c index ec7ef8f7548..ca9d8bdb305 100644 --- a/gcc/tree-vrp.c +++ b/gcc/tree-vrp.c @@ -3565,20 +3565,184 @@ extract_range_basic (value_range_t *vr, gimple stmt) bool sop = false; tree type = gimple_expr_type (stmt); - /* If the call is __builtin_constant_p and the argument is a - function parameter resolve it to false. This avoids bogus - array bound warnings. - ??? We could do this as early as inlining is finished. */ - if (gimple_call_builtin_p (stmt, BUILT_IN_CONSTANT_P)) - { - tree arg = gimple_call_arg (stmt, 0); - if (TREE_CODE (arg) == SSA_NAME - && SSA_NAME_IS_DEFAULT_DEF (arg) - && TREE_CODE (SSA_NAME_VAR (arg)) == PARM_DECL) - set_value_range_to_null (vr, type); - } - else if (INTEGRAL_TYPE_P (type) - && gimple_stmt_nonnegative_warnv_p (stmt, &sop)) + if (gimple_call_builtin_p (stmt, BUILT_IN_NORMAL)) + { + tree fndecl = gimple_call_fndecl (stmt), arg; + int mini, maxi, zerov = 0, prec; + + switch (DECL_FUNCTION_CODE (fndecl)) + { + case BUILT_IN_CONSTANT_P: + /* If the call is __builtin_constant_p and the argument is a + function parameter resolve it to false. This avoids bogus + array bound warnings. + ??? We could do this as early as inlining is finished. */ + arg = gimple_call_arg (stmt, 0); + if (TREE_CODE (arg) == SSA_NAME + && SSA_NAME_IS_DEFAULT_DEF (arg) + && TREE_CODE (SSA_NAME_VAR (arg)) == PARM_DECL) + { + set_value_range_to_null (vr, type); + return; + } + break; + /* Both __builtin_ffs* and __builtin_popcount return + [0, prec]. */ + CASE_INT_FN (BUILT_IN_FFS): + CASE_INT_FN (BUILT_IN_POPCOUNT): + arg = gimple_call_arg (stmt, 0); + prec = TYPE_PRECISION (TREE_TYPE (arg)); + mini = 0; + maxi = prec; + if (TREE_CODE (arg) == SSA_NAME) + { + value_range_t *vr0 = get_value_range (arg); + /* If arg is non-zero, then ffs or popcount + are non-zero. */ + if (((vr0->type == VR_RANGE + && integer_nonzerop (vr0->min)) + || (vr0->type == VR_ANTI_RANGE + && integer_zerop (vr0->min))) + && !TREE_OVERFLOW (vr0->min)) + mini = 1; + /* If some high bits are known to be zero, + we can decrease the maximum. */ + if (vr0->type == VR_RANGE + && TREE_CODE (vr0->max) == INTEGER_CST + && !TREE_OVERFLOW (vr0->max)) + maxi = tree_floor_log2 (vr0->max) + 1; + } + goto bitop_builtin; + /* __builtin_parity* returns [0, 1]. */ + CASE_INT_FN (BUILT_IN_PARITY): + mini = 0; + maxi = 1; + goto bitop_builtin; + /* __builtin_c[lt]z* return [0, prec-1], except for + when the argument is 0, but that is undefined behavior. + On many targets where the CLZ RTL or optab value is defined + for 0 the value is prec, so include that in the range + by default. */ + CASE_INT_FN (BUILT_IN_CLZ): + arg = gimple_call_arg (stmt, 0); + prec = TYPE_PRECISION (TREE_TYPE (arg)); + mini = 0; + maxi = prec; + if (optab_handler (clz_optab, TYPE_MODE (TREE_TYPE (arg))) + != CODE_FOR_nothing + && CLZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (TREE_TYPE (arg)), + zerov) + /* Handle only the single common value. */ + && zerov != prec) + /* Magic value to give up, unless vr0 proves + arg is non-zero. */ + mini = -2; + if (TREE_CODE (arg) == SSA_NAME) + { + value_range_t *vr0 = get_value_range (arg); + /* From clz of VR_RANGE minimum we can compute + result maximum. */ + if (vr0->type == VR_RANGE + && TREE_CODE (vr0->min) == INTEGER_CST + && !TREE_OVERFLOW (vr0->min)) + { + maxi = prec - 1 - tree_floor_log2 (vr0->min); + if (maxi != prec) + mini = 0; + } + else if (vr0->type == VR_ANTI_RANGE + && integer_zerop (vr0->min) + && !TREE_OVERFLOW (vr0->min)) + { + maxi = prec - 1; + mini = 0; + } + if (mini == -2) + break; + /* From clz of VR_RANGE maximum we can compute + result minimum. */ + if (vr0->type == VR_RANGE + && TREE_CODE (vr0->max) == INTEGER_CST + && !TREE_OVERFLOW (vr0->max)) + { + mini = prec - 1 - tree_floor_log2 (vr0->max); + if (mini == prec) + break; + } + } + if (mini == -2) + break; + goto bitop_builtin; + /* __builtin_ctz* return [0, prec-1], except for + when the argument is 0, but that is undefined behavior. + If there is a ctz optab for this mode and + CTZ_DEFINED_VALUE_AT_ZERO, include that in the range, + otherwise just assume 0 won't be seen. */ + CASE_INT_FN (BUILT_IN_CTZ): + arg = gimple_call_arg (stmt, 0); + prec = TYPE_PRECISION (TREE_TYPE (arg)); + mini = 0; + maxi = prec - 1; + if (optab_handler (ctz_optab, TYPE_MODE (TREE_TYPE (arg))) + != CODE_FOR_nothing + && CTZ_DEFINED_VALUE_AT_ZERO (TYPE_MODE (TREE_TYPE (arg)), + zerov)) + { + /* Handle only the two common values. */ + if (zerov == -1) + mini = -1; + else if (zerov == prec) + maxi = prec; + else + /* Magic value to give up, unless vr0 proves + arg is non-zero. */ + mini = -2; + } + if (TREE_CODE (arg) == SSA_NAME) + { + value_range_t *vr0 = get_value_range (arg); + /* If arg is non-zero, then use [0, prec - 1]. */ + if (((vr0->type == VR_RANGE + && integer_nonzerop (vr0->min)) + || (vr0->type == VR_ANTI_RANGE + && integer_zerop (vr0->min))) + && !TREE_OVERFLOW (vr0->min)) + { + mini = 0; + maxi = prec - 1; + } + /* If some high bits are known to be zero, + we can decrease the result maximum. */ + if (vr0->type == VR_RANGE + && TREE_CODE (vr0->max) == INTEGER_CST + && !TREE_OVERFLOW (vr0->max)) + { + maxi = tree_floor_log2 (vr0->max); + /* For vr0 [0, 0] give up. */ + if (maxi == -1) + break; + } + } + if (mini == -2) + break; + goto bitop_builtin; + /* __builtin_clrsb* returns [0, prec-1]. */ + CASE_INT_FN (BUILT_IN_CLRSB): + arg = gimple_call_arg (stmt, 0); + prec = TYPE_PRECISION (TREE_TYPE (arg)); + mini = 0; + maxi = prec - 1; + goto bitop_builtin; + bitop_builtin: + set_value_range (vr, VR_RANGE, build_int_cst (type, mini), + build_int_cst (type, maxi), NULL); + return; + default: + break; + } + } + if (INTEGRAL_TYPE_P (type) + && gimple_stmt_nonnegative_warnv_p (stmt, &sop)) set_value_range_to_nonnegative (vr, type, sop || stmt_overflow_infinity (stmt)); else if (vrp_stmt_computes_nonzero (stmt, &sop) diff --git a/gcc/tree.h b/gcc/tree.h index b4445170088..6297b49c399 100644 --- a/gcc/tree.h +++ b/gcc/tree.h @@ -322,7 +322,7 @@ extern const char * built_in_names[(int) END_BUILTINS]; #define CASE_FLT_FN(FN) case FN: case FN##F: case FN##L #define CASE_FLT_FN_REENT(FN) case FN##_R: case FN##F_R: case FN##L_R -#define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL +#define CASE_INT_FN(FN) case FN: case FN##L: case FN##LL: case FN##IMAX /* In an OMP_CLAUSE node. */ diff --git a/gcc/vec.h b/gcc/vec.h index 3c1bb9a3d6b..09a1d0a4d86 100644 --- a/gcc/vec.h +++ b/gcc/vec.h @@ -337,10 +337,22 @@ struct va_gc CXX_MEM_STAT_INFO); template<typename T, typename A> - static void release (vec<T, A, vl_embed> *&v) { v = NULL; } + static void release (vec<T, A, vl_embed> *&v); }; +/* Free GC memory used by V and reset V to NULL. */ + +template<typename T, typename A> +inline void +va_gc::release (vec<T, A, vl_embed> *&v) +{ + if (v) + ::ggc_free (v); + v = NULL; +} + + /* Allocator for GC memory. Ensure there are at least RESERVE free slots in V. If EXACT is true, grow exactly, else grow exponentially. As a special case, if the vector had not been |